High efficient algorithm for picking up number from array - c++

Question

Here is the problem:
There are 2*N+1 integers in one array, and there are N pair int numbers, i,e, two 1, or two 3 etc,so there is only one int number , which has no pair.
The question is how to find this number with high efficient algorithm.
Thanks for any clues or comments.

Answer 1

Ok, Ok, here's an explanation of my comment. :-/
missingNum = 0
for each value in list
missingNum = missingNum ^ value //^ = xor
next
print(missingNum)
That's a linear algorithm, O(n).
So what's happening here? Say, we have [2,1,3,1,2], for those familiar with XOR operator, know that 1 ^ 1 = 0, 0 ^ 0 = 0, and 1 ^ 0 = 1, 0 ^ 1 = 1 (remember there's no carry)
So essentially, when we XOR a sequence of bits (100110111), and it has even numbers of 1, each will XOR themselves to zero...if the number of 1's are odd, the XOR yields a 1
So in our example, starting from lsb
2 : 0010
1 : 0001
3 : 0011
1 : 0001
2 : 0010
lsb bit: 0 ^ 1 ^ 1 ^ 1 ^ 0 : 1
2nd bit: 1 ^ 0 ^ 1 ^ 0 ^ 1 : 1
3rd bit: 0 ^ 0 ^ 0 ^ 0 ^ 0 : 0
4th bit: 0 ^ 0 ^ 0 ^ 0 ^ 0 : 0
So our missing number is
0011 = 3

Answer 2

You can find more universal answer in this question. If you assume n=2, m=1 you'll get what you want.
But, as st0le said, in your case XOR should be enough.

Answer 3

If I understand the question correctly, you've got an array containing an odd number of integer values, consisting of a number of integers that appear twice plus one integer that appears only once. For example, the array might look like this:
[3, 41, 6, 6, 41]
where 6 and 41 are both repeated and 3 is unique.
It would be good to know if there are any other constraints. For example:
Is the array sorted? (If so, this is a simple problem to solve in O(N) time with no requirement for temporary storage.)
Can the unpaired integer be the same as an integer in a pair? e.g. is [1, 2, 2, 2, 1] a valid input, being a pair of 1s, a pair of 2s and an unpaired 2?
Assuming the array isn't sorted, here's one solution, expressed in pseudocode, which runs in O(N) time and requires at most around half the storage space again of the original array.
SEEN = []
for N in ARRAY:
if N in SEEN:
remove N from SEEN
else:
add N to SEEN
if size of SEEN != 1:
error - ARRAY doesn't contain exactly 1 un-paired value
else:
answer = SEEN[0]
Here's a sample implementation using an NSMutableDictionary to store seen values, assuming that the source array is a plain C array.
#import <Foundation/Foundation.h>
int main(int argc, char argv[]) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
int array[9] = {3, 4, 5, 6, 7, 6, 5, 4, 3};
NSMutableDictionary *d = [NSMutableDictionary dictionaryWithCapacity:16];
for (int i = 0; i < sizeof(array)/sizeof(int); i++) {
NSNumber *num = [NSNumber numberWithInt:array[i]];
if ([d objectForKey:num]) {
[d removeObjectForKey:num];
} else {
[d setObject:[NSNull null] forKey:num];
}
}
if ([d count] == 1) {
NSLog(#"Unpaired number: %i", [[[d keyEnumerator] nextObject] intValue]);
} else {
NSLog(#"Error: Expected 1 unpaired number, found %u", [d count]);
}
[pool release];
return 1;
}
And here it is running:
$ gcc -lobjc -framework Foundation -std=c99 demo.m ; ./a.out
2010-12-25 11:23:21.426 a.out[17544:903] Unpaired number: 7