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 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
Similar Reads
Count number of increasing sub-sequences : O(NlogN) Given an array arr[] of length N, the task is to find the number of strictly increasing sub-sequences in the given array.Examples: Input: arr[] = {1, 2, 3} Output: 7 All increasing sub-sequences will be: 1) {1} 2) {2} 3) {3} 4) {1, 2} 5) {1, 3} 6) {2, 3} 7) {1, 2, 3} Thus, answer = 7Input: arr[] = {
12 min read
Generate sequence with equal sum of adjacent integers Given an integer N, find a sequence of N integers such that the sum of all integers in the sequence is equal to the sum of any two adjacent integers in the sequence. Examples: Input: N = 4Output: 1 -1 1 -1Explanation: Total sum of the four integers is 0 and the sum of any two adjacent integers is al
8 min read
Find all subsequences with sum equals to K Given an array arr[] of length n and a number k, the task is to find all the subsequences of the array with sum of its elements equal to k.Note: A subsequence is a subset that can be derived from an array by removing zero or more elements, without changing the order of the remaining elements.Example
7 min read
Minimum number of elements which are not part of Increasing or decreasing subsequence in array Given an array of n elements. Make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements which are not
12 min read
Count of subsequences in an array with sum less than or equal to X Given an integer array arr[] of size N and an integer X, the task is to count the number of subsequences in that array such that its sum is less than or equal to X. Note: 1 <= N <= 1000 and 1 <= X <= 1000, where N is the size of the array. Examples: Input : arr[] = {84, 87, 73}, X = 100
13 min read