finding closest value in an array

EDIT: Have adjusted the queries below to convert to using long arithmetic, so that we avoid overflow issues.

I would probably use MoreLINQ's MinBy method:

var nearest = array.MinBy(x => Math.Abs((long) x - targetNumber));

Or you could just use:

var nearest = array.OrderBy(x => Math.Abs((long) x - targetNumber)).First();

... but that will sort the whole collection, which you really don't need. It won't make much difference for a small array, admittedly... but it just doesn't feel quite right, compared with describing what you're actually trying to do: find the element with the minimum value according to some function.

Note that both of these will fail if the array is empty, so you should check for that first.

If you're using .Net 3.5 or above LINQ can help you here:

var closest = array.OrderBy(v => Math.Abs((long)v - targetNumber)).First();

Alternatively, you could write your own extension method:

public static int ClosestTo(this IEnumerable<int> collection, int target){    // NB Method will return int.MaxValue for a sequence containing no elements.    // Apply any defensive coding here as necessary.    var closest = int.MaxValue;    var minDifference = int.MaxValue;    foreach (var element in collection)    {        var difference = Math.Abs((long)element - target);        if (minDifference > difference)        {            minDifference = (int)difference;            closest = element;        }    }    return closest;}

Useable like so:

var closest = array.ClosestTo(targetNumber);

Both Jon and Rich gave great answers with MinBy and ClosestTo. But I would never recommend using OrderBy if your intent is to find a single element. It's far too inefficient for those kinds of tasks. It's simply the wrong tool for the job.

Here's a technique that performs marginally better than MinBy, is already included in the .NET framework, but less elegant than MinBy: Aggregate

var nearest = array.Aggregate((current, next) => Math.Abs((long)current - targetNumber) < Math.Abs((long)next - targetNumber) ? current : next);

As I said, not as elegant as Jon's method, but viable.

Performance on my computer:

1. For(each) Loops = fastest
2. Aggregate = 2.5x slower than loops
3. MinBy = 3.5x slower than loops
4. OrderBy = 12x slower than loops