Validity of a given Tic-Tac-Toe board configuration

Tic-Tac-Toe, a traditional game enjoyed by millions throughout the world, is not only a source of enjoyment but also a source of academic inquiry. Because of the game's simplicity, it's an excellent instance for researching board layouts and their validity. In this post, we will look at a valid Tic-Tac-Toe board configuration and how to tell if a particular board follows the game's rules.

Valid vs. Invalid Board Configurations

A valid Tic-Tac-Toe board layout follows the game's specified rules. It is critical to examine the following major elements when determining the authenticity of a particular board:

Number of Xs and Os: The number of Xs and Os in an acceptable configuration should be nearly equal, with X generally making the initial move. If one of the players wins the game, they usually get one more move, which is absolutely fine.

Unoccupied Cells: A valid configuration must not have any cells with two marks, i.e., an X and an O in the same cell. Without exception, all markers on the board should be singles.

Winning Condition: A valid configuration must correspond to the Tic-Tac-Toe winning condition. If a player has already won, the board should show a legitimate winning pattern, such as a row, column, or diagonal, and the game should end there.

Game Progression: The sequence of moves should adhere to the game's turn-based structure. For example, X cannot make two consecutive movements unless O takes a turn in between.

Game completion: If the board is full and no one has won, the game should end in a draw. There should be no more possible movements, and neither player should have established a winning pattern.

Validity of a given Tic-Tac-Toe board configuration

Algorithm

1. Starting the Game:

Make a three-by-three gaming board.
Initiate the current player (usually 'X' or 'O').

2. Show the Board:

Show the first empty game board.

3. Gameplay Loop:

To handle player turns and game progress, use a loop.

Look for a winning condition:

Determine if the current player has created a winning pattern (row, column, or diagonal).
Display the victory message and finish the game if a win condition is satisfied.

Check for a draw:

If no win condition is satisfied and all cells on the board are filled, show a draw message and finish the game.

Request a move from the present player:

Show the current player's sign (an 'X' or a 'O').
Request that the player input their move (often by specifying row and column).

Verify the move:

Check that the entered row and column are in the correct range (1-3).
If the selected cell is not empty, request a fresh move.
With the player's move, update the game board.
For the following turn, switch to the next player.

4. The game is over:

If the game loop stops, it's because of a win, a tie, or a player's decision to depart.
Display the game outcome (win, tie, or departure).

Rules

Objective: Tic-Tac-Toe's goal is for the first player to build a row, column, or diagonal of three of your symbols (either X or O) on a 3x3 grid or board.

Equipment: To play Tic-Tac-Toe, you'll need a 3x3 grid, generally created on paper or a gaming board, and two players, one with the X sign and the other with the O symbol.

Gameplay:

Starting Player: X is the typical starter. Players take turns inserting their emblem on an empty grid cell.

Turn-based: Players take turns and make one move per turn. The initial move is made by X, followed by O, and so on.

Winning Condition: The first person to produce a horizontal, vertical, or diagonal line of three of their symbols wins the game. When a winning pattern is achieved, the game is over.

Draw (Tie): The game is called a draw (tie) if all of the cells on the grid are filled, and no player has established a winning pattern. The game is over, and no one has won.

Illegal movements: Players are not permitted to place their symbol in a cell that is already held by the symbol of their opponent, nor can they make two consecutive movements.

Patterns of Success:

Horizontal: Three of the same sign on the same horizontal line in a row.

Vertical: Three identical symbols in a row on the same vertical line.

Diagonal: Three of the same symbol diagonally from the top-left corner to the bottom-right corner or top-right corner to the bottom-left corner.

The game is over:

When one player achieves a winning pattern, or when all cells on the grid are filled, the game ends in a tie.

Validity Evaluation

To determine the legitimacy of a specific Tic-Tac-Toe board arrangement, do the following steps:

Count how many Xs and Os are on the board. They should be nearly equal, with X getting one extra move if X wins.
Check the board for instances of duplicate marking in the same cell. If any are discovered, the board is deemed invalid.
Examine the board for a valid winning pattern. If such a pattern occurs, the game should be stopped there.
Ensure that the move sequence corresponds to the game's turn-based structure. The setup is incorrect if a player makes two consecutive movements without waiting for their opponent's turn.
When the board is full, and no player has a winning pattern, the game should end in a draw. If there are any possible movements on the board, the arrangement is invalid.

Implementation

#include <stdio.h>
// Function to display the Tic-Tac-Toe board
void display_board(char board[3][3]) {
    printf("\n");
    for (int i = 0; i < 3; i++) {
        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
        if (i < 2) {
            printf("---|---|---\n");
        }
    }
    printf("\n");
}
// Function to check for a win
int check_win(char board[3][3], char player) {
    for (int i = 0; i < 3; i++) {
        if (board[i][0] == player && board[i][1] == player && board[i][2] == player) {
            return 1;  // Horizontal win
        }
        if (board[0][i] == player && board[1][i] == player && board[2][i] == player) {
            return 1;  // Vertical win
        }
    }
    if (board[0][0] == player && board[1][1] == player && board[2][2] == player) {
        return 1;  // Diagonal win (top-left to bottom-right)
    }
    if (board[0][2] == player && board[1][1] == player && board[2][0] == player) {
        return 1;  // Diagonal win (top-right to bottom-left)
    }
    return 0;  // No win
}
// Function to check for a draw
int check_draw(char board[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (board[i][j] == ' ') {
                return 0;  // There are still empty spaces
            }
        }
    }
    return 1;  // All spaces are filled (draw)
}
int main() {
    char board[3][3] = { {' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '} };
    char current_player = 'X';
    int row, col;
    printf("Welcome to Tic-Tac-Toe!\n");
    while (1) {
        display_board(board);
        printf("Player %c's turn.\n", current_player);
        while (1) {
            printf("Enter your move (row and column, e.g., 1 2): ");
            if (scanf("%d %d", &row, &col) == 2) {
                if (row >= 1 && row <= 3 && col >= 1 && col <= 3 && board[row - 1][col - 1] == ' ') {
                    break;
                }
            }
            while (getchar() != '\n');  // Clear input buffer
            printf("Invalid move. Please try again.\n");
        }
        board[row - 1][col - 1] = current_player;
        if (check_win(board, current_player)) {
            display_board(board);
            printf("Player %c wins!\n", current_player);
            break;
        } else if (check_draw(board)) {
            display_board(board);
            printf("It's a draw!\n");
            break;
        }
        current_player = (current_player == 'X') ? 'O' : 'X';
    }
    return 0;
}

Output:

Welcome to Tic-Tac-Toe!
    |   |   
---|---|---
    |   |   
---|---|---
   |   |   
Player X's turn.
Enter your move (row and column, e.g., 1 2): 1 1
 X |   |   
---|---|---
   |   |   
---|---|---
   |   |   
Player O's turn.
Enter your move (row and column, e.g., 1 2): 2 2
 X |   |   
---|---|---
   | O |   
---|---|---
   |   |  
Player X's turn.
Enter your move (row and column, e.g., 1 2): 1 2
 X | X |   
---|---|---
   | O |   
---|---|---
   |   |   
Player O's turn.
Enter your move (row and column, e.g., 1 2): 2 1
 X | X |   
---|---|---
 O | O |   
---|---|---
   |   |   
Player X's turn.
Enter your move (row and column, e.g., 1 2): 3 3
 X | X |   X
--|---|---
 O | O |   
---|---|---
   |   | 
Player X wins!

Next TopicWeighted Prefix Search

← prev next →