Jak mogę zabrać 1 dodatkowy przedmiot z TakeWhile Linq?

Question

(linia kodu zainteresowania jest ostatnim, reszta jest tylko dla pełnej reprezentacji)

Korzystanie poniższy kod, chciałem wziąć wyborców aż przekroczyła maksymalnych głosów potrzebnych, ale zatrzymuje się tuż przed osiągnięciem tej maksymalnej liczby głosów, więc moja pula wyborców ma o 1 mniej wyborcę, niż chciałem.

Czy w LINQ istnieje czysty sposób, w jaki mógłbym zdobyć głosy, AŻ osiągnął maksymalną liczbę głosów? Wiem, że mógłbym dodać jeszcze jednego wyborcę lub zrobić to w pętli, ale jestem ciekawy, czy byłby to dobry sposób na zrobienie tego z LINQ.

var voters = new List<Person> 
          { 
           new Person("Alice", Vote.Yes), 
           new Person("Bob", Vote.Yes), 
           new Person("Catherine", Vote.No), 
           new Person("Denzel", Vote.Yes), 
           new Person("Einrich", Vote.Abstain), 
           new Person("Frederica", Vote.Abstain), 
           new Person("Goeffried", Vote.Abstain), 
          }; 
      voters.Single(c => c.Name == "Alice").Voices = 100; 
      voters.Single(c => c.Name == "Bob").Voices = 150; 
      voters.Single(c => c.Name == "Catherine").Voices = 99; 
      voters.Single(c => c.Name == "Denzel").Voices = 24; 
      voters.Single(c => c.Name == "Einrich").Voices = 52; 
      voters.Single(c => c.Name == "Frederica").Voices = 39; 
      voters.Single(c => c.Name == "Goeffried").Voices = 99; 

// this takes voters until we are BEFORE reaching X voices... 
int voicesSoFar = 0; 
int voicesNeeded = 300; 
var eligibleVoters = voters.TakeWhile((p => (voicesSoFar += p.Voices) < voicesNeeded)); 

Answer 1

Szukacie

voters.TakeWhile(p => { 
    bool exceeded = voicesSoFar > voicesNeeded ; 
    voicesSoFar += p.Voices; 
    return !exceeded; 
}); 

Jeśli nalegać na jednej liniowej, to będzie działać porównując poprzednią wartość:

voters.TakeWhile(p => (voicesSoFar += p.Voices) - p.Voices < voicesNeeded); 

Answer 2

Wystarczy napisać własną metodę rozszerzenia:

static class IEnumerableExtensions { 
    public static IEnumerable<T> TakeUntil<T>(
     this IEnumerable<T> elements, 
     Func<T, bool> predicate 
    ) { 
     return elements.Select((x, i) => new { Item = x, Index = i }) 
         .TakeUntil((x, i) => predicate(x.Item)) 
         .Select(x => x.Item); 
    } 

    public static IEnumerable<T> TakeUntil<T>(
     this IEnumerable<T> elements, 
     Func<T, int, bool> predicate 
    ) { 
     int i = 0; 
     foreach (T element in elements) { 
      if (predicate(element, i)) { 
       yield return element; 
       yield break; 
      } 
      yield return element; 
      i++; 
     } 
    } 
} 

Zastosowanie:

var eligibleVoters = voters.TakeUntil(
         p => (voicesSoFar += p.Voices) >= voicesNeeded 
        ); 

foreach(var voter in eligibleVoters) { 
    Console.WriteLine(voter.Name); 
} 

wyjściowa:

Alice 
Bob 
Catherine 

Answer 3

W sytuacji, gdy chciałem wykonać funkcję aż włącznie uderzył warunek końcowy zrobiłem :

public static IEnumerable<T> TakeUntilIncluding<T>(this IEnumerable<T> list, Func<T, bool> predicate) 
{ 
    foreach(T el in list) 
    { 
     yield return el; 
     if (predicate(el)) 
      yield break; 
    } 
} 

Pracowałem dla mnie! Myślę, że jest to rozwiązanie niezależne od implementacji, takie jak Jason, ale prostsze.

Answer 4

Zmiana odpowiedzi Kobi, ale demonstruje użycie (value, index). index jest przydatny w rozwiązywaniu podobnych problemów, ale nie w PO.

voters.TakeWhile((value, index) => (voicesSoFar += value.Voices) - value.Voices < voicesNeeded); 

Answer 5

Miałem do czynienia z tym samym problemem. Użyłem Unię i Przejdź metod, tak aby wziąć aż było

IEnumerable<Something> newSomethings = somethings.TakeWhile(s => s != stop).Union(new List<Something>(){stop}); 

i skrzyni ładunkowej aż

IEnumerable<Something> newSomethings = somethings.SkipWhile(s => s != stop).Skip(1); 

Istnieje również Take metodę, która przyjmuje niektóre int pierwszych wyników.