CS 1713, Assignment 9, The Game of Life — Spring 1998 Page 1 of 2
CS 1713, Introduction to Computer Science
Assignment 9, Spring 1998
The Game of Life, Due April 16, 1998
Life. For this assignment you are to write a C program that will simulate the game of “Life.” Life takes
place on an infinite 2-dimensional rectangular grid of cells. Initially (the 0th generation, or at time
)
some finite collection of these cells are “live”— the rest are “dead.” At each successive generation, cells
may remain live or dead, or may switch states according to fixed rules. Thus the course of the game depends
on the initial configuration and on the fixed set of rules. What happens to a cell depends on its state (live or
dead) and on the states of its 8 neighbors (cells touching the given cell on an edge or a corner).
Here are the rules:
BIRTH: A cell that’s dead at time
becomes live at time
if exactly three of its eight neighbors were
live at time
.
DEATH by overcrowding: A cell that’s live at time
and has four or more of its eight neighbors live at
time
will be dead at time
.
DEATH by exposure: A live cell that has only one live neighbor or none at all at time
will also be dead
at time
.
In summary, a live cell stays live if it has exactly 2 or 3 live neighbors—otherwise it dies. A dead cell
becomes a live one if it has exactly 3 live neighbors—otherwise it stays dead. These simple rules lead to an
astonishing complexity.
A Finite Grid. For this course it is too hard to think about an “infinite” grid of cells, so your simulation
should work on a fixed rectangular
grid of cells—with
rows and
columns. Since we want
you to display your results on an ordinary terminal screen, you should choose
and
,i.e., a
rectangular grid. I suggest you use an array of char, using a blank for dead and a star (*) for live.
Notice that cells on the boundaries of the grid do not have a full eight neighbors, and your count of dead
and live cells must stay inside the grid. (You must not have a row or column index outside the ranges from
0 to
and from 0 to
.)
The Initial Program. Your program should use two
arrays, for the
th and
st generations.
These arrays should be passed as parameters. You must use a separate C function neighbors with the row
and column number as parameters that returns the number of live neighbors of a given cell. (The function
neighbors must also handle the boundary correctly.) You must also have a function next gen with the
two arrays as parameters that updates from one generation to the next (using the neighbors function).
Another function get config should read a finite list of pairs of integers for the initial configuration.
There will be a number of sample initial files to choose from. Finally, you need a function disp array to
output each new generation to the screen. The simplest way is just to write 24 lines of 80 characters each.
Here is a sample outline for this program:
#include <stdio.h>
#include <stdlib.h>
#define M 24
#define N 80
#define MAX_GEN 40
void get_config(char b[M][N]);
void blank_array(char b[M][N]);
void disp_array(char b[M][N]);
void next_gen(char b1[M][N], char b2[M][N]);
void assign(char b1[M][N], char b2[M][N]);
int neighbors(char b[M][N], int i, int j);
void main(void)
{
char b1[M][N], b2[M][N];
get_config(b1);
