Question

Project 4

simulation with conway's rules for life - revisited

due before 4/30 11:59pm, autograded by project 4 zylab, limited to 10 submissions.

We will be using the concepts from project 2 to test the more recent concepts of linked lists, pointers, and file I/O. The initial data points will be stored in a file (specification of the layout of the file below), each grid of values will be dynamically allocated and then referenced via a pointer in a linked list.

More details are:

input file

first line will list the number of time steps to simulate

second line will include number of rows followed by the number of columns in the grid to be simulated

remaining lines in the file will have the positions of the initial cells that are "alive"

dynamically create nodes that use the following struct

struct node {
        int rows;
        int columns;
        int * grid; // a pointer to the grid that should be of size rows*columns
        struct node *next_step; // a pointer to the node that holds the grid for the next time step
        };

you will create a linked list of nodes where each node is a single time step

the begin pointer should point to the initial grid, and each time step should follow.

no array notation is to be used, so no []'s should appear in your code.

You MUST create the following functions

struct node *createInitialNode(FILE *input, int *numsteps); // read data from file pointer input and return a dynamically created node with the data and the number of time steps to simulate in numsteps

void nextStep(struct node *begin); // add a struct node to the end of the list pointed to by begin for the next time step, so use data in the last node in the list to create the new timestep. 

void printList(struct node *begin); // print out all the grids contained in the list pointed to by begin.

You should use your code from project 2. If you had issues with the functions from project 2, you should see the professor or a TA ASAP!!!!!!

The autograder will test the three functions above (as well as the functionality of your new array creation) and produce a score of 65 points. The remaining 35 points will be for style per @7

Notes:

by using the linked list there is no limit to the number of time steps to simulate, recall project 2 had a max number of time steps.

by using dynamically allocated memory there is no limit to the grid size, recall project 2 had a max grid size.

when grading the style points, if any []'s are seen in the code, a 0 will be given for the autograded test cases.

Example input file sampleinput.txt

contains:

3
10 12
7 7
7 8
7 9
8 7
9 8

Answer 1

#include <stdio.h>
#include <stdlib.h>

struct node
{
int rows;
int columns;
int *grid;
struct node *next_step;
};

struct node *createInitialNode(FILE *input,int *numsteps);

void nextStep(struct node *begin);

void printList(struct node *begin);

int neighbors(struct node *nodeptr,int i,int j);

void printGrid(int *anArray,int rows,int columns);

int main(void)
{
char inputname[30];
printf("Welcome to Conway's game of Life\nPlease enter filename\n");
scanf ("%[^\n]%*c", inputname); //Reading filename
FILE *fin;
fin=fopen(inputname,"r"); //Opening file
int numsteps;
struct node *head=createInitialNode(fin,&numsteps); //Creating head node
// loop to get the array state after steps time steps
for(int step=1; step<=numsteps; step++) //Creating linked list of nodes for each time step
nextStep(head);
// display the grid after steps number of time steps
printList(head); //Printing the grids in the linked list
return EXIT_SUCCESS;
}

// function to return the number of live neighboring cells for a cell at (i,j) at time step

struct node* createInitialNode(FILE *input,int *numsteps)
{
fscanf(input,"%d",numsteps); //Extracting the number of time steps
int rows,columns,x,y;
fscanf(input,"%d %d",&rows,&columns); //Extracting the number of rows and columns
struct node *head=(struct node *)malloc(sizeof(struct node)); //Dynamically creating a new node
  
//Initializing the new node
head->grid=(int*)malloc(columns*rows*sizeof(int)); //Dynamically creating a new grid
head->columns=columns;
head->rows=rows;
head->next_step=NULL;
  
//Filling all grid values to 0
for(int i=0; i<rows; i++)
{
for(int j=0; j<columns; j++)
*(head->grid+columns*i+j)=0;
}
  
//Extracting the positions of live cells and marking it in the grid
while(fscanf(input,"%d %d",&x,&y)==2)
*(head->grid+columns*x+y)=1;
return head;
}

