Comment prendre tous, mais le dernier élément dans une séquence à l'aide de LINQ?

Disons que j'ai une séquence.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();
//sequence now contains: 0,1,2,3,...,999999,1000000

L'obtention de la séquence n'est pas bon marché et est généré dynamiquement, et je veux parcourir une fois seulement.

Je veux obtenir 0 - 999999 (c'est à dire tout sauf le dernier élément)

Je reconnais que je pourrais faire quelque chose comme:

sequence.Take(sequence.Count() - 1);

mais que les résultats dans les deux énumérations sur le gros de la séquence.

Est-il LINQ construction qui me permet de le faire:

sequence.TakeAllButTheLastElement();

Vous avez le choix entre une O(2n) en temps O(comte) de l'espace de l'efficacité de l'algorithme, lorsque celui-ci a également besoin de déplacer des éléments dans un tableau interne.
Dario, pourriez-vous nous expliquer pour quelqu'un qui n'est pas que dans les grandes o-notation?
Voir également cette double question: stackoverflow.com/q/4166493/240733
J'ai fini avec la mise en cache par la conversion de la collecte à la Liste, puis en appelant sequenceList.RemoveAt(sequence.Count - 1);. Dans mon cas, il est acceptable parce que, après tout LINQ manipulations je dois le convertir en tableau ou IReadOnlyCollection de toute façon. Je me demande ce qui est votre cas où vous ne l'envisage même pas de mise en cache? Comme je peux le voir, même approuvé réponse fait un peu de mise en cache si simple de conversion de List est beaucoup plus facile et plus rapide à mon avis.

InformationsquelleAutor Mike | 2009-11-22

.net c#linq

Je ne sais pas Linq solution - Mais vous pouvez facilement le code de l'algorithme par vous-même à l'aide de générateurs (taux de retour).

public static IEnumerable<T> TakeAllButLast<T>(this IEnumerable<T> source) {
    var it = source.GetEnumerator();
    bool hasRemainingItems = false;
    bool isFirst = true;
    T item = default(T);

    do {
        hasRemainingItems = it.MoveNext();
        if (hasRemainingItems) {
            if (!isFirst) yield return item;
            item = it.Current;
            isFirst = false;
        }
    } while (hasRemainingItems);
}

static void Main(string[] args) {
    var Seq = Enumerable.Range(1, 10);

    Console.WriteLine(string.Join(", ", Seq.Select(x => x.ToString()).ToArray()));
    Console.WriteLine(string.Join(", ", Seq.TakeAllButLast().Select(x => x.ToString()).ToArray()));
}

Ou comme une solution généralisée de jeter les n derniers éléments (en utilisant une file d'attente comme suggéré dans les commentaires):

public static IEnumerable<T> SkipLastN<T>(this IEnumerable<T> source, int n) {
    var  it = source.GetEnumerator();
    bool hasRemainingItems = false;
    var  cache = new Queue<T>(n + 1);

    do {
        if (hasRemainingItems = it.MoveNext()) {
            cache.Enqueue(it.Current);
            if (cache.Count > n)
                yield return cache.Dequeue();
        }
    } while (hasRemainingItems);
}

static void Main(string[] args) {
    var Seq = Enumerable.Range(1, 4);

    Console.WriteLine(string.Join(", ", Seq.Select(x => x.ToString()).ToArray()));
    Console.WriteLine(string.Join(", ", Seq.SkipLastN(3).Select(x => x.ToString()).ToArray()));
}

Maintenant, pouvez-vous généraliser à prendre toutes mais au final, vous n?
Nice. Une petite erreur; taille de file d'attente doit être initialisé à n + 1, puisque c'est la taille maximale de la file d'attente.
ReSharper ne comprends pas votre code (affectation dans l'expression conditionnelle) mais j'ai un peu l'aime +1
Gardez à l'esprit que IEnumerator<T> est IDisposable.

InformationsquelleAutor Dario

43

Comme une alternative à la création de votre propre méthode et dans un cas, les éléments d'ordre n'est pas important, la prochaine sera d'oeuvre:
```
var result = sequence.Reverse().Skip(1);
```
- Notez que cela nécessite que vous disposiez de suffisamment de mémoire pour stocker la totalité de la séquence, et bien sûr il ENCORE parcourt la totalité de la séquence, une fois pour construire l'inversion de l'ordre et une fois pour le parcourir. Assez bien c'est pire que le Comte solution peu importe comment vous le trancher; c'est plus lente ET prend beaucoup plus de mémoire.
- Je ne sais pas comment le "Reverse" méthode de travail, donc je ne suis pas sûr de la quantité de mémoire à utiliser. Mais je suis d'accord sur deux itérations. Cette méthode ne doit pas être utilisé sur de grandes collections ou si la performance est importante.
- Eh bien, comment serait - vous mettre en œuvre le sens Inverse? Pouvez-vous trouver un moyen en général pour le faire sans stocker la totalité de la séquence?
- Ne vois rien de mieux que O(n) de l'espace. Assurez-vous que la meilleure solution de méthode personnalisée pour ce but.
- Je l'aime, et il est conforme aux critères de pas de la génération de la séquence deux fois.
- et en plus, vous aurez également besoin d'inverser la séquence entière de nouveau à la garder comme elle est equence.Reverse().Skip(1).Reverse() pas une bonne solution
InformationsquelleAutor Kamarey
42

Parce que je ne suis pas un fan de manière explicite à l'aide d'un Enumerator, voici une alternative. Notez que le wrapper méthodes sont nécessaires pour laisser arguments invalides jeter début, plutôt que de s'en remettre les chèques jusqu'à ce que la séquence est dénombrés.
```
public static IEnumerable<T> DropLast<T>(this IEnumerable<T> source)
{
    if (source == null)
        throw new ArgumentNullException("source");

    return InternalDropLast(source);
}

private static IEnumerable<T> InternalDropLast<T>(IEnumerable<T> source)
{
    T buffer = default(T);
    bool buffered = false;

    foreach (T x in source)
    {
        if (buffered)
            yield return buffer;

        buffer = x;
        buffered = true;
    }
}
```
Comme par Eric Lippert la suggestion, il se généralise à n éléments:
```
public static IEnumerable<T> DropLast<T>(this IEnumerable<T> source, int n)
{
    if (source == null)
        throw new ArgumentNullException("source");

    if (n < 0)
        throw new ArgumentOutOfRangeException("n", 
            "Argument n should be non-negative.");

    return InternalDropLast(source, n);
}

private static IEnumerable<T> InternalDropLast<T>(IEnumerable<T> source, int n)
{
    Queue<T> buffer = new Queue<T>(n + 1);

    foreach (T x in source)
    {
        buffer.Enqueue(x);

        if (buffer.Count == n + 1)
            yield return buffer.Dequeue();
    }
}
```
Où j'ai maintenant tampon avant rendement au lieu de après rendement, de sorte que le n == 0 cas n'a pas besoin d'un traitement spécial.
- Dans le premier exemple, il serait probablement jamais si légèrement plus rapide pour définir buffered=false dans une clause else avant d'assigner buffer. La condition est déjà vérifié tout de même, mais cela permettrait d'éviter de manière redondante réglage buffered chaque passage dans la boucle.
- Quelqu'un peut me dire les avantages/inconvénients de ce rapport à la réponse choisie?
- Quel est l'avantage d'avoir la mise en œuvre d'une méthode distincte qui n'a pas la saisie de chèques? Aussi, je venais de déposer la seule mise en œuvre et de donner des multiples de la mise en œuvre d'une valeur par défaut.
- Avec le chèque dans une autre méthode, vous pouvez réellement obtenir la validation du moment où vous appelez DropLast. Sinon, la validation se produit uniquement lorsque vous énumérer la séquence (sur le premier appel à MoveNext sur la IEnumerator). Pas une chose amusante à déboguer quand il pourrait y avoir une quantité arbitraire de code entre la génération de la IEnumerable et en fait l'énumération d'elle. Aujourd'hui, j'écrirais InternalDropLast comme une fonction interne de DropLast, mais cette fonctionnalité n'existe pas en C# quand j'ai écrit ce code il y a 9 ans.
InformationsquelleAutor Joren
13

Pour ceux qui utilisent une version plus récente de .net, le Enumerable.SkipLast(IEnumerable<TSource>, Int32) méthode a été ajouté dans .NET Core 2.0
```
var sequence = GetSequence();

var allExceptLast = sequence.SkipLast(1);
```
Source: https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.skiplast
- Cela existe aussi dans MoreLinq
InformationsquelleAutor Justin Lessard
12

Rien dans la BCL (ou MoreLinq je crois), mais vous pouvez créer votre propre méthode d'extension.
```
public static IEnumerable<T> TakeAllButLast<T>(this IEnumerable<T> source)
{
    using (var enumerator = source.GetEnumerator())
        bool first = true;
        T prev;
        while(enumerator.MoveNext())
        {
            if (!first)
                yield return prev;
            first = false;
            prev = enumerator.Current;
        }
    }
}
```
- Ce code ne fonctionne pas... devrait probablement être if (!first) et tirez first = false de la si.
- Ce code est hors tension. La logique semble être de retour le non initialisée prev dans la première itération, et boucle pour toujours après que".
- Le code semble avoir "compilation" d'erreur. Peut-être que vous souhaitez corriger. Mais oui, on peut écrire un répéteur qui parcourt une fois et retourne tous, mais le dernier élément.
- Vous avez absolument raison - j'ai écrit cela dans une véritable ruée! Fixe maintenant. @Amby: Euh, pas sûr de ce que le compilateur que vous utilisez. Je n'avais rien de la sorte. 😛
- Gardez à l'esprit que IEnumerator<T> est IDisposable.
- Oups, oui. J'ai ajouté un using déclaration maintenant.
InformationsquelleAutor Noldorin

Il serait utile si .NET Framework a été livré avec une extension de la méthode de ce genre.

public static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source, int count)
{
    var enumerator = source.GetEnumerator();
    var queue = new Queue<T>(count + 1);

    while (true)
    {
        if (!enumerator.MoveNext())
            break;
        queue.Enqueue(enumerator.Current);
        if (queue.Count > count)
            yield return queue.Dequeue();
    }
}

Gardez à l'esprit que IEnumerator<T> est IDisposable.

InformationsquelleAutor Alex Aza

si vous n'avez pas le temps pour le déploiement de votre propre poste, voici un moyen plus rapide:

var next = sequence.First();
sequence.Skip(1)
    .Select(s => 
    { 
        var selected = next;
        next = s;
        return selected;
    });

InformationsquelleAutor SmallBizGuy

Une légère expansion sur Joren la solution élégante:

public static IEnumerable<T> Shrink<T>(this IEnumerable<T> source, int left, int right)
{
    int i = 0;
    var buffer = new Queue<T>(right + 1);

    foreach (T x in source)
    {
        if (i >= left) //Read past left many elements at the start
        {
            buffer.Enqueue(x);
            if (buffer.Count > right) //Build a buffer to drop right many elements at the end
                yield return buffer.Dequeue();    
        } 
        else i++;
    }
}
public static IEnumerable<T> WithoutLast<T>(this IEnumerable<T> source, int n = 1)
{
    return source.Shrink(0, n);
}
public static IEnumerable<T> WithoutFirst<T>(this IEnumerable<T> source, int n = 1)
{
    return source.Shrink(n, 0);
}

Où rétrécir implémente un simple comptage de l'avant de supprimer la première left de nombreux éléments et la même jeté tampon de laisser tomber la dernière right de nombreux éléments.

InformationsquelleAutor silasdavis

3

Si vous pouvez obtenir le Count ou Length d'une énumération, qui, dans la plupart des cas, vous peut, alors il suffit Take(n - 1)

Exemple avec des tableaux
```
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int[] sub = arr.Take(arr.Length - 1).ToArray();
```
Exemple avec IEnumerable<T>
```
IEnumerable<int> enu = Enumerable.Range(1, 100);
IEnumerable<int> sub = enu.Take(enu.Count() - 1);
```
- La question est à propos IEnumerables et votre solution est-ce que l'OP est d'essayer d'éviter. Votre code a un impact sur les performances.
InformationsquelleAutor series0ne

Une légère variation sur la accepté de répondre, ce qui (à mon goût) est un peu plus simple:

    public static IEnumerable<T> AllButLast<T>(this IEnumerable<T> enumerable, int n = 1)
    {
        //for efficiency, handle degenerate n == 0 case separately 
        if (n == 0)
        {
            foreach (var item in enumerable)
                yield return item;
            yield break;
        }

        var queue = new Queue<T>(n);
        foreach (var item in enumerable)
        {
            if (queue.Count == n)
                yield return queue.Dequeue();

            queue.Enqueue(item);
        }
    }

InformationsquelleAutor jr76

1

Pourquoi ne pas simplement .ToList<type>() sur la séquence, puis nombre d'appels et de prendre comme vous l'avez fait à l'origine..mais depuis il a été tiré dans une liste, il ne faut pas faire, cher énumération deux fois. Droit?

InformationsquelleAutor Brady Moritz

La solution que j'utilise pour ce problème est un peu plus élaboré.

Mon util statique classe contient une méthode d'extension MarkEnd qui convertit les T-éléments dans EndMarkedItem<T>-éléments. Chaque élément est marqué avec un supplément de int, qui est soit 0; ou (dans le cas où on s'intéresse plus particulièrement au cours des 3 éléments) -3, -2, ou -1 pour les 3 derniers articles.

Cela pourrait être utile sur son propre, par exemple lorsque vous souhaitez créer une liste dans un simple foreachen boucle avec des virgules après chaque élément, sauf les 2 derniers, avec l'avant-dernier élément, puis par une conjonction de mots (comme “et” ou “ou”), et le dernier élément suivi d'un point.

Pour la génération de l'ensemble de la liste sans la dernière n éléments, la méthode d'extension ButLast simplement parcourt la EndMarkedItem<T>s, tandis que EndMark == 0.

Si vous ne spécifiez pas tailLength, seul le dernier élément est marqué (en MarkEnd()) ou abandonnées (en ButLast()).

Comme les autres solutions, cela fonctionne par mise en mémoire tampon.

using System;
using System.Collections.Generic;
using System.Linq;
namespace Adhemar.Util.Linq {
public struct EndMarkedItem<T> {
public T Item { get; private set; }
public int EndMark { get; private set; }
public EndMarkedItem(T item, int endMark) : this() {
Item = item;
EndMark = endMark;
}
}
public static class TailEnumerables {
public static IEnumerable<T> ButLast<T>(this IEnumerable<T> ts) {
return ts.ButLast(1);
}
public static IEnumerable<T> ButLast<T>(this IEnumerable<T> ts, int tailLength) {
return ts.MarkEnd(tailLength).TakeWhile(te => te.EndMark == 0).Select(te => te.Item);
}
public static IEnumerable<EndMarkedItem<T>> MarkEnd<T>(this IEnumerable<T> ts) {
return ts.MarkEnd(1);
}
public static IEnumerable<EndMarkedItem<T>> MarkEnd<T>(this IEnumerable<T> ts, int tailLength) {
if (tailLength < 0) {
throw new ArgumentOutOfRangeException("tailLength");
}
else if (tailLength == 0) {
foreach (var t in ts) {
yield return new EndMarkedItem<T>(t, 0);
}
}
else {
var buffer = new T[tailLength];
var index = -buffer.Length;
foreach (var t in ts) {
if (index < 0) {
buffer[buffer.Length + index] = t;
index++;
}
else {
yield return new EndMarkedItem<T>(buffer[index], 0);
buffer[index] = t;
index++;
if (index == buffer.Length) {
index = 0;
}
}
}
if (index >= 0) {
for (var i = index; i < buffer.Length; i++) {
yield return new EndMarkedItem<T>(buffer[i], i - buffer.Length - index);
}
for (var j = 0; j < index; j++) {
yield return new EndMarkedItem<T>(buffer[j], j - index);
}
}
else {
for (var k = 0; k < buffer.Length + index; k++) {
yield return new EndMarkedItem<T>(buffer[k], k - buffer.Length - index);
}
}
}    
}
}
}

InformationsquelleAutor Adhemar

    public static IEnumerable<T> NoLast<T> (this IEnumerable<T> items) {
if (items != null) {
var e = items.GetEnumerator();
if (e.MoveNext ()) {
T head = e.Current;
while (e.MoveNext ()) {
yield return head; ;
head = e.Current;
}
}
}
}

InformationsquelleAutor ddur

Je ne pense pas qu'il peut obtenir plus succincte que cette - aussi de s'assurer de Disposer de IEnumerator<T>:

public static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source)
{
using (var it = source.GetEnumerator())
{
if (it.MoveNext())
{
var item = it.Current;
while (it.MoveNext())
{
yield return item;
item = it.Current;
}
}
}
}

