Digital Root of a given large number using Recursion

Last Updated : 20 Dec, 2022

Given a large number num in the form of string with length as N, the task is to find its digital root.

The digital root of a positive integer is found by summing the digits of the integer. If the resulting value is a single digit then that digit is the digital root. If the resulting value contains two or more digits, those digits are summed and the process is repeated. This is continued as long as necessary to obtain a single digit.

Examples:

Input: num = 675987890789756545689070986776987
Output: 5
Explanation:
Sum of individual digit of the above number = 212
Sum of individual digit of 212 = 5
So the Digital root is 5

Input: num = 876598758938317432685778263
Output: 2
Explanation:
Sum of individual digit of the above number = 155
Sum of individual digit of 155 = 11
Sum of individual digit of 11 = 2
So the Digital root is 2

Approach:

Follow the below steps to solve the problem:

Find out all the digits of a number.
Add all the number one by one.
If the final sum contains more than one digit, Call the recursive function again to make it a single digit.
The result obtained in the single-digit is the Digital Root of the number.

Below is the implementation of the above approach:

C++

// C++ program to print the digital
// root of a given very large number

#include <bits/stdc++.h>
using namespace std;

// Function to convert given
// sum into string
string convertToString(int sum)
{
    string str = "";
    // Loop to extract digit one by one
    // from the given sum and concatenate
    // into the string
    while (sum) {
        // Type casting for concatenation
        str = str + (char)((sum % 10) + '0');
        sum = sum / 10;
    }
    // Return converted string
    return str;
}

// Function to get individual digit
// sum from string
string GetIndividulaDigitSum(string str, int len)
{
    int sum = 0;
    // Loop to get individual digit sum
    for (int i = 0; i < len; i++) {
        sum = sum + str[i] - '0';
    }
    // Function call to convert
    // sum into string
    return convertToString(sum);
}

// Function to calculate the digital
// root of a very large number
int GetDigitalRoot(string str)
{
    // Base condition
    if (str.length() == 1) {
        return str[0] - '0';
    }
    // Function call to get
    // individual digit sum
    str = GetIndividulaDigitSum(str, str.length());
    // Recursive function to get digital
    // root of a very large number
    return GetDigitalRoot(str);
}

// Driver code
int main()
{
    string str = "675987890789756545689070986776987";

    // Function call
    cout << GetDigitalRoot(str);
}

Java

// Java program to print the digital
// root of a given very large number
import java.util.*;
import java.io.*;
class GFG {

    // Function to convert given
    // sum into String
    static String convertToString(int sum)
    {
        String str = "";

        // Loop to extract digit one by one
        // from the given sum and concatenate
        // into the String
        while (sum > 0) {

            // Type casting for concatenation
            str = str + (char)((sum % 10) + '0');
            sum = sum / 10;
        }

        // Return converted String
        return str;
    }

    // Function to get individual digit
    // sum from String
    static String GetIndividulaDigitSum(String str, int len)
    {
        int sum = 0;

        // Loop to get individual digit sum
        for (int i = 0; i < len; i++) {
            sum = sum + str.charAt(i) - '0';
        }

        // Function call to convert
        // sum into String
        return convertToString(sum);
    }

    // Function to calculate the digital
    // root of a very large number
    static int GetDigitalRoot(String str)
    {
        // Base condition
        if (str.length() == 1) {
            return str.charAt(0) - '0';
        }

        // Function call to get
        // individual digit sum
        str = GetIndividulaDigitSum(str, str.length());

        // Recursive function to get digital
        // root of a very large number
        return GetDigitalRoot(str);
    }

    // Driver code
    public static void main(String[] args)
    {
        String str = "675987890789756545689070986776987";

        // Function call
        System.out.print(GetDigitalRoot(str));
    }
}

// This code is contributed by sapnasingh4991

Python3

# Python3 program to print the digital
# root of a given very large number

# Function to convert given
# sum into string


def convertToString(sum):
    str1 = ""

    # Loop to extract digit one by one
    # from the given sum and concatenate
    # into the string
    while (sum):

        # Type casting for concatenation
        str1 = str1 + chr((sum % 10) + ord('0'))
        sum = sum // 10

    # Return converted string
    return str1

# Function to get individual digit
# sum from string


def GetIndividulaDigitSum(str1, len1):
    sum = 0
    # Loop to get individual digit sum
    for i in range(len1):
        sum = sum + ord(str1[i]) - ord('0')

    # Function call to convert
    # sum into string
    return convertToString(sum)

# Function to calculate the digital
# root of a very large number


def GetDigitalRoot(str1):
    # Base condition
    if (len(str1) == 1):
        return ord(str1[0]) - ord('0')

    # Function call to get
    # individual digit sum
    str1 = GetIndividulaDigitSum(str1, len(str1))
    # Recursive function to get digital
    # root of a very large number
    return GetDigitalRoot(str1)

# Driver code
if __name__ == '__main__':
    str1 = "675987890789756545689070986776987"

    # Function call
    print(GetDigitalRoot(str1))

# This code is contributed by Surendra_Gangwar

// C# program to print the digital
// root of a given very large number
using System;
class GFG {

    // Function to convert given
    // sum into String
    static String convertToString(int sum)
    {
        String str = "";

        // Loop to extract digit one by one
        // from the given sum and concatenate
        // into the String
        while (sum > 0) {
            // Type casting for concatenation
            str = str + (char)((sum % 10) + '0');
            sum = sum / 10;
        }

        // Return converted String
        return str;
    }

    // Function to get individual digit
    // sum from String
    static String GetIndividulaDigitSum(String str, int len)
    {
        int sum = 0;

        // Loop to get individual digit sum
        for (int i = 0; i < len; i++) {
            sum = sum + str[i] - '0';
        }

        // Function call to convert
        // sum into String
        return convertToString(sum);
    }

    // Function to calculate the digital
    // root of a very large number
    static int GetDigitalRoot(String str)
    {
        // Base condition
        if (str.Length == 1) {
            return str[0] - '0';
        }

        // Function call to get
        // individual digit sum
        str = GetIndividulaDigitSum(str, str.Length);

        // Recursive function to get digital
        // root of a very large number
        return GetDigitalRoot(str);
    }

    // Driver code
    public static void Main(String[] args)
    {
        String str = "675987890789756545689070986776987";

        // Function call
        Console.Write(GetDigitalRoot(str));
    }
}

// This code is contributed by Rajput-Ji

JavaScript

<script>
    // Javascript program to print the digital
    // root of a given very large number
    
    // Function to convert given
    // sum into string
    function convertToString(sum)
    {
        let str = "";
        // Loop to extract digit one by one
        // from the given sum and concatenate
        // into the string
        while (sum > 0)
        {
        
            // Type casting for concatenation
            str = str + String.fromCharCode((sum % 10) + '0'.charCodeAt());
            sum = parseInt(sum / 10, 10);
        }
        // Return converted string
        return str;
    }

    // Function to get individual digit
    // sum from string
    function GetIndividulaDigitSum(str, len)
    {
        let sum = 0;
        
        // Loop to get individual digit sum
        for (let i = 0; i < len; i++) {
            sum = sum + str[i].charCodeAt() - '0'.charCodeAt();
        }
        
        // Function call to convert
        // sum into string
        return convertToString(sum);
    }

    // Function to calculate the digital
    // root of a very large number
    function GetDigitalRoot(str)
    {
        // Base condition
        if (str.length == 1) {
            return (str[0].charCodeAt() - '0'.charCodeAt());
        }
        
        // Function call to get
        // individual digit sum
        str = GetIndividulaDigitSum(str, str.length);
        
        // Recursive function to get digital
        // root of a very large number
        return GetDigitalRoot(str);
    }
    
    let str = "675987890789756545689070986776987";
 
    // Function to print final digit
    document.write(GetDigitalRoot(str));

// This code is contributed by mukesh07.
</script>

Output

Time Complexity: O(N), which can be computed as follows:

O(log N) time to find the sum of digits of num first time, where N is the count of digits initially.
O(log log N) time to find the sum of digits next time
O(log log log N) time to find the sum of digits next time
... and so on.

Auxiliary Space: O(1), since the sum stored in the string will not exceed 3 digits for N ? 10⁵

Sum of natural numbers using recursion

MohammadMudassir

Improve

Article Tags :

Practice Tags :

Digital Root of a given large number using Recursion

Similar Reads

Thank You!

What kind of Experience do you want to share?