# Find all combinations that add upto given number

Given a positive number, find out all combinations of positive numbers that adds upto that number. The program should print only combinations, not permutations. For example, for input 3, either 1, 2 or 2, 1 should be printed.

Examples :

```Input: N = 3
Output:
1 1 1
1 2
3

Input: N = 5
Output:
1 1 1 1 1
1 1 1 2
1 1 3
1 2 2
1 4
2 3
5 ```

We strongly recommend you to minimize your browser and try this yourself first.

The idea is to use recursion. We use an array to store combinations and we recursively fill the array and recurse with reduced number. The invariant used in the solution is that each combination will always be stored in increasing order of elements involved. That way we can avoid printing permutations.

Below is implementation of above idea :

## C++

 `// C++ program to find out all combinations of ` `// positive numbers that add upto given number ` `#include ` `using` `namespace` `std; ` ` `  `/*    arr - array to store the combination ` `    ``index - next location in array ` `    ``num - given number ` `    ``reducedNum - reduced number */` `void` `findCombinationsUtil(``int` `arr[], ``int` `index, ` `                       ``int` `num, ``int` `reducedNum) ` `{ ` `    ``// Base condition ` `    ``if` `(reducedNum < 0) ` `        ``return``; ` ` `  `    ``// If combination is found, print it ` `    ``if` `(reducedNum == 0) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < index; i++) ` `            ``cout << arr[i] << ``" "``; ` `        ``cout << endl; ` `        ``return``; ` `    ``} ` ` `  `    ``// Find the previous number stored in arr[] ` `    ``// It helps in maintaining increasing order ` `    ``int` `prev = (index == 0)? 1 : arr[index-1]; ` ` `  `    ``// note loop starts from previous number ` `    ``// i.e. at array location index - 1 ` `    ``for` `(``int` `k = prev; k <= num ; k++) ` `    ``{ ` `        ``// next element of array is k ` `        ``arr[index] = k; ` ` `  `        ``// call recursively with reduced number ` `        ``findCombinationsUtil(arr, index + 1, num, ` `                                 ``reducedNum - k); ` `    ``} ` `} ` ` `  `/* Function to find out all combinations of ` `   ``positive numbers that add upto given number. ` `   ``It uses findCombinationsUtil() */` `void` `findCombinations(``int` `n) ` `{ ` `    ``// array to store the combinations ` `    ``// It can contain max n elements ` `    ``int` `arr[n]; ` ` `  `    ``//find all combinations ` `    ``findCombinationsUtil(arr, 0, n, n); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 5; ` `    ``findCombinations(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find out  ` `// all combinations of positive ` `// numbers that add upto given ` `// number ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `    ``/* arr - array to store the  ` `    ``combination  ` `    ``index - next location in array ` `    ``num - given number ` `    ``reducedNum - reduced number */` `static` `void` `findCombinationsUtil(``int` `arr[], ``int` `index, ` `                                 ``int` `num, ``int` `reducedNum) ` `{ ` `    ``// Base condition ` `    ``if` `(reducedNum < ``0``) ` `        ``return``; ` ` `  `    ``// If combination is  ` `    ``// found, print it ` `    ``if` `(reducedNum == ``0``) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < index; i++) ` `                ``System.out.print (arr[i] + ``" "``); ` `            ``System.out.println(); ` `        ``return``; ` `    ``} ` ` `  `    ``// Find the previous number  ` `    ``// stored in arr[]. It helps  ` `    ``// in maintaining increasing  ` `    ``// order ` `    ``int` `prev = (index == ``0``) ?  ` `                          ``1` `: arr[index - ``1``]; ` ` `  `    ``// note loop starts from  ` `    ``// previous number i.e. at ` `    ``// array location index - 1 ` `    ``for` `(``int` `k = prev; k <= num ; k++) ` `    ``{ ` `        ``// next element of ` `        ``// array is k ` `        ``arr[index] = k; ` ` `  `        ``// call recursively with ` `        ``// reduced number ` `        ``findCombinationsUtil(arr, index + ``1``, num, ` `                                 ``reducedNum - k); ` `    ``} ` `} ` ` `  `/* Function to find out all  ` `combinations of positive  ` `numbers that add upto given ` `number. It uses findCombinationsUtil() */` `static` `void` `findCombinations(``int` `n) ` `{ ` `    ``// array to store the combinations ` `    ``// It can contain max n elements ` `    ``int` `arr[] = ``new` `int` `[n]; ` ` `  `    ``// find all combinations ` `    ``findCombinationsUtil(arr, ``0``, n, n); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `n = ``5``; ` `    ``findCombinations(n); ` `} ` `} ` ` `  `// This code is contributed ` `// by akt_mit `

## Python3

 `# Python3 program to find out all ` `# combinations of positive  ` `# numbers that add upto given number ` ` `  `# arr - array to store the combination ` `# index - next location in array ` `# num - given number ` `# reducedNum - reduced number  ` `def` `findCombinationsUtil(arr, index, num, ` `                              ``reducedNum): ` ` `  `    ``# Base condition ` `    ``if` `(reducedNum < ``0``): ` `        ``return``; ` ` `  `    ``# If combination is  ` `    ``# found, print it ` `    ``if` `(reducedNum ``=``=` `0``): ` ` `  `        ``for` `i ``in` `range``(index): ` `            ``print``(arr[i], end ``=` `" "``); ` `        ``print``(""); ` `        ``return``; ` ` `  `    ``# Find the previous number stored in arr[].  ` `    ``# It helps in maintaining increasing order ` `    ``prev ``=` `1` `if``(index ``=``=` `0``) ``else` `arr[index ``-` `1``]; ` ` `  `    ``# note loop starts from previous  ` `    ``# number i.e. at array location ` `    ``# index - 1 ` `    ``for` `k ``in` `range``(prev, num ``+` `1``): ` `         `  `        ``# next element of array is k ` `        ``arr[index] ``=` `k; ` ` `  `        ``# call recursively with ` `        ``# reduced number ` `        ``findCombinationsUtil(arr, index ``+` `1``, num,  ` `                                 ``reducedNum ``-` `k); ` ` `  `# Function to find out all  ` `# combinations of positive numbers  ` `# that add upto given number. ` `# It uses findCombinationsUtil()  ` `def` `findCombinations(n): ` `     `  `    ``# array to store the combinations ` `    ``# It can contain max n elements ` `    ``arr ``=` `[``0``] ``*` `n; ` ` `  `    ``# find all combinations ` `    ``findCombinationsUtil(arr, ``0``, n, n); ` ` `  `# Driver code ` `n ``=` `5``; ` `findCombinations(n); ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to find out all ` `// combinations of positive numbers ` `// that add upto given number ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `/* arr - array to store the  ` `combination  ` `index - next location in array  ` `num - given number  ` `reducedNum - reduced number */` `static` `void` `findCombinationsUtil(``int` `[]arr, ``int` `index,  ` `                                 ``int` `num, ``int` `reducedNum)  ` `{  ` `    ``// Base condition  ` `    ``if` `(reducedNum < 0)  ` `        ``return``;  ` ` `  `    ``// If combination is  ` `    ``// found, print it  ` `    ``if` `(reducedNum == 0)  ` `    ``{  ` `        ``for` `(``int` `i = 0; i < index; i++)  ` `            ``Console.Write (arr[i] + ``" "``);  ` `            ``Console.WriteLine();  ` `        ``return``;  ` `    ``}  ` ` `  `    ``// Find the previous number  ` `    ``// stored in arr[]. It helps  ` `    ``// in maintaining increasing  ` `    ``// order  ` `    ``int` `prev = (index == 0) ?  ` `                          ``1 : arr[index - 1];  ` ` `  `    ``// note loop starts from  ` `    ``// previous number i.e. at  ` `    ``// array location index - 1  ` `    ``for` `(``int` `k = prev; k <= num ; k++)  ` `    ``{  ` `        ``// next element of  ` `        ``// array is k  ` `        ``arr[index] = k;  ` ` `  `        ``// call recursively with  ` `        ``// reduced number  ` `        ``findCombinationsUtil(arr, index + 1, num,  ` `                                 ``reducedNum - k);  ` `    ``}  ` `}  ` ` `  `/* Function to find out all  ` `combinations of positive  ` `numbers that add upto given  ` `number. It uses findCombinationsUtil() */` `static` `void` `findCombinations(``int` `n)  ` `{  ` `    ``// array to store the combinations  ` `    ``// It can contain max n elements  ` `    ``int` `[]arr = ``new` `int` `[n];  ` ` `  `    ``// find all combinations  ` `    ``findCombinationsUtil(arr, 0, n, n);  ` `}  ` ` `  `// Driver code  ` `static` `public` `void` `Main () ` `{ ` `    ``int` `n = 5;  ` `    ``findCombinations(n);  ` `}  ` `}  ` ` `  `// This code is contributed  ` `// by akt_mit  `

## PHP

 ` `

Output :

```1 1 1 1 1
1 1 1 2
1 1 3
1 2 2
1 4
2 3
5
```

Exercise : Modify above solution to consider only distinct elements in a combination.

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

Improved By : jit_t, Mithun Kumar

Article Tags :
Practice Tags :

6

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