Normalize string quoting and fix formatting inconsistencies.

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.

Author: nicholasadamou

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)

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

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]

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

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)

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):

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]
         )

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")

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]

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)

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

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