Posted on by Kalkicode
Code Backtracking

Print all combinations of N length sequences whose product is M

Here given code implementation process.

``````// C Program
// Print all combinations of N length sequences whose product is M
#include <stdio.h>

void subSequences(int result[], int count, int product, int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
// Display element value
printf(" %d", result[i]);
}
printf("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = 1; i <= m; ++i)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
subSequences(result, count + 1, product *i, n, m);
}
}
}
void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
printf(" Length  : %d",n);
printf("\n Product %d\n",m);
// Auxiliary array which is collect result
int result[n];
subSequences(result, 0, 1, n, m);
}
int main()
{
// Length of sequences
int n = 3;
// Product
int m = 28;
// Test
findSequence(n, m);
return 0;
}``````

Output

`````` Length  : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````// Java program for
// Print all combinations of N length sequences whose product is M
public class Combination
{
public void subSequences(int[] result, int count,
int product, int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
// Display element value
System.out.print(" " + result[i]);
}
System.out.print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = 1; i <= m; ++i)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
subSequences(result, count + 1,
product * i, n, m);
}
}
}
public void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
System.out.print(" Length : " + n);
System.out.println("\n Product " + m);
// Auxiliary array which is collect result
int[] result = new int[n];
subSequences(result, 0, 1, n, m);
}
public static void main(String[] args)
{
Combination task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 28;
// Test
task.findSequence(n, m);
}
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````// Include header file
#include <iostream>

using namespace std;
// C++ program for
// Print all combinations of N length sequences whose product is M
class Combination
{
public: void subSequences(int result[], int count,
int product, int n, int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
// Display element value
cout << " " << result[i];
}
cout << "\n";
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = 1; i <= m; ++i)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
this->subSequences(result, count + 1,
product *i, n, m);
}
}
}
void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
cout << " Length : " << n;
cout << "\n Product " << m << endl;
// Auxiliary array which is collect result
int result[n];
this->subSequences(result, 0, 1, n, m);
}
};
int main()
{
Combination *task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 28;
// Test
task->findSequence(n, m);
return 0;
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````// Include namespace system
using System;
// Csharp program for
// Print all combinations of N length sequences whose product is M
public class Combination
{
public void subSequences(int[] result,
int count,
int product,
int n,
int m)
{
if (count == n && product == m)
{
for (int i = 0; i < count; ++i)
{
// Display element value
Console.Write(" " + result[i]);
}
Console.Write("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (int i = 1; i <= m; ++i)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
this.subSequences(result, count + 1,
product * i, n, m);
}
}
}
public void findSequence(int n, int m)
{
if (n <= 0)
{
return;
}
Console.Write(" Length : " + n);
Console.WriteLine("\n Product " + m);
// Auxiliary array which is collect result
int[] result = new int[n];
this.subSequences(result, 0, 1, n, m);
}
public static void Main(String[] args)
{
Combination task = new Combination();
// Length of sequences
int n = 3;
// Product
int m = 28;
// Test
task.findSequence(n, m);
}
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````package main
import "fmt"
// Go program for
// Print all 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,
count int,
product int,
n int,
m int) {
if count == n && product == m {
for i := 0 ; i < count ; i++ {
// Display element value
fmt.Print(" ", result[i])
}
fmt.Print("\n")
} else if product > m || count >= n {
return
} else {
for i := 1 ; i <= m ; i++ {
// Collect elements
result[count] = i
// Find subsequence by using recursively
this.subSequences(result,
count + 1,
product * i,
n,
m)
}
}
}
func(this Combination) findSequence(n, m int) {
if n <= 0 {
return
}
fmt.Print(" Length : ", n)
fmt.Println("\n Product ", m)
// Auxiliary array which is collect result
var result = make([] int, n)
this.subSequences(result, 0, 1, n, m)
}
func main() {
var task * Combination = getCombination()
// Length of sequences
var n int = 3
// Product
var m int = 28
// Test
task.findSequence(n, m)
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````<?php
// Php program for
// Print all combinations of N length sequences whose product is M
class Combination
{
public	function subSequences(\$result,
\$count,
\$product,
\$n,
\$m)
{
if (\$count == \$n && \$product == \$m)
{
for (\$i = 0; \$i < \$count; ++\$i)
{
// Display element value
echo(" ".\$result[\$i]);
}
echo("\n");
}
else if (\$product > \$m || \$count >= \$n)
{
return;
}
else
{
for (\$i = 1; \$i <= \$m; ++\$i)
{
// Collect elements
\$result[\$count] = \$i;
// Find subsequence by using recursively
\$this->subSequences(\$result,
\$count + 1,
\$product * \$i,
\$n,
\$m);
}
}
}
public	function findSequence(\$n, \$m)
{
if (\$n <= 0)
{
return;
}
echo(" Length : ".\$n);
echo("\n Product ".\$m."\n");
// Auxiliary array which is collect result
\$result = array_fill(0, \$n, 0);
\$this->subSequences(\$result, 0, 1, \$n, \$m);
}
}

function main()
{
\$task = new Combination();
// Length of sequences
\$n = 3;
// Product
\$m = 28;
// Test
\$task->findSequence(\$n, \$m);
}
main();``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````// Node JS program for
// Print all combinations of N length sequences whose product is M
class Combination
{
subSequences(result, count, product, n, m)
{
if (count == n && product == m)
{
for (var i = 0; i < count; ++i)
{
// Display element value
process.stdout.write(" " + result[i]);
}
process.stdout.write("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
for (var i = 1; i <= m; ++i)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
this.subSequences(result,
count + 1,
product * i,
n,
m);
}
}
}
findSequence(n, m)
{
if (n <= 0)
{
return;
}
process.stdout.write(" Length : " + n);
console.log("\n Product " + m);
// Auxiliary array which is collect result
var result = Array(n).fill(0);
this.subSequences(result, 0, 1, n, m);
}
}

function main()
{
var task = new Combination();
// Length of sequences
var n = 3;
// Product
var m = 28;
// Test
task.findSequence(n, m);
}
main();``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````#  Python 3 program for
#  Print all combinations of N length sequences whose product is M
class Combination :
def subSequences(self, result, count, product, n, m) :
if (count == n and product == m) :
i = 0
while (i < count) :
#  Display element value
print(" ", result[i], end = "")
i += 1

print(end = "\n")
elif (product > m or count >= n) :
return
else :
i = 1
while (i <= m) :
#  Collect elements
result[count] = i
#  Find subsequence by using recursively
self.subSequences(result, count + 1,
product * i, n, m)
i += 1

def findSequence(self, n, m) :
if (n <= 0) :
return

print(" Length : ", n, end = "")
print("\n Product ", m)
#  Auxiliary list which is collect result
result = [0] * (n)
self.subSequences(result, 0, 1, n, m)

def main() :
task = Combination()
#  Length of sequences
n = 3
#  Product
m = 28
#  Test
task.findSequence(n, m)

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

Output

`````` Length :  3
Product  28
1  1  28
1  2  14
1  4  7
1  7  4
1  14  2
1  28  1
2  1  14
2  2  7
2  7  2
2  14  1
4  1  7
4  7  1
7  1  4
7  2  2
7  4  1
14  1  2
14  2  1
28  1  1``````
``````#  Ruby program for
#  Print all combinations of N length sequences whose product is M
class Combination
def subSequences(result, count, product, n, m)
if (count == n && product == m)
i = 0
while (i < count)
#  Display element value
print(" ", result[i])
i += 1
end

print("\n")
elsif (product > m || count >= n)
return
else

i = 1
while (i <= m)
#  Collect elements
result[count] = i
#  Find subsequence by using recursively
self.subSequences(result, count + 1, product * i, n, m)
i += 1
end

end

end

def findSequence(n, m)
if (n <= 0)
return
end

print(" Length : ", n)
print("\n Product ", m, "\n")
#  Auxiliary array which is collect result
result = Array.new(n) {0}
self.subSequences(result, 0, 1, n, m)
end

end

def main()
task = Combination.new()
#  Length of sequences
n = 3
#  Product
m = 28
#  Test
task.findSequence(n, m)
end

main()``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1
``````
``````// Scala program for
// Print all combinations of N length sequences whose product is M
class Combination()
{
def subSequences(result: Array[Int],
count: Int, product: Int, n: Int, m: Int): Unit = {
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
// Display element value
print(" " + result(i));
i += 1;
}
print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = 1;
while (i <= m)
{
// Collect elements
result(count) = i;
// Find subsequence by using recursively
subSequences(result, count + 1,
product * i, n, m);
i += 1;
}
}
}
def findSequence(n: Int, m: Int): Unit = {
if (n <= 0)
{
return;
}
print(" Length : " + n);
println("\n Product " + m);
// Auxiliary array which is collect result
var result: Array[Int] = Array.fill[Int](n)(0);
subSequences(result, 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 = 28;
// Test
task.findSequence(n, m);
}
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````
``````// Swift 4 program for
// Print all combinations of N length sequences whose product is M
class Combination
{
func subSequences(_ result: inout[Int],
_ count: Int, _ product: Int,
_ n: Int, _ m: Int)
{
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
// Display element value
print(" ", result[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = 1;
while (i <= m)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
self.subSequences(&result,
count + 1,
product * i,
n,
m);
i += 1;
}
}
}
func findSequence(_ n: Int, _ m: Int)
{
if (n <= 0)
{
return;
}
print(" Length : ", n, terminator: "");
print("\n Product ", m);
// Auxiliary array which is collect result
var result: [Int] = Array(repeating: 0, count: n);
self.subSequences(&result, 0, 1, n, m);
}
}
func main()
{
let task: Combination = Combination();
// Length of sequences
let n: Int = 3;
// Product
let m: Int = 28;
// Test
task.findSequence(n, m);
}
main();``````

Output

`````` Length :  3
Product  28
1  1  28
1  2  14
1  4  7
1  7  4
1  14  2
1  28  1
2  1  14
2  2  7
2  7  2
2  14  1
4  1  7
4  7  1
7  1  4
7  2  2
7  4  1
14  1  2
14  2  1
28  1  1``````
``````// Kotlin program for
// Print all combinations of N length sequences whose product is M
class Combination
{
fun subSequences(result: Array < Int > ,
count: Int, product: Int,
n: Int, m: Int): Unit
{
if (count == n && product == m)
{
var i: Int = 0;
while (i < count)
{
// Display element value
print(" " + result[i]);
i += 1;
}
print("\n");
}
else if (product > m || count >= n)
{
return;
}
else
{
var i: Int = 1;
while (i <= m)
{
// Collect elements
result[count] = i;
// Find subsequence by using recursively
this.subSequences(result,
count + 1,
product * i,
n,
m);
i += 1;
}
}
}
fun findSequence(n: Int, m: Int): Unit
{
if (n <= 0)
{
return;
}
print(" Length : " + n);
println("\n Product " + m);
// Auxiliary array which is collect result
var result: Array < Int > = Array(n)
{
0
};
this.subSequences(result, 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 = 28;
// Test
task.findSequence(n, m);
}``````

Output

`````` Length : 3
Product 28
1 1 28
1 2 14
1 4 7
1 7 4
1 14 2
1 28 1
2 1 14
2 2 7
2 7 2
2 14 1
4 1 7
4 7 1
7 1 4
7 2 2
7 4 1
14 1 2
14 2 1
28 1 1``````

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