Question

ok, this should be interesting.

lets assume i have the following code:

in this example, the first available number would be 2.

List<long> myList = new List<long>(){0,1,10,3};

in this example, the first available number would be ‘4’.

List<long> myList = new List<long>(){0,1,2,3};

any ideas?

Answer 1

So by “available” you mean “the lowest non-negative number which doesn’t already exist in the list”?

I’d be tempted to write something like:

HashSet<long> existing = new HashSet<long>(list);
for (long x = 0; x < long.MaxValue; x++)
{
    if (!existing.Contains(x))
    {
        return x;
    }
}
throw new InvalidOperationException("Somehow the list is enormous...");

EDIT: Alternatively, you could order the list and then find the first value where the index isn’t the same as the value…

var ordered = list.OrderBy(x => x);
var differences = ordered.Select((value, index) => new { value, index })
                         .Where(pair => pair.value != pair.index)
                         .Select(pair => (int?) pair.index);
var firstDifference = differences.FirstOrDefault();
long nextAvailable = firstDifference ?? list.Count;

The last line is to take care of the situation where the list is contiguous from 0. Another alternative would be:

var nextAvailable = list.Concat(new[] { long.MaxValue })
                        .OrderBy(x => x)
                        .Select((value, index) => new { value, index })
                        .Where(pair => pair.value != pair.index)
                        .Select(pair => pair.index)
                        .First();

This should be fine so long as the list doesn’t contain long.MaxValue + 1 elements, which it can’t in current versions of .NET. (That’s a lot of memory…) To be honest, this will already have problems when it goes beyond int.MaxValue elements due to the Select part taking an int index…