Sum of one after another sequence

Question

I have this scenario where I have to add the numbers inside a collection. An example would serve a best example.

I have these values in my database:

| Foo |
| 1   |
| 5   |
| 8   |
| 4   |

Result:

| Foo | Result |
|  1  | 1      |
|  5  | 6      |
|  8  | 14     |
|  4  | 18     |

As you can see, it has a somewhat fibonacci effect but the twist here is the numbers are given.

I can achieve this result with the help of for loop but is this possible doing in Linq. Like querying the database then having a result like above?

Any help would be much appreciated. Thanks!

Answer 1

I'm not sure how exactly you're touching the database, but here's a solution that can probably be improved upon:

var numbers = new List<int> { 1, 5, 8, 4 };
var result = numbers.Select((n, i) => numbers.Where((nn, ii) => ii <= i).Sum());

This overload of Select and Where takes the object (each number) and the index of that object. For each index, I used numbers.Where to Sum all the items with a lower and equal index.

For example, when the Select gets to the number 8 (index 2), numbers.Where grabs items with index 0-2 and sums them.

Answer 2

I think you can achieve this with :

var acc = 0;
var result = numbers.Select(i =>
    {
        acc += i;
        return acc;
    }).ToList();

You need the ToList to be sure it will be run only once (otherwise the acc will keep growing).

Also I'm not sure it can be converted to a query (and performed server side).

Thomas Levesque posted a response to a similar question where he provide a SelectAggregate method who provide the intermediate values of an aggregate computation.

It's look like this feature is not present in Linq by default, so you probably will not be able to perform the computation server side using Linq.

Answer 3

MoreLINQ has a Scan method that allows you to aggregate the values in a sequence while yielding each intermediate value, rather than just the final value, which is exactly what you're trying to do.

With that you can write:

var query = data.Scan((sum, next) => sum + next);

The one overload that you need here will be copied below. See the link above for details and additional overloads:

    public static IEnumerable<TSource> Scan<TSource>(this IEnumerable<TSource> source,
        Func<TSource, TSource, TSource> transformation)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (transformation == null) throw new ArgumentNullException("transformation");
        return ScanImpl(source, transformation);
    }

    private static IEnumerable<T> ScanImpl<T>(IEnumerable<T> source, Func<T, T, T> f)
    {
        using (var i = source.GetEnumerator())
        {
            if (!i.MoveNext())
                throw new InvalidOperationException("Sequence contains no elements.");

            var aggregator = i.Current;

            while (i.MoveNext())
            {
                yield return aggregator;
                aggregator = f(aggregator, i.Current);
            }
            yield return aggregator;
        }
    }

Answer 4

You could do the following

int runningTotal = 0;
var runningTotals = numbers.Select(n => new 
    { 
        Number = n, 
        RunningTotal = (runningTotal += n)
    });

This will give you the number and the running total.

Answer 5

It's just an adaption of @Jonesy's answer:

int[] ints = new[] {1, 5, 8, 4};
var result = ints.Select((x, y) => x + ints.Take(y).Sum());