1. import java.util.Arrays;
  2. 
  3. import javax.xml.stream.events.Characters;
  4. 
  5. public class Board {
  7. private static final int SIZE = 10;
  9. private char[][] board;
  11. public Board(){
  12. board = new char[SIZE][SIZE];
  13. }
  15. /**
  16. * Sets all the cells of the board to c.
  17. * @param c
  18. */
  19. public void setAll(char c){
  20. for (int row = 0; row < SIZE; row++) {
  21. for (int col = 0; col < SIZE; col++) {
  22. board[row][col] = c;
  23. }
  24. }
  25. }
  26. 
  27. /**
  28. * Set every character in the board to one of the chars in w, all chosen at random.
  29. * That is, every character in board is set to one of the letters word.
  30. * We pick the letter randomly, with Math.random()
  31. * @param w the word.
  32. *///lab 1
  33. public void setToWord(String w){
  34. char[] c = w.toCharArray();
  35. for (int row = 0; row < SIZE; row++) {
  36. for (int col = 0; col < SIZE; col++) {
  37. board[row][col] = w.charAt((int)(Math.random() * w.length()));
  38. }
  39. }
  40. }
  41. 
  42. /**
  43. * Fill a rectangle bounded by topRow, bottomRow and topCol,
  44. * bottomCol (inclusive) with fillChar. That is, we set all
  45. * the row,col pair positions that are within the given rectangle to fillChar
  46. * @param firstRow
  47. * @param firstCol
  48. * @param lastRow
  49. * @param lastCol
  50. * @param fillChar
  51. *///lab 2
  52. public void setRectangle(int firstRow, int firstCol, int lastRow, int lastCol, char fillChar){
  53. for (int row = firstRow; row <= lastRow; row++) {
  54. for (int col = firstCol; col <= lastCol; col++) {
  55. board[row][col] = fillChar;
  56. }
  57. }
  58. }
  59. 
  60. /**
  61. * Set row i+1 in board to be identical to row i for all even i.
  62. * That is, row 1 is set to be identical to row 0, row 3 is set
  63. * identical to row , and so on for all the rows in board.
  64. *///lab 3
  65. public void setToRowPairs(){
  66. if (SIZE <= 1) return; //just one row, nothing to do.
  67. for (int row = 1; row < SIZE; row+=2) {
  68. for (int col = 0; col < SIZE; col++) {
  69. board[row][col] = board[row-1][col];
  70. }
  71. }
  72. }
  74. /**
  75. * Set all the characters in board that are digits to c.
  76. * TIP: Character.isDigit() will come in handy.
  77. * @param c the character that will be placed in all the
  78. * selected locations.
  79. *///lab 4
  80. public void setDigitsTo(char c){
  81. if (SIZE <= 1) return; //just one row, nothing to do.
  82. for (int row = 0; row < SIZE; row++) {
  83. for (int col = 0; col < SIZE; col++) {
  84. if (Character.isDigit(board[row][col])){
  85. board[row][col] = c;
  86. }
  87. }
  88. }
  89. }
  92. /**
  93. * Determine if a contains c
  94. * @param a
  95. * @param c
  96. * @return
  97. */
  98. private static boolean contains(char[] a, char c){
  99. for (char i: a){
  100. if (i == c) return true;
  101. }
  102. return false;
  103. }
  105. /**
  106. * Find all the unique characters in the board and return a array
  107. * that contains all these characters. The returned array does not
  108. * contain any repeated character.
  109. * @return an array with all the distinct characters in board.
  110. * It has no repeats.
  111. *///lab 1
  112. public char[] getAllChars(){
  113. //there can be at most SIZE*SIZE unique chars.
  114. char[] allTheChars = new char[SIZE*SIZE];
  115. int nextIndex = 0;
  116. //add all unique chars to allTheChars
  117. for (int row = 0; row < SIZE; row++) {
  118. for (int col = 0; col < SIZE; col++) {
  119. if ( ! contains(allTheChars, board[row][col])){
  120. allTheChars[nextIndex++] = board[row][col];
  121. }
  122. }
  123. }
  124. //now, make a copy of it without all the empty spots
  125. char[] result = Arrays.copyOf(allTheChars, nextIndex);
  126. return result;
  128. //Another way to implement this method is to first Array.sort(board) and then
  129. // do one pass over the sorted array. Which one is faster? (take 146 and find out)
  130. }
  133. /**
  134. * Find the longest sequence of the same char in a (horizontal) row and
  135. * return the char in question. If there is a tie, return a char in a
  136. * sequence of maximal length (For example, if 'aaaa' and 'cccc' are the
  137. * longest, return either 'a' or 'c', it does not matter which).
  138. * Only checks horizontal (in the same row) sequences.
  139. * @return the char in the longest sequence.
  140. *///lab 2
  141. public char getLongestSequenceRow(){
  142. if (SIZE <= 1) return 1;
  143. int maxLength = 0;
  144. char maxChar = ' ';
  145. for (int row = 0; row < SIZE; row++) {
  146. char last = board[row][0];
  147. int length = 1;
  148. for (int col = 0; col < SIZE; col++) {
  149. if (board[row][col] == last){
  150. length++;
  151. if (length > maxLength){
  152. maxLength = length;
  153. maxChar = last;
  154. }
  155. }
  156. else {
  157. length = 1;
  158. }
  159. last = board[row][col];
  160. }
  161. };
  162. return maxChar;
  163. }
  165. /**
  166. * Determine if word appears on the board, written horizontally from
  167. * left to right (that is, like a word in a book).
  168. * TIP: String.toCharArray() might be useful.
  169. * @param word the word we are looking for.
  170. * @return true if word appears written horizontally somewhere in board,
  171. * false otherwise
  172. *///lab 3
  173. public boolean appears(String word){
  174. if (word.length() > SIZE) return false; //too big to fit
  175. char[] w = word.toCharArray();
  176. for (int row = 0; row < SIZE; row++) {
  177. for (int col = 0; col <= SIZE - w.length; col++) {
  178. boolean match = true;
  179. for (int i=0; i < w.length; i++){
  180. if (w[i] != board[row][col+i]){
  181. match = false;
  182. break;
  183. }
  184. }
  185. if (match){
  186. return true;
  187. }
  188. }
  189. }
  190. return false;
  191. }
  193. /**
  194. * Find out if the character c appears stacked in a column that contains
  195. * exactly 3 instances of it. For example, if c is * then, this is a match:
  196. * rtyii
  197. * 8*des
  198. * d*dfq
  199. * i*dkk
  200. * 998dd
  201. *
  202. * but, this is not a match (because it has 4 *s):
  203. * 9*ddk
  204. * d*dkd
  205. * i*dkd
  206. * i*kdk
  207. * djdjd
  208. *
  209. * Returns true is somewhere on the board there are
  210. * exactly 3 c's stacked in a column, but no more.
  211. * @param c
  212. * @return
  213. *///lab 4
  214. public boolean colOfThree(char c){
  215. if (SIZE < 3) return false; //too small
  216. for (int col = 0; col < SIZE; col++) {
  217. for (int row = 0; row <= SIZE-3; row++) {
  218. if ((row == 0 || board[row-1][col] != c) && //we are either at the first row, or the char at row-1 is not c, and
  219. (board[row][col] == c && board[row+1][col] == c && board[row+2][col] == c) && // there are 3 in a col, and
  220. (row + 3 == SIZE || board[row+3][col] != c)){ //we are at the last row or the next char at row+3 is not c
  221. return true;
  222. }
  223. }
  224. }
  225. return false;
  226. }
  228. public String toString(){
  229. String result = "";
  230. for (int row = 0; row < SIZE; row++) {
  231. for (int col = 1; col < SIZE; col++) {
  232. result += board[row][col];
  233. }
  234. result += "\n";
  235. }
  236. return result;
  237. }
  238. 
  239. /** For testing purposes. */
  240. public void set(int row, int col, char c){
  241. board[row][col] = c;
  242. }
  244. 
  245. /**
  246. * @param args
  247. */
  248. public static void main(String[] args) {
  249. //All labs
  250. Board b = new Board();
  251. b.setAll('R');
  252. System.out.println(b);
  254. //lab 1
  255. b.setToWord("Synchronicity");
  256. System.out.println(b);
  258. //lab 2
  259. b.setToWord("thep0l1c3");
  260. System.out.println(b);
  261. b.setDigitsTo('*');
  262. System.out.println(b);
  263. 
  264. //lab 3
  265. b.setRectangle(2,2,4,4,'P');
  266. System.out.println(b);
  268. //lab 4
  269. b.setToRowPairs();
  270. System.out.println(b);
  271. 
  273. //lab 1
  274. char[] unique = b.getAllChars();
  275. System.out.println("unique=" + Arrays.toString(unique));
  277. //lab 2
  278. System.out.println("Longest char=" + b.getLongestSequenceRow());
  279. b.setToWord("Everybreathyoutake");
  280. System.out.println(b);
  281. System.out.println("Longest char=" + b.getLongestSequenceRow());
  283. //lab 3
  284. System.out.println(b);
  285. System.out.println("Does e appear? " + b.appears("e"));
  286. System.out.println("Does ee appear? " + b.appears("ee"));
  287. System.out.println("Does eee appear? " + b.appears("eee"));
  288. System.out.println("Does eeee appear? " + b.appears("eeee"));
  290. //lab 4
  291. System.out.println("");
  292. b.setAll('*');
  293. b.set(1, 3, 'T');
  294. b.set(2, 3, 'T');
  295. b.set(3, 3, 'T');
  296. System.out.println(b);
  297. System.out.println("Col of three T: " + b.colOfThree('T'));
  298. b.set(4, 3, 'T');
  299. System.out.println(b);
  300. System.out.println("Col of three T: " + b.colOfThree('T'));
  301. }
  302. 
  303. }