Open In App

Find the missing number in a sorted array of limited range

Improve
Improve
Like Article
Like
Save
Share
Report

Given a sorted array of size n and given that there are numbers from 1 to n+1 with one missing, the missing number is to be found. It may be assumed that array has distinct elements.

Examples: 

Input : 1 3 4 5 6
Output : 2

Input  : 1 2 3 4 5 7 8 9 10
Output  : 6

We traverse all elements. For every element a[i], we check if it is equal to i+1 or not. If not, we return (i+1). 

Implementation:

C++




// C++ program to find missing Number in
// a sorted array of size n and distinct
// elements.
#include<bits/stdc++.h>
using namespace std;
 
// Function to find missing number
int getMissingNo(int a[], int n)
{
    for (int i=0; i<n; i++)       
        if (a[i] != (i+1))
            return (i+1);
  
    // If all numbers from 1 to n
    // are present
    return n+1;
}
 
// Driver code
int main()
{
    int a[] = {1, 2, 4, 5, 6};
    int n = sizeof(a) / sizeof(a[0]);
    cout << getMissingNo(a, n);
    return 0;
}
 
// This code is contributed by Sachin Bisht


Java




// Java program to find missing Number in
// a sorted array of size n and distinct
// elements.
import java.io.*;
public class Main
{
    // Function to find missing number
    static int getMissingNo(int a[])
    {
        int n = a.length;
        for (int i=0; i<n; i++)       
            if (a[i] != (i+1))
                return (i+1);
 
        // If all numbers from 1 to n
        // are present
        return n+1;
    }
       
    /* program to test above function */
    public static void main(String args[])
    {
        int a[] = {1, 2, 4, 5, 6};
        System.out.println(getMissingNo(a));
    }
}


Python3




# Python program to find missing Number in
# a sorted array of size n and distinct
# elements.
 
# function to find missing number
def getMissingNo(a):
    n = len(a)
     
    for i in range(n):
        if(a[i] != i + 1):
            return i + 1
             
    # If all numbers from 1 to n
    # are present
    return n+1
 
# Driver code
a = [1, 2, 4, 5, 6]
print(getMissingNo(a))
 
# This code is contributed by Sachin Bisht


C#




// C# program to find missing Number
// in a sorted array of size n and
// distinct elements.
using System;
 
class GFG
{
     
// Function to find missing number
static int getMissingNo(int []a, int n)
{
    for (int i = 0; i < n; i++)
        if (a[i] != (i + 1))
            return (i + 1);
 
    // If all numbers from
    // 1 to n are present
    return n + 1;
}
 
// Driver code
public static void Main()
{
    int []a = {1, 2, 4, 5, 6};
    int n = a.Length;
    Console.WriteLine(getMissingNo(a, n));
}
}
 
// This code is contributed by ihritik


Javascript




<script>
// javascript program to find missing Number
// in a sorted array of size n and
// distinct elements.
     
// Function to find missing number
function getMissingNo(a,n)
{
    for (let i = 0; i < n; i++)
        if (a[i] != (i + 1))
            return (i + 1);
 
    // If all numbers from
    // 1 to n are present
    return n + 1;
}
 
// Driver code
let a = [1, 2, 4, 5, 6]
let n = a.length;
document.write(getMissingNo(a, n));
 
// This code is contributed by mohit kumar 29.
</script>


PHP




<?php
// PHP program to find missing Number
// in a sorted array of size n and
// distinct elements.
 
// Function to find missing number
function getMissingNo($a, $n)
{
    for ($i = 0; $i < $n; $i++)
        if ($a[$i] != ($i + 1))
            return ($i + 1);
 
    // If all numbers from
    // 1 to n are present
    return $n + 1;
}
 
// Driver code
$a = array(1, 2, 4, 5, 6);
$n = sizeof($a);
echo getMissingNo($a, $n);
 
// This code is contributed
// by ihritik
?>


Output

3









Time Complexity: O(N), Where N is the length of the given array.
Auxiliary Space: O(1)

Another Approach: (Use mathematical approach to solve this problem)

It is given, elements in the array are in the range of [1, n + 1], so first calculate the required total sum by adding all the numbers from 1 to n + 1, this can be calculated by using the formula of “sum of first N natural numbers” by sum = N*(N+1) / 2, where N is the first N natural numbers. After that subtract the required total sum by current sum of the given array. This will result in the missing number that are not present in the given array.

Implementation:

C++




// C++ program to find missing Number in
// a sorted array of size n and distinct
// elements.
#include <iostream>
#include <vector>
using namespace std;
 
int findMissingNumber(const vector<int>& nums)
{
    int xor_sum = 0;
    int n = nums.size();
 
    // XOR operation between elements and their indices
    for (int i = 0; i < n; i++) {
        xor_sum ^= nums[i]
                   ^ (i + 1); // XOR current element and its
                              // expected value (index + 1)
    }
 
    // XOR operation with XOR of all numbers from 1 to n+1
    xor_sum ^= (n + 1);
 
    return xor_sum; // Return the missing number
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, 3, 4, 5, 6 };
    int missingNum = findMissingNumber(arr);
    cout << missingNum << endl;
 
    return 0;
}


Java




// Java program to find missing Number in a sorted array of
// size n and distinct elements.
 
import java.io.*;
 
class GFG {
 
    // Function to find missing number
    static int getMissingNo(int[] a, int n)
    {
 
        // Total sum required
        int total_sum = ((n + 1) * (n + 2)) / 2;
 
        // Current sum of given array
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += a[i];
        }
        return total_sum - sum;
    }
 
    public static void main(String[] args)
    {
        int[] a = { 1, 2, 4, 5, 6 };
        int n = a.length;
 
        System.out.print(getMissingNo(a, n));
    }
}
 
// This code is contributed by lokeshmvs21.


Python3




class GFG :
   
    # Function to find missing number
    @staticmethod
    def  getMissingNo( a,  n) :
       
        # Total sum required
        total_sum = int(((n + 1) * (n + 2)) / 2)
         
        # Current sum of given array
        sum = 0
        i = 0
        while (i < n) :
            sum += a[i]
            i += 1
        return total_sum - sum
    @staticmethod
    def main( args) :
        a = [1, 2, 4, 5, 6]
        n = len(a)
        print(GFG.getMissingNo(a, n), end ="")
     
if __name__=="__main__":
    GFG.main([])
     
    # This code is contributed by aadityaburujwale.


C#




// C# program to find missing Number in a sorted array of
// size n and distinct elements.
using System;
 
public class GFG {
 
    // Function to find missing number
    static int getMissingNo(int[] a, int n)
    {
 
        // Total sum required
        int total_sum = ((n + 1) * (n + 2)) / 2;
 
        // Current sum of given array
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += a[i];
        }
        return total_sum - sum;
    }
 
    static public void Main()
    {
 
        // Code
        int[] a = { 1, 2, 4, 5, 6 };
        int n = a.Length;
 
        Console.Write(getMissingNo(a, n));
    }
}
 
// This code is contributed by lokeshmvs21.


Javascript




<script>
 
// Function to find missing number
function  getMissingNo( a, n)
{
    // Total sum required
    let total_sum = ((n + 1) * (n + 2)) / 2;
 
    // Current sum of given array
    let sum = 0;
 
    for (let i = 0; i < n; i++)
        sum += a[i];
 
    return total_sum - sum;
}
 
 
    let a = [1, 2, 4, 5, 6 ];
    let n = 5;
   document.write( getMissingNo(a, n));
 
 
</script>


Output

3









Time Complexity: O(N), Where N is the length of the given array.
Auxiliary Space: O(1)

.

Approach: The task can be solved with the help of XOR operation. Follow the steps below to solve the problem:

  • Initialize a variable called xor_sum to 0.
  • Iterate through the array and perform the XOR operation between each element and its index.
  • Store the result in xor_sum.
  • Perform the XOR operation between xor_sum and the XOR of all numbers from 1 to n+1.
  • Return the resulting xor_sum, which will be the missing number.

Below is the implementation of the above approach:

C++




// C++ program to find missing Number in
// a sorted array of size n and distinct
// elements.
#include <iostream>
#include <vector>
using namespace std;
 
int findMissingNumber(const vector<int>& nums)
{
    int xor_sum = 0;
    int n = nums.size();
 
    // XOR operation between elements and their indices
    for (int i = 0; i < n; i++) {
        xor_sum ^= nums[i]
                   ^ (i + 1); // XOR current element and its
                              // expected value (index + 1)
    }
 
    // XOR operation with XOR of all numbers from 1 to n+1
    xor_sum ^= (n + 1);
 
    return xor_sum; // Return the missing number
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, 3, 4, 5, 6 };
    int missingNum = findMissingNumber(arr);
    cout << missingNum << endl;
 
    return 0;
}


Java




// Java program to find missing Number in
// a sorted array of size n and distinct
// elements.
 
import java.util.Arrays;
 
public class GFG {
 
    // Function to find the missing number in a sorted array of size n with distinct elements
    public static int findMissingNumber(int[] nums) {
        int xorSum = 0;
        int n = nums.length;
 
        // XOR operation between elements and their indices
        for (int i = 0; i < n; i++) {
            xorSum ^= nums[i]
                    ^ (i + 1); // XOR current element and its expected value (index + 1)
        }
 
        // XOR operation with XOR of all numbers from 1 to n+1
        xorSum ^= (n + 1);
 
        return xorSum; // Return the missing number
    }
//Driver code
    public static void main(String[] args) {
        int[] arr = { 1, 3, 4, 5, 6 };
        int missingNum = findMissingNumber(arr);
        System.out.println(missingNum);
    }
}


Python3




# Function to find the missing number in a sorted array
def findMissingNumber(nums):
    xorSum = 0
    n = len(nums)
 
    # XOR operation between elements and their indices
    for i in range(n):
        xorSum ^= nums[i] ^ (i + 1# XOR current element and its expected value (index + 1)
 
    # XOR operation with XOR of all numbers from 1 to n+1
    xorSum ^= n + 1
 
    return xorSum  # Return the missing number
 
# Driver Code
arr = [1, 3, 4, 5, 6]
missingNum = findMissingNumber(arr)
print(missingNum)
 
# THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)


C#




using System;
using System.Collections.Generic;
 
class GFG
{
    static int FindMissingNumber(List<int> nums)
    {
        int xorSum = 0;
        int n = nums.Count;
 
        // XOR operation between elements and their indices
        for (int i = 0; i < n; i++)
        {
            xorSum ^= nums[i]
                      ^ (i + 1); // XOR current element and its expected value (index + 1)
        }
 
        // XOR operation with XOR of all numbers from 1 to n+1
        xorSum ^= (n + 1);
 
        return xorSum; // Return the missing number
    }
 
    static void Main(string[] args)
    {
        List<int> arr = new List<int> { 1, 3, 4, 5, 6 };
        int missingNum = FindMissingNumber(arr);
        Console.WriteLine(missingNum);
 
        Console.ReadLine();
    }
}


Javascript




// JavaScript program to find missing Number in
// a sorted array of size n and distinct
// elements.
function findMissingNumber(nums) {
    let xorSum = 0;
    let n = nums.length;
 
    // XOR operation between elements and their indices
    for (let i = 0; i < n; i++) {
        xorSum ^= nums[i] ^ (i + 1); // XOR current element and its expected value (index + 1)
    }
 
    // XOR operation with XOR of all numbers from 1 to n+1
    xorSum ^= n + 1;
 
    return xorSum; // Return the missing number
}
 
// Driver Code
let arr = [1, 3, 4, 5, 6];
let missingNum = findMissingNumber(arr);
console.log(missingNum);
 
// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)


Output:

2

Time Complexity: O(n)

Auxiliary Space: O(1)



Last Updated : 29 Aug, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads