# Print all possible ways to write N as sum of two or more positive integers

Given an integer N, the task is to print all the possible ways in which N can be written as the sum of two or more positive integers.
Examples:

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

Approach: The idea is to use recursion to solve this problem. The idea is to consider every integer from 1 to N such that the sum N can be reduced by this number at each recursive call and if at any recursive call N reduces to zero then we will print the answer stored in the vector. Below are the steps for recursion:

1. Get the number N whose sum has to be broken into two or more positive integers.
2. Recursively iterate from value 1 to N as index i:
• Base Case: If the value called recursively is 0, then print the current vector as this is the one of the way to broke N into two or more positive integers.

```if (n == 0)
printVector(arr);

```
• Recursive Call: If the base case is not met, then Recursively iterate from [i, N – i]. Push the current element j into vector(say arr) and recursively iterate for the next index and after the this recursion ends then pop the element j inserted previously:

```for j in range[i, N]:
arr.push_back(j);
recursive_function(arr, j + 1, N - j);
arr.pop_back(j);

```

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print the values stored ` `// in vector arr ` `void` `printVector(vector<``int``>& arr) ` `{ ` `    ``if` `(arr.size() != 1) { ` ` `  `        ``// Traverse the vector arr ` `        ``for` `(``int` `i = 0; i < arr.size(); i++) { ` `            ``cout << arr[i] << ``" "``; ` `        ``} ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// Recursive function to print different ` `// ways in which N can be written as ` `// a sum of at 2 or more positive integers ` `void` `findWays(vector<``int``>& arr, ``int` `i, ``int` `n) ` `{ ` `    ``// If n is zero then print this ` `    ``// ways of breaking numbers ` `    ``if` `(n == 0) ` `        ``printVector(arr); ` ` `  `    ``// Start from previous element ` `    ``// in the representation till n ` `    ``for` `(``int` `j = i; j <= n; j++) { ` ` `  `        ``// Include current element ` `        ``// from representation ` `        ``arr.push_back(j); ` ` `  `        ``// Call function again ` `        ``// with reduced sum ` `        ``findWays(arr, j, n - j); ` ` `  `        ``// Backtrack to remove current ` `        ``// element from representation ` `        ``arr.pop_back(); ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given sum N ` `    ``int` `n = 4; ` ` `  `    ``// To store the representation ` `    ``// of breaking N ` `    ``vector<``int``> arr; ` ` `  `    ``// Function Call ` `    ``findWays(arr, 1, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to print the values stored ` `// in vector arr ` `static` `void` `printVector(ArrayList arr) ` `{ ` `    ``if` `(arr.size() != ``1``) ` `    ``{ ` `         `  `        ``// Traverse the vector arr ` `        ``for``(``int` `i = ``0``; i < arr.size(); i++) ` `        ``{ ` `            ``System.out.print(arr.get(i) + ``" "``); ` `        ``} ` `        ``System.out.println(); ` `    ``} ` `} ` ` `  `// Recursive function to print different ` `// ways in which N can be written as ` `// a sum of at 2 or more positive integers ` `static` `void` `findWays(ArrayList arr,  ` `                     ``int` `i, ``int` `n) ` `{ ` `     `  `    ``// If n is zero then print this ` `    ``// ways of breaking numbers ` `    ``if` `(n == ``0``) ` `        ``printVector(arr); ` ` `  `    ``// Start from previous element ` `    ``// in the representation till n ` `    ``for``(``int` `j = i; j <= n; j++)  ` `    ``{ ` `         `  `        ``// Include current element ` `        ``// from representation ` `        ``arr.add(j); ` ` `  `        ``// Call function again ` `        ``// with reduced sum ` `        ``findWays(arr, j, n - j); ` ` `  `        ``// Backtrack to remove current ` `        ``// element from representation ` `        ``arr.remove(arr.size() - ``1``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given sum N ` `    ``int` `n = ``4``; ` `     `  `    ``// To store the representation ` `    ``// of breaking N ` `    ``ArrayList arr = ``new` `ArrayList(); ` `     `  `    ``// Function call ` `    ``findWays(arr, ``1``, n); ` `} ` `} ` ` `  `// This code is contributed by offbeat `

## Python3

 `# Python3 program for the above approach ` ` `  `# Function to print the values stored ` `# in vector arr ` `def` `printVector(arr): ` ` `  `    ``if` `(``len``(arr) !``=` `1``): ` ` `  `        ``# Traverse the vector arr ` `        ``for` `i ``in` `range``(``len``(arr)): ` `            ``print``(arr[i], end ``=` `" "``) ` `        ``print``()     ` ` `  `# Recursive function to prdifferent ` `# ways in which N can be written as ` `# a sum of at 2 or more positive integers ` `def` `findWays(arr, i, n): ` ` `  `    ``# If n is zero then prthis ` `    ``# ways of breaking numbers ` `    ``if` `(n ``=``=` `0``): ` `        ``printVector(arr) ` ` `  `    ``# Start from previous element ` `    ``# in the representation till n ` `    ``for` `j ``in` `range``(i, n ``+` `1``): ` ` `  `        ``# Include current element ` `        ``# from representation ` `        ``arr.append(j) ` ` `  `        ``# Call function again ` `        ``# with reduced sum ` `        ``findWays(arr, j, n ``-` `j) ` ` `  `        ``# Backtrack to remove current ` `        ``# element from representation ` `        ``del` `arr[``-``1``] ` `         `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Given sum N ` `    ``n ``=` `4` ` `  `    ``# To store the representation ` `    ``# of breaking N ` `    ``arr ``=` `[] ` ` `  `    ``# Function Call ` `    ``findWays(arr, ``1``, n) ` ` `  `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{  ` ` `  `// Function to print the values stored  ` `// in vector arr  ` `static` `void` `printList(List<``int``> arr)  ` `{  ` `    ``if` `(arr.Count != 1)  ` `    ``{  ` `         `  `        ``// Traverse the vector arr  ` `        ``for``(``int` `i = 0; i < arr.Count; i++)  ` `        ``{  ` `            ``Console.Write(arr[i] + ``" "``);  ` `        ``}  ` `        ``Console.WriteLine();  ` `    ``}  ` `}  ` ` `  `// Recursive function to print different  ` `// ways in which N can be written as  ` `// a sum of at 2 or more positive integers  ` `static` `void` `findWays(List<``int``> arr,  ` `                     ``int` `i, ``int` `n)  ` `{  ` `     `  `    ``// If n is zero then print this  ` `    ``// ways of breaking numbers  ` `    ``if` `(n == 0)  ` `        ``printList(arr);  ` ` `  `    ``// Start from previous element  ` `    ``// in the representation till n  ` `    ``for``(``int` `j = i; j <= n; j++)  ` `    ``{  ` `         `  `        ``// Include current element  ` `        ``// from representation  ` `        ``arr.Add(j);  ` ` `  `        ``// Call function again  ` `        ``// with reduced sum  ` `        ``findWays(arr, j, n - j);  ` ` `  `        ``// Backtrack to remove current  ` `        ``// element from representation  ` `        ``arr.RemoveAt(arr.Count - 1);  ` `    ``}  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `     `  `    ``// Given sum N  ` `    ``int` `n = 4;  ` `     `  `    ``// To store the representation  ` `    ``// of breaking N  ` `    ``List<``int``> arr = ``new` `List<``int``>();  ` `     `  `    ``// Function call  ` `    ``findWays(arr, 1, n);  ` `}  ` `}  ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```1 1 1 1
1 1 2
1 3
2 2
```

Time Complexity: O(2N
Auxiliary Space: O(N2)

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