# Sum the digits of a number

Posted on

### Question :

Sum the digits of a number

If I want to find the sum of the digits of a number, i.e.:

• Input: `932`
• Output: `14`, which is `(9 + 3 + 2)`

What is the fastest way of doing this?

I instinctively did:

``````sum(int(digit) for digit in str(number))
``````

and I found this online:

``````sum(map(int, str(number)))
``````

Which is best to use for speed, and are there any other methods which are even faster?

Both lines you posted are fine, but you can do it purely in integers, and it will be the most efficient:

``````def sum_digits(n):
s = 0
while n:
s += n % 10
n //= 10
return s
``````

or with `divmod`:

``````def sum_digits2(n):
s = 0
while n:
n, remainder = divmod(n, 10)
s += remainder
return s
``````

Even faster is the version without augmented assignments:

``````def sum_digits3(n):
r = 0
while n:
r, n = r + n % 10, n // 10
return r
``````

``````> %timeit sum_digits(n)
1000000 loops, best of 3: 574 ns per loop

> %timeit sum_digits2(n)
1000000 loops, best of 3: 716 ns per loop

> %timeit sum_digits3(n)
1000000 loops, best of 3: 479 ns per loop

> %timeit sum(map(int, str(n)))
1000000 loops, best of 3: 1.42 us per loop

> %timeit sum([int(digit) for digit in str(n)])
100000 loops, best of 3: 1.52 us per loop

> %timeit sum(int(digit) for digit in str(n))
100000 loops, best of 3: 2.04 us per loop
``````

If you want to keep summing the digits until you get a single-digit number (one of my favorite characteristics of numbers divisible by 9) you can do:

``````def digital_root(n):
x = sum(int(digit) for digit in str(n))
if x < 10:
return x
else:
return digital_root(x)
``````

Which actually turns out to be pretty fast itself…

``````%timeit digital_root(12312658419614961365)

10000 loops, best of 3: 22.6 µs per loop
``````

This might help

``````def digit_sum(n):
num_str = str(n)
sum = 0
for i in range(0, len(num_str)):
sum += int(num_str[i])
return sum
``````

Doing some Codecademy challenges I resolved this like:

``````def digit_sum(n):
digits = []
nstr = str(n)
for x in nstr:
digits.append(int(x))
return sum(digits)
``````

Found this on one of the problem solving challenge websites. Not mine, but it works.

``````num = 0            # replace 0 with whatever number you want to sum up
print(sum([int(k) for k in str(num)]))
``````

Here is a solution without any loop or recursion but works for non-negative integers only (Python3):

``````def sum_digits(n):
if n > 0:
s = (n-1) // 9
return n-9*s
return 0
``````

The best way is to use math.
I knew this from school.(kinda also from codewars)

``````def digital_sum(num):
return (num % 9) or num and 9
``````

Just don’t know how this works in code, but I know it’s maths

If a number is divisible by 9 then, it’s digital_sum will be 9,
if that’s not the case then `num % 9` will be the digital sum.

``````def digitsum(n):
result = 0
for i in range(len(str(n))):
result = result + int(str(n)[i:i+1])
return(result)
``````

“result” is initialized with 0.

Inside the for loop, the number(n) is converted into a string to be split with loop index(i) and get each digit. —> str(n)[i:i+1]

This sliced digit is converted back to an integer —-> int(str(n)[i:i+1])