Design TicTacToe

 This article. is for self practice:

refer: https://leetcode.com/problems/design-tic-tac-toe/solution/

Assume the following rules are for the tic-tac-toe game on an n x n board between two players:

1. A move is guaranteed to be valid and is placed on an empty block.
2. Once a winning condition is reached, no more moves are allowed.
3. A player who succeeds in placing n of their marks in a horizontal, vertical, or diagonal row wins the game.

Implement the TicTacToe class:

• TicTacToe(int n) Initializes the object the size of the board n.
• int move(int row, int col, int player) Indicates that the player with id player plays at the cell (row, col) of the board. The move is guaranteed to be a valid move, and the two players alternate in making moves. Return
  • 0 if there is no winner after the move,
  • 1 if player 1 is the winner after the move, or
  • 2 if player 2 is the winner after the move.

 

Example 1:

Input
["TicTacToe", "move", "move", "move", "move", "move", "move", "move"]
[[3], [0, 0, 1], [0, 2, 2], [2, 2, 1], [1, 1, 2], [2, 0, 1], [1, 0, 2], [2, 1, 1]]
Output
[null, 0, 0, 0, 0, 0, 0, 1]

Explanation
TicTacToe ticTacToe = new TicTacToe(3);
Assume that player 1 is "X" and player 2 is "O" in the board.
ticTacToe.move(0, 0, 1); // return 0 (no one wins)
|X| | |
| | | |    // Player 1 makes a move at (0, 0).
| | | |

ticTacToe.move(0, 2, 2); // return 0 (no one wins)
|X| |O|
| | | |    // Player 2 makes a move at (0, 2).
| | | |

ticTacToe.move(2, 2, 1); // return 0 (no one wins)
|X| |O|
| | | |    // Player 1 makes a move at (2, 2).
| | |X|

ticTacToe.move(1, 1, 2); // return 0 (no one wins)
|X| |O|
| |O| |    // Player 2 makes a move at (1, 1).
| | |X|

ticTacToe.move(2, 0, 1); // return 0 (no one wins)
|X| |O|
| |O| |    // Player 1 makes a move at (2, 0).
|X| |X|

ticTacToe.move(1, 0, 2); // return 0 (no one wins)
|X| |O|
|O|O| |    // Player 2 makes a move at (1, 0).
|X| |X|

ticTacToe.move(2, 1, 1); // return 1 (player 1 wins)
|X| |O|
|O|O| |    // Player 1 makes a move at (2, 1).
|X|X|X|

 

Constraints:

• 2 <= n <= 100
• player is 1 or 2.
• 0 <= row, col < n
• (row, col) are unique for each different call to move.
• At most n2 calls will be made to move.

The algorithm can be implemented as follows:

1. For a given n, initialize arrays rows and cols of size n with the value of every element set to 0.

2. For each move, we must increment/decrement the row, column, diagonal, and anti-diagonal according to who is the current player and which cell was marked. If the current player is player 1, we increment the value and if it is player 2, we decrement the value.

   Note: If we apply simple math rules, we can increment or decrement the values irrespective of the player.

   We can use an additional variable currentPlayer with the value 1 for player 1 and -1 for player 2, and add the value of currentPlayer to the current row, column, diagonal and anti-diagonal.

3. As a final step, we must determine whether the current player has won the game. If any row, column, diagonal, or anti-diagonal is equal to n (for player 1) or -n (for player 2) then the current player has won the game.

   Also, rather than having separate conditions to check whose turn it is, we can check the absolute values.

package practice;

public class TictacToe {


    int[] row;
    int[] col;
    int diagonal;
    int antidiagonal;


    public TictacToe(int n) {
        row = new int[n];
        col = new int[n];
    }

    public int move(int r, int c, int player) {
        //player1 score=1; player2 score=-1
        int currentPlayerScore = player == 1 ? 1 : -1;
        row[r] = row[r] + currentPlayerScore;
        col[c] = col[c] + currentPlayerScore;

        //diagonal score
        if (r == c) {
            diagonal = diagonal + currentPlayerScore;
        }

        //antiDiagonal

        if (c == row.length - r - 1) {
            antidiagonal = antidiagonal + currentPlayerScore;
        }
        if (Math.abs(row[r]) == row.length || Math.abs(col[c]) == row.length || (r == c && Math.abs(diagonal) == row.length) || (c == row.length - r - 1 && (Math.abs(antidiagonal) == row.length))) {

            return player;
        }
        return 0;
    }

    public static void main(String [] arg){
        TictacToe ticTacToe= new TictacToe(3)     ;
        System.out.println(ticTacToe.move(0, 0, 1));
        System.out.println(ticTacToe.move(0, 2, 2));
        System.out.println(ticTacToe.move(2, 2, 1));
        System.out.println(ticTacToe.move(1, 1, 2));
        System.out.println(ticTacToe.move(2, 0, 1));
        System.out.println(ticTacToe.move(1, 0, 2));
        System.out.println(ticTacToe.move(2, 1, 1));

    }
}

/**
 * Your TicTacToe object will be instantiated and called as such:
 * TicTacToe obj = new TicTacToe(n);
 * int param_1 = obj.move(row,col,player);
 */