Skip to content
Related Articles

Related Articles

Print all non-increasing sequences of sum equal to a given number x
  • Difficulty Level : Hard
  • Last Updated : 13 Apr, 2021

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 and it may be equal to
   // the previous stored value, 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)
{
     
    // Array to store sequences on by one
    int arr[x];
    generateUtil(x, arr, 0, 0);
}
 
// Driver code
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 and it may be equal to
           // the previous stored value, 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.

Python3




# Python3 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 and it may be equal to
    # the previous stored value, 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 and it may be equal to
           // the previous stored value, 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 and it may be equal to
    // the previous stored value, 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.
?>

Javascript




<script>
 
// Javascript program to generate all
// non-increasing sequences of sum equals to x
 
// Utility function to print array
// arr[0..n-1]
function printArr(arr, n)
{
    for(let i = 0; i < n; i++)
        document.write(arr[i] + " ");
           
    document.write("</br>");
}
   
// 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
    let num = 1;
       
    // The placed number must also be
    // smaller than previously placed
    // numbers and it may be equal to
    // the previous stored value, 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()
function generate(x)
{
     
    // Array to store sequences on by one
    let arr = new Array(x);
    generateUtil(x, arr, 0, 0);
}
 
// Driver code  
let x = 5;
 
generate(x);
   
// This code is contributed by divyeshrabadiya07    
 
</script>

Output: 

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

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
 

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 :