# Distinct combinations of N length sequences whose product is M

Here given code implementation process.

```
// C Program
// Distinct combinations of N length sequences whose product is M
#include <stdio.h>
void subSequences(
int result[],
int start,
int count,
int product,
int n,
int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
printf(" %d", result[i]);
}
printf("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = start; i <= m; ++i)
{
// Collect elements
result[count] = i;
subSequences(result,
i + 1,
count + 1,
product * i,
n, m);
}
}
}
// Handles the request to find resultant subsequences
void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
printf("Given Length : %d \n",n);
printf("Product : %d \n",m);
// Auxiliary array which is collect result
int result[n];
subSequences(result, 1, 0, 1, n, m);
}
int main()
{
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
findSequence(n, m);
return 0;
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Java program for
// Distinct combinations of N length sequences whose product is M
public class Combination
{
public void subSequences(int[] result,
int start,
int count,
int product,
int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
System.out.print(" " + result[i]);
}
System.out.print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = start; i <= m; ++i)
{
// Collect elements
result[count] = i;
subSequences(result, i + 1,
count + 1, product * i, n, m);
}
}
}
// Handles the request to find resultant subsequences
public void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
System.out.print("Given Length : " + n + " \n");
System.out.print("Product : " + m + " \n");
// Auxiliary array which is collect result
int[] result = new int[n];
subSequences(result, 1, 0, 1, n, m);
}
public static void main(String[] args)
{
Combination task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
task.findSequence(n, m);
}
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Include header file
#include <iostream>
using namespace std;
// C++ program for
// Distinct combinations of N length sequences whose product is M
class Combination
{
public: void subSequences(int result[],
int start, int count,
int product, int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
cout << " " << result[i];
}
cout << "\n";
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = start; i <= m; ++i)
{
// Collect elements
result[count] = i;
this->subSequences(result, i + 1,
count + 1,
product *i, n, m);
}
}
}
// Handles the request to find resultant subsequences
void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
cout << "Given Length : " << n << " \n";
cout << "Product : " << m << " \n";
// Auxiliary array which is collect result
int result[n];
this->subSequences(result, 1, 0, 1, n, m);
}
};
int main()
{
Combination *task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
task->findSequence(n, m);
return 0;
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Include namespace system
using System;
// Csharp program for
// Distinct combinations of N length sequences whose product is M
public class Combination
{
public void subSequences(int[] result,
int start, int count,
int product, int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
Console.Write(" " + result[i]);
}
Console.Write("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = start; i <= m; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(result, i + 1,
count + 1, product * i,
n, m);
}
}
}
// Handles the request to find resultant subsequences
public void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
Console.Write("Given Length : " + n + " \n");
Console.Write("Product : " + m + " \n");
// Auxiliary array which is collect result
int[] result = new int[n];
this.subSequences(result, 1, 0, 1, n, m);
}
public static void Main(String[] args)
{
Combination task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
task.findSequence(n, m);
}
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
package main
import "fmt"
// Go program for
// Distinct combinations of N length sequences whose product is M
type Combination struct {}
func getCombination() * Combination {
var me *Combination = &Combination {}
return me
}
func(this Combination) subSequences(result[] int,
start int, count int,
product int,
n int,
m int) {
if count == n && product == m {
for i := 0 ; i < count ; i++ {
fmt.Print(" ", result[i])
}
fmt.Print("\n")
} else if product > m || count >= n {
return
} else {
for i := start ; i <= m ; i++ {
// Collect elements
result[count] = i
this.subSequences(result, i + 1,
count + 1,
product * i,
n, m)
}
}
}
// Handles the request to find resultant subsequences
func(this Combination) findSequence(n, m int) {
if n <= 0 {
return
}
fmt.Print("Given Length : ", n, " \n")
fmt.Print("Product : ", m, " \n")
// Auxiliary array which is collect result
var result = make([] int, n)
this.subSequences(result, 1, 0, 1, n, m)
}
func main() {
var task * Combination = getCombination()
// Length of sequences
var n int = 3
// Product
var m int = 60
// Test
task.findSequence(n, m)
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
<?php
// Php program for
// Distinct combinations of N length sequences whose product is M
class Combination
{
public function subSequences($result,
$start, $count,
$product, $n, $m)
{
if ($count == $n && $product == $m)
{
for ($i = 0; $i < $count; ++$i)
{
echo(" ".$result[$i]);
}
echo("\n");
}
else if ($product > $m || $count >= $n)
{
return;
}
else
{
for ($i = $start; $i <= $m; ++$i)
{
// Collect elements
$result[$count] = $i;
$this->subSequences($result, $i + 1,
$count + 1,
$product * $i, $n, $m);
}
}
}
// Handles the request to find resultant subsequences
public function findSequence($n, $m)
{
if ($n <= 0)
{
return;
}
echo("Given Length : ".$n.
" \n");
echo("Product : ".$m.
" \n");
// Auxiliary array which is collect result
$result = array_fill(0, $n, 0);
$this->subSequences($result, 1, 0, 1, $n, $m);
}
}
function main()
{
$task = new Combination();
// Length of sequences
$n = 3;
// Product
$m = 60;
// Test
$task->findSequence($n, $m);
}
main();
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Node JS program for
// Distinct combinations of N length sequences whose product is M
class Combination
{
subSequences(result, start, count, product, n, m)
{
if (count == n && product == m)
{
for (var i = 0; i < count; ++i)
{
process.stdout.write(" " + result[i]);
}
process.stdout.write("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (var i = start; i <= m; ++i)
{
// Collect elements
result[count] = i;
this.subSequences(result, i + 1,
count + 1,
product * i,
n, m);
}
}
}
// Handles the request to find resultant subsequences
findSequence(n, m)
{
if (n <= 0)
{
return;
}
process.stdout.write("Given Length : " + n + " \n");
process.stdout.write("Product : " + m + " \n");
// Auxiliary array which is collect result
var result = Array(n).fill(0);
this.subSequences(result, 1, 0, 1, n, m);
}
}
function main()
{
var task = new Combination();
// Length of sequences
var n = 3;
// Product
var m = 60;
// Test
task.findSequence(n, m);
}
main();
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
# Python 3 program for
# Distinct combinations of N length sequences whose product is M
class Combination :
def subSequences(self, result, start, count, product, n, m) :
if (count == n and product == m) :
i = 0
while (i < count) :
print(" ", result[i], end = "")
i += 1
print(end = "\n")
elif (product > m or count >= n) :
return
else :
i = start
while (i <= m) :
# Collect elements
result[count] = i
self.subSequences(result, i + 1,
count + 1,
product * i,
n, m)
i += 1
# Handles the request to find resultant subsequences
def findSequence(self, n, m) :
if (n <= 0) :
return
print("Given Length : ", n ," ")
print("Product : ", m ," ")
# Auxiliary list which is collect result
result = [0] * (n)
self.subSequences(result, 1, 0, 1, n, m)
def main() :
task = Combination()
# Length of sequences
n = 3
# Product
m = 60
# Test
task.findSequence(n, m)
if __name__ == "__main__": main()
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
# Ruby program for
# Distinct combinations of N length sequences whose product is M
class Combination
def subSequences(result, start, count, product, n, m)
if (count == n && product == m)
i = 0
while (i < count)
print(" ", result[i])
i += 1
end
print("\n")
elsif (product > m || count >= n)
return
else
i = start
while (i <= m)
# Collect elements
result[count] = i
self.subSequences(result, i + 1,
count + 1,
product * i, n, m)
i += 1
end
end
end
# Handles the request to find resultant subsequences
def findSequence(n, m)
if (n <= 0)
return
end
print("Given Length : ", n ," \n")
print("Product : ", m ," \n")
# Auxiliary array which is collect result
result = Array.new(n) {0}
self.subSequences(result, 1, 0, 1, n, m)
end
end
def main()
task = Combination.new()
# Length of sequences
n = 3
# Product
m = 60
# Test
task.findSequence(n, m)
end
main()
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Scala program for
// Distinct combinations of N length sequences whose product is M
class Combination()
{
def subSequences(result: Array[Int],
start: Int, count: Int,
product: Int,
n: Int,
m: Int): Unit = {
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
print(" " + result(i));
i += 1;
}
print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = start;
while (i <= m)
{
// Collect elements
result(count) = i;
subSequences(result, i + 1,
count + 1,
product * i,
n, m);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
def findSequence(n: Int, m: Int): Unit = {
if (n <= 0)
{
return;
}
print("Given Length : " + n + " \n");
print("Product : " + m + " \n");
// Auxiliary array which is collect result
var result: Array[Int] = Array.fill[Int](n)(0);
subSequences(result, 1, 0, 1, n, m);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combination = new Combination();
// Length of sequences
var n: Int = 3;
// Product
var m: Int = 60;
// Test
task.findSequence(n, m);
}
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Swift 4 program for
// Distinct combinations of N length sequences whose product is M
class Combination
{
func subSequences(_ result: inout[Int],
_ start: Int,
_ count: Int,
_ product: Int,
_ n: Int,
_ m: Int)
{
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
print(" ", result[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = start;
while (i <= m)
{
// Collect elements
result[count] = i;
self.subSequences(&result, i + 1,
count + 1,
product * i,
n, m);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
func findSequence(_ n: Int, _ m: Int)
{
if (n <= 0)
{
return;
}
print("Given Length : ", n ," ");
print("Product : ", m ," ");
// Auxiliary array which is collect result
var result: [Int] = Array(repeating: 0, count: n);
self.subSequences(&result, 1, 0, 1, n, m);
}
}
func main()
{
let task: Combination = Combination();
// Length of sequences
let n: Int = 3;
// Product
let m: Int = 60;
// Test
task.findSequence(n, m);
}
main();
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

```
// Kotlin program for
// Distinct combinations of N length sequences whose product is M
class Combination
{
fun subSequences(result: Array < Int > ,
start: Int, count: Int,
product: Int,
n: Int, m: Int): Unit
{
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
print(" " + result[i]);
i += 1;
}
print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = start;
while (i <= m)
{
// Collect elements
result[count] = i;
this.subSequences(result, i + 1,
count + 1,
product * i, n, m);
i += 1;
}
}
}
// Handles the request to find resultant subsequences
fun findSequence(n: Int, m: Int): Unit
{
if (n <= 0)
{
return;
}
print("Given Length : " + n + " \n");
print("Product : " + m + " \n");
// Auxiliary array which is collect result
var result: Array < Int > = Array(n)
{
0
};
this.subSequences(result, 1, 0, 1, n, m);
}
}
fun main(args: Array < String > ): Unit
{
val task: Combination = Combination();
// Length of sequences
val n: Int = 3;
// Product
val m: Int = 60;
// Test
task.findSequence(n, m);
}
```

#### Output

```
Given Length : 3
Product : 60
1 2 30
1 3 20
1 4 15
1 5 12
1 6 10
2 3 10
2 5 6
3 4 5
```

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.

## New Comment