int missingNumber(IEnumerable myCol)
{
return (myCol.Count() + 1) * myCol.Count() / 2 – myCol.Sum();
}

int missingNumber(IEnumerable list)
{
var k = new List(list);
k.Sort();
return k.Last() != k.Count() + 1 ? k.Count() + 1 : k.Where((elem, index) => (index + 1) != elem).First() – 1;
}

/**
* @param sequence : Sequence of length N Contains integers 1 to (N + 1)
* with one number missing. The array is unsorted.
*
* @return The missing number
*
* Algorithm: In this case we do not calculate any integer sum at all. We do cumulative
* XOR of all elements with index. Please note that N XOR N == 0. So all elements eventually
* cancel all index and last number standing after cumulative XOR is the missing number.
* For example consider the sequence [1] [2] [3] [?].
* So 1 XOR 1 == 0, 2 XOR 2 == 0, 3 XOR 3 == 0, so last number standing will be 4.
* It does not matter if numbers are permuted instead of being sorted.
*/

public static int method_3(int [] intSeq)
{
int missingNum = intSeq.length + 1;
for (int i = 0; i < intSeq.length; ++i)
{
missingNum ^= ((i+1) ^ intSeq[i]);
}

return missingNum;
}

Once the list is sorted it’s easy to find the missing number.

null = 0

def findMissing( sequence ):

	# Pad the list to fit the missing value
	sequence.append( null ) 

	# Sort the list
	sequenceSort( sequence )

	# Find 'null' index and hence missing value
	return sequence.index( null ) + 1

# Sorts a sequence (in linear time and constant space)
# Assumes the list is large enough to fit all values
def sequenceSort( sequence ):
	index = 0
	while( index < len(sequence) ):

		# Pull out a value and set its spot to 'null'
		value = sequence[index]
		sequence[index] = null 

		# Insert the value into the list.
		# Keep inserting the evicted values till we fill the slot we first got
		# the value from.
		while( True ):
			value = insert( value, sequence )
			if( (value == sequence[index]) or (value == null) ):
				break	

		index = index + 1

	return sequence 

# Inserts a value into the list, returning the value
# that used to live at that index.
def insert( value, sequence ):
	index = value - 1
	evicted = sequence[index]
	sequence[index] = value
	return evicted

I’d be interested to see what this looks like in F#. Since my solution depends on the mutability of the original list, it’s hard to see how you could do it in a nice, clean, functional way.

public static int method_1(int [] sequence)
{
// this can overflow
int allSum = ((sequence.length + 1) * (sequence.length + 2)) / 2;

int seqSum = 0;
for (int i = 0; i < sequence.length; ++i)
{
// this can overflow
seqSum += sequence[i];
}

return allSum - seqSum;
}

/**
* @param sequence : Sequence of length N Contains integers 1 to (N + 1)
* with one number missing. The array is unsorted.
*
* @return The missing number
*/
public static int method_2(int [] sequence)
{
int missingNum = sequence.length + 1;
for (int i = 0; i < sequence.length; ++i)
{
missingNum += ((i+1) - sequence[i]);
}

return missingNum;
}

I’ll give it a go when I get a little free time.

By the way, is there a solution that uses O(1) memory and has O(n) computational complexity?

If you read through the comments on the post for this question you’ll see that Jesus DeLaTorre and Heiko Hatzfeld have made similar observations. I accept it’s a very pedantic point though.

One way to do it with truly O(1) memory usage would be to sort the original array using an in-place sort like quicksort. Once the list was in order it would then be trivial to step through it and find the missing number.

Of course, the computational complexity of my solution is O(n^2), which is far less efficient than yours.

According to Michael’s comment, I understood that I did correctly, and in addition my solution was accepted by the authors.