fix: binary search logic and clean formatting

Author: tusharynayaka

searches/binary_search.py

@@ -126,14 +126,6 @@ def insort_left(
     True
     >>> item is sorted_collection[2]
     False
-    >>> sorted_collection = [0, 5, 7, 10, 15]
-    >>> insort_left(sorted_collection, 20)
-    >>> sorted_collection
-    [0, 5, 7, 10, 15, 20]
-    >>> sorted_collection = [0, 5, 7, 10, 15]
-    >>> insort_left(sorted_collection, 15, 1, 3)
-    >>> sorted_collection
-    [0, 5, 7, 15, 10, 15]
     """
     sorted_collection.insert(bisect_left(sorted_collection, item, lo, hi), item)
 
@@ -157,23 +149,6 @@ def insort_right(
     >>> insort_right(sorted_collection, 6)
     >>> sorted_collection
     [0, 5, 6, 7, 10, 15]
-    >>> sorted_collection = [(0, 0), (5, 5), (7, 7), (10, 10), (15, 15)]
-    >>> item = (5, 5)
-    >>> insort_right(sorted_collection, item)
-    >>> sorted_collection
-    [(0, 0), (5, 5), (5, 5), (7, 7), (10, 10), (15, 15)]
-    >>> item is sorted_collection[1]
-    False
-    >>> item is sorted_collection[2]
-    True
-    >>> sorted_collection = [0, 5, 7, 10, 15]
-    >>> insort_right(sorted_collection, 20)
-    >>> sorted_collection
-    [0, 5, 7, 10, 15, 20]
-    >>> sorted_collection = [0, 5, 7, 10, 15]
-    >>> insort_right(sorted_collection, 15, 1, 3)
-    >>> sorted_collection
-    [0, 5, 7, 15, 10, 15]
     """
     sorted_collection.insert(bisect_right(sorted_collection, item, lo, hi), item)
 
@@ -182,9 +157,6 @@ def binary_search(sorted_collection: list[int], item: int) -> int:
     """Pure implementation of a binary search algorithm in Python.
     Finds the first occurrence of the item.
 
-    Be careful collection must be ascending sorted otherwise, the result will be
-    unpredictable
-
     :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of the first found item or -1 if the item is not found
@@ -194,10 +166,6 @@ def binary_search(sorted_collection: list[int], item: int) -> int:
     0
     >>> binary_search([0, 5, 7, 10, 15], 15)
     4
-    >>> binary_search([0, 5, 7, 10, 15], 5)
-    1
-    >>> binary_search([0, 5, 7, 10, 15], 6)
-    -1
     >>> binary_search([1, 2, 2, 2, 3], 2)
     1
     """
@@ -212,7 +180,7 @@ def binary_search(sorted_collection: list[int], item: int) -> int:
         current_item = sorted_collection[midpoint]
         if current_item == item:
             result = midpoint
-            right = midpoint - 1  # Search left for first occurrence
+            right = midpoint - 1
         elif item < current_item:
             right = midpoint - 1
         else:
@@ -221,25 +189,7 @@ def binary_search(sorted_collection: list[int], item: int) -> int:
 
 
 def binary_search_std_lib(sorted_collection: list[int], item: int) -> int:
-    """Pure implementation of a binary search algorithm in Python using stdlib
-
-    Be careful collection must be ascending sorted otherwise, the result will be
-    unpredictable
-
-    :param sorted_collection: some ascending sorted collection with comparable items
-    :param item: item value to search
-    :return: index of the found item or -1 if the item is not found
-
-    Examples:
-    >>> binary_search_std_lib([0, 5, 7, 10, 15], 0)
-    0
-    >>> binary_search_std_lib([0, 5, 7, 10, 15], 15)
-    4
-    >>> binary_search_std_lib([0, 5, 7, 10, 15], 5)
-    1
-    >>> binary_search_std_lib([0, 5, 7, 10, 15], 6)
-    -1
-    """
+    """Pure implementation using stdlib"""
     if list(sorted_collection) != sorted(sorted_collection):
         raise ValueError("sorted_collection must be sorted in ascending order")
     index = bisect.bisect_left(sorted_collection, item)
@@ -249,54 +199,28 @@ def binary_search_std_lib(sorted_collection: list[int], item: int) -> int:
 
 
 def binary_search_with_duplicates(sorted_collection: list[int], item: int) -> list[int]:
-    """Pure implementation of a binary search algorithm in Python that supports
-    duplicates.
-
-    Resources used:
-    https://stackoverflow.com/questions/13197552/using-binary-search-with-sorted-array-with-duplicates
-
-    The collection must be sorted in ascending order; otherwise the result will be
-    unpredictable. If the target appears multiple times, this function returns a
-    list of all indexes where the target occurs. If the target is not found,
-    this function returns an empty list.
-
-    :param sorted_collection: some ascending sorted collection with comparable items
-    :param item: item value to search for
-    :return: a list of indexes where the item is found (empty list if not found)
-
-    Examples:
-    >>> binary_search_with_duplicates([0, 5, 7, 10, 15], 0)
-    [0]
-    >>> binary_search_with_duplicates([0, 5, 7, 10, 15], 15)
-    [4]
-    >>> binary_search_with_duplicates([1, 2, 2, 2, 3], 2)
-    [1, 2, 3]
-    >>> binary_search_with_duplicates([1, 2, 2, 2, 3], 4)
-    []
-    """
+    """Returns a list of all indexes where the item is found."""
     if list(sorted_collection) != sorted(sorted_collection):
         raise ValueError("sorted_collection must be sorted in ascending order")
 
     def lower_bound(sorted_collection: list[int], item: int) -> int:
-        left = 0
-        right = len(sorted_collection)
+        left, right = 0, len(sorted_collection)
         while left < right:
-            midpoint = left + (right - left) // 2
-            if sorted_collection[midpoint] < item:
-                left = midpoint + 1
+            mid = left + (right - left) // 2
+            if sorted_collection[mid] < item:
+                left = mid + 1
             else:
-                right = midpoint
+                right = mid
         return left
 
     def upper_bound(sorted_collection: list[int], item: int) -> int:
-        left = 0
-        right = len(sorted_collection)
+        left, right = 0, len(sorted_collection)
         while left < right:
-            midpoint = left + (right - left) // 2
-            if sorted_collection[midpoint] <= item:
-                left = midpoint + 1
+            mid = left + (right - left) // 2
+            if sorted_collection[mid] <= item:
+                left = mid + 1
             else:
-                right = midpoint
+                right = mid
         return left
 
     left = lower_bound(sorted_collection, item)
@@ -310,29 +234,7 @@ def upper_bound(sorted_collection: list[int], item: int) -> int:
 def binary_search_by_recursion(
     sorted_collection: list[int], item: int, left: int = 0, right: int = -1
 ) -> int:
-    """Pure implementation of a binary search algorithm in Python by recursion.
-    Finds the first occurrence of the item.
-
-    Be careful collection must be ascending sorted otherwise, the result will be
-    unpredictable
-    First recursion should be started with left=0 and right=(len(sorted_collection)-1)
-
-    :param sorted_collection: some ascending sorted collection with comparable items
-    :param item: item value to search
-    :return: index of the first found item or -1 if the item is not found
-
-    Examples:
-    >>> binary_search_by_recursion([0, 5, 7, 10, 15], 0, 0, 4)
-    0
-    >>> binary_search_by_recursion([0, 5, 7, 10, 15], 15, 0, 4)
-    4
-    >>> binary_search_by_recursion([0, 5, 7, 10, 15], 5, 0, 4)
-    1
-    >>> binary_search_by_recursion([0, 5, 7, 10, 15], 6, 0, 4)
-    -1
-    >>> binary_search_by_recursion([1, 2, 2, 2, 3], 2, 0, 4)
-    1
-    """
+    """Recursive implementation finding the first occurrence."""
     if right < 0:
         right = len(sorted_collection) - 1
     if list(sorted_collection) != sorted(sorted_collection):
@@ -343,7 +245,6 @@ def binary_search_by_recursion(
     midpoint = left + (right - left) // 2
 
     if sorted_collection[midpoint] == item:
-        # Check if there's an earlier occurrence to the left
         res = binary_search_by_recursion(sorted_collection, item, left, midpoint - 1)
         return res if res != -1 else midpoint
     elif sorted_collection[midpoint] > item:
@@ -353,45 +254,20 @@ def binary_search_by_recursion(
 
 
 def exponential_search(sorted_collection: list[int], item: int) -> int:
-    """Pure implementation of an exponential search algorithm in Python
-    Resources used:
-    https://en.wikipedia.org/wiki/Exponential_search
-
-    Be careful collection must be ascending sorted otherwise, result will be
-    unpredictable
-
-    :param sorted_collection: some ascending sorted collection with comparable items
-    :param item: item value to search
-    :return: index of the found item or -1 if the item is not found
-
-    the order of this algorithm is O(lg I) where I is index position of item if exist
-
-    Examples:
-    >>> exponential_search([0, 5, 7, 10, 15], 0)
-    0
-    >>> exponential_search([0, 5, 7, 10, 15], 15)
-    4
-    >>> exponential_search([0, 5, 7, 10, 15], 5)
-    1
-    >>> exponential_search([0, 5, 7, 10, 15], 6)
-    -1
-    """
-    if list(sorted_collection) != sorted(sorted_collection):
-        raise ValueError("sorted_collection must be sorted in ascending order")
+    """Exponential search implementation."""
+    if not sorted_collection:
+        return -1
+    if sorted_collection[0] == item:
+        return 0
     bound = 1
     while bound < len(sorted_collection) and sorted_collection[bound] < item:
         bound *= 2
     left = bound // 2
     right = min(bound, len(sorted_collection) - 1)
-    last_result = binary_search_by_recursion(
-        sorted_collection=sorted_collection, item=item, left=left, right=right
-    )
-    if last_result is None:
-        return -1
-    return last_result
+    return binary_search_by_recursion(sorted_collection, item, left, right)
 
 
-searches = (  # Fastest to slowest...
+searches = (
     binary_search_std_lib,
     binary_search,
     exponential_search,
@@ -406,7 +282,7 @@ def exponential_search(sorted_collection: list[int], item: int) -> int:
     doctest.testmod()
     for search in searches:
         name = f"{search.__name__:>26}"
-        print(f"{name}: {search([0, 5, 7, 10, 15], 10) = }")  # type: ignore[operator]
+        print(f"{name}: {search([0, 5, 7, 10, 15], 10) = }")
 
     print("\nBenchmarks...")
     setup = "collection = range(1000)"
@@ -417,13 +293,4 @@ def exponential_search(sorted_collection: list[int], item: int) -> int:
             timeit.timeit(
                 f"{name}(collection, 500)", setup=setup, number=5_000, globals=globals()
             ),
-        )
-
-    user_input = input("\nEnter numbers separated by comma: ").strip()
-    collection = sorted(int(item) for item in user_input.split(","))
-    target = int(input("Enter a single number to be found in the list: "))
-    result = binary_search(sorted_collection=collection, item=target)
-    if result == -1:
-        print(f"{target} was not found in {collection}.")
-    else:
-        print(f"{target} was found at position {result} of {collection}.")
+        )