Merge branch 'master' into fix-exponential-search-empty-list

Author: Dhaylight1

DIRECTORY.md

@@ -110,6 +110,8 @@
 ## [Blockchain](blockchain)
   * [Diophantine Equation](blockchain/diophantine_equation.py)
   * [Merkle Tree](blockchain/merkle_tree.py)
+  * [Proof Of Stake](blockchain/proof_of_stake.py)
+  * [Proof Of Work](blockchain/proof_of_work.py)
   * [Simple Blockchain](blockchain/simple_blockchain.py)
   * [Simple Proof Of Work](blockchain/simple_proof_of_work.py)
 
@@ -638,6 +640,7 @@
   * [Strongly Connected Components](graphs/strongly_connected_components.py)
   * [Tarjans Scc](graphs/tarjans_scc.py)
   * Tests
+    * [Test Graphs Floyd Warshall](graphs/tests/test_graphs_floyd_warshall.py)
     * [Test Johnson](graphs/tests/test_johnson.py)
     * [Test Min Spanning Tree Kruskal](graphs/tests/test_min_spanning_tree_kruskal.py)
     * [Test Min Spanning Tree Prim](graphs/tests/test_min_spanning_tree_prim.py)

blockchain/proof_of_stake.py

@@ -0,0 +1,40 @@
+import random
+
+
+class Validator:
+    def __init__(self, name: str, stake: int) -> None:
+        """
+        Initializes a new validator with a given name and stake.
+
+        Args:
+            name (str): The name of the validator.
+            stake (int): The amount of stake the validator has.
+        """
+        self.name = name
+        self.stake = stake
+
+
+def choose_validator(validators: list[Validator]) -> Validator:
+    """
+    Selects a validator to create the next block based on the weight of their stake.
+
+    The higher the stake, the greater the chance to be selected.
+
+    Args:
+        validators (list[Validator]): A list of Validator objects.
+
+    Returns:
+        Validator: The selected validator based on weighted random selection.
+
+    Example:
+        >>> validators = [Validator("Alice", 50), Validator("Bob", 30)]
+        >>> chosen = choose_validator(validators)
+        >>> isinstance(chosen, Validator)
+        True
+    """
+    total_stake = sum(v.stake for v in validators)
+    weighted_validators = [(v, v.stake / total_stake) for v in validators]
+    selected = random.choices(
+        [v[0] for v in weighted_validators], weights=[v[1] for v in weighted_validators]
+    )
+    return selected[0]

blockchain/proof_of_work.py

@@ -0,0 +1,29 @@
+import hashlib
+
+
+def proof_of_work(difficulty: int) -> int:
+    """
+    Simulates a Proof of Work mining process.
+
+    The miner must find a nonce such that the hash of the nonce starts
+    with a specific number of leading zeros (difficulty).
+
+    Args:
+        difficulty (int): The number of leading zeros required in the hash.
+
+    Returns:
+        int: The nonce value that solves the puzzle.
+
+    Example:
+        >>> result = proof_of_work(2)  # Difficulty of 2 should be fast
+        >>> isinstance(result, int)
+        True
+    """
+    prefix = "0" * difficulty
+    nonce = 0
+
+    while True:
+        hash_result = hashlib.sha256(f"{nonce}".encode()).hexdigest()
+        if hash_result.startswith(prefix):
+            return nonce
+        nonce += 1

graphs/graphs_floyd_warshall.py

@@ -9,10 +9,11 @@ def _print_dist(dist, v) -> None:
     print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
     for i in range(v):
         for j in range(v):
+            end_char = "" if j == v - 1 else "  "
             if dist[i][j] != float("inf"):
-                print(int(dist[i][j]), end="\t")
+                print(int(dist[i][j]), end=end_char)
             else:
-                print("INF", end="\t")
+                print("INF", end=end_char)
         print()
 
 
@@ -31,6 +32,28 @@ def floyd_warshall(graph, v):
     4. The above is repeated for each vertex k in the graph.
     5. Whenever distance[i][j] is given a new minimum value, next vertex[i][j] is
         updated to the next vertex[i][k].
+
+
+    >>> graph = [
+    ...     [0, 3, float('inf')],
+    ...     [2, 0, float('inf')],
+    ...     [float('inf'), 7, 0]
+    ... ]
+
+    >>> expected = [
+    ...     [0, 3, float('inf')],
+    ...     [2, 0, float('inf')],
+    ...     [9, 7, 0]
+    ... ]
+    >>> dist, _ = floyd_warshall(graph, 3)
+    <BLANKLINE>
+    The shortest path matrix using Floyd Warshall algorithm
+    <BLANKLINE>
+    0  3  INF
+    2  0  INF
+    9  7  0
+    >>> dist == expected
+    True
     """
 
     dist = [[float("inf") for _ in range(v)] for _ in range(v)]

graphs/tests/test_graphs_floyd_warshall.py

@@ -0,0 +1,40 @@
+import pytest
+
+from graphs.graphs_floyd_warshall import floyd_warshall
+
+
+def test_no_edges():
+    graph = [
+        [0, float("inf"), float("inf")],
+        [float("inf"), 0, float("inf")],
+        [float("inf"), float("inf"), 0],
+    ]
+    expected = [
+        [0, float("inf"), float("inf")],
+        [float("inf"), 0, float("inf")],
+        [float("inf"), float("inf"), 0],
+    ]
+    dist, _ = floyd_warshall(graph, 3)
+    assert dist == expected
+
+
+def test_with_edges():
+    graph = [[0, 3, float("inf")], [2, 0, float("inf")], [float("inf"), 7, 0]]
+    expected = [[0, 3, float("inf")], [2, 0, float("inf")], [9, 7, 0]]
+    dist, _ = floyd_warshall(graph, 3)
+    assert dist == expected
+
+
+def test_unreachable_vertices():
+    graph = [
+        [0, 1, float("inf")],
+        [float("inf"), 0, 2],
+        [float("inf"), float("inf"), 0],
+    ]
+    expected = [[0, 1, 3], [float("inf"), 0, 2], [float("inf"), float("inf"), 0]]
+    dist, _ = floyd_warshall(graph, 3)
+    assert dist == expected
+
+
+if __name__ == "__main__":
+    pytest.main()

matrix/count_islands_in_matrix.py

@@ -1,15 +1,46 @@
 # An island in matrix is a group of linked areas, all having the same value.
 # This code counts number of islands in a given matrix, with including diagonal
 # connections.
-
-
 class Matrix:  # Public class to implement a graph
+    """This public class represents the 2-Dimensional matrix to count
+    the number of islands.An island is the connected group of 1s,including the top,
+    down, right, left as well as the diagonal connections.
+    >>> matrix1 = Matrix(3, 3, [[1, 1, 0], [0, 1, 0], [1, 0, 1]])
+    >>> matrix1.count_islands()
+    1
+    >>> matrix2 = Matrix(2, 2, [[1, 1], [1, 1]])
+    >>> matrix2.count_islands()
+    1
+    """
+
     def __init__(self, row: int, col: int, graph: list[list[bool]]) -> None:
+        """Initializes the matrix with the given number of rows, columns and matrix.
+        Args:
+            row (int): number of rows in the matrix
+            col (int): number of columns in the matrix
+            graph (list[list[bool]]): 2-D list of 0s and 1s representing the matrix
+        """
         self.ROW = row
         self.COL = col
         self.graph = graph
 
     def is_safe(self, i: int, j: int, visited: list[list[bool]]) -> bool:
+        """This checks if the current cell can be included in the current island.
+        Args:
+            i (int): row index
+            j (int): column index
+            visited (list[list[bool]]): 2D list tracking the visited cells
+        Returns:
+            bool: True if the cell is valid and part of the island
+            (1 for True and ) for False)
+        >>> visited = [[False, False], [False, False]]
+        >>> graph = [[1, 0], [0, 1]]
+        >>> m = Matrix(2, 2, graph)
+        >>> m.is_safe(0, 0, visited)
+        1
+        >>> m.is_safe(0, 1, visited)
+        0
+        """
         return (
             0 <= i < self.ROW
             and 0 <= j < self.COL
@@ -18,6 +49,19 @@ def is_safe(self, i: int, j: int, visited: list[list[bool]]) -> bool:
         )
 
     def diffs(self, i: int, j: int, visited: list[list[bool]]) -> None:
+        """This is the recursive function to mark all the cells visited which
+        are connected to (i, j) indices.
+        Args:
+            i (int): row index
+            j (int): column index
+            visited (list[list[bool]]): 2D list tracking the visited cells
+        >>> visited = [[False, False], [False, False]]
+        >>> graph = [[1, 1], [0, 1]]
+        >>> m = Matrix(2, 2, graph)
+        >>> m.diffs(0, 0, visited)
+        >>> visited
+        [[True, True], [False, True]]
+        """
         # Checking all 8 elements surrounding nth element
         row_nbr = [-1, -1, -1, 0, 0, 1, 1, 1]  # Coordinate order
         col_nbr = [-1, 0, 1, -1, 1, -1, 0, 1]
@@ -27,6 +71,18 @@ def diffs(self, i: int, j: int, visited: list[list[bool]]) -> None:
                 self.diffs(i + row_nbr[k], j + col_nbr[k], visited)
 
     def count_islands(self) -> int:  # And finally, count all islands.
+        """
+        This counts all the islands in the given matrix.
+        Returns:
+            int: the number of islands in the given matrix.
+        Example -
+        >>> mat = Matrix(1, 1, [[1]])
+        >>> mat.count_islands()
+        1
+        >>> mat2 = Matrix(2, 2, [[0, 0], [0, 0]])
+        >>> mat2.count_islands()
+        0
+        """
         visited = [[False for j in range(self.COL)] for i in range(self.ROW)]
         count = 0
         for i in range(self.ROW):

matrix/matrix_class.py

@@ -204,9 +204,11 @@ def cofactors(self) -> Matrix:
         return Matrix(
             [
                 [
-                    self.minors().rows[row][column]
-                    if (row + column) % 2 == 0
-                    else self.minors().rows[row][column] * -1
+                    (
+                        self.minors().rows[row][column]
+                        if (row + column) % 2 == 0
+                        else self.minors().rows[row][column] * -1
+                    )
                     for column in range(self.minors().num_columns)
                 ]
                 for row in range(self.minors().num_rows)

searches/linear_search.py

@@ -55,7 +55,7 @@ def rec_linear_search(sequence: list, low: int, high: int, target: int) -> int:
     -1
     """
     if not (0 <= high < len(sequence) and 0 <= low < len(sequence)):
-        raise Exception("Invalid upper or lower bound!")
+        raise ValueError("Invalid upper or lower bound!")
     if high < low:
         return -1
     if sequence[low] == target: