# The Sum of Digit Number in C Language

When I'm working on this HackerRank Problem which is about how to sum a certain digit number

*I feel Déjà vu*.

I remember encountering the same problem during an online coding interview when applying for a job application back then. Of course, I fail at that time.

## The Past

I forgot when I encountered this problem and which company I applied to back then. But, I couldn't forget the problem even until today. Because I still remember how hilarious my solution was back then.

If my memory is correct, this is my approach to tackling the problem:

```
SET result to 0
CONVERT the n from Integer to String
CONVERT the n from String to Char Array
FOR each character from the n
CONVERT the character to an Integer
SUM the result with the current digit
END FOR
```

I'm using Java as the programming language.
My idea back then is to iterate each of the digit numbers and then sum it.
But, *with a million conversions*.

First, to get each digit from the given number I convert from integer to String and lastly to an array of characters..

I know, it's not the best solution. But, it should solve the given problem. Alas, my proposed solution was not accepted. Heck, even the platform gave me this message:

The solutions do not meet the expected performance/complexity please find another solution.

I forgot what is exactly the message, but that's the gist. Of course, I failed.

## The Present

Never in my wildest dreams, did I find a similar problem again. No less in my journey to learn about the C programming language offered by HackerRank.

Since this is part of the learning about C programming language. Of course, the problem description gives a hint on how to solve the problem. Which I couldn't understand at all.

The modulo operator,

`%`

, returns the remainder of a division. For example,`4 % 3 = 1`

and`12 % 10 = 2`

. The ordinary division operator,`/`

, returns a truncated integer value when performed on integers. For example,`5 / 3 = 1`

. To get the last digit of a number in base 10, use 10 as the modulo divisor.

I mean, *isn't the modulo useful only for deciding whether a number is odd or even*?

Well… I still couldn't figure how to solve the problem. So, I employ my *Google-fu* and it's led me to this.

This is the code after I modify it to adjust with the Hacker Rank problem:

```
int main() {
int n;
scanf("%d", &n);
//Complete the code to calculate the sum of the five digits on n.
int sum = 0;
while (n != 0) {
sum += n % 10;
n = n / 10;
}
printf("%d\n", sum);
return 0;
```

Well, *it works*.
Now, what I need is to understand how this algorithm could solve the problem.

It took me days to finally understand how it works. But, after realising the keyword the puzzle is solved now. The keyword is this:

**To get the last digit of a number in base 10, use 10 as the modulo divisor.**

To be honest, I do some cheat to understand the algorithm.
I put some `printf`

here and there and this is the result:

```
Find the sum of digit number for 58612
================================
The current given number is 58612
Sum the `sum` with last digit number from given number
sum = sum + (last digit number)
sum = 0 + (58612 mod 10)
sum = 0 + 2
Now reduce the given number, let's remove the last digit number
num = 58612 / 10
num = 5861
================================
The current given number is 5861
Sum the `sum` with last digit number from given number
sum = sum + (last digit number)
sum = 2 + (5861 mod 10)
sum = 2 + 1
Now reduce the given number, let's remove the last digit number
num = 5861 / 10
num = 586
================================
The current given number is 586
Sum the `sum` with last digit number from given number
sum = sum + (last digit number)
sum = 3 + (586 mod 10)
sum = 3 + 6
Now reduce the given number, let's remove the last digit number
num = 586 / 10
num = 58
================================
The current given number is 58
Sum the `sum` with last digit number from given number
sum = sum + (last digit number)
sum = 9 + (58 mod 10)
sum = 9 + 8
Now reduce the given number, let's remove the last digit number
num = 58 / 10
num = 5
================================
The current given number is 5
Sum the `sum` with last digit number from given number
sum = sum + (last digit number)
sum = 17 + (5 mod 10)
sum = 17 + 5
Now reduce the given number, let's remove the last digit number
num = 5 / 10
num = 0
the sum: 22
```

Now, let's break down what's happening.

**Variable Assignment**

```
num := 58612
sum := 0
```

First, we want to sum the digit number which we assign to the `num`

variable.
In this case is 58612.
We also declare a `sum`

variable with a value of 0.
In the end, we want the `sum`

variable to contain a value from `5+8+6+1+2`

which results in *22*.

**Iteration**

`while num is not equal to 0, do:`

Next, we want to iterate for each digit number and sum it.
To do that, we declare an iteration.
The iteration will only stop when the `num`

is equal to zero (0).

Well, if you pay attention the `num`

value is 58612.
So, inside of the iteration, we must do something to reduce the `num`

until it becomes zero (0).

**Main Logic**

```
sum := sum + num mod 10
num := num / 10
```

Inside the iteration is where the main logic starts.
In this section, there are two things.
First, we start to sum each digit number from the `sum`

.
Second, we decrease the `num`

until it becomes zero (0).

I will start with this `num := num / 10`

first.
The purpose of this logic is to assign the `num`

with new value from `num / 10`

.
Now, if you grab a calculator and start divide 58612 with 10 you will get 5861,2.
But, since our `num`

is an `int`

the decimal value will be discarded and you will only get 5861 as the result.

Keep dividing the `num`

by ten (10), and eventually the `num`

will become zero (0).
Thus, the iteration will be stopped.

Now, my cyber friend, you know that dividing the `num`

by ten (10) will slowly remove the last digit number.
Could you imagine now what the result of `num % 10`

?

Yes, *it will give you the last digit number*.

So, let's break down what happening with this code `sum := sum + num mod 10`

on the first iteration.

```
sum = sum + (num % 10)
sum = 0 + (58612 % 10)
sum = 0 + (2)
sum = 2
```

Now, let's move to the second iteration.
Remember that the `num`

was already divided by 10 and now its value is 5681.

```
sum = sum + (num % 10)
sum = 2 + (5861 % 10)
sum = 2 + (1)
sum = 3
```

**Return Value**

`return sum`

Finally, when the iteration operation is finished.
We return the `sum`

, which already obtain new value from `2 + 1 + 6 + 8 + 5`

.

*Today, I learned something amazing*.