# Find all combinations of two equal sum subsequences

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[0]);        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)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.