## Description

Part 1: Bunnies and Foxes, equilibrium

As promised, we will revisit the bunny and fox example from Lab #3. Remember we had formula

for computing the population of bunnies and foxes in the next year given the current population.

Here is a slight variation of the functions from Lab # 3 combined into a single function that returns

a tuple:

def next_pop(bpop, fpop):

bpop_next = int(max(0,round((10*bpop)/(1+0.1*bpop) – 0.05*bpop*fpop)))

fpop_next = int(max(0,round(0.4 * fpop + 0.02 * fpop * bpop)))

return (bpop_next, fpop_next)

The population of bunnies and foxes change every year as a function of the above formula. What can

we expect in the future? Option 1: bunnies or foxes will totally disappear and never appear again

(convergence), option 2: the populations will remain unchanged after a certain point (convergence),

or option 3: the population will never reach convergence. You will write a program in this part to

check which one is expected to occur.

Your program will have the function next_pop given above. You must define a second function

called:

check_convergence(bpop, fpop)

that takes as input the initial population of bunnies and foxes, and then computes the population

of the following year continuously using a WHILE LOOP. Your loop stops and outputs the

remaining population of bunnies and foxes until any one of the following is true:

(a) No bunnies or foxes (or both) are left, i.e. has population zero (convergence is true),

(b) The population of bunnies and foxes in the current year is identical to the previous year, i.e.

population equilibrium is reached (convergence is true),

(c) None of the above is true, but you have computed exactly 100 generations (convergence is

false).

Your function, when finished computing the while loop must return a 4-tuple:

(bpop, fpop, iter, converged)

where bpop,fpop are the final populations of bunnies and foxes, iter is the total number of

iterations the while loop repeated to reach this number (i.e. number of times you called the

next_pop function), and converged is either True or False based on whether convergence was

achieved.

Your functions must not have any global variables and you must use a while loop in the convergence function.

Your program will use these functions by first asking the user for the current bunny and fox

population. Assume the input is a valid integer.

Once a value is given for both populations, you must call function check_convergence(bpop, fpop)

from your module and print out the returned values. Sample output from separate runs is given

below:

Please enter the starting bunny population ==> 6

6

Please enter the starting fox population ==> 7

7

(Bunny, Fox): Start (6, 7) End: (30, 30), Converged: True in 8 generations

Please enter the starting bunny population ==> 10

10

Please enter the starting fox population ==> 10

10

(Bunny, Fox): Start (10, 10) End: (29, 30), Converged: False in 100 generations

Please enter the starting bunny population ==> 1000

1000

Please enter the starting fox population ==> 2

2

(Bunny, Fox): Start (1000, 2) End: (0, 41), Converged: True in 1 generations

When you are sure your program satisfy the requirements stated here, submit it.

When you have tested your code, please submit it as hw5_part1.py.

Part 2: Election Time in Pythonia

In the spirit of the budding election season, let us examine the current political struggles in the

far-off land of Pythonia. You will run a fantasy election in which candidates are trying to win

villages by obtaining more votes than their competitors. On election day, villagers head to the

polls and cast their vote, and the results pour in state-by-state. Before the next state’s outcome is

announced, you decide to run a simulation to see which of two running candidates will be ranked

higher based on the state’s voting turnout and the candidates’ current standing.

Write a program to read from the user a comma-separated string that represents the current

standing of two candidates in the election. The input is of the form:

candidate name, states won, states tied, total representative votes

Compute the candidate’s current standing (or “rank”) by adding up the following:

• each state won is worth 5 points

• each state with a tied-win is worth 2 points

• count half (rounding down) of the total representative votes

One candidate is ranked higher than another simply if this score is higher than the other candidate’s.

Now you prepare for the different possible outcomes of the next state’s voting for the candidates.

Each candidate can receive 0 to 4 representative votes from the villagers, so the possible outcomes

look like 1-0, 1-1, 0-1, 0-0, 2-0, 2-1, 2-2, 1-3, etc.

In these outcomes, the candidate with more representative votes wins the state, and both candidates

receive a ”tied win” if the score is tied.

For any possible outcome, compute which candidate will have the higher standing after winning or

losing and print the first letter of the winning candidate’s name as the result, or ‘-’ if the candidates

then have the same standing. You will print this information in a 5 by 5 board.

For simplicity, assume the input will be in the correct format, with no spaces around commas.

