Display Friends Pairing Group
Here given code implementation process.
/*
Java program for
Display Friends Pairing Group
*/
public class Pairing
{
public int count;
public Pairing()
{
this.count = 0;
}
public void swapElement(int[] element, int a, int b)
{
int temp = element[a];
element[a] = element[b];
element[b] = temp;
}
public void findPairs(int[] element, String output, int index, int n)
{
if (index <= n)
{
// This is work on pair of single element
findPairs(element,
output + "(" + element[index] + ")",
index + 1, n);
for (int i = index + 1; i <= n; ++i)
{
if (index + 1 == i)
{
// Consicutive element are pair
findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")",
index + 2, n);
}
else
{
swapElement(element, i, index + 1);
findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")", index + 2, n);
swapElement(element, i, index + 1);
}
}
}
else
{
// Increase the value of result counter
++this.count;
// Display pair result
System.out.println((this.count) + " : " + output);
}
}
public void printPair(int n)
{
if (n <= 0)
{
return;
}
System.out.println("\nGiven n " + n);
this.count = 0;
int[] element = new int[n + 1];
for (int i = 0; i <= n; ++i)
{
element[i] = i;
}
findPairs(element, "", 1, n);
}
public static void main(String[] args)
{
Pairing task = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)// Include header file
#include <iostream>
using namespace std;
/*
C++ program for
Display Friends Pairing Group
*/
class Pairing
{
public: int count;
Pairing()
{
this->count = 0;
}
void swapElement(int element[], int a, int b)
{
int temp = element[a];
element[a] = element[b];
element[b] = temp;
}
void findPairs(int element[], string output, int index, int n)
{
if (index <= n)
{
// This is work on pair of single element
this->findPairs(element, output + "("
+ to_string(element[index]) + ")",
index + 1, n);
for (int i = index + 1; i <= n; ++i)
{
if (index + 1 == i)
{
// Consicutive element are pair
this->findPairs(element, output + " ("
+ to_string(element[index]) + ","
+ to_string(element[(index + 1)]) + ")",
index + 2, n);
}
else
{
this->swapElement(element, i, index + 1);
this->findPairs(element, output + " ("
+ to_string(element[index]) + ","
+ to_string(element[(index + 1)]) + ")",
index + 2, n);
this->swapElement(element, i, index + 1);
}
}
}
else
{
// Increase the value of result counter
++this->count;
// Display pair result
cout << (this->count) << " : " << output << endl;
}
}
void printPair(int n)
{
if (n <= 0)
{
return;
}
cout << "\nGiven n " << n << endl;
this->count = 0;
int element[n + 1];
for (int i = 0; i <= n; ++i)
{
element[i] = i;
}
this->findPairs(element, "", 1, n);
}
};
int main()
{
Pairing *task = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task->printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task->printPair(5);
return 0;
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)// Include namespace system
using System;
/*
Csharp program for
Display Friends Pairing Group
*/
public class Pairing
{
public int count;
public Pairing()
{
this.count = 0;
}
public void swapElement(int[] element, int a, int b)
{
int temp = element[a];
element[a] = element[b];
element[b] = temp;
}
public void findPairs(int[] element, String output, int index, int n)
{
if (index <= n)
{
// This is work on pair of single element
this.findPairs(element,
output + "(" + element[index] + ")",
index + 1, n);
for (int i = index + 1; i <= n; ++i)
{
if (index + 1 == i)
{
// Consicutive element are pair
this.findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")",
index + 2, n);
}
else
{
this.swapElement(element, i, index + 1);
this.findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")",
index + 2, n);
this.swapElement(element, i, index + 1);
}
}
}
else
{
// Increase the value of result counter
++this.count;
// Display pair result
Console.WriteLine((this.count) + " : " + output);
}
}
public void printPair(int n)
{
if (n <= 0)
{
return;
}
Console.WriteLine("\nGiven n " + n);
this.count = 0;
int[] element = new int[n + 1];
for (int i = 0; i <= n; ++i)
{
element[i] = i;
}
this.findPairs(element, "", 1, n);
}
public static void Main(String[] args)
{
Pairing task = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)package main
import "strconv"
import "fmt"
/*
Go program for
Display Friends Pairing Group
*/
type Pairing struct {
count int
}
func getPairing() * Pairing {
var me *Pairing = &Pairing {}
me.count = 0
return me
}
func(this Pairing) swapElement(element[] int, a int, b int) {
var temp int = element[a]
element[a] = element[b]
element[b] = temp
}
func(this *Pairing) findPairs(element[] int, output string, index int, n int) {
if index <= n {
// This is work on pair of single element
this.findPairs(element, output + "(" +
strconv.Itoa(element[index]) + ")", index + 1, n)
for i := index + 1 ; i <= n ; i++ {
if index + 1 == i {
// Consicutive element are pair
this.findPairs(element, output + " (" +
strconv.Itoa(element[index]) + "," +
strconv.Itoa(element[(index + 1)]) + ")", index + 2, n)
} else {
this.swapElement(element, i, index + 1)
this.findPairs(element, output + " (" +
strconv.Itoa(element[index]) + "," +
strconv.Itoa(element[(index + 1)]) + ")", index + 2, n)
this.swapElement(element, i, index + 1)
}
}
} else {
// Increase the value of result counter
this.count++
// Display pair result
fmt.Println((this.count), " : ", output)
}
}
func(this Pairing) printPair(n int) {
if n <= 0 {
return
}
fmt.Println("\nGiven n ", n)
this.count = 0
var element = make([] int, n + 1)
for i := 0 ; i <= n ; i++ {
element[i] = i
}
this.findPairs(element, "", 1, n)
}
func main() {
var task * Pairing = getPairing()
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4)
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5)
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)<?php
/*
Php program for
Display Friends Pairing Group
*/
class Pairing
{
public $count;
public function __construct()
{
$this->count = 0;
}
public function swapElement(&$element, $a, $b)
{
$temp = $element[$a];
$element[$a] = $element[$b];
$element[$b] = $temp;
}
public function findPairs($element, $output, $index, $n)
{
if ($index <= $n)
{
// This is work on pair of single element
$this->findPairs($element, $output.
"(".strval($element[$index]).
")", $index + 1, $n);
for ($i = $index + 1; $i <= $n; ++$i)
{
if ($index + 1 == $i)
{
// Consicutive element are pair
$this->findPairs($element, $output.
" (".strval($element[$index]).
",".strval($element[($index + 1)]).
")", $index + 2, $n);
}
else
{
$this->swapElement($element, $i, $index + 1);
$this->findPairs($element, $output.
" (".strval($element[$index]).
",".strval($element[($index + 1)]).
")", $index + 2, $n);
$this->swapElement($element, $i, $index + 1);
}
}
}
else
{
// Increase the value of result counter
++$this->count;
// Display pair result
echo(($this->count).
" : ".$output.
"\n");
}
}
public function printPair($n)
{
if ($n <= 0)
{
return;
}
echo("\nGiven n ".$n.
"\n");
$this->count = 0;
$element = array_fill(0, $n + 1, 0);
for ($i = 0; $i <= $n; ++$i)
{
$element[$i] = $i;
}
$this->findPairs($element, "", 1, $n);
}
}
function main()
{
$task = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
$task->printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
$task->printPair(5);
}
main();Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)/*
Node JS program for
Display Friends Pairing Group
*/
class Pairing
{
constructor()
{
this.count = 0;
}
swapElement(element, a, b)
{
var temp = element[a];
element[a] = element[b];
element[b] = temp;
}
findPairs(element, output, index, n)
{
if (index <= n)
{
// This is work on pair of single element
this.findPairs(element,
output + "(" + element[index] + ")",
index + 1, n);
for (var i = index + 1; i <= n; ++i)
{
if (index + 1 == i)
{
// Consicutive element are pair
this.findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")",
index + 2, n);
}
else
{
this.swapElement(element, i, index + 1);
this.findPairs(element,
output + " (" + element[index] + "," +
element[(index + 1)] + ")",
index + 2, n);
this.swapElement(element, i, index + 1);
}
}
}
else
{
// Increase the value of result counter
++this.count;
// Display pair result
console.log((this.count) + " : " + output);
}
}
printPair(n)
{
if (n <= 0)
{
return;
}
console.log("\nGiven n " + n);
this.count = 0;
var element = Array(n + 1).fill(0);
for (var i = 0; i <= n; ++i)
{
element[i] = i;
}
this.findPairs(element, "", 1, n);
}
}
function main()
{
var task = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}
main();Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)# Python 3 program for
# Display Friends Pairing Group
class Pairing :
def __init__(self) :
self.count = 0
def swapElement(self, element, a, b) :
temp = element[a]
element[a] = element[b]
element[b] = temp
def findPairs(self, element, output, index, n) :
if (index <= n) :
# This is work on pair of single element
self.findPairs(element, output + "("
+ str(element[index]) + ")", index + 1, n)
i = index + 1
while (i <= n) :
if (index + 1 == i) :
# Consicutive element are pair
self.findPairs(element, output + " ("
+ str(element[index]) + ","
+ str(element[(index + 1)]) + ")", index + 2, n)
else :
self.swapElement(element, i, index + 1)
self.findPairs(element, output + " ("
+ str(element[index]) + ","
+ str(element[(index + 1)]) + ")", index + 2, n)
self.swapElement(element, i, index + 1)
i += 1
else :
# Increase the value of result counter
self.count += 1
# Display pair result
print((self.count) ," : ", output)
def printPair(self, n) :
if (n <= 0) :
return
print("\nGiven n ", n)
self.count = 0
element = [0] * (n + 1)
i = 0
while (i <= n) :
element[i] = i
i += 1
self.findPairs(element, "", 1, n)
def main() :
task = Pairing()
# n = 4
# ------------
# (1)(2)(3)(4)
# (1)(2) (3,4)
# (1) (2,3)(4)
# (1) (2,4)(3)
# (1,2)(3)(4)
# (1,2) (3,4)
# (1,3)(2)(4)
# (1,3) (2,4)
# (1,4)(3)(2)
# (1,4) (3,2)
task.printPair(4)
# n = 5
# ------------
# (1)(2)(3)(4)(5)
# (1)(2)(3) (4,5)
# (1)(2) (3,4)(5)
# (1)(2) (3,5)(4)
# (1) (2,3)(4)(5)
# (1) (2,3) (4,5)
# (1) (2,4)(3)(5)
# (1) (2,4) (3,5)
# (1) (2,5)(4)(3)
# (1) (2,5) (4,3)
# (1,2)(3)(4)(5)
# (1,2)(3) (4,5)
# (1,2) (3,4)(5)
# (1,2) (3,5)(4)
# (1,3)(2)(4)(5)
# (1,3)(2) (4,5)
# (1,3) (2,4)(5)
# (1,3) (2,5)(4)
# (1,4)(3)(2)(5)
# (1,4)(3) (2,5)
# (1,4) (3,2)(5)
# (1,4) (3,5)(2)
# (1,5)(3)(4)(2)
# (1,5)(3) (4,2)
# (1,5) (3,4)(2)
# (1,5) (3,2)(4)
task.printPair(5)
if __name__ == "__main__": main()Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)# Ruby program for
# Display Friends Pairing Group
class Pairing
# Define the accessor and reader of class Pairing
attr_reader :count
attr_accessor :count
def initialize()
self.count = 0
end
def swapElement(element, a, b)
temp = element[a]
element[a] = element[b]
element[b] = temp
end
def findPairs(element, output, index, n)
if (index <= n)
# This is work on pair of single element
self.findPairs(element, output + "(" +
element[index].to_s + ")", index + 1, n)
i = index + 1
while (i <= n)
if (index + 1 == i)
# Consicutive element are pair
self.findPairs(element, output + " (" +
element[index].to_s + "," +
element[(index + 1)].to_s + ")",
index + 2, n)
else
self.swapElement(element, i, index + 1)
self.findPairs(element,
output + " (" +
element[index].to_s + "," +
element[(index + 1)].to_s + ")",
index + 2, n)
self.swapElement(element, i, index + 1)
end
i += 1
end
else
# Increase the value of result counter
self.count += 1
# Display pair result
print((self.count) ," : ", output, "\n")
end
end
def printPair(n)
if (n <= 0)
return
end
print("\nGiven n ", n, "\n")
self.count = 0
element = Array.new(n + 1) {0}
i = 0
while (i <= n)
element[i] = i
i += 1
end
self.findPairs(element, "", 1, n)
end
end
def main()
task = Pairing.new()
# n = 4
# ------------
# (1)(2)(3)(4)
# (1)(2) (3,4)
# (1) (2,3)(4)
# (1) (2,4)(3)
# (1,2)(3)(4)
# (1,2) (3,4)
# (1,3)(2)(4)
# (1,3) (2,4)
# (1,4)(3)(2)
# (1,4) (3,2)
task.printPair(4)
# n = 5
# ------------
# (1)(2)(3)(4)(5)
# (1)(2)(3) (4,5)
# (1)(2) (3,4)(5)
# (1)(2) (3,5)(4)
# (1) (2,3)(4)(5)
# (1) (2,3) (4,5)
# (1) (2,4)(3)(5)
# (1) (2,4) (3,5)
# (1) (2,5)(4)(3)
# (1) (2,5) (4,3)
# (1,2)(3)(4)(5)
# (1,2)(3) (4,5)
# (1,2) (3,4)(5)
# (1,2) (3,5)(4)
# (1,3)(2)(4)(5)
# (1,3)(2) (4,5)
# (1,3) (2,4)(5)
# (1,3) (2,5)(4)
# (1,4)(3)(2)(5)
# (1,4)(3) (2,5)
# (1,4) (3,2)(5)
# (1,4) (3,5)(2)
# (1,5)(3)(4)(2)
# (1,5)(3) (4,2)
# (1,5) (3,4)(2)
# (1,5) (3,2)(4)
task.printPair(5)
end
main()Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)
/*
Scala program for
Display Friends Pairing Group
*/
class Pairing(var count: Int)
{
def this()
{
this(0);
}
def swapElement(element: Array[Int], a: Int, b: Int): Unit = {
var temp: Int = element(a);
element(a) = element(b);
element(b) = temp;
}
def findPairs(
element: Array[Int],
output: String,
index: Int,
n: Int): Unit = {
if (index <= n)
{
// This is work on pair of single element
findPairs(element,
output + "(" + element(index).toString() + ")",
index + 1, n);
var i: Int = index + 1;
while (i <= n)
{
if (index + 1 == i)
{
// Consicutive element are pair
findPairs(element,
output + " (" + element(index).toString() + "," +
element((index + 1)).toString() + ")",
index + 2, n);
}
else
{
swapElement(element, i, index + 1);
findPairs(element, output + " (" +
element(index).toString() + "," +
element((index + 1)).toString() + ")",
index + 2, n);
swapElement(element, i, index + 1);
}
i += 1;
}
}
else
{
// Increase the value of result counter
this.count += 1;
// Display pair result
println(""+(this.count) + " : " + output);
}
}
def printPair(n: Int): Unit = {
if (n <= 0)
{
return;
}
println("\nGiven n " + n);
this.count = 0;
var element: Array[Int] = Array.fill[Int](n + 1)(0);
var i: Int = 0;
while (i <= n)
{
element(i) = i;
i += 1;
}
findPairs(element, "", 1, n);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Pairing = new Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)/*
Kotlin program for
Display Friends Pairing Group
*/
class Pairing
{
var count: Int;
constructor()
{
this.count = 0;
}
fun swapElement(element: Array < Int > , a: Int, b: Int): Unit
{
val temp: Int = element[a];
element[a] = element[b];
element[b] = temp;
}
fun findPairs(element: Array < Int > ,
output: String, index: Int, n: Int): Unit
{
if (index <= n)
{
// This is work on pair of single element
this.findPairs(element,
output + "(" + element[index].toString() + ")",
index + 1, n);
var i: Int = index + 1;
while (i <= n)
{
if (index + 1 == i)
{
// Consicutive element are pair
this.findPairs(element,
output + " (" + element[index].toString() +
"," + element[(index + 1)].toString() + ")",
index + 2, n);
}
else
{
this.swapElement(element, i, index + 1);
this.findPairs(element,
output + " (" +
element[index].toString() + "," +
element[(index + 1)].toString() + ")",
index + 2, n);
this.swapElement(element, i, index + 1);
}
i += 1;
}
}
else
{
// Increase the value of result counter
this.count += 1;
// Display pair result
println(""+(this.count) + " : " + output);
}
}
fun printPair(n: Int): Unit
{
if (n <= 0)
{
return;
}
println("\nGiven n " + n);
this.count = 0;
val element: Array < Int > = Array(n + 1)
{
0
};
var i: Int = 0;
while (i <= n)
{
element[i] = i;
i += 1;
}
this.findPairs(element, "", 1, n);
}
}
fun main(args: Array < String > ): Unit
{
val task: Pairing = Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)/*
Swift 4 program for
Display Friends Pairing Group
*/
class Pairing
{
var count: Int;
init()
{
self.count = 0;
}
func swapElement(_ element: inout[Int],
_ a: Int,
_ b: Int)
{
let temp: Int = element[a];
element[a] = element[b];
element[b] = temp;
}
func findPairs(_ element: inout[Int],
_ output: String, _ index: Int, _ n: Int)
{
if (index <= n)
{
// This is work on pair of single element
self.findPairs(&element, output + "("
+ String(element[index]) + ")", index + 1, n);
var i: Int = index + 1;
while (i <= n)
{
if (index + 1 == i)
{
// Consicutive element are pair
self.findPairs(&element, output + " ("
+ String(element[index]) + ","
+ String(element[(index + 1)]) + ")", index + 2, n);
}
else
{
self.swapElement(&element, i, index + 1);
self.findPairs(&element, output + " ("
+ String(element[index]) + ","
+ String(element[(index + 1)]) + ")", index + 2, n);
self.swapElement(&element, i, index + 1);
}
i += 1;
}
}
else
{
// Increase the value of result counter
self.count += 1;
// Display pair result
print((self.count) ," : ", output);
}
}
func printPair(_ n: Int)
{
if (n <= 0)
{
return;
}
print("\nGiven n ", n);
self.count = 0;
var element: [Int] = Array(repeating: 0, count: n + 1);
var i: Int = 0;
while (i <= n)
{
element[i] = i;
i += 1;
}
self.findPairs(&element, "", 1, n);
}
}
func main()
{
let task: Pairing = Pairing();
/*
n = 4
------------
(1)(2)(3)(4)
(1)(2) (3,4)
(1) (2,3)(4)
(1) (2,4)(3)
(1,2)(3)(4)
(1,2) (3,4)
(1,3)(2)(4)
(1,3) (2,4)
(1,4)(3)(2)
(1,4) (3,2)
*/
task.printPair(4);
/*
n = 5
------------
(1)(2)(3)(4)(5)
(1)(2)(3) (4,5)
(1)(2) (3,4)(5)
(1)(2) (3,5)(4)
(1) (2,3)(4)(5)
(1) (2,3) (4,5)
(1) (2,4)(3)(5)
(1) (2,4) (3,5)
(1) (2,5)(4)(3)
(1) (2,5) (4,3)
(1,2)(3)(4)(5)
(1,2)(3) (4,5)
(1,2) (3,4)(5)
(1,2) (3,5)(4)
(1,3)(2)(4)(5)
(1,3)(2) (4,5)
(1,3) (2,4)(5)
(1,3) (2,5)(4)
(1,4)(3)(2)(5)
(1,4)(3) (2,5)
(1,4) (3,2)(5)
(1,4) (3,5)(2)
(1,5)(3)(4)(2)
(1,5)(3) (4,2)
(1,5) (3,4)(2)
(1,5) (3,2)(4)
*/
task.printPair(5);
}
main();Output
Given n 4
1 : (1)(2)(3)(4)
2 : (1)(2) (3,4)
3 : (1) (2,3)(4)
4 : (1) (2,4)(3)
5 : (1,2)(3)(4)
6 : (1,2) (3,4)
7 : (1,3)(2)(4)
8 : (1,3) (2,4)
9 : (1,4)(3)(2)
10 : (1,4) (3,2)
Given n 5
1 : (1)(2)(3)(4)(5)
2 : (1)(2)(3) (4,5)
3 : (1)(2) (3,4)(5)
4 : (1)(2) (3,5)(4)
5 : (1) (2,3)(4)(5)
6 : (1) (2,3) (4,5)
7 : (1) (2,4)(3)(5)
8 : (1) (2,4) (3,5)
9 : (1) (2,5)(4)(3)
10 : (1) (2,5) (4,3)
11 : (1,2)(3)(4)(5)
12 : (1,2)(3) (4,5)
13 : (1,2) (3,4)(5)
14 : (1,2) (3,5)(4)
15 : (1,3)(2)(4)(5)
16 : (1,3)(2) (4,5)
17 : (1,3) (2,4)(5)
18 : (1,3) (2,5)(4)
19 : (1,4)(3)(2)(5)
20 : (1,4)(3) (2,5)
21 : (1,4) (3,2)(5)
22 : (1,4) (3,5)(2)
23 : (1,5)(3)(4)(2)
24 : (1,5)(3) (4,2)
25 : (1,5) (3,4)(2)
26 : (1,5) (3,2)(4)
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