# Generate permutation of 1 to N such that absolute difference of consecutive numbers give K distinct integers

Given two integers N and K where K < N, the task is to generate a permutation of integers from 1 to N such that the absolute difference of all the consecutive integers give exactly K distinct integers.

Examples:

Input: N = 3, K = 2
Output: 1 3 2
|1 – 3| = 2 and |3 – 2| = 1 which gives 2 distinct integers (2 and 1)

Input: N = 5, K = 4
Output: 1 5 2 4 3
|1 – 5| = 4, |5 – 2| = 3, |2 – 4| = 2 and |4 – 3| = 1 gives 4 distinct integers i.e. 4, 3, 2 and 1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The problem can be easily solved by simple observation. At the odd indices place increasing sequence 1, 2, 3, … and at the even indices place the decreasing sequence N, N-1, N-2, … and so on.

For N = 10, a permutation with distinct integers for consecutive absolute difference can be 1 10 2 9 3 8 4 7 5 6. The consecutive absolute difference gives integers 9, 8, 7 and so on.
So, first print K integers of such a sequence then make the rest of the differences equal to 1. The code is quite self explanatory.

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to generate a permutation of integers ` `// from 1 to N such that the absolute difference of ` `// all the two consecutive integers give K distinct integers ` `void` `printPermutation(``int` `N, ``int` `K) ` `{ ` `    ``// To store the permutation ` `    ``vector<``int``> res; ` ` `  `    ``int` `l = 1, r = N, flag = 0; ` ` `  `    ``for` `(``int` `i = 0; i < K; i++) { ` ` `  `        ``if` `(!flag) { ` ` `  `            ``// For sequence 1 2 3... ` `            ``res.push_back(l); ` `            ``l++; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// For sequence N, N-1, N-2... ` `            ``res.push_back(r); ` `            ``r--; ` `        ``} ` ` `  `        ``// Flag is used to alternate between ` `        ``// the above if else statements ` `        ``flag ^= 1; ` `    ``} ` ` `  `    ``// Taking integers with difference 1 ` ` `  `    ``// If last element added was r + 1 ` `    ``if` `(!flag) { ` `        ``for` `(``int` `i = r; i >= l; i--) ` `            ``res.push_back(i); ` `    ``} ` ` `  `    ``// If last element added was l - 1 ` `    ``else` `{ ` `        ``for` `(``int` `i = l; i <= r; i++) ` `            ``res.push_back(i); ` `    ``} ` ` `  `    ``// Print the permutation ` `    ``for` `(``auto` `i : res) ` `        ``cout << i << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 10, K = 4; ` ` `  `    ``printPermutation(N, K); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of the above approach ` `import` `java.util.Vector; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to generate a permutation  ` `    ``// of integers from 1 to N such that the  ` `    ``// absolute difference of all the two  ` `    ``// consecutive integers give K distinct integers ` `    ``static` `void` `printPermutation(``int` `N, ``int` `K)  ` `    ``{ ` `        ``// To store the permutation ` `        ``Vector res = ``new` `Vector<>(); ` ` `  `        ``int` `l = ``1``, r = N, flag = ``0``; ` ` `  `        ``for` `(``int` `i = ``0``; i < K; i++) ` `        ``{ ` `            ``if` `(flag == ``0``)  ` `            ``{ ` `                ``// For sequence 1 2 3... ` `                ``res.add(l); ` `                ``l++; ` `            ``}  ` `            ``else`  `            ``{ ` `                ``// For sequence N, N-1, N-2... ` `                ``res.add(r); ` `                ``r--; ` `            ``} ` ` `  `            ``// Flag is used to alternate between ` `            ``// the above if else statements ` `            ``flag ^= ``1``; ` `        ``} ` ` `  `        ``// Taking integers with difference 1 ` `        ``// If last element added was r + 1 ` `        ``if` `(flag != ``1``)  ` `        ``{ ` `            ``for` `(``int` `i = r; i >= l; i--)  ` `            ``{ ` `                ``res.add(i); ` `            ``} ` `        ``}  ` `        ``// If last element added was l - 1 ` `        ``else`  `        ``{ ` `            ``for` `(``int` `i = l; i <= r; i++)  ` `            ``{ ` `                ``res.add(i); ` `            ``} ` `        ``} ` ` `  `        ``// Print the permutation ` `        ``for` `(Integer i : res)  ` `        ``{ ` `            ``System.out.print(i + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `N = ``10``, K = ``4``; ` `        ``printPermutation(N, K); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by ` `// 29AjayKumar  `

 `# Python 3 implementation of the approach ` ` `  `# Function to generate a permutation  ` `# of integers from 1 to N such that the  ` `# absolute difference of all the two  ` `# consecutive integers give K distinct ` `# integers ` `def` `printPermutation(N, K): ` ` `  `    ``# To store the permutation ` `    ``res ``=` `list``(); ` ` `  `    ``l, r, flag ``=` `1``, N, ``0` ` `  `    ``for` `i ``in` `range``(K): ` ` `  `        ``if` `flag ``=``=` `False``: ` `             `  `            ``# For sequence 1 2 3... ` `            ``res.append(l) ` `            ``l ``+``=` `1` `     `  `        ``else``: ` `             `  `            ``# For sequence N, N-1, N-2... ` `            ``res.append(r); ` `            ``r ``-``=` `1``; ` ` `  `    ``# Flag is used to alternate between ` `    ``# the above if else statements ` `        ``flag ``=` `flag ^ ``1``; ` ` `  `    ``# Taking integers with difference 1 ` ` `  `    ``# If last element added was r + 1 ` `    ``if` `flag ``=``=` `False``: ` `        ``for` `i ``in` `range``(r, ``2``, ``-``1``): ` `            ``res.append(i) ` ` `  `    ``# If last element added was l - 1 ` `    ``else``: ` `        ``for` `i ``in` `range``(l, r): ` `            ``res.append(i) ` ` `  `    ``# Print the permutation ` `    ``for` `i ``in` `res: ` `        ``print``(i, end ``=` `" "``) ` ` `  `# Driver code ` `N, K ``=` `10``, ``4` `printPermutation(N, K) ` ` `  `# This code is contributed by ` `# Mohit Kumar 29 `

 `// C# implementation of the above approach ` `using` `System; ` `using` `System.Collections; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to generate a permutation  ` `    ``// of integers from 1 to N such that the  ` `    ``// absolute difference of all the two  ` `    ``// consecutive integers give K distinct integers ` `    ``static` `void` `printPermutation(``int` `N, ``int` `K)  ` `    ``{ ` `         `  `        ``// To store the permutation ` `        ``ArrayList res = ``new` `ArrayList(); ` ` `  `        ``int` `l = 1, r = N, flag = 0; ` `        ``for` `(``int` `i = 0; i < K; i++) ` `        ``{ ` `            ``if` `(flag == 0)  ` `            ``{ ` `                ``// For sequence 1 2 3... ` `                ``res.Add(l); ` `                ``l++; ` `            ``}  ` `            ``else` `            ``{ ` `                ``// For sequence N, N-1, N-2... ` `                ``res.Add(r); ` `                ``r--; ` `            ``} ` ` `  `            ``// Flag is used to alternate between ` `            ``// the above if else statements ` `            ``flag ^= 1; ` `        ``} ` ` `  `        ``// Taking integers with difference 1 ` `        ``// If last element added was r + 1 ` `        ``if` `(flag != 1)  ` `        ``{ ` `            ``for` `(``int` `i = r; i >= l; i--)  ` `            ``{ ` `                ``res.Add(i); ` `            ``} ` `        ``}  ` `         `  `        ``// If last element added was l - 1 ` `        ``else` `        ``{ ` `            ``for` `(``int` `i = l; i <= r; i++)  ` `            ``{ ` `                ``res.Add(i); ` `            ``} ` `        ``} ` ` `  `        ``// Print the permutation ` `        ``foreach` `(``int` `i ``in` `res)  ` `        ``{ ` `            ``Console.Write(i + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `N = 10, K = 4; ` `        ``printPermutation(N, K);         ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

 `= ``\$l``; ``\$i``--)  ` `            ``array_push``(``\$res``, ``\$i``);  ` `    ``}  ` ` `  `    ``// If last element added was l - 1  ` `    ``else`  `    ``{  ` `        ``for` `(``\$i` `= l; ``\$i` `<= ``\$r``; ``\$i``++)  ` `            ``array_push``(``\$res``, ``\$i``);  ` `    ``}  ` ` `  `    ``// Print the permutation  ` `    ``for``(``\$i` `= 0; ``\$i` `< sizeof(``\$res``); ``\$i``++) ` `        ``echo` `\$res``[``\$i``], ``" "``; ` `}  ` ` `  `// Driver code  ` `\$N` `= 10; ` `\$K` `= 4;  ` ` `  `printPermutation(``\$N``, ``\$K``);  ` ` `  `// This code is contributed by Ryuga ` `?> `

Output:
```1 10 2 9 8 7 6 5 4 3
```

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Practice Tags :