重新排列前N个数字，使其距离为K

给定正数K，我们需要以这样的方式置换前N个自然数，即每个置换数与其原始位置的绝对距离为K，如果无法以这种方式重新排列它们，则无法打印。
例子 ：

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]

我们可以通过在解决方案中找到模式来解决此问题。如果我们手动处理许多解决方案，我们可以看到，如果将N个数字划分为大小为2K的插槽，则每个插槽可以重新排列为大小为K的两个部分，位置与实际位置的差为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

在下面的代码中，通过按实际顺序打印所有数字来分别处理K = 0的情况。当N无法被2K整除时，将直接打印“不可能”。

C++

// C++ program to rearrange permuatations to make
// them K distance away
#include 
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 permuatations
// 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
# permuatations 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 prnumbers
    # 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 permuatations
// 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

 
// 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);
 

输出 ：

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