The Fibonacci sequence is a sequence of numbers such that any number, except for the first and second, is the sum of the previous two.
[0, 1, 1, 2, 3, 5, 8, 13, 21...]
We can represent this in the formula:
fib(n) = fib(n-1)+fib(n-2)
With this formula, we can write a simple
function to solve for
Note: Only use this to test for small numbers, preferably n < 10. I'll explain later
def fib(n): if n < 2: # base case return n return fib(n-1) + fib(n-2) if __name__ == "__main__": print(fib(7))
Why do we need a base case?
It's easy enough to convert the formula directly into
def fib(n): return fib(n-1) + fib(n-2)
The problem with this though is that when you run it, it throws a
This simply means that there's possibly an infinite loop in the program.
A base case in a recursive function tells the function when to stop (to
avoid going into an infinite loop) and is usually something that is
already known or that can be solved for easily without needing the
function. In our case here, we know from the definition that any number
in the sequence, except for the first and second, is the sum of the
previous two. We use that to form our base case
if n < 2: return n.
Making it more efficient
Remember when I told you to only test the program with small values of
n? Here's why.
As it stands, every call to
fib() results in two more calls to
return statement. The call tree grows exponentially. 15 calls
are required to compute
fib(5), 177 calls for
fib(10), 21,891 for
fib(20)… you get the point. To solve this problem, we can use
Memoization helps avoid unnecessary calculation of the same values if
they were already previously calculated. It works just like memorization
for humans. You already have
2 x 2 memorized and can give the answer
immediately without having to use a calculator.
799 x 377? You
probably need to use a calculator for that. If, for some reason, you
find that you get asked
799 x 377 a lot, it would be nice to have it
memorized so you don't have to calculate it every other time. The value
799 x 377 will always remain the same, so all you have to do is
calculate it once, save the value in your "cache" (memory), and retrieve
it every time you need it.
Luckily, python has a built-in decorator that does just that.
from functools import lru_cache @lru_cache(maxsize=None) def fib(n): if n < 2: # base case return n return fib(n-1) + fib(n-2) if __name__ == "__main__": print(fib(50))
Now you can test with large numbers safely.