Homework Assignments and Grading

20 points (Satisfies all requirements - a job well done):

17 points (Meets general requirements with a few minor problems):

14 points (Serious problems):

10 points (Extremely serious problems but demonstrates some effort and understanding):

5 points (Shows little effort and does not represent passing work):

Homework Assignments

Assignment 1. Due Friday, April 9, 11:00 A.M.

• 1. Copy in the program listed on page 28 exactly as shown.
Since not everyone has the book, look here if you need the code.
• 2. Once it runs, edit the comment block to contain the information described in class.
• 3. Submit using submit procedure.

Assignment 2. Due Friday, April 16, 11:00 A.M.

• Chapter 2, programming project #7 on page 93.

Assignment 3. Due Friday, April 23, 11:00 A.M.

• Chapter 3, programming project #7 (p. 142)

Additional requirements not mentioned in the text: Your program should take the initial and final velocities as user inputs, not just the fixed values given in the text. Write functions to do the following:
•  Print general instructions to the user.
•  Find acceleration (a), given initial and final velocities, and elapsed time (t).
•  Find elapsed time (t), given initial and final velocities, and acceleration (a).

Assignment 4. Due Friday, April 30, 11:00 A.M.

Chapter 4, programming project #2, p. 203

Assignment 5. Due Friday, May 7, 11:00 A.M.

 
• Chapter 5, programming project #8, p. 272.   Include some form of input validation.

Assignment 6. Due Date Extended to Monday, May 17, 10:00 P.M.

 
• Chapter 6, programming project #3, p. 319.

Additional requirement:  Include a function called  divisible with the following prototype:
int divisible(int n, int m);
The return value of divisible will be 1 if n is divisible by n, and 0 otherwise.  Divisible should be used in parts a, b, and c of the problem.  For instance, in part a. you might use it like this:
if( divisible(n,7) || divisible(n,11) || divisible(n,13) )
{
..do stuff..
}
There have been some questions as to how the program should interact with the user.  There are basically two possibilities: (1) The user enters the list of integers on a single line, hits return,  then the program prints out the list with the answers to questions a, b, and c; or (2)  the user enters just one integer on a line, then return,  the program answers questions a, b, and c for that integer, then prompts the user to enter another integer, or some sentinel character (like q) to quit.  The book appears to be telling you to do (1), but (2) is also acceptable.  You may consider doing (2) since I think it is a little easier to implement.

Assignment 7. Due Date Extended to Wednesday, June 2, 11:00 am

• Chapter 8, programming project #13, p.422 (Conway's Game of Life)

Read the program description given in the book and take careful note of the added options and requirements I have given in class, some of which are outlined below.
Program operation:
Your program should prompt for and scan in a positive integer from the user which will be the number of generations of life to calculate.  Input validation is required at this stage at the same level of sophistication as function get_int on p.250.  I suggest you modify that example to your own purpose.

Your program should then read in the initial configuration (i.e. generation 0) of live and dead cells from a text file consisting of a rectangular grid of characters.  For testing purposes, you should create this text file yourself using your favorite text editor (pico, ex, vi, emacs..).   Before you
try to write the code for reading in this file, you should thoroughly examine the examples on input file pointers which I showed you in class.  This code is available on the webpage under Class Code/File Pointers.  You should copy the code from the second example, create a text file (called temp, or whatever else you like) whose contents are just the characters:

12345
12345
12345
12345
12345

just as I showed you in class.  Compile and run the example, and then start making modifications to both the example and the text file until you understand how it works.  Consult either me or one of the lab tutors if you get stuck in this process.  Ultimately the functions you write to read in the text file, and to display the grid should be modifications of this example.

After the initial configuration is read, your program will print the heading: "Generation 0", display the initial grid, print the message: "Press return to continue", and then pause.  When the user hits return, the next generation is printed with an appropriate heading and message, and another pause.  This process continues until the correct number of generations have been displayed, at which point execution halts.

It is required that you include at least five functions, corresponding to the five subproblems in the structure chart which I showed you.  These subproblems were: (1) get the number of generations to compute from the user, with input validation; (2) read in the initial grid from a file; (3) display the current grid with a heading giving the generation number; (4) compute the next generation; and (5) compute the live neighbor counts for the present generation.  Note that (5) is a subproblem of (4).  The structure chart itself looked like:

               LIFE
                 |
   ______________|______________
  |         |         |         |
  |         |         |         |
 (1)       (2)       (3)       (4)
                                |
                                |
                               (5)

The number of rows and columns in your world grid must be given by constant macros.  Thus your program will work on any size grid and and on any initial configuration file.  The name of the initial configuration file will also be defined by a constant macro, as in the second example on the webpage.  The characters used to represent live and dead cells (which must also be represented by constant macros) are to be  '*'  and  '.'  respectively.

Consider the following very simple algorithm for determining whether cell in the ith row and jth column will be alive on the next generation:

1.   If cell[i][j] has 3 live neighbors in the present generation, it will be alive in the next generation;
2.   else if cell[i][j] has 2 live neighbors and is itself alive in the present generation, then it will be alive in the next generation;
3.   else cell[i][j] will be dead in the next generation.
Check that this algorithm really does embody rules (1), (2), and (3) given in the book and in class, and consider using it in your program.
Recall you have two options for dealing with the boundary cells.  One is to let the boundary cells be permanently dead and simply not process them, and the other is to wrap the left boundary and identify it with the right, and likewise for the top and bottom.  We refer to this as the torus option.

When you have a working prototype test your program on the following 25 by 25 initial grid:

.........................
.........................
.........................
.........................
.........................
.........................
............*............
............*............
........*********........
........*...*...*........
.......*.*.***.*.*.......
........*...*...*........
........*********........
..........*.*.*..........
..........*.*.*..........
..........*.*.*..........
..........*****..........
............*............
............*............
.........................
.........................
.........................
.........................
.........................
.........................

Regardless of which boundary option you have chosen, generation 15 should look like:

.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.....*....*...*....*.....
....*..***.*.*.***..*....
....*..*.*.*.*.*.*..*....
.....*.....*.*.....*.....
......*****...*****......
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
 
 

Then try your program on the following 17 by 28 initial grid.

............................
............................
.......****...*******.......
.....******......*******....
........*****......*****....
............................
............................
........*..*..*.............
........*..*..*.............
........****..*.............
........*..*..*.............
........*..*..*.............
........*..*..*.............
........*******.............
............................
............................
............................

If you have chosen to use the torus option, then generation 34 should look like:

........***..***............
............................
............................
............................
............................
..........**....*...........
................*****.......
.*............*...****......
**.***.......*.......**.....
..****..........******.....*
.*.........**.*.*****.....**
**.........**............***
.............*...........***
..........*...............**
..........*..*.............*
.........**.*.*...........**
.........**..***............

If you have chosen to use the dead boundary option, generation 34 should look like:

............................
............................
............................
............................
...............***..........
...............*..*...**....
................**....**....
............................
...........*................
..........*.*...*...........
...........*...*............
................*...........
............................
...**.......................
..*..*......................
...**.......................
............................
 
 
 
 

Allison Coates


Last modified: Mon Apr 26 16:36:38 PDT 1999