# 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& 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& 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 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 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 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 arr = new List();             // 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.