# Fill the missing numbers in the array of N natural numbers such that arr[i] not equal to i

• Difficulty Level : Medium
• Last Updated : 30 Jan, 2022

Given an unsorted array arr[] consisting of N natural numbers and the missing numbers as 0 such that arr[i] ≠ i, the task is to find and fill these missing numbers without changing the initial order. Please note that the array can contain numbers from 1 to N only once.

Examples:

Input: arr[] = {7, 4, 0, 3, 0, 5, 1}
Output: 7 4 6 3 2 5 1
Explanation:
In the given array, unfilled indices are 2 and 4. So the missing numbers that can be filled, to fulfil the criteria arr[i] ≠ i, are 6 and 2 respectively.

Input: arr[] = {2, 1, 0, 0, 0}
Output: 2 1 4 5 3
Explanation:
In the given array unfilled indices are 3, 4 and 5. So the missing numbers that can be filled, to fulfil the criteria arr[i] ≠ i, are 4, 5 and 3 respectively.

Approach:

• Store all the unfilled indices in an array unfilled_indices[]. i.e, for all i such that arr[i] = 0.
• Also store all the elements which are missing in the array missing[]. This can be done by first inserting all elements from 1 to N and then deleting all elements which is not 0
• Simply iterate the unfilled_indices[] array and start allocating all elements stored in missing[] array possibly taking each element from backwards(to avoid any i getting arr[i] = i).
• Now it may be possible that maximum one index can get the same arr[i] = i. Simply swap with it any other element after checking that the other index should be present in unfilled_indices[].
• Print the new array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach` `#include ``using` `namespace` `std;` `// Function to print array``void` `printArray(``int``[], ``int``);` `// Function to fill the position``// with arr[i] = 0``void` `solve(``int` `arr[], ``int` `n)``{` `    ``set<``int``> unfilled_indices;``    ``set<``int``> missing;` `    ``// Inserting all elements in``    ``// missing[] set from 1 to N``    ``for` `(``int` `i = 1; i < n; i++)``        ``missing.insert(i);` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Inserting unfilled positions``        ``if` `(arr[i] == 0)``            ``unfilled_indices.insert(i);` `        ``// Removing allocated_elements``        ``else` `{``            ``auto` `it = missing.find(arr[i]);``            ``missing.erase(it);``        ``}``    ``}``    ``auto` `it2 = missing.end();``    ``it2--;` `    ``// Loop for filling the positions``    ``// with arr[i] != i``    ``for` `(``auto` `it = unfilled_indices.begin();``         ``it != unfilled_indices.end();``         ``it++, it2--) {``        ``arr[*it] = *it2;``    ``}``    ``int` `pos = 0;` `    ``// Checking for any arr[i] = i``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(arr[i] == i) {``            ``pos = i;``        ``}``    ``}` `    ``int` `x;` `    ``// Finding the suitable position``    ``// in the array to swap with found i``    ``// for which arr[i] = i``    ``if` `(pos != 0) {``        ``for` `(``int` `i = 1; i < n; i++) {``            ``if` `(pos != i) {` `                ``// Checking if the position``                ``// is present in unfilled_position``                ``if` `(unfilled_indices.find(i)``                    ``!= unfilled_indices.end()) {` `                    ``// Swapping arr[i] & arr[pos]``                    ``// (arr[pos] = pos)``                    ``x = arr[i];``                    ``arr[i] = pos;``                    ``arr[pos] = x;``                    ``break``;``                ``}``            ``}``        ``}``    ``}``    ``printArray(arr, n);``}` `// Function to Print the array``void` `printArray(``int` `arr[], ``int` `n)``{``    ``for` `(``int` `i = 1; i < n; i++)``        ``cout << arr[i] << ``" "``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 0, 7, 4, 0,``                  ``3, 0, 5, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``solve(arr, n);``    ``return` `0;``}`

## Java

 `// Java implementation of above approach``import` `java.io.*;``import` `java.util.*;``class` `GFG``{` `  ``// Function to fill the position``  ``// with arr[i] = 0``  ``static` `void` `solve(``int` `arr[], ``int` `n)``  ``{``    ``Set unfilled_indices = ``new` `HashSet();``    ``Set missing = ``new` `HashSet();` `    ``// Inserting all elements in``    ``// missing[] set from 1 to N``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{``      ``missing.add(i);``    ``}``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{` `      ``// Inserting unfilled positions``      ``if` `(arr[i] == ``0``)``      ``{``        ``unfilled_indices.add(i);``      ``}` `      ``// Removing allocated_elements``      ``else``      ``{``        ``missing.remove(arr[i]);``      ``}``    ``}``    ``int``[] mi = ``new` `int``[missing.size()];``    ``int` `l = ``0``;``    ``for``(``int` `x:missing)``    ``{``      ``mi[l++] = x;``    ``}``    ``int` `m = missing.size();` `    ``// Loop for filling the positions``    ``// with arr[i] != i``    ``for``(``int` `it:unfilled_indices)``    ``{``      ``arr[it] = mi[m - ``1``];``      ``m--;``    ``}``    ``int` `pos = ``0``;` `    ``// Checking for any arr[i] = i``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{``      ``if` `(arr[i] == i)``      ``{``        ``pos = i;``      ``}``    ``}``    ``int` `x;` `    ``// Finding the suitable position``    ``// in the array to swap with found i``    ``// for which arr[i] = i``    ``if` `(pos != ``0``)``    ``{``      ``for` `(``int` `i = ``1``; i < n; i++)``      ``{``        ``if` `(pos != i)``        ``{` `          ``// Checking if the position``          ``// is present in unfilled_position``          ``if``(unfilled_indices.contains(i))``          ``{` `            ``// Swapping arr[i] & arr[pos]``            ``// (arr[pos] = pos)``            ``x = arr[i];``            ``arr[i] = pos;``            ``arr[pos] = x;``            ``break``;``          ``}``        ``}``      ``}``    ``}``    ``printArray(arr, n);``  ``}` `  ``// Function to Print the array``  ``static` `void` `printArray(``int` `arr[], ``int` `n)``  ``{``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{``      ``System.out.print(arr[i] + ``" "``);   ``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``int``[] arr = { ``0``, ``7``, ``4``, ``0``,``3``, ``0``, ``5``, ``1` `};``    ``int` `n = arr.length;``    ``solve(arr, n);``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 implementation of above approach` `# Function to fill the position``# with arr[i] = 0``def` `solve(arr, n):``    ` `    ``unfilled_indices ``=` `{}``    ``missing ``=` `{}``    ` `    ``# Inserting all elements in``    ``# missing[] set from 1 to N``    ``for` `i ``in` `range``(n):``        ``missing[i] ``=` `1` `    ``for` `i ``in` `range``(``1``, n):` `        ``# Inserting unfilled positions``        ``if` `(arr[i] ``=``=` `0``):``            ``unfilled_indices[i] ``=` `1``            ` `        ``# Removing allocated_elements``        ``else``:``            ``del` `missing[arr[i]]` `    ``it2 ``=` `list``(missing.keys())``    ``m ``=` `len``(it2)` `    ``# Loop for filling the positions``    ``# with arr[i] != i``    ``for` `it ``in` `unfilled_indices:``        ``arr[it] ``=` `it2[m ``-` `1``]``        ``m ``-``=` `1` `    ``pos ``=` `0` `    ``# Checking for any arr[i] = i``    ``for` `i ``in` `range``(``1``, n):``        ``if` `(arr[i] ``=``=` `i):``            ``pos ``=` `i` `    ``x  ``=` `0` `    ``# Finding the suitable position``    ``# in the array to swap with found i``    ``# for which arr[i] = i``    ``if` `(pos !``=` `0``):``        ``for` `i ``in` `range``(``1``, n):``            ``if` `(pos !``=` `i):``                ` `                ``# Checking if the position``                ``# is present in unfilled_position``                ``if` `i ``in` `unfilled_indices:``                    ` `                    ``# Swapping arr[i] & arr[pos]``                    ``# (arr[pos] = pos)``                    ``x ``=` `arr[i]``                    ``arr[i] ``=` `pos``                    ``arr[pos] ``=` `x``                    ``break` `    ``printArray(arr, n)` `# Function to Print the array``def` `printArray(arr, n):``    ` `    ``for` `i ``in` `range``(``1``, n):``        ``print``(arr[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``0``, ``7``, ``4``, ``0``, ``3``, ``0``, ``5``, ``1` `]` `    ``n ``=` `len``(arr)` `    ``solve(arr, n)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to fill the position``// with arr[i] = 0``static` `void` `solve(``int``[] arr, ``int` `n)``{``    ``HashSet<``int``> unfilled_indices = ``new` `HashSet<``int``>();``    ``HashSet<``int``> missing = ``new` `HashSet<``int``>();``    ` `    ``// Inserting all elements in``    ``// missing[] set from 1 to N``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``missing.Add(i);``    ``}``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ` `        ``// Inserting unfilled positions``        ``if` `(arr[i] == 0)``        ``{``            ``unfilled_indices.Add(i);``        ``}``        ` `        ``// Removing allocated_elements``        ``else``        ``{``            ``missing.Remove(arr[i]);``        ``}``    ``}``    ` `    ``int``[] mi = ``new` `int``[missing.Count];``    ``int` `l = 0;``    ` `    ``foreach``(``int` `x ``in` `missing)``    ``{``        ``mi[l++] = x;``    ``}``    ` `    ``int` `m = missing.Count;``    ` `    ``// Loop for filling the positions``    ``// with arr[i] != i``    ``foreach``(``int` `it ``in` `unfilled_indices)``    ``{``        ``arr[it] = mi[m - 1];``        ``m--;``    ``}``    ``int` `pos = 0;``    ` `    ``// Checking for any arr[i] = i``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(arr[i] == i)``        ``{``            ``pos = i;``        ``}``    ``}``    ` `    ``// Finding the suitable position``    ``// in the array to swap with found i``    ``// for which arr[i] = i``    ``if` `(pos != 0)``    ``{``        ``for``(``int` `i = 1; i < n; i++)``        ``{``            ``if` `(pos != i)``            ``{``                ` `                ``// Checking if the position``                ``// is present in unfilled_position``                ``if` `(unfilled_indices.Contains(i))``                ``{``                    ` `                    ``// Swapping arr[i] & arr[pos]``                    ``// (arr[pos] = pos)``                    ``int` `x = arr[i];``                    ``arr[i] = pos;``                    ``arr[pos] = x;``                    ``break``;``                ``}``            ``}``        ``}``    ``}``    ``printArray(arr, n);``}` `// Function to Print the array``static` `void` `printArray(``int``[] arr, ``int` `n)``{``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``Console.Write(arr[i] + ``" "``);``    ``}``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int``[] arr = { 0, 7, 4, 0, 3, 0, 5, 1 };``    ``int` `n = arr.Length;``    ` `    ``solve(arr, n);``}``}` `// This code is contributed by rag2127`

## Javascript

 ``
Output:
`7 4 6 3 2 5 1`

Time Complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up