Merge branch 'develop'

Author: codejsha

README.md

@@ -226,7 +226,7 @@ MutableValueGraph<City, Distance> roads = ValueGraphBuilder.directed()
 
 **Graph algorithms**
 
-- A\* search algorithm: A single-pair shortest path algorithm. This is a variant of Dijkstra's algorithm using heuristics to try to speed up the search.
+- A\* search algorithm, CCSP#2.2.5: A single-pair shortest path algorithm. This is a variant of Dijkstra's algorithm using heuristics to try to speed up the search.
 - Bellman-Ford algorithm, CLRS#24.1: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A single source the shortest path algorithm that can handle negative edge weights. It finds the shortest path from a source vertex to all other vertices in a weighted graph.
 
 ```txt
@@ -250,7 +250,7 @@ algorithm BellmanFord(G, source):
     return true
 ```
 
-- Breadth-first search (BFS), CLRS#22.2, CCSP#4.3.1: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph), [python(test)](python-algorithm/algorithm/graph/test) | A search algorithm that traverses a graph layer by layer. Check the shortest path and compute the distance from the source vertex to all other vertices.
+- Breadth-first search (BFS), CLRS#22.2, CCSP#2.2.4, CCSP#4.3.1: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph), [python(test)](python-algorithm/algorithm/graph/test) | A search algorithm that traverses a graph layer by layer. Check the shortest path and compute the distance from the source vertex to all other vertices.
 
 ```txt
 algorithm BFS(G, source):
@@ -275,7 +275,7 @@ algorithm BFS(G, source):
         u.color = BLACK
 ```
 
-- Depth-first search (DFS), CLRS#22.3: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A search algorithm that traverses a graph by exploring as far as possible along each branch before backtracking. Check to exists cycle in a graph.
+- Depth-first search (DFS), CLRS#22.3, CCSP#2.2.3: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A search algorithm that traverses a graph by exploring as far as possible along each branch before backtracking. Check to exists cycle in a graph.
 
 ```txt
 algorithm DFS(G):
@@ -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$)
@@ -1051,9 +1051,9 @@ Collections.binarySearch(arrayList, 3);   // for list
 
 **Examples**
 
+- DNA search (Search a codon(combinations of three nucleotides) in a gene), CCSP#2.1: [python](python-algorithm/algorithm/search)(`linear_contains`, `binary_contains`) | Search a codon(combinations of three nucleotides) in a gene using linear search and binary search.
 - Find k-th smallest/largest element in an array, EPI#11.8: [c++](cpp-algorithm/src/search)(`FindKthSmallestElement`, `FindKthLargestElement`) | Find the k-th smallest/largest element in an array using the quickselect algorithm (`QuickSelectAlgorithm`).
 - Find the minimum and maximum elements in an array, EPI#11.7: [c++](cpp-algorithm/src/search)(`FindMinMax`)
-- Search a codon(combinations of three nucleotides) in a gene, CCSP#2.1: [python](python-algorithm/algorithm/search)(`linear_contains`, `binary_contains`) | Search a codon(combinations of three nucleotides) in a gene using linear search and binary search.
 - Search an element in generic list, CCSP#2.1: [python](python-algorithm/algorithm/search)(`generic_linear_contains`, `generic_linear_contains`) | Search an element in generic list using linear search and binary search.
 - Search a sorted array for entry equal to its index, EPI#11.2: [c++](cpp-algorithm/src/search)(`SearchEntryEqualToItsIndex`)
 - Search a sorted array for the first greater than a key: [c++](cpp-algorithm/src/search)(`SearchFirstGreaterThanKey`)
@@ -1249,6 +1249,7 @@ var str = collection.stream()
 
 **Examples**
 
+- Bit compression, CCSP#1.2: [python](python-algorithm/algorithm/string) | Compress a string using bit manipulation.
 - Convert string, EPI#6.1: [c++](cpp-algorithm/src/string)(`IntToString`, `StringToInt`) | Convert integer to string and vice versa.
 - IP address validation, EPI#6.9: [c++](cpp-algorithm/src/string) | Validate IPv4 address that is in the form of _x.x.x.x_ where _x_ is a number between 0 and 255.
 - Look and say problem, EPI#6.7: [c++](cpp-algorithm/src/string)

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: generator of Fibonacci numbers
+    """
+    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,7 +1,7 @@
 def gcd_euclidean(a: int, b: int) -> int:
     """
     Find the greatest common divisor of two numbers using the Euclidean algorithm.
-    :param a: number
+    :param a: dividend
     :param b: divisor
     :return: the greatest common divisor
     """
@@ -14,7 +14,7 @@ def gcd_euclidean_divmod(a: int, b: int) -> int:
     """
     Find the greatest common divisor of two numbers using the Euclidean algorithm.
     If the numbers are large, use divmod to calculate them.
-    :param a: number
+    :param a: dividend
     :param b: divisor
     :return: the greatest common divisor
     """
@@ -26,7 +26,7 @@ def gcd_euclidean_divmod(a: int, b: int) -> int:
 def gcd_extended_euclidean(a: int, b: int) -> tuple:
     """
     Find the greatest common divisor of two numbers using the extended Euclidean algorithm.
-    :param a: number
+    :param a: dividend
     :param b: divisor
     :return: the greatest common divisor, x, y (where ax + by = gcd(a, b))
     """

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

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

python-algorithm/algorithm/math/greatest_common_divisor.py

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

python-algorithm/algorithm/search/test/test_dna_search.py

@@ -0,0 +1,37 @@
+class CompressedGene:
+    def __init__(self, gene: str) -> None:
+        self._compress(gene)
+
+    def __str__(self) -> str:  # string representation for pretty printing
+        return self.decompress()
+
+    def _compress(self, gene: str) -> None:
+        self.bit_string: int = 1  # start with sentinel
+        for nucleotide in gene.upper():
+            self.bit_string <<= 2  # shift left two bits
+            if nucleotide == 'A':  # change last two bits to 00
+                self.bit_string |= 0b00
+            elif nucleotide == 'C':  # change last two bits to 01
+                self.bit_string |= 0b01
+            elif nucleotide == 'G':  # change last two bits to 10
+                self.bit_string |= 0b10
+            elif nucleotide == 'T':  # change last two bits to 11
+                self.bit_string |= 0b11
+            else:
+                raise ValueError('Invalid Nucleotide:{}'.format(nucleotide))
+
+    def decompress(self) -> str:
+        gene: str = ''
+        for i in range(0, self.bit_string.bit_length() - 1, 2):  # - 1 to exclude sentinel
+            bits: int = self.bit_string >> i & 0b11  # get just 2 relevant bits
+            if bits == 0b00:  # A
+                gene += 'A'
+            elif bits == 0b01:  # C
+                gene += 'C'
+            elif bits == 0b10:  # G
+                gene += 'G'
+            elif bits == 0b11:  # T
+                gene += 'T'
+            else:
+                raise ValueError('Invalid bits:{}'.format(bits))
+        return gene[::-1]  # [::-1] reverses string by slicing backward

python-algorithm/algorithm/search/test/test_generic_search.py

@@ -0,0 +1,19 @@
+from sys import getsizeof
+
+import pytest
+
+import algorithm.utils.logging as log_utils
+from algorithm.string.bit_compression import CompressedGene
+
+
+@pytest.mark.benchmark(group='gene_string_compression')
+def test_bit_compression(benchmark):
+    logger = log_utils.get_console_logger(__name__, 'DEBUG')
+    original: str = 'TAGGGATTAACCGTTATATATATATAGCCATGGATCGATTATATAGGGATTAACCGTTATATATATATAGCCATGGATCGATTATA' * 100
+    compressed: CompressedGene = benchmark(CompressedGene, original)
+
+    print('')
+    logger.debug('original is {} bytes'.format(getsizeof(original)))
+    logger.debug('compressed is {} bytes'.format(getsizeof(compressed.bit_string)))
+
+    assert original == compressed.decompress()

python-algorithm/algorithm/string/bit_compression.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Union
+
+
+def get_console_logger(name: str, level: Union[int, str, None] = None) -> logging.Logger:
+    """
+    Get a console logger with the specified name and log level.
+    :param name: logger name
+    :param level: log level which can be an integer, string, or None
+    :return: console logger
+    """
+    if level is None:
+        level = logging.INFO
+    elif isinstance(level, str):
+        level = _str_to_log_level(level)
+    elif not isinstance(level, int):
+        raise TypeError(f'Invalid log level type: {type(level)}')
+
+    return _create_console_logger(name, level)
+
+
+def _str_to_log_level(level: str) -> int:
+    """
+    Convert a string log level to an integer log level.
+    :param level: string log level
+    :return: integer log level
+    """
+    level = level.upper()
+    log_levels = {
+        'NOTSET': logging.NOTSET,
+        'DEBUG': logging.DEBUG,
+        'INFO': logging.INFO,
+        'WARNING': logging.WARNING,
+        'WARN': logging.WARNING,
+        'ERROR': logging.ERROR,
+        'CRITICAL': logging.CRITICAL,
+        'FATAL': logging.CRITICAL
+    }
+
+    if level in log_levels:
+        return log_levels[level]
+    else:
+        raise ValueError(f'Invalid log level: {level}')
+
+
+def _create_console_logger(name: str, level: int) -> logging.Logger:
+    """
+    Get a console logger with the specified name and log level.
+    :param name: logger name
+    :param level: log level
+    :return: console logger
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    return logger