Valid Tic-Tac-Toe State

Valid Tic-Tac-Toe State - Problem

Array Matrix Medium

Given a Tic-Tac-Toe board as a string array board, return true if and only if it is possible to reach this board position during the course of a valid tic-tac-toe game.

The board is a 3 x 3 array that consists of characters ' ', 'X', and 'O'. The ' ' character represents an empty square.

Rules of Tic-Tac-Toe:

Players take turns placing characters into empty squares ' '
The first player always places 'X' characters, while the second player always places 'O' characters
'X' and 'O' characters are always placed into empty squares, never filled ones
The game ends when there are three of the same (non-empty) character filling any row, column, or diagonal
The game also ends if all squares are non-empty
No more moves can be played if the game is over

Input & Output

Example 1 — Valid Game State

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

› Output: false

💡 Note: O went first, but X should always go first. This violates the turn order rule.

Example 2 — Valid Game State

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

› Output: false

💡 Note: X has 3 moves and O has 1 move. Since X goes first, this means O should have made 2 moves. Invalid turn count.

Example 3 — Valid End State

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

› Output: false

💡 Note: Both X and O have winning lines, which is impossible in a valid game. Only one player can win.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 A Apple 8

The key insight is that X always goes first in tic-tac-toe, so valid states must follow strict turn ordering and winning rules. Best approach validates all rules systematically: count pieces, check turn order, detect winners, and ensure game stops after victory. Time: O(1), Space: O(1)

Common Approaches

✓ Rule-by-Rule Validation

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

Systematically verify all game rules: count moves, check turn order, validate win conditions, and ensure game didn't continue after a win. This approach checks each rule separately for clarity.

Single-Pass Validation

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

Combine counting and win detection in one traversal. Check rules as we go and exit early when possible. More efficient than the brute force approach.

Rule-by-Rule Validation — Algorithm Steps

Count X and O pieces on the board
Verify turn order (X goes first)
Check for winning lines
Ensure game stopped after win

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Pieces

Count X and O pieces on board

Check Turn Order

Verify X goes first (X count = O count or O+1)

Check Wins

Look for winning lines in rows, columns, diagonals

Validate State

Ensure game rules are followed

Code -

solution.c — C

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

bool hasWinner(char board[3][4], char player) {
    // Check rows
    for (int i = 0; i < 3; i++) {
        bool rowWin = true;
        for (int j = 0; j < 3; j++) {
            if (board[i][j] != player) {
                rowWin = false;
                break;
            }
        }
        if (rowWin) return true;
    }
    
    // Check columns
    for (int col = 0; col < 3; col++) {
        bool colWin = true;
        for (int row = 0; row < 3; row++) {
            if (board[row][col] != player) {
                colWin = false;
                break;
            }
        }
        if (colWin) 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 solution(char board[3][4]) {
    int xCount = 0, oCount = 0;
    
    // Count pieces
    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++;
        }
    }
    
    bool xWins = hasWinner(board, 'X');
    bool oWins = hasWinner(board, 'O');
    
    // Rule validation
    if (!(xCount == oCount || xCount == oCount + 1)) return false;
    if (xWins && oWins) return false;
    if (xWins && xCount != oCount + 1) return false;
    if (oWins && xCount != oCount) return false;
    
    return true;
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    char board[3][4];
    // Parse the JSON-like input ["XOX", "O X", "XOX"]
    char *start = strchr(line, '[');
    char *token = strtok(start + 1, ",");
    
    for (int i = 0; i < 3; i++) {
        // Remove quotes and whitespace
        while (*token == ' ' || *token == '"') token++;
        char *end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"' || *end == ']')) end--;
        *(end + 1) = '\0';
        
        strcpy(board[i], token);
        board[i][3] = '\0';
        
        if (i < 2) token = strtok(NULL, ",");
    }
    
    printf(solution(board) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 3x3 board size, constant number of operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Rule-by-Rule Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler