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

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

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.

Implementation:

## 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[0]);``    ``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 `

Time Complexity : O(n log n)
Auxiliary Space: O(n)

This article is contributed by Aarti_Rathi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up