C# 获取数组中连续元素的最大和

我想得到数组中三个连续元素的最大和，以及最大和的起始元素的索引

在给定数组中

int a[] = {2,1,3,2,4,6,7,9,1}     

最大总和=6+7+9=22 最大和的起始索引是起始项-6的5索引

我已经编写了如下代码，但它的性能效率不高。不确定使用Linq是否能提供更好的结果

谁能提出更好的办法

private static int[] getConsecutiveSum(int[] a, int k)
        {
            List<int> lst = new List<int>();
            for (int x = 0; x < a.Length; x++)
            {
                lst.Add(getsum(a, x, k));
            }

            var max = lst[0];
            var index = 0;
            for(var i = 0; i <lst.Count; i++)
            {
                if(lst[i] > max)
                {
                    max = lst[i];
                    index = i;
                }
            }
            int[] result = new int[2];
            result[0] = max;
            result[1] = index;
            return result;
        }

        private static int getsum(int[] a, int s, int e)
        {
            var sum = 0;
            var loop = 1;
            for (int x = s; x < a.Length; x++)
            {
                sum = sum + a[x];
                loop++;
                if (loop > e) break;
            }
            if (loop > e) return sum;
            else return 0;
        }
}

---

嗯，在LINQ，它将是这样的：

var result = a.Select((s, i) => new { Sum = a.Skip(i).Take(3).Sum(), Index = i })
              .OrderByDescending(o => o.Sum)
              .First();

Console.WriteLine($"MaxSum: {result.Sum}, StartIndex: {result.Index}");

输出：

最大总和：22，起始索引：5

对于您的任务，看起来是这样的：

private static int[] getConsecutiveSum(int[] a, int k)
{
    int[] result = new int[2];
    var maxSum = a.Select((s, i) => new { Sum = a.Skip(i).Take(k).Sum(), Index = i })
                  .OrderByDescending(o => o.Sum)
                  .First();
    result[0] = maxSum.Sum;
    result[1] = maxSum.Index;
    return result;
}

我没有将您的方法的返回类型从int[]更改为tuple或其他类型，因为如果这是一个在线编码挑战或其他问题，那么我猜您不允许更改方法的返回类型以使代码检查自动化成为可能。

您不希望任何集合列表找到最大值；我们只需要扫描阵列。因为我们想要返回2个值，所以让我们使用Tuple作为最简单的实现

private static Tuple<int, int> getMaxSum(int[] a, int k) {
  int sum = a.Take(k).Sum();
  int max = sum;
  int index = 0;

  for (int i = k; i < a.Length; ++i) {
    sum = sum - a[i - k] + a[i];

    if (sum > max) {
      max = sum;
      index = i - k + 1;
    }
  }

  return Tuple.Create(max, index);
}

...

int a[] = new int[] {
  2, 1, 3, 2, 4, 6, 7, 9, 1};

var result = getMaxSum(a, 3);

Console.Write($"Sum is {result.Item1}; starting index is {result.Item2}");

---

在不使用Linq的情况下，它的性能会更有效。由于您希望从方法中获得两个值，因此可以使用out参数：

private static void GetConsecutiveSum(int[] values, out int maximumSum, out int startIndex)
{
    maximumSum = 0;
    startIndex = -1;
    for (int i = 0; i < values.Length - 2; i++)
    {
        int sequenceSum = values[i] + values[i + 1] + values[i + 2];
        if (sequenceSum > maximumSum)
        {
            maximumSum = sequenceSum;
            startIndex = i;
        }
    }
}

---

只需遍历每个数字，直到最后一个减去你想要得到的连续数。然后每次只需添加数字，如果总和更高->保存索引和总和，如果不是->继续。那有什么难的？你的代码看起来很慢，因为你做了一些不必要的事情，[]={2,1,3,2,4,6,7,9,1}是数组声明吗？有人请先解决这个问题。您需要在数组中处理int.MaxValue和int.MinValue作为可能的值吗？或者您可以返回一个tupleint max，int索引名为tuplesawesomness@TheGeneral：你说得很对，谢谢！然而，命名的tuples仅出现在C7.0中，这就是为什么OP使用第6版甚至第4版呢？我将其实现为tuple

private static void GetConsecutiveSum(int[] values, out int maximumSum, out int startIndex)
{
    maximumSum = 0;
    startIndex = -1;
    for (int i = 0; i < values.Length - 2; i++)
    {
        int sequenceSum = values[i] + values[i + 1] + values[i + 2];
        if (sequenceSum > maximumSum)
        {
            maximumSum = sequenceSum;
            startIndex = i;
        }
    }
}