# Find all subsequences whose product is less than k in array

Here given code implementation process.

``````// C Program
// Find all subsequences whose product is less than k in array
#include <stdio.h>

void subSequences(int arr[],
int result[],
int start,
int count,
int product,
int n,
int k)
{
if (product <= k)
{
for (int i = 0; i < count; ++i)
{
printf(" %d", result[i]);
}
printf("\n");
}
if (count >= n)
{
return;
}
else
{
for (int i = start + 1; i <= n; ++i)
{
// Collect elements
result[count] = i;
subSequences(arr, result, i,
count + 1, product *i, n, k);
}
}
}
// Handles the request to find resultant subsequences
void findProductSequence(int arr[], int n, int k)
{
// Auxiliary array which is collect result
int result[n];
subSequences(arr, result, 0, 0, 1, n, k);
}
int main()
{
int arr[] = {
1 , 2 , 3 , 4
};
int n = sizeof(arr) / sizeof(arr[0]);
// Product
int k = 6;
// Test
//
findProductSequence(arr, n, k);
return 0;
}``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````// Java program for
// Find all subsequences whose product is less than k in array
public class Combination
{
public void subSequences(int[] arr,
int[] result,
int start,
int count,
int product,
int n,
int k)
{
if (product <= k)
{
for (int i = 0; i < count; ++i)
{
System.out.print(" " + result[i]);
}
System.out.print("\n");
}
if (count >= n)
{
return;
}
else
{
for (int i = start + 1; i <= n; ++i)
{
// Collect elements
result[count] = i;
subSequences(arr, result, i,
count + 1,
product * i,
n, k);
}
}
}
// Handles the request to find resultant subsequences
public void findProductSequence(int[] arr, int n, int k)
{
// Auxiliary array which is collect result
int[] result = new int[n];
subSequences(arr, result, 0, 0, 1, n, k);
}
public static void main(String[] args)
{
int[] arr = {
1 , 2 , 3 , 4
};
int n = arr.length;
// Product
int k = 6;
// Test
}
}``````

#### Output

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

using namespace std;
// C++ program for
// Find all subsequences whose product is less than k in array
class Combination
{
public: void subSequences(
int arr[],
int result[],
int start,
int count,
int product,
int n,
int k)
{
if (product <= k)
{
for (int i = 0; i < count; ++i)
{
cout << " " << result[i];
}
cout << "\n";
}
if (count >= n)
{
return;
}
else
{
for (int i = start + 1; i <= n; ++i)
{
// Collect elements
result[count] = i;
this->subSequences(arr, result,
i, count + 1,
product *i,
n, k);
}
}
}
// Handles the request to find resultant subsequences
void findProductSequence(int arr[], int n, int k)
{
// Auxiliary array which is collect result
int result[n];
this->subSequences(arr, result, 0, 0, 1, n, k);
}
};
int main()
{
int arr[] = {
1 , 2 , 3 , 4
};
int n = sizeof(arr) / sizeof(arr[0]);
// Product
int k = 6;
// Test
return 0;
}``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````// Include namespace system
using System;
// Csharp program for
// Find all subsequences whose product is less than k in array
public class Combination
{
public void subSequences(
int[] arr,
int[] result,
int start,
int count,
int product,
int n,
int k)
{
if (product <= k)
{
for (int i = 0; i < count; ++i)
{
Console.Write(" " + result[i]);
}
Console.Write("\n");
}
if (count >= n)
{
return;
}
else
{
for (int i = start + 1; i <= n; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(arr, result,
i, count + 1,
product * i,
n,
k);
}
}
}
// Handles the request to find resultant subsequences
public void findProductSequence(int[] arr, int n, int k)
{
// Auxiliary array which is collect result
int[] result = new int[n];
this.subSequences(arr, result, 0, 0, 1, n, k);
}
public static void Main(String[] args)
{
int[] arr = {
1 , 2 , 3 , 4
};
int n = arr.Length;
// Product
int k = 6;
// Test
}
}``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````package main
import "fmt"
// Go program for
// Find all subsequences whose product is less than k in array
type Combination struct {}
func getCombination() * Combination {
var me *Combination = &Combination {}
return me
}
func(this Combination) subSequences(arr[] int,
result[] int,
start int,
count int,
product int,
n int,
k int) {
if product <= k {
for i := 0 ; i < count ; i++ {
fmt.Print(" ", result[i])
}
fmt.Print("\n")
}
if count >= n {
return
} else {
for i := start + 1 ; i <= n ; i++ {
// Collect elements
result[count] = i
this.subSequences(arr, result,
i, count + 1,
product * i, n, k)
}
}
}
// Handles the request to find resultant subsequences
func(this Combination) findProductSequence(arr[] int,
n int, k int) {
// Auxiliary array which is collect result
var result = make([] int, n)
this.subSequences(arr, result, 0, 0, 1, n, k)
}
func main() {
var task * Combination = getCombination()
var arr = [] int {
1,
2,
3,
4,
}
var n int = len(arr)
// Product
var k int = 6
// Test
}``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````<?php
// Php program for
// Find all subsequences whose product is less than k in array
class Combination
{
public	function subSequences(\$arr,
\$result,
\$start,
\$count,
\$product,
\$n,
\$k)
{
if (\$product <= \$k)
{
for (\$i = 0; \$i < \$count; ++\$i)
{
echo(" ".\$result[\$i]);
}
echo("\n");
}
if (\$count >= \$n)
{
return;
}
else
{
for (\$i = \$start + 1; \$i <= \$n; ++\$i)
{
// Collect elements
\$result[\$count] = \$i;
\$this->subSequences(\$arr,
\$result,
\$i,
\$count + 1,
\$product * \$i,
\$n,
\$k);
}
}
}
// Handles the request to find resultant subsequences
public	function findProductSequence(\$arr, \$n, \$k)
{
// Auxiliary array which is collect result
\$result = array_fill(0, \$n, 0);
\$this->subSequences(\$arr, \$result, 0, 0, 1, \$n, \$k);
}
}

function main()
{
\$arr = array(1, 2, 3, 4);
\$n = count(\$arr);
// Product
\$k = 6;
// Test
}
main();``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````// Node JS program for
// Find all subsequences whose product is less than k in array
class Combination
{
subSequences(arr, result, start, count, product, n, k)
{
if (product <= k)
{
for (var i = 0; i < count; ++i)
{
process.stdout.write(" " + result[i]);
}
process.stdout.write("\n");
}
if (count >= n)
{
return;
}
else
{
for (var i = start + 1; i <= n; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(arr, result, i,
count + 1,
product * i,
n, k);
}
}
}
// Handles the request to find resultant subsequences
findProductSequence(arr, n, k)
{
// Auxiliary array which is collect result
var result = Array(n).fill(0);
this.subSequences(arr, result, 0, 0, 1, n, k);
}
}

function main()
{
var arr = [1, 2, 3, 4];
var n = arr.length;
// Product
var k = 6;
// Test
}
main();``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````#  Python 3 program for
#  Find all subsequences whose product is less than k in array
class Combination :
def subSequences(self, arr, result, start,
count, product, n, k) :
if (product <= k) :
i = 0
while (i < count) :
print(" ", result[i], end = "")
i += 1

print(end = "\n")

if (count >= n) :
return
else :
i = start + 1
while (i <= n) :
#  Collect elements
result[count] = i
self.subSequences(arr, result, i,
count + 1,
product * i, n, k)
i += 1

#  Handles the request to find resultant subsequences
def findProductSequence(self, arr, n, k) :
#  Auxiliary list which is collect result
result = [0] * (n)
self.subSequences(arr, result, 0, 0, 1, n, k)

def main() :
arr = [1, 2, 3, 4]
n = len(arr)
#  Product
k = 6
#  Test

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

#### Output

``````  1
1  2
1  2  3
1  3
1  4
2
2  3
3
4``````
``````#  Ruby program for
#  Find all subsequences whose product is less than k in array
class Combination
def subSequences(arr, result, start,
count, product, n, k)
if (product <= k)
i = 0
while (i < count)
print(" ", result[i])
i += 1
end

print("\n")
end

if (count >= n)
return
else

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

end

end

#  Handles the request to find resultant subsequences
def findProductSequence(arr, n, k)
#  Auxiliary array which is collect result
result = Array.new(n) {0}
self.subSequences(arr, result, 0, 0, 1, n, k)
end

end

def main()
arr = [1, 2, 3, 4]
n = arr.length
#  Product
k = 6
#  Test
end

main()``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4
``````
``````// Scala program for
// Find all subsequences whose product is less than k in array
class Combination()
{
def subSequences(arr: Array[Int],
result: Array[Int],
start: Int,
count: Int,
product: Int,
n: Int,
k: Int): Unit = {
if (product <= k)
{
var i: Int = 0;
while (i < count)
{
print(" " + result(i));
i += 1;
}
print("\n");
}
if (count >= n)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= n)
{
// Collect elements
result(count) = i;
subSequences(arr, result, i,
count + 1,
product * i, n, k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
def findProductSequence(arr: Array[Int],
n: Int, k: Int): Unit = {
// Auxiliary array which is collect result
var result: Array[Int] = Array.fill[Int](n)(0);
subSequences(arr, result, 0, 0, 1, n, k);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combination = new Combination();
var arr: Array[Int] = Array(1, 2, 3, 4);
var n: Int = arr.length;
// Product
var k: Int = 6;
// Test
}
}``````

#### Output

`````` 1
1 2
1 2 3
1 3
1 4
2
2 3
3
4``````
``````import Foundation;
// Swift 4 program for
// Find all subsequences whose product is less than k in array
class Combination
{
func subSequences(_ arr: [Int],
_ result: inout[Int], _ start: Int,
_ count: Int, _ product: Int,
_ n: Int, _ k: Int)
{
if (product <= k)
{
var i: Int = 0;
while (i < count)
{
print(" ", result[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
if (count >= n)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= n)
{
// Collect elements
result[count] = i;
self.subSequences(arr, &result,
i, count + 1,
product * i,
n, k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
func findProductSequence(_ arr: [Int], _ n: Int, _ k: Int)
{
// Auxiliary array which is collect result
var result: [Int] = Array(repeating: 0, count: n);
self.subSequences(arr, &result, 0, 0, 1, n, k);
}
}
func main()
{
let arr: [Int] = [1, 2, 3, 4];
let n: Int = arr.count;
// Product
let k: Int = 6;
// Test
}
main();``````

#### Output

``````  1
1  2
1  2  3
1  3
1  4
2
2  3
3
4``````
``````// Kotlin program for
// Find all subsequences whose product is less than k in array
class Combination
{
fun subSequences(arr: Array < Int > ,
result: Array < Int > ,
start: Int, count: Int,
product: Int,
n: Int,
k: Int): Unit
{
if (product <= k)
{
var i: Int = 0;
while (i < count)
{
print(" " + result[i]);
i += 1;
}
print("\n");
}
if (count >= n)
{
return;
}
else
{
var i: Int = start + 1;
while (i <= n)
{
// Collect elements
result[count] = i;
this.subSequences(arr,
result, i,
count + 1,
product * i,
n,
k);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
fun findProductSequence(arr: Array < Int > ,
n: Int, k: Int): Unit
{
// Auxiliary array which is collect result
var result: Array < Int > = Array(n)
{
0
};
this.subSequences(arr, result, 0, 0, 1, n, k);
}
}
fun main(args: Array < String > ): Unit
{
val arr: Array < Int > = arrayOf(1, 2, 3, 4);
val n: Int = arr.count();
// Product
val k: Int = 6;
// Test
}``````

#### Output

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

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