使用递归Javascript的数组的总和

Question

通过递归sum()寻找解决此问题的方法。 现在，代码有效，但我应该不止一次调用sum() ，并且它不应该改变输入数组。

var sum = function(array) {
    if(array.length === 0){
        return 0;
    }
    function add(array, i){
        console.log(array[i]);
        if(i === array.length-1){
            return array[i];
        }
        return array[i] + add(array, i+1);
    }
    return add(array, 0);
};
sum([1, 2, 3, 4, 5, 6]) //21

Answer 1

满足您所有要求的单衬纸：

var sum = function(array) {
    return (array.length === 0) ? 0 : array[0] + sum(array.slice(1));
}

// or in ES6

var sum = (array) => (array.length === 0) ? 0 : array[0] + sum(array.slice(1));

// Test cases
sum([1,2,3]); // 6

var s = [1,2,3];
sum(s); // 6
sum(s); // 6

推理

• 在递归调用中，您需要将您的任务建模为简化为基本情况。 在这种情况下，最简单的基本情况是空数组——此时，您的函数应该返回零。
• 减少步骤应该是什么？ 好吧，您可以将数组的总和建模为将第一个元素添加到数组其余部分的sum的结果 - 在某些时候，这些连续调用最终将导致调用sum([]) ，这是对你已经知道了。 这正是上面的代码所做的。
• array.slice(1) 从第一个元素开始创建数组的浅拷贝，并且原始数组上不会发生任何变化。 为简洁起见，我使用了三元表达式。

细分：

sum([1,2,3])
-> 1 + sum([2,3])
-> 1 + 2 + sum([3])
-> 1 + 2 + 3 + sum([])
-> 1 + 2 + 3 + 0
-> 6

Answer 2

您走在正确的轨道上，但请考虑 sum 可以采用可选的第二个参数（默认为零），指示从...开始求和的位置。

function sum(array, n) {
    n ||= 0;
    if (n === array.length) {
        return 0;
    } else {
        return array[n] + sum(array, n + 1);
    }
}

Answer 3

arr = [1,2,3,4]
sum = arr.reduce((acc, curr)=> acc+curr)

Answer 4

您实际上并不需要 sum 函数中的 add 函数，只需将函数内联并以 0 作为起点启动，或者可选地检查 i 变量是否为 undefined 并将其初始化为 0！

var sum = function(array, i) {
    if(array.length === 0){
        return 0;
    }
  console.log(array[i]);
  if(i === array.length-1){
    return array[i];
  }
  return array[i] + sum(array, i+1);
};
console.log(sum([1, 2, 3, 4, 5, 6],0)) //21

Answer 5

您有两种解决方案：

• 你可以使用.reduce()方法
• 或执行简单的尾递归

减少：

function sum(a, b) {
  return a + b;
}

const array = [1, 2, 3, 4, 5, 6];

//In our reduce, we will apply our sum function, 
//and pass the result as the next value
const res = array.reduce(sum);

递归：

function sumRec(array, acc = 0, index) {
    //We will update our accumulator, and increment
  // the value of our current index
  return index === array.length
  ? acc
  : sumRec(array, acc += array[index], ++index);
}

console.log(sumRec(array, 0, 0));

就个人而言，我发现第一个解决方案更优雅。

Answer 6

function sumArr(arr){
  if(arr.length>1){
    return arr.pop()+sumArr(arr);
  }else{
    return arr[0];
  }
}

Answer 7

 function sumNumbersRecursively(input){ if (input.length == 0){ return 0; } else{ return input.shift() + sumNumbersRecursively(input); } } console.log(sumNumbersRecursively([2,3,4]))

Answer 8

如果您必须多次调用sum ，则使用二元方法：将数组分成两半并在每一块上重复。 当长度为 1 时，返回单个值。

这对你有用吗？ 恐怕我不记得数组切片的JS语法，所以我的递归语句可能在细节上是错误的。

var sum = function(array) {
    if(array.length === 1){
        return array[0];
    }
    mid = array.length / 2
    return sum(array[0:mid-1]) + sum(array[mid:array.length-1])
};
sum([1, 2, 3, 4, 5, 6]) //21