# Lexicographically smallest permutation number up to K having given array as a subsequence

• Last Updated : 29 Sep, 2021

Given an integer K and an array arr[] having N pairwise distinct integers in the range [1, K], the task is to find the lexicographically smallest permutation of the first K positive integers such that the given array arr[] is a subsequence of the permutation.

Examples:

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.

Input: arr[] = {1, 3, 5, 7}, K = 8
Output: 1 2 3 4 5 6 7 8
Explanation: {1, 2, 3, 4, 5, 6, 7, 8} is the lexicographically smallest permutatuion of the first 8 positive integers such that the given array  {1, 3, 5, 7} is also a subsequence of the permutation.

Input: arr[] = {6, 4, 2, 1}, K=7
Output: 3 5 6 4 2 1 7

Approach: The given problem can be solved by using a greedy approach. Below are the steps to follow:

• Create a vector missing[] that stores the integers in the range [1, K] in increasing order that are not present in the given array arr[] using the approach discussed in this article.
• Create two pointers p1 and p2 which store the current index in arr[] and missing[] respectively. Initially, both are equal to 0.
• Greedily take and store the minimum of arr[p1] and missing [p2] into a vector, say ans[] and increment the respective pointer to the next position till the count of the stored integers is less than K.
• In order to make things easier, append INT_MAX at the end of the array missing[] and arr[] which will avoid getting out of bounds.
• After completing the above steps, all the values stored in the ans[] is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the lexicographically``// smallest permutation such that the``// given array is a subsequence of it``void` `findPermutation(``int` `K, vector<``int``> arr)``{``    ``// Stores the missing elements in``    ``// arr in the range [1, K]``    ``vector<``int``> missing;` `    ``// Stores if the ith element is``    ``// present in arr or not``    ``vector<``bool``> visited(K + 1, 0);` `    ``// Loop to mark all integers present``    ``// in the array as visited``    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``visited[arr[i]] = 1;``    ``}` `    ``// Loop to insert all the integers``    ``// not visited into missing``    ``for` `(``int` `i = 1; i <= K; i++) {``        ``if` `(!visited[i]) {``            ``missing.push_back(i);``        ``}``    ``}``    ``// Append INT_MAX at end in order``    ``// to prevent going out of bounds``    ``arr.push_back(INT_MAX);``    ``missing.push_back(INT_MAX);` `    ``// Pointer to the current element``    ``int` `p1 = 0;` `    ``// Pointer to the missing element``    ``int` `p2 = 0;` `    ``// Stores the required permutation``    ``vector<``int``> ans;` `    ``// Loop to construct the permutation``    ``// using greedy approach``    ``while` `(ans.size() < K) {` `        ``// If missing element is smaller``        ``// that the current element insert``        ``// missing element``        ``if` `(arr[p1] < missing[p2]) {``            ``ans.push_back(arr[p1]);``            ``p1++;``        ``}` `        ``// Insert current element``        ``else` `{``            ``ans.push_back(missing[p2]);``            ``p2++;``        ``}``    ``}` `    ``// Print the required Permutation``    ``for` `(``int` `i = 0; i < K; i++) {``        ``cout << ans[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `K = 7;``    ``vector<``int``> arr = { 6, 4, 2, 1 };` `    ``// Function Call``    ``findPermutation(K, arr);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the lexicographically``// smallest permutation such that the``// given array is a subsequence of it``static` `void` `findPermutation(``int` `K, Vector arr)``{``    ``// Stores the missing elements in``    ``// arr in the range [1, K]``    ``Vector missing = ``new` `Vector();` `    ``// Stores if the ith element is``    ``// present in arr or not``    ``boolean` `visited[] = ``new` `boolean``[K + ``1``];` `    ``// Loop to mark all integers present``    ``// in the array as visited``    ``for` `(``int` `i = ``0``; i < arr.size(); i++) {``        ``visited[arr.get(i)] = ``true``;``    ``}` `    ``// Loop to insert all the integers``    ``// not visited into missing``    ``for` `(``int` `i = ``1``; i <= K; i++) {``        ``if` `(!visited[i]) {``            ``missing.add(i);``        ``}``    ``}``    ``// Append Integer.MAX_VALUE at end in order``    ``// to prevent going out of bounds``    ``arr.add(Integer.MAX_VALUE);``    ``missing.add(Integer.MAX_VALUE);` `    ``// Pointer to the current element``    ``int` `p1 = ``0``;` `    ``// Pointer to the missing element``    ``int` `p2 = ``0``;` `    ``// Stores the required permutation``    ``Vector ans = ``new` `Vector();` `    ``// Loop to conthe permutation``    ``// using greedy approach``    ``while` `(ans.size() < K) {` `        ``// If missing element is smaller``        ``// that the current element insert``        ``// missing element``        ``if` `(arr.get(p1) < missing.get(p2)) {``            ``ans.add(arr.get(p1));``            ``p1++;``        ``}` `        ``// Insert current element``        ``else` `{``            ``ans.add(missing.get(p2));``            ``p2++;``        ``}``    ``}` `    ``// Print the required Permutation``    ``for` `(``int` `i = ``0``; i < K; i++) {``        ``System.out.print(ans.get(i)+ ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `K = ``7``;``    ``Integer []a = {``6``, ``4``, ``2``, ``1``};``    ``Vector arr = ``new` `Vector<>(Arrays.asList(a));` `    ``// Function Call``    ``findPermutation(K, arr);` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for the above approach` `# Function to find the lexicographically``# smallest permutation such that the``#  given array is a subsequence of it``def` `findPermutation(K, arr):``  ` `    ``# Stores the missing elements in``        ``# arr in the range [1, K]``    ``missing ``=` `[]` `    ``# Stores if the ith element is``    ``# present in arr or not``    ``visited ``=` `[``0``]``*``(K``+``1``)` `    ``# Loop to mark all integers present``    ``# in the array as visited``    ``for` `i ``in` `range``(``4``):``        ``visited[arr[i]] ``=` `1` `    ``# Loop to insert all the integers``    ``# not visited into missing``    ``for` `i ``in` `range``(``1``, K``+``1``):``        ``if``(``not` `visited[i]):``            ``missing.append(i)` `    ``# Append INT_MAX at end in order``        ``# to prevent going out of bounds``    ``INT_MAX ``=` `2147483647``    ``arr.append(INT_MAX)``    ``missing.append(INT_MAX)` `    ``# Pointer to the current element``    ``p1 ``=` `0` `    ``# Pointer to the missing element``    ``p2 ``=` `0` `    ``# Stores the required permutation``    ``ans ``=` `[]` `    ``# Loop to construct the permutation``    ``# using greedy approach` `    ``while` `(``len``(ans) < K):``        ``# If missing element is smaller``                ``# that the current element insert``        ``# missing element``        ``if` `(arr[p1] < missing[p2]):``            ``ans.append(arr[p1])``            ``p1 ``=` `p1 ``+` `1` `        ``# Insert current element``        ``else``:``            ``ans.append(missing[p2])``            ``p2 ``=` `p2 ``+` `1` `    ``# Print the required Permutation``    ``for` `i ``in` `range``(``0``, K):``        ``print``(ans[i], end``=``" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``K ``=` `7``    ``arr ``=` `[``6``, ``4``, ``2``, ``1``]` `    ``# Function Call``    ``findPermutation(K, arr)``    ` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections;``class` `GFG{` `// Function to find the lexicographically``// smallest permutation such that the``// given array is a subsequence of it``static` `void` `findPermutation(``int` `K, ArrayList arr)``{``  ` `    ``// Stores the missing elements in``    ``// arr in the range [1, K]``    ``ArrayList missing = ``new` `ArrayList();` `    ``// Stores if the ith element is``    ``// present in arr or not``    ``bool` `[] visited = ``new` `bool``[K + 1];` `    ``// Loop to mark all integers present``    ``// in the array as visited``    ``for` `(``int` `i = 0; i < arr.Count; i++) {``        ``visited[(``int``)arr[i]] = ``true``;``    ``}` `    ``// Loop to insert all the integers``    ``// not visited into missing``    ``for` `(``int` `i = 1; i <= K; i++) {``        ``if` `(!visited[i]) {``            ``missing.Add(i);``        ``}``    ``}``    ``// Append Int32.MaxValue at end in order``    ``// to prevent going out of bounds``    ``arr.Add(Int32.MaxValue);``    ``missing.Add(Int32.MaxValue);` `    ``// Pointer to the current element``    ``int` `p1 = 0;` `    ``// Pointer to the missing element``    ``int` `p2 = 0;` `    ``// Stores the required permutation``    ``ArrayList ans = ``new` `ArrayList();` `    ``// Loop to conthe permutation``    ``// using greedy approach``    ``while` `(ans.Count < K) {` `        ``// If missing element is smaller``        ``// that the current element insert``        ``// missing element``        ``if` `((``int``)arr[p1] < (``int``)missing[p2]) {``            ``ans.Add(arr[p1]);``            ``p1++;``        ``}` `        ``// Insert current element``        ``else` `{``            ``ans.Add(missing[p2]);``            ``p2++;``        ``}``    ``}` `    ``// Print the required Permutation``    ``for` `(``int` `i = 0; i < K; i++) {``        ``Console.Write(ans[i]+ ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `K = 7;``    ``int` `[] a = {6, 4, 2, 1};``    ``ArrayList arr = ``new` `ArrayList(a);` `    ``// Function Call``    ``findPermutation(K, arr);``}``}` `// This code is contributed by ihritik.`

## Javascript

 ``

Output:
`3 5 6 4 2 1 7`

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

My Personal Notes arrow_drop_up