Open In App

Rearrange first N numbers to make them at K distance

Improve
Improve
Like Article
Like
Save
Share
Report

Given a positive number K, we need to permute first N natural numbers in such a way that the absolute distance of each permuted number from its original position is K and if it is not possible to rearrange them in such a manner then print not possible. 
Examples : 

Input  :  N = 12   
          K = 2
Output : [3 4 1 2 7 8 5 6 11 12 9 10]
Explanation : Initial permutation is
[1 2 3 4 5 6 7 8 9 10 11 12]
In rearrangement, [3 4 1 2 7 8 5 6 11
12 9 10] we have all elements at
distance 2. 

Input  :  N = 12   
          K = 3
Output : [4 5 6 1 2 3 10 11 12 7 8 9]

We can solve this problem by finding the pattern in solutions. If we go through many solutions manually, we can see that if we partition N numbers into slots of size 2K, then each slot can be rearranged in two parts of size K, where the difference of position with the actual position will be K.

Example 1 : N = 12 and K = 2

First 12 numbers are partitioned into 
2*2 = 4 sized 12/4 = 3 slots as shown below,
[[1 2 3 4] [5 6 7 8] [9 10 11 12]]

Now each half of the slot is swapped so that, 
every number will go at K position distance 
from its initial position as shown below,
[[3 4 1 2] [7 8 5 6] [11 12 9 10]]

Example 2 :  N = 12 and K = 3,
[1 2 3 4 5 6 7 8 9 10 11 12]
[[1 2 3 4 5 6] [7 8 9 10 11 12]]
[[4 5 6 1 2 3] [10 11 12 7 8 9]]
[4 5 6 1 2 3 10 11 12 7 8 9]
Which is the final rearrangement for 
N = 12 and K = 3

In the below code, the case when K = 0 is handled separately by printing all numbers in their actual order. When N is not divisible by 2K, ‘not possible’ is printed directly.  

C++




// C++ program to rearrange permutations to make
// them K distance away
#include <bits/stdc++.h>
using namespace std;
 
/* Method prints permutation of first N numbers,
where each number is K distance away from its
actual position */
void printRearrangeNnumberForKDistance(int N, int K)
{
    // If K = 0, then print numbers in their natural
    // order
    if (K == 0)
    {
        for (int i = 1; i <= N; i++)
            cout << i << " ";
        cout << endl;
        return;
    }
 
    // If N doesn't divide (2K) evenly, then
    // rearrangement is not possible
    if (N % (2 * K) != 0)
    {
        cout << "Not Possible\n";
        return;
    }
 
    // Copy first N numbers to an auxiliary
    // array
    int arr[N + 1];
    for (int i = 1; i <= N; i++)
        arr[i] = i;
 
    // Swap halves of each 2K sized slot
    for (int i = 1; i <= N; i += 2 * K)
        for (int j = 1; j <= K; j++)
            swap(arr[i + j - 1], arr[K + i + j - 1]);
 
    // Print the rearranged array
    for (int i = 1; i <= N; i++)
        cout << arr[i] << " ";
}
 
// Driver code
int main()
{
    int N = 12, K = 3;
    printRearrangeNnumberForKDistance(N, K);
    return 0;
}


Java




// Java program to rearrange permutations
// to make them K distance away
 
class GFG
{
    /* Method prints permutation of first N numbers,
    where each number is K distance away from its
    actual position */
    static void printRearrangeNnumberForKDistance(int N, int K)
    {
        // If K = 0, then print numbers
        // in their natural order
        if (K == 0)
        {
            for (int i = 1; i <= N; i++)
                System.out.print(i + " ");
            System.out.println();
            return;
        }
     
        // If N doesn't divide (2K) evenly, then
        // rearrangement is not possible
        if (N % (2 * K) != 0)
        {
            System.out.print("Not Possible\n");
            return;
        }
     
        // Copy first N numbers to an auxiliary
        // array
        int arr[]=new int[N + 1];
        for (int i = 1; i <= N; i++)
            arr[i] = i;
     
        // Swap halves of each 2K sized slot
        for (int i = 1; i <= N; i += 2 * K)
            for (int j = 1; j <= K; j++)
            {
                int temp = arr[i + j - 1];
                arr[i + j - 1] = arr[K + i + j - 1];
                arr[K + i + j - 1] = temp;
            }
     
        // Print the rearranged array
        for (int i = 1; i <= N; i++)
            System.out.print(arr[i] + " ");
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int N = 12, K = 3;
        printRearrangeNnumberForKDistance(N, K);
    }
}
 
