Normalize string quoting and fix formatting inconsistencies.

nicholasadamou · nicholasadamou · commit a37511dc56a9 · 2025-01-16T19:25:42.000-05:00
Switched all single quotes to double quotes for consistency across the codebase. Added or removed blank lines where appropriate for better readability. Reformatted multi-line strings, list definitions, and function arguments to align with PEP 8 standards.
diff --git a/Binary Search/On Solution Space/koko_eating_bananas.py b/Binary Search/On Solution Space/koko_eating_bananas.py
@@ -4,10 +4,11 @@
 import unittest
 from typing import List
 
+
 def min_eating_speed(piles: List[int], hours: int) -> int:
     piles.sort()
 
-    left =  1
+    left = 1
     right = max(piles)
 
     result = right
@@ -27,6 +28,7 @@ def min_eating_speed(piles: List[int], hours: int) -> int:
 
     return result
 
+
 class Test(unittest.TestCase):
     def test_min_eating_speed(self):
         self.assertEqual(min_eating_speed([1, 4, 3, 2], 9), 2)
diff --git a/Binary Search/Rotated Array/find_minimum_in_rotated_sorted_array.py b/Binary Search/Rotated Array/find_minimum_in_rotated_sorted_array.py
@@ -3,12 +3,13 @@
 import unittest
 from typing import List
 
+
 def find_min(nums: List[int]) -> int:
     n = len(nums)
 
     left = 0
     right = n - 1
-    min_element = float('inf')
+    min_element = float("inf")
 
     while left < right:
         pivot = (left + right) // 2
@@ -21,6 +22,7 @@ def find_min(nums: List[int]) -> int:
 
     return min(min_element, nums[left])
 
+
 class TestFindMin(unittest.TestCase):
     def test_sorted_array(self):
         # Case: Sorted array without rotation
diff --git a/Binary Search/Rotated Array/search_in_rotated_sorted_array.py b/Binary Search/Rotated Array/search_in_rotated_sorted_array.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def search(nums: List[int], target: int) -> int:
     n = len(nums)
 
@@ -28,6 +29,7 @@ def search(nums: List[int], target: int) -> int:
 
     return -1
 
+
 class TestSearchRotatedSortedArray(unittest.TestCase):
     def test_target_in_rotated_array(self):
         nums = [4, 5, 6, 7, 0, 1, 2]
diff --git a/Binary Search/Rotated Array/search_in_rotated_sorted_array_II.py b/Binary Search/Rotated Array/search_in_rotated_sorted_array_II.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def find_min(nums: List[int]) -> int:
     left, right = 0, len(nums) - 1
 
@@ -23,6 +24,7 @@ def find_min(nums: List[int]) -> int:
 
     return nums[left]
 
+
 class TestFindMin(unittest.TestCase):
     def test_example_cases(self):
         # Example cases given in the prompt
diff --git a/Binary Search/Search In Array/binary_search.py b/Binary Search/Search In Array/binary_search.py
@@ -20,6 +20,7 @@
 #     # If target is not present, return -1
 #     return -1
 
+
 def binary_search(nums: List[int], target: int) -> int:
     n = len(nums)
 
@@ -39,6 +40,7 @@ def binary_search(nums: List[int], target: int) -> int:
 
     return -1
 
+
 class Test(unittest.TestCase):
     def test_binary_search(self):
         self.assertEqual(binary_search([-1, 0, 2, 4, 6, 8], 4), 3)
diff --git a/Binary Search/Search In Array/count_negative_numbers_in_a_sorted_matrix.py b/Binary Search/Search In Array/count_negative_numbers_in_a_sorted_matrix.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def count_negatives(grid: List[List[int]]) -> int:
     def count_negatives_in_row(row: List[int]) -> int:
         n = len(row)
@@ -27,8 +28,8 @@ def count_negatives_in_row(row: List[int]) -> int:
 
     return result
 
-class TestCountNegatives(unittest.TestCase):
 
+class TestCountNegatives(unittest.TestCase):
     def test_empty_grid(self):
         # Test case with an empty grid
         grid = []
@@ -61,11 +62,13 @@ def test_multiple_rows_with_negatives(self):
 
     def test_large_matrix(self):
         # Test case with a large matrix for performance validation
-        grid = [[5, 4, 3, 2, -1],
-                [4, 3, 2, -1, -2],
-                [3, 2, -1, -2, -3],
-                [2, -1, -2, -3, -4],
-                [-1, -2, -3, -4, -5]]
+        grid = [
+            [5, 4, 3, 2, -1],
+            [4, 3, 2, -1, -2],
+            [3, 2, -1, -2, -3],
+            [2, -1, -2, -3, -4],
+            [-1, -2, -3, -4, -5],
+        ]
         self.assertEqual(count_negatives(grid), 15)
 
     def test_single_column(self):
diff --git a/Binary Search/Search In Array/find_right_interval.py b/Binary Search/Search In Array/find_right_interval.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List, Tuple
 
+
 def find_right_interval(intervals: List[List[int]]) -> List[int]:
     if not intervals:
         return []
@@ -46,6 +47,7 @@ def search_left(start_intervals: List[Tuple[int, int]], end: int) -> int:
 
     return result
 
+
 class TestFindRightInterval(unittest.TestCase):
     def test_no_intervals(self):
         self.assertEqual(find_right_interval([]), [])
@@ -57,22 +59,15 @@ def test_single_interval_is_its_own_right(self):
         self.assertEqual(find_right_interval([[1, 1]]), [0])
 
     def test_multiple_intervals_no_overlap(self):
-        self.assertEqual(
-            find_right_interval([[1, 2], [3, 4], [5, 6]]), [1, 2, -1]
-        )
+        self.assertEqual(find_right_interval([[1, 2], [3, 4], [5, 6]]), [1, 2, -1])
 
     def test_multiple_intervals_with_overlap(self):
-        self.assertEqual(
-            find_right_interval([[1, 4], [2, 3], [3, 4]]), [-1, 2, -1]
-        )
+        self.assertEqual(find_right_interval([[1, 4], [2, 3], [3, 4]]), [-1, 2, -1])
 
     def test_multiple_intervals_with_same_start(self):
-        self.assertEqual(
-            find_right_interval([[1, 2], [1, 3], [3, 4]]), [2, 2, -1]
-        )
+        self.assertEqual(find_right_interval([[1, 2], [1, 3], [3, 4]]), [2, 2, -1])
 
     def test_large_intervals(self):
         self.assertEqual(
-            find_right_interval([[1, 1000], [500, 1500], [1001, 2000]]),
-            [2, -1, -1]
+            find_right_interval([[1, 1000], [500, 1500], [1001, 2000]]), [2, -1, -1]
         )
diff --git a/Binary Search/Search In Array/find_smallest_letter_greater_than_target.py b/Binary Search/Search In Array/find_smallest_letter_greater_than_target.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def next_letter_greater(letters: List[str], target: str) -> str:
     if not letters:
         raise ValueError("The input list 'letters' cannot be empty.")
@@ -22,35 +23,36 @@ def next_letter_greater(letters: List[str], target: str) -> str:
 
     return letters[left % n]
 
+
 class TestNextLetterGreater(unittest.TestCase):
     def test_single_element(self):
-        self.assertEqual(next_letter_greater(['c'], 'a'), 'c')
-        self.assertEqual(next_letter_greater(['c'], 'c'), 'c')
+        self.assertEqual(next_letter_greater(["c"], "a"), "c")
+        self.assertEqual(next_letter_greater(["c"], "c"), "c")
 
     def test_basic_cases(self):
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'a'), 'c')
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'c'), 'f')
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'd'), 'f')
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'g'), 'j')
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'j'), 'c')
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "a"), "c")
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "c"), "f")
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "d"), "f")
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "g"), "j")
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "j"), "c")
 
     def test_wrap_around(self):
