# sum of an array using recursion Javascript

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;
}
console.log(array[i]);
if(i === array.length-1){
return array[i];
}
}
};
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
``````

## Reasoning

• In a recursive call, you need to model your task as reduction to a base case. The simplest base case in this case is the empty array - at that point, your function should return zero.
• What should the reduction step be? Well you can model a sum of an array as the result of adding the first element to the `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);
}
}
``````

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

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:

• you can use .reduce() method
• or perform a simple tail recursion

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.

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

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
``````

``````function sumNumbersRecursively(input){
if (input.length == 0){
return 0;
} else{
return input.shift() + sumNumbersRecursively(input);
}
}

console.log(sumNumbersRecursively([2,3,4]))``````