попарной итерация в C# или скользящего окно перечислитель

Question

Если у меня есть IEnumerable как:

string[] items = new string[] { "a", "b", "c", "d" }; 

Я хотел бы цикл через все пары последовательных элементов (окно размера 2 скольжения). Какой бы

("a","b"), ("b", "c"), ("c", "d") 

Мое решение было это

public static IEnumerable<Pair<T, T>> Pairs(IEnumerable<T> enumerable) { 
     IEnumerator<T> e = enumerable.GetEnumerator(); e.MoveNext(); 
     T current = e.Current; 
     while (e.MoveNext()) { 
      T next = e.Current; 
      yield return new Pair<T, T>(current, next); 
      current = next; 
     } 
    } 

// used like this : 
foreach (Pair<String,String> pair in IterTools<String>.Pairs(items)) { 
    System.Out.PrintLine("{0}, {1}", pair.First, pair.Second) 
} 

Когда я писал этот код, я задавался вопросом, есть ли уже функционирует в рамках .NET, которые делают то же самое, и сделать это не просто для пар, но для кортежей любого размера. ИМХО должен быть хороший способ сделать этот вид скользящих оконных операций.

Я использую C# 2.0, и я могу себе представить, что с C# 3.0 (w/LINQ) есть больше (и более приятных) способов сделать это, но меня в первую очередь интересуют решения C# 2.0. Хотя, я также буду признателен за решения C# 3.0.

Answer 1

C# 3.0 решение (извините :)

public static IEnumerable<IEnumerable<T>> Tuples<T>(this IEnumerable<T> sequence, int nTuple) 
{ 
    if(nTuple <= 0) throw new ArgumentOutOfRangeException("nTuple"); 

    for(int i = 0; i <= sequence.Count() - nTuple; i++) 
     yield return sequence.Skip(i).Take(nTuple); 
} 

Это не самый производительный в мире, но это обязательно приятно смотреть.

Действительно, единственное, что делает это решение C# 3.0, это конструкция .Skip.Take, поэтому, если вы просто измените это на добавление элементов в этом диапазоне в список вместо этого, он должен быть золотым для 2.0. Тем не менее, он все еще не работает.

Answer 2

Расширение на previous answer, чтобы избежать из O (N) подход явным образом с помощью переданный итератора:

public static IEnumerable<IEnumerable<T>> Tuples<T>(this IEnumerable<T> input, int groupCount) { 
    if (null == input) throw new ArgumentException("input"); 
    if (groupCount < 1) throw new ArgumentException("groupCount"); 

    var e = input.GetEnumerator(); 

    bool done = false; 
    while (!done) { 
    var l = new List<T>(); 
    for (var n = 0; n < groupCount; ++n) { 
     if (!e.MoveNext()) { 
     if (n != 0) { 
      yield return l; 
     } 
     yield break; 
     } 
     l.Add(e.Current); 
    } 
    yield return l; 
    } 
} 

Для C# 2, до методы расширения, падение "это" из входного параметра и вызов как статический метод.

Answer 3

Alternate Pairs реализации, используя последнюю пару, чтобы сохранить предыдущее значение:

static IEnumerable<Pair<T, T>> Pairs(IEnumerable<T> collection) { 
    Pair<T, T> pair = null; 
    foreach(T item in collection) { 
    if(pair == null) 
     pair = Pair.Create(default(T), item); 
    else 
     yield return pair = Pair.Create(pair.Second, item); 
    } 
} 

Простой Window реализации (только безопасны для частного использования, если абонент не сохраняет возвращаемые массивы; см примечание):

static IEnumerable<T[]> Window(IEnumerable<T> collection, int windowSize) { 
    if(windowSize < 1) 
    yield break; 

    int index = 0; 
    T[] window = new T[windowSize]; 
    foreach(var item in collection) { 
    bool initializing = index < windowSize; 

    // Shift initialized window to accomodate new item. 
    if(!initializing) 
     Array.Copy(window, 1, window, 0, windowSize - 1); 

    // Add current item to window. 
    int itemIndex = initializing ? index : windowSize - 1; 
    window[itemIndex] = item; 

    index++; 
    bool initialized = index >= windowSize; 
    if(initialized) 
     //NOTE: For public API, should return array copy to prevent 
     // modifcation by user, or use a different type for the window. 
     yield return window; 
    } 
} 

Пример использования:

for(int i = 0; i <= items.Length; ++i) { 
    Console.WriteLine("Window size {0}:", i); 
    foreach(string[] window in IterTools<string>.Window(items, i)) 
    Console.WriteLine(string.Join(", ", window)); 
    Console.WriteLine(); 
} 

Answer 4

Рат эр, чем требуется тип кортежа (пара), то почему бы не просто принять селектор:

public static IEnumerable<TResult> Pairwise<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TSource, TResult> resultSelector) 
{ 
    TSource previous = default(TSource); 

    using (var it = source.GetEnumerator()) 
    { 
     if (it.MoveNext()) 
      previous = it.Current; 

     while (it.MoveNext()) 
      yield return resultSelector(previous, previous = it.Current); 
    } 
} 

, который позволяет пропускать промежуточный объект, если вы хотите:

string[] items = new string[] { "a", "b", "c", "d" }; 
var pairs = items.Pairwise((x, y) => string.Format("{0},{1}", x, y)); 

foreach(var pair in pairs) 
    Console.WriteLine(pair); 

Или вы можете использовать анонимный тип :

var pairs = items.Pairwise((x, y) => new { First = x, Second = y }); 

Answer 5

F # Seq модуль определяет парную функцию над IEnumerable<T>, но этой функцией не в рамках .NET.

Если бы он был в среде .NET, вместо того, чтобы возвращать пары, он, вероятно, согласился бы с селекторной функцией из-за отсутствия поддержки кортежей на таких языках, как C# и VB.

var pairs = ns.Pairwise((a, b) => new { First = a, Second = b }; 

Я не думаю, что любой из ответов здесь действительно улучшить вашу простую реализацию итератора, который, казалось, больше всего natural мне (и плакат dahlbyk по внешности вещей!) Тоже.

Answer 6

Что-то вроде этого:

public static IEnumerable<TResult> Pairwise<T, TResult>(this IEnumerable<T> enumerable, Func<T, T, TResult> selector) 
{ 
    var previous = enumerable.First(); 
    foreach (var item in enumerable.Skip(1)) 
    { 
     yield return selector(previous, item); 
     previous = item; 
    } 
} 

Answer 7

В .NET 4 это становится еще проще: -

 var input = new[] { "a", "b", "c", "d", "e", "f" }; 
     var result = input.Zip(input.Skip(1), (a, b) => Tuple.Create(a, b)); 

Answer 8

Самый простой способ заключается в использовании ReactiveExtensions

using System.Reactive; 
using System.Reactive.Linq; 

и сделать себе метод расширения для набора bash вместе

public static IEnumerable<IList<T>> Buffer<T>(this IEnumerable<T> seq, int bufferSize, int stepSize) 
{ 
    return seq.ToObservable().Buffer(bufferSize, stepSize).ToEnumerable(); 
} 

Answer 9

Для удобства здесь приведена безрезультатная версия ответа @ dahlbyk.

public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> enumerable) 
{ 
    var previous = default(T); 

    using (var e = enumerable.GetEnumerator()) 
    { 
     if (e.MoveNext()) 
      previous = e.Current; 

     while (e.MoveNext()) 
      yield return Tuple.Create(previous, previous = e.Current); 
    } 
} 

Answer 10

Немного опоздал на вечеринку, но в качестве альтернативы все эти методы расширения, можно использовать фактические «скольжение» Collection держать (и выбросить) данные.

Вот один я в конечном итоге сделать сегодня:

public class SlidingWindowCollection<T> : ICollection<T> 
{ 
    private int _windowSize; 
    private Queue<T> _source; 

    public SlidingWindowCollection(int windowSize) 
    { 
     _windowSize = windowSize; 
     _source = new Queue<T>(windowSize); 
    } 

    public void Add(T item) 
    { 
     if (_source.Count == _windowSize) 
     { 
      _source.Dequeue(); 
     } 
     _source.Enqueue(item); 
    } 

    public void Clear() 
    { 
     _source.Clear(); 
    } 

    ...and just keep forwarding all other ICollection<T> methods to _source. 
} 

Использование:

int pairSize = 2; 
var slider = new SlidingWindowCollection<string>(pairSize); 
foreach(var item in items) 
{ 
    slider.Add(item); 
    Console.WriteLine(string.Join(", ", slider)); 
} 

Answer 11

Вот мое решение с использованием стека. Он короткий и лаконичный.

string[] items = new string[] { "a", "b", "c", "d" }; 

Stack<string> stack = new Stack<string>(items.Reverse()); 

while(stack.Count > 1) 
{ 
    Console.WriteLine("{0},{1}", stack.Pop(), stack.Peek()); 
}