Edit: techniquement identique à cette réponse.

InformationsquelleAutor Robert Schmidt

Vous pourriez écrire:

var list = xyz.Select(x=>x.Id).ToList();
list.RemoveAt(list.Count - 1);

InformationsquelleAutor RoJaIt

C'est un général et à mon humble avis solution élégante qui va gérer tous les cas correctement:

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
public static void Main()
{
IEnumerable<int> r = Enumerable.Range(1, 20);
foreach (int i in r.AllButLast(3))
Console.WriteLine(i);
Console.ReadKey();
}
}
public static class LinqExt
{
public static IEnumerable<T> AllButLast<T>(this IEnumerable<T> enumerable, int n = 1)
{
using (IEnumerator<T> enumerator = enumerable.GetEnumerator())
{
Queue<T> queue = new Queue<T>(n);
for (int i = 0; i < n && enumerator.MoveNext(); i++)
queue.Enqueue(enumerator.Current);
while (enumerator.MoveNext())
{
queue.Enqueue(enumerator.Current);
yield return queue.Dequeue();
}
}
}
}

Gardez à l'esprit que IEnumerator<T> est IDisposable.

InformationsquelleAutor Tarik

-1

Mon traditionnel IEnumerable approche:

///<summary>
///Skips first element of an IEnumerable
///</summary>
///<typeparam name="U">Enumerable type</typeparam>
///<param name="models">The enumerable</param>
///<returns>IEnumerable of type skipping first element</returns>
private IEnumerable<U> SkipFirstEnumerable<U>(IEnumerable<U> models)
{
using (var e = models.GetEnumerator())
{
if (!e.MoveNext()) return;
for (;e.MoveNext();) yield return e.Current;
yield return e.Current;
}
}
///<summary>
///Skips last element of an IEnumerable
///</summary>
///<typeparam name="U">Enumerable type</typeparam>
///<param name="models">The enumerable</param>
///<returns>IEnumerable of type skipping last element</returns>
private IEnumerable<U> SkipLastEnumerable<U>(IEnumerable<U> models)
{
using (var e = models.GetEnumerator())
{
if (!e.MoveNext()) return;
yield return e.Current;
for (;e.MoveNext();) yield return e.Current;
}
}

Votre SkipLastEnumerable peut être traditionnel, mais est cassé. Le premier élément qu'elle renvoie est toujours pas défini U - même "modèles" a 1 élément. Dans ce dernier cas, je m'attends à un résultat vide.
Aussi, IEnumerator<T> est IDisposable.
Vrai/noté. Je vous remercie.

InformationsquelleAutor Chibueze Opata

-1

Un moyen simple serait de simplement convertir à une file d'attente et la file d'attente jusqu'à ce que le nombre d'articles que vous voulez sauter à gauche.
```
public static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source, int n)
{
var queue = new Queue<T>(source);
while (queue.Count() > n)
{
yield return queue.Dequeue();
}
}
```
- Il y a Prendre utilisés de prendre connu nombre d'éléments. Et la file d'attente pour assez grand énumérable est terrible.
InformationsquelleAutor John Stevens
-2

Pourrait être:
```
var allBuLast = sequence.TakeWhile(e => e != sequence.Last());
```
J'imagine que ça doit être comme de "Où", mais la préservation de l'ordre(?).
- C'est un moyen inefficace de le faire. Pour évaluer la séquence.Last() c'est de parcourir l'ensemble de la séquence, le faire pour chaque élément de la séquence. O(n^2) l'efficacité.
- Vous êtes de droite. Je ne sais pas ce que je pensais quand j'ai écrit ce XD. De toute façon, vous êtes sûr que la Dernière() va traverser la totalité de la séquence? Pour certaines implémentations de IEnumerable (comme un Tableau), ce qui devrait être O(1). Je n'ai pas vérifier la Liste de mise en œuvre, mais il pourrait aussi avoir un "inverse" de l'itérateur, à partir du dernier élément, qui prendraient en O(1) trop. Aussi, vous devez prendre en compte que O(n) = O(2n), au moins techniquement parlant. Par conséquent, si cette procédure n'est pas absolument critique pour vos applications de performance, je m'en tiendrais à la beaucoup plus claire de la séquence.Prendre(séquence.Count() - 1).Ce qui concerne les!
- Je ne suis pas d'accord avec toi camarade, de la séquence.Last() est O(1), de sorte qu'il n'est pas nécessaire de parcourir l'ensemble de la séquence. stackoverflow.com/a/1377895/812598
- c'est seulement O(1) si la séquence met en œuvre ICollection/IList ou est un Tableau. Toutes les autres séquences sont O(N). Dans ma question, je ne présume pas que l'un des O(1) sources
- Eh bien oui, vous avez raison, selon ce que vous mettre en œuvre sur la séquence. Cependant, il semble qu'il n'est pas O(1) pour ICollection/IList comme vous l'avez dit, c'est juste O(1) pour IList seulement stackoverflow.com/a/18200099/812598
- La séquence peut avoir plusieurs articles qui satisfait à cette condition e == séquence.Last(), par exemple, de nouveaux [] { 1, 1, 1, 1 }
InformationsquelleAutor Guillermo Ares
-2

Si la vitesse est une exigence, cette ancienne école doit être le plus rapide, même si le code n'a pas l'air aussi lisse que linq pourraient le faire.
```
int[] newSequence = int[sequence.Length - 1];
for (int x = 0; x < sequence.Length - 1; x++)
{
newSequence[x] = sequence[x];
}
```
Cela exige que la séquence est un tableau, car il a une longueur fixe et d'éléments indexés.
- Vous avez affaire à un IEnumerable qui ne permettent pas l'accès aux éléments via un index. Votre solution ne fonctionne pas. En supposant que vous faites à droite, il exige de la traversée de la séquence pour déterminer la longueur, l'allocation d'un tableau de longueur n-1, copie de tous les éléments. - 1. 2n-1 opérations et (2n-1) * (4 ou 8 octets) de mémoire. Ce n'est même pas rapide.
InformationsquelleAutor einord
-4

Je serais probablement faire quelque chose comme ceci:
```
sequence.Where(x => x != sequence.LastOrDefault())
```
C'est une itération avec un chèque qu'il n'est pas le dernier pour chaque temps si.
- Deux raisons qui n'est pas une bonne chose à faire. 1) .LastOrDefault() nécessite une itération à l'ensemble de la séquence, et qui est appelée pour chaque élément de la séquence (dans l' .Où()). 2) Si la séquence est [1,2,1,2,1,2] et vous avez utilisé votre technique, vous serez à gauche avec [1,1,1].
InformationsquelleAutor einord

Vous devez vous connecter pour publier un commentaire.