Changes the code To return the list in dynamic_programming/subset_generation.py

dynamic_programming/subset_generation.py

@@ -1,44 +1,60 @@
-# Print all subset combinations of n element in given set of r element.
-
-
-def combination_util(arr, n, r, index, data, i):
+def subset_combinations(elements: list[int], n: int) -> list:
     """
-    Current combination is ready to be printed, print it
-    arr[]  ---> Input Array
-    data[] ---> Temporary array to store current combination
-    start & end ---> Staring and Ending indexes in arr[]
-    index  ---> Current index in data[]
-    r ---> Size of a combination to be printed
+    Compute n-element combinations from a given list using dynamic programming.
+    Args:
+        elements: The list of elements from which combinations will be generated.
+        n: The number of elements in each combination.
+    Returns:
+        A list of tuples, each representing a combination of n elements.
+        >>> subset_combinations(elements=[10, 20, 30, 40], n=2)
+        [(10, 20), (10, 30), (10, 40), (20, 30), (20, 40), (30, 40)]
+        >>> subset_combinations(elements=[1, 2, 3], n=1)
+        [(1,), (2,), (3,)]
+        >>> subset_combinations(elements=[1, 2, 3], n=3)
+        [(1, 2, 3)]
+        >>> subset_combinations(elements=[42], n=1)
+        [(42,)]
+        >>> subset_combinations(elements=[6, 7, 8, 9], n=4)
+        [(6, 7, 8, 9)]
+        >>> subset_combinations(elements=[10, 20, 30, 40, 50], n=0)
+        [()]
+        >>> subset_combinations(elements=[1, 2, 3, 4], n=2)
+        [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+        >>> subset_combinations(elements=[1, 'apple', 3.14], n=2)
+        [(1, 'apple'), (1, 3.14), ('apple', 3.14)]
+        >>> subset_combinations(elements=['single'], n=0)
+        [()]
+        >>> subset_combinations(elements=[], n=9)
+        []
+        >>> from itertools import combinations
+        >>> all(subset_combinations(items, n) == list(combinations(items, n))
+        ...     for items, n in (
+        ...         ([10, 20, 30, 40], 2), ([1, 2, 3], 1), ([1, 2, 3], 3), ([42], 1),
+        ...         ([6, 7, 8, 9], 4), ([10, 20, 30, 40, 50], 1), ([1, 2, 3, 4], 2),
+        ...         ([1, 'apple', 3.14], 2), (['single'], 0), ([], 9)))
+        True
     """
-    if index == r:
-        for j in range(r):
-            print(data[j], end=" ")
-        print(" ")
-        return
-    #  When no more elements are there to put in data[]
-    if i >= n:
-        return
-    # current is included, put next at next location
-    data[index] = arr[i]
-    combination_util(arr, n, r, index + 1, data, i + 1)
-    # current is excluded, replace it with
-    # next (Note that i+1 is passed, but
-    # index is not changed)
-    combination_util(arr, n, r, index, data, i + 1)
-    # The main function that prints all combinations
-    # of size r in arr[] of size n. This function
-    # mainly uses combinationUtil()
+    r = len(elements)
+    if n > r:
+        return []
+
+    dp: list[list[tuple]] = [[] for _ in range(r + 1)]
 
+    dp[0].append(())
 
-def print_combination(arr, n, r):
-    # A temporary array to store all combination one by one
-    data = [0] * r
-    # Print all combination using temporary array 'data[]'
-    combination_util(arr, n, r, 0, data, 0)
+    for i in range(1, r + 1):
+        for j in range(i, 0, -1):
+            for prev_combination in dp[j - 1]:
+                dp[j].append(tuple(prev_combination) + (elements[i - 1],))
+
+    try:
+        return sorted(dp[n])
+    except TypeError:
+        return dp[n]
 
 
 if __name__ == "__main__":
-    # Driver code to check the function above
-    arr = [10, 20, 30, 40, 50]
-    print_combination(arr, len(arr), 3)
-    # This code is contributed by Ambuj sahu
+    from doctest import testmod
+
+    testmod()
+    print(f"{subset_combinations(elements=[10, 20, 30, 40], n=2) = }")