Given an array of two element as minimum and maximum values (`[min, max]`

), how can you sum up all the values between the min and max values?

```
rangeSum([1, 9]) // 45
rangeSum([5, 12]) // 68
```

We are about to dive into 3 ways to achieve this!

### Prerequisite

To flow with this article, it is expected that you have basic understanding of javascript's array methods.

### Let's Sum a Range of values using:

- while...loop

```
function rangeSum(array) {
let result = 0;
let i = 0;
while (i < array[1]) {
result = result + (i + array[0]);
i++;
}
return result;
}
```

- for...loop

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

- for...loop, push(), reduce()

```
function rangeSum(array) {
let rangeArray = [];
for (let i = array[0]; i <= array[1]; i++) {
rangeArray.push(i);
}
let result = rangeArray.reduce((acc, char) => acc + char);
return result;
}
```

### Conclusion

There are many ways to solve problems programmatically. You are only limited by your imagination. Feel free to let me know other ways you solved yours in the comment section.

If you have questions, comments or suggestions, please drop them in the comment section.

You can also follow and message me on social media platforms.

Thank You For Your Time.

## Discussion

I tried to implement the algorithm myself and came up with a solution that is utilizing the formula for

sums by Gauss.IDK how to explain the equation but it would look like this:

I implemented this in typescript to see if it works:

The

`startingPoint - 1`

is adjusting that the formula would be excluding the min and we want to include it. In general it seems to be working quiet well.The advantage here also is that it only has to execute

2 operationsno matter how large the span is.This would decrease the time complexity to

O(1). Which is quiet nice.Kay, thank you for your suggestion. This is how I did it with

`javascript`

:So, I had to add the lower boundary (min value) to the final answer to make it work properly.

Yeah. You either have to add the

`min`

value or subtract`minManipulation(array[0]-1)`

because otherwise it will exclude the lower boundary. So I corrected the formula to reflect this change (just in case anybody is interested in this).Looking Good 💪