game-of-life-step

<tmp>/workspace
data/grid.csv
data/config.json
main.py
task.toml
environment/README.md
instruction.md

fatal: not a git repository (or any of the parent directories): .git

# Starter stub for the toroidal Game-of-Life task.
#
# It reads the starting board from data/grid.csv and the run settings from
# data/config.json, then (for now) just copies the board straight through
# to output/next.csv WITHOUT advancing any generations. Replace the body so
# it actually evolves the board the requested number of steps under the rules
# described in the task.

import csv
import json
import os

with open("data/grid.csv") as f:
    grid = [[int(x) for x in row] for row in csv.reader(f) if row]

with open("data/config.json") as f:
    config = json.load(f)

generations = int(config["generations"])  # number of steps to advance
topology = config["topology"]

# TODO: replace this passthrough with the evolved board. As written it ignores
# the rules and the generation count, so it does not produce the requested board.
next_grid = grid

os.makedirs("output", exist_ok=True)
with open("output/next.csv", "w", newline="") as f:
    csv.writer(f).writerows(next_grid)

{"topology": "toroidal", "generations": 3}

1,1,0,0,0,0,0,1
0,0,0,0,1,1,0,1
0,2,0,0,1,0,0,0
0,0,0,0,0,0,2,0
1,0,0,0,0,0,0,0
1,0,1,1,0,0,0,1

I have a Game-of-Life board waiting at data/grid.csv and I'd like you to evolve it forward a few generations on a wrap-around world. This is not the plain textbook version, so please read the rules below carefully before you start.

The board file has no header row. Each line is one row of the board, and within a line the cells are comma-separated integers. A cell holds one of three values: 0 means an empty (dead) cell, 1 means a living cell, and 2 means a permanent wall. Every row has the same number of columns, so the board is a rectangle. Walls are fixed obstacles built into the world: a wall is never alive and never becomes alive, it always stays a wall, and crucially it is never counted as a living neighbour when you tally up the cells around some other position. Think of a wall as a hole in the board that simply contributes nothing to anyone's neighbour count and carries its value 2 through unchanged to every later generation.

Alongside the board there is a small settings file at data/config.json. It has two fields. One is topology, which for this task is always the string toroidal and tells you the board wraps around. The other is generations, a positive integer giving exactly how many steps forward you should advance the board. So if generations is three, you apply the update rule three times in sequence, each new board computed from the one before it.

The wrap-around part is the important twist. The world is a torus: the left edge is glued to the right edge and the top edge is glued to the bottom edge. So a cell sitting in the leftmost column still has neighbours to its left, namely the cells in the rightmost column of the same rows, and likewise a cell in the top row has neighbours above it that come from the bottom row. The four corners wrap diagonally as well. The upshot is that every non-wall cell has exactly eight neighbour positions, found by stepping one cell in each of the eight directions and wrapping any index that runs off an edge back around t
… (+1640 chars truncated)

# Starter stub for the toroidal Game-of-Life task.
#
# It reads the starting board from data/grid.csv and the run settings from
# data/config.json, then (for now) just copies the board straight through
# to output/next.csv WITHOUT advancing any generations. Replace the body so
# it actually evolves the board the requested number of steps under the rules
# described in the task.

import csv
import json
import os

with open("data/grid.csv") as f:
    grid = [[int(x) for x in row] for row in csv.reader(f) if row]

with open("data/config.json") as f:
    config = json.load(f)

generations = int(config["generations"])  # number of steps to advance
topology = config["topology"]

if topology != "toroidal":
    raise ValueError(f"unsupported topology: {topology!r}")

rows = len(grid)
cols = len(grid[0]) if rows else 0


def living_neighbours(board, row, col):
    count = 0
    for row_delta in (-1, 0, 1):
        for col_delta in (-1, 0, 1):
            if row_delta == 0 and col_delta == 0:
                continue

            neighbour_row = (row + row_delta) % rows
            neighbour_col = (col + col_delta) % cols
            if board[neighbour_row][neighbour_col] == 1:
                count += 1

    return count


next_grid = grid
for _ in range(generations):
    current = next_grid
    updated = []

    for row_index, row in enumerate(current):
        updated_row = []
        for col_index, cell in enumerate(row):
            if cell == 2:
                updated_row.append(2)
                continue

            neighbours = living_neighbours(current, row_index, col_index)
            if cell == 1:
                updated_row.append(1 if neighbours in (2, 3) else 0)
            else:
                updated_row.append(1 if neighbours == 3 else 0)

        updated.append(updated_row)

    next_grid = updated

os.makedirs("output", exist_ok=True)
with open("output/next.csv", "w", newline="") as f:
    csv.writer(f).writerows(next_grid)

0,1,1,1,0,1,0,0
0,1,1,0,0,0,0,0
0,2,0,0,0,0,0,0
1,1,0,0,0,0,2,0
1,1,0,0,0,0,0,0
1,0,1,0,0,0,0,0

input shape: 6 x 8
output shape: 6 x 8
valid values: [0, 1, 2]
walls preserved: True

0,1,1,1,0,1,0,0
0,1,1,0,0,0,0,0
0,2,0,0,0,0,0,0
1,1,0,0,0,0,2,0
1,1,0,0,0,0,0,0
1,0,1,0,0,0,0,0

True
True
True