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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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.
?>

chevron_right



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



My Personal Notes arrow_drop_up