C # réseaux valeur minimale dans la gamme spécifique

Question

Tout le monde! Comment puis-je obtenir une valeur minimale d'un tableau int dans la gamme spécifique en C #? Par exemple: int [] Array = new int {1,2,3,4,5,6,7,8,76,45}; Et je veux obtenir une valeur minimale de 3-ème et 8 ème élément. Peut-être qu'il est possible d'obtenir par le biais de requêtes LINQ?

Answer 1

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

Answer 2

Je me dis que je peux aussi bien ajouter mon tuppence à ce sujet. Comme objets Jason au fait que nous disons combien nous sauter plutôt que l'indice final, nous pouvons ajouter une méthode simple d'extension:

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

Alors:

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

Régler le nom de la méthode d'extension au goût. (Naming est difficile, et je ne vais pas passer les âges à venir avec une belle personne ici:)

Answer 3

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

---

EDIT

En fait, l'approche est au-dessus tout à fait inefficace, car elle énumère toute la séquence, même si nous ne sommes pas intéressés par des articles avec un indice supérieur à 7. Une meilleure solution serait d'utiliser TakeWhile:

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

Malheureusement, il est peu lisible ... La meilleure option pour le rendre plus agréable est sans doute de créer une méthode d'extension personnalisée, comme le montre la réponse de Jon.

Answer 4

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 5

Juste pour ajouter une autre option:

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

AFAIK, ceci est « théoriquement » plus rapidement si vous devez prendre une gamme proche de la fin de l'un, et votre choix est vraiment très longue.

En effet, (encore une fois AFAIK) Skip() ne prend pas en compte est un tableau (à savoir est accessible au hasard en O (1)) et de toute façon énumère.

Answer 6

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

Answer 7

Personnellement, je préfère ceci:

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