Merge branch 'feature/fibonacci' into develop

Author: codejsha

README.md

@@ -821,7 +821,7 @@ Set<Integer> set = Sets.newTreeSet();
 
 **Examples**
 
-- Fibonacci number: [c++](cpp-algorithm/src/dp) | Fibonacci sequence is a sequence of numbers where each number is the sum of the two preceding numbers. Fibonacci number is $n$th number in the sequence. The Fibonacci sequence is defined as follows:
+- Fibonacci number, CCSP#1.1: [c++](cpp-algorithm/src/dp),[python](python-algorithm/algorithm/dp) | Fibonacci sequence is a sequence of numbers where each number is the sum of the two preceding numbers. Fibonacci number is $n$th number in the sequence. The Fibonacci sequence is defined as follows:
   - $F_0 = 0$
   - $F_1 = 1$
   - $F_n = F_{n-1} + F_{n-2}$ (for $n > 1$)

python-algorithm/algorithm/dp/__init__.py

@@ -0,0 +1,75 @@
+from functools import lru_cache
+from typing import Dict
+from typing import Generator
+
+
+def fibonacci_recursive(n: int) -> int:
+    """
+    Calculate the Fibonacci number of the given number.
+    :param n: input number
+    :return: Fibonacci number
+    """
+    if n < 2:  # base case
+        return n
+    return fibonacci_recursive(n - 2) + fibonacci_recursive(n - 1)  # recursive case
+
+
+def fibonacci_memoization(n: int) -> int:
+    """
+    Calculate the Fibonacci number of the given number using memoization.
+    :param n: input number
+    :return: Fibonacci number
+    """
+    memo: Dict[int, int] = {0: 0, 1: 1}  # our base cases
+
+    def helper(m: int) -> int:
+        if m not in memo:
+            memo[m] = helper(m - 1) + helper(m - 2)  # memoization
+        return memo[m]
+
+    return helper(n)
+
+
+@lru_cache(maxsize=None)
+def fibonacci_automatic_memoization(n: int) -> int:
+    """
+    Calculate the Fibonacci number of the given number using automatic memoization.
+    It uses the @lru_cache decorator to cache the results of the function.
+    It has same definition as :func:`fibonacci_recursive`.
+    :param n: input number
+    :return: Fibonacci number
+    """
+    if n < 2:  # base case
+        return n
+    return fibonacci_recursive(n - 2) + fibonacci_recursive(n - 1)  # recursive case
+
+
+def fibonacci_iterative(n: int) -> int:
+    """
+    Calculate the Fibonacci number of the given number using iterative approach.
+    :param n: input number
+    :return: Fibonacci number
+    """
+    if n == 0:
+        return n  # special case
+    _last: int = 0  # initially set to fib(0)
+    _next: int = 1  # initially set to fib(1)
+    for _ in range(1, n):
+        _last, _next = _next, _last + _next
+    return _next
+
+
+def fibonacci_generator(n: int) -> Generator[int, None, None]:
+    """
+    Calculate the Fibonacci number of the given number using generator approach.
+    :param n: input number
+    :return: Fibonacci number
+    """
+    yield 0  # special case
+    if n > 0:
+        yield 1  # special case
+    _last: int = 0  # initially set to fibonacci(0)
+    _next: int = 1  # initially set to fibonacci(1)
+    for _ in range(1, n):
+        _last, _next = _next, _last + _next
+        yield _next  # main generation step

python-algorithm/algorithm/dp/fibonacci.py

@@ -0,0 +1,75 @@
+from collections import deque
+
+import pytest
+
+import algorithm.dp.fibonacci as fibonacci
+
+
+@pytest.mark.benchmark(group='fibonacci_recursive')
+@pytest.mark.parametrize(
+    argnames='input_number, expected',
+    argvalues=[
+        (5, 5),
+        (20, 6765),
+        (30, 832_040)
+    ],
+    ids=['case1', 'case2', 'case3'])
+def test_fibonacci_recursive(benchmark, input_number, expected):
+    result = benchmark(fibonacci.fibonacci_recursive, input_number)
+    assert expected == result
+
+
+@pytest.mark.benchmark(group='fibonacci_memoization')
+@pytest.mark.parametrize(
+    argnames='input_number, expected',
+    argvalues=[
+        (5, 5),
+        (20, 6765),
+        (30, 832_040)
+    ],
+    ids=['case1', 'case2', 'case3'])
+def test_fibonacci_memoization(benchmark, input_number, expected):
+    result = benchmark(fibonacci.fibonacci_memoization, input_number)
+    assert expected == result
+
+
+@pytest.mark.benchmark(group='fibonacci_automatic_memoization')
+@pytest.mark.parametrize(
+    argnames='input_number, expected',
+    argvalues=[
+        (5, 5),
+        (20, 6765),
+        (30, 832_040)
+    ],
+    ids=['case1', 'case2', 'case3'])
+def test_fibonacci_automatic_memoization(benchmark, input_number, expected):
+    result = benchmark(fibonacci.fibonacci_automatic_memoization, input_number)
+    assert expected == result
+
+
+@pytest.mark.benchmark(group='fibonacci_iterative')
+@pytest.mark.parametrize(
+    argnames='input_number, expected',
+    argvalues=[
+        (5, 5),
+        (20, 6765),
+        (30, 832_040)
+    ],
+    ids=['case1', 'case2', 'case3'])
+def test_fibonacci_iterative(benchmark, input_number, expected):
+    result = benchmark(fibonacci.fibonacci_iterative, input_number)
+    assert expected == result
+
+
+@pytest.mark.benchmark(group='fibonacci_generator')
+@pytest.mark.parametrize(
+    argnames='input_number, expected',
+    argvalues=[
+        (5, 5),
+        (20, 6765),
+        (30, 832_040)
+    ],
+    ids=['case1', 'case2', 'case3'])
+def test_fibonacci_generator(benchmark, input_number, expected):
+    result = benchmark(fibonacci.fibonacci_generator, input_number)
+    assert expected == deque(result, maxlen=1).pop()

python-algorithm/algorithm/dp/test/__init__.py

@@ -1,4 +1,5 @@
 import pytest
+
 from algorithm.search.dna_search import Nucleotide, string_to_gene, linear_contains, binary_contains
 
 

python-algorithm/algorithm/dp/test/test_fibonacci.py

@@ -1,4 +1,5 @@
 import pytest
+
 from algorithm.search.generic_search import generic_linear_contains, generic_binary_contains