In the last month I encountered multiple *algorithmic tasks* which involved the processing of individual digits in a number. And I found out a **very common** solution is to stringify the number and then process the letters as the separate digits. So I thought I’d share a better approach.

## Leetcode Example

This is the assignment of Leetcode 202 problem, also called Happy Number.

Write an algorithm to determine if a number

`n`

is happy. Ahappy numberis a number defined by the following process:

- Starting with any positive integer, replace the number by the sum of the squares of its digits.
- Repeat the process until the number equals 1 (where it will stay), or it
loops endlessly in a cyclewhich does not include 1.- Those numbers for which this process
ends in 1are happy.Return

`true`

if`n`

is a happy number, and`false`

if not.## Examples

Example 1:

- Input: n = 19
- Output: true
Explanation:

12 + 92 = 82

82 + 22 = 68

62 + 82 = 100

12 + 02 + 02 = 1

Example 2:

- Input: n = 2
- Output: false

Now I found this solution on Youtube: Google LOVES this coding interview question. It’s in Python and it goes something like this:

```
def isHappy(n: int) -> bool:
seen = set()
current = str(n)
while current not in seen:
seen.add(current)
sum = 0
for digit in current:
digit = int(digit)
sum += digit ** 2
if sum == 1:
return True
current = str(sum)
return False
```

The main grudge I have with this method is (as the post title suggests) that it

- It first turns the number into a string
- It then iterates over the letters of the string
- Turns the letter
**back into a number** - Does the calculation

You don’t have to deal with the string nonsense to solve this!!! This is a numerical task. The input is a number.

You already have the number!Just work with it as it is!

## Process a number digit by digit

You can get the last digit of a number by modulating it by 10.

`42 % 10 # 2`

We can *“shift”* the number and get rid of the last digit by dividing it by 10. Here we actually want to divide it so that we get an integer back, not a float.

`42 // 10 # 4`

This is basically all you need to solve this kind of problem. We could optimize further, but this is the heart of the task and it needed some love.

## A better solution

This is a solution implementing the **numerical approach** explained above.

```
def isHappyNum(n: int) -> bool:
seen = set()
while n not in seen:
seen.add(n)
sum = 0
while n > 0:
digit = n % 10
sum += digit * digit
n //= 10
if sum == 1:
return True
n = sum # Try again for the summed number
return False
```

It’s very similar to the previous one! Some key differences are

- I’m treating
`n`

as the current working value. - Instead of looping over letters, the inner loop stops when
`n`

reaches zero

The rest is pretty much the same.

## Benchmark

This is what we’re after. I’ve benchmarked the two implementations with the same inputs for 500k iterations.

```
Benchmarking 10 inputs with 500000 iterations:
isHappyNum: 1.930453375
isHappyStr: 31.234492208999995
```

The results are not surprising. The numerical approach runs circles around the string solution, being **approximately 16x faster.**

Main takeaway: Computers love numbers. Who would have guessed.

You can get the benchmark code on GitHub!

## Programming language matters

I think language choice really matters when solving these kinds of Leetcode tasks. Python is fast to code in, but it also shields you from a lot of internal things that are important for efficient programming.

For example when accessing the digits, you get a `str`

. In python, an element of a string is a string! This is sometimes convenient, but it also makes it super easy to fall into similar performance traps. In languages like *Go*, you would get a `byte`

. This warns you that you are doing something wrong, because converting a byte into a string and the string then into an integer should set of alarm bells in your head.

I’d say **pick a proper statically-typed compiled language** if you are learning to program. Even if the goal of the task is just to implement an algorithm. Languages like *Go*, *Java*, *C#* or *Swift* are great to learn on. You can write a working code in *Python* or *Javascript* quickly, but it comes at a hidden cost. You will thank yourself in the long run!