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

• Difficulty Level : Medium
• Last Updated : 20 Apr, 2021

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 one of the ways 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 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`

## Javascript

 ``

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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :