Looking for a way to solve this problem by recursing sum(). Right now, the code works, but I am supposed to call sum() more than once, and it should not mutate the input array.
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
A one-liner that meets all your requirements:
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 of the remainder of the array - at some point, these successive calls will eventually result in a call to sum([]), the answer to which you already know. That is exactly what the code above does.array.slice(1) creates a shallow copy of the array starting from the first element onwards, and no mutation ever occurs on the original array. For conciseness, I have used a ternary expression.Breakdown:
sum([1,2,3])
-> 1 + sum([2,3])
-> 1 + 2 + sum([3])
-> 1 + 2 + 3 + sum([])
-> 1 + 2 + 3 + 0
-> 6
You're on the right track, but consider that sum could take an optional second argument (that defaults to zero) that indicates the position to start summing from...
function sum(array, n) {
n ||= 0;
if (n === array.length) {
return 0;
} else {
return array[n] + sum(array, n + 1);
}
}
n ||= 0; doing? Is it short for n = n || 0 ?
if (n === undefined) n = 0;
n || = 0 ES6? It's so usefulfunction sumArr(arr){
if(arr.length>1){
return arr.pop()+sumArr(arr);
}else{
return arr[0];
}
}
function sumNumbersRecursively(input){
if (input.length == 0){
return 0;
} else{
return input.shift() + sumNumbersRecursively(input);
}
}
console.log(sumNumbersRecursively([2,3,4]))
You don't really need the add function inside your sum function just inline the function and initiate with, 0 as a starting point, or optionally check the i variable for undefined and initialize it to 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
You have two solutions:
With reduction:
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);
With recursion:
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));
Personally, I find the first solution more elegant.
arr = [1,2,3,4]
sum = arr.reduce((acc, curr)=> acc+curr)
If you have to call sum more than once, then use the binary approach: split the array in half and recur on each piece. When you get to a length of 1, return the single value.
Does this work for you? I'm afraid I don't recall the JS syntax for array slices, so my recursion statement may be wrong in the details.
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
O(n).
function sum(array) { return array.length ? array[0] + sum(array.slice(1)) : 0; }suman extra optional parameter :-)