Python Program to get K length groups with given summation

Given a list, our task is to write a Python program to extract all K length sublists with lead to given summation. 

Input : test_list = [6, 3, 12, 7, 4, 11], N = 21, K = 4

Output : [(6, 6, 6, 3), (6, 6, 3, 6), (6, 3, 6, 6), (6, 7, 4, 4), (6, 4, 7, 4), (6, 4, 4, 7), (3, 6, 6, 6), (3, 3, 3, 12), (3, 3, 12, 3), (3, 3, 4, 11), (3, 3, 11, 4), (3, 12, 3, 3), (3, 7, 7, 4), (3, 7, 4, 7), (3, 4, 3, 11), (3, 4, 7, 7), (3, 4, 11, 3), (3, 11, 3, 4), (3, 11, 4, 3), (12, 3, 3, 3), (7, 6, 4, 4), (7, 3, 7, 4), (7, 3, 4, 7), (7, 7, 3, 4), (7, 7, 4, 3), (7, 4, 6, 4), (7, 4, 3, 7), (7, 4, 7, 3), (7, 4, 4, 6), (4, 6, 7, 4), (4, 6, 4, 7), (4, 3, 3, 11), (4, 3, 7, 7), (4, 3, 11, 3), (4, 7, 6, 4), (4, 7, 3, 7), (4, 7, 7, 3), (4, 7, 4, 6), (4, 4, 6, 7), (4, 4, 7, 6), (4, 11, 3, 3), (11, 3, 3, 4), (11, 3, 4, 3), (11, 4, 3, 3)]

Explanation : All groups of length 4 and sum 21 are printed.

Input : test_list = [6, 3, 12, 7, 4, 11], N = 210, K = 4

Output : []

Explanation : Since no 4 size group sum equals 210, no group is printed as result.

Method : Using sum() + product() + loop 

In this all possible sublists of length K are computed using product(), sum() is used to compare the sublist's sum with the required summation. 

# Python3 code to demonstrate working of
# K length groups with given summation
# Using sum + product()
from itertools import product

# initializing list
test_list = [6, 3, 12, 7, 4, 11]
             
# printing original list
print("The original list is : " + str(test_list))

# initializing Summation 
N = 21

# initializing size 
K = 4

# Looping for each product and comparing with required summation
res = []
for sub in product(test_list, repeat = K):
  if sum(sub) == N:
    res.append(sub)
        
# printing result
print("The sublists with of given size and sum : " + str(res))

Output:

The original list is : [6, 3, 12, 7, 4, 11]

The sublists with of given size and sum : [(6, 6, 6, 3), (6, 6, 3, 6), (6, 3, 6, 6), (6, 7, 4, 4), (6, 4, 7, 4), (6, 4, 4, 7), (3, 6, 6, 6), (3, 3, 3, 12), (3, 3, 12, 3), (3, 3, 4, 11), (3, 3, 11, 4), (3, 12, 3, 3), (3, 7, 7, 4), (3, 7, 4, 7), (3, 4, 3, 11), (3, 4, 7, 7), (3, 4, 11, 3), (3, 11, 3, 4), (3, 11, 4, 3), (12, 3, 3, 3), (7, 6, 4, 4), (7, 3, 7, 4), (7, 3, 4, 7), (7, 7, 3, 4), (7, 7, 4, 3), (7, 4, 6, 4), (7, 4, 3, 7), (7, 4, 7, 3), (7, 4, 4, 6), (4, 6, 7, 4), (4, 6, 4, 7), (4, 3, 3, 11), (4, 3, 7, 7), (4, 3, 11, 3), (4, 7, 6, 4), (4, 7, 3, 7), (4, 7, 7, 3), (4, 7, 4, 6), (4, 4, 6, 7), (4, 4, 7, 6), (4, 11, 3, 3), (11, 3, 3, 4), (11, 3, 4, 3), (11, 4, 3, 3)]

Time Complexity: O(n*n)
Auxiliary Space: O(n)

Approach#2: Using recursion: The approach uses backtracking to generate all possible groups of length K with sum N. It starts with an empty group and recursively tries to add numbers from the given list to form a group. If the group becomes of length K and its sum is N, it is added to the list of groups.

1. Define a backtrack function that takes curr_group, remaining_sum, and remaining_len as parameters.
2. Check if remaining_sum is equal to 0 and remaining_len is equal to 0. If yes, return the current group as a list of list.
3. Check if remaining_sum is less than 0 or remaining_len is less than 0. If yes, return an empty list.
4. Initialize an empty list of groups to store all possible groups.
5. Loop through the given list test_list using the enumerate() function.
6. Add the current number to the current group to form a new group and reduce the remaining_sum and remaining_len accordingly.
7. Recursively call the backtrack function with the new group, new_sum, new_len, and remaining_list.
8. Append the returned groups to the groups list.
9. Return the final groups list.

# Python program for the above approach

# Function to get the K length groups
def get_k_length_groups(test_list, N, K):

   # Function to recursively find the states
    def backtrack(curr_group, remaining_sum, remaining_len):
        if remaining_sum == 0 and remaining_len == 0:
            return [curr_group]
        if remaining_sum < 0 or remaining_len < 0:
            return []
        groups = []

        # Update the group and call recursively
        for i, num in enumerate(test_list):
            new_group = curr_group + [num]
            new_sum = remaining_sum - num
            new_len = remaining_len - 1
            remaining_list = test_list[i:]
            groups += backtrack(new_group, new_sum, new_len)

        # Return the groups
        return groups

    # Backtrack the current state
    groups = backtrack([], N, K)

    # Return the resultant groups
    return groups


# Driver Code
test_list = [6, 3, 12, 7, 4, 11]
N = 21
K = 4
print(get_k_length_groups(test_list, N, K))

[[6, 6, 6, 3], [6, 6, 3, 6], [6, 3, 6, 6], [6, 7, 4, 4], [6, 4, 7, 4], [6, 4, 4, 7], [3, 6, 6, 6], [3, 3, 3, 12], [3, 3, 12, 3], [3, 3, 4, 11], [3, 3, 11, 4], [3, 12, 3, 3], [3, 7, 7, 4], [3, 7, 4, 7], [3, 4, 3, 11], [3, 4, 7, 7], [3, 4, 11, 3], [3, 11, 3, 4], [3, 11, 4, 3], [12, 3, 3, 3], [7, 6, 4, 4], [7, 3, 7, 4], [7, 3, 4, 7], [7, 7, 3, 4], [7, 7, 4, 3], [7, 4, 6, 4], [7, 4, 3, 7], [7, 4, 7, 3], [7, 4, 4, 6], [4, 6, 7, 4], [4, 6, 4, 7], [4, 3, 3, 11], [4, 3, 7, 7], [4, 3, 11, 3], [4, 7, 6, 4], [4, 7, 3, 7], [4, 7, 7, 3], [4, 7, 4, 6], [4, 4, 6, 7], [4, 4, 7, 6], [4, 11, 3, 3], [11, 3, 3, 4], [11, 3, 4, 3], [11, 4, 3, 3]]

Time Complexity: O(N^K), because we are generating all possible groups of length K with sum N, and each number in the list, can either be included or excluded in a group.

Space Complexity: O(K) because we are using the curr_group list to store the current group, and its length is at most K. Additionally, the recursion depth can go up to K, so the space complexity is O(K).