Javascript 使用分隔符查找最大子数组长度

我试图解决这个问题：

---

给定两个参数：数组

a

和整数

i

，找出所有元素之和为

的最大数组长度。蛮力方法可能是解决此问题的最佳方法。从每个条目开始，看看你能走多远，然后才能得出一个和
>i
，如果它比你迄今为止看到的最好的，保存它。我在下面提供了一个示例Java解决方案，我还没有实际运行它，所以我的一个或两个索引可能会关闭，但我认为您可以了解要点。运行时是O（n^2），内存是O（n）（两者都与#getMaxSubArray（newint[]{1,2,3,4,5,6,7,8,9,10}，1000000）一起出现）

private int[]getMaxSubArray（int[]a，int i）{
int minIndex=0；
int maxIndex=-1；
对于（int j=0；ji）{
继续；
}
整数和=a[j]；
对于（int k=j+1；ki）{
如果（（k-1）-j>maxIndex-minIndex）{
maxIndex=k-1；
minIndex=j；
}
打破
}
总和+=a[k]；
}
}
如果（最大索引-最小索引<0）{
返回null；
}
int[]结果=新的int[maxIndex-minIndex+1]；
对于（int p=minIndex；p我将这样做

首先，我们将通过从原始数组中只取最小的元素来获得最长的子数组，因为这样一来，随着我们的进行，总和将尽可能最小。因此：


const-original=[3,1,2,1]；
常数maxsum=4；
//为了确保我们只取最小的，让我们
//直接对数组进行排序。这样最小的
//元素将始终是第一个。
//.slice调用是制作一个副本，所以我们不会更改
//原件：
const sorted=original.slice（）.sort（）；
//这是你的求和函数，看起来很合法。
函数数组（a）{
返回a.reduce（（a，b）=>a+b，0）
}
//现在从排序数组的前面获取项目并
//将它们放入新阵列中，直到原始阵列
//空或达到最大值。
设子阵=[]；
while（排序.长度）{
//获取下一个最小的元素。它始终是
//第一个是因为那种。
常量最小=排序的.shift（）；
//如果我们所有的加上这个新元素
//大于最大值，我们的工作完成：
if（SUMRARY（子阵列）+最小>最大和）中断；
//否则，将其添加到子数组并继续。
子阵列推送（最小）
}
//循环运行后，要么元素用完，
//或者我们达到了极限。不管怎样，我们的工作都完成了。
log（“原始数组：”，原始）；
log（“最大子集：”，子数组）；
console.log（“最大子集长度：”，subarray.length）；
这是我的解决方案。它将返回子数组的最大长度。你们能看一下吗，伙计们

function maxLength(a, k) {
const sortedArray = a.sort((i,j) => i - j);
let sum = 0;
let length = 0;
const subArray = [];
for (let i=0; i < sortedArray.length; i++) {
   sum = sum + sortedArray[i];
   if (sum <= k) {
      length++;
      subArray.push(sortedArray[i]);
   } else {
       return length;
   }
}
return length;
}

函数最大长度（a，k）{
常数sortedArray=a.sort（（i，j）=>i-j）；
设和=0；
设长度=0；
常量子数组=[]；
for（设i=0；i如果（总结：我们没有做你的家庭作业。展示你尝试过但不起作用的东西。展示你尝试过的东西。如果你完全迷路了：继续从数组中取出最小的元素，直到所取项目的总和达到你的极限，或者直到你拿走了所有东西。我添加了我的代码。我会尝试你所说的@CRiceI我不明白那会如何工作，因为我没有从阵列中取出最小的元素已经解决了该元素的问题，这是著名的“最大子阵列问题”的一个变种。如果你搜索Wikipedia，你会发现一个有用的介绍和一些可能的解决方法。这可能不需要对数组进行排序吗？我认为唯一的区别是跟踪最后添加的一个小元素，并查找下一个最小的元素，对吗？你的代码看起来几乎是正确的答案，但在一个测试用例中应该返回“46”它返回了数组长度的“49”。这是plunker：嗯，我确实注意到了排序的一个错误，因为它是按unicode顺序排序的，而不是按升序排序的。这是通过在排序中添加一个比较器来修复的，例如：
.sort（（a，b）=>a-b）
。但是，随后长度增加到51，总和为22045。你能说一下为什么你认为结果应该是46而不是51吗？我以为目标是尽可能长？嗯。我想你可能有其他条件。子数组必须是原始数组的一个连续部分吗？如果是，那么结果确实是正确的46！我将编辑答案以将其考虑在内。是的，它应该是原始数组的连续块。谢谢
private int[] getMaxSubArray(int[] a, int i) {
  int minIndex = 0;
  int maxIndex = -1;
  for (int j = 0; j < a.length; j+=1) {
    if (a[j] > i) {
      continue;
    }

    int sum = a[j];
    for (int k = j + 1; k < a.length; k++) {
      if (sum + a[k] > i) {
        if ((k - 1) - j > maxIndex - minIndex) {
          maxIndex = k - 1;
          minIndex = j;
        }
        break;
      }
      sum += a[k];
    }
  }

  if (maxIndex - minIndex < 0) {
    return null;
  }
  int[] result = new int[maxIndex - minIndex + 1];
  for (int p = minIndex; p <= maxIndex; p += 1) {
    result[p - minIndex] = a[p];
  }
  return result;
}

function maxLength(a, k) {
const sortedArray = a.sort((i,j) => i - j);
let sum = 0;
let length = 0;
const subArray = [];
for (let i=0; i < sortedArray.length; i++) {
   sum = sum + sortedArray[i];
   if (sum <= k) {
      length++;
      subArray.push(sortedArray[i]);
   } else {
       return length;
   }
}
return length;
}