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

Last Updated : 10 Feb, 2023

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 previous 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 one 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 previous 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 previous 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# 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 previous 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 previous 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 previous 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

Maximize sum of all elements which are not a part of the Longest Increasing Subsequence

Ashish Gupta

Improve

Article Tags :

Practice Tags :

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

Similar Reads