Add binary search and stack-related algorithms

Introduce binary search-based solutions for common problems like searching in arrays, 2D matrices, and optimization problems. Additionally, implement stack-based solutions for tasks such as daily temperature calculation, largest rectangle in a histogram, and car fleet determination, each supplemented with unit tests.

Author: nicholasadamou

Arrays & Hashing/top_k_frequent_elements.py

@@ -5,6 +5,15 @@
 from typing import List
 from collections import Counter
 
+# The nlargest function allows you to find the k largest elements
+# from an iterable based on a specified key function.
+#
+# def top_k_frequent(nums: List[int], k: int) -> List[int]:
+#     counts = Counter(nums)
+#
+#     # Use heapq.nlargest to get the k elements with the highest counts
+#     return heapq.nlargest(k, counts.keys(), key=counts.get)
+
 def top_k_frequent(nums: List[int], k: int) -> List[int]:
     n = len(nums)
 

Binary Search/__init__.py

@@ -0,0 +1,45 @@
+# https://neetcode.io/problems/binary-search
+
+import unittest
+from typing import List
+
+# Python has a builtin binary search function: 'bisect_left'.
+# The bisect_left function from Python's bisect module is used
+# to find the insertion point for an element in a sorted list to
+# maintain sorted order.
+#
+# from bisect import bisect_left
+# def binary_search(nums: List[int], target: int) -> int:
+#     # Find the index where target should be inserted
+#     index = bisect_left(nums, target)
+#
+#     # Check if the target is actually present at the found index
+#     if index != len(nums) and nums[index] == target:
+#         return index
+#
+#     # If target is not present, return -1
+#     return -1
+
+def binary_search(nums: List[int], target: int) -> int:
+    n = len(nums)
+
+    left = 0
+    right = n - 1
+
+    while left <= right:
+        mid = (left + right) // 2
+
+        if nums[mid] == target:
+            return mid
+
+        if nums[mid] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+
+    return -1
+
+class Test(unittest.TestCase):
+    def test_binary_search(self):
+        self.assertEqual(binary_search([-1, 0, 2, 4, 6, 8], 4), 3)
+        self.assertEqual(binary_search([-1, 0, 2, 4, 6, 8], 3), -1)

Binary Search/binary_search.py

@@ -0,0 +1,31 @@
+# https://neetcode.io/problems/eating-bananas
+import math
+import unittest
+from typing import List
+
+def min_eating_speed(piles: List[int], hours: int) -> int:
+    piles.sort()
+
+    left =  1
+    right = max(piles)
+    result = right
+
+    while left < right:
+        k = (left + right) // 2
+
+        total_time = 0
+        for pile in piles:
+            total_time += math.ceil(float(pile) / k)
+
+        if total_time <= hours:
+            result = k
+            right = k - 1
+        else:
+            left = k + 1
+
+    return result
+
+class Test(unittest.TestCase):
+    def test_min_eating_speed(self):
+        self.assertEqual(min_eating_speed([1, 4, 3, 2], 9), 2)
+        self.assertEqual(min_eating_speed([25, 10, 23, 4], 4), 25)

Binary Search/koko_eating_bananas.py

@@ -0,0 +1,51 @@
+# https://neetcode.io/problems/search-2d-matrix
+
+import unittest
+from typing import List
+
+# 'bisect_left' can be used here, but requires flattening the matrix first
+# from bisect import bisect_left
+#
+# def search_matrix(matrix: List[List[int]], target: int) -> bool:
+#     if not matrix or not matrix[0]:
+#         return False
+#
+#     # Flatten the matrix
+#     flat_list = [element for row in matrix for element in row]
+#
+#     # Use bisect_left to find the insertion point
+#     index = bisect_left(flat_list, target)
+#
+#     # Check if the target is actually at the found index
+#     return index < len(flat_list) and flat_list[index] == target
+
+def search_matrix(matrix: List[List[int]], target: int) -> bool:
+    n = len(matrix)
+    m = len(matrix[0])
+
+    rows = n
+    cols = m
+
+    left = 0
+    right = (rows * cols) - 1
+
+    while left <= right:
+        mid = (left + right) // 2
+
+        row = mid // rows
+        col = mid // cols
+
+        if matrix[row][col] == target:
+            return True
+
+        if matrix[row][col] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+
+    return False
+
+class Test(unittest.TestCase):
+    def test_search_matrix(self):
+        self.assertTrue(search_matrix([[1, 2, 4, 8],[10, 11, 12, 13],[14, 20, 30, 40]], 10))
+        self.assertFalse(search_matrix([[1, 2, 4, 8],[10, 11, 12, 13],[14, 20, 30, 40]], 15))

