# 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)
{
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
}
}``````

#### 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()
{
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
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)
{
// Length of sequences
int n = 3;
// Product
int m = 60;
// Test
}
}``````

#### 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
}``````

#### 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()
{
// Length of sequences
\$n = 3;
// Product
\$m = 60;
// Test
}
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()
{
// Length of sequences
var n = 3;
// Product
var m = 60;
// Test
}
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() :
#  Length of sequences
n = 3
#  Product
m = 60
#  Test

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()
#  Length of sequences
n = 3
#  Product
m = 60
#  Test
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
}
}``````

#### 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()
{
// Length of sequences
let n: Int = 3;
// Product
let m: Int = 60;
// Test
}
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
{
// Length of sequences
val n: Int = 3;
// Product
val m: Int = 60;
// Test
}``````

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

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