Merge branch 'feature/naming' into develop

Author: codejsha

python-algorithm/algorithm/graph/test/test_breadth_first_search.py

@@ -37,7 +37,7 @@ def create_city_graph() -> networkx.Graph:
 
 @pytest.mark.benchmark(group='graph_neighbors')
 @pytest.mark.parametrize(
-    argnames='graph, source, expected',
+    argnames='graph, source, expected_neighbors',
     argvalues=[
         (city_graph, "Seattle", ["Chicago", "San Francisco"]),
         (city_graph, "San Francisco", ["Seattle", "Riverside", "Los Angeles"]),
@@ -55,24 +55,39 @@ def create_city_graph() -> networkx.Graph:
         (city_graph, "Philadelphia", ["New York", "Washington"]),
         (city_graph, "Washington", ["Atlanta", "Miami", "Detroit", "Philadelphia"])
     ])
-def test_graph_neighbors(benchmark, graph, source, expected):
-    result = benchmark(graph.neighbors, source)
-    assert sorted(expected) == sorted(result)
+def test_graph_neighbors(benchmark, graph, source, expected_neighbors):
+    """
+    Find the neighboring city nodes of the source city node in the United States city graph.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param expected_neighbors: list of neighboring city nodes
+    """
+    neighbor_iterator = benchmark(graph.neighbors, source)
+    assert sorted(expected_neighbors) == sorted(neighbor_iterator)
 
 
 @pytest.mark.benchmark(group='graph_breadth_first_search')
 @pytest.mark.parametrize(
-    argnames='graph, source, distance, expected',
+    argnames='graph, source, distance, expected_nodes',
     argvalues=[
         (city_graph, "Boston", 1, ["Detroit", "New York"]),
         (city_graph, "Boston", 2, ["Chicago", "Washington", "Philadelphia"]),
         (city_graph, "Boston", 3, ["Seattle", "Riverside", "Dallas", "Atlanta", "Miami"]),
     ],
-    ids=["distance1", "distance2", "distance3"])
-def test_graph_breadth_first_search(benchmark, graph, source, distance, expected):
+    ids=['distance1', 'distance2', 'distance3'])
+def test_graph_breadth_first_search(benchmark, graph, source, distance, expected_nodes):
+    """
+    Find the city nodes at a given distance from the source city node in the United States city graph.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param distance: distance from the source city node
+    :param expected_nodes: list of city nodes at the given distance from the source city node
+    """
     bfs_generator = benchmark(networkx.bfs_layers, graph, source)
-    path = []
+    nodes = []
     for i, layer in enumerate(bfs_generator):
         if i == distance:
-            path = list(layer)
-    assert path == expected
+            nodes = list(layer)
+    assert nodes == expected_nodes

python-algorithm/algorithm/greedy/cashier_change.py

@@ -1,4 +1,10 @@
 def cashier_change(denominations: list[int], price: int) -> int:
+    """
+    Find the minimum number of coins needed to make change for a given amount of money.
+    :param denominations: list of coin denominations
+    :param price: amount of money
+    :return: minimum number of coins
+    """
     change = price
     coins = 0
 

python-algorithm/algorithm/greedy/interval_schedule.py

@@ -1,6 +1,6 @@
 def interval_scheduling_lecture(lectures: list[dict]) -> list[dict]:
     """
-    Greedy algorithm to schedule lectures.
+    Schedule lectures to maximize the number of lectures that can be attended. This uses the greedy algorithm.
     :param lectures: list of lectures
     :return: list of scheduled lectures
     """

python-algorithm/algorithm/greedy/test/test_cashier_change.py

@@ -5,12 +5,12 @@
 
 @pytest.mark.benchmark(group='cashier_change')
 @pytest.mark.parametrize(
-    argnames='denominations, price, expected',
+    argnames='denominations, price, expected_count',
     argvalues=[
         ([25, 10, 5, 1], 30, 2),
         ([25, 10, 5, 1], 24, 6)
     ],
     ids=['case1', 'case2'])
-def test_cashier_change(benchmark, denominations, price, expected):
-    result = benchmark(cashier_change, denominations, price)
-    assert expected == result
+def test_cashier_change(benchmark, denominations, price, expected_count):
+    coin_count = benchmark(cashier_change, denominations, price)
+    assert expected_count == coin_count

python-algorithm/algorithm/greedy/test/test_interval_schedule.py

@@ -17,9 +17,9 @@
 
 @pytest.mark.benchmark(group='interval_scheduling_lecture')
 @pytest.mark.parametrize(
-    argnames='lectures, expected',
+    argnames='lectures, expected_schedule',
     argvalues=[([lecture1, lecture2, lecture3], [lecture2, lecture3])],
     ids=['case1'])
-def test_interval_scheduling_lecture(benchmark, lectures, expected):
+def test_interval_scheduling_lecture(benchmark, lectures, expected_schedule):
     result = benchmark(interval_scheduling_lecture, lectures)
-    assert expected == result
+    assert expected_schedule == result

python-algorithm/algorithm/math/base_expansion.py

@@ -1,8 +1,10 @@
 def base_expansion(number: int, base: int) -> str:
     """
-    Base b expansion of integer number
+    Convert a number to a different base. This is base b expansion of a number.
+    :param number: number to convert
+    :param base: base to convert to
+    :return: number in the new base
     """
-
     result = []
     expansion_table = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4',
                        5: '5', 6: '6', 7: '7', 8: '8', 9: '9',

python-algorithm/algorithm/math/binary_operation.py

@@ -1,8 +1,10 @@
 def addition_binary_number(number1: str, number2: str) -> str:
     """
-    Addition of binary numbers
+    Add two binary numbers which are represented as strings.
+    :param number1: number string 1
+    :param number2: number string 2
+    :return: sum of the two binary numbers
     """
-
     result = []
     carry = 0
     number1 = number1[::-1]

python-algorithm/algorithm/math/greatest_common_divisor.py

@@ -1,8 +1,10 @@
 def gcd_euclidean(a: int, b: int) -> int:
     """
     Find the greatest common divisor of two numbers using the Euclidean algorithm.
+    :param a: number
+    :param b: divisor
+    :return: the greatest common divisor
     """
-
     while b != 0:
         a, b = b, a % b
     return a
@@ -12,8 +14,10 @@ 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 b: divisor
+    :return: the greatest common divisor
     """
-
     while b != 0:
         a, b = b, divmod(a, b)[1]
     return a
@@ -22,8 +26,10 @@ 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 b: divisor
+    :return: the greatest common divisor, x, y (where ax + by = gcd(a, b))
     """
-
     if b == 0:
         return a, 1, 0
     else:

python-algorithm/algorithm/math/least_common_multiple.py

@@ -1,10 +1,12 @@
 from algorithm.math.greatest_common_divisor import gcd_euclidean
 
 
-def lcm(a: int, b: int) -> int:
+def lcm_with_gcd(a: int, b: int) -> int:
     """
     Find the least common multiple of two numbers.
-    LCM(a,b) = a * b / GCD(a,b)
+    LCM(a, b) = a * b / GCD(a, b)
+    :param a: number1
+    :param b: number2
+    :return: the least common multiple
     """
-
     return a * b // gcd_euclidean(a, b)

python-algorithm/algorithm/math/matrix_multiplication.py

@@ -3,12 +3,12 @@
 
 def multiply_matrix(matrix_a: np.array, matrix_b: np.array) -> np.array:
     """
-    Function that performs matrix multiplication
-
-    return np.dot(matrix_a, matrix_b)
+    Function that performs matrix multiplication.
+    If you use numpy, it is np.dot(matrix_a, matrix_b)
+    :param matrix_a: matrix1
+    :param matrix_b: matrix2
+    :return: the result of matrix multiplication
     """
-
-    # m x n matrix
     m = matrix_a.shape[0]
     n = matrix_b.shape[1]
     matrix_c = np.zeros((m, n))