Javascript 字符串加法I coderbyte完全被难住了

有谁能像一个6岁的孩子那样向我解释这个解决方案吗？我无法理解这些解决方案。也许是一些代码注释

多谢各位

---

我在coderbyte上花了两个小时试图解决这个问题。问题是：

让函数ArrayAdditionI（arr）获取存储的数字数组 在arr中，如果 数组的总和可以等于数组中的最大数， 否则返回字符串false。例如：如果arr包含[4,6， 23,10,1,3]输出应返回true，因为4+6+10+3= 23数组不会为空，不会包含所有相同的元素，并且可能包含负数

我浏览了互联网，从coderbyte上的人们的答案中阅读了很多人的解决方案，但是没有任何评论，我真的很难弄清楚这是怎么做到的。我已经开始了无数次，所以我甚至不确定最后一次尝试是否更好

我知道我需要以某种方式循环测试每个组合索引5、索引4、索引3、索引2、索引1，以及每个小于所有组合的组合（即索引5和索引3）。我就是不知道该怎么做。如果我知道列表总是由5个数字组成的数组，它需要所有5个数字，我会写5个循环，所有循环都相等地嵌套在一个大循环中，对吗？然而，由于不需要所有的数字，也不知道所有情况下数组的长度，这增加了复杂性，我完全被难住了。我尝试使用Math.floor（Math.random（）*array.length）；要生成数字列表。。。但这也不起作用

function ArrayAdditionI(arr) { 
  var longest = arr.sort( function(a,b) { return a-b });
  var longest = longest[longest.length - 1];

  var sumArr = function (arrb) {
    var sum = 0;
    for (var z = 0; z < arrb.length; z++){
      sum += arrb[z];
    }
    return sum;
  };

  for (var i = 0; i > arr.length; i++) {
    for (var y = 0; y > arr.length; i++) {
    testArr.push(arr[i]);
    if (sumArr(testArr) === longest) {
      return true;
    }
    testArr.push(... its 4am and I'm stumped!...)
    }}


  // code goes here  
  return false; 

}

// keep this function call here 
// to see how to enter arguments in JavaScript scroll down
ArrayAdditionI(readline());           

函数数组添加（arr）{
var longest=arr.sort（函数（a，b）{返回a-b}）；
var longest=最长[最长.长度-1]；
var sumArr=函数（arrb）{
var总和=0；
对于（var z=0；zarr.length；i++）{
对于（变量y=0；y>arr.length；i++）{
测试推力（arr[i]）；
if（sumArr（testArr）==最长）{
返回true；
}
推（凌晨4点，我被难住了！）
}}
//代码在这里
返回false；
}
//将此函数调用保留在此处
//要查看如何在JavaScript中输入参数，请向下滚动
ArrayAdditionI（readline（））；

四月份的评论基本上告诉了你问题的名称以及在谷歌上搜索的内容

java代码中的解决方案如下所示

1）

这是理论和伪代码

2）

如果集合数>0，请更改代码以返回所需的内容

3）修改下面代码中的GetAllSubsetByStack，以便在找到集合时停止：

---

下面是一个相当简单易懂的常见问题解决方案。它基本上是通过将每个后续数字（循环j）相加，在数组中向前循环（循环i）。如果循环j在没有解决方案的情况下结束，则循环k开始并删除每个后续编号。然后我递增，循环重新开始

function ArrayAdditionI(arr) { 
  arr.sort(function(a,b){return a - b})
  var largest = arr.pop();  // Set largest to last (largest) array value
  var sum = 0;
  for (var i = 0; i < arr.length; i++){     // Start outer loop 
    sum += arr[i];
    for (var j = 0; j < arr.length; j++){   // Start inner to begin sum
      if (i != j) {     // Ensure we don't add the same array index to itself
        sum += arr[j];
        console.log(sum);
        if (sum == largest) {
          return true;
        }
      }
    }
    for (var k = 0; k < arr.length; k++) {  // If no match, start 2nd loop to re-iterate removing index values
      if (i != k) {
        sum -= arr[k];
        console.log(sum);
        if (sum == largest) {
          return true;
        }
      }
    }
    sum = 0;    // Reset sum for outer loop
  }
  return false; 
}

函数数组添加（arr）{
sort（函数（a，b）{返回a-b}）
var max=arr.pop（）；//将最大值设置为最后一个（最大）数组值
var总和=0；
对于（var i=0；i

在我昨晚参加的一次会议上，我们对“MakeChange”算法进行了类似的递归。今天早上，我在几个星期没有看这个问题之后，用新的眼光看了看这个问题。这是我想到的

本质上：将数组排序为从大到小，将其移到小，并将其声明为“目标”，然后通过在每次递归时将其越来越小地切片来递归减少数组，当数组达到0长度时，将原始数组随机化并再次开始减少

如果目标=总计（即减少），则返回true 如果我随机化数组超过1000次，则返回false

function ArrayAdditionI(arr) {

  var originalArr = arr.sort(function(a,b) {return b-a});
  var goal = arr.shift();
  var counter = 0;

  function randomArray(array) {
    for (var i = array.length - 1; i > 0; i -= 1){
      var j = Math.floor(Math.random() * (i + 1));
      var temp = array[i];
      array[i] = array[j];
      array[j] = temp;
    }
    return array;
  }

  function recurse(arr) {
    if (arr.length == 0){
      counter++
      var newArr = randomArray(originalArr);
      return recurse(newArr);

    } else {

      var total = arr.reduce(function(a,b) {return a+b});

      if (goal == total){
        return true

      } else if (counter == 1000) {
        return false 

       } else {
         newArr = arr.slice(1);
         return recurse(newArr);


       }
    } 
  }

  // code goes here  
  return recurse(originalArr); 

}

---

休息一下，稍后再来，谷歌搜索子集和问题你的解决方案可以通过稍微修改nice找到！今天早上我刚刚添加了一个递归版本。奇怪的巧合是我已经好几个星期没看这个问题了。