feat(data structures, puzzles, strings): longest common prefix, number of islands

Author: BrianLusina

datastructures/graphs/disjoint_set/__init__.py

@@ -1,74 +1,5 @@
-class DisjointSetUnion:
-    """A class for the Union-Find (Disjoint Set Union) data structure."""
+from datastructures.sets.union_find.disjoint_set_union import DisjointSetUnion
+from datastructures.sets.union_find.union_find import UnionFind
 
-    def __init__(self, size: int):
-        """Initializes the data structure with 'size' elements, each in its own set."""
-        if size <= 0:
-            raise ValueError("Size must be a positive integer.")
-        self.root = list(range(size))
-        self.rank = [1] * size  # For union by rank
-        self.count = size  # Number of disjoint sets
 
-    def find(self, i: int) -> int:
-        """Finds the representative (root) of the set containing element 'i'."""
-        if self.root[i] == i:
-            return i
-        # Path compression: make all nodes on the path point to the root
-        self.root[i] = self.find(self.root[i])
-        return self.root[i]
-
-    def union(self, i: int, j: int) -> bool:
-        """
-        Merges the sets containing elements 'i' and 'j'.
-        Returns True if a merge occurred, False if they were already in the same set.
-        """
-        root_i = self.find(i)
-        root_j = self.find(j)
-
-        if root_i != root_j:
-            # Union by rank: attach the smaller tree to the larger tree
-            if self.rank[root_i] > self.rank[root_j]:
-                self.root[root_j] = root_i
-            elif self.rank[root_i] < self.rank[root_j]:
-                self.root[root_i] = root_j
-            else:
-                self.root[root_j] = root_i
-                self.rank[root_i] += 1
-
-            self.count -= 1
-            return True
-
-        return False
-
-    def get_count(self) -> int:
-        """Returns the current number of disjoint sets."""
-        return self.count
-
-
-class UnionFind:
-    """A minimal Union-Find data structure with path compression."""
-
-    def __init__(self, size: int):
-        """Initializes the data structure with 'size' elements."""
-        if size <= 0:
-            raise ValueError("Size must be a positive integer.")
-        self.parent = list(range(size))
-
-    def find(self, x: int) -> int:
-        """Finds the representative (root) of the set containing element 'x'."""
-        if self.parent[x] != x:
-            # Path compression
-            self.parent[x] = self.find(self.parent[x])
-        return self.parent[x]
-
-    def union(self, x: int, y: int) -> bool:
-        """
-        Merges the sets containing elements 'x' and 'y'.
-        Returns True if a merge occurred, False if already in same set.
-        """
-        root_x = self.find(x)
-        root_y = self.find(y)
-        if root_x != root_y:
-            self.parent[root_y] = root_x
-            return True
-        return False
+__all__ = ["UnionFind", "DisjointSetUnion"]

datastructures/sets/union_find/__init__.py

@@ -0,0 +1,45 @@
+class DisjointSetUnion:
+    """A class for the Union-Find (Disjoint Set Union) data structure."""
+
+    def __init__(self, size: int):
+        """Initializes the data structure with 'size' elements, each in its own set."""
+        if size <= 0:
+            raise ValueError("Size must be a positive integer.")
+        self.root = list(range(size))
+        self.rank = [1] * size  # For union by rank
+        self.count = size  # Number of disjoint sets
+
+    def find(self, i: int) -> int:
+        """Finds the representative (root) of the set containing element 'i'."""
+        if self.root[i] == i:
+            return i
+        # Path compression: make all nodes on the path point to the root
+        self.root[i] = self.find(self.root[i])
+        return self.root[i]
+
+    def union(self, i: int, j: int) -> bool:
+        """
+        Merges the sets containing elements 'i' and 'j'.
+        Returns True if a merge occurred, False if they were already in the same set.
+        """
+        root_i = self.find(i)
+        root_j = self.find(j)
+
+        if root_i != root_j:
+            # Union by rank: attach the smaller tree to the larger tree
+            if self.rank[root_i] > self.rank[root_j]:
+                self.root[root_j] = root_i
+            elif self.rank[root_i] < self.rank[root_j]:
+                self.root[root_i] = root_j
+            else:
+                self.root[root_j] = root_i
+                self.rank[root_i] += 1
+
+            self.count -= 1
+            return True
+
+        return False
+
+    def get_count(self) -> int:
+        """Returns the current number of disjoint sets."""
+        return self.count

datastructures/sets/union_find/disjoint_set_union.py

@@ -0,0 +1,27 @@
+class UnionFind:
+    """A minimal Union-Find data structure with path compression."""
+
+    def __init__(self, size: int):
+        """Initializes the data structure with 'size' elements."""
+        if size <= 0:
+            raise ValueError("Size must be a positive integer.")
+        self.parent = list(range(size))
+
+    def find(self, x: int) -> int:
+        """Finds the representative (root) of the set containing element 'x'."""
+        if self.parent[x] != x:
+            # Path compression
+            self.parent[x] = self.find(self.parent[x])
+        return self.parent[x]
+
+    def union(self, x: int, y: int) -> bool:
+        """
+        Merges the sets containing elements 'x' and 'y'.
+        Returns True if a merge occurred, False if already in same set.
+        """
+        root_x = self.find(x)
+        root_y = self.find(y)
+        if root_x != root_y:
+            self.parent[root_y] = root_x
+            return True
+        return False

datastructures/sets/union_find/union_find.py

@@ -29,8 +29,8 @@ def insert(self, word: str, index: Optional[int] = None) -> None:
                               ↘
                                e(2) → r(2)
 
-        Index then tracks the earliest index of the word in the original list. So, for the example above, the index of
-        "player" would be 2, not 0.
+        The Index then tracks the earliest index of the word in the original list. So, for the example above, the index
+        of "player" would be 2, not 0.
 
         Parameters:
             word (str): The word to insert

datastructures/trees/trie/trie.py

@@ -78,14 +78,14 @@ def lucky_numbers_simulation(matrix: List[List[int]]) -> List[int]:
 
     row_min = []
     for i in range(row_length):
-        r_min = float('inf')
+        r_min = float("inf")
         for j in range(col_length):
             r_min = min(r_min, matrix[i][j])
         row_min.append(r_min)
 
     col_max = []
     for i in range(col_length):
-        c_max = float('-inf')
+        c_max = float("-inf")
         for j in range(row_length):
             c_max = max(c_max, matrix[j][i])
         col_max.append(c_max)

puzzles/arrays/lucky_numbers_in_a_matrix/__init__.py

@@ -1,7 +1,10 @@
 import unittest
 from typing import List
 from parameterized import parameterized
-from puzzles.arrays.lucky_numbers_in_a_matrix import lucky_numbers, lucky_numbers_simulation
+from puzzles.arrays.lucky_numbers_in_a_matrix import (
+    lucky_numbers,
+    lucky_numbers_simulation,
+)
 
 
 class LuckyNumbersInAMatrixTestCase(unittest.TestCase):
@@ -27,8 +30,8 @@ class LuckyNumbersInAMatrixTestCase(unittest.TestCase):
             ([[30, 20, 10], [40, 50, 60], [70, 80, 90]], [70]),
             ([[5, 1, 9], [10, 8, 2], [7, 3, 6]], []),
             ([[22, 11], [88, 77], [55, 44]], [77]),
