Digital Root - Problem

Write a function that takes a positive integer and repeatedly sums its digits until only a single digit remains. This single digit is called the digital root.

For example:

16 → 1 + 6 = 7 (single digit, so return 7)
38 → 3 + 8 = 11 → 1 + 1 = 2 (return 2)
942 → 9 + 4 + 2 = 15 → 1 + 5 = 6 (return 6)

Requirements: Implement both iterative and recursive solutions.

Input & Output

Example 1 — Basic Case

$ Input: n = 942

› Output: 6

💡 Note: Step-by-step: 942 → 9 + 4 + 2 = 15 → 1 + 5 = 6. Since 6 is a single digit, return 6.

Example 2 — Single Digit Input

$ Input: n = 7

› Output: 7

💡 Note: Since 7 is already a single digit, return it directly without any processing.

Example 3 — Multiple Iterations

$ Input: n = 9999

› Output: 9

💡 Note: 9999 → 9 + 9 + 9 + 9 = 36 → 3 + 6 = 9. The digital root is 9.

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 Apple 6

The digital root can be computed iteratively by repeatedly summing digits, recursively with the same logic, or optimally using the mathematical formula 1 + (n-1) % 9. The optimal approach leverages modular arithmetic properties to achieve O(1) time complexity.

Common Approaches

✓ Iterative Digit Summing

⏱️ Time: O(log n) Space: O(1)

Use a loop to continuously sum the digits of a number. While the number has more than one digit, extract each digit using modulo 10, add them up, and repeat the process with the new sum.

Mathematical Formula (Optimal)

⏱️ Time: O(1) Space: O(1)

The digital root follows a mathematical pattern based on modular arithmetic. If a number is 0, return 0. If divisible by 9 (and not 0), return 9. Otherwise, return n % 9. This eliminates the need for any digit summing loops.

Recursive with Memoization

⏱️ Time: O(log n) Space: O(log n)

Use recursion where each call sums the digits of the current number. If the result is still multi-digit, recursively call the function again. Base case is when the number becomes a single digit.

Iterative Digit Summing — Algorithm Steps

While number has more than 1 digit, continue loop
Extract each digit using n % 10 and n // 10
Sum all extracted digits
Replace original number with the sum
Return when single digit reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with input number 942

First Sum

9 + 4 + 2 = 15 (still two digits)

Second Sum

1 + 5 = 6 (single digit - done!)

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    while (n >= 10) {
        int digitSum = 0;
        while (n > 0) {
            digitSum += n % 10;
            n /= 10;
        }
        n = digitSum;
    }
    return n;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration reduces digits by summing them, taking logarithmic time relative to input size

⚡ Linearithmic

Space Complexity

O(1)

Only uses a few variables regardless of input size

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Digital Root - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Digit Summing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler