# 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++

 `// 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

 `// 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  `

## Python3

 `# 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#

 `// 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 `

## PHP

 `= ``\$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
``` My Personal Notes arrow_drop_up 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.