Game of Life - Practice Coding Problems

Game of Life - Problem

Conway's Game of Life is a fascinating cellular automaton that simulates the evolution of life on a grid! 🧬

You're given an m × n grid where each cell is either alive (represented by 1) or dead (represented by 0). Each cell interacts with its eight neighbors (horizontally, vertically, and diagonally adjacent cells) according to these four simple rules:

🔹 Under-population: Any live cell with fewer than 2 live neighbors dies
🔹 Survival: Any live cell with 2 or 3 live neighbors survives to the next generation
🔹 Over-population: Any live cell with more than 3 live neighbors dies
🔹 Reproduction: Any dead cell with exactly 3 live neighbors becomes alive

Important: All changes happen simultaneously - you must calculate the next state based on the current state, not on partially updated cells. Your task is to update the board in-place to reflect the next generation.

Input & Output

example_1.py — Basic Evolution

$ Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]

› Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]

💡 Note: The center forms a 'blinker' pattern that oscillates. Cell (1,1) dies from under-population (only 1 neighbor), while cells with exactly 3 neighbors come to life through reproduction.

example_2.py — Still Life

$ Input: board = [[1,1],[1,1]]

› Output: [[1,1],[1,1]]

💡 Note: This is a 'block' - a still life pattern. Each cell has exactly 2 or 3 live neighbors, so all cells survive to the next generation unchanged.

example_3.py — Edge Case

$ Input: board = [[1]]

› Output: [[0]]

💡 Note: A single live cell has 0 neighbors, so it dies from under-population. Edge case showing how isolated cells cannot survive.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 25
board[i][j] is 0 or 1
Follow-up: Can you solve it in-place with O(1) extra memory?

Visualization

Tap to expand

Understanding the Visualization

Survey the Population

Count how many living neighbors each cell has in all 8 directions

Apply Natural Laws

Determine fate based on Game of Life rules: loneliness, survival, overcrowding, or reproduction

Simultaneous Evolution

All changes happen at once - like a synchronized biological process

Next Generation

The board now represents the evolved state of the cellular automaton

Key Takeaway

🎯 Key Insight: The magic happens when we realize we can encode both current and future states in the same memory location using bit manipulation, achieving true in-place evolution!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses clever bit manipulation to achieve true in-place processing with O(1) space complexity. By encoding both current and next states in the same integer using different bits, we eliminate the need for extra memory while maintaining the simultaneous evolution requirement of Conway's Game of Life.

Common Approaches

Approach	Time	Space	Notes
✓ In-Place with State Encoding (Optimal)	O(m×n)	O(1)	Use additional bits to encode both current and next states in the same cell

In-Place with State Encoding (Optimal) — Algorithm Steps

For each cell, count live neighbors using only the first bit (original state)
Apply Game of Life rules to determine next state
Store next state in the second bit of the same cell
After processing all cells, shift all values right to get the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Neighbors

Count live neighbors using first bit only

Encode Next State

Store next state in second bit while preserving first bit

Apply to All Cells

Process all cells with encoded states

Extract Result

Right shift to get final next generation

Code -

solution.c — C

void gameOfLife(int** board, int boardSize, int* boardColSize){
    if (boardSize == 0 || boardColSize[0] == 0) return;
    
    int m = boardSize, n = boardColSize[0];
    int directions[8][2] = {{-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,1}, {1,-1}, {1,0}, {1,1}};
    
    // First pass: calculate next state and store in second bit
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int liveNeighbors = 0;
            
            // Count live neighbors using first bit
            for (int k = 0; k < 8; k++) {
                int ni = i + directions[k][0];
                int nj = j + directions[k][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n) {
                    liveNeighbors += board[ni][nj] & 1;
                }
            }
            
            // Apply Game of Life rules
            int currentState = board[i][j] & 1;
            if (currentState == 1) {  // Currently alive
                if (liveNeighbors == 2 || liveNeighbors == 3) {
                    board[i][j] |= 2;  // Set second bit to 1 (stays alive)
                }
            } else {  // Currently dead
                if (liveNeighbors == 3) {
                    board[i][j] |= 2;  // Set second bit to 1 (becomes alive)
                }
            }
        }
    }
    
    // Second pass: shift right to get final result
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            board[i][j] >>= 1;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell once and check its 8 neighbors (constant time per cell)

✓ Linear Growth

Space Complexity

O(1)

We use the input board itself to store both current and next states using bit manipulation

✓ Linear Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

In-Place with State Encoding (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler