COMP 141 Spring 2020

Program 7: The Strange Garden

Assigned: Wednesday, April 8
Due: Sunday, April 19, 2020 by 11:55pm

Computer science, while fun, is not something you can do 24/7. Keeping up with hobbies is important, so you decide to take up gardening as a new hobby. You know nothing about growing plants, however, so you decide to visit a new flower shop in your neighborhood.

The shop owner seems a bit strange, however, and sells you some plants you've never seen before, known only as "Plant A" and "Plant B". The shop owner tells you that these plants grow in specific ways according to a strange set of rules. In this project, you will develop a computer program that shows how the plants grow.

Rules for the plants

The shopkeeper tells you some basic rules for the two kinds of Plants, Plant A and Plant B.

Each plant type is always planted separately from the other type (A and B). The two types never grow together.
Each plant is planted in straight rows of individual plants.
The plants grow in what are called generations: every day the plants grow and change in size according to the rules below.

Plant A

Every plant in a row of Plant A will always be either "alive" or "dormant". This plant has a very simple growing pattern that is based on its neighboring plants:

If a plant is alive and exactly one of its two neighboring plants (the plants to the immediate left and right) are also alive, then it will stay alive in the next generation.
If a plant is alive and both of its two neighboring plants are alive, then it will become dormant in the next generation due to overcrowding.
If a plant is alive and both of its two neighboring plants are dormant, then it will become dormant in the next generation due to loneliness.
If a plant is dormant and exactly one of its two neighboring plants are alive, then it regenerates and becomes alive in the next generation.
If a plant is dormant and its two neighboring plants are both alive or both dormant, then it stays dormant in the next generation.
Note 1: All the plants in the row change to the next generation at the same time.
Note 2: The plant on the far left and the plant on the far right of the row have only one neighbor, so these rules do not apply to them: they will always be dormant.

Let's examine a few generations of Plant A. Suppose we have a row of eight plants. We represent an alive plant with an asterisk (*), and a dormant plant with a period (.). To make it easier to talk about the plants, let's number them from left to right, starting with 0. Suppose the plants begin like this:

01234567  <-- Plant numbers
.***..*.  <-- Plant status

To figure out what happens at the next generation, let's examine the plants from left to right.

Plant 0 is on the far left, so it always stays dormant.
Plant 1 is alive and has exactly one alive neighbor, so it will remain alive in the next generation.
Plant 2 is also alive, but both of its neighbors are alive, so it will become dormant in the next generation.
Plant 3, like plant 1, is alive and has exactly one alive neighbor, so it will remain alive.
Plant 4 is dormant, but it has exactly one alive neighbor, so it will regenerate and become alive in the next generation.
Plant 5 is similar to plant 4 (dormant, but has one alive neighbor), so it will also become alive.
Plant 6 is alive, but has no alive neighbors, so it will become dormant in the next generation.
Plant 7 is on the far right, so it always stays dormant.

So the first two generation of plants in the row looks like this, with the initial generation on top and the second generation below.

01234567
.***..*.
.*.***..

If we apply the same rules again, we end up with the third generation of plants, which when added below the first two generations, looks like this:

01234567
.***..*.
.*.***..
...*.**.

Plant B

The shopkeeper has warned you that Plant B is trickier than Plant A.

