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

• Difficulty Level : Medium
• Last Updated : 08 Jul, 2022

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

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

## Javascript

 ``

Output:

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

Time Complexity : O(K+N)

Space Complexity : O(N)

My Personal Notes arrow_drop_up