Design Tic-Tac-Toe

Design Tic-Tac-Toe - Problem

Design a Tic-Tac-Toe game that is played between two players on an n × n board. You may assume the following rules:

A move is guaranteed to be valid and is placed on an empty block.
Once a winning condition is reached, no more moves are allowed.
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 with 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.

Input & Output

Example 1 — Player 1 Wins on 3x3 Board

$ Input: n = 3, moves: [[0,0,1], [0,2,2], [2,2,1], [1,1,2], [2,0,1], [1,0,2], [1,2,1]]

› Output: [null,0,0,0,0,0,0,1]

💡 Note: Player 1 places marks at (0,0), (2,2), (2,0), (1,2). The last move (1,2) completes the anti-diagonal [0,0]→[1,1]→[2,2], so Player 1 wins.

Example 2 — Row Win on 2x2 Board

$ Input: n = 2, moves: [[0,0,1], [1,1,2], [0,1,1]]

› Output: [null,0,0,1]

💡 Note: Player 1 fills the entire top row: (0,0) and (0,1). Two marks in a row on a 2x2 board means Player 1 wins.

Example 3 — Column Win

$ Input: n = 3, moves: [[0,0,1], [1,1,2], [1,0,1], [2,2,2], [2,0,1]]

› Output: [null,0,0,0,0,1]

💡 Note: Player 1 places marks at (0,0), (1,0), (2,0) - filling the entire first column and winning.

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 n² calls will be made to move

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 32 Apple 28

The optimal approach uses counter arrays to track row, column, and diagonal sums in O(1) time per move. Player 1 adds +1, Player 2 adds -1. When any counter reaches ±n, that player wins. Time: O(1), Space: O(n).

Common Approaches

✓ Brute Force - Check Entire Board

⏱️ Time: O(n) Space: O(n²)

Maintain a 2D array representing the board. After each move, iterate through all rows, columns, and diagonals to check if any player has achieved n consecutive marks.

Optimized - Track Row/Column Sums

⏱️ Time: O(1) Space: O(n)

Instead of checking the entire board, maintain counters for each row, column, and diagonal. Player 1 adds +1, Player 2 adds -1. A sum of ±n means that player wins.

Brute Force - Check Entire Board — Algorithm Steps

Step 1: Store the board as 2D array with player IDs
Step 2: After each move, check the entire row, column, and both diagonals
Step 3: Return winner if found, otherwise return 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Place Mark

Player places mark on board

Check Lines

Scan entire row, column, and diagonals

Result

Return winner or continue game

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int n;
    int** board;
} TicTacToe;

TicTacToe* ticTacToeCreate(int n) {
    TicTacToe* obj = (TicTacToe*)malloc(sizeof(TicTacToe));
    obj->n = n;
    obj->board = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        obj->board[i] = (int*)calloc(n, sizeof(int));
    }
    return obj;
}

int ticTacToeMove(TicTacToe* obj, int row, int col, int player) {
    obj->board[row][col] = player;
    
    // Check row
    int rowWin = 1;
    for (int c = 0; c < obj->n; c++) {
        if (obj->board[row][c] != player) {
            rowWin = 0;
            break;
        }
    }
    if (rowWin) return player;
    
    // Check column
    int colWin = 1;
    for (int r = 0; r < obj->n; r++) {
        if (obj->board[r][col] != player) {
            colWin = 0;
            break;
        }
    }
    if (colWin) return player;
    
    // Check main diagonal
    if (row == col) {
        int diagWin = 1;
        for (int i = 0; i < obj->n; i++) {
            if (obj->board[i][i] != player) {
                diagWin = 0;
                break;
            }
        }
        if (diagWin) return player;
    }
    
    // Check anti-diagonal
    if (row + col == obj->n - 1) {
        int antiDiagWin = 1;
        for (int i = 0; i < obj->n; i++) {
            if (obj->board[i][obj->n-1-i] != player) {
                antiDiagWin = 0;
                break;
            }
        }
        if (antiDiagWin) return player;
    }
    
    return 0;
}

int main() {
    printf("[null,0,0,0,1]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each move requires checking one row + one column + two diagonals = 4n operations

✓ Linear Growth

Space Complexity

O(n²)

Need to store the entire n×n board

⚠ Quadratic Space

125.0K Views

Medium Frequency

~25 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Entire Board — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler