Move accross in slices to make more performant

Author: WillGibson

list_things/src/continuous_subset.py

@@ -1,24 +1,26 @@
-from itertools import combinations, accumulate
+from itertools import accumulate
 from typing import Optional
 
 
 def continuous_subset_adding_up_to(full_set: list[int], target_sum: int) -> Optional[list[int]]:
     accumulated_sums = list(accumulate(full_set))
 
-    start_index = 0
-    while len(full_set) > 0:
-        maximum_end_index = len(accumulated_sums) - 1
-        end_index = start_index
-        while end_index <= maximum_end_index:
-            if accumulated_sums[end_index] == target_sum:
-                return full_set[start_index : end_index + 1]
-            elif accumulated_sums[end_index] - accumulated_sums[start_index] == target_sum:
-                return full_set[start_index + 1 : end_index + 1]
-            end_index += 1
-
-        # Move in one from the left
-        del full_set[0]
-        del accumulated_sums[0]
+    slice_length = 1
+    list_length = len(full_set)
+    while slice_length <= list_length:
+        left_index = 0
+        while left_index <= list_length - slice_length:
+            right_index = left_index + slice_length - 1
+            if left_index == 0:
+                if accumulated_sums[right_index] == target_sum:
+                    return full_set[left_index:slice_length]
+            elif accumulated_sums[right_index] - accumulated_sums[left_index - 1] == target_sum:
+                if slice_length == 1:
+                    return [full_set[right_index]]
+                else:
+                    return full_set[left_index : left_index + slice_length]
+            left_index += 1
+        slice_length += 1
 
     # Not able to find a subset adding up to target
     return None

list_things/tests/test_continuous_subset.py

@@ -4,21 +4,39 @@
 
 
 class TestContinousSubsetAddingUpTo:
+    def test_sublist_with_unnattainable_target_returns_none(self):
+        assert continuous_subset_adding_up_to([13, 2, 1], 8) is None
+
     @pytest.mark.parametrize(
         "full_set,target_sum,expected",
         [
             ([1], 1, [1]),
             ([1, 2, 3, 4], 1, [1]),
-            ([1, 2, 3, 4], 3, [1, 2]),
+            ([1, 2, 3, 4], 3, [3]),
             ([1, 2, 3, 4], 6, [1, 2, 3]),
             ([1, 2, 3, 4], 10, [1, 2, 3, 4]),
             ([1, 2, 3, 4], 9, [2, 3, 4]),
             ([1, 2, 3, 4], 7, [3, 4]),
             ([1, 2, 3, 4], 4, [4]),
+            ([1, 2, 3, 4], 5, [2, 3]),
         ],
     )
     def test_returns_subset_adding_up_to_target_sum(self, full_set, target_sum, expected):
         assert continuous_subset_adding_up_to(full_set, target_sum) == expected
 
-    def test_sublist_with_unnattainable_target_returns_none(self):
-        assert continuous_subset_adding_up_to([13, 2, 1], 8) is None
+    @pytest.mark.parametrize(
+        "list_size,target_sum",
+        [
+            (1000, 1076),
+            (1000, 13076),
+            (10000, 130476),
+            (100000, 1500090),
+            (1000000, 1500090),  # Takes about 350ms
+            (10000000, 1500090),  # Takes about 642ms
+            (10000000, 97000900),  # Takes about 30s
+        ],
+    )
+    def test_works_with_larger_lists(self, list_size, target_sum):
+        result = continuous_subset_adding_up_to(list(range(list_size)), target_sum)
+        print(f"\nResult: {result}")
+        assert sum(result) == target_sum

list_things/tests/test_scattered_subset.py

@@ -23,23 +23,14 @@ def test_returns_subset_adding_up_to_target_sum(self, full_set, target_sum, expe
         assert scattered_subset_adding_up_to(full_set, target_sum).sort() == expected.sort()
 
     @pytest.mark.parametrize(
-        "target_sum",
+        "list_size,target_sum",
         [
-            1,
-            55,
-            943,
-            777,
-            1234,
-            # 4321, Times out
+            (1000, 1234),
+            (1000, 1076),
+            # (1000, 3076), Times out
         ],
     )
-    def test_works_with_larger_lists(self, target_sum):
-        assert sum(scattered_subset_adding_up_to(list(range(1000)), target_sum)) == target_sum
-
-    @pytest.mark.parametrize(
-        "target_sum",
-        [1076523],
-    )
-    @pytest.mark.skip("Times out")
-    def test_works_with_a_target_bigger_than_any_element_in_a_much_larger_list(self, target_sum):
-        assert sum(scattered_subset_adding_up_to(list(range(1000000)), target_sum)) == target_sum
+    def test_works_with_a_target_bigger_than_any_element_in_a_much_larger_list(
+        self, list_size, target_sum
+    ):
+        assert sum(scattered_subset_adding_up_to(list(range(list_size)), target_sum)) == target_sum