#481 fair_partition

Author: wojtask

src/solutions/chapter7/__init__.py

@@ -0,0 +1,36 @@
+from book.data_structures import Array
+from book.data_structures import CT
+from util import range_of
+
+
+def fair_partition(A: Array[CT], p: int, r: int) -> int:
+    """Partitions an array into two subarrays, the low side and the high side, such that each element in the low side of
+    the partition is less than or equal to the pivot value, which is, in turn, less than or equal to each element in the
+    high side. Distributes elements equal to the pivot value evenly to the low side and to the high side.
+
+    Implements:
+        Fair-Partition
+
+    Args:
+        A: an Array to partition
+        p: the lower index of the subarray to partition
+        r: the upper index of the subarray to partition
+
+    Returns:
+        The index q, such that each element in A[p:q - 1] is less than or equal to A[q], and that A[q] is less than or
+        equal to each element in A[q + 1:r]. If all the elements in A[p:r] are equal, returns q = (p + r) // 2.
+    """
+    x = A[r]
+    i = p - 1
+    low = False
+    for j in range_of(p, to=r - 1):
+        if A[j] < x:
+            i += 1
+            A[i], A[j] = A[j], A[i]
+        elif A[j] == x:
+            if low:
+                i += 1
+                A[i], A[j] = A[j], A[i]
+            low = not low
+    A[i + 1], A[r] = A[r], A[i + 1]
+    return i + 1

src/solutions/chapter7/section1/__init__.py

@@ -0,0 +1,43 @@
+import math
+
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.strategies import integers
+from hypothesis.strategies import just
+from hypothesis.strategies import lists
+
+from solutions.chapter7.section1.exercise2 import fair_partition
+from test_case import ClrsTestCase
+from test_util import create_array
+from util import range_of
+
+
+class TestChapter7(ClrsTestCase):
+
+    @given(st.data())
+    def test_fair_partition(self, data):
+        elements = data.draw(lists(integers(), min_size=1))
+        A = create_array(elements)
+        n = len(elements)
+
+        actual_split_index = fair_partition(A, 1, n)
+
+        left_max = -math.inf
+        right_min = math.inf
+        for i in range_of(1, to=actual_split_index):
+            left_max = max(left_max, A[i])
+        for i in range_of(actual_split_index + 1, to=n):
+            right_min = min(right_min, A[i])
+        self.assertLessEqual(left_max, right_min)
+        self.assertArrayPermuted(A, elements, end=n)
+
+    @given(st.data())
+    def test_fair_partition_all_values_equal(self, data):
+        value = data.draw(integers())
+        elements = data.draw(lists(just(value), min_size=1))
+        A = create_array(elements)
+        n = len(elements)
+
+        actual_split_index = fair_partition(A, 1, n)
+
+        self.assertEqual(actual_split_index, (n + 1) // 2)