Design Tic-Tac-Toe - Practice Coding Problems

Design Tic-Tac-Toe - Problem

You're building an intelligent Tic-Tac-Toe game that can handle boards of any size! 🎯

Your task is to design a TicTacToe class that can efficiently determine winners on an n × n board. The game follows these rules:

📍 Players alternate turns placing their marks (Player 1 and Player 2)
🎯 A player wins by getting n marks in a row - horizontally, vertically, or diagonally
✅ All moves are guaranteed to be valid (no need to check bounds or occupied cells)
🏁 Once someone wins, no more moves are allowed

Your Challenge: Implement the class efficiently! The naive approach of checking the entire board after each move would be O(n²) - but can you do better? 🚀

Class Interface:

TicTacToe(int n)     // Initialize n×n board
int move(row, col, player)  // Make move, return winner (0=none, 1=player1, 2=player2)

Input & Output

example_1.py — Basic 3×3 Game

$ Input: TicTacToe(3) move(0, 0, 1) → 0 move(0, 2, 2) → 0 move(2, 2, 1) → 0 move(1, 1, 2) → 0 move(2, 0, 1) → 0 move(1, 0, 2) → 2

› Output: Player 2 wins on the last move

💡 Note: Player 2 gets three in the first column: (0,2)→X, (1,0)→X, (1,1)→X, forming a winning line vertically in column 0.

example_2.py — Diagonal Win

$ Input: TicTacToe(3) move(0, 0, 1) → 0 move(0, 1, 2) → 0 move(1, 1, 1) → 0 move(0, 2, 2) → 0 move(2, 2, 1) → 1

› Output: Player 1 wins with main diagonal

💡 Note: Player 1 achieves victory by occupying the main diagonal: positions (0,0), (1,1), and (2,2).

example_3.py — Larger Board

$ Input: TicTacToe(4) move(0, 0, 1) → 0 move(1, 1, 2) → 0 move(0, 1, 1) → 0 move(1, 2, 2) → 0 move(0, 2, 1) → 0 move(1, 3, 2) → 0 move(0, 3, 1) → 1

› Output: Player 1 wins entire top row

💡 Note: On a 4×4 board, Player 1 fills the entire first row with 4 consecutive marks to win.

Visualization

Tap to expand

Understanding the Visualization

Traditional Approach

After each move, scan entire board checking every possible winning line

Smart Realization

We only need to track progress toward victory, not the full board state

Counter Magic

Each counter represents progress: +1 for Player 1, -1 for Player 2

Instant Victory

When any counter hits ±n, we have an immediate winner!

Key Takeaway

🎯 Key Insight: Instead of asking 'What's on the board?', ask 'How close is each player to winning?' - this transforms an O(n) problem into O(1) magic!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each move only updates constant number of counters and checks for winners instantly

✓ Linear Growth

Space Complexity

O(n)

We store 2n+2 counters (n rows + n columns + 2 diagonals)

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 100
player is either 1 or 2
0 ≤ row, col < n
(row, col) are valid coordinates of an empty cell
At most n² calls will be made to move

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 35 f Meta 28

The optimal approach uses smart counters instead of storing the full board. By maintaining separate counters for each row, column, and diagonal, we can detect winners in O(1) time per move with only O(n) space. The key insight: use +1 for Player 1 and -1 for Player 2, so reaching ±n means victory!

Common Approaches

Approach	Time	Space	Notes
✓ Smart Counters (Optimal)	O(1)	O(n)	Track running counts for each row, column, and diagonal - O(1) winner detection!
Brute Force (Check Entire Board)	O(n)	O(n²)	After each move, scan entire board to check for winning conditions

Smart Counters (Optimal) — Algorithm Steps

Initialize counters for each row, column, and both diagonals
Use positive values for player 1, negative for player 2
When a move is made, increment/decrement the relevant counters
Check if any counter equals +n (player 1 wins) or -n (player 2 wins)
Return the winner immediately, or 0 if no winner yet

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Create counters for rows, columns, and diagonals

Update Counters

Each move increments relevant counters (+1 for P1, -1 for P2)

Check Thresholds

If any counter reaches ±n, declare winner instantly

O(1) Detection

No board scanning needed - pure counter mathematics!

Code -

solution.c — C

typedef struct {
    int* rows;
    int* cols;
    int diag;
    int antiDiag;
    int n;
} TicTacToe;

TicTacToe* ticTacToeCreate(int n) {
    TicTacToe* obj = (TicTacToe*)malloc(sizeof(TicTacToe));
    obj->n = n;
    obj->rows = (int*)calloc(n, sizeof(int));
    obj->cols = (int*)calloc(n, sizeof(int));
    obj->diag = 0;
    obj->antiDiag = 0;
    return obj;
}

int ticTacToeMove(TicTacToe* obj, int row, int col, int player) {
    int value = (player == 1) ? 1 : -1;
    
    // Update counters
    obj->rows[row] += value;
    obj->cols[col] += value;
    
    // Update diagonals if applicable
    if (row == col) {
        obj->diag += value;
    }
    if (row + col == obj->n - 1) {
        obj->antiDiag += value;
    }
    
    // Check for winner
    int target = (player == 1) ? obj->n : -(obj->n);
    
    if (obj->rows[row] == target ||
        obj->cols[col] == target ||
        obj->diag == target ||
        obj->antiDiag == target) {
        return player;
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each move only updates constant number of counters and checks for winners instantly

✓ Linear Growth

Space Complexity

O(n)

We store 2n+2 counters (n rows + n columns + 2 diagonals)

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 100
player is either 1 or 2
0 ≤ row, col < n
(row, col) are valid coordinates of an empty cell
At most n² calls will be made to move

67.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Smart Counters (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler