Print combinations of distinct numbers which add up to give sum N

Given a positive integer N, the task is to find out all the combinations of positive integers that add upto the given integer N. The program should print only combinations, not permutations and all the integers in a combination must be distinct. For example, for input 3, either 1, 2 or 2, 1 should be printed and 1, 1, 1 must not be printed as the integers are not distinct.
Examples:

Input: N = 3 
Output:
1 2 
3
Input: N = 7 
Output:
1 2 4 
1 6 
2 5 
3 4 
7 

Approach: The approach is an extension of the approach discussed here. The idea used to get all the distinct element is that first we find all the elements that add up to give sum N. Then we iterate over each of the elements and store the elements into the set. Storing the elements into set would remove all the duplicate elements, and after that we add up the sum of the elements of the set and check whether it is equal to N or not.
Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

/* arr[] to store all the distinct elements
    index - next location in array
    num - given number
    reducedNum - reduced number */
void findCombinationsUtil(int arr[], int index,
                          int n, int red_num)
{

    // Set to store all the
    // distinct elements
    set<int> s;
    int sum = 0;

    // Base condition
    if (red_num < 0) {
        return;
    }

    if (red_num == 0) {

        // Iterate over all the elements
        // and store it into the set
        for (int i = 0; i < index; i++) {
            s.insert(arr[i]);
        }

        // Calculate the sum of all
        // the elements of the set
        for (auto itr = s.begin();
             itr != s.end(); itr++) {
            sum = sum + (*itr);
        }

        // Compare whether the sum is equal to n or not,
        // if it is equal to n print the numbers
        if (sum == n) {
            for (auto i = s.begin();
                 i != s.end(); i++) {
                cout << *i << " ";
            }
            cout << endl;
            return;
        }
    }

    // Find previous number stored in the array
    int prev = (index == 0) ? 1 : arr[index - 1];

    for (int k = prev; k <= n; k++) {

        // Store all the numbers recursively
        // into the arr[]
        arr[index] = k;
        findCombinationsUtil(arr, index + 1,
                             n, red_num - k);
    }
}

// Function to find all the
// distinct combinations of n
void findCombinations(int n)
{
    int a[n];
    findCombinationsUtil(a, 0, n, n);
}

