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

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

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

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

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

Обновление: я только что реализовал это в реальном проекте и использовал C# 7.0 ValueTuple вместо этого:

public static IEnumerable<(T, T)> Pairwise<T>(this IEnumerable<T> source)
{
    var previous = default(T);
    using (var it = source.GetEnumerator())
    {
        if (it.MoveNext())
            previous = it.Current;

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

Самый простой способ - использовать ReactiveExtensions

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

и сделайте себе метод расширения, чтобы собрать это вместе

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

Просто для удобства вот версия ответа @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);
    }
}

Немного поздно для вечеринки, но в качестве альтернативы всем этим методам расширения можно использовать фактическое «скользящее» 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));
}

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

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

Вы можете взять ту же концепцию и использовать очередь, которая позволяет избежать необходимости реверсирования элементов и даже проще:

var queue = new Queue<string>(items);

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

Коротко о производительности:

Я считаю важным понимать, что если вы не знаете, что задача является узким местом в вашем реальном приложении, вероятно, не стоит выяснять, какой действительно быстрый способ сделать это. Вместо этого напишите код, который сделает всю работу за вас. Кроме того, используйте код, который вы можете запомнить, чтобы он легко вылетел у вас из рук в следующий раз, когда он вам понадобится.

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

Run #1
  InputZip             00:00:00.7355567
  PairwiseExtension    00:00:00.5290042
  Stack                00:00:00.6451204
  Queue                00:00:00.3245580
  ForLoop              00:00:00.7808004
  TupleExtension       00:00:03.9661995

Run #2
  InputZip             00:00:00.7386347
  PairwiseExtension    00:00:00.5369850
  Stack                00:00:00.6910079
  Queue                00:00:00.3246276
  ForLoop              00:00:00.8272945
  TupleExtension       00:00:03.9415258

Протестировано с помощью инструмента микротестирования Джона Скита.

Если вы хотите взглянуть на исходный код для теста, перейдите сюда: суть здесь

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

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

Расширение предыдущего ответа на избегайте подхода 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 перед методами расширения удалите "this" из входного параметра и вызовите его как статический метод.

Простите, если я что-то упускаю из виду, но почему бы не что-то простое, например, цикл for?:

public static List <int []> ListOfPairs (int [] items)
{
    List <int> output = new List <int>();
    for (int i=0; i < items.Length-1; i++)
    {
        Int [] pair = new int [2];
        pair [0]=items [i];
        pair [1]=items [i+1];
        output.Add (pair);
    }
    return output;
}

Решение С# 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. Тем не менее, это все еще не работает.

Альтернативная реализация 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( );
}

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

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

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

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

Я создал слегка измененную версию кода, обновленного в конце 2020 года, в ответе @dahlbyk. Он лучше подходит для проектов с включенными ссылочными типами, допускающими значение NULL (<Nullable>enable</Nullable>). Я также добавил основные документы.

/// <summary>
/// Enumerates over tuples of pairs of the elements from the original sequence. I.e. { 1, 2, 3 } becomes { (1, 2), (2, 3) }. Note that { 1 } becomes { }.
/// </summary>
public static IEnumerable<(T, T)> Pairwise<T>(this IEnumerable<T> source)
{
    using var it = source.GetEnumerator();
        
    if (!it.MoveNext())
        yield break;

    var previous = it.Current;

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