Question

I got this question for HW and I can’t figure out how to do it:
An array A[1…n] contains all the integers from 0 to n except one. The array is not sorted.
In this problem, we cannot access an entire integer in A with a single operation.
The elements of A are represented in binary, and the only operation we can use to access them is “fetch the jth bit of A[i]”, which takes constant time.

I have to find the missing integer in O(n) time.

The time it takes to do it mormally is O(NlgN)
(run on the N array, and fetch all the bits which are function of N – lgn bits).

How can I do it without reading all the bits?

Answer 1

Let’s assume for now that n is 2^k – 1 for some k.

Let’s also look at an example where k = 3.

000
001
010
011
100
101
110
111

You’ll notice that when there is a full set, like the one shown above, each column (each digit’s place) has the same number of ones and zeros. Of course, for convenience we are showing this as sorted, but in reality, I am not stating that it is.

Let’s take a look at the following list

000
001
010
011
100
110
111

We look at the first bit of all of the elements ( O(n) ) and figure out which count is less than the other.

We see that for the first bit, there is a number with the 1 in the most significant bit missing. This means that we know that our number has a one in its most significant bit.

Basically, we partition into two sets, one where the most significant bit is 1 and one where the most significant bit is 0. The smaller set shows us what bit the missing number has.

We do the same thing on the smaller partition.

Since it is O(n) + O(n/2) + O (n/4) … it is basically O (2n) which is O (n).

EDIT

For the general case, refer to the following document, bottom of page 1.

Basically, it involves making use of the fact that when n is not a power of two, you can take into account the fact that given n, you know exactly how many should fall under the bit=1 partition and the bit=0 partition if this was a complete set.