# 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`

My Personal Notes arrow_drop_up
Recommended Articles
Page :