-            ([[1,10,4,2],[9,3,8,7],[15,16,17,12]], [12]),
-            ([[7,8],[1,2]], [7]),
+            ([[1, 10, 4, 2], [9, 3, 8, 7], [15, 16, 17, 12]], [12]),
+            ([[7, 8], [1, 2]], [7]),
         ]
     )
     def test_lucky_numbers_in_matrix(
@@ -58,8 +61,8 @@ def test_lucky_numbers_in_matrix(
             ([[30, 20, 10], [40, 50, 60], [70, 80, 90]], [70]),
             ([[5, 1, 9], [10, 8, 2], [7, 3, 6]], []),
             ([[22, 11], [88, 77], [55, 44]], [77]),
-            ([[1,10,4,2],[9,3,8,7],[15,16,17,12]], [12]),
-            ([[7,8],[1,2]], [7]),
+            ([[1, 10, 4, 2], [9, 3, 8, 7], [15, 16, 17, 12]], [12]),
+            ([[7, 8], [1, 2]], [7]),
         ]
     )
     def test_lucky_numbers_in_matrix_simulation(

puzzles/arrays/lucky_numbers_in_a_matrix/test_lucky_numbers_in_a_matrix.py

@@ -1,9 +1,18 @@
 # Number of Islands
 
-Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
+Given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), return the number of islands.
 
-An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume
-all four edges of the grid are all surrounded by water.
+An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. 
+If any '1' cells are connected to each other horizontally or vertically (not diagonally), they form an island
+You may assume all four edges of the grid are all surrounded by water.
+
+Constraints
+
+- 1 <= `grid.length` <= 50
+- 1 <= `grid[i].length` <= 50
+- `grid[i][j]` is either '0' or '1'
+
+## Examples
 
 Example 1:
 
@@ -14,6 +23,7 @@ Input: grid = [
 ["0","0","0","0","0"]
 ]
 Output: 1
+
 Example 2:
 
 Input: grid = [

puzzles/graphs/number_of_islands/README.md

@@ -1,4 +1,5 @@
-from typing import List
+from typing import List, Tuple, Set
+from puzzles.graphs.number_of_islands.union_find import UnionFind
 
 
 def num_of_islands(grid: List[List[str]]) -> int:
@@ -7,26 +8,31 @@ def num_of_islands(grid: List[List[str]]) -> int:
     if len(grid) == 0 or not grid[0]:
         return islands
 
-    visited = set()
+    visited: Set[Tuple[int, int]] = set()
     number_of_rows, number_of_cols = len(grid), len(grid[0])
 
-    def dfs(r: int, c: int):
-        if (
-            r not in range(number_of_rows)
-            or c not in range(number_of_cols)
-            or grid[r][c] == "0"
-            or (r, c) in visited
-        ):
-            return
-
-        visited.add((r, c))
-        # [0, 1] -> move right along column
-        # [0, -1] -> move left along column
-        # [1, 0] -> move down along row
-        # [-1, 0] -> move up along row
-        directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
-        for dr, dc in directions:
-            dfs(r + dr, c + dc)
+    def dfs(start_r: int, start_c: int):
+        stack = [(start_r, start_c)]
+
+        while stack:
+            r, c = stack.pop()
+
+            if (
+                r not in range(number_of_rows)
+                or c not in range(number_of_cols)
+                or grid[r][c] == "0"
+                or (r, c) in visited
+            ):
+                continue
+
+            visited.add((r, c))
+            # [0, 1] -> move right along column
+            # [0, -1] -> move left along column
+            # [1, 0] -> move down along row
+            # [-1, 0] -> move up along row
+            directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+            for dr, dc in directions:
+                stack.append((r + dr, c + dc))
 
     for row in range(number_of_rows):
         for col in range(number_of_cols):
@@ -35,3 +41,25 @@ def dfs(r: int, c: int):
                 dfs(row, col)
 
     return islands
+
+
+def num_islands_union_find(grid: List[List[str]]) -> int:
+    if not grid:
+        return 0
+
+    cols = len(grid[0])
+    rows = len(grid)
+    uf = UnionFind(grid)
+
+    for r in range(rows):
+        for c in range(cols):
+            if grid[r][c] == "1":
+                grid[r][c] = "0"
+
+                if r + 1 < rows and grid[r + 1][c] == "1":
+                    uf.union(r * cols + c, (r + 1) * cols + c)
+                if c + 1 < cols and grid[r][c + 1] == "1":
+                    uf.union(r * cols + c, r * cols + c + 1)
+
+    count = uf.get_count()
+    return count