Raíz digital de un entero grande dado usando recursividad

La raíz digital de un entero positivo se encuentra sumando los dígitos del entero. Si el valor resultante es un solo dígito, entonces ese dígito es la raíz digital. Si el valor resultante contiene dos o más dígitos, esos dígitos se suman y se repite el proceso. Esto continúa todo el tiempo que sea necesario para obtener un solo dígito.
Dado un gran número N , la tarea es encontrar su raíz digital. El número de entrada puede ser grande y puede que no sea posible almacenarlo incluso si usamos long long int.
Ejemplos: 

Entrada: N = 675987890789756545689070986776987 
Salida: 5 
Explicación: 
Suma de dígitos individuales del número anterior = 212 
Suma de dígitos individuales de 212 = 5 
Así que la raíz digital es 5
Entrada: num = 876598758938317432685778263 
Salida: 2 
Explicación: 
Suma de dígitos individuales de número anterior = 155 
Suma del dígito individual de 155 = 11 
Suma del dígito individual de 11 = 2 
Así que la raíz digital es 2 
 

Acercarse:  

1. Averiguar todos los dígitos de un número .
2. Suma todos los números uno por uno.
3. Si la suma final contiene más de un dígito, vuelva a llamar a la función recursiva para convertirla en un solo dígito.
4. El resultado obtenido en el de un solo dígito es la Raíz Digital del número.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ program 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 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);
}
int main()
{
    string str
        = "675987890789756545689070986776987";
 
    // Function to print final digit
    cout << GetDigitalRoot(str);
}

// Java program 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 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 to print final digit
    System.out.print(GetDigitalRoot(str));
}
}
 
// This code is contributed by sapnasingh4991

# 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)
 
if __name__ == '__main__':
    str1 = "675987890789756545689070986776987"
 
    # Function to print final digit
    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 to print readonly digit
  Console.Write(GetDigitalRoot(str));
}
}
 
// This code is contributed by Rajput-Ji

<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>

5