Given two integers k and n, write a function that prints all the sequences of length k composed of numbers 1,2..n. You need to print these sequences in sorted order.
Examples:
Input: k = 2, n = 3
Output:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Input: k = 3, n = 4
Output:
1 1 1
1 1 2
1 1 3
1 1 4
1 2 1
.....
.....
4 3 4
4 4 1
4 4 2
4 4 3
4 4 4
Method 1 (Simple and Iterative):
The simple idea to print all sequences in sorted order is to start from {1 1 … 1} and keep incrementing the sequence while the sequence doesn’t become {n n … n}. Following is the detailed process.
1) Create an output array arr[] of size k. Initialize the array as {1, 1…1}.
2) Print the array arr[].
3) Update the array arr[] so that it becomes immediate successor (to be printed) of itself. For example, immediate successor of {1, 1, 1} is {1, 1, 2}, immediate successor of {1, 4, 4} is {2, 1, 1} and immediate successor of {4, 4, 3} is {4 4 4}.
4) Repeat steps 2 and 3 while there is a successor array. In other words, while the output array arr[] doesn’t become {n, n .. n}
Now let us talk about how to modify the array so that it contains immediate successor. By definition, the immediate successor should have the same first p terms and larger (p+l)th term. In the original array, (p+1)th term (or arr[p]) is smaller than n and all terms after arr[p] i.e., arr[p+1], arr[p+2], … arr[k-1] are n.
To find the immediate successor, we find the point p in the previously printed array. To find point p, we start from rightmost side and keep moving till we find a number arr[p] such that arr[p] is smaller than n (or not n). Once we find such a point, we increment it arr[p] by 1 and make all the elements after arr[p] as 1 i.e., we do arr[p+1] = 1, arr[p+2] = 1 .. arr[k-1] = 1. Following are the detailed steps to get immediate successor of arr[]
1) Start from the rightmost term arr[k-1] and move toward left. Find the first element arr[p] that is not same as n.
2) Increment arr[p] by 1
3) Starting from arr[p+1] to arr[k-1], set the value of all terms as 1.
C++
#include<iostream>
using namespace std;
void printArray(int arr[], int size)
{
for(int i = 0; i < size; i++)
cout <<" "<< arr[i];
cout <<"\n";
return;
}
int getSuccessor(int arr[], int k, int n)
{
int p = k - 1;
while (arr[p] == n)
p--;
if (p < 0)
return 0;
arr[p] = arr[p] + 1;
for(int i = p + 1; i < k; i++)
arr[i] = 1;
return 1;
}
void printSequences(int n, int k)
{
int *arr = new int[k];
for(int i = 0; i < k; i++)
arr[i] = 1;
while(1)
{
printArray(arr, k);
if(getSuccessor(arr, k, n) == 0)
break;
}
delete(arr);
return;
}
int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}
|
C
#include<stdio.h>
void printArray(int arr[], int size)
{
for(int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
return;
}
int getSuccessor(int arr[], int k, int n)
{
int p = k - 1;
while (arr[p] == n)
p--;
if (p < 0)
return 0;
arr[p] = arr[p] + 1;
for(int i = p + 1; i < k; i++)
arr[i] = 1;
return 1;
}
void printSequences(int n, int k)
{
int *arr = new int[k];
for(int i = 0; i < k; i++)
arr[i] = 1;
while(1)
{
printArray(arr, k);
if(getSuccessor(arr, k, n) == 0)
break;
}
delete(arr);
return;
}
int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}
|
Java
class GFG
{
static void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
{
System.out.printf("%d ", arr[i]);
}
System.out.printf("\n");
return;
}
static int getSuccessor(int arr[], int k, int n)
{
int p = k - 1;
while (arr[p] == n)
{
p--;
if (p < 0)
{
break;
}
}
if (p < 0)
{
return 0;
}
arr[p] = arr[p] + 1;
for (int i = p + 1; i < k; i++)
{
arr[i] = 1;
}
return 1;
}
static void printSequences(int n, int k)
{
int[] arr = new int[k];
for (int i = 0; i < k; i++)
{
arr[i] = 1;
}
while (true)
{
printArray(arr, k);
if (getSuccessor(arr, k, n) == 0)
{
break;
}
}
}
public static void main(String[] args)
{
int n = 3;
int k = 2;
printSequences(n, k);
}
}
|
Python3
def printArray(arr, size):
for i in range(size):
print(arr[i], end = " ")
print()
return
def getSuccessor(arr, k, n):
p = k - 1
while (arr[p] == n and 0 <= p < k):
p -= 1
if (p < 0):
return 0
arr[p] = arr[p] + 1
i = p + 1
while(i < k):
arr[i] = 1
i += 1
return 1
def printSequences(n, k):
arr = [0] * k
for i in range(k):
arr[i] = 1
while(1):
printArray(arr, k)
if(getSuccessor(arr, k, n) == 0):
break
return
n = 3
k = 2
printSequences(n, k)
|
C#
using System;
class GFG
{
static void printArray(int []arr, int size)
{
for (int i = 0; i < size; i++)
{
Console.Write("{0} ", arr[i]);
}
Console.Write("\n");
return;
}
static int getSuccessor(int []arr, int k, int n)
{
int p = k - 1;
while (arr[p] == n)
{
p--;
if (p < 0)
{
break;
}
}
if (p < 0)
{
return 0;
}
arr[p] = arr[p] + 1;
for (int i = p + 1; i < k; i++)
{
arr[i] = 1;
}
return 1;
}
static void printSequences(int n, int k)
{
int[] arr = new int[k];
for (int i = 0; i < k; i++)
{
arr[i] = 1;
}
while (true)
{
printArray(arr, k);
if (getSuccessor(arr, k, n) == 0)
{
break;
}
}
}
public static void Main(String[] args)
{
int n = 3;
int k = 2;
printSequences(n, k);
}
}
|
Javascript
<script>
function printArray(arr , size)
{
for (i = 0; i < size; i++)
{
document.write(arr[i]+" ");
}
document.write("<br>");
return;
}
function getSuccessor(arr , k , n)
{
var p = k - 1;
while (arr[p] == n)
{
p--;
if (p < 0)
{
break;
}
}
if (p < 0)
{
return 0;
}
arr[p] = arr[p] + 1;
for (i = p + 1; i < k; i++)
{
arr[i] = 1;
}
return 1;
}
function printSequences(n , k)
{
var arr = Array.from({length: k}, (_, i) => 0);
for (i = 0; i < k; i++)
{
arr[i] = 1;
}
while (true)
{
printArray(arr, k);
if (getSuccessor(arr, k, n) == 0)
{
break;
}
}
}
var n = 3;
var k = 2;
printSequences(n, k);
</script>
|
Output:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Time Complexity: There are total n^k sequences. Printing a sequence and finding its successor take O(k) time. So time complexity of above implementation is O(k*n^k).
Auxiliary Space: O(k)
Method 2 (Tricky and Recursive)
The recursive function printSequencesRecur generates and prints all sequences of length k. The idea is to use one more parameter index. The function printSequencesRecur keeps all the terms in arr[] same till index, update the value at index and recursively calls itself for more terms after index.
C++
#include<iostream>
using namespace std;
void printArray(int arr[], int size)
{
for(int i = 0; i < size; i++)
cout<< " "<< arr[i];
cout<<"\n";
return;
}
void printSequencesRecur(int arr[], int n, int k, int index)
{
int i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i<=n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k-1, index+1);
}
}
}
void printSequences(int n, int k)
{
int *arr = new int[k];
printSequencesRecur(arr, n, k, 0);
delete(arr);
return;
}
int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}
|
C
#include<stdio.h>
void printArray(int arr[], int size)
{
for(int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
return;
}
void printSequencesRecur(int arr[], int n, int k, int index)
{
int i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i<=n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k-1, index+1);
}
}
}
void printSequences(int n, int k)
{
int *arr = new int[k];
printSequencesRecur(arr, n, k, 0);
delete(arr);
return;
}
int main()
{
int n = 3;
int k = 2;
printSequences(n, k);
return 0;
}
|
Java
class GfG {
static void printArray(int arr[], int size)
{
for(int i = 0; i < size; i++)
System.out.print(arr[i] + " ");
System.out.println();
return;
}
static void printSequencesRecur(int arr[], int n, int k, int index)
{
int i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i<=n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k-1, index+1);
}
}
}
static void printSequences(int n, int k)
{
int arr[] = new int[k];
printSequencesRecur(arr, n, k, 0);
return ;
}
public static void main(String[] args)
{
int n = 3;
int k = 2;
printSequences(n, k);
}
}
|
Python3
def printArray(arr, size):
for i in range(size):
print(arr[i], end = " ");
print("");
return;
def printSequencesRecur(arr, n, k, index):
if (k == 0):
printArray(arr, index);
if (k > 0):
for i in range(1, n + 1):
arr[index] = i;
printSequencesRecur(arr, n, k - 1,
index + 1);
def printSequences(n, k):
arr = [0] * n;
printSequencesRecur(arr, n, k, 0);
return;
n = 3;
k = 2;
printSequences(n, k);
|
C#
using System;
class GFG
{
static void printArray(int []arr, int size)
{
for(int i = 0; i < size; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
return;
}
static void printSequencesRecur(int []arr, int n,
int k, int index)
{
int i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i<=n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k - 1, index + 1);
}
}
}
static void printSequences(int n, int k)
{
int[] arr = new int[k];
printSequencesRecur(arr, n, k, 0);
return;
}
public static void Main()
{
int n = 3;
int k = 2;
printSequences(n, k);
}
}
|
PHP
<?php
function printArray($arr, $size)
{
for($i = 0; $i < $size; $i++)
echo $arr[$i] . " ";
echo "\n";
return;
}
function printSequencesRecur($arr, $n, $k, $index)
{
if ($k == 0)
{
printArray($arr, $index);
}
if ($k > 0)
{
for($i = 1; $i <= $n; ++$i)
{
$arr[$index] = $i;
printSequencesRecur($arr, $n,
$k - 1, $index + 1);
}
}
}
function printSequences($n, $k)
{
$arr = array();
printSequencesRecur($arr, $n, $k, 0);
return;
}
$n = 3;
$k = 2;
printSequences($n, $k);
?>
|
Javascript
<script>
function printArray(arr, size)
{
for(i = 0; i < size; i++)
document.write(arr[i] + " ");
document.write("<br>");
return;
}
function printSequencesRecur(arr , n , k , index)
{
var i;
if (k == 0)
{
printArray(arr, index);
}
if (k > 0)
{
for(i = 1; i <= n; ++i)
{
arr[index] = i;
printSequencesRecur(arr, n, k - 1, index+1);
}
}
}
function printSequences(n, k)
{
var arr = Array.from({length: k}, (_, i) => 0);
printSequencesRecur(arr, n, k, 0);
return ;
}
var n = 3;
var k = 2;
printSequences(n, k);
</script>
|
Output:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Time Complexity: There are n^k sequences and printing a sequence takes O(k) time. So time complexity is O(k*n^k).
Auxiliary Space: O(k)
Thanks to mopurizwarriors for suggesting above method. As suggested by alphayoung, we can avoid use of arrays for small sequences that can fit in an integer. Following is the implementation for same.
C++
void printSeqRecur(int num, int pos, int k, int n)
{
if (pos == k)
{
cout << num << endl;
return;
}
for (int i = 1; i <= n; i++)
{
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
void printSequences(int k, int n)
{
printSeqRecur(0, 0, k, n);
}
|
C
void printSeqRecur(int num, int pos, int k, int n)
{
if (pos == k) {
printf("%d \n", num);
return;
}
for (int i = 1; i <= n; i++) {
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
void printSequences(int k, int n)
{
printSeqRecur(0, 0, k, n);
}
|
Java
static void printSeqRecur(int num, int pos, int k, int n)
{
if (pos == k) {
System.out.print(num + " ");
return;
}
for (int i = 1; i <= n; i++) {
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
static void printSequences(int k, int n)
{
printSeqRecur(0, 0, k, n);
}
|
Python3
def printSeqRecur ( num , n, k ):
if n == 0:
print(num )
return
for _ in range(1, k + 1):
printSeqRecur (num * 10 + _, n - 1, k)
if __name__ == "__main__":
k = 3
n = 2
printSeqRecur(0, n, k)
|
C#
static void printSeqRecur(int num, int pos,
int k, int n)
{
if (pos == k)
{
Console.Write(num + " ");
return;
}
for (int i = 1; i <= n; i++)
{
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
static void printSequences(int k, int n)
{
printSeqRecur(0, 0, k, n);
}
|
PHP
<?php
function printSeqRecur ($num ,$n, $k)
{
if ($n == 0)
{
# if total digits become equal
# to n, print the number and return
print($num . "\n");
return;
}
for ($i = 1; $i < $k + 1; $i++)
printSeqRecur($num * 10 +
$i, $n - 1, $k);
}
$k = 3;
$n = 2;
printSeqRecur(0, $n, $k);
?>
|
Javascript
<script>
function printSeqRecur( num, pos, k, n)
{
if (pos == k)
{
document.write( num + "<br>" );
return;
}
for (var i = 1; i <= n; i++)
{
printSeqRecur(num * 10 + i, pos + 1, k, n);
}
}
function printSequences( k, n)
{
printSeqRecur(0, 0, k, n);
}
</script>
|
Time Complexity: O(k*n^k)
Auxiliary Space: O(n * k)
References:
Algorithms and Programming: Problems and Solutions by Alexander Shen
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!