Solving the Digital Root Algorithm using JavaScript
Tags: javascript, challenge
Published: 2020-05-17 03:45:48

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:
```javascript
666
=> 6 + 6 + 6
=> 18
=> 1 + 8 
=> 9
```

The key to solving this algorithm is to use an iterative method. 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.

```javascript
function digitalRoot(number) {
   let sum = number
}
```

2) Write a conditional statement to execute _something_ on the sum if it's a multi-digit number.
```javascript
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.

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

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

```javascript
digitalRoot(666)
=> 18
```

So 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.

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

## Edits made after publishing
Changed the wording in this article because I originally talked about using a recursive solution, but ended up writing just an iterative one. Thanks for all the comments! ✨