You must use for loops to accomplish this. The output below uses 5 spaces for each column.

Here is a possible run of the program in Wing:

Enter candidate 1 stats ==> Lovelace,5,1,28

Lovelace,5,1,28

Enter candidate 2 stats ==> Turing,4,3,29

Turing,4,3,29

Columns are Lovelace’s votes, rows are Turing’s votes

Votes| 0 1 2 3 4

—–|————————-

0 | L L L L L

1 | T – L L L

2 | T T L L L

3 | T T T – L

4 | T T T T L

In this case, Lovelace and Turing have two chances to be tied in rank if the outcome of this next

state is 1-1 or 3-3. Here is another possible run:

Enter candidate 1 stats ==> Engelbart,6,0,32

Engelbart,6,0,32

Enter candidate 2 stats ==> Babbage,3,1,22

Babbage,3,1,22

Columns are Engelbart’s votes, rows are Babbage’s votes

Votes| 0 1 2 3 4

—–|————————-

0 | E E E E E

1 | E E E E E

2 | E E E E E

3 | E E E E E

4 | E E E E E

In this case, Engelbart is already doing so well that even losing the state would not lower his rank

below Babbage.

You must use functions for this part. Keep in mind as you break down this part into steps that

a function should aim to solve just one task so that main code and other functions can call it

whenever needed.

Here are some suggestions of functions you might want to write for this part:

• make_board(candidate1, candidate2): return the board to print as a string (or list of

strings)

• print_board(board): print the board in the above format

• winner(candidate1, candidate2, outcome): take two candidate’s information and one

possible outcome, and return the letter to print, the “winner”

The idea here is to do calculations in one area, and then use the result for printing in another.

Beware that such a winner function must not change the original candidate’s stats so that you

may call the function multiple times (for each possible outcome). The rest is easily accomplished

with a double for loop.

When you have tested your code, please submit it as hw5_part2.py.

Part 3: Baby Names

In this part, you will use real data from Social Security Administration on the number of times

a certain name is given to a babies born in the United States. The information is given in a file.

We provide you with two separate files, one is a much shorter file for testing (babies_short.txt)

and the second one is a very long file with all the baby names given between years 2000-2010

(babies.txt).

Each line in the file looks like this:

Marnie,F,164

Darrow,M,17

This means that Marnie as a female name is given to 164 babies, and Darrow as a male name is

given to 17 babies. Of course, it is possible for the some names to be given both to male and female

babies.

Write a program that first reads the file name to be used for baby names and a cutoff k from the

user. Your program then should find and print the top k most popular female baby names and the

top k most popular male baby names (and for each name, the number of times it is given). You

must put a new line after every third name to make your output look pleasant.

Here are possible expected outputs:

File name => babies_short.txt

babies_short.txt

How many names to display? => 2

2

Top female names

Elsa (3353) Marnie (164)

Top male names

Amilcar (238) Leshawn (157)

File name => babies.txt

babies.txt

How many names to display? => 5

5

Top female names

Emily (223590) Madison (193063) Emma (181156)

Olivia (155935) Hannah (155607)

Top male names

Jacob (273642) Michael (250370) Joshua (231771)

Matthew (221411) Daniel (203569)

There is a very simple trick to solving this homework. The sort function in Python can sort lists

and lists of lists (or tuples). For example, suppose we sort a list of tuples containing 2 elements

each:

>>> x = [ (2, ‘a’), (6, ‘b’), (4, ‘c’), (6, ‘a’), (1, ‘f’) ]

>>> x.sort()

>>> x

[(1, ‘f’), (2, ‘a’), (4, ‘c’), (6, ‘a’), (6, ‘b’)]

>>> x.sort(reverse=True)

>>> x

[(6, ‘b’), (6, ‘a’), (4, ‘c’), (2, ‘a’), (1, ‘f’)]

As we can see from the above example, when we sort x, it will first sort by the first value in each

tuple. If the first value is equal, then it will sort by the second value. As a result, (6, ‘a’) comes

before (6, ‘b’). You can also sort in descending order by using x.sort(reverse=True).

If you want to find the top names, you must create a list that you can sort first by the frequency

of the name, then the name. In the unlikely case that two names have the same frequency, their

ordering will be descending lexicographic order. We can fix them with a hack, but will skip that

for now. You will learn very elegant ways to avoid this in your next class.

When you have tested your code, please submit it as hw5_part3.py.