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

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

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