Design Tic-Tac-Toe

class TicTacToe {
public:
    vector<int> rowSums;
    vector<int> colSums;
    int mainDiagonal;
    int secondaryDiagonal;

    TicTacToe(int size) {
        rowSums.assign(size, 0);
        colSums.assign(size, 0);
        mainDiagonal = 0;
        secondaryDiagonal = 0;
    }

    int makeMove(int row, int col, int player) {
        int value = (player == 1) ? 1 : -1;
        // update player score tracking
        rowSums[row] += value;
        colSums[col] += value;
        // diagonal adjustments
        if (row == col) {
            mainDiagonal += value;
        }
        if (col == (colSums.size() - row - 1)) {
            secondaryDiagonal += value;
        }
        int dimension = rowSums.size();
        // determines if player wins
        if (abs(rowSums[row]) == dimension ||
            abs(colSums[col]) == dimension ||
            abs(mainDiagonal) == dimension ||
            abs(secondaryDiagonal) == dimension) {
            return player;
        }
        return 0; // continue game
    }
};

Implement a Tic-Tac-Toe game using C++ where the functionality is encapsulated within a class named TicTacToe. The core elements of the class include:

• Member Variables:

  • rowSums: Tracks sum of values in each row. Winning condition checks involve examining the absolute values of these sums.
  • colSums: Similar to rowSums, but for columns.
  • mainDiagonal: Sum of the main diagonal entries.
  • secondaryDiagonal: Sum of the secondary diagonal entries.

• Constructor - TicTacToe(int size):

  • Initializes vectors rowSums and colSums with zeros based on the size of the Tic-Tac-Toe board provided.
  • Sets mainDiagonal and secondaryDiagonal to 0.

• Method - int makeMove(int row, int col, int player):

  • Accepts the position (row, col) for the move and the player making the move (1 or 2).
  • Converts player parameter to 1 for Player 1 and -1 for Player 2 - assists in simplifying win condition tracking by summing these integers.
  • Updates the respective row and column sums along with the diagonals, if applicable (checks if move is on either diagonal).
  • After updating, checks each, i.e., row, column, and diagonals, to determine if the move made resulted in a win condition, i.e., the absolute value of the sum equals the size of the board (indicating all cells in that line are occupied by the same player).
  • Returns the player number if there's a winning sequence or 0 if the game is to continue.

Developing the game using this approach minimizes the time complexity of determining wins to constant time, making this implementation efficient, especially for a larger board size. Each makeMove operation resolves in constant time, enhancing the performance compared to checking the entire board linearly after every move.

public class Game {
    int[] rowTrack;
    int[] colTrack;
    int diagonalSum;
    int antiDiagonalSum;

    public Game(int size) {
        rowTrack = new int[size];
        colTrack = new int[size];
    }

    public int makeMove(int row, int col, int player) {
        int mark = (player == 1) ? 1 : -1;
        rowTrack[row] += mark;
        colTrack[col] += mark;

        if (row == col) {
            diagonalSum += mark;
        }
        if (col == (colTrack.length - row - 1)) {
            antiDiagonalSum += mark;
        }
        
        int n = rowTrack.length;
        if (Math.abs(rowTrack[row]) == n ||
            Math.abs(colTrack[col]) == n ||
            Math.abs(diagonalSum) == n ||
            Math.abs(antiDiagonalSum) == n) {
            return player;
        }
        return 0;
    }
}

The provided Java code implements a basic version of Tic-Tac-Toe game logic for an n x n board. Here's a succinct summary of how it operates:

• Initialization:

  • The Game class is initialized with two arrays, rowTrack and colTrack, to keep track of the sum of marks along each row and column, respectively.
  • Two additional integer variables, diagonalSum and antiDiagonalSum, are used to track the sum of the main diagonal and the anti-diagonal.

• Making a Move:

  • The makeMove method takes three parameters: row, col, and player. The player parameter identifies which player is making the move, using 1 for player 1 and -1 for player 2.
  • When a move is made at a certain cell, the corresponding row and column trackers are updated by the player's mark value (either 1 or -1).
  • Checks are made to see if placing a mark updates the diagonals—if the current move impacts either diagonal, the respective sum is updated accordingly.

• Determining a Winner:

  • After every move, the method checks if the absolute value of the sums in rowTrack for the current row, colTrack for the current column, diagonalSum, or antiDiagonalSum equals the board size n.
  • If any of these conditions hold, the current player is declared the winner as this means a whole row, column, or diagonal has been filled with their marks.

• Return Value:

  • The makeMove method returns the player number if there is a winner in the current move, otherwise, it returns 0, indicating that the game continues.

This implementation effectively handles each move's impacts on the game state, providing a straightforward method to not only track plays but also quickly determine the win status without needing to scan the entire board after each move. The utilization of sums to represent rows, columns, and diagonals simplifies the verification process for a winning condition, allowing for an efficient gameplay experience.