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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find out all combinations of
// positive numbers that add upto given number
#include <iostream>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP 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 */
function findCombinationsUtil($arr, $index
                              $num, $reducedNum)
{
    // Base condition
    if ($reducedNum < 0)
        return;
  
    // If combination is 
    // found, print it
    if ($reducedNum == 0)
    {
        for ($i = 0; $i < $index; $i++)
            echo $arr[$i] , " ";
        echo "\n";
        return;
    }
  
    // Find the previous number 
    // stored in arr[] It helps 
    // in maintaining increasing order
    $prev = ($index == 0) ? 1 : $arr[$index - 1];
  
    // note loop starts from previous 
    // number i.e. at array location
    // index - 1
    for ($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() */
function findCombinations($n)
{
    // array to store the combinations
    // It can contain max n elements
    $arr = array();
  
    //find all combinations
    findCombinationsUtil($arr, 0, $n, $n);
}
  
// Driver code
$n = 5;
findCombinations($n);
  
// This code is contributed by ajit
?>

chevron_right



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.

This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up

Improved By : jit_t, Mithun Kumar



Article Tags :
Practice Tags :


2


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