c# - LINQを使用して複数（2つ以上）の不規則なリストをインターリーブする

Question

次のデータがあるとしましょう

IEnumerable<IEnumerable<int>> items = new IEnumerable<int>[] { 
    new int[] { 1, 2, 3, 4 },
    new int[] { 5, 6 },
    new int[] { 7, 8, 9 }
};

結果が得られるように、アイテムがインターリーブされたフラットリストを返す最も簡単な方法は何でしょうか。

1、5、7、2、6、8、3、9、4

注：内部リストの数は実行時に不明です。

Answer 1

あなたが説明しているのは、本質的に、オーバーハングしたアイテムが含まれ、結果が平坦化されるトランスポーズメソッドです。これが私の試みです：

static IEnumerable<IEnumerable<T>> TransposeOverhanging<T>(
    this IEnumerable<IEnumerable<T>> source)
{
    var enumerators = source.Select(e => e.GetEnumerator()).ToArray();
    try
    {
        T[] g;
        do
        {
            yield return g = enumerators
                .Where(e => e.MoveNext()).Select(e => e.Current).ToArray();
        }
        while (g.Any());
    }
    finally
    {
        Array.ForEach(enumerators, e => e.Dispose());
    }
}

例：

var result = items.TransposeOverhanging().SelectMany(g => g).ToList();
// result == { 1, 5, 7, 2, 6, 8, 3, 9, 4 }

Answer 2

以下の解決策は非常に簡単です。結局のところ、dtb によって提案されたソリューションのほぼ 2 倍も高速です。

private static IEnumerable<T> Interleave<T>(this IEnumerable<IEnumerable<T>> source )
{
    var queues = source.Select(x => new Queue<T>(x)).ToList();
    while (queues.Any(x => x.Any())) {
        foreach (var queue in queues.Where(x => x.Any())) {
            yield return queue.Dequeue();
        }
    }
}

Answer 3

dtb's answerに基づく私の試みは次のとおりです。SelectMany外部呼び出しと内部呼び出しを回避しToArrayます。

public static IEnumerable<T> Interleave<T>(this IEnumerable<IEnumerable<T>> source)
{
    var enumerators = source.Select(e => e.GetEnumerator()).ToArray();
    try
    {
        bool itemsRemaining;
        do
        {
            itemsRemaining = false;
            foreach (var item in 
                     enumerators.Where(e => e.MoveNext()).Select(e => e.Current))
            {
                yield return item;
                itemsRemaining = true;
            }
        }
        while (itemsRemaining);
    }
    finally
    {
        Array.ForEach(enumerators, e => e.Dispose());
    }
}

Answer 4

• 例外がスローされた場合でも、すべての列挙子を破棄しました
• 外側のシーケンスを積極的に評価しますが、内側のシーケンスには遅延評価を使用します。

---

public static IEnumerable<T> Interleave<T>(IEnumerable<IEnumerable<T>> sequences)
{
    var enumerators = new List<IEnumerator<T>>();
    try
    {
        // using foreach here ensures that `enumerators` contains all already obtained enumerators, in case of an expection is thrown here.
        // this ensures proper disposing in the end
        foreach(var enumerable in sequences)
        {
            enumerators.Add(enumerable.GetEnumerator());
        }

        var queue = new Queue<IEnumerator<T>>(enumerators); 
        while (queue.Any())
        {
            var enumerator = queue.Dequeue();
            if (enumerator.MoveNext())
            {
                queue.Enqueue(enumerator);
                yield return enumerator.Current;
            }
        }
    }
    finally
    {
        foreach(var enumerator in enumerators)
        {
            enumerator.Dispose();
        }
    }
}

Answer 5

「dtb」の回答ほどエレガントではありませんが、機能し、シングルライナーです:)

Enumerable.Range(0, items.Max(x => x.Count()))
                      .ToList()
                      .ForEach(x =>
                                   {
                                            items
                                            .Where(lstChosen => lstChosen.Count()-1 >= x)
                                            .Select(lstElm => lstElm.ElementAt(x))
                                            .ToList().ForEach(z => Console.WriteLine(z));
                                   });