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

• Difficulty Level : Hard
• Last Updated : 17 Jun, 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``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 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 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#

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

 ` 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

 ``

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