LINQ pour Obtenir la Valeur la plus Proche?

J'ai une Liste, Leur a une propriété de Type Float.

Il y a des objets avec des valeurs de propriété de 10,20,22,30.

J'ai besoin d'écrire une requête qui trouve les objets les plus proches à 21, dans ce cas, il trouverait le 20 et 22 de l'objet. Ensuite, j'ai besoin d'en écrire un qui trouve l'objet ferme de 21 sans le dépasser, et il serait de retour de l'objet avec une valeur de 20.

Je n'ai aucune idée de l'endroit où/comment commencer avec celui-ci. De l'aide?

Grâce.

La mise a jour de wow il y en a tellement génial réponses ici. Merci! Je ne sais pas lequel suivre donc je vais toutes les essayer. Une chose qui pourrait le rendre plus (ou moins) intéressant, c'est que la même requête devra s'appliquer à LINQ-to-SQL entités, peut-être que la réponse récoltées à partir de la MS Linq forums de travail sera le meilleur? Ne sais pas.

  • Er, 22 est plus de 21 ans.... ne vaudrait-il trouver 20?
  • Oui je voulais dire 20, désolé pour le screwup.
InformationsquelleAutor Snowy | 2010-09-16
  1. 22

    Voici une solution qui satisfait à la deuxième requête en temps linéaire:

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

    (Édité à partir "d'en haut" à "en dessous" après clarification)

    Comme pour la première requête, il serait plus simple d'utiliser MoreLinq's MinBy extension:

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

    Il est également possible de le faire dans la norme LINQ dans le temps linéaire, mais avec 2 passes de la source:

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

    Si l'efficacité n'est pas un problème, vous pouvez trier l'ordre et de sélectionner la première valeur dans O(n * log n) comme d'autres l'ont publié.

    • que diriez-vous si nous avons besoin de 22 à la place?
    InformationsquelleAutor Ani
  2. 24

    Essayer de les trier par la valeur absolue de la différence entre le nombre et le 21, puis prendre le premier élément:

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

    Ou raccourcir selon @Yuriy Faktorovich commentaire:

    float closest = MyStuff
    .OrderBy(n => Math.Abs(n - 21))
    .First();
    • Vous pourrait raccourcir la suppression Select et de mettre de la distance dans le OrderBy
    • Si MyStuff est trié, ce qui pourrait être fait en O(n), qui OrderBy ne l'est pas. Quelque chose à considérer si votre liste est déjà triée et non négligeable dans la taille (ou ce qui pourrait s'exécuter dans une boucle).
    InformationsquelleAutor amurra
  3. 7

    Basé sur ce post à Microsoft Linq forums:

    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 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();

    OU

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

    et voici une méthode d'extension:

    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();
}

    Utilisation:

    var result = numbers.Closest(n => n, pivot);
    • Vous devriez mettre la OrderBy après le Where, afin de ne pas avoir de sorte que de nombreux éléments.
    • Merci pour votre suggestion. J'ai modifié le code.
    InformationsquelleAutor Cheng Chen