How to Implement the Min-Max Algorithm in Python

Brandon Kindred
3 min readJust now

--

Photo by Solstice Hannan on Unsplash

Hey there, fellow coder! Ready to dive into a fun and classic problem? Today, we’re going to learn how to implement the min-max algorithm in Python to make our own unbeatable Tic-Tac-Toe AI! This blog post is beginner-friendly, so don’t worry if you’re new to coding. We’ll walk through everything step-by-step, and by the end, you’ll have a Python script that can outplay anyone at Tic-Tac-Toe.

What Is the Min-Max Algorithm?

The min-max algorithm is a decision-making algorithm used in game theory. It’s perfect for two-player, turn-based games like Tic-Tac-Toe, Chess, or Connect 4. Here’s how it works:

- Min represents the opponent trying to minimize the score.
- Max represents the player (or AI) trying to maximize the score.

The algorithm simulates every possible move in the game, evaluates them, and chooses the move with the best possible outcome.

Setting Up Tic-Tac-Toe

Let’s start with some basic code to set up the game board and check for a winner. We’ll use a 3x3 grid represented by a list of lists in Python.

# Initialize the game board
board = [[' ' for _ in range(3)] for _ in range(3)]

def print_board(board):
for row in board:
print("|".join(row))
print("-" * 5)

def check_winner(board):
# Check rows, columns, and diagonals for a win
for row in board:
if row[0] == row[1] == row[2] and row[0] != ' ':
return row[0]

for col in range(3):
if board[0][col] == board[1][col] == board[2][col] and board[0][col] != ' ':
return board[0][col]

if board[0][0] == board[1][1] == board[2][2] and board[0][0] != ' ':
return board[0][0]

if board[0][2] == board[1][1] == board[2][0] and board[0][2] != ' ':
return board[0][2]

return None

def is_board_full(board):
return all(cell != ' ' for row in board for cell in row)

Implementing the Min-Max Algorithm

Now let’s implement the min-max algorithm. We’ll write a function that evaluates the board and chooses the best move for the AI.

def minmax(board, is_maximizing):
winner = check_winner(board)
if winner == 'X':
return 1
elif winner == 'O':
return -1
elif is_board_full(board):
return 0

if is_maximizing:
best_score = -float('inf')
for i in range(3):
for j in range(3):
if board[i][j] == ' ':
board[i][j] = 'X' # AI's move
score = minmax(board, False)
board[i][j] = ' '
best_score = max(score, best_score)
return best_score
else:
best_score = float('inf')
for i in range(3):
for j in range(3):
if board[i][j] == ' ':
board[i][j] = 'O' # Opponent's move
score = minmax(board, True)
board[i][j] = ' '
best_score = min(score, best_score)
return best_score

Making the AI’s Move

With the minmax function ready we can now create a function for the AI to pick its move based on the highest score calculated by minmax

def ai_move(board):
best_score = -float('inf')
best_move = None

for i in range(3):
for j in range(3):
if board[i][j] == ' ':
board[i][j] = 'X' # AI's move
score = minmax(board, False)
board[i][j] = ' '

if score > best_score:
best_score = score
best_move = (i, j)

if best_move:
board[best_move[0]][best_move[1]] = 'X'

Putting It All Together

Now we’ll add the logic for a human player to take their turn, and we’ll tie everything together in a loop that runs until the game ends.

def player_move(board):
while True:
try:
row = int(input("Enter row (1, 2, or 3): ")) - 1
col = int(input("Enter column (1, 2, or 3): ")) - 1
if board[row][col] == ' ':
board[row][col] = 'O'
break
else:
print("Spot already taken, try again!")
except (ValueError, IndexError):
print("Invalid input. Please enter numbers between 1 and 3.")

def play_game():
print("Welcome to Tic-Tac-Toe!")
print_board(board)

while True:
player_move(board)
print_board(board)

if check_winner(board):
print("You win!")
break
if is_board_full(board):
print("It's a draw!")
break

print("AI's turn...")
ai_move(board)
print_board(board)

if check_winner(board):
print("AI wins!")
break
if is_board_full(board):
print("It's a draw!")
break

play_game()

Give It a Go!

There you have it — your very own unbeatable Tic-Tac-Toe AI using the min-max algorithm!

Feel free to customize the code, try playing against it, or even adapt it for other games. Understanding the min-max algorithm is a great introduction to AI programming, and you’ll be well on your way to creating more complex game AIs in no time.

Happy coding, and may the best player (probably the AI) win!

--

--

Brandon Kindred

Entrepreneur & computer science nerd that is passionate about AI, robotics, & startup life. Currently focused on improving UX processes at https://Look-see.com