Wascally Wabbits

In 1202, Leonardo of Pisa (commonly known as Fibonacci) considered a mathematical exercise regarding the reproduction of a population of rabbits. He made the following simplifying assumptions about the population:

The population begins in the first month with a pair of newborn rabbits.

Rabbits reach reproductive age after one month.

In any given month, every rabbit of reproductive age mates with another rabbit of reproductive age.

Exactly one month after two rabbits mate, they produce one male and one female rabbit.

Rabbits never die or stop reproducing.

Fibonacci’s exercise was to calculate how many pairs of rabbits would remain in one year. We can see that in the second month, the first pair of rabbits reach reproductive age and mate. In the third month, another pair of rabbits is born, and we have two rabbit pairs; our first pair of rabbits mates again. In the fourth month, another pair of rabbits is born to the original pair, while the second pair reach maturity and mate (with three total pairs). After a year, the rabbit population boasts 144 pairs.

Although Fibonacci’s assumption of the rabbits’ immortality may seem a bit farfetched, his model was not unrealistic for reproduction in a predator-free environment: European rabbits were introduced to Australia in the mid 19th Century, a place with no real indigenous predators for them. Within 50 years, the rabbits had already eradicated many plant species across the continent, leading to irreversible changes in the Australian ecosystem and turning much of its grasslands into eroded, practically uninhabitable parts of the modern Outback. In this problem, we will use the simple idea of counting rabbits to introduce a new computational topic, which involves building up large solutions from smaller ones.

#### Problem

A sequence is an ordered collection of objects (usually numbers), which are allowed to repeat. Sequences can be finite or infinite. Two examples are the finite sequence (*π*,−2‾√,0,*π*) and the infinite sequence of odd numbers (1,3,5,7,9,…). We use the notation *an* to represent the *n*-th term of a sequence.

A recurrence relation is a way of defining the terms of a sequence with respect to the values of previous terms. In the case of Fibonacci’s rabbits from the introduction, any given month will contain the rabbits that were alive the previous month, plus any new offspring. A key observation is that the number of offspring in any month is equal to the number of rabbits that were alive two months prior. As a result, if *Fn* represents the number of rabbit pairs alive after the *n*-th month, then we obtain the Fibonacci sequence having terms *Fn* that are defined by the recurrence relation

(with *F*1=*F*2=1 to initiate the sequence). Although the sequence bears Fibonacci’s name, it was known to Indian mathematicians over two millennia ago.

When finding the *n*-th term of a sequence defined by a recurrence relation, we can simply use the recurrence relation to generate terms for progressively larger values of *n*. This problem introduces us to the computational technique of dynamic programming, which successively builds up solutions by using the answers to smaller cases.

Given a DNA string *t* corresponding to a coding strand, its transcribed RNA string *u* is formed by replacing all occurrences of ‘T’ in *t* with ‘U’ in *u*.

##### Given

Given: Positive integers *n* ≤ 40 and *k *≤ 5.

##### Return

The total number of rabbit pairs that will be present after *n* months, if we begin with 1 pair and in each generation, every pair of reproduction-age rabbits produces a litter of *k* rabbit pairs (instead of only 1 pair).

#### Solution

Change the n and m values in the dataset given to you.

```
n = 89
m = 16
bunnies = [1, 1]
months = 2
count = []
while months < n:
if months < m:
bunnies.append(bunnies[-2] + bunnies[-1])
elif months == m or count == m + 1:
bunnies.append(bunnies[-2] + bunnies[-1] - 1)
else:
bunnies.append(bunnies[-2] + bunnies[-1] - bunnies[-(m + 1)])
months += 1
print(bunnies[-1])
```

###### Important note:

This problem is taken from rosalind.info. Please visit ROSALIND to find out more about Bioinformatics problems. You may also clink onto links for the definitions of each terminology.