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.
- 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)
- 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.
- A bit is set in xor only if corresponding bits in X and Y are different. This is the crucial step to understand.
- We take a set bit in XOR. Let us consider the rightmost set bit in XOR, set_bit_no = 010
- 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.
- 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++ 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 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. |
# 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. |
// 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 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. ?> |
<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