Given an array of N integers, ranging from 1 to N+1, find the missing number in that array. It is easy to see that with N slots and N+1 integers, there must be a missing number in the array.

This problem is very similar to another problem: find repeated number in an array

For example,

Input:A = [1,2,5,4,6] N = 5 range 1 to 6.Output:3.Input:A = [1,5,3,4,7,8,9,2] N = 8 range 1 to 9.Output:6

## Approaches to find absent number

**Using hash**

Create a hash with the size equal to N+1. Scan through elements of the array and mark as true in the hash. Go through the hash and find a number that is still set to false. That number will be the missing number in the array.

The complexity of this method is `O(n)` with additional `O(n)` space complexity.

**Using mathmatics**

We know that the sum of N consecutive numbers is `N*(N+1)/2`. If a number is missing, the sum of all numbers will not be equal to `N*(N+1)/2`. The missing number will be the difference between the expected sum and the actual sum.

Our missing number should be = (N+2) * (N+1) /2 – Actual sum; N+1 because the range of numbers is from 1 to N+1

Complexity is `O(n)`. However, there is a catch: there may be an overflow risk if `N` is big enough.

**Using XOR**

There is a beautiful property of XOR, that is: if we XOR a number with itself, the result will be zero. How can this property help us to find the missing number? In the problem, there are two sets of numbers: the first one is the range 1 to N+1, and others which are actually present in the array. These two sets differ by only one number and that is our missing number. Now if we XOR first set of numbers with the second set of numbers, all except the absent number will cancel each other. The final result will be the output of our problem.

### Algorithm using XOR

1. Scan through the entire array and XOR all elements. Call it `aXOR`

2. Now XOR all numbers for 1 to N+1. Call it `eXOR`

3. Now XOR aXOR and eXOR, the result is the missing number

Letâ€™s take an example and see if this works

A = [1,3,4,5] Here N = 4, Range is 1 to 5.

XORing bit representations of actual numbers

001 XOR 011 = 010 XOR 100 = 110 XOR 101 = 011 (aXOR)

XORing bit representation of expected numbers

001 XOR 010 = 011 XOR 011 = 000 XOR 100 = 100 XOR 101 = 001 (eXOR)

Now XOR actualXOR and expectedXOR;

011 XOR 001 = 010 = 2 is our answer.

### Implementation

public int missingNumber(int[] nums) { int n = nums.length; int nXOR = 0; for(int i=0; i<=n; i++){ nXOR ^= i; } int aXOR = 0; for(int i=0; i<n; i++){ aXOR ^= nums[i]; } return aXOR ^ nXOR; }

The complexity of the XOR method is `O(n)` with no additional space complexity.

If you want to contribute to this blog in any way, please reach out to us: Contact. Also, please share if you find something wrong or missing. We would love to hear what you have to say.