Añadir dos listas de diferente longitud en C#

Question

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

a + b me debe dar 2,4,6,4,5

obvisouly puedo escribir un bucle, pero hay una manera mejor? usando linq?

Answer 1

se puede utilizar una operación de "zip" modificado con bastante facilidad, pero nada construido en algo como:.

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

Answer 2

A continuación se muestra una solución a su problema.

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

Answer 3

En este caso, si las listas son de la misma longitud o de longitudes diferentes, que en realidad no importa. biblioteca de clases .NET no tiene Enumerable.Zip método para combinar dos secuencias (sólo vendrá en .NET 4.0), y que necesitaría algo así aquí de cualquier manera. Así que o bien tiene que escribir un bucle, o para escribir su propia Zip (que todavía implicaría un bucle).

Hay algunos trucos para exprimir todo esto en una sola consulta LINQ sin bucles, con la participación de unirse en los índices, pero esos serían muy lento y realmente inútil.

Answer 4

¿Qué pasó con el 1 y el extra 2 y 3? Si usted está buscando los valores distintos:

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

le dará 1 2 3 4 5

Si usted está buscando sólo la segunda lista anexa a la primera a continuación:

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

le dará 1 2 3 1 2 3 4 5

Editar: Oh, ya veo, estás buscando un tipo de Zip, pero que devuelve las piezas adicionales.Prueba esto:

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

y aquí hay uno que es más como una función postal normal, que no devuelve los extras: Uso

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

Ejemplo:

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

Resultados en :

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

Answer 5

Mi aplicación usando un bucle:

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

Answer 6

El feo solución 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]); 

Answer 7

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

Answer 8

El uso de .NET 4.0 Zip operador:

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

Si desea generalizar esto, compruebe que tiene más elementos y usar eso como la "b" anterior.

Answer 9

¿Qué tal esto:

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

Answer 10

Aquí hay 3 más:

Hacer las listas del mismo tamaño, a continuación, sólo sencilla Seleccionar.

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

no les haga el mismo tamaño, pero pasan por el más largo y compruebe si el final del rango en el más corto (shortList.Count tienda para la ganancia fácil perf):

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 mientras se puede, a continuación, Skip y Union el resto:

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

Answer 11

tuve que ajustar ligeramente solución de Marc para mi uso para permitir listas de diferentes ty pes, así que pensé en publicar en caso de que alguien más lo necesite.

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