Find Winner on a Tic Tac Toe Game - Practice Coding Problems

Find Winner on a Tic Tac Toe Game - Problem

You're given the sequence of moves in a classic Tic-Tac-Toe game and need to determine the current game state!

In this 3×3 grid game:

Player A always goes first and places 'X' marks
Player B goes second and places 'O' marks
Players alternate turns placing their marks in empty squares
The game ends when someone gets three in a row (horizontally, vertically, or diagonally)
If all 9 squares are filled without a winner, it's a draw

Your task: Given an array moves where moves[i] = [row, col] represents the i-th move, return:

"A" if player A wins
"B" if player B wins
"Draw" if the game ended in a tie
"Pending" if the game is still ongoing

Example: moves = [[0,0],[2,0],[1,1],[1,0],[2,2]] results in A winning with a diagonal!

Input & Output

example_1.py — A Wins Diagonally

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

› Output: "A"

💡 Note: A places X at (0,0), (1,1), and (2,2) forming a diagonal. The game ends after A's third move with A as the winner.

example_2.py — Draw Game

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

› Output: "Draw"

💡 Note: All 9 squares are filled but neither player achieved three in a row. The game ends in a draw.

example_3.py — Pending Game

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

› Output: "Pending"

💡 Note: After 6 moves, no player has three in a row and there are still empty squares. The game is still ongoing.

Constraints

1 ≤ moves.length ≤ 9
moves[i].length == 2
0 ≤ moves[i][j] ≤ 2
There are no repeated moves
All moves are valid according to tic-tac-toe rules

Visualization

Tap to expand

Understanding the Visualization

Set Up Scorecard

Create progress counters for both players across all 8 winning lines

Process Each Move

For each move, increment the current player's counters for affected lines

Check for Victory

If any counter reaches 3, declare that player the winner immediately

Determine Final State

If no winner after all moves, check if it's a draw or still pending

Key Takeaway

🎯 Key Insight: Track winning progress, not board state - it's faster and more elegant!

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 22

The optimal approach uses progress tracking instead of board simulation. Track how many marks each player has in each winning line (3 rows, 3 columns, 2 diagonals). When any count reaches 3, that player wins immediately! This eliminates the need to store the actual board and provides O(1) winner detection.

Common Approaches

Approach	Time	Space	Notes
✓ Progress Tracking (Optimal)	O(n)	O(1)	Track progress toward winning in each line without storing the actual board
Brute Force (Board Simulation)	O(n)	O(1)	Build the actual 3×3 board and check all winning conditions after each move

Progress Tracking (Optimal) — Algorithm Steps

Create counters for each player for 3 rows, 3 columns, and 2 diagonals
For each move, increment the appropriate counters for the current player
If any counter reaches 3, that player wins immediately
If all moves are processed without a winner, check if board is full (draw) or pending

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Set up progress arrays for both players

Process Move

Increment relevant counters for current player

Check Victory

See if any counter reached 3

Winner Found

Return winner immediately when detected

Code -

solution.c — C

char* tictactoe(int** moves, int movesSize, int* movesColSize) {
    // Track progress for each player
    int rowsA[3] = {0}, colsA[3] = {0}, rowsB[3] = {0}, colsB[3] = {0};
    int diagA = 0, antiDiagA = 0, diagB = 0, antiDiagB = 0;
    
    static char result[10];
    
    for (int i = 0; i < movesSize; i++) {
        int row = moves[i][0], col = moves[i][1];
        int isA = (i % 2 == 0);
        
        if (isA) {
            rowsA[row]++;
            colsA[col]++;
            if (row == col) diagA++;
            if (row + col == 2) antiDiagA++;
            
            if (rowsA[row] == 3 || colsA[col] == 3 || diagA == 3 || antiDiagA == 3) {
                strcpy(result, "A");
                return result;
            }
        } else {
            rowsB[row]++;
            colsB[col]++;
            if (row == col) diagB++;
            if (row + col == 2) antiDiagB++;
            
            if (rowsB[row] == 3 || colsB[col] == 3 || diagB == 3 || antiDiagB == 3) {
                strcpy(result, "B");
                return result;
            }
        }
    }
    
    strcpy(result, (movesSize == 9) ? "Draw" : "Pending");
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) where n is number of moves. Each move updates counters in O(1) time

✓ Linear Growth

Space Complexity

O(1)

O(1) space for fixed-size counter arrays (8 lines × 2 players)

✓ Linear Space

52.2K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Progress Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler