There is lots of information about the Fibonacci Sequence on wikipedia and on wolfram. A lot more than you may need. Anyway it is a good thing to learn how to use these resources to find (quickly if possible) what you need.

## Write Fib sequence formula to infinite

In math, it's given in a recursive form:

In programming, **infinite** doesn't exist. You can use a recursive form translating the math form directly in your language, for example in Python it becomes:

```
def F(n):
if n == 0: return 0
elif n == 1: return 1
else: return F(n-1)+F(n-2)
```

Try it in your favourite language and see that this form requires **a lot** of time as n gets bigger. In fact, this is O(2^{n}) in time.

Go on on the sites I linked to you and will see this (on wolfram):

This one is pretty easy to implement and very, very fast to compute, in Python:

```
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
```

An other way to do it is following the definition (from wikipedia):

The first number of the sequence is 0,
the second number is 1, and each
subsequent number is equal to the sum
of the previous two numbers of the
sequence itself, yielding the sequence
0, 1, 1, 2, 3, 5, 8, etc.

If your language supports iterators you may do something like:

```
def F():
a,b = 0,1
while True:
yield a
a, b = b, a + b
```

## Display startNumber to endNumber only from Fib sequence.

Once you know how to generate Fibonacci Numbers you just have to cycle trough the numbers and check if they verify the given conditions.

Suppose now you wrote a f(n) that returns the n-th term of the Fibonacci Sequence (like the one with sqrt(5) )

In most languages you can do something like:

```
def SubFib(startNumber, endNumber):
n = 0
cur = f(n)
while cur <= endNumber:
if startNumber <= cur:
print cur
n += 1
cur = f(n)
```

In python I'd use the iterator form and go for:

```
def SubFib(startNumber, endNumber):
for cur in F():
if cur > endNumber: return
if cur >= startNumber:
yield cur
for i in SubFib(10, 200):
print i
```

My hint is to *learn to read* what you need. Project Euler (google for it) will train you to do so :P
Good luck and have fun!

## Best Solution

You model the time function to calculate

`Fib(n)`

as sum of time to calculate`Fib(n-1)`

plus the time to calculate`Fib(n-2)`

plus the time to add them together (`O(1)`

). This is assuming that repeated evaluations of the same`Fib(n)`

take the same time - i.e. no memoization is use.`T(n<=1) = O(1)`

`T(n) = T(n-1) + T(n-2) + O(1)`

You solve this recurrence relation (using generating functions, for instance) and you'll end up with the answer.

Alternatively, you can draw the recursion tree, which will have depth

`n`

and intuitively figure out that this function is asymptotically`O(2`

^{n}`)`

. You can then prove your conjecture by induction.Base:

`n = 1`

is obviousAssume

`T(n-1) = O(2`

^{n-1}`)`

,therefore`T(n) = T(n-1) + T(n-2) + O(1)`

which is equal to`T(n) = O(2`

^{n-1}`) + O(2`

^{n-2}`) + O(1) = O(2`

^{n}`)`

However, as noted in a comment, this is not the tight bound. An interesting fact about this function is that the T(n) is asymptotically

the sameas the value of`Fib(n)`

since both are defined as`f(n) = f(n-1) + f(n-2)`

.The leaves of the recursion tree will always return 1. The value of

`Fib(n)`

is sum of all values returned by the leaves in the recursion tree which is equal to the count of leaves. Since each leaf will take O(1) to compute,`T(n)`

is equal to`Fib(n) x O(1)`

. Consequently, the tight bound for this function is the Fibonacci sequence itself (~`θ(1.6`

^{n}`)`

). You can find out this tight bound by using generating functions as I'd mentioned above.