使用 C#/Linq 累加序列的子序列

Question

我试图根据以下要求找到一种更好的方法来处理数字序列： sequence[i]的值是其自身值加上sequence[0]到sequence[i-1]的累加之和。

例如： 如果序列是一个列表，

List<double> list = new List<double> { 10.0, 20.0, 30.0, 40.0 };

则输出结果应该是

list[0] = 10.0
list[1] = 20.0 + 10.0
list[2] = 30.0 + 10.0 + 20.0
list[3] = 40.0 + 10.0 + 20.0 + 30.0

我知道使用多次迭代的强力方式，但我想知道一定有更好的解决方案（也许使用 LINQ）。

Answer 1

假设您有权访问 LINQ：

using System.Linq;

List<int> numbers = new List<int> {10, 20, 30, 40};
List<int> runningTotals = new List<int>(numbers.Count);

numbers.Aggregate(0, (sum, value) => {
    sum += value; 
    runningTotals.Add(sum); 
    return sum;
});

Answer 2

我的版本是对我在注释中添加的内容的修改，并返回 IEnumerable 而不是 List，但 ToList() 会解决这个问题。

应该还是蛮有效率的。谁不喜欢使用yield return？ ;-)

public IEnumerable<double> GetCumulativeSequence (IEnumerable<double> input)
{
    var runningTotal = 0.0;
    foreach (double current in input)
    {
        runningTotal+=current;
        yield return runningTotal;
    }
}

void Main()
{
    List<double> list = new List<double> { 10.0, 20.0, 30.0, 40.0 };
    var foo = GetCumulativeSequence(list);
}

这样做的主要优点是它只对输入数组执行一次循环。如果您实际上没有使用返回的所有内容（即您只查看前三个），那么它不会计算其余的内容。在较长的列表等中可能有用。Chris Doggett 的答案之类的内容也会如此，但并非所有此处使用 linq 的内容。

Answer 3

使用相对未知的 Select 重载可以让您查看索引：

var result = list.Select((val, index) => list.Take(index + 1).Sum())

Answer 4

非 LINQ 版本，只是为了有所不同：

List<double> GetSums(List<double> values)
{
   List<double> sums = new List<double>();
   double total = 0;
   foreach(double d in values)
   {
      total += d;
      sums.Add(total);
   }
   return sums;
}

Answer 5

这是另一种类似于其中一篇文章的方法，但这个方法是独立的：

// C#
Enumerable.Range(1, 100)
.Aggregate(new List<int>{0},
  (acc, x) => { acc.Add(acc.Last() + x); return acc; })
.Dump(); // Dump using LINQPad; ans: 5050

如果我们切换到 int64，并使用 10,000,000 作为上限，并读取最终的累积结果，则代码在大约 450 毫秒内执行最终输出为 Corei5：

50000005000000

顺便说一句，对于 1,000,000 的执行上限约为 40 毫秒，因此将大小增加 10 会使时间增加 10。

Answer 6

返回操作序列的中间结果：

public static IEnumerable<TResult> Scan<T, TResult>(this IEnumerable<T> src, TResult seed, Func<TResult, T, TResult> combine) {
    foreach (var s in src) {
        seed = combine(seed, s);
        yield return seed;
    }
}

我基于 APL 扫描运算符（类似于 Aggregate 本质上是 APL 归约运算符）构建了一个通用（有很多变体）扩展方法，该方法 然后可以像这样使用：

var ans = list.Scan(0.0, (a, d) => a+d).ToList();