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

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

Python 3

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

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

Output:

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

Suggest a Topic

C++

Java

Python 3

C#

PHP

Recommended Posts: