C# -Arrays Minimalwert in einem bestimmten Bereich

Question

Jeder! Wie kann ich einen minimalen Wert eines int-Arrays in einem bestimmten Bereich in C# erhalten? Zum Beispiel: int [] Array = neu int {1,2,3,4,5,6,7,8,76,45}; Und ich möchte einen minimalen Wert zwischen 3-und 8-ten Element erhalten. Vielleicht ist es möglich, über LINQ-Abfragen zu erhalten?

Answer 1

array.Skip(2).Take(5).Min(); 

Answer 2

int min = array.Where((value, index) => index >= 2 && index <= 7).Min(); 

---

EDIT

Eigentlich über dem Ansatz ist sehr ineffizient, weil es die ganze Sequenz aufzählt, auch wenn wir in den Punkten mit einem Index von mehr als 7. Eine bessere Lösung nicht interessiert sind wäre TakeWhile zu verwenden:

int min = array.TakeWhile((value, index) => index <= 7).Skip(2).Min(); 

Leider ist es nicht sehr gut lesbar ... Die beste Option, es schöner zu machen, ist wahrscheinlich eine benutzerdefinierte Erweiterung Methode, wie sho zu erstellen wn in Jons Antwort.

Answer 3

int[] arr = {0,1,2,3,4,5,6,7,8}; 
int start = 3; 
int end = 8; 
int min = arr.Skip(start - 1).Take(end - start).Min(); 

Answer 4

array.Skip(3).Take(4).Min(); 

Answer 5

nur eine weitere Option hinzuzufügen:

int start = 3; 
int end = 8; 
var min = Enumerable.Range(start - 1,end - start).Select(idx => array[idx]).Min(); 

AFAIK ist dies "theorically" schneller, wenn Sie einen Bereich in der Nähe des Endes der einen nehmen, und Ihr Array ist wirklich sehr lang.

Das ist, weil (wieder AFAIK) Skip() berücksichtigt nicht, dass ein Array ist (d. H. Zufällig in O (1) zugegriffen werden kann) und zählt es trotzdem auf.

Answer 6

Ich denke, ich kann meine Tuppence dazu hinzufügen.

public static IEnumerable<T> WithIndexBetween<T>(this IEnumerable<T> source, 
    int startInclusive, int endExclusive) 
{ 
    // The two values can be the same, yielding no results... but they must 
    // indicate a reasonable range 
    if (endExclusive < startInclusive) 
    { 
     throw new ArgumentOutOfRangeException("endExclusive"); 
    } 
    return source.Skip(startInclusive).Take(endExclusive - startInclusive); 
} 

Dann: Als Jason auf die Tatsache, Objekte, die wir sagen, wie viele wir das Überspringen eher als Ende Index, können wir eine einfache Erweiterung Methode hinzufügen

int min = array.WithIndexBetween(2, 7).Min(); 

die Verlängerung einstellen Methodenname nach Geschmack. (Naming ist hart, und ich werde nicht im Alter mit einem schönen man hier :)

Answer 7

persönlich kommen verbringen, würde ich das vorziehen:

public static class ArrayExtensions { 
    public static bool ArrayAndIndexesAreValid(
     T[] array, 
     int startInclusive, 
     int endExclusive 
    ) { 
    return array != null && 
      array.Length > 0 && 
      startInclusive >= 0 && startInclusive < array.Length && 
      endExclusive >= 1 && endExclusive <= array.Length && 
      startInclusive < endExclusive; 
    } 
    public static IEnumerable<T> Slice<T>(
     this T[] array, 
     int startInclusive, 
     int endExclusive 
    ) { 
     Contract.Requires<ArgumentException>(ArrayAndIndexesAreValid(
      array, 
      startInclusive, 
      endExclusive) 
     ); 
     for (int index = startInclusive; index < endExclusive; index++) { 
      yield return array[index]; 
     } 
    } 
    public static T MinimumInIndexRange<T>(
     this T[] array, 
     int startInclusive, 
     int endExclusive 
    ) where T : IComparable { 
     Contract.Requires<ArgumentException>(ArrayAndIndexesAreValid(
      array, 
      startInclusive, 
      endExclusive) 
     ); 
     return array.Slice(startInclusive, endExclusive).Min(); 
    } 

    public static T MaximumInIndexRange<T>(
     this T[] array, 
     int startInclusive, 
     int endExclusive 
    ) where T : IComparable { 
     Contract.Requires<ArgumentException>(ArrayAndIndexesAreValid(
      array, 
      startInclusive, 
      endExclusive) 
     ); 
     return array.Slice(startInclusive, endExclusive).Max(); 
    } 
}