// This code is contributed by Anant Agarwal.


Python3




# Python3 program to rearrange
# permutations to make them
# K distance away
 
'''
 * Method prints permutation of
 first N numbers, where each number
 is K distance * away from its actual
 position
 '''
def printRearrangeNnumberForKDistance(N, K):
   
    # If K = 0, then print numbers
    # in their natural order
    if (K == 0):
        for i in range(1, N + 1):
            print(i, end = " ");
        print();
        return;
 
    # If N doesn't divide (2K) evenly,
    # then rearrangement is not possible
    if (N % (2 * K) != 0):
        print("Not Possible");
        return;
 
    # Copy first N numbers to an
    # auxiliary array
    arr = [0] * (N + 1);
 
    for i in range(1, N + 1):
        arr[i] = i;
 
    # Swap halves of each 2K
    # sized slot
    for i in range(1, N + 1,
                   2 * K):
        for j in range(1, K + 1):
            temp = arr[i + j - 1];
            arr[i + j - 1] = arr[K + i + j - 1];
            arr[K + i + j - 1] = temp;
 
    # Print rearranged array
    for i in range(1, N + 1):
        print(arr[i], end = " ");
 
# Driver code
if __name__ == '__main__':
   
    N = 12;
    K = 3;
    printRearrangeNnumberForKDistance(N, K);
 
# This code is contributed by 29AjayKumar


C#




// C# program to rearrange permutations
// to make them K distance away
using System;
 
class GFG
{
    /* Method prints permutation of first N numbers,
    where each number is K distance away from its
    actual position */
    static void printRearrangeNnumberForKDistance(int N, int K)
    {
        // If K = 0, then print numbers
        // in their natural order
        if (K == 0)
        {
            for (int i = 1; i <= N; i++)
            Console.Write(i + " ");
            Console.WriteLine();
            return;
        }
     
        // If N doesn't divide (2K) evenly, then
        // rearrangement is not possible
        if (N % (2 * K) != 0)
        {
            Console.Write("Not Possible\n");
            return;
        }
     
        // Copy first N numbers to an auxiliary
        // array
        int []arr=new int[N + 1];
        for (int i = 1; i <= N; i++)
            arr[i] = i;
     
        // Swap halves of each 2K sized slot
        for (int i = 1; i <= N; i += 2 * K)
            for (int j = 1; j <= K; j++)
            {
                int temp = arr[i + j - 1];
                arr[i + j - 1] = arr[K + i + j - 1];
                arr[K + i + j - 1] = temp;
            }
     
        // Print the rearranged array
        for (int i = 1; i <= N; i++)
            Console.Write(arr[i] + " ");
    }
     
    // Driver code
    public static void Main ()
    {
        int N = 12, K = 3;
        printRearrangeNnumberForKDistance(N, K);
    }
}
 
// This code is contributed by nitin mittal.


Javascript




<script>
 
// JavaScript program for the above approach
 
    /* Method prints permutation of first N numbers,
    where each number is K distance away from its
    actual position */
    function printRearrangeNnumberForKDistance(N, K)
    {
        // If K = 0, then print numbers
        // in their natural order
        if (K == 0)
        {
            for (let i = 1; i <= N; i++)
                document.write(i + " ");
            document.write("<br/>");
            return;
        }
     
        // If N doesn't divide (2K) evenly, then
        // rearrangement is not possible
        if (N % (2 * K) != 0)
        {
            document.write("Not Possible\n");
            return;
        }
     
        // Copy first N numbers to an auxiliary
        // array
        let arr = [];
        for (let i = 1; i <= N; i++)
            arr[i] = i;
     
        // Swap halves of each 2K sized slot
        for (let i = 1; i <= N; i += 2 * K)
            for (let j = 1; j <= K; j++)
            {
                let temp = arr[i + j - 1];
                arr[i + j - 1] = arr[K + i + j - 1];
                arr[K + i + j - 1] = temp;
            }
     
        // Print the rearranged array
        for (let i = 1; i <= N; i++)
            document.write(arr[i] + " ");
    }
     
 
// Driver Code
    let N = 12, K = 3;
    printRearrangeNnumberForKDistance(N, K);
 
</script>


Output : 

4 5 6 1 2 3 10 11 12 7 8 9



Last Updated : 28 Jan, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads