Valid Tic-Tac-Toe State - Practice Coding Problems

Valid Tic-Tac-Toe State - Problem

Array Matrix Medium

Imagine you're a referee for a tic-tac-toe tournament, and you need to determine if a given board state is legally reachable during a valid game.

You're given a 3×3 tic-tac-toe board as a string array, where each cell contains either:

'X' - First player's move
'O' - Second player's move
' ' - Empty square

Game Rules:

Player X always goes first
Players alternate turns (X, then O, then X, etc.)
Players can only place marks in empty squares
Game ends when someone gets 3 in a row (horizontally, vertically, or diagonally)
Game also ends when the board is full
No moves can be made after the game ends

Your task is to return true if this board state could have been reached during a valid game, or false if it's impossible.

Example: If X has already won but there are more O's placed after that winning move, the state is invalid!

Input & Output

example_1.py — Valid Mid-Game State

$ Input: ["O ", " ", " "]

› Output: false

💡 Note: Invalid because O went first, but X should always go first in tic-tac-toe.

example_2.py — Valid Win State

$ Input: ["XOX", " X ", " "]

› Output: false

💡 Note: Invalid because both players seem to have continued playing after X won the middle column.

example_3.py — Valid Empty Start

$ Input: ["XXX", " ", "OOO"]

› Output: false

💡 Note: Invalid because both X and O have winning rows, which is impossible in a real game.

Visualization

Tap to expand

Understanding the Visualization

Count the Pieces

Count X's and O's to ensure X went first and players alternated properly

Find the Winners

Check all rows, columns, and diagonals for three-in-a-row

Validate End Conditions

Ensure the game stopped immediately when someone won

Key Takeaway

🎯 Key Insight: A tic-tac-toe state is valid only if it follows proper turn order AND the game stopped immediately when someone won. The moment a player gets three-in-a-row, no more moves can be made!

Time & Space Complexity

Time Complexity

⏱️

O(1)

We check a fixed 3x3 board, so it's constant time despite nested loops

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to count pieces and track winners

✓ Linear Space

Constraints

board.length == 3
board[i].length == 3
board[i][j] is either 'X', 'O', or ' '

Asked in

⊞ Microsoft 35 a Amazon 28 G Google 22 f Meta 18

The optimal approach validates a tic-tac-toe board by checking four key rules: proper turn alternation (X goes first), no simultaneous winners, game ends immediately when someone wins, and correct piece counts. The key insight is that the game must stop the moment someone achieves three-in-a-row - any additional moves after that make the state invalid.

Common Approaches

Approach	Time	Space	Notes
✓ Rule Validation Approach	O(1)	O(1)	Check all game rules systematically one by one

Rule Validation Approach — Algorithm Steps

Count total X's and O's on the board
Validate turn order: X goes first, so count(X) should be count(O) or count(O) + 1
Check if X has won (3 in any row, column, or diagonal)
Check if O has won
Validate win conditions: both players can't win, game must end when someone wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Pieces

Count X's and O's to verify turn order

Check Winners

Identify if either player has won

Validate End State

Ensure game stopped when someone won

Code -

solution.c — C

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

bool hasWinner(char board[3][4], char player) {
    // Check rows
    for (int i = 0; i < 3; i++) {
        if (board[i][0] == player && board[i][1] == player && board[i][2] == player) {
            return true;
        }
    }
    
    // Check columns
    for (int j = 0; j < 3; j++) {
        if (board[0][j] == player && board[1][j] == player && board[2][j] == player) {
            return true;
        }
    }
    
    // Check diagonals
    if (board[0][0] == player && board[1][1] == player && board[2][2] == player) {
        return true;
    }
    if (board[0][2] == player && board[1][1] == player && board[2][0] == player) {
        return true;
    }
    
    return false;
}

bool validTicTacToe(char board[3][4]) {
    int xCount = 0, oCount = 0;
    
    // Count X's and O's
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (board[i][j] == 'X') xCount++;
            else if (board[i][j] == 'O') oCount++;
        }
    }
    
    // Rule 1: Valid turn counts
    if (!(xCount == oCount || xCount == oCount + 1)) {
        return false;
    }
    
    bool xWins = hasWinner(board, 'X');
    bool oWins = hasWinner(board, 'O');
    
    // Rule 2: Both can't win
    if (xWins && oWins) return false;
    
    // Rule 3: If X wins, X should have one more piece
    if (xWins && xCount != oCount + 1) return false;
    
    // Rule 4: If O wins, counts should be equal
    if (oWins && xCount != oCount) return false;
    
    return true;
}

int main() {
    char board[3][4];
    char input[100];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing
    sscanf(input, "[\"%3s\",\"%3s\",\"%3s\"]", board[0], board[1], board[2]);
    
    printf("%s\n", validTicTacToe(board) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

We check a fixed 3x3 board, so it's constant time despite nested loops

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to count pieces and track winners

✓ Linear Space

Constraints

board.length == 3
board[i].length == 3
board[i][j] is either 'X', 'O', or ' '

27.6K Views

Medium Frequency

~18 min Avg. Time

894 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

Rule Validation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler