Skip to content
Related Articles

Related Articles

Find the Missing Number

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 21 Jun, 2022

You are given a list of n-1 integers and these integers are in the range of 1 to n. There are no duplicates in the list. One of the integers is missing from the list. Write an efficient code to find the missing integer.
Example: 

Input: arr[] = {1, 2, 4, 6, 3, 7, 8}
Output: 5
Explanation: The missing number between 1 to 8 is 5

Input: arr[] = {1, 2, 3, 5}
Output: 4
Explanation: The missing number between 1 to 5 is 4

Method 1: This method uses the technique of the Summation formula. 

  • Approach: The length of the array is n-1. So, the sum of all n elements i.e. sum of numbers from 1 to n can be calculated using the formula n*(n+1)/2. Now find the sum of all the elements in the array and subtract it from the sum of the first n natural numbers, it will give us the value of the missing element.
  • Algorithm: 
    1. Calculate the sum of the first n natural numbers as sumtotal= n*(n+1)/2
    2. Create a variable sum to store the sum of the array elements.
    3. Traverse the array from start to end.
    4. Update the value of sum as sum = sum + array[i]
    5. Print the missing number as SumTotal – sum

Below is the implementation of the above approach:

C++14




#include <bits/stdc++.h>
using namespace std;
  
// Function to get the missing number
int getMissingNo(int a[], int n)
{
  
    int total = (n + 1) * (n + 2) / 2;
    for (int i = 0; i < n; i++)
        total -= a[i];
    return total;
}
  
// Driver Code
int main()
{
    int arr[] = { 1, 2, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int miss = getMissingNo(arr, n);
    cout << miss;
}

C




#include <stdio.h>
  
/* getMissingNo takes array and size of array as arguments*/
int getMissingNo(int a[], int n)
{
    int i, total;
    total = (n + 1) * (n + 2) / 2;
    for (i = 0; i < n; i++)
        total -= a[i];
    return total;
}
  
/*program to test above function */
int main()
{
    int a[] = { 1, 2, 4, 5, 6 };
    int miss = getMissingNo(a, 5);
    printf("%d", miss);
    getchar();
}

Java




// Java program to find missing Number
import java.util.*;
import java.util.Arrays;
class GFG {
    public static int
    findDisappearedNumbers(int[] nums)
    {
        int n=nums.length;
        int sum=((n+1)*(n+2))/2;
        for(int i=0;i<n;i++)
          sum-=nums[i];
        return sum;
    }
    public static void main(String[] args)
    {
        int[] a = { 1, 2, 4, 5, 6 };
        System.out.println(findDisappearedNumbers(a));
    }
}

Python




# getMissingNo takes list as argument
def getMissingNo(A):
    n = len(A)
    total = (n + 1)*(n + 2)/2
    sum_of_A = sum(A)
    return total - sum_of_A
  
  
# Driver program to test the above function
A = [1, 2, 4, 5, 6]
miss = getMissingNo(A)
print(miss)
# This code is contributed by Pratik Chhajer

C#




// C# program to find missing Number
using System;
  
class GFG {
    // Function to ind missing number
    static int getMissingNo(int[] a, int n)
    {
        int total = (n + 1) * (n + 2) / 2;
  
        for (int i = 0; i < n; i++)
            total -= a[i];
  
        return total;
    }
  
    /* program to test above function */
    public static void Main()
    {
        int[] a = { 1, 2, 4, 5, 6 };
        int miss = getMissingNo(a, 5);
        Console.Write(miss);
    }
}
  
// This code is contributed by Sam007_

PHP




<?php
// PHP program to find
// the Missing Number
  
// getMissingNo takes array and
// size of array as arguments
function getMissingNo ($a, $n)
{
    $total = ($n + 1) * ($n + 2) / 2; 
    for ( $i = 0; $i < $n; $i++)
        $total -= $a[$i];
    return $total;
}
  
// Driver Code
$a = array(1, 2, 4, 5, 6);
$miss = getMissingNo($a, 5);
echo($miss);
  
// This code is contributed by Ajit.
?>

Javascript




<script>
   
    // Function to get the missing number
    function getMissingNo(a, n) {
   
        let total = Math.floor((n + 1) * (n + 2) / 2);
        for (let i = 0; i < n; i++)
            total -= a[i];
        return total;
    }
   
    // Driver Code
  
    let arr = [ 1, 2, 4, 5, 6 ];
    let n = arr.length;
    let miss = getMissingNo(arr, n);
    document.write(miss);
  
// This code is contributed by Surbhi Tyagi 
  
</script>

Output

3

Complexity Analysis: 

  • Time Complexity: O(n). 
    Only one traversal of the array is needed.
  • Space Complexity: O(1). 
    No extra space is needed

Modification for Overflow :
Approach: The approach remains the same but there can be an overflow if n is large. In order to avoid integer overflow, pick one number from the known numbers and subtract that one number from the given numbers. This way there won’t be any Integer Overflow.

Algorithm: 

  1. Create a variable sum = 1 which will store the missing number and a counter variable c = 2.
  2. Traverse the array from start to end.
  3. Update the value of sum as sum = sum – array[i] + c and increment c as c++.
  4. Print the missing number as a sum.

Complete Interview Preparation - GFG

Below is the implementation of the above approach:

C++




#include <bits/stdc++.h>
using namespace std;
  
int getMissingNo(int a[], int n)
{
    int i, total = 1;
  
    for (i = 2; i <= (n + 1); i++) {
        total += i;
        total -= a[i - 2];
    }
    return total;
}
  
// Driver Program
int main()
{
    int arr[] = { 1, 2, 3, 5 };
    cout << getMissingNo(arr, sizeof(arr) / sizeof(arr[0]));
    return 0;
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

C




#include <stdio.h>
  
int getMissingNo(int a[], int n)
{
    int i, total = 1;
  
    for (i = 2; i <= (n + 1); i++) {
        total += i;
        total -= a[i - 2];
    }
    return total;
}
  
// Driver Program
int main()
{
    int arr[] = { 1, 2, 3, 5 };
    printf("%d",getMissingNo(arr, sizeof(arr) / sizeof(arr[0])));
    return 0;
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

Java




// Java implementation
class GFG {
    static int getMissingNo(int a[], int n)
    {
        int total = 1;
        for (int i = 2; i <= (n + 1); i++) {
            total += i;
            total -= a[i - 2];
        }
        return total;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 5 };
        System.out.println(getMissingNo(arr, arr.length));
    }
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

Python3




# a represents the array
# n : Number of elements in array a
def getMissingNo(a, n): 
    i, total = 0, 1
  
    for i in range(2, n + 2):
        total += i
        total -= a[i - 2]
    return total
  
# Driver Code
arr = [1, 2, 3, 5]
print(getMissingNo(arr, len(arr)))
  
# This code is contributed by Mohit kumar

C#




using System;
  
class GFG
{
      
// a represents the array
// n : Number of elements in array a
static int getMissingNo(int[] a, int n) 
    int i, total = 1; 
      
    for ( i = 2; i <= (n + 1); i++)
    {
        total += i;
        total -= a[i - 2];
    }
    return total; 
  
// Driver Code
public static void Main() 
{
    int[] arr = {1, 2, 3, 5};
    Console.Write(getMissingNo(arr, (arr.Length)));
  
    // Console.Write(getMissingNo(arr, 4));
}
}
// This code is contributed by SoumikMondal

Javascript




<script>
  
// a represents the array
// n : Number of elements in array a
function getMissingNo(a) 
    let n = a.length;
    let i, total=1; 
      
    for (i = 2; i<= (n+1); i++)
    {
        total += i;
        total -= a[i-2];
    }
    return total; 
  
//Driver Program
    let arr = [1, 2, 3, 5];
    document.write(getMissingNo(arr));
  
  
//This code is contributed by Mayank Tyagi
  
</script>

Output

4

Complexity Analysis: 

  • Time Complexity: O(n). 
    Only one traversal of the array is needed.
  • Space Complexity: O(1). 
    No extra space is needed

Thanks to Sahil Rally for suggesting this improvement.
Method 2: This method uses the technique of XOR to solve the problem.  

Approach: 
XOR has certain properties 

  • Assume a1 ^ a2 ^ a3 ^ …^ an = a and a1 ^ a2 ^ a3 ^ …^ an-1 = b
  • Then a ^ b = an

Algorithm: 

  1. Create two variables a = 0 and b = 0
  2. Run a loop from 1 to n with i as counter.
  3. For every index, update a as a = a ^ i
  4. Now traverse the array from start to end.
  5. For every index, update b as b = b ^ array[i].
  6. Print the missing number as a ^ b.

Below is the implementation of the above approach:

C++




#include <bits/stdc++.h>
using namespace std;
  
// Function to get the missing number
int getMissingNo(int a[], int n)
{
    // For xor of all the elements in array
    int x1 = a[0];
  
    // For xor of all the elements from 1 to n+1
    int x2 = 1;
  
    for (int i = 1; i < n; i++)
        x1 = x1 ^ a[i];
  
    for (int i = 2; i <= n + 1; i++)
        x2 = x2 ^ i;
  
    return (x1 ^ x2);
}
  
// Driver Code
int main()
{
    int arr[] = { 1, 2, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int miss = getMissingNo(arr, n);
    cout << miss;
}

C




#include <stdio.h>
  
/* getMissingNo takes array and size of array as arguments*/
int getMissingNo(int a[], int n)
{
    int i;
    int x1 = a[0]; /* For xor of all the elements in array */
    int x2 = 1; /* For xor of all the elements from 1 to n+1 */
  
    for (i = 1; i < n; i++)
        x1 = x1 ^ a[i];
  
    for (i = 2; i <= n + 1; i++)
        x2 = x2 ^ i;
  
    return (x1 ^ x2);
}
  
/*program to test above function */
int main()
{
    int a[] = { 1, 2, 4, 5, 6 };
    int miss = getMissingNo(a, 5);
    printf("%d", miss);
    getchar();
}

Java




// Java program to find missing Number
// using xor
class Main {
    // Function to find missing number
    static int getMissingNo(int a[], int n)
    {
        int x1 = a[0];
        int x2 = 1;
  
        /* For xor of all the elements 
           in array */
        for (int i = 1; i < n; i++)
            x1 = x1 ^ a[i];
  
        /* For xor of all the elements 
           from 1 to n+1 */
        for (int i = 2; i <= n + 1; i++)
            x2 = x2 ^ i;
  
        return (x1 ^ x2);
    }
  
    /* program to test above function */
    public static void main(String args[])
    {
        int a[] = { 1, 2, 4, 5, 6 };
        int miss = getMissingNo(a, 5);
        System.out.println(miss);
    }
}

Python3




# Python3 program to find
# the missing Number
# getMissingNo takes list as argument 
  
def getMissingNo(a, n):
    x1 = a[0]
    x2 = 1
      
    for i in range(1, n):
        x1 = x1 ^ a[i]
          
    for i in range(2, n + 2):
        x2 = x2 ^ i
      
    return x1 ^ x2
  
  
# Driver program to test above function
if __name__=='__main__':
  
    a = [1, 2, 4, 5, 6]
    n = len(a)
    miss = getMissingNo(a, n) 
    print(miss)
      
# This code is contributed by Yatin Gupta 

C#




// C# program to find missing Number
// using xor
using System;
  
class GFG {
    // Function to find missing number
    static int getMissingNo(int[] a, int n)
    {
        int x1 = a[0];
        int x2 = 1;
  
        /* For xor of all the elements 
        in array */
        for (int i = 1; i < n; i++)
            x1 = x1 ^ a[i];
  
        /* For xor of all the elements 
        from 1 to n+1 */
        for (int i = 2; i <= n + 1; i++)
            x2 = x2 ^ i;
  
        return (x1 ^ x2);
    }
  
    /* driver program to test above function */
    public static void Main()
    {
        int[] a = { 1, 2, 4, 5, 6 };
        int miss = getMissingNo(a, 5);
        Console.Write(miss);
    }
}
  
// This code is contributed by Sam007_

PHP




<?php
// PHP program to find
// the Missing Number
// getMissingNo takes array and 
// size of array as arguments
function getMissingNo($a, $n)
{
    // For xor of all the
    // elements in array 
    $x1 = $a[0]; 
      
    // For xor of all the 
    // elements from 1 to n + 1
    $x2 = 1; 
      
    for ($i = 1; $i < $n; $i++)
        $x1 = $x1 ^ $a[$i];
              
    for ($i = 2; $i <= $n + 1; $i++)
        $x2 = $x2 ^ $i;     
      
    return ($x1 ^ $x2);
}
  
// Driver Code
$a = array(1, 2, 4, 5, 6);
$miss = getMissingNo($a, 5);
echo($miss);
  
// This code is contributed by Ajit.
?>

Javascript




<script>
      // Function to get the missing number
      function getMissingNo(a, n)
      {
        
        // For xor of all the elements in array
        var x1 = a[0];
  
        // For xor of all the elements from 1 to n+1
        var x2 = 1;
        for (var i = 1; i < n; i++) x1 = x1 ^ a[i];
        for (var i = 2; i <= n + 1; i++) x2 = x2 ^ i;
  
        return x1 ^ x2;
      }
  
      // Driver Code
  
      var arr = [1, 2, 4, 5, 6];
      var n = arr.length;
      var miss = getMissingNo(arr, n);
      document.write(miss);
        
      // This code is contributed by rdtank.
    </script>

Output

3

Complexity Analysis: 

  • Time Complexity: O(n). 
    Only one traversal of the array is needed.
  • Space Complexity: O(1). 
    No extra space is needed.

Method 3: This method will work only in python. 
Approach: 
Take the sum of all elements in the array and subtract that from the sum of n+1 elements. For Eg: 
If my elements are li=[1,2,4,5] then take the sum of all elements in li and subtract it from the sum of len(li)+1 elements. The following code shows the demonstration. 

C++




// C++ program to find the missing Number
#include <bits/stdc++.h>
using namespace std;
  
// getMissingNo takes list as argument
int getMissingNo(int a[], int n)
{
    int n_elements_sum = n * (n + 1) / 2;
    int sum = 0;
  
    for (int i = 0; i < n - 1; i++)
        sum += a[i];
    return n_elements_sum - sum;
}
  
// Driver code
int main()
{
    int a[] = { 1, 2, 4, 5, 6 };
    int n = sizeof(a) / sizeof(a[0]) + 1;
    int miss = getMissingNo(a, n);
    cout << (miss);
    return 0;
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

C




// C program to find the missing Number
#include <stdio.h>
  
// getMissingNo takes list as argument
int getMissingNo(int a[], int n)
{
    int n_elements_sum = n * (n + 1) / 2;
    int sum = 0;
  
    for (int i = 0; i < n - 1; i++)
        sum += a[i];
    return n_elements_sum - sum;
}
  
// Driver code
int main()
{
    int a[] = { 1, 2, 4, 5, 6 };
    int n = sizeof(a) / sizeof(a[0]) + 1;
    int miss = getMissingNo(a, n);
    printf("%d",miss);
    return 0;
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

Java




// Java program to find the missing Number
class GFG {
  
    // getMissingNo function for finding missing number
    static int getMissingNo(int a[], int n)
    {
        int n_elements_sum = n * (n + 1) / 2;
        int sum = 0;
  
        for (int i = 0; i < n - 1; i++)
            sum += a[i];
  
        return n_elements_sum - sum;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int a[] = { 1, 2, 4, 5, 6 };
        int n = a.length + 1;
        int miss = getMissingNo(a, n);
  
        System.out.print(miss);
    }
}
  
// This code is contributed by Aditya Kumar (adityakumar129)

Python3




# Python3 program to find
# the missing Number
# getMissingNo takes list as argument 
def getMissingNo(a, n):
    n_elements_sum=n*(n+1)//2
    return n_elements_sum-sum(a)
  
  
# Driver program to test above function
if __name__=='__main__':
  
    a = [1, 2, 4, 5, 6]
    n = len(a)+1
    miss = getMissingNo(a, n) 
    print(miss)

C#




// C# program to implement 
// the above approach
using System; 
class GFG{ 
    
// Function to find missing 
// number 
static int getMissingNo(int[] a, 
                        int n) 
  int n_elements_sum = (n * (n + 1) / 2);
  int sum = 0; 
  
  for (int i = 0; i < n - 1; i++) 
    sum = sum + a[i]; 
  
  return (n_elements_sum - sum); 
  
// Driver code
public static void Main() 
  int[] a = {1, 2, 4, 5, 6}; 
  int miss = getMissingNo(a, 5); 
  Console.Write(miss); 
  
// This code is contributed by Virusbuddah

Javascript




<script>
  
// JavaScript program to find
// the missing Number
  
// getMissingNo takes list 
// as argument 
function getMissingNo(a,n) 
      
    let n_elements_sum =Math.floor (n * (n + 1) / 2 );
    let sum = 0;
  
  for(let i = 0; i < n - 1; i++)
    sum += a[i];
  return n_elements_sum-sum;
  
// Driver Code
    let a = [1, 2, 4, 5, 6];
    let n=a.length+1;
    let miss=getMissingNo(a,n)
    document.write(miss);
      
// This code contributed by Rajput-Ji
  
</script>

Output

3
 

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

Method 4: Efficient Approach using (Cyclic Sort)
Approach: All the given array numbers are sorted and in the range of 1 to n-1. If the range is 1 to N  then every array element will be at the location, index == value-1 i.e. means at the 0th index value will be 1 similarly at the 1st index position value will be 2 and so on till nth value.

Below is the implementation of the above approach:

Java




// java program to check missingNo
import java.util.*;
public class MissingNumber {
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 4, 5, 6 };
        int n = arr.length;
        int ans = getMissingNo(arr, n);
        System.out.println(ans);
    }
  
    static int getMissingNo(int[] arr, int n)
    {
        int i = 0;
        while (i < n) {
            // as array is of 1 based indexing so the
            // correct position or index number of each
            // element is element-1 i.e. 1 will be at 0th
            // index similarly 2 correct index will 1 so
            // on...
            int correctpos = arr[i] - 1;
            if (arr[i] < n && arr[i] != arr[correctpos]) {
                // if array element should be lesser than
                // size and array element should not be at
                // its correct postion then only swap with
                // its correct positioin or index value
                swap(arr, i, correctpos);
            }
            else {
                // if element is at its correct position
                // just increment i and check for remaining
                // array elements
                i++;
            }
        }
      // check for missing elemnt by comparing elements with their index values 
        for (int index = 0; index < arr.length; index++) {
            if (arr[index] != index + 1) {
                return index + 1;
            }
        }
        return arr.length;
    }
  
    static void swap(int[] arr, int i, int correctpos)
    {
      // swap elements with their correct indexes
        int temp = arr[i];
        arr[i] = arr[correctpos];
        arr[correctpos] = temp;
    }
}
// this code is contributed by devendra solunke

Python3




# Python3 program to check missingNo
def getMissingNo(arr, n) :
    i = 0;
      
    while (i < n) :
        # as array is of 1 based indexing so the
        # correct position or index number of each
        # element is element-1 i.e. 1 will be at 0th
        # index similarly 2 correct index will 1 so
        # on...
        correctpos = arr[i] - 1;
        if (arr[i] < n and arr[i] != arr[correctpos]) :
            # if array element should be lesser than
            # size and array element should not be at
            # its correct postion then only swap with
            # its correct positioin or index value
            arr[i],arr[correctpos] = arr[correctpos], arr[i]
  
        else :
            # if element is at its correct position
            # just increment i and check for remaining
            # array elements
            i += 1;
              
    # check for missing elemnt by comparing elements with their index values 
    for index in range(n) : 
        if (arr[index] != index + 1) :
            return index + 1;
              
    return n;
  
if __name__ == "__main__" :
    arr = [ 1, 2, 4, 5, 6 ];
    n = len(arr);
    print(getMissingNo(arr, n));
  
  
    # This Code is Contributed by AnkThon

C#




// C# program to implement
// the above approach
using System;
class GFG {
  
    // Function to find missing
    // number
    static int getMissingNo(int[] arr, int n)
    {
        int i = 0;
        while (i < n) {
            // as array is of 1 based indexing so the
            // correct position or index number of each
            // element is element-1 i.e. 1 will be at 0th
            // index similarly 2 correct index will 1 so
            // on...
            int correctpos = arr[i] - 1;
            if (arr[i] < n && arr[i] != arr[correctpos]) {
                // if array element should be lesser than
                // size and array element should not be at
                // its correct postion then only swap with
                // its correct positioin or index value
                swap(arr, i, correctpos);
            }
            else {
                // if element is at its correct position
                // just increment i and check for remaining
                // array elements
                i++;
            }
        }
        // check for missing elemnt by comparing elements
        // with their index values
        for (int index = 0; index < n; index++) {
            if (arr[index] != index + 1) {
                return index + 1;
            }
        }
        return n;
    }
  
    static void swap(int[] arr, int i, int correctpos)
    {
        // swap elements with their correct indexes
        int temp = arr[i];
        arr[i] = arr[correctpos];
        arr[correctpos] = temp;
    }
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 4, 5, 6 };
        int n = arr.Length;
        int ans = getMissingNo(arr, n);
        Console.Write(ans);
    }
}
  
// This code is contributed by devendra solunke

Javascript




// javascript program to check missingNo
<script>
        var arr = [ 1, 2, 4, 5, 6 ];
        var n = arr.length;
        var ans = getMissingNo(arr, n);
        console.log(ans);
  
  
   function getMissingNo(arr, n)
    {
        var i = 0;
        while (i < n) {
            // as array is of 1 based indexing so the
            // correct position or index number of each
            // element is element-1 i.e. 1 will be at 0th
            // index similarly 2 correct index will 1 so
            // on...
            var correctpos = arr[i] - 1;
            if (arr[i] < n && arr[i] != arr[correctpos]) {
                // if array element should be lesser than
                // size and array element should not be at
                // its correct postion then only swap with
                // its correct positioin or index value
                swap(arr, i, correctpos);
            }
            else {
                // if element is at its correct position
                // just increment i and check for remaining
                // array elements
                i++;
            }
        }
      // check for missing elemnt by comparing elements with their index values 
        for (var index = 0; index < arr.length; index++) {
            if (arr[index] != index + 1) {
                return index + 1;
            }
        }
        return n;
    }
  
    function swap(arr, i, correctpos)
    {
      // swap elements with their correct indexes
        var temp = arr[i];
        arr[i] = arr[correctpos];
        arr[correctpos] = temp;
    }
</script>
// this code is contributed by devendra solunke

Output

3

Time Complexity: O(N) requires (n-1) comparisons, so -1 is constant hence we can eliminate it, and the remaining n is complexity for the Best Case.

If an array is not sorted it will be the worst case for an algorithm and it will take O(N2) complexity. let’s see how we can calculate worst-case complexity. 

1 + 2 + 3 + 4 . . . . . .  . . . .  (n-1) comparisons will required so the sum of all natural numbers can be calculated using n*(n+1)/2. Hence we can conclude that time complexity is N

Space Complexity: O( 1) 

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!