# 5 Best Ways to Find the Sum of Digits in a Number without Recursion in Python

Rate this post

π‘ Problem Formulation: Calculating the sum of digits in a number is a common task in programming. Given an input number, for example `123`, the desired output for the sum of its digits would be `6`, as `1 + 2 + 3 = 6`. This article explores five methods to accomplish this in Python without using recursion.

## Method 1: Using While Loop

This tried-and-true method uses a while loop to iterate over every digit in the number. By repeatedly dividing the number by ten and adding the remainder to the sum, it aggregates the digits until the number is reduced to zero.

Here’s an example:

```number = 123
sum_of_digits = 0
while number > 0:
sum_of_digits += number % 10
number //= 10
print(sum_of_digits)```

Output: `6`

This code repeatedly takes the last digit of the input number using the modulo operation and adds it to the sum. The number is then divided by 10 (and truncated using floor division) to remove the last digit. This process continues in a loop until the number is zero.

## Method 2: Using String Conversion

Python allows for easy conversion between data types. In this method, the number is converted into a string, which makes it iterable. The individual digits are then summed up by converting each character back into an integer.

Here’s an example:

```number = 123
sum_of_digits = sum(int(digit) for digit in str(number))
print(sum_of_digits)```

Output: `6`

The number is cast to a string, and then a generator expression is used to iterate over each ‘digit’ character. These characters are converted back into integers before being passed to the built-in `sum()` function, which calculates the total sum of the digits.

## Method 3: Using Map Function

The map function is a powerful tool in Python that applies a given function to every item in an iterable. When combined with string conversion of the number, it allows for compact digit summation.

Here’s an example:

```number = 123
sum_of_digits = sum(map(int, str(number)))
print(sum_of_digits)```

Output: `6`

Similar to Method 2, this code converts the number to a string to iterate over each character. `map()` applies the `int()` function to each character to convert it back into an integer, and then the digit sum is calculated using `sum()`.

## Method 4: Using List Comprehension

List comprehensions in Python provide a concise way to create lists. This method uses a list comprehension to convert each digit character into an integer and then calculates the sum of this list.

Here’s an example:

```number = 123
sum_of_digits = sum([int(digit) for digit in str(number)])
print(sum_of_digits)```

Output: `6`

By first converting the number to a string, this code snippet creates a list of integers representing each digit using a list comprehension, which is directly summed up to find the total sum of digits.

## Bonus One-Liner Method 5: Using Functional Approach with Reduce

In Python’s functional programming repertoire, the functools module’s reduce function can be used to cumulatively apply an operation to the items of an iterable.

Here’s an example:

```from functools import reduce
number = 123
sum_of_digits = reduce(lambda x, y: int(x) + int(y), str(number))
print(sum_of_digits)```

Output: `6`

The `reduce()` function applies a lambda function that takes two arguments and adds them after converting them to integers. The process starts with the first two characters of the string-represented number and continues cumulatively until the last digit.

## Summary/Discussion

Method 1: While Loop. Simple and efficient. It doesn’t require conversion and works well with large numbers. However, it’s more verbose than other methods.

Method 2: String Conversion and Generator Expression. Very readable and compact. It does not perform well with very large numbers due to the overhead of string manipulation.

Method 3: Map Function. Brief and functional. Has a similar performance characteristic to Method 2.

Method 4: List Comprehension. Clear and pythonic. Slightly less efficient than generator expressions due to the creation of an intermediate list.

Bonus Method 5: Functional Approach with Reduce. Compact one-liner. It can be less intuitive for those not familiar with functional programming concepts and is overkill for simple tasks.