Related Articles
Find all combinations of two equal sum subsequences
• Last Updated : 26 Aug, 2019

Given an array arr[] of integers, the task is to find all possible ways the array could be split into two subsequences such that the sum of the elements in both the subsequences is equal. Each number in the array must belong to only one of the two subsequences. Print all possible combinations of two subsequences.

Examples:

Input: arr[] = {1, 2, 3, 9, 4, 5}
Output:
1 2 9 and 3 4 5
1 2 4 5 and 3 9
3 9 and 1 2 4 5
3 4 5 and 1 2 9

Input: arr[] = {4, -1, 2, -1}
Output:
4 -1 -1 and 2
2 and 4 -1 -1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: A simple solution is to form all possible pairs of subsequences using recursion and compare the sum of elements in both the subsequences. For each array element, we have two choices, we can either take the current element in the first subsequence or the second.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 100000 ` ` `  `// Function to print the subsequence elements ` `void` `print(``int` `g1[], ``int` `a, ``int` `g2[], ``int` `b) ` `{ ` ` `  `    ``// Prints elements of the 1st subarray ` `    ``for` `(``int` `i = 0; i < a; i++) { ` `        ``cout << g1[i] << ``" "``; ` `    ``} ` `    ``cout << ``"and "``; ` ` `  `    ``// Prints elements of the 2nd subarray ` `    ``for` `(``int` `i = 0; i < b; i++) { ` `        ``cout << g2[i] << ``" "``; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `// Function that returns true if the sum of the ` `// elements of arrays g1[] and g2[] is equal ` `bool` `checksum(``int` `g1[], ``int` `a, ``int` `g2[], ``int` `b) ` `{ ` `    ``int` `i, x; ` ` `  `    ``// Adding elements of the 1st array ` `    ``for` `(i = 0, x = 0; i < a; i++) { ` `        ``x += g1[i]; ` `    ``} ` ` `  `    ``// Subtracting elements of the 2nd array ` `    ``for` `(i = 0; i < b; i++) { ` `        ``x -= g2[i]; ` `    ``} ` ` `  `    ``// If x is 0 then the sum of elements ` `    ``// in both the arrays is equal ` `    ``return` `(x == 0); ` `} ` ` `  `// Function to find all valid subsequences ` `void` `formgroups(``int` `arr[], ``int` `x, ``int` `g1[], ``int` `a, ` `                ``int` `g2[], ``int` `b, ``int` `n) ` `{ ` `    ``// Base Case ` `    ``if` `(x == n) { ` ` `  `        ``// If sum of the two subsequences ` `        ``// is equal then print the elements ` `        ``if` `(checksum(g1, a, g2, b)) { ` ` `  `            ``// Print the subsequences ` `            ``print(g1, a, g2, b); ` `        ``} ` `        ``return``; ` `    ``} ` ` `  `    ``// Recursive Case ` ` `  `    ``// Choose current element to be a ` `    ``// part of the first subsequence ` `    ``g1[a] = arr[x]; ` `    ``formgroups(arr, x + 1, g1, a + 1, g2, b, n); ` ` `  `    ``// Choose current element to be a ` `    ``// part of the second subsequence ` `    ``g2[b] = arr[x]; ` `    ``formgroups(arr, x + 1, g1, a, g2, b + 1, n); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 9, 4, 5 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``int` `g1[MAX], g2[MAX]; ` `    ``formgroups(arr, 0, g1, 0, g2, 0, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `static` `int` `MAX = ``100000``; ` ` `  `// Function to print the  ` `// subsequence elements ` `static` `void` `print(``int` `g1[], ``int` `a,  ` `                  ``int` `g2[], ``int` `b) ` `{ ` ` `  `    ``// Prints elements of the 1st subarray ` `    ``for` `(``int` `i = ``0``; i < a; i++) ` `    ``{ ` `        ``System.out.print(g1[i] + ``" "``); ` `    ``} ` `    ``System.out.print(``"and "``); ` ` `  `    ``// Prints elements of the 2nd subarray ` `    ``for` `(``int` `i = ``0``; i < b; i++)  ` `    ``{ ` `        ``System.out.print(g2[i] + ``" "``); ` `    ``} ` `    ``System.out.println(); ` `} ` ` `  `// Function that returns true if  ` `// the sum of the elements of  ` `// arrays g1[] and g2[] is equal ` `static` `boolean` `checksum(``int` `g1[], ``int` `a,  ` `                        ``int` `g2[], ``int` `b) ` `{ ` `    ``int` `i, x; ` ` `  `    ``// Adding elements of the 1st array ` `    ``for` `(i = ``0``, x = ``0``; i < a; i++)  ` `    ``{ ` `        ``x += g1[i]; ` `    ``} ` ` `  `    ``// Subtracting elements of  ` `    ``// the 2nd array ` `    ``for` `(i = ``0``; i < b; i++) ` `    ``{ ` `        ``x -= g2[i]; ` `    ``} ` ` `  `    ``// If x is 0 then the sum of elements ` `    ``// in both the arrays is equal ` `    ``return` `(x == ``0``); ` `} ` ` `  `// Function to find all valid subsequences ` `static` `void` `formgroups(``int` `arr[], ``int` `x,  ` `                       ``int` `g1[], ``int` `a,  ` `                       ``int` `g2[], ``int` `b, ``int` `n) ` `{ ` `    ``// Base Case ` `    ``if` `(x == n)  ` `    ``{ ` ` `  `        ``// If sum of the two subsequences ` `        ``// is equal then print the elements ` `        ``if` `(checksum(g1, a, g2, b))  ` `        ``{ ` ` `  `            ``// Print the subsequences ` `            ``print(g1, a, g2, b); ` `        ``} ` `        ``return``; ` `    ``} ` ` `  `    ``// Recursive Case ` ` `  `    ``// Choose current element to be a ` `    ``// part of the first subsequence ` `    ``g1[a] = arr[x]; ` `    ``formgroups(arr, x + ``1``, g1,  ` `                    ``a + ``1``, g2, b, n); ` ` `  `    ``// Choose current element to be a ` `    ``// part of the second subsequence ` `    ``g2[b] = arr[x]; ` `    ``formgroups(arr, x + ``1``, g1, a,  ` `                ``g2, b + ``1``, n); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``9``, ``4``, ``5` `}; ` `    ``int` `n = arr.length; ` ` `  `    ``int` `[]g1 = ``new` `int``[MAX]; ` `    ``int` `[]g2 = ``new` `int``[MAX]; ` `    ``formgroups(arr, ``0``, g1, ``0``, g2, ``0``, n); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992  `

## Python3

 `# Python 3 implementation of the approach ` `MAX` `=` `100000` ` `  `# Function to print the subsequence elements ` `def` `prints(g1, a, g2, b): ` `     `  `    ``# Prints elements of the 1st subarray ` `    ``for` `i ``in` `range``(a): ` `        ``print``(g1[i], end ``=` `" "``) ` `     `  `    ``print``(``"and "``, end ``=` `"") ` ` `  `    ``# Prints elements of the 2nd subarray ` `    ``for` `i ``in` `range``(b): ` `        ``print``(g2[i], end ``=` `" "``) ` `     `  `    ``print``(``"\n"``, end ``=` `"") ` ` `  `# Function that returns true if the sum of the ` `# elements of arrays g1[] and g2[] is equal ` `def` `checksum(g1, a, g2, b): ` `     `  `    ``# Adding elements of the 1st array ` `    ``x ``=` `0` `    ``for` `i ``in` `range``(``0``, a, ``1``): ` `        ``x ``+``=` `g1[i] ` ` `  `    ``# Subtracting elements of the 2nd array ` `    ``for` `i ``in` `range``(b): ` `        ``x ``-``=` `g2[i] ` ` `  `    ``# If x is 0 then the sum of elements ` `    ``# in both the arrays is equal ` `    ``return` `(x ``=``=` `0``) ` ` `  `# Function to find all valid subsequences ` `def` `formgroups(arr, x, g1, a, g2, b, n): ` `     `  `    ``# Base Case ` `    ``if` `(x ``=``=` `n): ` `         `  `        ``# If sum of the two subsequences ` `        ``# is equal then print the elements ` `        ``if` `(checksum(g1, a, g2, b)): ` `             `  `            ``# Print the subsequences ` `            ``prints(g1, a, g2, b) ` ` `  `        ``return` ` `  `    ``# Recursive Case ` ` `  `    ``# Choose current element to be a ` `    ``# part of the first subsequence ` `    ``g1[a] ``=` `arr[x] ` `    ``formgroups(arr, x ``+` `1``, g1, a ``+` `1``, g2, b, n) ` ` `  `    ``# Choose current element to be a ` `    ``# part of the second subsequence ` `    ``g2[b] ``=` `arr[x] ` `    ``formgroups(arr, x ``+` `1``, g1, a, g2, b ``+` `1``, n) ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``1``, ``2``, ``3``, ``9``, ``4``, ``5``] ` `    ``n ``=` `len``(arr) ` `    ``g1 ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `    ``g2 ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `    ``formgroups(arr, ``0``, g1, ``0``, g2, ``0``, n) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `static` `int` `MAX = 100000; ` ` `  `// Function to print the  ` `// subsequence elements ` `static` `void` `print(``int` `[]g1, ``int` `a,  ` `                  ``int` `[]g2, ``int` `b) ` `{ ` ` `  `    ``// Prints elements of the 1st subarray ` `    ``for` `(``int` `i = 0; i < a; i++) ` `    ``{ ` `        ``Console.Write(g1[i] + ``" "``); ` `    ``} ` `    ``Console.Write(``"and "``); ` ` `  `    ``// Prints elements of the 2nd subarray ` `    ``for` `(``int` `i = 0; i < b; i++)  ` `    ``{ ` `        ``Console.Write(g2[i] + ``" "``); ` `    ``} ` `    ``Console.WriteLine(); ` `} ` ` `  `// Function that returns true if  ` `// the sum of the elements of  ` `// arrays g1[] and g2[] is equal ` `static` `bool` `checksum(``int` `[]g1, ``int` `a,  ` `                     ``int` `[]g2, ``int` `b) ` `{ ` `    ``int` `i, x; ` ` `  `    ``// Adding elements of the 1st array ` `    ``for` `(i = 0, x = 0; i < a; i++)  ` `    ``{ ` `        ``x += g1[i]; ` `    ``} ` ` `  `    ``// Subtracting elements of  ` `    ``// the 2nd array ` `    ``for` `(i = 0; i < b; i++) ` `    ``{ ` `        ``x -= g2[i]; ` `    ``} ` ` `  `    ``// If x is 0 then the sum of elements ` `    ``// in both the arrays is equal ` `    ``return` `(x == 0); ` `} ` ` `  `// Function to find all valid subsequences ` `static` `void` `formgroups(``int` `[]arr, ``int` `x,  ` `                       ``int` `[]g1, ``int` `a,  ` `                       ``int` `[]g2, ``int` `b, ``int` `n) ` `{ ` `    ``// Base Case ` `    ``if` `(x == n)  ` `    ``{ ` ` `  `        ``// If sum of the two subsequences ` `        ``// is equal then print the elements ` `        ``if` `(checksum(g1, a, g2, b))  ` `        ``{ ` ` `  `            ``// Print the subsequences ` `            ``print(g1, a, g2, b); ` `        ``} ` `        ``return``; ` `    ``} ` ` `  `    ``// Recursive Case ` ` `  `    ``// Choose current element to be a ` `    ``// part of the first subsequence ` `    ``g1[a] = arr[x]; ` `    ``formgroups(arr, x + 1, g1,  ` `                    ``a + 1, g2, b, n); ` ` `  `    ``// Choose current element to be a ` `    ``// part of the second subsequence ` `    ``g2[b] = arr[x]; ` `    ``formgroups(arr, x + 1, g1, a,  ` `                ``g2, b + 1, n); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main()  ` `{ ` `    ``int` `[]arr = { 1, 2, 3, 9, 4, 5 }; ` `    ``int` `n = arr.Length; ` ` `  `    ``int` `[]g1 = ``new` `int``[MAX]; ` `    ``int` `[]g2 = ``new` `int``[MAX]; ` `    ``formgroups(arr, 0, g1, 0, g2, 0, n); ` `} ` `} ` ` `  `// This code is contributed by anuj_67... `

## PHP

 ` `

Output:

```1 2 9 and 3 4 5
1 2 4 5 and 3 9
3 9 and 1 2 4 5
3 4 5 and 1 2 9
```

Time Complexity: O(2n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :