# Generate a permutation of first N natural numbers having count of unique adjacent differences equal to K | Set 2

• Last Updated : 24 Feb, 2022

Given two positive integers N and K, the task is to construct a permutation of the first N natural numbers such that all possible absolute differences between adjacent elements are K.

Examples:

Input: N = 3, K = 1
Output: 1 2 3
Explanation: Considering the permutation {1, 2, 3}, all possible unique absolute difference of adjacent elements is {1}. Since the count is 1(= K), print the sequence {1, 2, 3} as the resultant permutation.

Input: N = 3, K = 2
Output: 1 3 2

The naive approach and the two-pointer approach of this problem are already discussed here. This article discusses a different approach deque.

Approach: It is easy to see that, answers for all values of K between [1, N-1] can be generated. For any K outside this range, there exists no answer. To solve the problem maintain a double-ended queue for all the current elements and a vector to store the sequence. Also, maintain a boolean value that will help to determine to pop the front or back element. Iterate the remaining element and if K is greater than 1 then push the element according to the boolean value and decrease K by 1. Flip the boolean value so that all remaining differences will have value 1. Follow the steps below to solve the problem:

Below is the implementation of the above approach.

## C++

 `// C++ Program for the above approach``#include ``using` `namespace` `std;` `// Function to calculate the required array``void` `K_ValuesArray(``int` `N, ``int` `K)``{` `    ``// Check for base cases``    ``if` `(K < 1 || K >= N) {``        ``cout << -1;``        ``return``;``    ``}` `    ``// Maintain a deque to store the``    ``// elements from [1, N];``    ``deque<``int``> dq;``    ``for` `(``int` `i = 2; i <= N; i++) {``        ``dq.push_back(i);``    ``}` `    ``// Maintain a boolean value which will``    ``// tell from where to pop the element``    ``bool` `front = ``true``;` `    ``// Create a vector to store the answer``    ``vector<``int``> ans;` `    ``// Push 1 in the answer initially``    ``ans.push_back(1);` `    ``// Push the remaining elements``    ``if` `(K > 1) {``        ``front ^= 1;``        ``K--;``    ``}` `    ``// Iterate over the range``    ``for` `(``int` `i = 2; i <= N; i++) {``        ``if` `(front) {``            ``int` `val = dq.front();``            ``dq.pop_front();` `            ``// Push this value in``            ``// the ans vector``            ``ans.push_back(val);``            ``if` `(K > 1) {``                ``K--;` `                ``// Flip the boolean``                ``// value``                ``front ^= 1;``            ``}``        ``}``        ``else` `{``            ``int` `val = dq.back();``            ``dq.pop_back();` `            ``// Push value in ans vector``            ``ans.push_back(val);``            ``if` `(K > 1) {``                ``K--;` `                ``// Flip boolean value``                ``front ^= 1;``            ``}``        ``}``    ``}` `    ``// Print Answer``    ``for` `(``int` `i = 0; i < N; i++) {``        ``cout << ans[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 7, K = 1;``    ``K_ValuesArray(N, K);` `    ``return` `0;``}`

## Java

 `// Java Program for the above approach``import` `java.util.*;``class` `GFG{` `// Function to calculate the required array``static` `void` `K_ValuesArray(``int` `N, ``int` `K)``{` `    ``// Check for base cases``    ``if` `(K < ``1` `|| K >= N) {``        ``System.out.print(-``1``);``        ``return``;``    ``}` `    ``// Maintain a deque to store the``    ``// elements from [1, N];``    ``Deque dq = ``new` `LinkedList();``    ``for` `(``int` `i = ``2``; i <= N; i++) {``        ``dq.add(i);``    ``}` `    ``// Maintain a boolean value which will``    ``// tell from where to pop the element``    ``boolean` `front = ``true``;` `    ``// Create a vector to store the answer``    ``Vector ans = ``new` `Vector();` `    ``// Push 1 in the answer initially``    ``ans.add(``1``);` `    ``// Push the remaining elements``    ``if` `(K > ``1``) {``        ``front ^=``true``;``        ``K--;``    ``}` `    ``// Iterate over the range``    ``for` `(``int` `i = ``2``; i <= N; i++) {``        ``if` `(front) {``            ``int` `val = dq.peek();``            ``dq.removeFirst();` `            ``// Push this value in``            ``// the ans vector``            ``ans.add(val);``            ``if` `(K > ``1``) {``                ``K--;` `                ``// Flip the boolean``                ``// value``                ``front ^=``true``;``            ``}``        ``}``        ``else` `{``            ``int` `val = dq.getLast();``            ``dq.removeLast();` `            ``// Push value in ans vector``            ``ans.add(val);``            ``if` `(K > ``1``) {``                ``K--;` `                ``// Flip boolean value``                ``front ^=``true``;``            ``}``        ``}``    ``}` `    ``// Print Answer``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``System.out.print(ans.get(i)+ ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``7``, K = ``1``;``    ``K_ValuesArray(N, K);` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# python Program for the above approach``from` `collections ``import` `deque` `# Function to calculate the required array``def` `K_ValuesArray(N, K):` `    ``# Check for base cases``    ``if` `(K < ``1` `or` `K >``=` `N):``        ``print``(``"-1"``)``        ``return` `    ``# Maintain a deque to store the``    ``# elements from [1, N];``    ``dq ``=` `deque()``    ``for` `i ``in` `range``(``2``, N ``+` `1``):``        ``dq.append(i)` `    ``# Maintain a boolean value which will``    ``# tell from where to pop the element``    ``front ``=` `True` `    ``# Create a vector to store the answer``    ``ans ``=` `[]` `    ``# Push 1 in the answer initially``    ``ans.append(``1``)` `    ``# Push the remaining elements``    ``if` `(K > ``1``):``        ``front ^``=` `1``        ``K ``-``=` `1` `    ``# Iterate over the range``    ``for` `i ``in` `range``(``2``, N``+``1``):``        ``if` `(front):``            ``val ``=` `dq.popleft()` `            ``# Push this value in``            ``# the ans vector``            ``ans.append(val)``            ``if` `(K > ``1``):``                ``K ``-``=` `1` `                ``# Flip the boolean``                ``# value``                ``front ^``=` `1` `        ``else``:``            ``val ``=` `dq.pop()` `            ``# Push value in ans vector``            ``ans.append(val)``            ``if` `(K > ``1``):``                ``K ``-``=` `1` `                ``# Flip boolean value``                ``front ^``=` `1` `    ``# Print Answer``    ``for` `i ``in` `range``(``0``, N):``        ``print``(ans[i], end``=``" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `7``    ``K ``=` `1``    ``K_ValuesArray(N, K)` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# Program for the above approach` `using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `    ``// Function to calculate the required array``    ``static` `void` `K_ValuesArray(``int` `N, ``int` `K)``    ``{` `        ``// Check for base cases``        ``if` `(K < 1 || K >= N)``        ``{``            ``Console.Write(-1);``            ``return``;``        ``}` `        ``// Maintain a deque to store the``        ``// elements from [1, N];``        ``LinkedList<``int``> dq = ``new` `LinkedList<``int``>();``        ``for` `(``int` `i = 2; i <= N; i++)``        ``{``            ``dq.AddLast(i);``        ``}` `        ``// Maintain a boolean value which will``        ``// tell from where to pop the element``        ``bool` `front = ``true``;` `        ``// Create a vector to store the answer``        ``List<``int``> ans = ``new` `List<``int``>();` `        ``// Push 1 in the answer initially``        ``ans.Add(1);` `        ``// Push the remaining elements``        ``if` `(K > 1)``        ``{``            ``front ^= ``true``;``            ``K--;``        ``}` `        ``// Iterate over the range``        ``for` `(``int` `i = 2; i <= N; i++)``        ``{``            ``if` `(front)``            ``{``                ``int` `val = dq.First.Value;``                ``dq.RemoveFirst();` `                ``// Push this value in``                ``// the ans vector``                ``ans.Add(val);``                ``if` `(K > 1)``                ``{``                    ``K--;` `                    ``// Flip the boolean``                    ``// value``                    ``front ^= ``true``;``                ``}``            ``}``            ``else``            ``{``                ``int` `val = dq.Last.Value;``                ``dq.RemoveLast();` `                ``// Push value in ans vector``                ``ans.Add(val);``                ``if` `(K > 1)``                ``{``                    ``K--;` `                    ``// Flip boolean value``                    ``front ^= ``true``;``                ``}``            ``}``        ``}` `        ``// Print Answer``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``Console.Write(ans[i] + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 7, K = 1;``        ``K_ValuesArray(N, K);` `    ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`1 2 3 4 5 6 7 `

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up