Merge branch 'TheAlgorithms:master' into mypy-fix-trie

Author: archaengel

CONTRIBUTING.md

@@ -53,7 +53,7 @@ Algorithms in this repo should not be how-to examples for existing Python packag
 Use [pre-commit](https://pre-commit.com/#installation) to automatically format your code to match our coding style:
 
 ```bash
-python3 -m pip install pre-commit  # required only once
+python3 -m pip install pre-commit  # only required the first time
 pre-commit install
 ```
 That's it! The plugin will run every time you commit any changes. If there are any errors found during the run, fix them and commit those changes. You can even run the plugin manually on all files:

DIRECTORY.md

@@ -514,6 +514,7 @@
   * [Sum Of Arithmetic Series](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_arithmetic_series.py)
   * [Sum Of Digits](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_digits.py)
   * [Sum Of Geometric Progression](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_geometric_progression.py)
+  * [Sylvester Sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/sylvester_sequence.py)
   * [Test Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
   * [Trapezoidal Rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
   * [Triplet Sum](https://github.com/TheAlgorithms/Python/blob/master/maths/triplet_sum.py)
@@ -931,7 +932,6 @@
   * [Reverse Letters](https://github.com/TheAlgorithms/Python/blob/master/strings/reverse_letters.py)
   * [Reverse Words](https://github.com/TheAlgorithms/Python/blob/master/strings/reverse_words.py)
   * [Split](https://github.com/TheAlgorithms/Python/blob/master/strings/split.py)
-  * [Swap Case](https://github.com/TheAlgorithms/Python/blob/master/strings/swap_case.py)
   * [Upper](https://github.com/TheAlgorithms/Python/blob/master/strings/upper.py)
   * [Word Occurrence](https://github.com/TheAlgorithms/Python/blob/master/strings/word_occurrence.py)
   * [Word Patterns](https://github.com/TheAlgorithms/Python/blob/master/strings/word_patterns.py)

data_structures/disjoint_set/disjoint_set.py

@@ -1,27 +1,29 @@
 """
-    disjoint set
+    Disjoint set.
     Reference: https://en.wikipedia.org/wiki/Disjoint-set_data_structure
 """
 
 
 class Node:
-    def __init__(self, data):
+    def __init__(self, data: int) -> None:
         self.data = data
+        self.rank: int
+        self.parent: Node
 
 
-def make_set(x):
+def make_set(x: Node) -> None:
     """
-    make x as a set.
+    Make x as a set.
     """
     # rank is the distance from x to its' parent
     # root's rank is 0
     x.rank = 0
     x.parent = x
 
 
-def union_set(x, y):
+def union_set(x: Node, y: Node) -> None:
     """
-    union two sets.
+    Union of two sets.
     set with bigger rank should be parent, so that the
     disjoint set tree will be more flat.
     """
@@ -37,9 +39,9 @@ def union_set(x, y):
             y.rank += 1
 
 
-def find_set(x):
+def find_set(x: Node) -> Node:
     """
-    return the parent of x
+    Return the parent of x
     """
     if x != x.parent:
         x.parent = find_set(x.parent)
@@ -57,7 +59,7 @@ def find_python_set(node: Node) -> set:
     raise ValueError(f"{node.data} is not in {sets}")
 
 
-def test_disjoint_set():
+def test_disjoint_set() -> None:
     """
     >>> test_disjoint_set()
     """

data_structures/linked_list/__init__.py

@@ -6,7 +6,7 @@
     - Last node: points to null
 """
 
-from typing import Any
+from typing import Any, Optional
 
 
 class Node:
@@ -17,15 +17,18 @@ def __init__(self, item: Any, next: Any) -> None:
 
 class LinkedList:
     def __init__(self) -> None:
-        self.head = None
+        self.head: Optional[Node] = None
         self.size = 0
 
     def add(self, item: Any) -> None:
         self.head = Node(item, self.head)
         self.size += 1
 
     def remove(self) -> Any:
-        if self.is_empty():
+        # Switched 'self.is_empty()' to 'self.head is None'
+        # because mypy was considering the possibility that 'self.head'
+        # can be None in below else part and giving error
+        if self.head is None:
             return None
         else:
             item = self.head.item
@@ -50,7 +53,7 @@ def __str__(self) -> str:
         else:
             iterate = self.head
             item_str = ""
-            item_list = []
+            item_list: list[str] = []
             while iterate:
                 item_list.append(str(iterate.item))
                 iterate = iterate.next

data_structures/linked_list/circular_linked_list.py

@@ -1,18 +1,18 @@
-from typing import Any
+from typing import Any, Iterator, Optional
 
 
 class Node:
     def __init__(self, data: Any):
-        self.data = data
-        self.next = None
+        self.data: Any = data
+        self.next: Optional[Node] = None
 
 
 class CircularLinkedList:
     def __init__(self):
         self.head = None
         self.tail = None
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         node = self.head
         while self.head:
             yield node.data
@@ -54,10 +54,10 @@ def insert_nth(self, index: int, data: Any) -> None:
     def delete_front(self):
         return self.delete_nth(0)
 
-    def delete_tail(self) -> None:
+    def delete_tail(self) -> Any:
         return self.delete_nth(len(self) - 1)
 
-    def delete_nth(self, index: int = 0):
+    def delete_nth(self, index: int = 0) -> Any:
         if not 0 <= index < len(self):
             raise IndexError("list index out of range.")
         delete_node = self.head
@@ -76,7 +76,7 @@ def delete_nth(self, index: int = 0):
                 self.tail = temp
         return delete_node.data
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return len(self) == 0
 
 

data_structures/linked_list/has_loop.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Optional
 
 
 class ContainsLoopError(Exception):
@@ -7,8 +7,8 @@ class ContainsLoopError(Exception):
 
 class Node:
     def __init__(self, data: Any) -> None:
-        self.data = data
-        self.next_node = None
+        self.data: Any = data
+        self.next_node: Optional[Node] = None
 
     def __iter__(self):
         node = self

data_structures/linked_list/middle_element_of_linked_list.py

@@ -1,5 +1,8 @@
+from typing import Optional
+
+
 class Node:
-    def __init__(self, data: int) -> int:
+    def __init__(self, data: int) -> None:
         self.data = data
         self.next = None
 
@@ -14,7 +17,7 @@ def push(self, new_data: int) -> int:
         self.head = new_node
         return self.head.data
 
-    def middle_element(self) -> int:
+    def middle_element(self) -> Optional[int]:
         """
         >>> link = LinkedList()
         >>> link.middle_element()
@@ -54,6 +57,7 @@ def middle_element(self) -> int:
             return slow_pointer.data
         else:
             print("No element found.")
+            return None
 
 
 if __name__ == "__main__":

data_structures/linked_list/skip_list.py

@@ -5,14 +5,14 @@
 from __future__ import annotations
 
 from random import random
-from typing import Generic, TypeVar
+from typing import Generic, Optional, TypeVar, Union
 
 KT = TypeVar("KT")
 VT = TypeVar("VT")
 
 
 class Node(Generic[KT, VT]):
-    def __init__(self, key: KT, value: VT):
+    def __init__(self, key: Union[KT, str] = "root", value: Optional[VT] = None):
         self.key = key
         self.value = value
         self.forward: list[Node[KT, VT]] = []
@@ -49,7 +49,7 @@ def level(self) -> int:
 
 class SkipList(Generic[KT, VT]):
     def __init__(self, p: float = 0.5, max_level: int = 16):
-        self.head = Node("root", None)
+        self.head: Node[KT, VT] = Node[KT, VT]()
         self.level = 0
         self.p = p
         self.max_level = max_level

divide_and_conquer/inversions.py

@@ -2,31 +2,25 @@
 Given an array-like data structure A[1..n], how many pairs
 (i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are
 called inversions. Counting the number of such inversions in an array-like
-object is the important. Among other things, counting inversions  can help
-us determine how close a given array is to being sorted
-
+object is the important. Among other things, counting inversions can help
+us determine how close a given array is to being sorted.
 In this implementation, I provide two algorithms, a divide-and-conquer
 algorithm which runs in nlogn and the brute-force n^2 algorithm.
-
 """
 
 
 def count_inversions_bf(arr):
     """
     Counts the number of inversions using a a naive brute-force algorithm
-
     Parameters
     ----------
     arr: arr: array-like, the list containing the items for which the number
     of inversions is desired. The elements of `arr` must be comparable.
-
     Returns
     -------
     num_inversions: The total number of inversions in `arr`
-
     Examples
     ---------
-
      >>> count_inversions_bf([1, 4, 2, 4, 1])
      4
      >>> count_inversions_bf([1, 1, 2, 4, 4])
@@ -49,20 +43,16 @@ def count_inversions_bf(arr):
 def count_inversions_recursive(arr):
     """
     Counts the number of inversions using a divide-and-conquer algorithm
-
     Parameters
     -----------
     arr: array-like, the list containing the items for which the number
     of inversions is desired. The elements of `arr` must be comparable.
-
     Returns
     -------
     C: a sorted copy of `arr`.
     num_inversions: int, the total number of inversions in 'arr'
-
     Examples
     --------
-
     >>> count_inversions_recursive([1, 4, 2, 4, 1])
     ([1, 1, 2, 4, 4], 4)
     >>> count_inversions_recursive([1, 1, 2, 4, 4])
@@ -72,40 +62,34 @@ def count_inversions_recursive(arr):
     """
     if len(arr) <= 1:
         return arr, 0
-    else:
-        mid = len(arr) // 2
-        P = arr[0:mid]
-        Q = arr[mid:]
+    mid = len(arr) // 2
+    P = arr[0:mid]
+    Q = arr[mid:]
 
-        A, inversion_p = count_inversions_recursive(P)
-        B, inversions_q = count_inversions_recursive(Q)
-        C, cross_inversions = _count_cross_inversions(A, B)
+    A, inversion_p = count_inversions_recursive(P)
+    B, inversions_q = count_inversions_recursive(Q)
+    C, cross_inversions = _count_cross_inversions(A, B)
 
-        num_inversions = inversion_p + inversions_q + cross_inversions
-        return C, num_inversions
+    num_inversions = inversion_p + inversions_q + cross_inversions
+    return C, num_inversions
 
 
 def _count_cross_inversions(P, Q):
     """
     Counts the inversions across two sorted arrays.
     And combine the two arrays into one sorted array
-
     For all 1<= i<=len(P) and for all 1 <= j <= len(Q),
     if P[i] > Q[j], then (i, j) is a cross inversion
-
     Parameters
     ----------
     P: array-like, sorted in non-decreasing order
     Q: array-like, sorted in non-decreasing order
-
     Returns
     ------
     R: array-like, a sorted array of the elements of `P` and `Q`
     num_inversion: int, the number of inversions across `P` and `Q`
-
     Examples
     --------
-
     >>> _count_cross_inversions([1, 2, 3], [0, 2, 5])
     ([0, 1, 2, 2, 3, 5], 4)
     >>> _count_cross_inversions([1, 2, 3], [3, 4, 5])