Skip to content
Related Articles

Related Articles

Fill the missing numbers in the array of N natural numbers such that arr[i] not equal to i
  • Difficulty Level : Medium
  • Last Updated : 19 Jan, 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: 

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 <bits/stdc++.h>
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<Integer> unfilled_indices = new HashSet<Integer>();
    Set<Integer> missing = new HashSet<Integer>();
 
    // 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
 
    = 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
Output: 
7 4 6 3 2 5 1

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :