Print all non-increasing sequences of sum equal to a given number x

Given a number x, print all possible non-increasing sequences with sum equals to x.

Examples:

Input: x = 3
Output: 1 1 1
        2 1
        3

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

We strongly recommend you to minimize your browser and try this yourself first.

The idea is to use a recursive function, an array arr[] to store all sequences one by one and an index variable curr_idx to store current next index in arr[]. Below is algorithm.

1) If current sum is equal to x, then print current sequence.
2) Place all possible numbers from 1 to x-curr_sum numbers at curr_idx in array. Here curr_sum is sum of current elements in arr[]. After placing a number, recur for curr_sum + number and curr_idx+1,

Below is the implementation of above steps.

C++

// C++ program to generate all non-increasing sequences 
// of sum equals to x 
#include<bits/stdc++.h> 
using namespace std; 
  
// Utility function to print array arr[0..n-1] 
void printArr(int arr[], int n) 
{ 
    for (int i=0; i<n; i++) 
      cout << arr[i] << " "; 
    cout << endl; 
} 
  
//  Recursive Function to generate all non-increasing sequences 
// with sum x 
// arr[]    --> Elements of current sequence 
// curr_sum --> Current Sum 
// curr_idx --> Current index in arr[] 
void generateUtil(int x, int arr[], int curr_sum, int curr_idx) 
{ 
   // If current sum is equal to x, then we found a sequence 
   if (curr_sum == x) 
   { 
      printArr(arr, curr_idx); 
      return; 
   } 
  
   // Try placing all numbers from 1 to x-curr_sum at current index 
   int num = 1; 
  
   // The placed number must also be smaller than previously placed 
   // numbers, i.e., arr[curr_idx-1] if there exists a pevious number 
   while (num<=x-curr_sum && (curr_idx==0 || num<=arr[curr_idx-1])) 
   { 
       // Place number at curr_idx 
       arr[curr_idx] = num; 
  
       // Recur 
       generateUtil(x, arr, curr_sum+num, curr_idx+1); 
  
       // Try next number 
       num++; 
   } 
} 
  
// A wrapper over generateUtil() 
void generate(int x) 
{ 
    int arr[x]; // Array to store sequences on by one 
    generateUtil(x, arr, 0, 0); 
} 
  
// Driver program 
int main() 
{ 
    int x = 5; 
    generate(x); 
    return 0; 
} 

Java

// Java program to generate all non-increasing 
// sequences of sum equals to x 
class GFG { 
      
    // Utility function to print array 
    // arr[0..n-1] 
    static void printArr(int arr[], int n) 
    { 
        for (int i = 0; i < n; i++) 
            System.out.printf("%d ", arr[i]); 
              
        System.out.println(""); 
    } 
      
    // Recursive Function to generate all  
    // non-increasing sequences with sum x 
    // arr[] --> Elements of current sequence 
    // curr_sum --> Current Sum 
    // curr_idx --> Current index in arr[] 
    static void generateUtil(int x, int arr[], 
                     int curr_sum, int curr_idx) 
    { 
          
        // If current sum is equal to x, then 
        // we found a sequence 
        if (curr_sum == x) 
        { 
            printArr(arr, curr_idx); 
            return; 
        } 
          
        // Try placing all numbers from 1 to  
        // x-curr_sum at current index 
        int num = 1; 
          
        // The placed number must also be smaller 
        // than previously placed numbers, i.e., 
        // arr[curr_idx-1] if there exists a 
        // pevious number 
        while (num <= x - curr_sum &&  
                             (curr_idx == 0 || 
                     num <= arr[curr_idx - 1])) 
        { 
              
            // Place number at curr_idx 
            arr[curr_idx] = num; 
          
            // Recur 
            generateUtil(x, arr, curr_sum+num, 
                                     curr_idx + 1); 
          
            // Try next number 
            num++; 
        } 
    } 
      
    // A wrapper over generateUtil() 
    static void generate(int x) 
    { 
          
        // Array to store sequences on by one 
        int arr[] = new int [x]; 
        generateUtil(x, arr, 0, 0); 
    } 
      
    // Driver program 
    public static void main(String[] args) 
    { 
        int x = 5; 
        generate(x); 
    } 
} 
  
// This code is contributed by Smitha. 

Python 3

# Python 3 program to generate all 
# non-increasing sequences of sum 
# equals to x 
  
# Utility function to print array 
# arr[0..n-1] 
def printArr(arr, n): 
  
    for i in range(0, n): 
        print(arr[i], end = " ") 
          
    print("") 
  
  
# Recursive Function to generate 
# all non-increasing sequences 
# with sum x arr[] --> Elements 
# of current sequence 
# curr_sum --> Current Sum 
# curr_idx --> Current index in 
# arr[] 
def generateUtil(x, arr, curr_sum, 
                         curr_idx): 
  
# If current sum is equal to x, 
# then we found a sequence 
    if (curr_sum == x): 
  
        printArr(arr, curr_idx) 
        return
  
  
    # Try placing all numbers from  
    # 1 to x-curr_sum at current 
    # index 
    num = 1
      
    # The placed number must also 
    # be smaller than previously 
    # placed numbers, i.e.,  
    # arr[curr_idx-1] if there  
    # exists a pevious number 
    while (num <= x - curr_sum and 
                (curr_idx == 0 or
           num <= arr[curr_idx - 1])): 
  
        # Place number at curr_idx 
        arr[curr_idx] = num 
      
        # Recur 
        generateUtil(x, arr,  
            curr_sum + num, curr_idx + 1) 
      
        # Try next number 
        num += 1
  
  
  
# A wrapper over generateUtil() 
def generate(x): 
  
    # Array to store sequences 
    # on by one 
    arr = [0] * x 
    generateUtil(x, arr, 0, 0) 
  
  
# Driver program 
x = 5
generate(x) 
  
# This code is contributed 
# by Smitha. 

C#

// C# program to generate all non-increasing 
// sequences of sum equals to x 
using System; 
  
class GFG { 
       
    // Utility function to print array 
    // arr[0..n-1] 
    static void printArr(int []arr, int n) 
    { 
        for (int i = 0; i < n; i++) 
            Console.Write( arr[i]); 
               
        Console.WriteLine(); 
    } 
       
    // Recursive Function to generate all  
    // non-increasing sequences with sum x 
    // arr[] --> Elements of current sequence 
    // curr_sum --> Current Sum 
    // curr_idx --> Current index in arr[] 
    static void generateUtil(int x, int []arr, 
                     int curr_sum, int curr_idx) 
    { 
           
        // If current sum is equal to x, then 
        // we found a sequence 
        if (curr_sum == x) 
        { 
            printArr(arr, curr_idx); 
            return; 
        } 
           
        // Try placing all numbers from 1 to  
        // x-curr_sum at current index 
        int num = 1; 
           
        // The placed number must also be smaller 
        // than previously placed numbers, i.e., 
        // arr[curr_idx-1] if there exists a 
        // pevious number 
        while (num <= x - curr_sum &&  
                             (curr_idx == 0 || 
                     num <= arr[curr_idx - 1])) 
        { 
               
            // Place number at curr_idx 
            arr[curr_idx] = num; 
           
            // Recur 
            generateUtil(x, arr, curr_sum+num, 
                                     curr_idx + 1); 
           
            // Try next number 
            num++; 
        } 
    } 
       
    // A wrapper over generateUtil() 
    static void generate(int x) 
    { 
           
        // Array to store sequences on by one 
        int []arr = new int [x]; 
        generateUtil(x, arr, 0, 0); 
    } 
       
    // Driver program 
    public static void Main() 
    { 
        int x = 5; 
        generate(x); 
    } 
} 
   
// This code is contributed by nitin mittal. 

PHP

<?php 
// PHP program to generate all  
// non-increasing sequences 
// of sum equals to x 
  
// function to print array  
// arr[0..n-1] 
function printArr($arr, $n) 
{ 
    for ($i = 0; $i < $n; $i++) 
    echo $arr[$i] , " "; 
    echo " \n"; 
} 
  
// Recursive Function to generate 
// all non-increasing sequences 
// with sum x 
// arr[] --> Elements of current sequence 
// curr_sum --> Current Sum 
// curr_idx --> Current index in arr[] 
function generateUtil($x, $arr, $curr_sum, 
                                $curr_idx) 
{ 
      
    // If current sum is equal to x, 
    // then we found a sequence 
    if ($curr_sum == $x) 
    { 
        printArr($arr, $curr_idx); 
        return; 
    } 
      
    // Try placing all numbers from  
    // 1 to x-curr_sum at current index 
    $num = 1; 
      
    // The placed number must also  
    // be smaller than previously 
    // placed numbers, i.e., arr[curr_idx-1]  
    // if there exists a pevious number 
    while ($num <= $x - $curr_sum and 
          ($curr_idx == 0 or $num <=  
                $arr[$curr_idx - 1])) 
    {   
        // Place number at curr_idx 
        $arr[$curr_idx] = $num; 
      
        // Recur 
        generateUtil($x, $arr, $curr_sum +  
                     $num, $curr_idx + 1); 
      
        // Try next number 
        $num++; 
    } 
} 
  
// A wrapper over generateUtil() 
function generate($x) 
{ 
    // Array to store  
    // sequences on by one 
    $arr = array();  
    generateUtil($x, $arr, 0, 0); 
} 
  
    // Driver Code 
    $x = 5; 
    generate($x); 
  
// This code is contributed by anuj_67. 
?> 

Output:

This article is contributed by Ashish Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes

C++

Java

Python 3

C#

PHP

Recommended Posts: