3

関数が以下で説明するように、特定の方法で 2 つのリストをマージする必要があります。この実装は再帰を使用して動作しますが、扱いにくいようです。LINQでこれを行うためのより良い方法を知っている人はいますか?外側の(フラット化されていない)要素を参照できるaのようなものがあるはずですが、SelectMany何も見つかりません

/// <summary>
/// Function merges two list by combining members in order with combiningFunction
/// For example   (1,1,1,1,1,1,1) with 
///               (2,2,2,2)       and a function that simply adds
/// will produce  (3,3,3,3,1,1,1)
/// </summary>
public static IEnumerable<T> MergeList<T>(this IEnumerable<T> first, 
                                          IEnumerable<T> second, 
                                          Func<T, T, T> combiningFunction)
{
    if (!first.Any())
        return second;

    if (!second.Any())
        return first;

    var result = new List<T> {combiningFunction(first.First(), second.First())};
    result.AddRange(MergeList<T>(first.Skip(1), second.Skip(1), combiningFunction));

    return result;
}
4

3 に答える 3

5

Enumerable.Zipまさにあなたが望むものです。

var resultList = Enumerable.Zip(first, second,
// or, used as an extension method:  first.Zip(second,
    (f, s) => new
              {
                  FirstItem = f,
                  SecondItem = s,
                  Sum = f + s
              });

編集：1つのリストが完了しても続く「外側」の圧縮スタイルを考慮していないようです。これを説明するソリューションは次のとおりです。

public static IEnumerable<TResult> OuterZip<TFirst, TSecond, TResult>(
    this IEnumerable<TFirst> first, IEnumerable<TSecond> second,
    Func<TFirst, TSecond, TResult> resultSelector)
{
    using (IEnumerator<TFirst> firstEnumerator = first.GetEnumerator())
    using (IEnumerator<TSecond> secondEnumerator = second.GetEnumerator())
    {
        bool firstHasCurrent = firstEnumerator.MoveNext();
        bool secondHasCurrent = secondEnumerator.MoveNext();

        while (firstHasCurrent || secondHasCurrent)
        {
            TFirst firstValue = firstHasCurrent
                ? firstEnumerator.Current
                : default(TFirst);

            TSecond secondValue = secondHasCurrent
                ? secondEnumerator.Current
                : default(TSecond);

            yield return resultSelector(firstValue, secondValue);

            firstHasCurrent = firstEnumerator.MoveNext();
            secondHasCurrent = secondEnumerator.MoveNext();
        }
    }
}

default(TFirst)この関数を簡単に変更して、ブール値を結果セレクター関数に渡して、最初または 2 番目の要素が存在するかどうかを示すことができます (default(TSecond)ラムダで作業する代わりに)。

于 2013-05-29T04:36:38.633 に答える
1

のようなものはどうですか

public static IEnumerable<T> MyMergeList<T>(this IEnumerable<T> first,
                                  IEnumerable<T> second,
                                  Func<T, T, T> combiningFunction)
{
    return Enumerable.Range(0, Math.Max(first.Count(), second.Count())).
        Select(x => new
                        {
                            v1 = first.Count() > x ? first.ToList()[x] : default(T),
                            v2 = second.Count() > x ? second.ToList()[x] : default(T),
                        }).Select(x => combiningFunction(x.v1, x.v2));
}
于 2013-05-29T04:53:18.410 に答える
0

古き良き時代のループだけでは何が問題なのですか。確かに、それほど派手ではありませんが、非常に簡単で、再帰を使用する必要はありません。

var firstList = first.ToList();
var secondList = second.ToList();
var firstCount = first.Count();
var secondCount = second.Count();
var result = new List<T>();
for (int i = 0; i < firstCount || i < secondCount; i++)
{
    if (i >= firstCount)
        result.Add(secondList[i]);
    if (i >= secondCount)
        result.Add(firstList[i]);

    result.Add(combiningFunction(firstList[i], secondList[i]));
}
于 2013-05-29T04:32:15.437 に答える