Code Shortest pour calculer la liste min/max dans .NET

Question

Je voudrais quelque chose comme

int minIndex = list.FindMin(delegate (MyClass a, MyClass b) {returns a.CompareTo(b);}); 

Est-il possible de le faire builtin dans .NET?

Answer 1

Essayez de regarder ceux-ci:

Min

Max

Tant que met en œuvre votre classe IComparable, tout ce que vous avez à faire est:

List<MyClass> list = new List(); 
//add whatever you need to add 

MyClass min = list.Min(); 
MyClass max = list.Max(); 

Answer 2

LINQ vous avez la Min() et Max() fonctions.

Vous pouvez faire list.AsQueryable().Min();

Answer 3

Vous notez que: « Je suis toujours en 2 » - vous pourriez donc vouloir regarder LINQBridge. Ceci est en fait destiné à C# 3.0 et .NET 2.0, mais vous devriez être en mesure de l'utiliser avec C# 2.0 et .NET 2.0 - juste vous devez utiliser la longue main:

MyClass min = Enumerable.Min(list), 
     max = Enumerable.Max(list); 

Bien sûr, ce sera plus facile si vous pouvez passer en C# 3.0 (en ciblant toujours .NET 2.0).

Et si LINQBridge n'est pas une option, vous pouvez l'implémenter:

static void Main() 
{ 
    int[] data = { 3, 5, 1, 5, 5 }; 
    int min = Min(data); 
} 
static T Min<T>(IEnumerable<T> values) 
{ 
    return Min<T>(values, Comparer<T>.Default); 
} 
static T Min<T>(IEnumerable<T> values, IComparer<T> comparer) 
{ 
    bool first = true; 
    T result = default(T); 
    foreach(T value in values) { 
     if(first) 
     { 
      result = value; 
      first = false; 
     } 
     else 
     { 
      if(comparer.Compare(result, value) > 0) 
      { 
       result = value; 
      } 
     } 
    } 
    return result; 
} 

Answer 4

Eh bien, si vous ne pouvez pas utiliser .NET 3.5, vous pouvez toujours trier la liste, puis retourner la liste [0 ] Ce n'est peut-être pas le moyen le plus rapide, mais c'est probablement le code le plus court, surtout si votre classe implémente déjà IComparable.

List<SomeClass> list = new List<SomeClass>(); 
// populate the list 
// assume that SomeClass implements IComparable 
list.Sort(); 
return list[0];    // min, or 
return list[list.Count - 1]; // max 

Cela suppose aussi, bien sûr, qu'il n'a pas d'importance quel élément vous retourner si vous avez plusieurs éléments qui sont le minimum ou maximum.

Si votre classe ne met pas en œuvre IComparable, vous pouvez passer à un délégué anonyme, quelque chose comme ceci:

list.Sort(delegate(SomeClass x, SomeClass y) { return string.Compare(x.Name, y.Name); });