refactor 348

fishercoder1534 · fishercoder1534 · commit 69ffc4fda405 · 2019-01-19T07:24:29.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_348.java b/src/main/java/com/fishercoder/solutions/_348.java
@@ -62,76 +62,70 @@ Could you trade extra space such that move() operation can be done in O(1)?
 
  */
 public class _348 {
-    /**
-     * credit: https://discuss.leetcode.com/topic/44548/java-o-1-solution-easy-to-understand
-     *
-     * Key: in order to win a TicTacToe, you must have the entire row or column,
-     * thus, we don't need to keep track of the entire n^2 board.
-     * We only need to keep a count for each row and column.
-     * If at any time, a row or column matches the size of the board, then that player has won.*/
-    public static class TicTacToe {
-
-        private int diagonal;
+    public static class Solution1 {
         /**
-         * This is diagonal:
-         * |X| | |
-         * | |X| |
-         * | | |X|
-         * So, its condition is always like this: if (row == col)
-         */
-
-        private int antidiagonal;
-        /**
-         * This is antidiagonal:
-         * | | |X|
-         * | |X| |
-         * |X| | |
-         * So, its condition is always like this: if (col == size - row - 1)
-         */
-        private int[] rows;
-        private int[] cols;
-
-        /**
-         * Initialize your data structure here.
-         */
-        public TicTacToe(int n) {
-            rows = new int[n];
-            cols = new int[n];
-        }
-
-        /**
-         * Player {player} makes a move at ({row}, {col}).
+         * credit: https://discuss.leetcode.com/topic/44548/java-o-1-solution-easy-to-understand
          *
-         * @param row    The row of the board.
-         * @param col    The column of the board.
-         * @param player The player, can be either 1 or 2.
-         * @return The current winning condition, can be either:
-         * 0: No one wins.
-         * 1: Player 1 wins.
-         * 2: Player 2 wins.
+         * Key: in order to win a TicTacToe, you must have the entire row or column, thus, we don't need
+         * to keep track of the entire n^2 board. We only need to keep a count for each row and column.
+         * If at any time, a row or column matches the size of the board, then that player has won.
          */
-        public int move(int row, int col, int player) {
-            int toAdd = player == 1 ? 1 : -1;
-
-            rows[row] += toAdd;
-            cols[col] += toAdd;
-            int size = rows.length;
-
-            if (row == col) {
-                diagonal += toAdd;
-            }
-            if (col == (size - row - 1)) {
-                antidiagonal += toAdd;
+        public static class TicTacToe {
+
+            private int diagonal;
+            /**
+             * This is diagonal: |X| | | | |X| | | | |X| So, its condition is always like this: if (row ==
+             * col)
+             */
+
+            private int antidiagonal;
+            /**
+             * This is antidiagonal: | | |X| | |X| | |X| | | So, its condition is always like this: if
+             * (col == size - row - 1)
+             */
+            private int[] rows;
+            private int[] cols;
+
+            /**
+             * Initialize your data structure here.
+             */
+            public TicTacToe(int n) {
+                rows = new int[n];
+                cols = new int[n];
             }
 
-            if (Math.abs(rows[row]) == size
+            /**
+             * Player {player} makes a move at ({row}, {col}).
+             *
+             * @param row The row of the board.
+             * @param col The column of the board.
+             * @param player The player, can be either 1 or 2.
+             * @return The current winning condition, can be either: 0: No one wins. 1: Player 1 wins. 2:
+             * Player 2 wins.
+             */
+            public int move(int row, int col, int player) {
+                int toAdd = player == 1 ? 1 : -1;
+
+                rows[row] += toAdd;
+                cols[col] += toAdd;
+                int size = rows.length;
+
+                if (row == col) {
+                    diagonal += toAdd;
+                }
+                if (col == (size - row - 1)) {
+                    antidiagonal += toAdd;
+                }
+
+                if (Math.abs(rows[row]) == size
                     || Math.abs(cols[col]) == size
                     || Math.abs(antidiagonal) == size
                     || Math.abs(diagonal) == size) {
-                return player;
-            }
+                    return player;
+                }
 
-            return 0;
+                return 0;
+            }
         }
     }
 }
diff --git a/src/test/java/com/fishercoder/_348Test.java b/src/test/java/com/fishercoder/_348Test.java
@@ -5,38 +5,35 @@
 
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 5/13/17.
- */
 public class _348Test {
-    @Test
-    public void test1() {
-        int n = 3;
-        _348.TicTacToe ticTacToe = new _348.TicTacToe(n);
-        assertEquals(0, ticTacToe.move(0, 0, 1));
-        assertEquals(0, ticTacToe.move(0, 2, 2));
-        assertEquals(0, ticTacToe.move(2, 2, 1));
-        assertEquals(0, ticTacToe.move(1, 1, 2));
-        assertEquals(0, ticTacToe.move(2, 0, 1));
-        assertEquals(0, ticTacToe.move(1, 0, 2));
-        assertEquals(1, ticTacToe.move(2, 1, 1));
-    }
+  @Test
+  public void test1() {
+    int n = 3;
+    _348.Solution1.TicTacToe ticTacToe = new _348.Solution1.TicTacToe(n);
+    assertEquals(0, ticTacToe.move(0, 0, 1));
+    assertEquals(0, ticTacToe.move(0, 2, 2));
+    assertEquals(0, ticTacToe.move(2, 2, 1));
+    assertEquals(0, ticTacToe.move(1, 1, 2));
+    assertEquals(0, ticTacToe.move(2, 0, 1));
+    assertEquals(0, ticTacToe.move(1, 0, 2));
+    assertEquals(1, ticTacToe.move(2, 1, 1));
+  }
 
-    @Test
-    public void test2() {
-        int n = 3;
-        _348.TicTacToe ticTacToe = new _348.TicTacToe(n);
-        assertEquals(0, ticTacToe.move(0, 0, 1));
-        assertEquals(0, ticTacToe.move(1, 1, 1));
-        assertEquals(1, ticTacToe.move(2, 2, 1));
-    }
+  @Test
+  public void test2() {
+    int n = 3;
+    _348.Solution1.TicTacToe ticTacToe = new _348.Solution1.TicTacToe(n);
+    assertEquals(0, ticTacToe.move(0, 0, 1));
+    assertEquals(0, ticTacToe.move(1, 1, 1));
+    assertEquals(1, ticTacToe.move(2, 2, 1));
+  }
 
-    @Test
-    public void test3() {
-        int n = 3;
-        _348.TicTacToe ticTacToe = new _348.TicTacToe(n);
-        assertEquals(0, ticTacToe.move(0, 2, 2));
-        assertEquals(0, ticTacToe.move(1, 1, 2));
-        assertEquals(2, ticTacToe.move(2, 0, 2));
-    }
+  @Test
+  public void test3() {
+    int n = 3;
+    _348.Solution1.TicTacToe ticTacToe = new _348.Solution1.TicTacToe(n);
+    assertEquals(0, ticTacToe.move(0, 2, 2));
+    assertEquals(0, ticTacToe.move(1, 1, 2));
+    assertEquals(2, ticTacToe.move(2, 0, 2));
+  }
 }
