Inital solution for fibonacci sequence

Author: orfeasa

04. Recursion/04-04 Fibonacci Sequence/fibonacci.py

@@ -0,0 +1,43 @@
+from typing import Optional, List
+
+# Recursive fuction
+def fib_rec(n: int) -> int:
+    # base case
+    if n == 0 or n == 1:
+        return n
+    return fib_rec(n - 1) + fib_rec(n - 2)
+
+
+# Dynamic function
+def fib_dyn(n: int) -> int:
+    # base case
+    if n == 0 or n == 1:
+        return n
+    # Instantiate Cache information
+
+    cache_size = 10
+    cache: List[Optional[int]]
+    cache = [None] * (cache_size + 1)
+
+    cache[0] = 0
+    cache[1] = 1
+    current_num = 2
+
+    while current_num < n:
+        cache[current_num % cache_size] = (
+            cache[(current_num - 1) % cache_size]
+            + cache[(current_num - 2) % cache_size]
+        )
+        current_num += 1
+
+    return cache[(n - 1) % cache_size] + cache[(n - 2) % cache_size]
+
+
+# Iterative function
+def fib_iter(n: int) -> int:
+    # base case
+    if n == 0 or n == 1:
+        return n
+    phi = (1 + 5 ** 0.5) / 2
+    psi = 1 - phi
+    return round((phi ** n - psi ** n) / 5 ** 0.5)

04. Recursion/04-04 Fibonacci Sequence/fibonacci_test.py

@@ -0,0 +1,20 @@
+import unittest
+
+from fibonacci import fib_rec, fib_dyn, fib_iter
+
+
+class FibonacciTest(unittest.TestCase):
+    def test_rec(self):
+        self.assertEqual(fib_rec(10), 55)
+        self.assertEqual(fib_rec(1), 1)
+        self.assertEqual(fib_rec(23), 28657)
+
+    def test_dyn(self):
+        self.assertEqual(fib_dyn(10), 55)
+        self.assertEqual(fib_dyn(1), 1)
+        self.assertEqual(fib_dyn(23), 28657)
+
+    def test_iter(self):
+        self.assertEqual(fib_iter(10), 55)
+        self.assertEqual(fib_iter(1), 1)
+        self.assertEqual(fib_iter(23), 28657)

04. Recursion/04-04 Fibonacci Sequence/readme.md

@@ -0,0 +1,49 @@
+# Fibonnaci Sequence
+
+## Problem
+
+Implement a [Fibonnaci Sequence](https://en.wikipedia.org/wiki/Fibonacci_number) in three different ways:
+
+- Recursively
+- Dynamically (Using Memoization to store results)
+- Iteratively
+
+Your function will accept a number **n** and return the **nth** number of the fibonacci sequence
+
+Remember that a fibonacci sequence: 0,1,1,2,3,5,8,13,21,... starts off with a base case checking to see if n = 0 or 1, then it returns 1.
+
+Else it returns fib(n-1)+fib(n+2).
+
+## Code
+
+### Recursively
+
+Solve the problem using simple recursion.
+
+```python
+def fib_rec(n):
+    pass
+```
+
+### Dynamically
+
+Implement the function using dynamic programming by using a cache to store results (memoization).
+
+```python
+# Instantiate Cache information
+n = 10
+cache = [None] * (n + 1)
+
+
+def fib_dyn(n):
+    pass
+```
+
+### Iteratively
+
+Implement the solution with simple iteration.
+
+```python
+def fib_iter(n):
+    pass
+```

readme.md

@@ -34,7 +34,7 @@ Each problem contains the problem description and unit tests in a separate file.
 1. [Word Split](https://github.com/orfeasa/data-structure-problems/tree/master/04.%20Recursion/04-01%20Word%20Split)
 1. [Reverse String](https://github.com/orfeasa/data-structure-problems/tree/master/04.%20Recursion/04-02%20Reverse%20a%20String)
 1. [String Permutation](https://github.com/orfeasa/data-structure-problems/tree/master/04.%20Recursion/04-03%20String%20Permutation)
-1. Fibonacci Sequence
+1. [Fibonacci Sequence](https://github.com/orfeasa/data-structure-problems/tree/master/04.%20Recursion/04-04%20Fibonacci%20Sequence)
 1. Coin Change
 
 ### 5. Trees