LINQ, um den nächstliegenden Wert zu erhalten?

Habe ich eine Liste, MyStuff hat eine Eigenschaft vom Typ Float.

Gibt es Objekte mit Eigenschaftswerten von 10,20,22,30.

Schreiben brauche ich eine Abfrage, die Objekte erkennt, die am nächsten an 21, Sie würde in diesem Fall finden die 20-und 22-Objekt. Dann muss ich schreiben, eine, die findet das Objekt schließt an 21, ohne über, und würde es wieder das Objekt mit einem Wert von 20.

Habe ich keine Ahnung wo/wie anfangen mit diesem. Hilfe?

Dank.

Update - wow gibt es so viele geniale Antworten hier. Danke! Ich weiß nicht, was man zu Folgen, so werde ich versuchen Sie alle. Eine Sache, die macht es vielleicht mehr (oder weniger) interessant ist, dass die gleiche Abfrage für LINQ-to-SQL-Entitäten, so dass möglicherweise die Antwort geerntet aus dem MS Linq-Foren funktionieren am besten? Weiß nicht.

InformationsquelleAutor der Frage Snowy | 2010-09-16

  1. 20

    Hier ist eine Lösung, die erfüllt, dass die zweite Abfrage in linearer Zeit:

    var pivot = 21f;
var closestBelow = pivot - numbers.Where(n => n <= pivot)
                                  .Min(n => pivot - n);

    (Editiert von 'oben' nach 'unten' nach Klärung)

    Als für die erste query, es wäre das einfachste zu verwenden MoreLinq's MinBy Erweiterung:

    var closest = numbers.MinBy(n => Math.Abs(pivot - n));

    Es ist auch möglich, um es in der standard-LINQ-in der linearen Zeit, aber mit 2 geht von der Quelle:

    var minDistance = numbers.Min(n => Math.Abs(pivot - n));
var closest = numbers.First(n => Math.Abs(pivot - n) == minDistance);

    Wenn Effizienz ist nicht ein Problem, so Sortieren Sie die Reihenfolge und setze den ersten Wert in O(n * log n) wie andere schon gepostet haben.

    InformationsquelleAutor der Antwort Ani

  2. 22

    Versuchen, diese zu Sortieren, indem der absolute Wert der Differenz zwischen der Anzahl und 21 und dann nehmen Sie das erste Element:

    float closest = MyStuff
    .Select (n => new { n, distance = Math.Abs (n - 21) })
    .OrderBy (p => p.distance)
    .First().n;

    Oder verkürzen Sie es nach @Yuriy Faktorovich ' s Kommentar:

    float closest = MyStuff
    .OrderBy(n => Math.Abs(n - 21))
    .First();

    InformationsquelleAutor der Antwort amurra

  3. 6

    Basierend auf dieser Beitrag auf der Microsoft Linq-Foren:

    var numbers = new List<float> { 10f, 20f, 22f, 30f };
var target = 21f;

//gets single number which is closest
var closest = numbers.Select( n => new { n, distance = Math.Abs( n - target ) } )
  .OrderBy( p => p.distance )
  .First().n;

//get two closest
var take = 2;
var closests = numbers.Select( n => new { n, distance = Math.Abs( n - target ) } )
  .OrderBy( p => p.distance )
  .Select( p => p.n )
  .Take( take );       

//gets any that are within x of target
var within = 1;
var withins = numbers.Select( n => new { n, distance = Math.Abs( n - target ) } )
  .Where( p => p.distance <= within )
  .Select( p => p.n );

    InformationsquelleAutor der Antwort nrkn

  4. 3
    List<float> numbers = new List<float>() { 10f, 20f, 22f, 30f };
float pivot = 21f;
var result = numbers.Where(x => x >= pivot).OrderBy(x => x).FirstOrDefault();

    ODER

    var result = (from n in numbers
              where n>=pivot
              orderby n
              select n).FirstOrDefault();

    und hier kommt eine Erweiterung-Methode:

    public static T Closest<T,TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector, TKey pivot) where TKey : IComparable<TKey>
{
    return source.Where(x => pivot.CompareTo(keySelector(x)) <= 0).OrderBy(keySelector).FirstOrDefault();
}

    Verwendung:

    var result = numbers.Closest(n => n, pivot);

    InformationsquelleAutor der Antwort Danny Chen

Schreibe einen Kommentar