Добавьте два списка разной длины в С#

Ответ 1

Вы можете использовать модифицированную операцию "zip" достаточно легко, но ничего не встроено. Что-то вроде:

    static void Main() {
        var a = new List<int> { 1, 2, 3 };
        var b = new List<int> { 1, 2, 3, 4, 5 };
        foreach (var c in a.Merge(b, (x, y) => x + y)) {
            Console.WriteLine(c);
        }
    }
    static IEnumerable<T> Merge<T>(this IEnumerable<T> first,
            IEnumerable<T> second, Func<T, T, T> operation) {
        using (var iter1 = first.GetEnumerator())
        using (var iter2 = second.GetEnumerator()) {
            while (iter1.MoveNext()) {
                if (iter2.MoveNext()) {
                    yield return operation(iter1.Current, iter2.Current);
                } else {
                    yield return iter1.Current;
                }
            }
            while (iter2.MoveNext()) {
                yield return iter2.Current;
            }
        }
    }

Ответ 2

Использование .NET 4.0 Оператор Zip:

var sums = b.Zip(a, (x, y) => x + y)
            .Concat(b.Skip(a.Count()));

Если вы хотите обобщить это, проверьте, у кого больше элементов, и используйте это как "b" выше.

Ответ 3

Enumerable.Range(0, new[] { a.Count, b.Count }.Max())
    .Select(n => a.ElementAtOrDefault(n) + b.ElementAtOrDefault(n));

Ответ 4

Мне пришлось слегка настроить решение Marc для моего использования, чтобы разрешить списки разных типов, поэтому я подумал, что я опубликую его, если кто-нибудь еще этого захочет.

public static IEnumerable<TResult> Merge<TFirst,TSecond,TResult>(this IEnumerable<TFirst> first,
            IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> operation) {
    using (var iter1 = first.GetEnumerator()) {
        using (var iter2 = second.GetEnumerator()) {
            while (iter1.MoveNext()) {
                if (iter2.MoveNext()) {
                    yield return operation(iter1.Current, iter2.Current);
                } else {
                    yield return operation(iter1.Current, default(TSecond));
                }
            }
            while (iter2.MoveNext()) {
                yield return operation(default(TFirst),  iter2.Current);
            }
        }
    }
}

Ответ 5

Как насчет этого:

List<double> doubles = Enumerable.Range(0, Math.Max(a.Count, b.Count))
    .Select(x => (a.Count > x ? a[x] : 0) + (b.Count > x ? b[x] : 0))
    .ToList();

Ответ 6

Ниже приведено решение вашей проблемы.

List<double> a = new List<double>{1,2,3};
List<double> b = new List<double>{1,2,3,4,5};

List<double> sum = new List<double>();
int max = Math.Min(a.Count, b.Count);
for (int i = 0; i < max; i++){
    sum.Add(a[i] + b[i]);
}

if (a.Count < b.Count)
    for (int i = max i < b.Count)
        sum.Add(b[i]);
else
    for (int i = max i < a.Count)
    sum.Add(a[i]);

Ответ 7

Уродливое решение LINQ:

var sum = Enumerable.Range(0, (a.Count > b.Count) ? a.Count : b.Count)
    .Select(i => (a.Count > i && b.Count > i) ? a[i] + b[i] : (a.Count > i) ? a[i] : b[i]);

Ответ 8

В этом случае, если листы имеют одинаковую длину или разную длину, это не имеет большого значения. В библиотеке классов .NET нет Enumerable.Zip метод объединения двух последовательностей (он будет доступен только в .NET 4.0), и вы нужно что-то вроде этого здесь в любом случае. Таким образом, вам либо нужно написать цикл, либо написать собственный Zip (который все равно будет включать цикл).

Есть некоторые хаки, чтобы сжать это все в одном запросе LINQ без циклов, включая объединение индексов, но они будут очень медленными и действительно бессмысленными.

Ответ 9

Что случилось с 1 и дополнительными 2 и 3? Если вы ищете различные значения:

var one = new List<int> { 1, 2, 3 };
var two = new List<int> { 1, 2, 3, 4, 5 };

foreach (var x in one.Union(two)) Console.Write("{0} ", x);

Дает вам 1 2 3 4 5

Если вы ищете только второй список, добавленный к первому, тогда:

foreach(var x in one.Concat(two)) // ...

даст вам 1 2 3 1 2 3 4 5

