Digital Root of a given large integer using Recursion

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.
Given a large number N, the task is to find its digital root. The input number may be large and it may not be possible to store even if we use long long int.
Examples: 

Input: N = 675987890789756545689070986776987 
Output:
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:
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:  

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

Below is the implementation of the above approach: 
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ programm to print the digital
// root of a given very large number
 
#include <iostream>
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 concatinate
    // into the string
    while (sum) {
        // Type casting for concatination
        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);
}
int main()
{
    string str
        = "675987890789756545689070986776987";
 
    // Function to print final digit
    cout << GetDigitalRoot(str);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java programm to print the digital
// root of a given very large number
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 concatinate
    // into the String
    while (sum > 0) {
 
        // Type casting for concatination
        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 to print final digit
    System.out.print(GetDigitalRoot(str));
}
}
 
// This code is contributed by sapnasingh4991

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 programm 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 concatinate
    # into the string
    while (sum):
 
        # Type casting for concatination
        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)
 
if __name__ == '__main__':
    str1 = "675987890789756545689070986776987"
 
    # Function to print final digit
    print(GetDigitalRoot(str1))
 
# This code is contributed by Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# programm 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 concatinate
  // into the String
  while (sum > 0)
  {
    // Type casting for concatination
    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 to print readonly digit
  Console.Write(GetDigitalRoot(str));
}
}
 
// This code is contributed by Rajput-Ji

chevron_right


Output: 

5



 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.