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