Изменить: О, я вижу, вы ищете своего рода Zip, но возвращаете дополнительные части. Попробуйте следующее:

public static IEnumerable<V> Zip<T, U, V>(
    this IEnumerable<T> one,
    IEnumerable<U> two,
    Func<T, U, V> f)
{
    using (var oneIter = one.GetEnumerator()) {
        using (var twoIter = two.GetEnumerator()) {
            while (oneIter.MoveNext()) {
                twoIter.MoveNext();
                yield return f(oneIter.Current,
                    twoIter.MoveNext() ?
                        twoIter.Current :
                        default(U));
            }

            while (twoIter.MoveNext()) {
                yield return f(oneIter.Current, twoIter.Current);
            }
        }
    }
}

и здесь, который больше похож на обычную zip-функцию, которая не возвращает дополнительные функции:

public static IEnumerable<V> Zip<T, U, V>(
    this IEnumerable<T> one,
    IEnumerable<U> two,
    Func<T, U, V> f)
{
    using (var oneIter = one.GetEnumerator()) {
        using (var twoIter = two.GetEnumerator()) {
            while (oneIter.MoveNext()) {
                yield return f(oneIter.Current,
                    twoIter.MoveNext() ?
                        twoIter.Current :
                        default(U));
            }
        }
    }
}

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

var one = new List<int>  { 1, 2, 3, 4, 5};
var two = new List<char> { 'h', 'e', 'l', 'l', 'o' };

foreach (var x in one.Zip(two, (a,b) => new {A = a, B =b }))
    Console.WriteLine("{0} => '{1}'", x.A, x.B);

Результаты в:

1 = > 'h'
2 = > 'e'
3 = > 'l'
4 = > 'l'
5 = > 'o'

Ответ 10

Здесь еще 3:

Сделайте списки одного размера, а затем просто выберите.

(a.Count < b.Count ? a : b).AddRange(new double[Math.Abs(a.Count - b.Count)]);
var c = a.Select((n, i) => n + b[i]);

Не делайте их одинакового размера, но пройдите через самое длинное и проверьте на конец диапазона на кратчайшие (сохраните shortList.Count для легкого перфоманса):

var longList = a.Count > b.Count ? a : b;
var shortList = longList == a ? b : a;
var c = longList.Select((n, i) => n + (shortList.Count > i ? shortList[i] : 0));

Take пока вы можете, а затем Skip и Union остальные:

var c = a.Take(Math.Min(a.Count, b.Count))
         .Select((n, i) => n + b[i])
         .Union(a.Skip(Math.Min(a.Count, b.Count));

Ответ 11

В качестве комбинации ответов от Марка и Дамиана вы можете просто использовать этот код, который немного более готов к работе:

public static class EnumerableExtensions
{
    public static IEnumerable<T> Merge<T>(this IEnumerable<T> first, IEnumerable<T> second, Func<T, T, T> operation)
    {
        return Merge<T, T, T>(first, second, operation);
    }

    public static IEnumerable<TResult> Merge<T, TResult>(this IEnumerable<T> first, IEnumerable<T> second, Func<T, T, TResult> operation)
    {
        return Merge<T, T, TResult>(first, second, operation);
    }

    public static IEnumerable<TResult> Merge<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> operation)
    {
        if (first == null) throw new ArgumentNullException(nameof(first));
        if (second == null) throw new ArgumentNullException(nameof(second));

        using (var iter1 = first.GetEnumerator())
        using (var iter2 = second.GetEnumerator())
        {
            while (iter1.MoveNext())
            {
                yield return iter2.MoveNext()
                    ? operation(iter1.Current, iter2.Current)
                    : operation(iter1.Current, default);
            }

            while (iter2.MoveNext())
            {
                yield return operation(default, iter2.Current);
            }
        }
    }
}

Ответ 12

Способ сделать это только с Zip:

b.Zip(a.DefaultIfEmpty(), (x,y) => x+y)

Поскольку значение по умолчанию для числовых типов равно 0, вам не требуется дополнительная обработка.

Ответ 13

Моя реализация с использованием цикла:

List<double> shorter, longer;
if (a.Count > b.Count)
{
    shorter = b; longer = a
}
else
{
    shorter = a; longer = b;
}

List<double> result = new List<double>(longer);
for (int i = 0; i < shorter.Count; ++i)
{
     result[i] += shorter[i];
}