List<double> a = new List<double>{1,2,3};
List<double> b = new List<double>{1,2,3,4,5};
a + b应该给我2,4,6,4,5
显然我可以写一个循环但是有更好的方法吗？使用linq？答案 0 :(得分：23)
您可以轻松地使用修改后的“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;
}
}
}
答案 1 :(得分：14)
使用.NET 4.0的Zip运算符：
var sums = b.Zip(a, (x, y) => x + y)
.Concat(b.Skip(a.Count()));
如果你想概括一下，检查哪个元素有更多元素并将其用作上面的“b”。
答案 2 :(得分：7)
Enumerable.Range(0, new[] { a.Count, b.Count }.Max())
.Select(n => a.ElementAtOrDefault(n) + b.ElementAtOrDefault(n));答案 3 :(得分：7)
我不得不稍微调整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);
}
}
}
}
答案 4 :(得分：2)
这个怎么样：
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();
答案 5 :(得分：1)
以下是您问题的解决方案。
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]);
答案 6 :(得分：1)
丑陋的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]);
答案 7 :(得分：1)
仅使用Zip即可做到这一点的方法是：
b.Zip(a.DefaultIfEmpty(), (x,y) => x+y)
由于数字类型的默认值为0，因此不需要任何额外的处理。
答案 8 :(得分：0)
在这种情况下，无论列表是长度相同还是长度不同，它都无关紧要。 .NET类库没有Enumerable.Zip方法来组合两个序列（它只会出现在.NET 4.0中），你可能需要这样的方法。所以你要么写一个循环，要么写自己的Zip（这仍然会涉及一个循环）。
有一些黑客可以在没有循环的单个LINQ查询中挤压这一切，包括加入索引，但那些会非常慢而且毫无意义。
答案 9 :(得分：0)
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 =＆gt; 'H'
2 =＆gt; 'E'
3 =＆gt; 'L'
4 =＆gt; 'L'
5 =＆gt; 'o'
答案 10 :(得分：0)
这里还有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 :(得分：0)
结合Marc和Damian的答案，您可以只使用以下代码，这已经准备好了一些生产版本：
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 :(得分：0)
您可以用c压缩b，其中c具有相同的大小：
var c = a.Concat(Enumerable.Repeat(0, b.Length - a.Length));
答案 13 :(得分：-3)
我使用循环实现：
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];
}