Print all combinations of n natural number whose pair element difference is one

Here given code implementation process.

// C Program
// Print all combinations of n natural number 
// whose pair element difference is one
#include <stdio.h>

void subSequences(int result[], int start, int count, int n)
{
	if (count == n)
	{
		// Display resultant sequence
		for (int i = 0; i < n - 1; i += 2)
		{
			printf("(%d,%d) ", result[i], result[i + 1]);
		}
		printf("\n");
	}
	else if (count > n)
	{
		return;
	}
	else
	{
		for (int i = start; i < n; i += 2)
		{
          	// Set pair element
			result[count] = i + 1;
			result[count + 1] = i + 2;
			subSequences(result, start + 2, count + 2, n);
			result[count] = i + 2;
			result[count + 1] = i + 1;
			subSequences(result, i, count + 2, n);
		}
	}
}
void pairDifferences1s(int n)
{
	if (n % 2 != 0)
	{
		printf("\n Given n : %d is not even \n", n);
	}
	if (n <= 0)
	{
		return;
	}
  	printf(" Given : %d \n",n);
	// Auxiliary array which is collect result
	int result[n];
	subSequences(result, 0, 0, n);
}
int main()
{
	//  Length and natural number 1..n
	int n = 4;
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	pairDifferences1s(n);
	n = 6;
	/*

	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	pairDifferences1s(n);
	return 0;
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
// Java program for
// Print all combinations of n natural number 
// whose pair element difference is one
public class Combination
{
	public void subSequences(int[] result, 
  			int start, int count, int n)
	{
		if (count == n)
		{
			// Display resultant sequence
			for (int i = 0; i < n - 1; i += 2)
			{
				System.out.print("(" + result[i] + 
                                 "," + result[i + 1] + ") ");
			}
			System.out.print("\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			for (int i = start; i < n; i += 2)
			{
				// Set pair element
				result[count] = i + 1;
				result[count + 1] = i + 2;
				subSequences(result, start + 2, count + 2, n);
				result[count] = i + 2;
				result[count + 1] = i + 1;
				subSequences(result, i, count + 2, n);
			}
		}
	}
	public void pairDifferences1s(int n)
	{
		if (n % 2 != 0)
		{
			System.out.print("\n Given n : " + 
                             n + " is not even \n");
		}
		if (n <= 0)
		{
			return;
		}
		System.out.print(" Given : " + n + " \n");
		// Auxiliary array which is collect result
		int[] result = new int[n];
		subSequences(result, 0, 0, n);
	}
	public static void main(String[] args)
	{
		Combination task = new Combination();
		//  Length and natural number 1..n
		int n = 4;
		/*
		    n = 4
		    ----------
		    (1,2) (3,4) 
		    (1,2) (4,3) 
		    (2,1) (1,2) 
		    (2,1) (2,1) 
		    (2,1) (3,4) 
		    (2,1) (4,3) 
		    (3,4) (3,4) 
		    (3,4) (4,3) 
		    (4,3) (3,4) 
		    (4,3) (4,3)
		  
		*/
		// Test A
		task.pairDifferences1s(n);
		n = 6;
		/*

		    n = 6
		    pair n/2 = 3 pair in each result
		    ----------
		    (1,2) (3,4) (5,6) 
		    (1,2) (3,4) (6,5) 
		    (1,2) (4,3) (3,4) 
		    (1,2) (4,3) (4,3) 
		    (1,2) (4,3) (5,6) 
		    (1,2) (4,3) (6,5) 
		    (1,2) (5,6) (5,6) 
		    (1,2) (5,6) (6,5) 
		    (1,2) (6,5) (5,6) 
		    (1,2) (6,5) (6,5) 
		    (2,1) (1,2) (3,4) 
		    (2,1) (1,2) (4,3) 
		    (2,1) (1,2) (5,6) 
		    (2,1) (1,2) (6,5) 
		    (2,1) (2,1) (1,2) 
		    (2,1) (2,1) (2,1) 
		    (2,1) (2,1) (3,4) 
		    (2,1) (2,1) (4,3) 
		    (2,1) (2,1) (5,6) 
		    (2,1) (2,1) (6,5) 
		    (2,1) (3,4) (3,4) 
		    (2,1) (3,4) (4,3) 
		    (2,1) (3,4) (5,6) 
		    (2,1) (3,4) (6,5) 
		    (2,1) (4,3) (3,4) 
		    (2,1) (4,3) (4,3) 
		    (2,1) (4,3) (5,6) 
		    (2,1) (4,3) (6,5) 
		    (2,1) (5,6) (3,4) 
		    (2,1) (5,6) (4,3) 
		    (2,1) (5,6) (5,6) 
		    (2,1) (5,6) (6,5) 
		    (2,1) (6,5) (5,6) 
		    (2,1) (6,5) (6,5) 
		    (3,4) (3,4) (5,6) 
		    (3,4) (3,4) (6,5) 
		    (3,4) (4,3) (3,4) 
		    (3,4) (4,3) (4,3) 
		    (3,4) (4,3) (5,6) 
		    (3,4) (4,3) (6,5) 
		    (3,4) (5,6) (5,6) 
		    (3,4) (5,6) (6,5) 
		    (3,4) (6,5) (5,6) 
		    (3,4) (6,5) (6,5) 
		    (4,3) (3,4) (5,6) 
		    (4,3) (3,4) (6,5) 
		    (4,3) (4,3) (3,4) 
		    (4,3) (4,3) (4,3) 
		    (4,3) (4,3) (5,6) 
		    (4,3) (4,3) (6,5) 
		    (4,3) (5,6) (5,6) 
		    (4,3) (5,6) (6,5) 
		    (4,3) (6,5) (5,6) 
		    (4,3) (6,5) (6,5) 
		    (5,6) (3,4) (5,6) 
		    (5,6) (3,4) (6,5) 
		    (5,6) (4,3) (3,4) 
		    (5,6) (4,3) (4,3) 
		    (5,6) (4,3) (5,6) 
		    (5,6) (4,3) (6,5) 
		    (5,6) (5,6) (5,6) 
		    (5,6) (5,6) (6,5) 
		    (5,6) (6,5) (5,6) 
		    (5,6) (6,5) (6,5) 
		    (6,5) (6,5) (5,6) 
		    (6,5) (6,5) (6,5)
		  
		*/
		// Test B
		task.pairDifferences1s(n);
	}
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
// Include header file
#include <iostream>

using namespace std;
// C++ program for
// Print all combinations of n natural number 
// whose pair element difference is one
class Combination
{
    public: void subSequences(int result[], 
      int start, 
        int count, 
          int n)
    {
        if (count == n)
        {
            // Display resultant sequence
            for (int i = 0; i < n - 1; i += 2)
            {
                cout << "(" 
                     << result[i] 
                     << "," 
                     << result[i + 1] 
                     << ") ";
            }
            cout << "\n";
        }
        else if (count > n)
        {
            return;
        }
        else
        {
            for (int i = start; i < n; i += 2)
            {
                // Set pair element
                result[count] = i + 1;
                result[count + 1] = i + 2;
                this->subSequences(result, start + 2, count + 2, n);
                result[count] = i + 2;
                result[count + 1] = i + 1;
                this->subSequences(result, i, count + 2, n);
            }
        }
    }
    void pairDifferences1s(int n)
    {
        if (n % 2 != 0)
        {
            cout << "\n Given n : " << n << " is not even \n";
        }
        if (n <= 0)
        {
            return;
        }
        cout << " Given : " << n << " \n";
        // Auxiliary array which is collect result
        int result[n];
        this->subSequences(result, 0, 0, n);
    }
};
int main()
{
    Combination *task = new Combination();
    //  Length and natural number 1..n
    int n = 4;
    /*
        n = 4
        ----------
        (1,2) (3,4) 
        (1,2) (4,3) 
        (2,1) (1,2) 
        (2,1) (2,1) 
        (2,1) (3,4) 
        (2,1) (4,3) 
        (3,4) (3,4) 
        (3,4) (4,3) 
        (4,3) (3,4) 
        (4,3) (4,3)
      
    */
    // Test A
    task->pairDifferences1s(n);
    n = 6;
    /*

        n = 6
        pair n/2 = 3 pair in each result
        ----------
        (1,2) (3,4) (5,6) 
        (1,2) (3,4) (6,5) 
        (1,2) (4,3) (3,4) 
        (1,2) (4,3) (4,3) 
        (1,2) (4,3) (5,6) 
        (1,2) (4,3) (6,5) 
        (1,2) (5,6) (5,6) 
        (1,2) (5,6) (6,5) 
        (1,2) (6,5) (5,6) 
        (1,2) (6,5) (6,5) 
        (2,1) (1,2) (3,4) 
        (2,1) (1,2) (4,3) 
        (2,1) (1,2) (5,6) 
        (2,1) (1,2) (6,5) 
        (2,1) (2,1) (1,2) 
        (2,1) (2,1) (2,1) 
        (2,1) (2,1) (3,4) 
        (2,1) (2,1) (4,3) 
        (2,1) (2,1) (5,6) 
        (2,1) (2,1) (6,5) 
        (2,1) (3,4) (3,4) 
        (2,1) (3,4) (4,3) 
        (2,1) (3,4) (5,6) 
        (2,1) (3,4) (6,5) 
        (2,1) (4,3) (3,4) 
        (2,1) (4,3) (4,3) 
        (2,1) (4,3) (5,6) 
        (2,1) (4,3) (6,5) 
        (2,1) (5,6) (3,4) 
        (2,1) (5,6) (4,3) 
        (2,1) (5,6) (5,6) 
        (2,1) (5,6) (6,5) 
        (2,1) (6,5) (5,6) 
        (2,1) (6,5) (6,5) 
        (3,4) (3,4) (5,6) 
        (3,4) (3,4) (6,5) 
        (3,4) (4,3) (3,4) 
        (3,4) (4,3) (4,3) 
        (3,4) (4,3) (5,6) 
        (3,4) (4,3) (6,5) 
        (3,4) (5,6) (5,6) 
        (3,4) (5,6) (6,5) 
        (3,4) (6,5) (5,6) 
        (3,4) (6,5) (6,5) 
        (4,3) (3,4) (5,6) 
        (4,3) (3,4) (6,5) 
        (4,3) (4,3) (3,4) 
        (4,3) (4,3) (4,3) 
        (4,3) (4,3) (5,6) 
        (4,3) (4,3) (6,5) 
        (4,3) (5,6) (5,6) 
        (4,3) (5,6) (6,5) 
        (4,3) (6,5) (5,6) 
        (4,3) (6,5) (6,5) 
        (5,6) (3,4) (5,6) 
        (5,6) (3,4) (6,5) 
        (5,6) (4,3) (3,4) 
        (5,6) (4,3) (4,3) 
        (5,6) (4,3) (5,6) 
        (5,6) (4,3) (6,5) 
        (5,6) (5,6) (5,6) 
        (5,6) (5,6) (6,5) 
        (5,6) (6,5) (5,6) 
        (5,6) (6,5) (6,5) 
        (6,5) (6,5) (5,6) 
        (6,5) (6,5) (6,5)
      
    */
    // Test B
    task->pairDifferences1s(n);
    return 0;
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
// Include namespace system
using System;
// Csharp program for
// Print all combinations of n natural number
// whose pair element difference is one
public class Combination
{
	public void subSequences(int[] result, 
  				int start, int count, int n)
	{
		if (count == n)
		{
			// Display resultant sequence
			for (int i = 0; i < n - 1; i += 2)
			{
				Console.Write("(" + result[i] + "," + 
                              result[i + 1] + ") ");
			}
			Console.Write("\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			for (int i = start; i < n; i += 2)
			{
				// Set pair element
				result[count] = i + 1;
				result[count + 1] = i + 2;
				this.subSequences(result, 
                                  start + 2, 
                                  count + 2, 
                                  n);
				result[count] = i + 2;
				result[count + 1] = i + 1;
				this.subSequences(result, 
                                  i, 
                                  count + 2,
                                  n);
			}
		}
	}
	public void pairDifferences1s(int n)
	{
		if (n % 2 != 0)
		{
			Console.Write("\n Given n : " + 
                          n + " is not even \n");
		}
		if (n <= 0)
		{
			return;
		}
		Console.Write(" Given : " + n + " \n");
		// Auxiliary array which is collect result
		int[] result = new int[n];
		this.subSequences(result, 0, 0, n);
	}
	public static void Main(String[] args)
	{
		Combination task = new Combination();
		//  Length and natural number 1..n
		int n = 4;
		/*
		    n = 4
		    ----------
		    (1,2) (3,4) 
		    (1,2) (4,3) 
		    (2,1) (1,2) 
		    (2,1) (2,1) 
		    (2,1) (3,4) 
		    (2,1) (4,3) 
		    (3,4) (3,4) 
		    (3,4) (4,3) 
		    (4,3) (3,4) 
		    (4,3) (4,3)
		  
		*/
		// Test A
		task.pairDifferences1s(n);
		n = 6;
		/*
		    n = 6
		    pair n/2 = 3 pair in each result
		    ----------
		    (1,2) (3,4) (5,6) 
		    (1,2) (3,4) (6,5) 
		    (1,2) (4,3) (3,4) 
		    (1,2) (4,3) (4,3) 
		    (1,2) (4,3) (5,6) 
		    (1,2) (4,3) (6,5) 
		    (1,2) (5,6) (5,6) 
		    (1,2) (5,6) (6,5) 
		    (1,2) (6,5) (5,6) 
		    (1,2) (6,5) (6,5) 
		    (2,1) (1,2) (3,4) 
		    (2,1) (1,2) (4,3) 
		    (2,1) (1,2) (5,6) 
		    (2,1) (1,2) (6,5) 
		    (2,1) (2,1) (1,2) 
		    (2,1) (2,1) (2,1) 
		    (2,1) (2,1) (3,4) 
		    (2,1) (2,1) (4,3) 
		    (2,1) (2,1) (5,6) 
		    (2,1) (2,1) (6,5) 
		    (2,1) (3,4) (3,4) 
		    (2,1) (3,4) (4,3) 
		    (2,1) (3,4) (5,6) 
		    (2,1) (3,4) (6,5) 
		    (2,1) (4,3) (3,4) 
		    (2,1) (4,3) (4,3) 
		    (2,1) (4,3) (5,6) 
		    (2,1) (4,3) (6,5) 
		    (2,1) (5,6) (3,4) 
		    (2,1) (5,6) (4,3) 
		    (2,1) (5,6) (5,6) 
		    (2,1) (5,6) (6,5) 
		    (2,1) (6,5) (5,6) 
		    (2,1) (6,5) (6,5) 
		    (3,4) (3,4) (5,6) 
		    (3,4) (3,4) (6,5) 
		    (3,4) (4,3) (3,4) 
		    (3,4) (4,3) (4,3) 
		    (3,4) (4,3) (5,6) 
		    (3,4) (4,3) (6,5) 
		    (3,4) (5,6) (5,6) 
		    (3,4) (5,6) (6,5) 
		    (3,4) (6,5) (5,6) 
		    (3,4) (6,5) (6,5) 
		    (4,3) (3,4) (5,6) 
		    (4,3) (3,4) (6,5) 
		    (4,3) (4,3) (3,4) 
		    (4,3) (4,3) (4,3) 
		    (4,3) (4,3) (5,6) 
		    (4,3) (4,3) (6,5) 
		    (4,3) (5,6) (5,6) 
		    (4,3) (5,6) (6,5) 
		    (4,3) (6,5) (5,6) 
		    (4,3) (6,5) (6,5) 
		    (5,6) (3,4) (5,6) 
		    (5,6) (3,4) (6,5) 
		    (5,6) (4,3) (3,4) 
		    (5,6) (4,3) (4,3) 
		    (5,6) (4,3) (5,6) 
		    (5,6) (4,3) (6,5) 
		    (5,6) (5,6) (5,6) 
		    (5,6) (5,6) (6,5) 
		    (5,6) (6,5) (5,6) 
		    (5,6) (6,5) (6,5) 
		    (6,5) (6,5) (5,6) 
		    (6,5) (6,5) (6,5)
		  
		*/
		// Test B
		task.pairDifferences1s(n);
	}
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
package main
import "fmt"
// Go program for
// Print all combinations of n natural number
// whose pair element difference is one
type Combination struct {}
func getCombination() * Combination {
	var me *Combination = &Combination {}
	return me
}
func(this Combination) subSequences(result[] int, 
		start int, 
		count int, 
		n int) {
	if count == n {
		// Display resultant sequence
		for i := 0 ; i < n - 1 ; i += 2 {
			fmt.Print("(", 
				result[i], 
				",", 
				result[i+1], 
				") ")
		}
		fmt.Print("\n")
	} else if count > n {
		return
	} else {
		for i := start ; i < n ; i += 2 {
			// Set pair element
			result[count] = i + 1
			result[count + 1] = i + 2
			this.subSequences(result, start + 2, count + 2, n)
			result[count] = i + 2
			result[count + 1] = i + 1
			this.subSequences(result, i, count + 2, n)
		}
	}
}
func(this Combination) pairDifferences1s(n int) {
	if n % 2 != 0 {
		fmt.Print("\n Given n : ", n, " is not even \n")
	}
	if n <= 0 {
		return
	}
	fmt.Print(" Given : ", n, " \n")
	// Auxiliary array which is collect result
	var result = make([] int, n)
	this.subSequences(result, 0, 0, n)
}
func main() {
	var task * Combination = getCombination()
	//  Length and natural number 1..n
	var n int = 4
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	task.pairDifferences1s(n)
	n = 6
	/*
	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	task.pairDifferences1s(n)
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
<?php
// Php program for
// Print all combinations of n natural number
// whose pair element difference is one
class Combination
{
	public	function subSequences($result, 
                                   $start, 
                                   $count, 
                                   $n)
	{
		if ($count == $n)
		{
			// Display resultant sequence
			for ($i = 0; $i < $n - 1; $i += 2)
			{
				echo("(".$result[$i].
					",".$result[$i + 1].
					") ");
			}
			echo("\n");
		}
		else if ($count > $n)
		{
			return;
		}
		else
		{
			for ($i = $start; $i < $n; $i += 2)
			{
				// Set pair element
				$result[$count] = $i + 1;
				$result[$count + 1] = $i + 2;
				$this->subSequences($result, 
                                    $start + 2, 
                                    $count + 2,
                                    $n);
				$result[$count] = $i + 2;
				$result[$count + 1] = $i + 1;
				$this->subSequences($result, 
                                    $i, 
                                    $count + 2, 
                                    $n);
			}
		}
	}
	public	function pairDifferences1s($n)
	{
		if ($n % 2 != 0)
		{
			echo("\n Given n : ".$n.
				" is not even \n");
		}
		if ($n <= 0)
		{
			return;
		}
		echo(" Given : ".$n.
			" \n");
		// Auxiliary array which is collect result
		$result = array_fill(0, $n, 0);
		$this->subSequences($result, 0, 0, $n);
	}
}

function main()
{
	$task = new Combination();
	//  Length and natural number 1..n
	$n = 4;
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	$task->pairDifferences1s($n);
	$n = 6;
	/*
	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	$task->pairDifferences1s($n);
}
main();

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
// Node JS program for
// Print all combinations of n natural number
// whose pair element difference is one
class Combination
{
	subSequences(result, start, count, n)
	{
		if (count == n)
		{
			// Display resultant sequence
			for (var i = 0; i < n - 1; i += 2)
			{
				process.stdout.write("(" + 
                                     result[i] + "," + 
                                     result[i + 1] + ") ");
			}
			process.stdout.write("\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			for (var i = start; i < n; i += 2)
			{
				// Set pair element
				result[count] = i + 1;
				result[count + 1] = i + 2;
				this.subSequences(result, 
                                  start + 2, count + 2, n);
				result[count] = i + 2;
				result[count + 1] = i + 1;
				this.subSequences(result, 
                                  i, count + 2, n);
			}
		}
	}
	pairDifferences1s(n)
	{
		if (n % 2 != 0)
		{
			process.stdout.write("\n Given n : " + 
                                 n + " is not even \n");
		}
		if (n <= 0)
		{
			return;
		}
		process.stdout.write(" Given : " + n + " \n");
		// Auxiliary array which is collect result
		var result = Array(n).fill(0);
		this.subSequences(result, 0, 0, n);
	}
}

function main()
{
	var task = new Combination();
	//  Length and natural number 1..n
	var n = 4;
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	task.pairDifferences1s(n);
	n = 6;
	/*
	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	task.pairDifferences1s(n);
}
main();

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
#  Python 3 program for
#  Print all combinations of n natural number
#  whose pair element difference is one
class Combination :
	def subSequences(self, result, start, count, n) :
		if (count == n) :
			i = 0
			#  Display resultant sequence
			while (i < n - 1) :
				print("(", 
                      result[i] ,",", 
                      result[i + 1] ,") ", 
                      end = "",sep = "")
				i += 2
			
			print(end = "\n")
		elif (count > n) :
			return
		else :
			i = start
			while (i < n) :
				#  Set pair element
				result[count] = i + 1
				result[count + 1] = i + 2
				self.subSequences(result, 
                                  start + 2, 
                                  count + 2, 
                                  n)
				result[count] = i + 2
				result[count + 1] = i + 1
				self.subSequences(result, 
                                  i, 
                                  count + 2,
                                  n)
				i += 2
			
		
	
	def pairDifferences1s(self, n) :
		if (n % 2 != 0) :
			print("\n Given n : ", n ," is not even ")
		
		if (n <= 0) :
			return
		
		print(" Given : ", n ," ")
		#  Auxiliary list which is collect result
		result = [0] * (n)
		self.subSequences(result, 0, 0, n)
	

def main() :
	task = Combination()
	#   Length and natural number 1..n
	n = 4
	#    n = 4
	#    ----------
	#    (1,2) (3,4) 
	#    (1,2) (4,3) 
	#    (2,1) (1,2) 
	#    (2,1) (2,1) 
	#    (2,1) (3,4) 
	#    (2,1) (4,3) 
	#    (3,4) (3,4) 
	#    (3,4) (4,3) 
	#    (4,3) (3,4) 
	#    (4,3) (4,3)
	#  Test A
	task.pairDifferences1s(n)
	n = 6
	#    n = 6
	#    pair n/2 = 3 pair in each result
	#    ----------
	#    (1,2) (3,4) (5,6) 
	#    (1,2) (3,4) (6,5) 
	#    (1,2) (4,3) (3,4) 
	#    (1,2) (4,3) (4,3) 
	#    (1,2) (4,3) (5,6) 
	#    (1,2) (4,3) (6,5) 
	#    (1,2) (5,6) (5,6) 
	#    (1,2) (5,6) (6,5) 
	#    (1,2) (6,5) (5,6) 
	#    (1,2) (6,5) (6,5) 
	#    (2,1) (1,2) (3,4) 
	#    (2,1) (1,2) (4,3) 
	#    (2,1) (1,2) (5,6) 
	#    (2,1) (1,2) (6,5) 
	#    (2,1) (2,1) (1,2) 
	#    (2,1) (2,1) (2,1) 
	#    (2,1) (2,1) (3,4) 
	#    (2,1) (2,1) (4,3) 
	#    (2,1) (2,1) (5,6) 
	#    (2,1) (2,1) (6,5) 
	#    (2,1) (3,4) (3,4) 
	#    (2,1) (3,4) (4,3) 
	#    (2,1) (3,4) (5,6) 
	#    (2,1) (3,4) (6,5) 
	#    (2,1) (4,3) (3,4) 
	#    (2,1) (4,3) (4,3) 
	#    (2,1) (4,3) (5,6) 
	#    (2,1) (4,3) (6,5) 
	#    (2,1) (5,6) (3,4) 
	#    (2,1) (5,6) (4,3) 
	#    (2,1) (5,6) (5,6) 
	#    (2,1) (5,6) (6,5) 
	#    (2,1) (6,5) (5,6) 
	#    (2,1) (6,5) (6,5) 
	#    (3,4) (3,4) (5,6) 
	#    (3,4) (3,4) (6,5) 
	#    (3,4) (4,3) (3,4) 
	#    (3,4) (4,3) (4,3) 
	#    (3,4) (4,3) (5,6) 
	#    (3,4) (4,3) (6,5) 
	#    (3,4) (5,6) (5,6) 
	#    (3,4) (5,6) (6,5) 
	#    (3,4) (6,5) (5,6) 
	#    (3,4) (6,5) (6,5) 
	#    (4,3) (3,4) (5,6) 
	#    (4,3) (3,4) (6,5) 
	#    (4,3) (4,3) (3,4) 
	#    (4,3) (4,3) (4,3) 
	#    (4,3) (4,3) (5,6) 
	#    (4,3) (4,3) (6,5) 
	#    (4,3) (5,6) (5,6) 
	#    (4,3) (5,6) (6,5) 
	#    (4,3) (6,5) (5,6) 
	#    (4,3) (6,5) (6,5) 
	#    (5,6) (3,4) (5,6) 
	#    (5,6) (3,4) (6,5) 
	#    (5,6) (4,3) (3,4) 
	#    (5,6) (4,3) (4,3) 
	#    (5,6) (4,3) (5,6) 
	#    (5,6) (4,3) (6,5) 
	#    (5,6) (5,6) (5,6) 
	#    (5,6) (5,6) (6,5) 
	#    (5,6) (6,5) (5,6) 
	#    (5,6) (6,5) (6,5) 
	#    (6,5) (6,5) (5,6) 
	#    (6,5) (6,5) (6,5)
	#  Test B
	task.pairDifferences1s(n)

if __name__ == "__main__": main()

Output

 Given :  4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given :  6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
#  Ruby program for
#  Print all combinations of n natural number
#  whose pair element difference is one
class Combination 
	def subSequences(result, start, count, n) 
		if (count == n) 
			i = 0
			#  Display resultant sequence
			while (i < n - 1) 
				print("(", result[i] ,",", 
                      result[i + 1] ,") ")
				i += 2
			end

			print("\n")
		elsif (count > n) 
			return
		else
 
			i = start
			while (i < n) 
				#  Set pair element
				result[count] = i + 1
				result[count + 1] = i + 2
				self.subSequences(result, 
                                  start + 2, 
                                  count + 2, n)
				result[count] = i + 2
				result[count + 1] = i + 1
				self.subSequences(result, 
                                  i, 
                                  count + 2, 
                                  n)
				i += 2
			end

		end

	end

	def pairDifferences1s(n) 
		if (n % 2 != 0) 
			print("\n Given n : ", 
                  n ," is not even \n")
		end

		if (n <= 0) 
			return
		end

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

end

def main() 
	task = Combination.new()
	#   Length and natural number 1..n
	n = 4
	#    n = 4
	#    ----------
	#    (1,2) (3,4) 
	#    (1,2) (4,3) 
	#    (2,1) (1,2) 
	#    (2,1) (2,1) 
	#    (2,1) (3,4) 
	#    (2,1) (4,3) 
	#    (3,4) (3,4) 
	#    (3,4) (4,3) 
	#    (4,3) (3,4) 
	#    (4,3) (4,3)
	#  Test A
	task.pairDifferences1s(n)
	n = 6
	#    n = 6
	#    pair n/2 = 3 pair in each result
	#    ----------
	#    (1,2) (3,4) (5,6) 
	#    (1,2) (3,4) (6,5) 
	#    (1,2) (4,3) (3,4) 
	#    (1,2) (4,3) (4,3) 
	#    (1,2) (4,3) (5,6) 
	#    (1,2) (4,3) (6,5) 
	#    (1,2) (5,6) (5,6) 
	#    (1,2) (5,6) (6,5) 
	#    (1,2) (6,5) (5,6) 
	#    (1,2) (6,5) (6,5) 
	#    (2,1) (1,2) (3,4) 
	#    (2,1) (1,2) (4,3) 
	#    (2,1) (1,2) (5,6) 
	#    (2,1) (1,2) (6,5) 
	#    (2,1) (2,1) (1,2) 
	#    (2,1) (2,1) (2,1) 
	#    (2,1) (2,1) (3,4) 
	#    (2,1) (2,1) (4,3) 
	#    (2,1) (2,1) (5,6) 
	#    (2,1) (2,1) (6,5) 
	#    (2,1) (3,4) (3,4) 
	#    (2,1) (3,4) (4,3) 
	#    (2,1) (3,4) (5,6) 
	#    (2,1) (3,4) (6,5) 
	#    (2,1) (4,3) (3,4) 
	#    (2,1) (4,3) (4,3) 
	#    (2,1) (4,3) (5,6) 
	#    (2,1) (4,3) (6,5) 
	#    (2,1) (5,6) (3,4) 
	#    (2,1) (5,6) (4,3) 
	#    (2,1) (5,6) (5,6) 
	#    (2,1) (5,6) (6,5) 
	#    (2,1) (6,5) (5,6) 
	#    (2,1) (6,5) (6,5) 
	#    (3,4) (3,4) (5,6) 
	#    (3,4) (3,4) (6,5) 
	#    (3,4) (4,3) (3,4) 
	#    (3,4) (4,3) (4,3) 
	#    (3,4) (4,3) (5,6) 
	#    (3,4) (4,3) (6,5) 
	#    (3,4) (5,6) (5,6) 
	#    (3,4) (5,6) (6,5) 
	#    (3,4) (6,5) (5,6) 
	#    (3,4) (6,5) (6,5) 
	#    (4,3) (3,4) (5,6) 
	#    (4,3) (3,4) (6,5) 
	#    (4,3) (4,3) (3,4) 
	#    (4,3) (4,3) (4,3) 
	#    (4,3) (4,3) (5,6) 
	#    (4,3) (4,3) (6,5) 
	#    (4,3) (5,6) (5,6) 
	#    (4,3) (5,6) (6,5) 
	#    (4,3) (6,5) (5,6) 
	#    (4,3) (6,5) (6,5) 
	#    (5,6) (3,4) (5,6) 
	#    (5,6) (3,4) (6,5) 
	#    (5,6) (4,3) (3,4) 
	#    (5,6) (4,3) (4,3) 
	#    (5,6) (4,3) (5,6) 
	#    (5,6) (4,3) (6,5) 
	#    (5,6) (5,6) (5,6) 
	#    (5,6) (5,6) (6,5) 
	#    (5,6) (6,5) (5,6) 
	#    (5,6) (6,5) (6,5) 
	#    (6,5) (6,5) (5,6) 
	#    (6,5) (6,5) (6,5)
	#  Test B
	task.pairDifferences1s(n)
end

main()

Output

 Given : 4 
(1,2) (3,4) 
(1,2) (4,3) 
(2,1) (1,2) 
(2,1) (2,1) 
(2,1) (3,4) 
(2,1) (4,3) 
(3,4) (3,4) 
(3,4) (4,3) 
(4,3) (3,4) 
(4,3) (4,3) 
 Given : 6 
(1,2) (3,4) (5,6) 
(1,2) (3,4) (6,5) 
(1,2) (4,3) (3,4) 
(1,2) (4,3) (4,3) 
(1,2) (4,3) (5,6) 
(1,2) (4,3) (6,5) 
(1,2) (5,6) (5,6) 
(1,2) (5,6) (6,5) 
(1,2) (6,5) (5,6) 
(1,2) (6,5) (6,5) 
(2,1) (1,2) (3,4) 
(2,1) (1,2) (4,3) 
(2,1) (1,2) (5,6) 
(2,1) (1,2) (6,5) 
(2,1) (2,1) (1,2) 
(2,1) (2,1) (2,1) 
(2,1) (2,1) (3,4) 
(2,1) (2,1) (4,3) 
(2,1) (2,1) (5,6) 
(2,1) (2,1) (6,5) 
(2,1) (3,4) (3,4) 
(2,1) (3,4) (4,3) 
(2,1) (3,4) (5,6) 
(2,1) (3,4) (6,5) 
(2,1) (4,3) (3,4) 
(2,1) (4,3) (4,3) 
(2,1) (4,3) (5,6) 
(2,1) (4,3) (6,5) 
(2,1) (5,6) (3,4) 
(2,1) (5,6) (4,3) 
(2,1) (5,6) (5,6) 
(2,1) (5,6) (6,5) 
(2,1) (6,5) (5,6) 
(2,1) (6,5) (6,5) 
(3,4) (3,4) (5,6) 
(3,4) (3,4) (6,5) 
(3,4) (4,3) (3,4) 
(3,4) (4,3) (4,3) 
(3,4) (4,3) (5,6) 
(3,4) (4,3) (6,5) 
(3,4) (5,6) (5,6) 
(3,4) (5,6) (6,5) 
(3,4) (6,5) (5,6) 
(3,4) (6,5) (6,5) 
(4,3) (3,4) (5,6) 
(4,3) (3,4) (6,5) 
(4,3) (4,3) (3,4) 
(4,3) (4,3) (4,3) 
(4,3) (4,3) (5,6) 
(4,3) (4,3) (6,5) 
(4,3) (5,6) (5,6) 
(4,3) (5,6) (6,5) 
(4,3) (6,5) (5,6) 
(4,3) (6,5) (6,5) 
(5,6) (3,4) (5,6) 
(5,6) (3,4) (6,5) 
(5,6) (4,3) (3,4) 
(5,6) (4,3) (4,3) 
(5,6) (4,3) (5,6) 
(5,6) (4,3) (6,5) 
(5,6) (5,6) (5,6) 
(5,6) (5,6) (6,5) 
(5,6) (6,5) (5,6) 
(5,6) (6,5) (6,5) 
(6,5) (6,5) (5,6) 
(6,5) (6,5) (6,5) 
// Scala program for
// Print all combinations of n natural number
// whose pair element difference is one
class Combination()
{
	def subSequences(result: Array[Int], 
      start: Int, count: Int, 
        n: Int): Unit = {
		if (count == n)
		{
			var i: Int = 0;
			// Display resultant sequence
			while (i < n - 1)
			{
				print("(" + result(i) + "," + 
                      result(i + 1) + ") ");
				i += 2;
			}
			print("\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			var i: Int = start;
			while (i < n)
			{
				// Set pair element
				result(count) = i + 1;
				result(count + 1) = i + 2;
				subSequences(result, 
                             start + 2, 
                             count + 2, 
                             n);
				result(count) = i + 2;
				result(count + 1) = i + 1;
				subSequences(result, i, count + 2, n);
				i += 2;
			}
		}
	}
	def pairDifferences1s(n: Int): Unit = {
		if (n % 2 != 0)
		{
			print("\n Given n : " + n + " is not even \n");
		}
		if (n <= 0)
		{
			return;
		}
		print(" Given : " + n + " \n");
		// Auxiliary array which is collect result
		var result: Array[Int] = Array.fill[Int](n)(0);
		subSequences(result, 0, 0, n);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Combination = new Combination();
		//  Length and natural number 1..n
		var n: Int = 4;
		/*
		    n = 4
		    ----------
		    (1,2) (3,4) 
		    (1,2) (4,3) 
		    (2,1) (1,2) 
		    (2,1) (2,1) 
		    (2,1) (3,4) 
		    (2,1) (4,3) 
		    (3,4) (3,4) 
		    (3,4) (4,3) 
		    (4,3) (3,4) 
		    (4,3) (4,3)
		  
		*/
		// Test A
		task.pairDifferences1s(n);
		n = 6;
		/*
		    n = 6
		    pair n/2 = 3 pair in each result
		    ----------
		    (1,2) (3,4) (5,6) 
		    (1,2) (3,4) (6,5) 
		    (1,2) (4,3) (3,4) 
		    (1,2) (4,3) (4,3) 
		    (1,2) (4,3) (5,6) 
		    (1,2) (4,3) (6,5) 
		    (1,2) (5,6) (5,6) 
		    (1,2) (5,6) (6,5) 
		    (1,2) (6,5) (5,6) 
		    (1,2) (6,5) (6,5) 
		    (2,1) (1,2) (3,4) 
		    (2,1) (1,2) (4,3) 
		    (2,1) (1,2) (5,6) 
		    (2,1) (1,2) (6,5) 
		    (2,1) (2,1) (1,2) 
		    (2,1) (2,1) (2,1) 
		    (2,1) (2,1) (3,4) 
		    (2,1) (2,1) (4,3) 
		    (2,1) (2,1) (5,6) 
		    (2,1) (2,1) (6,5) 
		    (2,1) (3,4) (3,4) 
		    (2,1) (3,4) (4,3) 
		    (2,1) (3,4) (5,6) 
		    (2,1) (3,4) (6,5) 
		    (2,1) (4,3) (3,4) 
		    (2,1) (4,3) (4,3) 
		    (2,1) (4,3) (5,6) 
		    (2,1) (4,3) (6,5) 
		    (2,1) (5,6) (3,4) 
		    (2,1) (5,6) (4,3) 
		    (2,1) (5,6) (5,6) 
		    (2,1) (5,6) (6,5) 
		    (2,1) (6,5) (5,6) 
		    (2,1) (6,5) (6,5) 
		    (3,4) (3,4) (5,6) 
		    (3,4) (3,4) (6,5) 
		    (3,4) (4,3) (3,4) 
		    (3,4) (4,3) (4,3) 
		    (3,4) (4,3) (5,6) 
		    (3,4) (4,3) (6,5) 
		    (3,4) (5,6) (5,6) 
		    (3,4) (5,6) (6,5) 
		    (3,4) (6,5) (5,6) 
		    (3,4) (6,5) (6,5) 
		    (4,3) (3,4) (5,6) 
		    (4,3) (3,4) (6,5) 
		    (4,3) (4,3) (3,4) 
		    (4,3) (4,3) (4,3) 
		    (4,3) (4,3) (5,6) 
		    (4,3) (4,3) (6,5) 
		    (4,3) (5,6) (5,6) 
		    (4,3) (5,6) (6,5) 
		    (4,3) (6,5) (5,6) 
		    (4,3) (6,5) (6,5) 
		    (5,6) (3,4) (5,6) 
		    (5,6) (3,4) (6,5) 
		    (5,6) (4,3) (3,4) 
		    (5,6) (4,3) (4,3) 
		    (5,6) (4,3) (5,6) 
		    (5,6) (4,3) (6,5) 
		    (5,6) (5,6) (5,6) 
		    (5,6) (5,6) (6,5) 
		    (5,6) (6,5) (5,6) 
		    (5,6) (6,5) (6,5) 
		    (6,5) (6,5) (5,6) 
		    (6,5) (6,5) (6,5)
		  
		*/
		// Test B
		task.pairDifferences1s(n);
	}
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,5)
// Swift 4 program for
// Print all combinations of n natural number
// whose pair element difference is one
class Combination
{
	func subSequences(_ result: inout[Int], 
  	_ start: Int, 
    _ count: Int, 
      _ n: Int)
	{
		if (count == n)
		{
			var i: Int = 0;
			// Display resultant sequence
			while (i < n - 1)
			{
				print("(", result[i] ,",",
                      result[i + 1] ,") ", 
                      terminator: "");
				i += 2;
			}
			print(terminator: "\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			var i: Int = start;
			while (i < n)
			{
				// Set pair element
				result[count] = i + 1;
				result[count + 1] = i + 2;
				self.subSequences(&result, start + 2, count + 2, n);
				result[count] = i + 2;
				result[count + 1] = i + 1;
				self.subSequences(&result, i, count + 2, n);
				i += 2;
			}
		}
	}
	func pairDifferences1s(_ n: Int)
	{
		if (n % 2  != 0)
		{
			print("\n Given n : ", n ," is not even ");
		}
		if (n <= 0)
		{
			return;
		}
		print(" Given : ", n ," ");
		// Auxiliary array which is collect result
		var result: [Int] = Array(repeating: 0, count: n);
		self.subSequences(&result, 0, 0, n);
	}
}
func main()
{
	let task: Combination = Combination();
	//  Length and natural number 1..n
	var n: Int = 4;
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	task.pairDifferences1s(n);
	n = 6;
	/*
	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	task.pairDifferences1s(n);
}
main();

Output

 Given :  4
( 1 , 2 ) ( 3 , 4 )
( 1 , 2 ) ( 4 , 3 )
( 2 , 1 ) ( 1 , 2 )
( 2 , 1 ) ( 2 , 1 )
( 2 , 1 ) ( 3 , 4 )
( 2 , 1 ) ( 4 , 3 )
( 3 , 4 ) ( 3 , 4 )
( 3 , 4 ) ( 4 , 3 )
( 4 , 3 ) ( 3 , 4 )
( 4 , 3 ) ( 4 , 3 )
 Given :  6
( 1 , 2 ) ( 3 , 4 ) ( 5 , 6 )
( 1 , 2 ) ( 3 , 4 ) ( 6 , 5 )
( 1 , 2 ) ( 4 , 3 ) ( 3 , 4 )
( 1 , 2 ) ( 4 , 3 ) ( 4 , 3 )
( 1 , 2 ) ( 4 , 3 ) ( 5 , 6 )
( 1 , 2 ) ( 4 , 3 ) ( 6 , 5 )
( 1 , 2 ) ( 5 , 6 ) ( 5 , 6 )
( 1 , 2 ) ( 5 , 6 ) ( 6 , 5 )
( 1 , 2 ) ( 6 , 5 ) ( 5 , 6 )
( 1 , 2 ) ( 6 , 5 ) ( 6 , 5 )
( 2 , 1 ) ( 1 , 2 ) ( 3 , 4 )
( 2 , 1 ) ( 1 , 2 ) ( 4 , 3 )
( 2 , 1 ) ( 1 , 2 ) ( 5 , 6 )
( 2 , 1 ) ( 1 , 2 ) ( 6 , 5 )
( 2 , 1 ) ( 2 , 1 ) ( 1 , 2 )
( 2 , 1 ) ( 2 , 1 ) ( 2 , 1 )
( 2 , 1 ) ( 2 , 1 ) ( 3 , 4 )
( 2 , 1 ) ( 2 , 1 ) ( 4 , 3 )
( 2 , 1 ) ( 2 , 1 ) ( 5 , 6 )
( 2 , 1 ) ( 2 , 1 ) ( 6 , 5 )
( 2 , 1 ) ( 3 , 4 ) ( 3 , 4 )
( 2 , 1 ) ( 3 , 4 ) ( 4 , 3 )
( 2 , 1 ) ( 3 , 4 ) ( 5 , 6 )
( 2 , 1 ) ( 3 , 4 ) ( 6 , 5 )
( 2 , 1 ) ( 4 , 3 ) ( 3 , 4 )
( 2 , 1 ) ( 4 , 3 ) ( 4 , 3 )
( 2 , 1 ) ( 4 , 3 ) ( 5 , 6 )
( 2 , 1 ) ( 4 , 3 ) ( 6 , 5 )
( 2 , 1 ) ( 5 , 6 ) ( 3 , 4 )
( 2 , 1 ) ( 5 , 6 ) ( 4 , 3 )
( 2 , 1 ) ( 5 , 6 ) ( 5 , 6 )
( 2 , 1 ) ( 5 , 6 ) ( 6 , 5 )
( 2 , 1 ) ( 6 , 5 ) ( 5 , 6 )
( 2 , 1 ) ( 6 , 5 ) ( 6 , 5 )
( 3 , 4 ) ( 3 , 4 ) ( 5 , 6 )
( 3 , 4 ) ( 3 , 4 ) ( 6 , 5 )
( 3 , 4 ) ( 4 , 3 ) ( 3 , 4 )
( 3 , 4 ) ( 4 , 3 ) ( 4 , 3 )
( 3 , 4 ) ( 4 , 3 ) ( 5 , 6 )
( 3 , 4 ) ( 4 , 3 ) ( 6 , 5 )
( 3 , 4 ) ( 5 , 6 ) ( 5 , 6 )
( 3 , 4 ) ( 5 , 6 ) ( 6 , 5 )
( 3 , 4 ) ( 6 , 5 ) ( 5 , 6 )
( 3 , 4 ) ( 6 , 5 ) ( 6 , 5 )
( 4 , 3 ) ( 3 , 4 ) ( 5 , 6 )
( 4 , 3 ) ( 3 , 4 ) ( 6 , 5 )
( 4 , 3 ) ( 4 , 3 ) ( 3 , 4 )
( 4 , 3 ) ( 4 , 3 ) ( 4 , 3 )
( 4 , 3 ) ( 4 , 3 ) ( 5 , 6 )
( 4 , 3 ) ( 4 , 3 ) ( 6 , 5 )
( 4 , 3 ) ( 5 , 6 ) ( 5 , 6 )
( 4 , 3 ) ( 5 , 6 ) ( 6 , 5 )
( 4 , 3 ) ( 6 , 5 ) ( 5 , 6 )
( 4 , 3 ) ( 6 , 5 ) ( 6 , 5 )
( 5 , 6 ) ( 3 , 4 ) ( 5 , 6 )
( 5 , 6 ) ( 3 , 4 ) ( 6 , 5 )
( 5 , 6 ) ( 4 , 3 ) ( 3 , 4 )
( 5 , 6 ) ( 4 , 3 ) ( 4 , 3 )
( 5 , 6 ) ( 4 , 3 ) ( 5 , 6 )
( 5 , 6 ) ( 4 , 3 ) ( 6 , 5 )
( 5 , 6 ) ( 5 , 6 ) ( 5 , 6 )
( 5 , 6 ) ( 5 , 6 ) ( 6 , 5 )
( 5 , 6 ) ( 6 , 5 ) ( 5 , 6 )
( 5 , 6 ) ( 6 , 5 ) ( 6 , 5 )
( 6 , 5 ) ( 6 , 5 ) ( 5 , 6 )
( 6 , 5 ) ( 6 , 5 ) ( 6 , 5 )
// Kotlin program for
// Print all combinations of n natural number
// whose pair element difference is one
class Combination
{
	fun subSequences(result: Array < Int > , 
                      start: Int, 
                      count: Int,
                      n: Int): Unit
	{
		if (count == n)
		{
			var i: Int = 0;
			// Display resultant sequence
			while (i < n - 1)
			{
				print("(" + result[i] + "," + 
                      result[i + 1] + ") ");
				i += 2;
			}
			print("\n");
		}
		else if (count > n)
		{
			return;
		}
		else
		{
			var i: Int = start;
			while (i < n)
			{
				// Set pair element
				result[count] = i + 1;
				result[count + 1] = i + 2;
				this.subSequences(result, start + 2, count + 2, n);
				result[count] = i + 2;
				result[count + 1] = i + 1;
				this.subSequences(result, i, count + 2, n);
				i += 2;
			}
		}
	}
	fun pairDifferences1s(n: Int): Unit
	{
		if (n % 2 != 0)
		{
			print("\n Given n : " + n + " is not even \n");
		}
		if (n <= 0)
		{
			return;
		}
		print(" Given : " + n + " \n");
		// Auxiliary array which is collect result
		val result: Array < Int > = Array(n)
		{
			0
		};
		this.subSequences(result, 0, 0, n);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Combination = Combination();
	//  Length and natural number 1..n
	var n: Int = 4;
	/*
	    n = 4
	    ----------
	    (1,2) (3,4) 
	    (1,2) (4,3) 
	    (2,1) (1,2) 
	    (2,1) (2,1) 
	    (2,1) (3,4) 
	    (2,1) (4,3) 
	    (3,4) (3,4) 
	    (3,4) (4,3) 
	    (4,3) (3,4) 
	    (4,3) (4,3)
	  
	*/
	// Test A
	task.pairDifferences1s(n);
	n = 6;
	/*
	    n = 6
	    pair n/2 = 3 pair in each result
	    ----------
	    (1,2) (3,4) (5,6) 
	    (1,2) (3,4) (6,5) 
	    (1,2) (4,3) (3,4) 
	    (1,2) (4,3) (4,3) 
	    (1,2) (4,3) (5,6) 
	    (1,2) (4,3) (6,5) 
	    (1,2) (5,6) (5,6) 
	    (1,2) (5,6) (6,5) 
	    (1,2) (6,5) (5,6) 
	    (1,2) (6,5) (6,5) 
	    (2,1) (1,2) (3,4) 
	    (2,1) (1,2) (4,3) 
	    (2,1) (1,2) (5,6) 
	    (2,1) (1,2) (6,5) 
	    (2,1) (2,1) (1,2) 
	    (2,1) (2,1) (2,1) 
	    (2,1) (2,1) (3,4) 
	    (2,1) (2,1) (4,3) 
	    (2,1) (2,1) (5,6) 
	    (2,1) (2,1) (6,5) 
	    (2,1) (3,4) (3,4) 
	    (2,1) (3,4) (4,3) 
	    (2,1) (3,4) (5,6) 
	    (2,1) (3,4) (6,5) 
	    (2,1) (4,3) (3,4) 
	    (2,1) (4,3) (4,3) 
	    (2,1) (4,3) (5,6) 
	    (2,1) (4,3) (6,5) 
	    (2,1) (5,6) (3,4) 
	    (2,1) (5,6) (4,3) 
	    (2,1) (5,6) (5,6) 
	    (2,1) (5,6) (6,5) 
	    (2,1) (6,5) (5,6) 
	    (2,1) (6,5) (6,5) 
	    (3,4) (3,4) (5,6) 
	    (3,4) (3,4) (6,5) 
	    (3,4) (4,3) (3,4) 
	    (3,4) (4,3) (4,3) 
	    (3,4) (4,3) (5,6) 
	    (3,4) (4,3) (6,5) 
	    (3,4) (5,6) (5,6) 
	    (3,4) (5,6) (6,5) 
	    (3,4) (6,5) (5,6) 
	    (3,4) (6,5) (6,5) 
	    (4,3) (3,4) (5,6) 
	    (4,3) (3,4) (6,5) 
	    (4,3) (4,3) (3,4) 
	    (4,3) (4,3) (4,3) 
	    (4,3) (4,3) (5,6) 
	    (4,3) (4,3) (6,5) 
	    (4,3) (5,6) (5,6) 
	    (4,3) (5,6) (6,5) 
	    (4,3) (6,5) (5,6) 
	    (4,3) (6,5) (6,5) 
	    (5,6) (3,4) (5,6) 
	    (5,6) (3,4) (6,5) 
	    (5,6) (4,3) (3,4) 
	    (5,6) (4,3) (4,3) 
	    (5,6) (4,3) (5,6) 
	    (5,6) (4,3) (6,5) 
	    (5,6) (5,6) (5,6) 
	    (5,6) (5,6) (6,5) 
	    (5,6) (6,5) (5,6) 
	    (5,6) (6,5) (6,5) 
	    (6,5) (6,5) (5,6) 
	    (6,5) (6,5) (6,5)
	  
	*/
	// Test B
	task.pairDifferences1s(n);
}

Output

 Given : 4
(1,2) (3,4)
(1,2) (4,3)
(2,1) (1,2)
(2,1) (2,1)
(2,1) (3,4)
(2,1) (4,3)
(3,4) (3,4)
(3,4) (4,3)
(4,3) (3,4)
(4,3) (4,3)
 Given : 6
(1,2) (3,4) (5,6)
(1,2) (3,4) (6,5)
(1,2) (4,3) (3,4)
(1,2) (4,3) (4,3)
(1,2) (4,3) (5,6)
(1,2) (4,3) (6,5)
(1,2) (5,6) (5,6)
(1,2) (5,6) (6,5)
(1,2) (6,5) (5,6)
(1,2) (6,5) (6,5)
(2,1) (1,2) (3,4)
(2,1) (1,2) (4,3)
(2,1) (1,2) (5,6)
(2,1) (1,2) (6,5)
(2,1) (2,1) (1,2)
(2,1) (2,1) (2,1)
(2,1) (2,1) (3,4)
(2,1) (2,1) (4,3)
(2,1) (2,1) (5,6)
(2,1) (2,1) (6,5)
(2,1) (3,4) (3,4)
(2,1) (3,4) (4,3)
(2,1) (3,4) (5,6)
(2,1) (3,4) (6,5)
(2,1) (4,3) (3,4)
(2,1) (4,3) (4,3)
(2,1) (4,3) (5,6)
(2,1) (4,3) (6,5)
(2,1) (5,6) (3,4)
(2,1) (5,6) (4,3)
(2,1) (5,6) (5,6)
(2,1) (5,6) (6,5)
(2,1) (6,5) (5,6)
(2,1) (6,5) (6,5)
(3,4) (3,4) (5,6)
(3,4) (3,4) (6,5)
(3,4) (4,3) (3,4)
(3,4) (4,3) (4,3)
(3,4) (4,3) (5,6)
(3,4) (4,3) (6,5)
(3,4) (5,6) (5,6)
(3,4) (5,6) (6,5)
(3,4) (6,5) (5,6)
(3,4) (6,5) (6,5)
(4,3) (3,4) (5,6)
(4,3) (3,4) (6,5)
(4,3) (4,3) (3,4)
(4,3) (4,3) (4,3)
(4,3) (4,3) (5,6)
(4,3) (4,3) (6,5)
(4,3) (5,6) (5,6)
(4,3) (5,6) (6,5)
(4,3) (6,5) (5,6)
(4,3) (6,5) (6,5)
(5,6) (3,4) (5,6)
(5,6) (3,4) (6,5)
(5,6) (4,3) (3,4)
(5,6) (4,3) (4,3)
(5,6) (4,3) (5,6)
(5,6) (4,3) (6,5)
(5,6) (5,6) (5,6)
(5,6) (5,6) (6,5)
(5,6) (6,5) (5,6)
(5,6) (6,5) (6,5)
(6,5) (6,5) (5,6)
(6,5) (6,5) (6,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







© 2021, kalkicode.com, All rights reserved