Finding sum of digits of a number until sum becomes single digit

Try it on GfG Practice

Given an integer n, we need to repeatedly find the sum of its digits until the result becomes a single-digit number.

Examples:

Input: n = 1234
Output: 1
Explanation:
Step 1: 1 + 2 + 3 + 4 = 10
Step 2: 1 + 0 = 1

Input: n = 5674
Output: 4
Explanation:
Step 1: 5 + 6 + 7 + 4 = 22
Step 2: 2 + 2 = 4

[Naive Approach] By Repetitively Adding Digits

The approach is focused on calculating the digital root of a number, which is the result of summing the digits repeatedly until a single-digit value is obtained. Here's how it works conceptually:

1. Sum the digits: Start by adding all the digits of the given number.
2. Check the result: If the sum is a single-digit number (i.e., less than 10), stop and return it.
3. Repeat the process: If the sum is still more than a single digit, repeat the process with the sum of digits. This continues until a single-digit sum is reached.

// C++ program to find the digit sum by 
// repetitively Adding its digits

#include <iostream>
using namespace std;

int singleDigit(int n) {
    int sum = 0;

    // Repetitively calculate sum until
    // it becomes single digit
    while (n > 0 || sum > 9) {

        // If n becomes 0, reset it to sum 
        // and start a new iteration.
        if (n == 0) {
            n = sum;
            sum = 0;
        }

        sum += n % 10;
        n /= 10;
    }
    return sum;
}

int main() {
    int n = 1234;
    cout << singleDigit(n);
    return 0;
}

// C program to find the digit sum by 
// repetitively Adding its digits

#include <stdio.h>

int singleDigit(int n) {
    int sum = 0;

    // Repetitively calculate sum until
    // it becomes single digit
    while (n > 0 || sum > 9) {

        // If n becomes 0, reset it to sum 
        // and start a new iteration.
        if (n == 0) {
            n = sum;
            sum = 0;
        }

        sum += n % 10;
        n /= 10;
    }
    return sum;
}

int main() {
    int n = 1234;
    printf("%d", singleDigit(n));
    return 0;
}

// Java program to find the digit sum by 
// repetitively Adding its digits

class GfG {
    static int singleDigit(int n) {
        int sum = 0;

        // Repetitively calculate sum until
        // it becomes single digit
        while (n > 0 || sum > 9) {

            // If n becomes 0, reset it to sum 
            // and start a new iteration.
            if (n == 0) {
                n = sum;
                sum = 0;
            }

            sum += n % 10;
            n /= 10;
        }
        return sum;
    }

    public static void main(String[] args) {
        int n = 1234;
        System.out.println(singleDigit(n));
    }
}

# Python program to find the digit sum by 
# repetitively Adding its digits

def singleDigit(n):
    sum = 0

    # Repetitively calculate sum until
    # it becomes single digit
    while n > 0 or sum > 9:

        # If n becomes 0, reset it to sum 
        # and start a new iteration
        if n == 0:
            n = sum
            sum = 0

        sum += n % 10
        n //= 10
    return sum

if __name__ == "__main__":
    n = 1234
    print(singleDigit(n))

// C# program to find the digit sum by 
// repetitively Adding its digits

using System;

class GfG {
    static int singleDigit(int n) {
        int sum = 0;

        // Repetitively calculate sum until
        // it becomes single digit
        while (n > 0 || sum > 9) {

            // If n becomes 0, reset it to sum 
            // and start a new iteration.
            if (n == 0) {
                n = sum;
                sum = 0;
            }

            sum += n % 10;
            n /= 10;
        }
        return sum;
    }

    static void Main() {
        int n = 1234;
        Console.WriteLine(singleDigit(n));
    }
}

// JavaScript program to find the digit sum by 
// repetitively Adding its digits

function singleDigit(n) {
    let sum = 0;

    // Repetitively calculate sum until
    // it becomes single digit
    while (n > 0 || sum > 9) {

        // If n becomes 0, reset it to sum 
        // and start a new iteration.
        if (n === 0) {
            n = sum;
            sum = 0;
        }

        sum += n % 10;
        n = Math.floor(n / 10);
    }
    return sum;
}

// Driver Code
const n = 1234;
console.log(singleDigit(n));

1

Time Complexity: O(log₁₀n), as we are iterating over the digits of the number.
Auxiliary Space: O(1)

[Expected Approach] Using Mathematical Formula

We know that every number in the decimal system can be expressed as a sum of its digits multiplied by powers of 10. For example, a number represented as abcd can be written as follows:

abcd = a*10^3 + b*10^2 + c*10^1 + d*10^0

We can separate the digits and rewrite this as:
abcd = a + b + c + d + (a*999 + b*99 + c*9)
abcd = a + b + c + d + 9*(a*111 + b*11 + c)

This implies that any number can be expressed as the sum of its digits plus a multiple of 9.
So, if we take modulo with 9 on each side,
abcd % 9 = (a + b + c + d) % 9 + 0

This means that the remainder when abcd is divided by 9 is equal to the remainder where the sum of its digits (a + b + c + d) is divided by 9.

If the sum of the digits itself consists of more than one digit, we can further express this sum as the sum of its digits plus a multiple of 9. Consequently, taking modulo 9 will eliminate the multiple of 9, until the sum of digits become single digit number.

As a result, the sum of the digits of any number, will equal its modulo 9. If the result of the modulo operation is zero, it indicates that the single-digit result is 9.
To know about code implementation Refer, Digital Root (repeated digital sum) of the given large integer