How to Solve the Digital Root Algorithm using JavaScript

One of my favorite algorithms is finding the digital root of any given integer. A digital root is a single-digit sum that is reached when you iteratively add up the digits that make up a number.

For example:

666=> 6 + 6 + 6=> 18=> 1 + 8 => 9

The key to solving this algorithm is to use recursion. The solution has to be smart enough to keep executing as long as the returned sum is higher than a single-digit number.

The approach

1. If our given integer is greater than 9, iterate through each digit in the number.
2. Add up each digit.
3. Assess if the sum is a single-digit number.
4. If not, go back to Step 1.

Let's break it down

1) Create a variable for the sum. Set it to equal the given integer. If this integer is a single-digit number, we'll return it at the very end without mutating it.

function digitalRoot(number) {   let sum = number}

2) Write a conditional statement to execute something on the sum if it's a multi-digit number.

function digitalRoot(number) {   let sum = number   if (sum > 9) {      // execute something here   }}

3) If the number is greater than 9, turn it into an array so that we can loop through it. In JavaScript, we have to turn the integer into a string, and then call the split() method on it to achieve this.

function digitalRoot(number) {   let sum = number   let arr = []   if (sum > 9) {      arr = sum.toString().split("")      console.log(arr)    }}digitalRoot(24)=> ["2", "4"]

4) Now let's iterate through the array and sum its elements. We can use the reduce() method for this. reduce() requires a reducer method to execute on, so let's write the logic for it and pass it into reduce(). Inside the reducer method, convert the values into an integer by wrapping each value in parseInt. Since this method will return a single value, we can reassign it to our sum variable.

function digitalRoot(number) {   let sum = number   let arr = []   let reducer = (a,b) => parseInt(a) + parseInt(b)   if (sum > 9) {      arr = sum.toString().split("")      sum = arr.reduce(reducer)      console.log(sum)    }}digitalRoot(24)=> 6

Et voil! We've solved the algorithm!
...Just kidding. It totally breaks if we pass in any larger numbers.

digitalRoot(666)=> 18

Let's take into account recursion! How can we keep executing our function while the sum is a multi-digit number?

5) Instead of a conditional if statement, let's use a while loop. The while loop will run while a condition is true, whereas an if statement will just execute once. Let's also move our console.log statement to the end of the function, outside of the loop, so that it only returns a single value.

function digitalRoot(number) {   let sum = number   let arr = []   let reducer = (a,b) => parseInt(a) + parseInt(b)   while (sum > 9) {      arr = sum.toString().split("")      sum = arr.reduce(reducer)   }   console.log(sum) }digitalRoot(666)=> 9

Conclusion

This is one of my favorite algorithms because it's not the most difficult to solve, but still poses an interesting problem. Sound off in the comments if you have a different way of solving this!