Merge branch 'master' of https://github.com/TheAlgorithms/Python

Author: cclauss

.github/workflows/autoblack.yml

@@ -11,12 +11,13 @@ jobs:
     steps:
       - uses: actions/checkout@v1  # Use v1, NOT v2
       - uses: actions/setup-python@v2
-      - run: pip install black
+      - run: pip install black isort
       - run: black --check .
       - name: If needed, commit black changes to a new pull request
         if: failure()
         run: |
           black .
+          isort --profile black --recursive .
           git config --global user.name github-actions
           git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'          
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY

.github/workflows/codespell.yml

@@ -13,5 +13,5 @@ jobs:
           SKIP="./.*,./other/dictionary.txt,./other/words,./project_euler/problem_22/p022_names.txt"
           codespell -L ans,fo,hist,iff,secant,tim --skip=$SKIP --quiet-level=2
       - name: Codespell comment
-          if: ${{ failure() }}
-          uses: plettich/python_codespell_action@master
+        if: ${{ failure() }}
+        uses: plettich/python_codespell_action@master

DIRECTORY.md

@@ -205,6 +205,7 @@
   * [Max Non Adjacent Sum](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_non_adjacent_sum.py)
   * [Max Sub Array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
   * [Max Sum Contiguous Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sum_contiguous_subsequence.py)
+  * [Minimum Cost Path](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_cost_path.py)
   * [Minimum Partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
   * [Optimal Binary Search Tree](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/optimal_binary_search_tree.py)
   * [Rod Cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
@@ -230,11 +231,11 @@
   * [Articulation Points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
   * [Basic Graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
   * [Bellman Ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-  * [Bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
   * [Bfs Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
   * [Bidirectional A Star](https://github.com/TheAlgorithms/Python/blob/master/graphs/bidirectional_a_star.py)
   * [Bidirectional Breadth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/bidirectional_breadth_first_search.py)
   * [Breadth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
+  * [Breadth First Search 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search_2.py)
   * [Breadth First Search Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search_shortest_path.py)
   * [Check Bipartite Graph Bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
   * [Check Bipartite Graph Dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
@@ -309,6 +310,7 @@
   * [Scoring Functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
   * [Sequential Minimum Optimization](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sequential_minimum_optimization.py)
   * [Support Vector Machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/support_vector_machines.py)
+  * [Word Frequency Functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/word_frequency_functions.py)
 
 ## Maths
   * [3N Plus 1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n_plus_1.py)
@@ -442,7 +444,9 @@
   * [Integeration By Simpson Approx](https://github.com/TheAlgorithms/Python/blob/master/other/integeration_by_simpson_approx.py)
   * [Largest Subarray Sum](https://github.com/TheAlgorithms/Python/blob/master/other/largest_subarray_sum.py)
   * [Least Recently Used](https://github.com/TheAlgorithms/Python/blob/master/other/least_recently_used.py)
+  * [Lfu Cache](https://github.com/TheAlgorithms/Python/blob/master/other/lfu_cache.py)
   * [Linear Congruential Generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
+  * [Lru Cache](https://github.com/TheAlgorithms/Python/blob/master/other/lru_cache.py)
   * [Magicdiamondpattern](https://github.com/TheAlgorithms/Python/blob/master/other/magicdiamondpattern.py)
   * [Markov Chain](https://github.com/TheAlgorithms/Python/blob/master/other/markov_chain.py)
   * [Nested Brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
@@ -566,6 +570,8 @@
     * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
   * Problem 42
     * [Solution42](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_42/solution42.py)
+  * Problem 47
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_47/sol1.py)
   * Problem 48
     * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
   * Problem 52
@@ -585,7 +591,8 @@
 
 ## Scheduling
   * [First Come First Served](https://github.com/TheAlgorithms/Python/blob/master/scheduling/first_come_first_served.py)
-  * [Shortest Job First Algorithm](https://github.com/TheAlgorithms/Python/blob/master/scheduling/shortest_job_first_algorithm.py)
+  * [Round Robin](https://github.com/TheAlgorithms/Python/blob/master/scheduling/round_robin.py)
+  * [Shortest Job First](https://github.com/TheAlgorithms/Python/blob/master/scheduling/shortest_job_first.py)
 
 ## Searches
   * [Binary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)

ciphers/affine_cipher.py

@@ -102,4 +102,4 @@ def get_random_key():
     import doctest
 
     doctest.testmod()
-    main()
+    # main()

data_structures/binary_tree/avl_tree.py

@@ -204,14 +204,16 @@ def del_node(root, data):
     if root is None:
         return root
     if get_height(root.get_right()) - get_height(root.get_left()) == 2:
-        if get_height(root.get_right().get_right()) > \
-           get_height(root.get_right().get_left()):
+        if get_height(root.get_right().get_right()) > get_height(
+            root.get_right().get_left()
+        ):
             root = left_rotation(root)
         else:
             root = rl_rotation(root)
     elif get_height(root.get_right()) - get_height(root.get_left()) == -2:
-        if get_height(root.get_left().get_left()) > \
-           get_height(root.get_left().get_right()):
+        if get_height(root.get_left().get_left()) > get_height(
+            root.get_left().get_right()
+        ):
             root = right_rotation(root)
         else:
             root = lr_rotation(root)
@@ -253,6 +255,7 @@ class AVLtree:
      2  *
     *************************************
     """
+
     def __init__(self):
         self.root = None
 
@@ -307,6 +310,7 @@ def __str__(self):  # a level traversale, gives a more intuitive look on the tre
 
 def _test():
     import doctest
+
     doctest.testmod()
 
 

dynamic_programming/max_non_adjacent_sum.py

@@ -1,4 +1,4 @@
-# Video Explaination: https://www.youtube.com/watch?v=6w60Zi1NtL8&feature=emb_logo
+# Video Explanation: https://www.youtube.com/watch?v=6w60Zi1NtL8&feature=emb_logo
 
 from typing import List
 

dynamic_programming/minimum_cost_path.py

@@ -0,0 +1,37 @@
+# Youtube Explanation: https://www.youtube.com/watch?v=lBRtnuxg-gU
+
+from typing import List
+
+
+def minimum_cost_path(matrix: List[List[int]]) -> int:
+    """
+    Find the minimum cost traced by all possible paths from top left to bottom right in
+    a given matrix
+
+    >>> minimum_cost_path([[2, 1], [3, 1], [4, 2]])
+    6
+
+    >>> minimum_cost_path([[2, 1, 4], [2, 1, 3], [3, 2, 1]])
+    7
+    """
+
+    # preprocessing the first row
+    for i in range(1, len(matrix[0])):
+        matrix[0][i] += matrix[0][i - 1]
+
+    # preprocessing the first column
+    for i in range(1, len(matrix)):
+        matrix[i][0] += matrix[i - 1][0]
+
+    # updating the path cost for current position
+    for i in range(1, len(matrix)):
+        for j in range(1, len(matrix[0])):
+            matrix[i][j] += min(matrix[i - 1][j], matrix[i][j - 1])
+
+    return matrix[-1][-1]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

graphs/bfs.py renamed to graphs/breadth_first_search_2.py

@@ -1,9 +1,7 @@
 """
-BFS.
-
+https://en.wikipedia.org/wiki/Breadth-first_search
 pseudo-code:
-
-BFS(graph G, start vertex s):
+breadth_first_search(graph G, start vertex s):
 // all nodes initially unexplored
 mark s as explored
 let Q = queue data structure, initialized with s
@@ -13,9 +11,10 @@
         if w unexplored:
             mark w as explored
             add w to Q (at the end)
-
 """
 
+from typing import Set, Dict
+
 G = {
     "A": ["B", "C"],
     "B": ["A", "D", "E"],
@@ -26,13 +25,13 @@
 }
 
 
-def bfs(graph, start):
+def breadth_first_search(graph: Dict, start: str) -> Set[str]:
     """
-    >>> ''.join(sorted(bfs(G, 'A')))
+    >>> ''.join(sorted(breadth_first_search(G, 'A')))
     'ABCDEF'
     """
-    explored, queue = set(), [start]  # collections.deque([start])
-    explored.add(start)
+    explored = {start}
+    queue = [start]
     while queue:
         v = queue.pop(0)  # queue.popleft()
         for w in graph[v]:
@@ -43,4 +42,4 @@ def bfs(graph, start):
 
 
 if __name__ == "__main__":
-    print(bfs(G, "A"))
+    print(breadth_first_search(G, "A"))

graphs/connected_components.py

@@ -5,29 +5,14 @@
 
 """
 
-test_graph_1 = {
-    0: [1, 2],
-    1: [0, 3],
-    2: [0],
-    3: [1],
-    4: [5, 6],
-    5: [4, 6],
-    6: [4, 5],
-}
-
-test_graph_2 = {
-    0: [1, 2, 3],
-    1: [0, 3],
-    2: [0],
-    3: [0, 1],
-    4: [],
-    5: [],
-}
+test_graph_1 = {0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}
+
+test_graph_2 = {0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}
 
 
 def dfs(graph: dict, vert: int, visited: list) -> list:
     """
-    Use depth first search to find all vertexes
+    Use depth first search to find all vertices
     being in the same component as initial vertex
     >>> dfs(test_graph_1, 0, 5 * [False])
     [0, 1, 3, 2]

graphs/gale_shapley_bigraph.py

@@ -0,0 +1,44 @@
+from typing import List
+
+
+def stable_matching(donor_pref: List[int], recipient_pref: List[int]) -> List[int]:
+    """
+    Finds the stable match in any bipartite graph, i.e a pairing where no 2 objects
+    prefer each other over their partner.  The function accepts the preferences of
+    oegan donors and recipients (where both are assigned numbers from 0 to n-1) and
+    returns a list where the index position corresponds to the donor and value at the
+    index is the organ recipient.
+
+    To better understand the algorithm, see also:
+    https://github.com/akashvshroff/Gale_Shapley_Stable_Matching (README).
+    https://www.youtube.com/watch?v=Qcv1IqHWAzg&t=13s (Numberphile YouTube).
+
+    >>> donor_pref = [[0, 1, 3, 2], [0, 2, 3, 1], [1, 0, 2, 3], [0, 3, 1, 2]]
+    >>> recipient_pref = [[3, 1, 2, 0], [3, 1, 0, 2], [0, 3, 1, 2], [1, 0, 3, 2]]
+    >>> print(stable_matching(donor_pref, recipient_pref))
+    [1, 2, 3, 0]
+    """
+    assert len(donor_pref) == len(recipient_pref)
+    n = len(donor_pref)
+    unmatched_donors = list(range(n))
+    donor_record = [-1] * n  # who the donor has donated to
+    rec_record = [-1] * n  # who the recipient has received from
+    num_donations = [0] * n
+    while unmatched_donors:
+        donor = unmatched_donors[0]
+        donor_preference = donor_pref[donor]
+        recipient = donor_preference[num_donations[donor]]
+        num_donations[donor] += 1
+        rec_preference = recipient_pref[recipient]
+        prev_donor = rec_record[recipient]
+        if prev_donor != -1:
+            if rec_preference.index(prev_donor) > rec_preference.index(donor):
+                rec_record[recipient] = donor
+                donor_record[donor] = recipient
+                unmatched_donors.append(prev_donor)
+                unmatched_donors.remove(donor)
+        else:
+            rec_record[recipient] = donor
+            donor_record[donor] = recipient
+            unmatched_donors.remove(donor)
+    return donor_record

graphs/strongly_connected_components.py

@@ -5,22 +5,9 @@
 
 """
 
-test_graph_1 = {
-    0: [2, 3],
-    1: [0],
-    2: [1],
-    3: [4],
-    4: [],
-}
-
-test_graph_2 = {
-    0: [1, 2, 3],
-    1: [2],
-    2: [0],
-    3: [4],
-    4: [5],
-    5: [3],
-}
+test_graph_1 = {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}
+
+test_graph_2 = {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}
 
 
 def topology_sort(graph: dict, vert: int, visited: list) -> list:

greedy_method/test_knapsack.py

@@ -35,9 +35,7 @@ def test_negative_profit_value(self):
         # profit = [10, -20, 30, 40, 50, 60]
         # weight = [2, 4, 6, 8, 10, 12]
         # max_weight = 15
-        self.assertRaisesRegex(
-            ValueError, "Weight can not be negative.",
-        )
+        self.assertRaisesRegex(ValueError, "Weight can not be negative.")
 
     def test_negative_weight_value(self):
         """

machine_learning/k_means_clust.py

@@ -250,7 +250,7 @@ def ReportGenerator(
     df["dummy"] = 1
     numeric_cols = df.select_dtypes(np.number).columns
     report = (
-        df.groupby(["Cluster"])[  # constract report dataframe
+        df.groupby(["Cluster"])[  # construct report dataframe
             numeric_cols
         ]  # group by cluster number
         .agg(
@@ -289,14 +289,14 @@ def ReportGenerator(
 
     clustersize = report[
         (report["Features"] == "dummy") & (report["Type"] == "count")
-    ]  # caclulating size of cluster(count of clientID's)
+    ]  # calculate the size of cluster(count of clientID's)
     clustersize.Type = (
         "ClusterSize"  # rename created cluster df to match report column names
     )
     clustersize.Features = "# of Customers"
     clusterproportion = pd.DataFrame(
         clustersize.iloc[:, 2:].values
-        / clustersize.iloc[:, 2:].values.sum()  # caclulating proportion of cluster
+        / clustersize.iloc[:, 2:].values.sum()  # calculating the proportion of cluster
     )
     clusterproportion[
         "Type"