查找所有加起来等于给定数字的组合

给定一个正数，找出与该数字相加的所有正数组合。该程序应仅打印组合，而不打印排列。例如，对于输入3，应打印1、2或2、1。
例子 ：

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 

强烈建议您最小化浏览器，然后自己尝试。
这个想法是使用递归。我们使用数组来存储组合，然后递归地填充数组并递减数量。解决方案中使用的不变式是，每种组合将始终以所涉及元素的升序存储。这样我们就可以避免打印排列。
以下是上述想法的实现：

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

Javascript

 
// Javascript 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 (let i = 0; i < index; i++)
               document.write (arr[i] + " ");
           document.write("<br/>");
        return;
    }
  
    // Find the previous number
    // stored in arr[]. It helps
    // in maintaining increasing
    // order
    let prev = (index == 0) ?
                          1 : arr[index - 1];
  
    // note loop starts from
    // previous number i.e. at
    // array location index - 1
    for (let 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
    let arr = [];
  
    // find all combinations
    findCombinationsUtil(arr, 0, n, n);
}
 
// Driver Code
 
    let n = 5;
    findCombinations(n);      
                       

输出 ：

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