Generate all unique partitions of an integer | Set 2

Given a positive integer n, the task is to generate all possible unique ways to represent n as sum of positive integers.

Examples:

Input: 4
Output:
4
3 1
2 2
2 1 1
1 1 1 1

Input: 3
Output:
3
2 1
1 1 1

Approach: We have already discussed the implementation of generating unique partitions in this post. This post contains another and far more intuitive implementation for the above problem using recursion.

The idea is simple and is kind of same approach as used here. We have to move recursively from n to 1 and keep on appending the numbers used to form sum in the array. When the sum becomes equal to n then we print the array and return. The base cases considered in the implementation are: remSum == 0: Required n is formed so print the array.

Then we have started forming required sum using the max value number used in the previous partition. If that number becomes greater than n we ignore it else we append that number to the array and move recursively to next iteration to form sum = (remSum – i) and where max value
number that could be used is i or less than i. This way we can generate the required unique partitions.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Array to store the numbers used
// to form the required sum
int dp[200];
int count = 0;
  
// Function to print the array which contains
// the unique partitions which are used
// to form the required sum
void print(int idx)
{
    for (int i = 1; i < idx; i++) {
        cout << dp[i] << " ";
    }
    cout << endl;
}
  
// Function to find all the unique partitions
// remSum = remaining sum to form
// maxVal is the maximum number that
// can be used to make the partition
void solve(int remSum, int maxVal, int idx, int& count)
{
  
    // If remSum == 0 that means the sum
    // is achieved so print the array
    if (remSum == 0) {
        print(idx);
        count++;
        return;
    }
  
    // i will begin from maxVal which is the
    // maximum value which can be used to form the sum
    for (int i = maxVal; i >= 1; i--) {
        if (i > remSum) {
            continue;
        }
        else if (i <= remSum) {
  
            // Store the number used in forming
            // sum gradually in the array
            dp[idx] = i;
  
            // Since i used the rest of partition
            // cant have any number greater than i
            // hence second parameter is i
            solve(remSum - i, i, idx + 1, count);
        }
    }
}
  
// Driver code
int main()
{
    int n = 4, count = 0;
  
    solve(n, n, 1, count);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach 
import java.util.*;
  
class GFG 
{
  
    // Array to store the numbers used 
    // to form the required sum 
    static int[] dp = new int[200];
    static int count = 0;
  
    // Function to print the array which contains 
    // the unique partitions which are used 
    // to form the required sum 
    static void print(int idx) 
    {
        for (int i = 1; i < idx; i++) 
        {
            System.out.print(dp[i] + " ");
        }
        System.out.println("");
    }
  
    // Function to find all the unique partitions 
    // remSum = remaining sum to form 
    // maxVal is the maximum number that 
    // can be used to make the partition 
    static void solve(int remSum, int maxVal, 
                        int idx, int count)
    {
  
        // If remSum == 0 that means the sum 
        // is achieved so print the array 
        if (remSum == 0
        {
            print(idx);
            count++;
            return;
        }
  
        // i will begin from maxVal which is the 
        // maximum value which can be used to form the sum 
        for (int i = maxVal; i >= 1; i--) 
        {
            if (i > remSum) 
            {
                continue;
            }
            else if (i <= remSum)
            {
  
                // Store the number used in forming 
                // sum gradually in the array 
                dp[idx] = i;
  
                // Since i used the rest of partition 
                // cant have any number greater than i 
                // hence second parameter is i 
                solve(remSum - i, i, idx + 1, count);
            }
        }
    }
  
    // Driver code 
    public static void main(String[] args)
    {
        int n = 4, count = 0;
  
        solve(n, n, 1, count);
    }
}
  
// This code has been contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of the approach
  
# Array to store the numbers used
# to form the required sum
dp = [0 for i in range(200)]
count = 0
  
# Function to print the array which contains
# the unique partitions which are used
# to form the required sum
def print1(idx):
    for i in range(1,idx,1):
        print(dp[i],end = " ")
    print("\n",end = "")
  
# Function to find all the unique partitions
# remSum = remaining sum to form
# maxVal is the maximum number that
# can be used to make the partition
def solve(remSum,maxVal,idx,count):
    # If remSum == 0 that means the sum
    # is achieved so print the array
    if (remSum == 0):
        print1(idx)
        count += 1
        return
    # i will begin from maxVal which is the
    # maximum value which can be used to form the sum
    i = maxVal
    while(i >= 1):
        if (i > remSum):
            i -= 1
            continue
        elif (i <= remSum):
            # Store the number used in forming
            # sum gradually in the array
            dp[idx] = i
  
            # Since i used the rest of partition
            # cant have any number greater than i
            # hence second parameter is i
            solve(remSum - i, i, idx + 1, count)
            i -= 1
  
# Driver code
if __name__ == '__main__':
    n = 4
    count = 0
  
    solve(n, n, 1, count)
      
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG 
  
    // Array to store the numbers used 
    // to form the required sum 
    static int[] dp = new int[200]; 
  
    // Function to print the array which contains 
    // the unique partitions which are used 
    // to form the required sum 
    static void print(int idx) 
    
        for (int i = 1; i < idx; i++) 
        
            Console.Write(dp[i] + " "); 
        
        Console.WriteLine(""); 
    
  
    // Function to find all the unique partitions 
    // remSum = remaining sum to form 
    // maxVal is the maximum number that 
    // can be used to make the partition 
    static void solve(int remSum, int maxVal, 
                        int idx, int count) 
    
  
        // If remSum == 0 that means the sum 
        // is achieved so print the array 
        if (remSum == 0) 
        
            print(idx); 
            count++; 
            return
        
  
        // i will begin from maxVal which is the 
        // maximum value which can be used to form the sum 
        for (int i = maxVal; i >= 1; i--) 
        
            if (i > remSum) 
            
                continue
            
            else if (i <= remSum) 
            
  
                // Store the number used in forming 
                // sum gradually in the array 
                dp[idx] = i; 
  
                // Since i used the rest of partition 
                // cant have any number greater than i 
                // hence second parameter is i 
                solve(remSum - i, i, idx + 1, count); 
            
        
    
  
    // Driver code 
    public static void Main() 
    
        int n = 4, count = 0; 
  
        solve(n, n, 1, count); 
    }
  
// This code is contributed by AnkitRai01 

chevron_right


Output:

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


My Personal Notes arrow_drop_up

Competitive Programmer, Full Stack Developer

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.