Write a program that uses a 20x20 board, initialised to a given pattern, to play the game Conway's life . After each turn print out the board pattern using a . for a dead square and a * for a live square. Squares off the board are considered permanently dead.
To write a program that plays Conway's Game of Life on a 20x20 board, you can follow these steps:
1. Initialize the board: Create a 20x20 grid initialized with the given pattern. You can represent each cell as a boolean value, where "true" represents a live cell and "false" represents a dead cell.
2. Define the rules: Conway's Game of Life has a specific set of rules for cell evolution. Each cell follows these rules to determine whether it lives or dies. The rules are as follows:
- Any live cell with fewer than two live neighbors dies (underpopulation).
- Any live cell with two or three live neighbors survives.
- Any live cell with more than three live neighbors dies (overpopulation).
- Any dead cell with exactly three live neighbors becomes a live cell (reproduction).
3. Implement the game loop: Set up a loop that represents each turn in the game. Inside the loop, apply the rules of the game to update the board pattern for the next turn.
4. Print the board pattern: After each turn, iterate through the board and print the current pattern using '.' for dead cells and '*' for live cells.
Now let's dive into the code implementation using Python:
```python
# Step 1: Initialize the board
board = [[False] * 20 for _ in range(20)] # Create a 20x20 board
# Step 2: Define the rules
def apply_rules(board):
new_board = [[False] * 20 for _ in range(20)] # Create a new board for the next turn
for i in range(20):
for j in range(20):
live_neighbors = count_live_neighbors(board, i, j)
if board[i][j]:
# Any live cell with fewer than two or more than three live neighbors dies
if live_neighbors < 2 or live_neighbors > 3:
new_board[i][j] = False
else:
new_board[i][j] = True
else:
# Any dead cell with exactly three live neighbors becomes a live cell
if live_neighbors == 3:
new_board[i][j] = True
else:
new_board[i][j] = False
return new_board
def count_live_neighbors(board, x, y):
count = 0
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
if dx == 0 and dy == 0:
continue # Skip the current cell
nx, ny = x + dx, y + dy
if 0 <= nx < 20 and 0 <= ny < 20 and board[nx][ny]: # Check boundaries and live neighbors
count += 1
return count
# Step 3: Implement the game loop
num_turns = 10 # Number of turns to play the game
for turn in range(num_turns):
# Step 4: Print the board pattern
print(f"Turn {turn + 1}:\n")
for row in board:
for cell in row:
print('*' if cell else '.', end=' ')
print()
print()
board = apply_rules(board) # Update the board pattern for the next turn
```
The above code uses nested loops to iterate through the board for each turn. It utilizes the `count_live_neighbors()` function to count the number of live neighbors for each cell and applies the rules accordingly to create a new board for the next turn using the `apply_rules()` function. At the end of each turn, the current pattern is printed using '*' for live cells and '.' for dead cells.