Related Articles

# Lexicographically Smallest Permutation of length N such that for exactly K indices, a[i] > a[i] + 1

• Difficulty Level : Basic
• Last Updated : 14 May, 2021

Given two integers N and K, the task is to generate a permutation of N numbers (Every number from 1 to N occurs exactly once) such that the number of indices where a[i]>a[i+1] is exactly K. Print “Not possible” if no such permutation is possible.
Examples:

```Input: N = 5, K = 3
Output: 5 4 3 1 2
Starting 3 indices satisfying the condition
a[i] > a[i]+1

Input: N = 7, k = 4
Output: 7 6 5 4 1 2 3```

Approach: Since the permutation should be lexicographically smallest with the condition satisfied for k indices i.e. a[i] > a[i+1]. So for that starting K+1 digits should be in decreasing order and remaining should be in increasing order. So just print the K numbers from N to 1. Then print numbers from 1 to N-K.

For example: N = 6, K = 4
Print K numbers from N to 1 i.e. 6, 5, 4, 3
Print N-K numbers from 1 to N-K i.e. 1, 2
Permutation will be 654312 i.e. Starting 4 indices satisfy a[i] > a[i+1] for i = 1 to k.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `void` `printPermutation(``int` `n, ``int` `k)``{``    ``int` `i, mx = n;``    ``for` `(i = 1; i <= k; i++) ``// Decreasing part``    ``{``        ``cout << mx << ``" "``;``        ``mx--;``    ``}``    ``for` `(i = 1; i <= mx; i++) ``// Increasing part``        ``cout << i << ``" "``;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5, K = 3;` `    ``if` `(K >= N - 1)``        ``cout << ``"Not Possible"``;` `    ``else``        ``printPermutation(N, K);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach` `import` `java.io.*;` `class` `GFG {`  `static` `void` `printPermutation(``int` `n, ``int` `k)``{``    ``int` `i, mx = n;``    ``for` `(i = ``1``; i <= k; i++) ``// Decreasing part``    ``{``        ``System.out.print( mx + ``" "``);``        ``mx--;``    ``}``    ``for` `(i = ``1``; i <= mx; i++) ``// Increasing part``        ``System.out.print( i + ``" "``);``}` `// Driver Code` `    ``public` `static` `void` `main (String[] args) {``            ``int` `N = ``5``, K = ``3``;` `    ``if` `(K >= N - ``1``)``        ``System.out.print( ``"Not Possible"``);` `    ``else``        ``printPermutation(N, K);``    ``}``}` `// This code is contributed by inder_verma..`

## Python3

 `# Python3 implementation of the``# above approach``def` `printPermutation(n, k):` `    ``mx ``=` `n``    ``for` `i ``in` `range``(``1``, k ``+` `1``): ``# Decreasing part``        ``print``(mx, end ``=` `" "``)``        ``mx ``-``=` `1``    ` `    ``for` `i ``in` `range``(``1``, mx ``+` `1``): ``# Increasing part``        ``print``(i, end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N, K ``=` `5``, ``3` `    ``if` `K >``=` `N ``-` `1``:``        ``print``(``"Not Possible"``)` `    ``else``:``        ``printPermutation(N, K)` `# This code is contributed``# by Rituraj Jain`

## C#

 `// C# implementation of the above approach``using` `System;``class` `GFG {`  `static` `void` `printPermutation(``int` `n, ``int` `k)``{``    ``int` `i, mx = n;``    ``for` `(i = 1; i <= k; i++) ``// Decreasing part``    ``{``        ``Console.Write( mx + ``" "``);``        ``mx--;``    ``}``    ``for` `(i = 1; i <= mx; i++) ``// Increasing part``        ``Console.Write( i + ``" "``);``}` `// Driver Code` `    ``public` `static` `void` `Main () {``            ``int` `N = 5, K = 3;` `    ``if` `(K >= N - 1)``        ``Console.WriteLine( ``"Not Possible"``);` `    ``else``        ``printPermutation(N, K);``    ``}``}` `// This code is contributed by inder_verma..`

## PHP

 `= ``\$N` `- 1)``        ``echo` `"Not Possible"``;` `    ``else``        ``printPermutation(``\$N``, ``\$K``);`  `// This code is contributed by inder_verma..``?>`

## Javascript

 ``
Output:
`5 4 3 1 2`

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up