Find Two Missing Numbers | Set 2 (XOR based solution)

Given an array of n unique integers where each element in the array is in range [1, n]. The array has all distinct elements and size of an array is (n-2). Hence Two numbers from the range are missing from this array. Find the two missing numbers.
Examples:

Input  : arr[] = {1, 3, 5, 6}, n = 6
Output : 2 4

Input : arr[] = {1, 2, 4}, n = 5
Output : 3 5

Input : arr[] = {1, 2}, n = 4
Output : 3 4

Find Two Missing Numbers | Set 1 (An Interesting Linear Time Solution)
We have discussed two methods to solve this problem in above article. The method 1 requires O(n) extra space and method 2 can causes overflow. In this post, a new solution is discussed. The solution discussed here is O(n) time, O(1) extra space and causes no overflow.
Below are steps. 

1. Find XOR of all array elements and natural numbers from 1 to n. Let the array be arr[] = {1, 3, 5, 6}

      XOR = (1 ^ 3  ^ 5 ^ 6) ^ (1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6)

2. As per the property of XOR, same elements will cancel out and we will be left with 2 XOR 4 = 6 (110). But we don’t know the exact numbers,let them be X and Y.
3. A bit is set in xor only if corresponding bits in X and Y are different. This is the crucial step to understand.
4. We take a set bit in XOR. Let us consider the rightmost set bit in XOR, set_bit_no = 010
5. Now again if we XOR all the elements of arr[] and 1 to n that have rightmost bit set we will get one of the repeating numbers, say x.

   Ex: Elements in arr[] with bit set: {3, 6}
   Elements from 1 to n with bit set {2, 3, 6}
   Result of XOR'ing all these is x = 2.

6. Similarly, if we XOR all the elements of arr[] and 1 to n that have rightmost bit not set, we will get the other element, say y.

   Ex: Elements in arr[] with bit not set: {1, 5}
   Elements from 1 to n with bit not set {1, 4, 5}
   Result of XOR'ing all these is y = 4 

Below is the implementation of above steps. 

C++

// C++ Program to find 2 Missing Numbers using O(1)
// extra space and no overflow.
#include<bits/stdc++.h>

// Function to find two missing numbers in range
// [1, n]. This function assumes that size of array
// is n-2 and all array elements are distinct
void findTwoMissingNumbers(int arr[], int n)
{
    /* Get the XOR of all elements in arr[] and
       {1, 2 .. n} */
    int XOR = arr[0];
    for (int i = 1; i < n-2; i++)
        XOR ^= arr[i];
    for (int i = 1; i <= n; i++)
        XOR ^= i;

    // Now XOR has XOR of two missing elements. Any set
    // bit in it must be set in one missing and unset in
    // other missing number

    // Get a set bit of XOR (We get the rightmost set bit)
    int set_bit_no = XOR & ~(XOR-1);

    // Now divide elements in two sets by comparing rightmost
    // set bit of XOR with bit at same position in each element.
    int x = 0, y = 0; // Initialize missing numbers
    for (int i = 0; i < n-2; i++)
    {
        if (arr[i] & set_bit_no)
            x = x ^ arr[i]; /*XOR of first set in arr[] */
        else
            y = y ^ arr[i]; /*XOR of second set in arr[] */
    }
    for (int i = 1; i <= n; i++)
    {
        if (i & set_bit_no)
            x = x ^ i; /* XOR of first set in arr[] and
                         {1, 2, ...n }*/
        else
            y = y ^ i; /* XOR of second set in arr[] and
                         {1, 2, ...n } */
    }

    printf("Two Missing Numbers are\n %d %d", x, y);
}

// Driver program to test above function
int main()
{
    int arr[] = {1, 3, 5, 6};

    // Range of numbers is 2 plus size of array
    int n = 2 + sizeof(arr)/sizeof(arr[0]);

    findTwoMissingNumbers(arr, n);

    return 0;
}

Java

// Java Program to find 2 Missing Numbers
import java.util.*;

class GFG {

