Conway’s Game of Life

Conway’s Game of Life, cellular automaton operates on a two-dimensional grid of cells, where each cell can be in one of two states:

Alive (1)
Dead (0)

Rules

1. A live cell with fewer than 2 live neighbors dies (underpopulation).
2. A live cell with 2 or 3 live neighbors stays alive (survival).
3. A live cell with more than 3 live neighbors dies (overpopulation).
4. A dead cell with exactly 3 live neighbors becomes alive (reproduction).

The grid should be updated only after evaluating the whole grid first.

Example Code

const rows = 3;
const cols = 3;

const grid = [
    [0, 1, 0],
    [0, 1, 0],
    [0, 1, 0]
];

const nextGrid = Array.from({ length: rows }, () => Array(cols).fill(0));

for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
        const neighbors = countNeighbors(grid, i, j, rows, cols);
        console.log("count neighbor is", neighbors);

const cell = grid[i][j];

if (cell === 1) {
            if (neighbors < 2) {
                // die
                nextGrid[i][j] = 0;
            } else if (neighbors === 2 || neighbors === 3) {
                // live
                nextGrid[i][j] = 1;
            } else if (neighbors > 3) {
                // die
                nextGrid[i][j] = 0;
            }
        } else {
            if (neighbors === 3) {
                nextGrid[i][j] = 1;
            }
        }
    }
}

console.log("grid is", grid);
console.log("nextGrid is", nextGrid);

function countNeighbors(grid, row, col, rows, cols) {
    const rowAbove = row - 1;
    const rowBelow = row + 1;
    const colLeft = col - 1;
    const colRight = col + 1;

const neighbors = [
        [rowAbove, colLeft],
        [rowAbove, col],
        [rowAbove, colRight],
        [row, colLeft],
        [row, colRight],
        [rowBelow, colLeft],
        [rowBelow, col],
        [rowBelow, colRight]
    ];

let count = 0;

for (let neighbor of neighbors) {
        const [r, c] = neighbor;

if (r >= 0 && r <= rows - 1 && c >= 0 && c <= cols - 1) {
            if (grid[r][c]) count++;
        }
    }
    return count;
}

Output Result

grid is [ [ 0, 1, 0 ], [ 0, 1, 0 ], [ 0, 1, 0 ] ]
nextGrid is [ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 0, 0, 0 ] ]