Merge branch 'master' into types/tim-sort-comparable

Author: cclauss

sorts/bitonic_sort.py

@@ -6,8 +6,16 @@
 
 from __future__ import annotations
 
+from typing import Protocol
 
-def comp_and_swap(array: list[int], index1: int, index2: int, direction: int) -> None:
+
+class Comparable(Protocol):
+    def __lt__(self, other: object, /) -> bool: ...
+
+
+def comp_and_swap[T: Comparable](
+    array: list[T], index1: int, index2: int, direction: int
+) -> None:
     """Compare the value at given index1 and index2 of the array and swap them as per
     the given direction.
 
@@ -32,13 +40,15 @@ def comp_and_swap(array: list[int], index1: int, index2: int, direction: int) ->
     >>> arr
     [12, 42, -21, 1]
     """
-    if (direction == 1 and array[index1] > array[index2]) or (
+    if (direction == 1 and array[index2] < array[index1]) or (
         direction == 0 and array[index1] < array[index2]
     ):
         array[index1], array[index2] = array[index2], array[index1]
 
 
-def bitonic_merge(array: list[int], low: int, length: int, direction: int) -> None:
+def bitonic_merge[T: Comparable](
+    array: list[T], low: int, length: int, direction: int
+) -> None:
     """
     It recursively sorts a bitonic sequence in ascending order, if direction = 1, and in
     descending if direction = 0.
@@ -62,7 +72,9 @@ def bitonic_merge(array: list[int], low: int, length: int, direction: int) -> No
         bitonic_merge(array, low + middle, middle, direction)
 
 
-def bitonic_sort(array: list[int], low: int, length: int, direction: int) -> None:
+def bitonic_sort[T: Comparable](
+    array: list[T], low: int, length: int, direction: int
+) -> None:
     """
     This function first produces a bitonic sequence by recursively sorting its two
     halves in opposite sorting orders, and then calls bitonic_merge to make them in the
@@ -76,6 +88,22 @@ def bitonic_sort(array: list[int], low: int, length: int, direction: int) -> Non
     >>> bitonic_sort(arr, 0, 8, 0)
     >>> arr
     [145, 92, 34, 12, 0, -23, -121, -167]
+
+    >>> arr = ["banana", "apple", "cherry", "date"]
+    >>> bitonic_sort(arr, 0, 4, 1)
+    >>> arr
+    ['apple', 'banana', 'cherry', 'date']
+
+    >>> arr = [3, 1.5, 2, 4.5]
+    >>> bitonic_sort(arr, 0, 4, 1)
+    >>> arr
+    [1.5, 2, 3, 4.5]
+
+    >>> arr = [1, "two", 3, "four"]
+    >>> bitonic_sort(arr, 0, 4, 1)
+    Traceback (most recent call last):
+    ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
     """
     if length > 1:
         middle = int(length / 2)

sorts/patience_sort.py

@@ -3,6 +3,7 @@
 from bisect import bisect_left
 from functools import total_ordering
 from heapq import merge
+from typing import Protocol
 
 """
 A pure Python implementation of the patience sort algorithm
@@ -19,16 +20,22 @@
 """
 
 
+class Comparable(Protocol):
+    def __lt__(self, other: object, /) -> bool: ...
+
+
 @total_ordering
-class Stack(list):
-    def __lt__(self, other):
+class Stack[T: Comparable](list[T]):
+    def __lt__(self, other: Stack[T]) -> bool:
         return self[-1] < other[-1]
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Stack):
+            return NotImplemented
         return self[-1] == other[-1]
 
 
-def patience_sort(collection: list) -> list:
+def patience_sort[T: Comparable](collection: list[T]) -> list[T]:
     """A pure implementation of patience sort algorithm in Python
 
     :param collection: some mutable ordered collection with heterogeneous
@@ -44,6 +51,17 @@ def patience_sort(collection: list) -> list:
 
     >>> patience_sort([-3, -17, -48])
     [-48, -17, -3]
+
+    >>> patience_sort(['d', 'a', 'b', 'e']) == sorted(['d', 'a', 'b', 'e'])
+    True
+
+    >>> patience_sort([3.3, 1.1, 2.2])
+    [1.1, 2.2, 3.3]
+
+    >>> patience_sort([1, "a"])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
     """
     stacks: list[Stack] = []
     # sort into stacks

sorts/unknown_sort.py

@@ -5,8 +5,14 @@
 already O(n)
 """
 
+from typing import Protocol
 
-def merge_sort(collection: list) -> list:
+
+class Comparable(Protocol):
+    def __lt__(self, other: object, /) -> bool: ...
+
+
+def merge_sort[T: Comparable](collection: list[T]) -> list[T]:
     """Pure implementation of the fastest merge sort algorithm in Python
 
     :param collection: some mutable ordered collection with heterogeneous
@@ -22,6 +28,17 @@ def merge_sort(collection: list) -> list:
 
     >>> merge_sort([-2, -5, -45])
     [-45, -5, -2]
+
+    >>> merge_sort(['d', 'a', 'b', 'e']) == sorted(['d', 'a', 'b', 'e'])
+    True
+
+    >>> merge_sort([1.1, 3.3, 5.5, 2.2, 4.4])
+    [1.1, 2.2, 3.3, 4.4, 5.5]
+
+    >>> merge_sort([1, "a"])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
     """
     start, end = [], []
     while len(collection) > 1:

tests/test_sorts.py

@@ -52,6 +52,7 @@
 from sorts.stooge_sort import stooge_sort
 from sorts.strand_sort import strand_sort
 from sorts.tim_sort import tim_sort
+from sorts.unknown_sort import merge_sort as unknown_sort
 
 
 def test_heap_sort() -> None:
@@ -91,6 +92,7 @@ def test_heap_sort() -> None:
     stooge_sort,
     strand_sort,
     tim_sort,
+    unknown_sort,
 )
 
 
@@ -158,11 +160,13 @@ def test_rec_insertion_sort(case) -> None:
         odd_even_sort,
         odd_even_transposition,
         pancake_sort,
+        patience_sort,
         reversort,
         selection_sort,
         shrink_shell_sort,
         strand_sort,
         tim_sort,
+        unknown_sort,
     ],
     ids=lambda f: f.__name__,
 )
@@ -182,3 +186,18 @@ def test_bogo_sort_comparable_items() -> None:
 
     with pytest.raises(TypeError):
         bogo_sort([1, "a"])
+
+
+def test_bitonic_sort_comparable_items() -> None:
+    from sorts.bitonic_sort import bitonic_sort
+
+    strings = ["banana", "apple", "cherry", "date"]
+    bitonic_sort(strings, 0, len(strings), 1)
+    assert strings == ["apple", "banana", "cherry", "date"]
+
+    numbers = [3, 1.5, 2, 4.5]
+    bitonic_sort(numbers, 0, len(numbers), 1)
+    assert numbers == [1.5, 2, 3, 4.5]
+
+    with pytest.raises(TypeError):
+        bitonic_sort([1, "two", 3, "four"], 0, 4, 1)