Tic-Tac-Toe Game Implementation

Introduction

Tic-Tac-Toe is a two-player game played on a 3x3 grid. Players take turns marking a square with either 'X' or 'O'. The first player to align three marks horizontally, vertically, or diagonally wins the game.

Game Representation

1️⃣ Visual Representation of the Board

  1 | 2 | 3 
 ---+---+---
  4 | 5 | 6 
 ---+---+---
  7 | 8 | 9 

Each number represents a position where a player can place their mark.

Step-by-Step Implementation

2️⃣ Step 1: Create the Board

• Use a list of 9 elements to represent the board.
• Initially, all positions are empty (' ').

3️⃣ Step 2: Player Moves

• Players 'X' and 'O' take turns.
• Validate the input to ensure a position is not already occupied.

4️⃣ Step 3: Check for a Win

• A player wins if any of the following conditions are met:
• Horizontal Win → board[0] == board[1] == board[2] != ' ' (same for rows 2 and 3)
• Vertical Win → board[0] == board[3] == board[6] != ' ' (same for columns 2 and 3)
• Diagonal Win → board[0] == board[4] == board[8] != ' ' or board[2] == board[4] == board[6] != ' '.

5️⃣ Step 4: Check for a Draw

• If all positions are filled and no player has won, the game is a draw.

6️⃣ Step 5: Loop Until Game Ends

• Players keep taking turns until there is a winner or a draw.

Code Implementation

class TicTacToe:
    """Tic-Tac-Toe Game Implementation"""

    def __init__(self):
        self.board = [' '] * 9  # 3x3 Board
        self.current_player = 'X'

    def display_board(self):
        """Displays the current board state"""
        print("\n")
        for i in range(0, 9, 3):
            print(f" {self.board[i]} | {self.board[i+1]} | {self.board[i+2]} ")
            if i < 6:
                print("---+---+---")
        print("\n")

    def make_move(self, position):
        """Places the player's mark at the given position"""
        if self.board[position] == ' ':
            self.board[position] = self.current_player
            return True
        return False  # Invalid move (position occupied)

    def check_winner(self):
        """Checks if there is a winner"""
        winning_positions = [
            [0, 1, 2], [3, 4, 5], [6, 7, 8],  # Rows
            [0, 3, 6], [1, 4, 7], [2, 5, 8],  # Columns
            [0, 4, 8], [2, 4, 6]              # Diagonals
        ]
        for line in winning_positions:
            if self.board[line[0]] == self.board[line[1]] == self.board[line[2]] != ' ':
                return True
        return False

    def check_draw(self):
        """Checks if the game is a draw"""
        return ' ' not in self.board

    def switch_player(self):
        """Switches the turn between 'X' and 'O'"""
        self.current_player = 'O' if self.current_player == 'X' else 'X'

    def play(self):
        """Runs the game loop until a win or draw occurs"""
        while True:
            self.display_board()
            try:
                position = int(input(f"Player {self.current_player}, enter position (1-9): ")) - 1
                if position not in range(9) or not self.make_move(position):
                    print("Invalid move. Try again.")
                    continue
            except ValueError:
                print("Please enter a valid number.")
                continue

            if self.check_winner():
                self.display_board()
                print(f"Player {self.current_player} wins!")
                break

            if self.check_draw():
                self.display_board()
                print("It's a draw!")
                break

            self.switch_player()

# Run the game
if __name__ == "__main__":
    game = TicTacToe()
    game.play()

Time Complexity Analysis

Key Takeaways

✅ Simple Grid-Based Logic: Uses a list to represent the board.
✅ Turn-Based System: Players switch after each valid move.
✅ Optimized Win Check: Uses predefined winning positions to speed up checks.
✅ Interactive Play: Uses input handling for a real-game experience.

Conclusion

Tic-Tac-Toe is an excellent beginner project to practice data structures, loops, and conditionals in Python. This implementation is optimized for efficiency and can be further expanded with AI-based move prediction. 🚀