// Driver code
int main()
{
    int n = 7;
    findCombinations(n);

    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
class GFG
{

/* arr[] to store all the distinct elements
    index - next location in array
    num - given number
    reducedNum - reduced number */
static void findCombinationsUtil(int arr[], int index,
                        int n, int red_num)
{

    // Set to store all the
    // distinct elements
    HashSet<Integer> s = new HashSet<>();
    int sum = 0;

    // Base condition
    if (red_num < 0)
    {
        return;
    }

    if (red_num == 0)
    {

        // Iterate over all the elements
        // and store it into the set
        for (int i = 0; i < index; i++)
        {
            s.add(arr[i]);
        }

        // Calculate the sum of all
        // the elements of the set
        for (Integer itr : s)
        {

            sum = sum + itr;
        }

        // Compare whether the sum is equal to n or not,
        // if it is equal to n print the numbers
        if (sum == n)
        {
            for (Integer i : s)
            {
                System.out.print(i+" ");
            }
            System.out.println();
            return;
        }
    }

    // Find previous number stored in the array
    int prev = (index == 0) ? 1 : arr[index - 1];

    for (int k = prev; k <= n; k++)
    {

        // Store all the numbers recursively
        // into the arr[]
        if(index < n)
        {
            arr[index] = k;
            findCombinationsUtil(arr, index + 1,
                            n, red_num - k);

        }
    }
}

// Function to find all the
// distinct combinations of n
static void findCombinations(int n)
{
    int []a = new int[n];
    findCombinationsUtil(a, 0, n, n);
}

// Driver code
public static void main(String arr[])
{
    int n = 7;
    findCombinations(n);
}
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 implementation of the approach

# arr[] to store all the distinct elements
# index - next location in array
# num - given number
# reducedNum - reduced number
def findCombinationsUtil(arr, index, n, red_num):

    # Set to store all the
    # distinct elements
    s = set()
    sum = 0

    # Base condition
    if (red_num < 0):
        return

    if (red_num == 0):

        # Iterate over all the elements
        # and store it into the set
        for i in range(index):
            s.add(arr[i])

        # Calculate the sum of all
        # the elements of the set
        for itr in s:
            sum = sum + (itr)

        # Compare whether the sum is equal to n or not,
        # if it is equal to n print the numbers
        if (sum == n):
            for i in s:
                print(i, end = " ")
            print("\n", end = "")
            return

    # Find previous number stored in the array
    if (index == 0):
        prev = 1
    else:
        prev = arr[index - 1]

    for k in range(prev, n + 1, 1):

        # Store all the numbers recursively
        # into the arr[]
        arr[index] = k
        findCombinationsUtil(arr, index + 1,
                             n, red_num - k)

# Function to find all the
# distinct combinations of n
def findCombinations(n):
    a = [0 for i in range(n + 1)]
    findCombinationsUtil(a, 0, n, n)

# Driver code
if __name__ == '__main__':
    n = 7
    findCombinations(n)

# This code is contributed by Surendra_Gangwar

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;

class GFG
{

/* arr[] to store all the distinct elements
    index - next location in array
    num - given number
    reducedNum - reduced number */
static void findCombinationsUtil(int []arr, int index,
                        int n, int red_num)
{

    // Set to store all the
    // distinct elements
    HashSet<int> s = new HashSet<int>();
    int sum = 0;

    // Base condition
    if (red_num < 0)
    {
        return;
    }

    if (red_num == 0)
    {

        // Iterate over all the elements
        // and store it into the set
        for (int i = 0; i < index; i++)
        {
            s.Add(arr[i]);
        }

        // Calculate the sum of all
        // the elements of the set
        foreach (int itr in s)
        {

            sum = sum + itr;
        }

        // Compare whether the sum is equal to n or not,
        // if it is equal to n print the numbers
        if (sum == n)
        {
            foreach (int i in s)
            {
                Console.Write(i+" ");
            }
            Console.WriteLine();
            return;
        }
    }

    // Find previous number stored in the array
    int prev = (index == 0) ? 1 : arr[index - 1];

    for (int k = prev; k <= n; k++)
    {

        // Store all the numbers recursively
        // into the arr[]
        if(index < n)
        {
            arr[index] = k;
            findCombinationsUtil(arr, index + 1,
                            n, red_num - k);

        }
    }
}

// Function to find all the
// distinct combinations of n
static void findCombinations(int n)
{
    int []a = new int[n];
    findCombinationsUtil(a, 0, n, n);
}

// Driver code
public static void Main(String []arr)
{
    int n = 7;
    findCombinations(n);
}
}

// This code contributed by Rajput-Ji

Javascript

<script>

      // JavaScript implementation of the approach
      /* arr[] to store all the distinct elements
    index - next location in array
    num - given number
    reducedNum - reduced number */
      function findCombinationsUtil(arr, index, n, red_num) {
        // Set to store all the
        // distinct elements
        var s = new Set();
        var sum = 0;

        // Base condition
        if (red_num < 0) {
          return;
        }

        if (red_num === 0) {
          // Iterate over all the elements
          // and store it into the set
          for (var i = 0; i < index; i++) {
            s.add(arr[i]);
          }

          // Calculate the sum of all
          // the elements of the set
          for (const itr of s) {
            sum = sum + itr;
          }

          // Compare whether the sum is equal to n or not,
          // if it is equal to n print the numbers
          if (sum === n) {
            for (const i of s) {
              document.write(i + " ");
            }
            document.write("<br>");
            return;
          }
        }

        // Find previous number stored in the array
        var prev = index === 0 ? 1 : arr[index - 1];

        for (var k = prev; k <= n; k++) {
          // Store all the numbers recursively
          // into the arr[]
          if (index < n) {
            arr[index] = k;
            findCombinationsUtil(arr, index + 1, n, red_num - k);
          }
        }
      }

      // Function to find all the
      // distinct combinations of n
      function findCombinations(n) {
        var a = new Array(n).fill(0);
        findCombinationsUtil(a, 0, n, n);
      }

      // Driver code
      var n = 7;
      findCombinations(n);

</script>

Output:

1 2 4 
1 6 
2 5 
3 4 
7

Time Complexity: O(nlogn)

Auxiliary Space: O(n)