Posted on by Kalkicode
Code Backtracking

# Increasing subsequence of n natural number in k size

Here given code implementation process.

``````// C Program
// Increasing subsequence of n natural number in k size
#include <stdio.h>

// Display result elements
void printResult(int result[], int k)
{
for (int i = 0; i < k; ++i)
{
printf(" %d", result[i]);
}
printf("\n");
}
void subSequences(int result[], int num,
int start, int count, int k)
{
if (count == k)
{
// Display calculated result
printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
for (int i = start + 1; i <= num; ++i)
{
// Collect elements
result[count] = i;
subSequences(result, num, i, count + 1, k);
}
}
}
// Handles the request to find resultant subsequences
void findSequence(int n, int k)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
int result[k];
// Find resultant subsequences
subSequences(result, n, 0, 0, k);
}
int main()
{
int n = 5;
int k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
findSequence(n, k);
return 0;
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````// Java program for
// Increasing subsequence of n natural number in k size
public class Combination
{
// Display result elements
public void printResult(int[] result, int k)
{
for (int i = 0; i < k; ++i)
{
System.out.print(" " + result[i]);
}
System.out.print("\n");
}
public void subSequences(int[] result,
int num, int start,
int count, int k)
{
if (count == k)
{
// Display calculated result
printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
for (int i = start + 1; i <= num; ++i)
{
// Collect elements
result[count] = i;
subSequences(result, num, i, count + 1, k);
}
}
}
// Handles the request to find resultant subsequences
public void findSequence(int n, int k)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
int[] result = new int[k];
// Find resultant subsequences
subSequences(result, n, 0, 0, k);
}
public static void main(String[] args)
{
int n = 5;
int k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````// Include header file
#include <iostream>

using namespace std;
// C++ program for
// Increasing subsequence of n natural number in k size
class Combination
{
public:
// Display result elements
void printResult(int result[], int k)
{
for (int i = 0; i < k; ++i)
{
cout << " " << result[i];
}
cout << "\n";
}
void subSequences(int result[],
int num,
int start,
int count,
int k)
{
if (count == k)
{
// Display calculated result
this->printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
for (int i = start + 1; i <= num; ++i)
{
// Collect elements
result[count] = i;
this->subSequences(result, num, i, count + 1, k);
}
}
}
// Handles the request to find resultant subsequences
void findSequence(int n, int k)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
int result[k];
// Find resultant subsequences
this->subSequences(result, n, 0, 0, k);
}
};
int main()
{
int n = 5;
int k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
return 0;
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````// Include namespace system
using System;
// Csharp program for
// Increasing subsequence of n natural number in k size
public class Combination
{
// Display result elements
public void printResult(int[] result, int k)
{
for (int i = 0; i < k; ++i)
{
Console.Write(" " + result[i]);
}
Console.Write("\n");
}
public void subSequences(int[] result,
int num,
int start,
int count, int k)
{
if (count == k)
{
// Display calculated result
this.printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
for (int i = start + 1; i <= num; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(result, num, i, count + 1, k);
}
}
}
// Handles the request to find resultant subsequences
public void findSequence(int n, int k)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
int[] result = new int[k];
// Find resultant subsequences
this.subSequences(result, n, 0, 0, k);
}
public static void Main(String[] args)
{
int n = 5;
int k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````package main
import "fmt"
// Go program for
// Increasing subsequence of n natural number in k size
type Combination struct {}
func getCombination() * Combination {
var me *Combination = &Combination {}
return me
}
// Display result elements
func(this Combination) printResult(result[] int, k int) {
for i := 0 ; i < k ; i++ {
fmt.Print(" ", result[i])
}
fmt.Print("\n")
}
func(this Combination) subSequences(result[] int,
num int,
start int,
count int,
k int) {
if count == k {
// Display calculated result
this.printResult(result, k)
return
} else if count > k {
return
} else {
for i := start + 1 ; i <= num ; i++ {
// Collect elements
result[count] = i
this.subSequences(result,
num,
i,
count + 1,
k)
}
}
}
// Handles the request to find resultant subsequences
func(this Combination) findSequence(n, k int) {
if n <= 0 || k <= 0 {
return
}
// Auxiliary array which is collect result
var result = make([] int, k)
// Find resultant subsequences
this.subSequences(result, n, 0, 0, k)
}
func main() {
var task * Combination = getCombination()
var n int = 5
var k int = 3
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````<?php
// Php program for
// Increasing subsequence of n natural number in k size
class Combination
{
// Display result elements
public	function printResult(\$result, \$k)
{
for (\$i = 0; \$i < \$k; ++\$i)
{
echo(" ".\$result[\$i]);
}
echo("\n");
}
public	function subSequences(\$result,
\$num,
\$start,
\$count, \$k)
{
if (\$count == \$k)
{
// Display calculated result
\$this->printResult(\$result, \$k);
return;
}
else if (\$count > \$k)
{
return;
}
else
{
for (\$i = \$start + 1; \$i <= \$num; ++\$i)
{
// Collect elements
\$result[\$count] = \$i;
\$this->subSequences(\$result,
\$num, \$i,
\$count + 1, \$k);
}
}
}
// Handles the request to find resultant subsequences
public	function findSequence(\$n, \$k)
{
if (\$n <= 0 || \$k <= 0)
{
return;
}
// Auxiliary array which is collect result
\$result = array_fill(0, \$k, 0);
// Find resultant subsequences
\$this->subSequences(\$result, \$n, 0, 0, \$k);
}
}

function main()
{
\$n = 5;
\$k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
main();``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````// Node JS program for
// Increasing subsequence of n natural number in k size
class Combination
{
// Display result elements
printResult(result, k)
{
for (var i = 0; i < k; ++i)
{
process.stdout.write(" " + result[i]);
}
process.stdout.write("\n");
}
subSequences(result, num, start, count, k)
{
if (count == k)
{
// Display calculated result
this.printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
for (var i = start + 1; i <= num; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(result,
num, i,
count + 1, k);
}
}
}
// Handles the request to find resultant subsequences
findSequence(n, k)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
var result = Array(k).fill(0);
// Find resultant subsequences
this.subSequences(result, n, 0, 0, k);
}
}

function main()
{
var n = 5;
var k = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
main();``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````#  Python 3 program for
#  Increasing subsequence of n natural number in k size
class Combination :
#  Display result elements
def printResult(self, result, k) :
i = 0
while (i < k) :
print(" ", result[i], end = "")
i += 1

print(end = "\n")

def subSequences(self, result,
num,
start,
count,
k) :
if (count == k) :
#  Display calculated result
self.printResult(result, k)
return
elif (count > k) :
return
else :
i = start + 1
while (i <= num) :
#  Collect elements
result[count] = i
self.subSequences(result,
num, i,
count + 1, k)
i += 1

#  Handles the request to find resultant subsequences
def findSequence(self, n, k) :
if (n <= 0 or k <= 0) :
return

#  Auxiliary list which is collect result
result = [0] * (k)
#  Find resultant subsequences
self.subSequences(result, n, 0, 0, k)

def main() :
n = 5
k = 3
#  Test A
#  n >= k
#  length k = 3
#  number (1..5)
#    1 2 3
#    1 2 4
#    1 2 5
#    1 3 4
#    1 3 5
#    1 4 5
#    2 3 4
#    2 3 5
#    2 4 5
#    3 4 5
#  --------------
#    All Unique result

if __name__ == "__main__": main()``````

#### Output

``````  1  2  3
1  2  4
1  2  5
1  3  4
1  3  5
1  4  5
2  3  4
2  3  5
2  4  5
3  4  5``````
``````#  Ruby program for
#  Increasing subsequence of n natural number in k size
class Combination
#  Display result elements
def printResult(result, k)
i = 0
while (i < k)
print(" ", result[i])
i += 1
end

print("\n")
end

def subSequences(result, num, start, count, k)
if (count == k)
#  Display calculated result
self.printResult(result, k)
return
elsif (count > k)
return
else

i = start + 1
while (i <= num)
#  Collect elements
result[count] = i
self.subSequences(result, num, i, count + 1, k)
i += 1
end

end

end

#  Handles the request to find resultant subsequences
def findSequence(n, k)
if (n <= 0 || k <= 0)
return
end

#  Auxiliary array which is collect result
result = Array.new(k) {0}
#  Find resultant subsequences
self.subSequences(result, n, 0, 0, k)
end

end

def main()
n = 5
k = 3
#  Test A
#  n >= k
#  length k = 3
#  number (1..5)
#    1 2 3
#    1 2 4
#    1 2 5
#    1 3 4
#    1 3 5
#    1 4 5
#    2 3 4
#    2 3 5
#    2 4 5
#    3 4 5
#  --------------
#    All Unique result
end

main()``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
``````
``````// Scala program for
// Increasing subsequence of n natural number in k size
class Combination()
{
// Display result elements
def printResult(result: Array[Int], k: Int): Unit = {
var i: Int = 0;
while (i < k)
{
print(" " + result(i));
i += 1;
}
print("\n");
}
def subSequences(result: Array[Int],
num: Int, start: Int,
count: Int, k: Int): Unit = {
if (count == k)
{
// Display calculated result
printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= num)
{
// Collect elements
result(count) = i;
subSequences(result, num, i, count + 1, k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
def findSequence(n: Int, k: Int): Unit = {
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
var result: Array[Int] = Array.fill[Int](k)(0);
// Find resultant subsequences
subSequences(result, n, 0, 0, k);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combination = new Combination();
var n: Int = 5;
var k: Int = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````
``````// Swift 4 program for
// Increasing subsequence of n natural number in k size
class Combination
{
// Display result elements
func printResult(_ result: [Int], _ k: Int)
{
var i: Int = 0;
while (i < k)
{
print(" ", result[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
func subSequences(_ result: inout[Int],
_ num: Int, _ start: Int,
_ count: Int, _ k: Int)
{
if (count == k)
{
// Display calculated result
self.printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= num)
{
// Collect elements
result[count] = i;
self.subSequences(&result, num, i, count + 1, k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
func findSequence(_ n: Int, _ k: Int)
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
var result: [Int] = Array(repeating: 0, count: k);
// Find resultant subsequences
self.subSequences(&result, n, 0, 0, k);
}
}
func main()
{
let n: Int = 5;
let k: Int = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}
main();``````

#### Output

``````  1  2  3
1  2  4
1  2  5
1  3  4
1  3  5
1  4  5
2  3  4
2  3  5
2  4  5
3  4  5``````
``````// Kotlin program for
// Increasing subsequence of n natural number in k size
class Combination
{
// Display result elements
fun printResult(result: Array < Int > , k: Int): Unit
{
var i: Int = 0;
while (i < k)
{
print(" " + result[i]);
i += 1;
}
print("\n");
}
fun subSequences(
result: Array < Int > ,
num: Int,
start: Int,
count: Int,
k: Int): Unit
{
if (count == k)
{
// Display calculated result
this.printResult(result, k);
return;
}
else if (count > k)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= num)
{
// Collect elements
result[count] = i;
this.subSequences(result, num, i, count + 1, k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
fun findSequence(n: Int, k: Int): Unit
{
if (n <= 0 || k <= 0)
{
return;
}
// Auxiliary array which is collect result
val result: Array < Int > = Array(k)
{
0
};
// Find resultant subsequences
this.subSequences(result, n, 0, 0, k);
}
}
fun main(args: Array < String > ): Unit
{
val n: Int = 5;
val k: Int = 3;
// Test A
// n >= k
// length k = 3
// number (1..5)
/*
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
--------------
All Unique result
*/
}``````

#### Output

`````` 1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post