Binary Search/search_a_2d_matrix.py

@@ -0,0 +1,38 @@
+# https://neetcode.io/problems/car-fleet
+
+import unittest
+from typing import List
+
+def car_fleet(target: int, positions: List[int], speeds: List[int]) -> int:
+    # Create a list of tuples where each tuple contains a car's position and speed.
+    cars = [(position, speed) for position, speed in zip(positions, speeds)]
+
+    # Sort the cars by their starting positions in descending order.
+    # This ensures that we process cars starting closest to the target first.
+    # A car can only form a fleet with another car that is ahead of it,
+    # so sorting by descending position helps in determining if a car will
+    # catch up to another car in front of it.
+    cars.sort(reverse=True)
+
+    # Initialize a stack to keep track of the time each car fleet takes to reach the target.
+    stack = []
+
+    for position, speed in cars:
+        # Calculate the time it takes for the current car to reach the target.
+        time_to_target = (target - position) / speed
+        # Push the time to the stack, representing a new fleet or an existing fleet's time.
+        stack.append(time_to_target)
+
+        # Check if the current car can catch up to the fleet in front of it.
+        # If the current car's time is less than or equal to the fleet's time in front,
+        # it means it will merge into the same fleet, so we remove it from the stack.
+        if len(stack) >= 2 and stack[-1] <= stack[-2]:
+            stack.pop()
+
+    # The number of distinct times in the stack represents the number of car fleets.
+    return len(stack)
+
+class Test(unittest.TestCase):
+    def test_car_fleet(self):
+        self.assertEqual(car_fleet(10, [1, 4], [3, 2]), 1)
+        self.assertEqual(car_fleet(10, [4, 1, 0, 7], [2, 2, 1, 1]), 3)

Stack/car_fleet.py

@@ -0,0 +1,23 @@
+# https://neetcode.io/problems/daily-temperatures
+
+import unittest
+from typing import List
+
+def daily_temperatures(temperatures: List[int]) -> List[int]:
+    n = len(temperatures)
+    result = [0] * n
+    seen_temperatures = [] # (temperature, index)
+
+    for index, temperature in enumerate(temperatures):
+        while seen_temperatures and temperature > seen_temperatures[-1][0]:
+            seen_temperature, seen_index = seen_temperatures.pop()
+            result[seen_index] = index - seen_index
+
+        seen_temperatures.append((temperature, index))
+
+    return result
+
+class Test(unittest.TestCase):
+    def test_daily_temperatures(self):
+        self.assertEqual(daily_temperatures([30, 38, 30, 36, 35, 40, 28]), [1, 4, 1, 2, 1, 0, 0])
+        self.assertEqual(daily_temperatures([22, 21, 20]), [0, 0, 0])

Stack/daily_temperatures.py

@@ -0,0 +1,37 @@
+# https://neetcode.io/problems/largest-rectangle-in-histogram
+
+import unittest
+from typing import List
+
+def largest_rectangle_area(heights: List[int]) -> int:
+    num_bars = len(heights)
+    stack = []  # This stack will store tuples of (start_index, bar_height)
+    max_area = 0  # Variable to keep track of the maximum area found
+
+    for current_index, current_height in enumerate(heights):
+        start_index = current_index  # Start index for the current bar
+
+        # While stack is not empty and the current bar height is less
+        # than the height of the bar at the top of the stack
+        while stack and stack[-1][1] > current_height:
+            popped_index, popped_height = stack.pop()  # Pop the top of the stack
+
+            # Calculate the area with the popped height as the smallest height
+            max_area = max(max_area, popped_height * (current_index - popped_index))
+
+            start_index = popped_index  # Update start index to the popped index
+
+        # Push the current bar onto the stack with its start index
+        stack.append((start_index, current_height))
+
+    # After processing all bars, compute area for remaining bars in the stack
+    for start_index, bar_height in stack:
+        # Calculate area with the remaining heights in the stack
+        max_area = max(max_area, bar_height * (num_bars - start_index))
+
+    return max_area
+
+class Test(unittest.TestCase):
+    def test_largest_rectangle_area(self):
+        self.assertEqual(largest_rectangle_area([7, 1, 7, 2, 2, 4]), 8)
+        self.assertEqual(largest_rectangle_area([1, 3, 7]), 7)