Related Articles

# Change the array into a permutation of numbers from 1 to n

• Difficulty Level : Medium
• Last Updated : 28 May, 2021

Given an array A of n elements. We need to change the array into a permutation of numbers from 1 to n using minimum replacements in the array.
Examples:

```Input : A[] = {2, 2, 3, 3}
Output : 2 1 3 4
Explanation:
To make it a permutation of 1 to 4, 1 and 4 are
missing from the array. So replace 2, 3 with
1 and 4.

Input :  A[] = {1, 3, 2}
Output : 1 3 2

Input : A[] = {10, 1, 2}
Output : 3 1 2
```

Approach: Observe that we don’t need to change the numbers which are in the range [1, n] and which are distinct(has only one occurrence). So, we use a greedy approach. If we meet the number we have never met before and this number is between 1 and n, we leave this number unchanged. And remove the duplicate elements and add the missing elements in the range [1, n]. Also replace the numbers, not in the range.

## C++

 `// CPP program to make a permutation of numbers``// from 1 to n using minimum changes.``#include ``using` `namespace` `std;` `void` `makePermutation(``int` `a[], ``int` `n)``{``    ``// Store counts of all elements.``    ``unordered_map<``int``, ``int``> count;``    ``for` `(``int` `i = 0; i < n; i++)``        ``count[a[i]]++;` `    ``int` `next_missing = 1;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(count[a[i]] != 1 || a[i] > n || a[i] < 1) {``            ``count[a[i]]--;` `            ``// Find next missing element to put``            ``// in place of current element.``            ``while` `(count.find(next_missing) != count.end())``                ``next_missing++;` `            ``// Replace with next missing and insert the``            ``// missing element in hash.``            ``a[i] = next_missing;``            ``count[next_missing] = 1;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 2, 2, 3, 3 };``    ``int` `n = ``sizeof``(A) / ``sizeof``(A);``    ``makePermutation(A, n);``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << A[i] << ``" "``;``    ``return` `0;``}`

## Java

 `// Java program to make a permutation of numbers``// from 1 to n using minimum changes.``import` `java.util.*;` `class` `GFG``{``static` `void` `makePermutation(``int` `[]a, ``int` `n)``{``    ``// Store counts of all elements.``    ``HashMap count = ``new` `HashMap();``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if``(count.containsKey(a[i]))``        ``{``            ``count.put(a[i], count.get(a[i]) + ``1``);``        ``}``        ``else``        ``{``            ``count.put(a[i], ``1``);``        ``}``    ``}` `    ``int` `next_missing = ``1``;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(count.containsKey(a[i]) &&``            ``count.get(a[i]) != ``1` `||``            ``a[i] > n || a[i] < ``1``)``        ``{``            ``count.put(a[i], count.get(a[i]) - ``1``);` `            ``// Find next missing element to put``            ``// in place of current element.``            ``while` `(count.containsKey(next_missing))``                ``next_missing++;` `            ``// Replace with next missing and insert``            ``// the missing element in hash.``            ``a[i] = next_missing;``            ``count. put(next_missing, ``1``);``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``2``, ``2``, ``3``, ``3` `};``    ``int` `n = A.length;``    ``makePermutation(A, n);``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``System.out.print(A[i] + ``" "``);``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 code to make a permutation``# of numbers from 1 to n using``# minimum changes.` `def` `makePermutation (a, n):` `    ``# Store counts of all elements.``    ``count ``=` `dict``()``    ``for` `i ``in` `range``(n):``        ``if` `count.get(a[i]):``            ``count[a[i]] ``+``=` `1``        ``else``:``            ``count[a[i]] ``=` `1``;``        ` `    ``next_missing ``=` `1``    ``for` `i ``in` `range``(n):``        ``if` `count[a[i]] !``=` `1` `or` `a[i] > n ``or` `a[i] < ``1``:``            ``count[a[i]] ``-``=` `1``            ` `            ``# Find next missing element to put``            ``# in place of current element.``            ``while` `count.get(next_missing):``                ``next_missing``+``=``1``            ` `            ``# Replace with next missing and``            ``# insert the missing element in hash.``            ``a[i] ``=` `next_missing``            ``count[next_missing] ``=` `1` `# Driver Code``A ``=` `[ ``2``, ``2``, ``3``, ``3` `]``n ``=` `len``(A)``makePermutation(A, n)` `for` `i ``in` `range``(n):``    ``print``(A[i], end ``=` `" "``)``    ` `# This code is contributed by "Sharad_Bhardwaj".`

## C#

 `// C# program to make a permutation of numbers``// from 1 to n using minimum changes.``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `void` `makePermutation(``int` `[]a, ``int` `n)``{``    ``// Store counts of all elements.``    ``Dictionary<``int``,``               ``int``> count = ``new` `Dictionary<``int``,``                                           ``int``>();``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if``(count.ContainsKey(a[i]))``        ``{``            ``count[a[i]] = count[a[i]] + 1;``        ``}``        ``else``        ``{``            ``count.Add(a[i], 1);``        ``}``    ``}` `    ``int` `next_missing = 1;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(count.ContainsKey(a[i]) &&``            ``count[a[i]] != 1 ||``            ``a[i] > n || a[i] < 1)``        ``{``            ``count[a[i]] = count[a[i]] - 1;` `            ``// Find next missing element to put``            ``// in place of current element.``            ``while` `(count.ContainsKey(next_missing))``                ``next_missing++;` `            ``// Replace with next missing and insert``            ``// the missing element in hash.``            ``a[i] = next_missing;``            ``count.Add(next_missing, 1);``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 2, 2, 3, 3 };``    ``int` `n = A.Length;``    ``makePermutation(A, n);``    ``for` `(``int` `i = 0; i < n; i++)``        ``Console.Write(A[i] + ``" "``);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`1 2 4 3`

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