-        self.assertEqual(next_letter_greater(['c', 'f', 'j'], 'k'), 'c')
+        self.assertEqual(next_letter_greater(["c", "f", "j"], "k"), "c")
 
     def test_duplicates(self):
-        self.assertEqual(next_letter_greater(['c', 'c', 'f', 'f', 'j', 'j'], 'a'), 'c')
-        self.assertEqual(next_letter_greater(['c', 'c', 'f', 'f', 'j', 'j'], 'c'), 'f')
-        self.assertEqual(next_letter_greater(['c', 'c', 'f', 'f', 'j', 'j'], 'f'), 'j')
-        self.assertEqual(next_letter_greater(['c', 'c', 'f', 'f', 'j', 'j'], 'j'), 'c')
+        self.assertEqual(next_letter_greater(["c", "c", "f", "f", "j", "j"], "a"), "c")
+        self.assertEqual(next_letter_greater(["c", "c", "f", "f", "j", "j"], "c"), "f")
+        self.assertEqual(next_letter_greater(["c", "c", "f", "f", "j", "j"], "f"), "j")
+        self.assertEqual(next_letter_greater(["c", "c", "f", "f", "j", "j"], "j"), "c")
 
     def test_large_list(self):
-        letters = ['a', 'b', 'c', 'd', 'e']
-        self.assertEqual(next_letter_greater(letters, 'c'), 'd')
-        self.assertEqual(next_letter_greater(letters, 'e'), 'a')
+        letters = ["a", "b", "c", "d", "e"]
+        self.assertEqual(next_letter_greater(letters, "c"), "d")
+        self.assertEqual(next_letter_greater(letters, "e"), "a")
 
     def test_edge_cases(self):
         with self.assertRaises(ValueError):
-            next_letter_greater([], 'a')
+            next_letter_greater([], "a")
 
     def test_nonexistent_target(self):
-        self.assertEqual(next_letter_greater(['a', 'b', 'd', 'e'], 'c'), 'd')
+        self.assertEqual(next_letter_greater(["a", "b", "d", "e"], "c"), "d")
diff --git a/Binary Search/Search In Array/first_position_and_last_position_of_element_in_sorted_array.py b/Binary Search/Search In Array/first_position_and_last_position_of_element_in_sorted_array.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def search_range(nums: List[int], target: int) -> List[int]:
     n = len(nums)
 
@@ -39,14 +40,15 @@ def find_right_index(nums: List[int], target: int) -> int:
 
     # Make sure that the target is in range
     if (
-        left_index <= right_index < n and
-        nums[left_index] == target and
-        nums[right_index] == target
+        left_index <= right_index < n
+        and nums[left_index] == target
+        and nums[right_index] == target
     ):
         return [left_index, right_index]
 
     return [-1, -1]
 
+
 class TestSearchRange(unittest.TestCase):
     def test_multiple_occurrences(self):
         nums = [5, 7, 7, 8, 8, 10]
diff --git a/Binary Search/Search In Array/search_insert_position.py b/Binary Search/Search In Array/search_insert_position.py
@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def search_left(nums: List[int], target: int) -> int:
     n = len(nums)
 
@@ -22,6 +23,7 @@ def search_left(nums: List[int], target: int) -> int:
 
     return left
 
+
 class TestSearchLeft(unittest.TestCase):
     def test_target_found(self):
         self.assertEqual(search_left([1, 3, 5, 6], 5), 2)
diff --git a/Binary Search/Search In Array/snapshot_array.py b/Binary Search/Search In Array/snapshot_array.py
@@ -3,11 +3,13 @@
 import unittest
 from collections import defaultdict
 
-class SnapshotArray:
 
+class SnapshotArray:
     def __init__(self, _: int):
         self.snap_id = 0
-        self.history = defaultdict(lambda: [(0, 0)])  # Default history with initial (snap_id, value)
+        self.history = defaultdict(
+            lambda: [(0, 0)]
+        )  # Default history with initial (snap_id, value)
 
     def set(self, index: int, value: int) -> None:
         # Fetch the last recorded snap_id for the given index
@@ -40,13 +42,18 @@ def get(self, index: int, snap_id: int) -> int:
             else:
                 right = mid - 1
 
-        return snaps[right][1]  # The value corresponding to the largest snap_id ≤ the requested snap_id
+        return snaps[right][
+            1
+        ]  # The value corresponding to the largest snap_id ≤ the requested snap_id
+
 
 class TestSnapshotArray(unittest.TestCase):
     def test_initialization(self):
         # Test that the SnapshotArray initializes without errors and the default history is correct.
         obj = SnapshotArray(5)
-        for i in range(5):  # Check that every index initializes with a default value of 0
+        for i in range(
+            5
+        ):  # Check that every index initializes with a default value of 0
             self.assertEqual(obj.get(i, 0), 0)
 
     def test_set_and_get_before_snap(self):
@@ -128,4 +135,6 @@ def test_large_snapshots(self):
         for i in range(1000):
             obj.set(0, i)
             snap_id = obj.snap()
-            self.assertEqual(obj.get(0, snap_id), i)  # Value should match at each snapshot
+            self.assertEqual(
+                obj.get(0, snap_id), i
+            )  # Value should match at each snapshot
diff --git a/Binary Search/Search In Array/time_based_key_value_store.py b/Binary Search/Search In Array/time_based_key_value_store.py
@@ -6,7 +6,6 @@
 
 
 class TimeMap:
-
     def __init__(self):
         self.store = defaultdict(list)
 
@@ -87,7 +86,9 @@ def test_multiple_keys(self):
 
         self.assertEqual(self.time_map.get("foo", 1), "bar")
         self.assertEqual(self.time_map.get("baz", 2), "qux")
-        self.assertEqual(self.time_map.get("baz", 1), "")  # baz doesn't have a value at or before 1
+        self.assertEqual(
+            self.time_map.get("baz", 1), ""
+        )  # baz doesn't have a value at or before 1
 
     def test_non_chronological_timestamps(self):
         """Test if the function works regardless of insertion order."""
@@ -104,7 +105,15 @@ def test_early_and_large_timestamps(self):
         self.time_map.set("foo", "late", 100000)
 
         self.assertEqual(self.time_map.get("foo", 0), "")  # no value at 0
-        self.assertEqual(self.time_map.get("foo", 1), "early")  # exact match at earliest
-        self.assertEqual(self.time_map.get("foo", 99999), "early")  # closest before 100000
-        self.assertEqual(self.time_map.get("foo", 100000), "late")  # exact match at 100000
-        self.assertEqual(self.time_map.get("foo", 100001), "late")  # closest after 100000
+        self.assertEqual(
+            self.time_map.get("foo", 1), "early"
+        )  # exact match at earliest
+        self.assertEqual(
+            self.time_map.get("foo", 99999), "early"
+        )  # closest before 100000
+        self.assertEqual(
+            self.time_map.get("foo", 100000), "late"
+        )  # exact match at 100000
+        self.assertEqual(
+            self.time_map.get("foo", 100001), "late"
+        )  # closest after 100000
diff --git a/Binary Search/Standard Search/find_the_index_of_the_larger_integer.py b/Binary Search/Standard Search/find_the_index_of_the_larger_integer.py
diff --git a/Binary Search/Standard Search/first_bad_version.py b/Binary Search/Standard Search/first_bad_version.py
diff --git a/Binary Search/Standard Search/guess_number_higher_or_lower.py b/Binary Search/Standard Search/guess_number_higher_or_lower.py
diff --git a/Binary Search/Standard Search/search_a_2d_matrix.py b/Binary Search/Standard Search/search_a_2d_matrix.py
diff --git a/Binary Search/Standard Search/search_in_a_sorted_array_of_unknown_size.py b/Binary Search/Standard Search/search_in_a_sorted_array_of_unknown_size.py
diff --git a/Binary Search/Tricky Invariant/peak_index_in_mountain_array.py b/Binary Search/Tricky Invariant/peak_index_in_mountain_array.py
