How do I add two lists in Linq so addedList[x] = listOne[x] + listTwo[x]?

Question

I want to add two lists of a numeric type such that addedList[x] = listOne[x] + listTwo[x]

The output of the list needs to be a Generic.IEnumerable that I can use in future linq queries.

While I was able to do it using the code below, I can't help but feel like there must be a better way. Any ideas?

List<int> firstList = new List<int>(new int[] { 1, 3, 4, 2, 5, 7, 2, 5, 7, 8, 9, 0 });
List<int> secondList = new List<int>(new int[] { 4, 6, 8, 3, 1, 5, 9, 3, 0 });

int findex = 0;

ILookup<int, int> flookup = firstList.ToLookup(f =>
                            {
                               int i = findex;
                               findex++; 
                               return i;
                               }, p => p);  

var listsAdded = from grp in flookup
                 select grp.First() + secondList.ElementAtOrDefault(grp.Key);

foreach (int i in listsAdded)
  Console.WriteLine(i);

Answer 1

var res = list.Concat(list1); 

concatenates two lists, including eventual duplicates.

var res = list.Union(list1);

concatenates two lists, providing a result without duplicates.

Answer 2

var result = 
   from i in 
        Enumerable.Range(0, Math.Max(firstList.Count, secondList.Count))
   select firstList.ElementAtOrDefault(i) + secondList.ElementAtOrDefault(i);

Answer 3

It sounds like you want a function like this:

public static IEnumerable<int> SumIntLists( 
    this IEnumerable<int> first, 
    IEnumerable<int> second) 
{
    using(var enumeratorA = first.GetEnumerator()) 
    using(var enumeratorB = second.GetEnumerator()) 
    { 
        while (enumeratorA.MoveNext()) 
        {
            if (enumeratorB.MoveNext())
                yield return enumeratorA.Current + enumeratorB.Current;
            else
                yield return enumeratorA.Current;
        }
        // should it continue iterating the second list?
        while (enumeratorB.MoveNext())
            yield return enumeratorB.Current;
    } 
} 

Answer 4

What you're looking for is a Zip method. This method allows you to combine to lists of equal length into a single list by applying a projection.

For example

var sumList = firstList.Zip(secondList, (x,y) => x + y).ToList();

This method was added to the BCL in CLR 4.0 (Reference). It's fairly straight forward to implement though and many versions are available online that can be copied into a 2.0 or 3.5 application.