void nextStep(struct node *begin)
{
struct node *next,*prev=begin;
next=(struct node *)malloc(sizeof(struct node)); //Creating new node
int col=begin->columns;
  
//Initializing the new node
next->columns=begin->columns;
next->rows=begin->rows;
next->next_step=NULL;
next->grid=(int*)malloc(next->columns*next->rows*sizeof(int)); //Creating the grid
  
//Traversing to the end of linked list
while(prev->next_step!=NULL)
prev=prev->next_step;
  
prev->next_step=next; //Linking the new node to the end of linked list
int liveNeighbors;
int r,c;
//Calculating the next state
for(r=0; r<begin->rows; r++)
{
for(c=0; c<begin->columns; c++)
{
liveNeighbors = neighbors(prev,r,c);
if( *(prev->grid+col*r+c) == 1)
{
if(liveNeighbors < 2 || liveNeighbors > 3)
*(next->grid+col*r+c)=0;
else
*(next->grid+col*r+c)=1;
}
else
{
if(liveNeighbors == 3)
*(next->grid+col*r+c)=1;
else
*(next->grid+col*r+c)=0;
}
}
}
return ;
}

void printList(struct node *begin)
{
//Traversing through the linked list
while(begin!=NULL)
{
printGrid(begin->grid,begin->rows,begin->columns);
begin=begin->next_step;
printf("\n");
}
return;
}

int neighbors(struct node *nodeptr,int i,int j)
{
int liveNeighbors=0;
int r=nodeptr->rows,c=nodeptr->columns;
int *anArray=nodeptr->grid;
if((i-1)>=0)
{
if((j-1) >=0)
{
if(*(anArray+c*(i-1)+j-1) == 1)
liveNeighbors++;
}
if(*(anArray+c*(i-1)+j) == 1)
liveNeighbors++;
if((j+1)<(c))
{
if(*(anArray+c*(i-1)+j+1) == 1)
liveNeighbors++;
}
}
if((j-1) >=0)
{
if(*(anArray+c*i+j-1) == 1)
liveNeighbors++;
}
if((j+1)<(c))
{
if(*(anArray+c*i+j+1) == 1)
liveNeighbors++;
}
if((i+1)<r)
{
if(*(anArray+c*(i+1)+j) == 1)
liveNeighbors++;
if((j-1) >=0)
{
if(*(anArray+c*(i+1)+j-1) == 1)
liveNeighbors++;
}
if((j+1)<(c))
{
if(*(anArray+c*(i+1)+j+1) == 1)
liveNeighbors++;
}
}
return liveNeighbors;
}

// function to print the grid at time step
void printGrid(int *anArray,int rows,int columns)
{
for(int i=0; i<rows; i++)
{
for(int j=0; j<columns; j++)
{
printf("%d ",*(anArray+columns*i+j));
}
printf("\n");
}
return ;
}

=========================================
See Output

Files g main.c Dinput.txt saved share gcc version 4.6.3 run input.txt Welcome to Conway's game of Life Please enter filename input.txt 2 10 12 3 7 7 4 7 8 5 7 9 6 8 7 7 9 8 0 00 0 0 0 0 1 1 1 00 0 0 0 0 0 00 1 0 0 0 0 0 0 0 0 0 0 001 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 011 0 0 0 0 00 0 0 0 0 10 1 00 0 00 0 0 0 0 1 1 000 0 0 0 0 0 0 0 1 01 0 0


Thanks, PLEASE RATE if helpful


--------------------------------------------USE BELOW CODE----------------------

#include <stdio.h>
#include <stdlib.h>

struct node
{
int rows;
int columns;
int *grid;
struct node *next_step;
};

struct node *createInitialNode(FILE *input,int *numsteps);

void nextStep(struct node *begin);

void printList(struct node *begin);

int neighbors(struct node *nodeptr,int i,int j);

void printGrid(int *anArray,int rows,int columns);

int main(void)
{
char inputname[30];
printf("Welcome to Conway's game of Life\nPlease enter filename\n");
scanf ("%[^\n]%*c", inputname); //Reading filename
FILE *fin;
fin=fopen(inputname,"r"); //Opening file
if(fin==NULL){
printf("ERROR opening filename %s\n",inputname);
return 0;
}
int numsteps;
struct node *head=createInitialNode(fin,&numsteps); //Creating head node
// loop to get the array state after steps time steps
for(int step=1; step<=numsteps; step++) //Creating linked list of nodes for each time step
nextStep(head);
// display the grid after steps number of time steps
printList(head); //Printing the grids in the linked list
return EXIT_SUCCESS;
}