While Plant A only has two states (alive and dormant), Plant B has three states, because Plant B can grow to be two different sizes while alive: big and small. So the three states are big, small, and dormant.
While Plant A's growth pattern is based on itself and its immediate left and right neighbors, Plant B is allowed to look at a flexible number of neighbors on either side. We call this the neighborhood. Plant A always uses a neighborhood of 1, which means it looks at 1 neighboring plant on either side. Plant B is allowed to use a neighborhood of any integer size. For instance, a neighborhood of 2 means that every Plant B is allowed to consider itself, plus the two plants to its left and the two plants to its right to figure out what it does in the next generation.
Plant B's growth pattern is based off of whether or not the total number of alive plants - big or small - in the neighborhood is even or odd. Whenever the number of alive plants in the neighborhood is odd, then the plant will grow bigger (changing from dormant to small, or small to big). When the number of alive plants in the neighborhood is even, then the plant will grow smaller (changing from big to small, or small to dormant). More specifically:
If a plant is big, and the number of alive plants in the neighborhood is odd, then it will stay big in the next generation (since it can't grow any bigger).
If a plant is big, and the number of alive plants in the neighborhood is even, then it will change to small in the next generation.
If a plant is small, and the number of alive plants in the neighborhood is odd, then it will change to big in the next generation.
If a plant is small, and the number of alive plants in the neighborhood is even, then it will change to dormant in the next generation.
If a plant is dormant, and the number of alive plants in the neighborhood is odd, then it will change to small in the next generation.
If a plant is dormant, and the number of alive plants in the neighborhood is even, then it will stay dormant in the next generation (since it can't get any smaller).
Plants on the far left and the far right sides of a row that do not have a full neighborhood are always dormant in all generations. In other words, for a neighborhood of 1, the single far left and far right plants are always dormant (like with Plant A). For a neighborhood of 2, the two far left and far right plants are always dormant.

Let's examine a few generations of Plant B, with a neighborhood of 1. Suppose we have a row of eight plants. We represent a big plant with a caret (^), a small plant with an asterisk (*), and a dormant plant with a period (.). Suppose the plants begin like this:

01234567
.^*.^.*.

Here's how we compute the next generation:

Plant 0 is on the far left and doesn't have a full neighborhood, so it stays dormant.
Plant 1 is big, and the total number of alive plants (big or small) within its neighborhood is 2 (itself, plus the small plant on the right). Because 2 is even, this plant will become small in the next generation.
Plant 2 is similar in that the total number of alive plants in its neighborhood is 2 (itself and the big plant to the left). Because 2 is even and this plant is already small, it will become dormant in the next generation.
Plant 3 has a similar neighborhood (2 alive plants). But it is already dormant, so it will stay dormant.
Plant 4 has a neighborhood with 1 alive plant (itself). Because 1 is odd, this plant will stay big in the next generation.
Plant 5 has a neighborhood with 2 alive plants. This plant is dormant, and 2 is even, so this plant will stay dormant.
Plant 6 has a neighborhood with 1 alive plant. This plant is small, so it will grow to big in the next generation.
Plant 7 is the far right plant without a full neighborhood, so it will stay dormant.
So the first two generations look like this:

01234567
.^*.^.*.
.*..^.^.

Adding in a third generation, we get this:

01234567
.^*.^.*.
.*..^.^.
.^**^.^.

How your program will work

You will write a program that asks the user whether they are growing Plant A or B, along with the initial plant configuration, and how many generations the user wants to see. Then you will simulate the growth of the row of plants for the specified number of generations, showing each generation, along with various statistics.

How to get started

Begin by downloading the starter code here. Read it over and familiarize yourself with it. The program will come together by writing a series of functions.
We will first write the functions to get Plant A to work, then write the code for Plant B.
Write the functions countSmall, countBig, and countDormant. They should be self-descriptive from their names and the comments in the code, and they all work in a similar way.
Test these functions from the Python shell by calling them manually with different garden configurations. All three of these functions should work fine with either plant A or plant B. Here are some examples:

>>> countDormant("..*^.^^...***.")
7
>>> countSmall("..*^.^^...***.")
4
>>> countBig("..*^.^^...***.")
3

Write the function nextGenerationA. This function takes one argument, which is the current generation of a row of plants (which we call a garden). See the comments in the function code to help you.
When youre finished, test the code from the Python shell. Here are some examples (the same three generations used above for Plant A). You should also make up your own test cases (make up some garden strings):

>>> nextGenerationA(".***..*.") # generation 1 -> 2
'.*.***..'
>>> nextGenerationA(".*.***..") # generation 2 -> 3
'...*.**.'
>>> nextGenerationA(".*.*****.*.") # another example
'...*...*...'

Now jump down to the main function and write some code to get Plant A to run. Look at the sample interactions below, and read the comments in the code to guide you.
Once Plant A is running, test the output thoroughly. Make sure your output matches mine (again, see the sample interactions below).
Now go back and write nextGenerationB. Follow the directions in the code.
Test this function thoroughly with various gardens and neighborhood sizes.

>>> nextGenerationB(".^*.^.*.", 1)  
'.*..^.^.'
>>> nextGenerationB(".*..^.^.", 1)
'.^**^.^.'
>>> nextGenerationB("......*......", 1)
'.....*^*.....'
>>> nextGenerationB(".....*^*.....", 1)
'....*.^.*....'
>>> nextGenerationB("......*......", 2)
'....**^**....'
>>> nextGenerationB("....**^**....", 2)
'..*.^.^.^.*..'
>>> nextGenerationB("......*......", 3)
'...***^***...'
>>> nextGenerationB("...***^***...", 3)
'....^.^.^....'

Write the remaining part of main to get Plant B to work.

Sample interactions

Plant A, Test 1

Are you growing plant A or B? A
What is the starting garden? .***..*.
How many dormant plants are on either side? 0
How many generations do you want to see? (not including the first) 5
.***..*. 4 4
.*.***.. 4 4
...*.**. 5 3
..*..**. 5 3
.*.****. 3 5
...*..*. 6 2

Plant A, Test 2

Are you growing plant A or B? A
What is the starting garden? *
How many dormant plants are on either side? 32
How many generations do you want to see? (not including the first) 32
................................*................................ 64 1
...............................*.*............................... 63 2
..............................*...*.............................. 63 2
.............................*.*.*.*............................. 61 4
............................*.......*............................ 63 2
...........................*.*.....*.*........................... 61 4
..........................*...*...*...*.......................... 61 4
.........................*.*.*.*.*.*.*.*......................... 57 8
........................*...............*........................ 63 2
.......................*.*.............*.*....................... 61 4
......................*...*...........*...*...................... 61 4
.....................*.*.*.*.........*.*.*.*..................... 57 8
....................*.......*.......*.......*.................... 61 4
...................*.*.....*.*.....*.*.....*.*................... 57 8
..................*...*...*...*...*...*...*...*.................. 57 8
.................*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*................. 49 16
................*...............................*................ 63 2
...............*.*.............................*.*............... 61 4
..............*...*...........................*...*.............. 61 4
.............*.*.*.*.........................*.*.*.*............. 57 8
............*.......*.......................*.......*............ 61 4
...........*.*.....*.*.....................*.*.....*.*........... 57 8
..........*...*...*...*...................*...*...*...*.......... 57 8
.........*.*.*.*.*.*.*.*.................*.*.*.*.*.*.*.*......... 49 16
........*...............*...............*...............*........ 61 4
.......*.*.............*.*.............*.*.............*.*....... 57 8
......*...*...........*...*...........*...*...........*...*...... 57 8
.....*.*.*.*.........*.*.*.*.........*.*.*.*.........*.*.*.*..... 49 16
....*.......*.......*.......*.......*.......*.......*.......*.... 57 8
...*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*... 49 16
..*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*.. 49 16
.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*. 33 32
................................................................. 65 0

Plant B, Test 1

Are you growing plant A or B? B
What is the starting garden? .^*.^.*.
How many dormant plants are on either side? 0
How many generations do you want to see? (not including the first) 5
What is the neighborhood size? 1
.^*.^.*. 4 2 2
.*..^.^. 5 1 2
.^**^.^. 3 2 3
.*^^*.^. 3 2 3
..^^..^. 5 0 3
.*****^. 2 5 1

Plant B, Test 2

Are you growing plant A or B? B
What is the starting garden? *
How many dormant plants are on either side? 20
How many generations do you want to see? (not including the first) 20
What is the neighborhood size? 1
....................*.................... 40 1 0
...................*^*................... 38 2 1
..................*.^.*.................. 38 2 1
.................*^.^.^*................. 36 2 3
................*.*.^.*.*................ 36 4 1
...............*^.^.^.^.^*............... 34 2 5
..............*.*.^.^.^.*.*.............. 34 4 3
.............*^.^.^.^.^.^.^*............. 32 2 7
............*.*.^.^.^.^.^.*.*............ 32 4 5
...........*^.^.^.^.^.^.^.^.^*........... 30 2 9
..........*.*.^.^.^.^.^.^.^.*.*.......... 30 4 7
.........*^.^.^.^.^.^.^.^.^.^.^*......... 28 2 11
........*.*.^.^.^.^.^.^.^.^.^.*.*........ 28 4 9
.......*^.^.^.^.^.^.^.^.^.^.^.^.^*....... 26 2 13
......*.*.^.^.^.^.^.^.^.^.^.^.^.*.*...... 26 4 11
.....*^.^.^.^.^.^.^.^.^.^.^.^.^.^.^*..... 24 2 15
....*.*.^.^.^.^.^.^.^.^.^.^.^.^.^.*.*.... 24 4 13
...*^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^*... 22 2 17
..*.*.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.*.*.. 22 4 15
.*^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^*. 20 2 19
..*.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.*.. 22 2 17

Plant B, Test 3

Are you growing plant A or B? B
What is the starting garden? *
How many dormant plants are on either side? 20
How many generations do you want to see? (not including the first) 20
What is the neighborhood size? 2
....................*.................... 40 1 0
..................**^**.................. 36 4 1
................*.^.^.^.*................ 36 2 3
..............**..^.^.^..**.............. 34 4 3
............*...*.*.^.*.*...*............ 34 6 1
..........**^*.*..^.^.^..*.*^**.......... 28 8 5
........*.^.*.*...*.^.*...*.*.^.*........ 30 8 3
......**..^.^..*.*..^..*.*..^.^..**...... 28 8 5
....*...*.*.*.......^.......*.*.*...*.... 32 8 1
..**^*.*..^..**...**^**...**..^..*.*^**.. 20 16 5
..^.*.*...^.*.....^.^.^.....*.^...*.*.^.. 28 6 7
..*.^..*.**..**.***.^.***.**..**.*..^.*.. 20 18 3
....*...*^.**.^..^.*^*.^..^.**.^*...*.... 24 10 7
..**^*...^.^^**..**.^.**..**^^.^...*^**.. 18 14 9
..^.*^..*****.^**.^*^*^.**^.*****..^*.^.. 14 18 9
..**^***^.^...*^..*.^.*..^*...^.^***^**.. 18 14 9
..^.^^^.****...**...^...**...****.^^^.^.. 20 12 9
..***^*....^.......*^*.......^....*^***.. 26 10 5
..^.^*^.***^**...*.^^^.*...**^***.^*^.^.. 16 14 11
..***^*...^^.^..*.**^**.*..^.^^...*^***.. 18 14 9
..^.^*^...*^**...*..^..*...**^*...^*^.^.. 22 10 9

Plant B, Test 4

Are you growing plant A or B? B
What is the starting garden? *
How many dormant plants are on either side? 20
How many generations do you want to see? (not including the first) 20
What is the neighborhood size? 3
....................*.................... 40 1 0
.................***^***................. 34 6 1
..............*.*.^.^.^.*.*.............. 34 4 3
...........**..*^.^.^.^.^*..**........... 30 6 5
........*...^...^.*.^.*.^...^...*........ 32 4 5
.....***^...^..***^.^.^***..^...^***..... 22 12 7
....*...*.*.**.^.^^*^*^^.^.**.*.*...*.... 22 12 7
...*^..*.*.....^*^*.^.*^*^.....*.*..^*... 24 10 7
....^*.^...*..**.^^*^*^^.**..*...^.*^.... 22 10 9
....^^*^*...**..***.^.***..**...*^*^^.... 20 14 7
...**^^^...*.^.*...*^*...*.^.*...^^^**... 22 10 9
....^^^*.**.*^*.**.^^^.**.*^*.**.*^^^.... 16 14 11
...***^.*^^*^^^*^^*^^^*^^*^^^*^^*.^***... 8 14 19
.....^*..**^^^^^^^^^^^^^^^^^^^**..*^..... 14 6 21
.....*^.*^^*^^^^^^^^^^^^^^^^^*^^*.^*..... 12 6 23
.....^**.**^^^^^^^^^^^^^^^^^^^**.**^..... 12 8 21
....*^.^...*^^^^^^^^^^^^^^^^^*...^.^*.... 16 4 21
....^^*^**..^*^^^^^^^^^^^^^*^..**^*^^.... 12 8 21
...**^.*^^**^^*^^^^^^^^^^^*^^**^^*.^**... 8 12 21
...^.^..**^^^^^^^^^^^^^^^^^^^^^**..^.^... 12 4 25
...*.^..^^*^^^^^^^^^^^^^^^^^^^*^^..^.*... 12 4 25

How do I know when my program works?

When your program output matches mine on all 6 tests, you can be reasonably sure everything works. Note that I will be testing your program with other inputs as well, so your code should work for any starting garden configuration and any neighborhood size for Plant B.

What to turn in

Through Moodle, turn in your code as a file called
yourLastName_yourFirstName_prg7.py.

Challenge Problems

Invent a Plant C that uses other rules to draw interesting patterns. In your code, implement Plant C and write in the comments what the rules are. Include some sample test cases that draw some interesting patterns.
Use simplegraphics to draw the output of Plant A and/or B using graphics. Here's an example of what you might draw (this uses black square for alive plants and white squares for dormant ones).

Notes

This project is based on something called a cellular automaton. In particular, Plant A is a particularly well-studied cellular automaton commonly known as Rule 90.

Grading

Your program will be graded on correctness, as well as on coding style, which refers to choices you make when writing your code, such as good use of variable names, appropriate indentation, and comments (this is not an exhaustive list). See the syllabus for further grading details.

You will receive one bonus point for every complete day your program is turned in early, up to a maximum of five points. For instance, if your program is due on September 20 at 11:59pm, if you turn in your code on Moodle any time on September 19 from 12:00am through 11:59pm, you will receive one extra point on your project. Programs submitted on September 18 from 12:00am through 11:59pm will receive two points. This pattern continues for up to five points.