# Print all combinations factors of given number

Here given code implementation process.

``````//  C program for
//  Print all combinations factors of given number
#include <stdio.h>

//  Print resultant element
void printSequence(int result[], int n)
{
for (int i = 0; i < n; ++i)
{
printf("  %d", result[i]);
}
printf("\n");
}
void findCombination(int result[], int index, int count, int num)
{
if (num == count)
{
printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
for (int i = 2; i <= num / 2; ++i)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
findCombination(result, index + 1, count *i, num);
}
}
void combination(int num)
{
if (num <= 0)
{
return;
}
printf("\n Given Number : %d\n", num);
if (num == 1)
{
// When have only one result
printf("\n 1 \n");
return;
}
// Result container
int result[num];
// Find combination pair
findCombination(result, 0, 1, num);
}
int main(int argc, char
const *argv[])
{
combination(24);
return 0;
}``````

#### Output

`````` Given Number : 24
2  2  2  3
2  2  3  2
2  2  6
2  3  2  2
2  3  4
2  4  3
2  6  2
2  12
3  2  2  2
3  2  4
3  4  2
3  8
4  2  3
4  3  2
4  6
6  2  2
6  4
8  3
12  2``````
``````/*
Java Program
Print all combinations factors of given number
*/
public class Combinations
{
//  Print resultant element
public void printSequence(int[] result, int n)
{
for (int i = 0; i < n; ++i)
{
System.out.print(" " + result[i]);
}
System.out.print("\n");
}
public void findCombination(int[] result,
int index,
int count,
int num)
{
if (num == count)
{
printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
for (int i = 2; i <= num / 2; ++i)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
findCombination(result, index + 1, count * i, num);
}
}
public void combination(int num)
{
if (num <= 0)
{
return;
}
System.out.print("\n Given Number : " + num + "\n");
if (num == 1)
{
// When have only one result
System.out.print("\n 1 \n");
return;
}
// Result container
int[] result = new int[num];
// Find combination pair
findCombination(result, 0, 1, num);
}
public static void main(String[] args)
{
Combinations task = new Combinations();
// Test
}
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````// Include header file
#include <iostream>
using namespace std;
/*
C++ Program
Print all combinations factors of given number
*/
class Combinations
{
public:
//  Print resultant element
void printSequence(int result[], int n)
{
for (int i = 0; i < n; ++i)
{
cout << " " << result[i];
}
cout << "\n";
}
void findCombination(int result[],
int index,
int count,
int num)
{
if (num == count)
{
this->printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
for (int i = 2; i <= num / 2; ++i)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
this->findCombination(result,
index + 1,
count *i,
num);
}
}
void combination(int num)
{
if (num <= 0)
{
return;
}
cout << "\n Given Number : " << num << "\n";
if (num == 1)
{
// When have only one result
cout << "\n 1 \n";
return;
}
// Result container
int result[num];
// Find combination pair
this->findCombination(result, 0, 1, num);
}
};
int main()
{
Combinations *task = new Combinations();
// Test
return 0;
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````// Include namespace system
using System;
/*
Csharp Program
Print all combinations factors of given number
*/
public class Combinations
{
//  Print resultant element
public void printSequence(int[] result, int n)
{
for (int i = 0; i < n; ++i)
{
Console.Write(" " + result[i]);
}
Console.Write("\n");
}
public void findCombination(int[] result,
int index,
int count,
int num)
{
if (num == count)
{
this.printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
for (int i = 2; i <= num / 2; ++i)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
this.findCombination(result,
index + 1,
count * i,
num);
}
}
public void combination(int num)
{
if (num <= 0)
{
return;
}
Console.Write("\n Given Number : " + num + "\n");
if (num == 1)
{
// When have only one result
Console.Write("\n 1 \n");
return;
}
// Result container
int[] result = new int[num];
// Find combination pair
this.findCombination(result, 0, 1, num);
}
public static void Main(String[] args)
{
Combinations task = new Combinations();
// Test
}
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````package main
import "fmt"
/*
Go Program
Print all combinations factors of given number
*/
type Combinations struct {}
func getCombinations() * Combinations {
var me *Combinations = &Combinations {}
return me
}
//  Print resultant element
func(this Combinations) printSequence(result[] int, n int) {
for i := 0 ; i < n ; i++ {
fmt.Print(" ", result[i])
}
fmt.Print("\n")
}
func(this Combinations) findCombination(result[] int,
index int, count int, num int) {
if num == count {
this.printSequence(result, index)
return
}
if index > num || count > num {
// Base case
return
}
for i := 2 ; i <= num / 2 ; i++ {
// Collect resultant element
result[index] = i
// Find combinations using recursively
this.findCombination(result, index + 1, count * i, num)
}
}
func(this Combinations) combination(num int) {
if num <= 0 {
return
}
fmt.Print("\n Given Number : ", num, "\n")
if num == 1 {
// When have only one result
fmt.Print("\n 1 \n")
return
}
// Result container
var result = make([] int, num)
// Find combination pair
this.findCombination(result, 0, 1, num)
}
func main() {
var task * Combinations = getCombinations()
// Test
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````<?php
/*
Php Program
Print all combinations factors of given number
*/
class Combinations
{
//  Print resultant element
public	function printSequence(\$result, \$n)
{
for (\$i = 0; \$i < \$n; ++\$i)
{
echo(" ".\$result[\$i]);
}
echo("\n");
}
public	function findCombination(\$result, \$index, \$count, \$num)
{
if (\$num == \$count)
{
\$this->printSequence(\$result, \$index);
return;
}
if (\$index > \$num || \$count > \$num)
{
// Base case
return;
}
for (\$i = 2; \$i <= (int)(\$num / 2); ++\$i)
{
// Collect resultant element
\$result[\$index] = \$i;
// Find combinations using recursively
\$this->findCombination(\$result,
\$index + 1,
\$count * \$i,
\$num);
}
}
public	function combination(\$num)
{
if (\$num <= 0)
{
return;
}
echo("\n Given Number : ".\$num.
"\n");
if (\$num == 1)
{
// When have only one result
echo("\n 1 \n");
return;
}
// Result container
\$result = array_fill(0, \$num, 0);
// Find combination pair
\$this->findCombination(\$result, 0, 1, \$num);
}
}

function main()
{
\$task = new Combinations();
// Test
}
main();``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````/*
Node JS Program
Print all combinations factors of given number
*/
class Combinations
{
//  Print resultant element
printSequence(result, n)
{
for (var i = 0; i < n; ++i)
{
process.stdout.write(" " + result[i]);
}
process.stdout.write("\n");
}
findCombination(result, index, count, num)
{
if (num == count)
{
this.printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
for (var i = 2; i <= parseInt(num / 2); ++i)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
this.findCombination(result, index + 1, count * i, num);
}
}
combination(num)
{
if (num <= 0)
{
return;
}
process.stdout.write("\n Given Number : " + num + "\n");
if (num == 1)
{
// When have only one result
process.stdout.write("\n 1 \n");
return;
}
// Result container
var result = Array(num).fill(0);
// Find combination pair
this.findCombination(result, 0, 1, num);
}
}

function main()
{
var task = new Combinations();
// Test
}
main();``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````#    Python 3 Program
#    Print all combinations factors of given number
class Combinations :
#   Print resultant element
def printSequence(self, result, n) :
i = 0
while (i < n) :
print(" ", result[i], end = "")
i += 1

print(end = "\n")

def findCombination(self, result, index, count, num) :
if (num == count) :
self.printSequence(result, index)
return

if (index > num or count > num) :
#  Base case
return

i = 2
while (i <= int(num / 2)) :
#  Collect resultant element
result[index] = i
#  Find combinations using recursively
self.findCombination(result, index + 1, count * i, num)
i += 1

def combination(self, num) :
if (num <= 0) :
return

print("\n Given Number : ", num )
if (num == 1) :
#  When have only one result
print("\n 1 ")
return

#  Result container
result = [0] * (num)
#  Find combination pair
self.findCombination(result, 0, 1, num)

def main() :
#  Test

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

#### Output

`````` Given Number :  24
2  2  2  3
2  2  3  2
2  2  6
2  3  2  2
2  3  4
2  4  3
2  6  2
2  12
3  2  2  2
3  2  4
3  4  2
3  8
4  2  3
4  3  2
4  6
6  2  2
6  4
8  3
12  2``````
``````#    Ruby Program
#    Print all combinations factors of given number
class Combinations
#   Print resultant element
def printSequence(result, n)
i = 0
while (i < n)
print(" ", result[i])
i += 1
end

print("\n")
end

def findCombination(result, index, count, num)
if (num == count)
self.printSequence(result, index)
return
end

if (index > num || count > num)
#  Base case
return
end

i = 2
while (i <= num / 2)
#  Collect resultant element
result[index] = i
#  Find combinations using recursively
self.findCombination(result, index + 1, count * i, num)
i += 1
end

end

def combination(num)
if (num <= 0)
return
end

print("\n Given Number : ", num ,"\n")
if (num == 1)
#  When have only one result
print("\n 1 \n")
return
end

#  Result container
result = Array.new(num) {0}
#  Find combination pair
self.findCombination(result, 0, 1, num)
end

end

def main()
#  Test
end

main()``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2
``````
``````/*
Scala Program
Print all combinations factors of given number
*/
class Combinations()
{
//  Print resultant element
def printSequence(result: Array[Int], n: Int): Unit = {
var i: Int = 0;
while (i < n)
{
print(" " + result(i));
i += 1;
}
print("\n");
}
def findCombination(result: Array[Int], index: Int,
count: Int, num: Int): Unit = {
if (num == count)
{
printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
var i: Int = 2;
while (i <= num / 2)
{
// Collect resultant element
result(index) = i;
// Find combinations using recursively
findCombination(result, index + 1, count * i, num);
i += 1;
}
}
def combination(num: Int): Unit = {
if (num <= 0)
{
return;
}
print("\n Given Number : " + num + "\n");
if (num == 1)
{
// When have only one result
print("\n 1 \n");
return;
}
// Result container
var result: Array[Int] = Array.fill[Int](num)(0);
// Find combination pair
findCombination(result, 0, 1, num);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combinations = new Combinations();
// Test
}
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````
``````/*
Swift 4 Program
Print all combinations factors of given number
*/
class Combinations
{
//  Print resultant element
func printSequence(_ result: [Int], _ n: Int)
{
var i: Int = 0;
while (i < n)
{
print(" ", result[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
func findCombination(_ result: inout[Int], _ index: Int,
_ count: Int, _ num: Int)
{
if (num == count)
{
self.printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
var i: Int = 2;
while (i <= num / 2)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
self.findCombination(&result, index + 1, count * i, num);
i += 1;
}
}
func combination(_ num: Int)
{
if (num <= 0)
{
return;
}
print("\n Given Number : ", num );
if (num == 1)
{
// When have only one result
print("\n 1 ");
return;
}
// Result container
var result: [Int] = Array(repeating: 0, count: num);
// Find combination pair
self.findCombination(&result, 0, 1, num);
}
}
func main()
{
let task: Combinations = Combinations();
// Test
}
main();``````

#### Output

`````` Given Number :  24
2  2  2  3
2  2  3  2
2  2  6
2  3  2  2
2  3  4
2  4  3
2  6  2
2  12
3  2  2  2
3  2  4
3  4  2
3  8
4  2  3
4  3  2
4  6
6  2  2
6  4
8  3
12  2``````
``````/*
Kotlin Program
Print all combinations factors of given number
*/
class Combinations
{
//  Print resultant element
fun printSequence(result: Array < Int > , n: Int): Unit
{
var i: Int = 0;
while (i < n)
{
print(" " + result[i]);
i += 1;
}
print("\n");
}
fun findCombination(result: Array < Int > ,
index: Int,
count: Int,
num: Int): Unit
{
if (num == count)
{
this.printSequence(result, index);
return;
}
if (index > num || count > num)
{
// Base case
return;
}
var i: Int = 2;
while (i <= num / 2)
{
// Collect resultant element
result[index] = i;
// Find combinations using recursively
this.findCombination(result, index + 1, count * i, num);
i += 1;
}
}
fun combination(num: Int): Unit
{
if (num <= 0)
{
return;
}
print("\n Given Number : " + num + "\n");
if (num == 1)
{
// When have only one result
print("\n 1 \n");
return;
}
// Result container
val result: Array < Int > = Array(num)
{
0
};
// Find combination pair
this.findCombination(result, 0, 1, num);
}
}
fun main(args: Array < String > ): Unit
{
val task: Combinations = Combinations();
// Test
}``````

#### Output

`````` Given Number : 24
2 2 2 3
2 2 3 2
2 2 6
2 3 2 2
2 3 4
2 4 3
2 6 2
2 12
3 2 2 2
3 2 4
3 4 2
3 8
4 2 3
4 3 2
4 6
6 2 2
6 4
8 3
12 2``````

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