// function to return the number of live neighboring cells for a cell at (i,j) at time step

struct node* createInitialNode(FILE *input,int *numsteps)
{

fseek(input, 0, SEEK_END); // goto end of file
if (ftell(input) == 0)
{
   printf("ERROR with initial point values");
exit(0);
    
}
fseek(input, 0, SEEK_SET);
fscanf(input,"%d",numsteps); //Extracting the number of time steps
int rows,columns,x,y;
fscanf(input,"%d %d",&rows,&columns); //Extracting the number of rows and columns
struct node *head=(struct node *)malloc(sizeof(struct node)); //Dynamically creating a new node

//Initializing the new node
head->grid=(int*)malloc(columns*rows*sizeof(int)); //Dynamically creating a new grid
head->columns=columns;
head->rows=rows;
head->next_step=NULL;

//Filling all grid values to 0
for(int i=0; i<rows; i++)
{
for(int j=0; j<columns; j++)
*(head->grid+columns*i+j)=0;
}

//Extracting the positions of live cells and marking it in the grid
while(fscanf(input,"%d %d",&x,&y)==2)
*(head->grid+columns*x+y)=1;
return head;
}

void nextStep(struct node *begin)
{
struct node *next,*prev=begin;
next=(struct node *)malloc(sizeof(struct node)); //Creating new node
int col=begin->columns;

//Initializing the new node
next->columns=begin->columns;
next->rows=begin->rows;
next->next_step=NULL;
next->grid=(int*)malloc(next->columns*next->rows*sizeof(int)); //Creating the grid

//Traversing to the end of linked list
while(prev->next_step!=NULL)
prev=prev->next_step;

prev->next_step=next; //Linking the new node to the end of linked list
int liveNeighbors;
int r,c;
//Calculating the next state
for(r=0; r<begin->rows; r++)
{
for(c=0; c<begin->columns; c++)
{
liveNeighbors = neighbors(prev,r,c);
if( *(prev->grid+col*r+c) == 1)
{
if(liveNeighbors < 2 || liveNeighbors > 3)
*(next->grid+col*r+c)=0;
else
*(next->grid+col*r+c)=1;
}
else
{
if(liveNeighbors == 3)
*(next->grid+col*r+c)=1;
else
*(next->grid+col*r+c)=0;
}
}
}
return ;
}

void printList(struct node *begin)
{
//Traversing through the linked list
while(begin!=NULL)
{
printGrid(begin->grid,begin->rows,begin->columns);
begin=begin->next_step;
printf("\n");
}
return;
}

int neighbors(struct node *nodeptr,int i,int j)
{
int liveNeighbors=0;
int r=nodeptr->rows,c=nodeptr->columns;
int *anArray=nodeptr->grid;
if((i-1)>=0)
{
if((j-1) >=0)
{
if(*(anArray+c*(i-1)+j-1) == 1)
liveNeighbors++;
}
if(*(anArray+c*(i-1)+j) == 1)
liveNeighbors++;
if((j+1)<(c))
{
if(*(anArray+c*(i-1)+j+1) == 1)
liveNeighbors++;
}
}
if((j-1) >=0)
{
if(*(anArray+c*i+j-1) == 1)
liveNeighbors++;
}
if((j+1)<(c))
{
if(*(anArray+c*i+j+1) == 1)
liveNeighbors++;
}
if((i+1)<r)
{
if(*(anArray+c*(i+1)+j) == 1)
liveNeighbors++;
if((j-1) >=0)
{
if(*(anArray+c*(i+1)+j-1) == 1)
liveNeighbors++;
}
if((j+1)<(c))
{
if(*(anArray+c*(i+1)+j+1) == 1)
liveNeighbors++;
}
}
return liveNeighbors;
}

// function to print the grid at time step
void printGrid(int *anArray,int rows,int columns)
{
for(int i=0; i<rows; i++)
{
for(int j=0; j<columns; j++)
{
printf("%d ",*(anArray+columns*i+j));
}
printf("\n");
}
return ;
}