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

• Difficulty Level : Medium
• Last Updated : 11 Jun, 2021

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:

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

My Personal Notes arrow_drop_up