#### The Ultimate Guide to JavaScript Algorithms - Lesson #20

# JavaScript Algorithms: Range Sum

Sometimes, while performing mathematical calculations, there comes the need to sum up a range of numbers. Some programming languages make this easy by implementing helper functions that enable one achieve such tasks simply via a function call. Not JavaScript!

In this challenge, we implement our own helper function for summing up numbers within a specified range. The range is specified using an array in the format:

```
[minimum,maximum]
```

You should already have your development environment setup for this course. Open the cloned repository and inside the `Beginner`

folder, navigate to the `rangeSum`

folder. Our work for this challenge will be done in here. Make sure to follow along in the `index-START.js`

file.

Given an array of two numbers, return the cummulative sum of the two numbers and all the numbers between them. E.g

```
rangeSum([1,9])
// Should return 45 i.e 1+2+3+4+5+6+7+8+9
```

We are to write a function that accepts one parameter i.e an array containing the minimum and maximum limit of the range respectively.

To solve this challenge, we need to sum up all the numbers as we loop through all the numbers starting from the minimum until we arrive at the maximum limit.

**Pretty straightforward**!** Let's do this**!

Let's now consider four ways to solve this challenge. They are:

- Using a For-loop
- Using the Arithmetic Progression Formula
- Using Recursion
- Using .reduce()

In this approach, we use a **For**-**loop** to iterate through every value from the minimum `arr[0]`

to the maximum `arr[1]`

.

```
function rangeSum(arr) {
let sum = 0;
for (i = arr[0]; i <= arr[1]; i++) {
sum += i;
}
return sum;
}
```

Notice how we initialize an accumulator variable `sum`

to `0`

. With `sum`

, we accumulate the sum by adding the current value of the iterator on every iteration. We basically start at the minimum value received and add every number we encounter to our sum until we arrive at the maximum number.
At the end, we return sum as the final result.

Now let's try using a formula.

In mathematics, an **arithmetic progression** (AP) or **arithmetic sequence** is a sequence of numbers ordered such that the difference between the consecutive terms is constant. This simply means, a list of numbers where the difference between each number and the next is always the same. Notice that in a range as shown below, this applies.

```
1,2,3,4,5,6,7,8,9,...
```

In the sequence above, the common difference is 1 and this will remain the case no matter how much farther we extend the list.
A general formula for calculating the sum of an arithmetic progression for a certain range of numbers with `n`

number of elements is:

a1 = First term of the sequence an = Last term of the sequence n = Number of elements in the sequence

In the solution below we apply this formula in solving the challenge.

```
function rangeSum(arr) {
return ((arr[1] - arr[0] +1) * (arr[0] + arr[1])) / 2;
}
```

We derive the value of `n`

as `maximum limit - minimum limit + 1`

as shown in the first bracket within the return statement. The rest of it follows accordingly, thus we arrive at the final sum which we return from the function.

Now let's try recursion.

In this solution we apply recursion by continually reducing the maximum limit and summing up all the returned values to arrive at the final sum.

```
function rangeSum(arr) {
if (arr[0] == arr[1]) {
return arr[0];
} else {
return rangeSum([arr[0], arr[1] - 1]) + arr[1];
}
}
```

Notice that we first specify a terminating case such that as soon as the maximum and minimum limits are equal, the recursion terminates by returning the current minimum i.e `arr[0]`

.

A step by step analysis of what is going on above will reveal that while we continually reduce the value of the maximum limit by `1`

for each recursive cycle i.e `arr[1] -1`

, we sum up all the maximum limits up until the minimum limits equals the maximum limit. Thus, for `rangeSum([1,9])`

, we would have:

```
9+8+7+6+5+4+3+2+1
```

Let's consider one final approach.

To apply this method, we first need to generate an array containing all the numbers found within the specified range. Thus, we initialize a variable `arrList`

with an empty array for this purpose. Using a **for**-**loop**, with our iterator `i`

starting from the minimum value `arr[0]`

we push every value of `i`

into our `arrList`

until we arrive at the maximum limit `arr[1]`

.

```
function rangeSum(arr) {
let arrList = [];
for (i = arr[0]; i <= arr[1]; i++) {
arrList.push(i);
}
return arrList.reduce((acc, num) => acc + num, 0);
}
```

After successfully populating `arrList`

, we call the `.reduce()`

method on the array. Starting with `0`

as the initial value of the accumulator, we add the current number `num`

from the array list to the accumulator and then move on to the next. At the end of this process, the final value arrived at is the sum and is returned as such.

**Wheeew**!!!** That was pretty tasking.**

To test the solutions above, run the following command from your terminal:

```
npm run test rangeSum
```

You'll notice that we've passed all tests. 💯 Now let's test performance.

Here on JSPerf, we run a performance comparison of the four solutions explored above. The screenshot below reveals the result.

The performance test above reveals that the optimal solution is the Arithmetic Progression Formula. The least optimized solution which is approximately 100% slower is the Recursive Method.

This challenge finds its application in mathematical operations involving number theory and combinatorics. It also suffices as a coding challenge.

We have now considered four(4) ways to sum up numbers within a specified range. We have also successfully identified the optimal solution to be the **Arithmetic Progression Formula.**
Make sure to explore other ways of solving this challenge. You can always perform a performance comparison using JSPerf as well as share your findings in the comment section.

For more information on the techniques and concepts applied above, you may use the following links:

**See you in the next one**!**✌🏿**

### Want to improve your coding and design skills?

I'm continually researching the best practices and tools for coding.

Join 50,000+ developers looking to make cool stuff.

We value your privacy. 1-click unsubscribe.

## Comments

What did you think of the article? Let us know!

(these comments are powered by GitHub issues and use 0 trackers)