使用 Linq 连续总和大于 0 的连续元素

Question

好的，这只是我几天前解决的一个有趣问题的一小部分。想象一下，我们有一个包含 N 个元素的数组。该数组仅由 1 和 -1 组成。它看起来像这样：

int[] arr = new int[] { -1, 1, -1, 1, 1, -1 };

我们的任务是找到保持（假想）计数器 >= 0 的连续元素的最大数量（从左到右），然后对数组进行切割，以便只剩下这些元素。

在我们的例子中，我们从计数器 0 开始：

计数器 = 0

第一个元素：-1 -> Counter = -1（低于0，所以我们重置了计数器）

秒：1 -> 计数器 = 1

第三个：-1 -> Counter = 0

第四个：1 -> Counter = 1

等等。

在上述例子中，答案是：

Solve(new int[] { -1, 1, -1, 1, 1, -1 }); // => new int[] { 1, -1, 1, 1, -1 };

现在，我的做法是这样的：

public static List<int> Solve(int[] input)
{
   List<List<int>> compare = new List<List<int>>();
   List<int> temp = new List<int>();
   for(int i = 0, c = 0; i < input.Length; i++)
   {
       if(input[i] == 1)
       {
           c++;
           temp.Add(input[i]);
       }
       else if(input[i] == -1)
       {
           c--;
           if (c >= 0)
               temp.Add(input[i]);
           else
           {
              c = 0;
              compare.Add(temp);
              temp = new List<int>();
           }
       }
   }

   compare.Add(temp);
   return compare.OrderByDescending(x => x.Count).First();
}

更多测试用例：

Solve(new int[] { -1, 1, -1, 1, 1, -1 }); // => new int[] { 1, -1, 1, 1, -1 };

Solve(new int[] { 1, 1, -1, -1, 1, 1 }); // => new int[] { 1, 1, -1, -1, 1, 1 };

Solve(new int[] { 1, -1, 1, -1, 1, -1, -1, 1, 1, 1 }); // => new int[] { 1, -1, 1, -1, 1, -1 };

Solve(new int[] { 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1 } 
// => new int[] { 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1 };

Solve(new int[] { -1, -1, -1 }); // => new int[] { };

但我对你们所有 Linq 策划者的问题是：有没有什么方法可以在 1 行代码中使用我们心爱的 Linq 来做到这一点？

那将不胜感激：D

Answer 1

如果您必须使用 Linq，并且您可以作弊并使用 MoreLinq，那么这种丑陋的混乱会起作用（它会返回多个集合，因为理论上您可以多次运行相同的最大大小）

Enumerable.Range(0, input.Count())
    .Select(i =>
        input.Skip(i)
             .Scan((Current: 0, Total: 0), (x, y) => (y, x.Total + y))
             .Skip(1)
             .TakeWhile(x => x.Total >= 0))
    .MaxBy(x => x.Count())
    .Select(x => x.Select(y => y.Current));

Answer 2

在这种特殊情况下，由于条件逻辑相对复杂，我会说使用迭代方法是更好的选择，但一些类似的任务可以通过使用 Aggregate 函数来解决，该函数在序列上应用累加器函数并允许您传递状态步骤之间。对于您的情况，它可能看起来像这样（使用一些 C# 9 features）：

var result = arr
    .Select((i, index) => (i, index))
    .Aggregate(
        (Sum: 0, Ranges: new List<List<int>> {new()}), // state holder 
        (agg, curr) =>
        {
            var sum = curr.i + agg.Sum;
            if (sum >= 0) agg.Ranges.Last().Add(curr.i);
            if (sum < 0)
            {
                sum = 0;
                agg.Ranges.Add(new());
            }

            return (sum, agg.Ranges);
        })
    .Ranges
    .Aggregate((agg, curr) => curr.Count > agg.Count ? curr : agg); // MaxBy via Aggregate

Answer 3

我同意其他建议 LINQ 可能不是最佳方法的答案。这是我的看法。此版本仅将较短的序列替换为较长的序列以避免一些内存开销，然后也可以跳过 OrderByDescending 步骤。

public static List<int> Solve(int[] input)
{
    var temp = new List<int>();
    var longestSequence = new List<int>();

    for (int i = 0, c = 0; i < input.Length; i++)
    {
        c += input[i];

        if (c >= 0)
            temp.Add(input[i]);
        else
        {
            c = 0;
            if (temp.Count > longestSequence.Count)
                longestSequence = temp;
            temp = new List<int>();
        }
    }

    return longestSequence;
}

如果您真的关心内存分配，例如复制到临时列表和隐藏的列表大小调整操作，那么您可以只跟踪序列的开始和结束，然后循环返回子序列。

Answer 4

我最近在申请工作时必须进行的技能测试中遇到了这个问题。您需要很少的代码来解决它，并且不需要 LINQ。

int currentLevel = 0;
List<int> lst = new List<int>();
for(int x = 0; x < input.length; x++) {
  currentLevel += input[x];
  if (currentLevel >= 0) {
    lst.Add(input[x]);
  }
}
return lst.ToArray();