# Happy Numbers

This problem was a tough one as it involved recursion, but also a tricky condition in which to *end* the recursion.

Given any number, we can create a new number by adding the sums of squares of digits of that number. For example, given 203, our new number is 4 + 0 + 9 = 13. If we repeat this process, we get a sequence of numbers:

203 -> 13 -> 10 -> 1 -> 1

Sometimes, like with 203, the sequence reaches (and stays at) 1. Numbers like this are called happy.

Not all numbers are happy. If we started with 11, the sequence would be:

11 -> 2 -> 4 -> 16 -> …

This sequence will never reach 1, and so the number 11 is called unhappy.

Given a positive whole number, you have to determine whether that number is happy or unhappy.

## Examples

happy(203) ➞ true

happy(11) ➞ false

happy(107) ➞ false

## My solution

My solution was started with recursion, but then I ended up following the pattern of this solution found on StackOverFlow.

```
// We initialize the function with an additional parameter - the prev array that will store values that recur
function happy(n, prev=[]) {
// A helper function, sumSquares, adds the square of each digit in the number passed into it.
const sumSquares = n => [...String(n)].map(Number).reduce((a, c) => c * c + a, 0)
// ss is initialized to hold the result of sumSquares(n)
let ss = sumSquares(n)
// if sumSquares(n) is equal to 1, then return true and end recursion.
if (ss === 1) return true
// if we've already seen the result of sumSquares(n), then return false
if (prev.includes(ss)) return false
// push the result of sumSquares onto the prev array
prev.push(ss)
// run the happy function again using ss (sumSquares of n) and the array prev as arguments.
return happy(ss, prev)
}
happy(100) // true
happy(101) // false
happy(102) // false
happy(103) // true
happy(104) // false
happy(105) // false
happy(106) // false
happy(107) // false
happy(108) // false
happy(109) // true
happy(110) // false
```

The tricky part here for me was figuring out how to make the recursive loop stop once a number is found that won’t reduce down to 1 (unhappy). The solution here was to use an array to pass the results of sumSquare(n) and hold the result to make sure that it isn’t in the array already using the `Array.prototype.includes()`

method.

## Other solutions

Here are two other solutions that I thought were interesting.

This one is concise, and uses the `if`

statements to check if `n`

is equal to 1 or 4, if they are, then the recursive loop is stopped since 1 is the end of the happy number search and happy numbers do not have a 4 in them. The real nitty-gritty of the function is in the return statement that includes `.reduce()`

, and passes in the `Math.pow`

operation on each number and adds them to the sum, with zero passed as the second argument or currentValue.

```
function happy(n) {
if (n == 1) return true;
if (n == 4) return false;
return happy([...n.toString()]
.reduce((sum, v) => Math.pow(Number(v), 2) + sum, 0))
}
```

Here’s another good solution. This is similar to the above in that it checks for 1 and 4. The end result of 1 is true and the end result of 4 is false. Pretty different from my solution as I didn’t check for 4 (I could have instead of using the prev array.)

```
const sum = arr => arr.reduce((total, num) => total + num, 0);
const getDigits = num => String(num).split('').map(Number);
const happy = num => {
if (num === 1) return true;
if (num === 4) return false;
return happy(sum(getDigits(num).map(digit => Math.pow(digit, 2))));
};
```