    // Function to find two missing numbers in range
    // [1, n]. This function assumes that size of array
    // is n-2 and all array elements are distinct
    static void findTwoMissingNumbers(int arr[], int n)
    {
        /* Get the XOR of all elements in arr[] and
           {1, 2 .. n} */
        int XOR = arr[0];
        for (int i = 1; i < n-2; i++)
            XOR ^= arr[i];
        for (int i = 1; i <= n; i++)
            XOR ^= i;

        // Now XOR has XOR of two missing elements.
        // Any set bit in it must be set in one missing
        // and unset in other missing number

        // Get a set bit of XOR (We get the rightmost
        // set bit)
        int set_bit_no = XOR & ~(XOR-1);

        // Now divide elements in two sets by comparing
        // rightmost set bit of XOR with bit at same
        // position in each element.
        int x = 0, y = 0; // Initialize missing numbers
        for (int i = 0; i < n-2; i++)
        {
            if ((arr[i] & set_bit_no) > 0)

                /*XOR of first set in arr[] */
                x = x ^ arr[i];
            else
                /*XOR of second set in arr[] */
                y = y ^ arr[i];
        }

        for (int i = 1; i <= n; i++)
        {
            if ((i & set_bit_no)>0)

                /* XOR of first set in arr[] and
                   {1, 2, ...n }*/
                x = x ^ i;
            else
                /* XOR of second set in arr[] and
                    {1, 2, ...n } */
                y = y ^ i;
        }

        System.out.println("Two Missing Numbers are ");
        System.out.println( x + " " + y);
    }

    /* Driver program to test above function */
    public static void main(String[] args)
    {
         int arr[] = {1, 3, 5, 6};

         // Range of numbers is 2 plus size of array
         int n = 2 +arr.length;

         findTwoMissingNumbers(arr, n);

        }
    }

// This code is contributed by Arnav Kr. Mandal.

Python3

# Python Program to find 2 Missing
# Numbers using O(1)
# extra space and no overflow.

# Function to find two missing
# numbers in range
# [1, n]. This function assumes
# that size of array
# is n-2 and all array elements
# are distinct
def findTwoMissingNumbers(arr, n):

        # Get the XOR of all
        # elements in arr[] and
    # {1, 2 .. n}
    XOR = arr[0]
    for i in range(1,n-2):
        XOR ^= arr[i]
    for i in range(1,n+1):
        XOR ^= i

    # Now XOR has XOR of two
        # missing elements. Any set
    # bit in it must be set in
        # one missing and unset in
    # other missing number

    # Get a set bit of XOR
        # (We get the rightmost set bit)
    set_bit_no = XOR & ~(XOR-1)

    # Now divide elements in two sets
        # by comparing rightmost
    # set bit of XOR with bit at same
        # position in each element.
    x = 0

        # Initialize missing numbers
    y = 0
    for i in range(0,n-2):
        if arr[i] & set_bit_no:

                # XOR of first set in arr[]
            x = x ^ arr[i]
        else:

                # XOR of second set in arr[]
            y = y ^ arr[i]
    for i in range(1,n+1):
        if i & set_bit_no:

                # XOR of first set in arr[] and
                # {1, 2, ...n }
            x = x ^ i

        else:

                # XOR of second set in arr[] and
                # {1, 2, ...n }
            y = y ^ i


    print ("Two Missing Numbers are\n%d %d"%(x,y))

# Driver program to test
# above function
arr = [1, 3, 5, 6]

# Range of numbers is 2
# plus size of array
n = 2 + len(arr)
findTwoMissingNumbers(arr, n)

# This code is contributed
# by Shreyanshi Arun.

C#

// Program to find 2 Missing Numbers
using System;

class GFG {

    // Function to find two missing
    // numbers in range [1, n].This
    // function assumes that size of
    // array is n-2 and all array
    // elements are distinct
    static void findTwoMissingNumbers(int[] arr, int n)
    {
        // Get the XOR of all elements
        // in arr[] and {1, 2 .. n}
        int XOR = arr[0];

        for (int i = 1; i < n - 2; i++)
            XOR ^= arr[i];

        for (int i = 1; i <= n; i++)
            XOR ^= i;

        // Now XOR has XOR of two missing
        // element. Any set bit in it must
        // be set in one missing and unset
        // in other missing number
        // Get a set bit of XOR (We get the
        // rightmost set bit)
        int set_bit_no = XOR & ~(XOR - 1);

        // Now divide elements in two sets
        // by comparing rightmost set bit
        // of XOR with bit at same position
        // in each element.
        int x = 0, y = 0;

        // Initialize missing numbers
        for (int i = 0; i < n - 2; i++) {

            if ((arr[i] & set_bit_no) > 0)

                // XOR of first set in arr[]
                x = x ^ arr[i];

            else
                // XOR of second set in arr[]
                y = y ^ arr[i];
        }

        for (int i = 1; i <= n; i++) {
            if ((i & set_bit_no) > 0)
                // XOR of first set in arr[]
                // and {1, 2, ...n }
                x = x ^ i;

            else
                // XOR of second set in arr[]
                // and {1, 2, ...n }
                y = y ^ i;
        }

        Console.WriteLine("Two Missing Numbers are ");
        Console.WriteLine(x + " " + y);
    }

    // Driver program
    public static void Main()
    {
        int[] arr = { 1, 3, 5, 6 };

        // Range of numbers is 2 plus
        // size of array
        int n = 2 + arr.Length;

        findTwoMissingNumbers(arr, n);
    }
}

// This code is contributed by Anant Agarwal.

PHP

<?php
// PHP Program to find 2 Missing
// Numbers using O(1) extra
// space and no overflow.

// Function to find two
// missing numbers in range
// [1, n]. This function
// assumes that size of array
// is n-2 and all array
// elements are distinct
function findTwoMissingNumbers($arr, $n)
{

    // Get the XOR of all
    // elements in arr[] and
    // {1, 2 .. n}
    $XOR = $arr[0];
    for ($i = 1; $i < $n - 2; $i++)
        $XOR ^= $arr[$i];
    for ($i = 1; $i <= $n; $i++)
        $XOR ^= $i;

    // Now XOR has XOR of two
    // missing elements. Any set
    // bit in it must be set in
    // one missing and unset in
    // other missing number

    // Get a set bit of XOR
    // (We get the rightmost
    // set bit)
    $set_bit_no = $XOR & ~($XOR - 1);

    // Now divide elements in two
    // sets by comparing rightmost
    // set bit of XOR with bit at
    // same position in each element.

    $x = 0;

    // Initialize missing numbers
    $y = 0;
    for ($i = 0; $i < $n - 2; $i++)
    {
        if ($arr[$i] & $set_bit_no)

            // XOR of first set in arr[]
            $x = $x ^ $arr[$i];

        else

            // XOR of second set in arr[]
            $y = $y ^ $arr[$i];
    }
    for ($i = 1; $i <= $n; $i++)
    {
        if ($i & $set_bit_no)

            // XOR of first set in arr[]
            // and {1, 2, ...n }
            $x = $x ^ $i;

        else

            // XOR of second set in arr[]
            // and {1, 2, ...n }
            $y = $y ^ $i;
    }

    echo "Two Missing Numbers are\n", $x;
    echo "\n", $y;
}

    // Driver Code
    $arr = array(1, 3, 5, 6);

    // Range of numbers is 2
    // plus size of array
    $n = 2 + count($arr);

    findTwoMissingNumbers($arr, $n);

// This code is contributed by anuj_67.
?>

Javascript

<script>

// Javascript Program to find 2
// Missing Numbers using O(1)
// extra space and no overflow.

// Function to find two missing numbers in range
// [1, n]. This function assumes that size of array
// is n-2 and all array elements are distinct
function findTwoMissingNumbers(arr, n)
{
    /* Get the XOR of all elements in arr[] and
       {1, 2 .. n} */
    let XOR = arr[0];
    for (let i = 1; i < n-2; i++)
        XOR ^= arr[i];
    for (let i = 1; i <= n; i++)
        XOR ^= i;

    // Now XOR has XOR of two missing
    // elements. Any set
    // bit in it must be set in
    // one missing and unset in
    // other missing number

    // Get a set bit of XOR
    // (We get the rightmost set bit)
    let set_bit_no = XOR & ~(XOR-1);

    // Now divide elements in two
    // sets by comparing rightmost
    // set bit of XOR with bit at same
    // position in each element.
    let x = 0, y = 0; // Initialize missing numbers
    for (let i = 0; i < n-2; i++)
    {
        if (arr[i] & set_bit_no)
            x = x ^ arr[i]; /*XOR of first set in arr[] */
        else
            y = y ^ arr[i]; /*XOR of second set in arr[] */
    }
    for (let i = 1; i <= n; i++)
    {
        if (i & set_bit_no)
            x = x ^ i; /* XOR of first set in arr[] and
                         {1, 2, ...n }*/
        else
            y = y ^ i; /* XOR of second set in arr[] and
                         {1, 2, ...n } */
    }

    document.write(`Two Missing Numbers are<br> ${x} ${y}`);
}

// Driver program to test above function
    let arr = [1, 3, 5, 6];

    // Range of numbers is 2 plus size of array
    n = 2 + arr.length;

    findTwoMissingNumbers(arr, n);

</script>

Output:  

Two Missing Numbers are
2 4

Time Complexity : O(n) 
Auxiliary Space : O(1) 
No integer overflow
This article is contributed by Shivam Agrawal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.