Posted on by Kalkicode
Code Recursion

# Digital root of a large number using recursion

The digital root of a number is the sum of its digits until a single-digit number is obtained. For example, the digital root of 123 is 1 + 2 + 3 = 6, and the digital root of 456 is 4 + 5 + 6 = 15, which further becomes 1 + 5 = 6. In this article, we will discuss how to find the digital root of a large number using a recursive approach.

## Problem Statement

Given a large number represented as a string, we need to find its digital root using recursion.

## Example

Consider the number "123456." The digital root is calculated as follows: 1 + 2 + 3 + 4 + 5 + 6 = 21 2 + 1 = 3 Hence, the digital root of 123456 is 3.

## Pseudocode

``````function findDigitalRoot(num):
if length(num) == 1:
return num
sum = 0
for i = 0 to length(num)-1:
sum += num[i] - '0'
return findDigitalRoot(convertToString(sum))

function digitalRoot(num):
print("Given number : " + num)
print("Digital root : " + findDigitalRoot(num))
``````

Algorithm

The algorithm to find the digital root of a number using recursion can be described as follows:

1. Define a function findDigitalRoot(num) that takes a string num as input.
2. If the length of num is 1, return the number as the digital root.
3. Initialize a variable sum to store the sum of digits.
4. Iterate through each character in num, convert it to an integer, and add it to the sum.
5. Recursively call findDigitalRoot() with the sum as the new input.
6. Repeat steps 2 to 5 until the digital root is obtained.
7. Finally, the digital root will be a single-digit number, and we return it.

Explanation:

1. The `findDigitalRoot` function is a recursive function that calculates the digital root of the input number `num`.
2. If the length of `num` is 1, it means we have a single-digit number, and we return the number as the digital root.
3. Otherwise, we initialize a variable `sum` to store the sum of digits and loop through each digit in the string representation of the number.
4. We convert each character to an integer by subtracting the ASCII value of '0' from the character. This gives us the actual digit value.
5. We add all the digits and recursively call the `findDigitalRoot` function with the new sum.
6. The process repeats until we obtain a single-digit digital root, and we return it.

## Program Solution

``````/*
Java Program
Digital root of a large number using recursion
*/
public class DigitSum
{
// Find the digital root using recursion process
public String findDigitalRoot(String num)
{
if (num.length() == 1)
{
// Returning the result of single digit
return num;
}
int sum = 0;
// Sum of all digit
for (int i = 0; i < num.length(); ++i)
{
sum += num.charAt(i) - '0';
}
return findDigitalRoot("" + sum);
}
// Handles the request to find digital root of given string number
public void digitalRoot(String num)
{
// Display given number
System.out.println(" Given number : " + num);
// Display calculated result
System.out.println(" Digital root : " + findDigitalRoot(num));
}
public static void main(String[] args)
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3

Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132

1 + 3 + 2 = 6
Result = 6
*/
}
}``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````// Include header file
#include <iostream>
#include <string>
using namespace std;

/*
C++ Program
Digital root of a large number using recursion
*/

class DigitSum
{
public:
// Find the digital root using recursion process
string findDigitalRoot(string num)
{
if (num.length() == 1)
{
// Returning the result of single digit
return num;
}
int sum = 0;
// Sum of all digit
for (int i = 0; i < num.length(); ++i)
{
sum += num[i] - '0';
}
return this->findDigitalRoot(to_string(sum));
}
// Handles the request to find digital root of given string number
void digitalRoot(string num)
{
// Display given number
cout << " Given number : " << num << endl;
// Display calculated result
cout << " Digital root : " << this->findDigitalRoot(num) << endl;
}
};
int main()
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
return 0;
}``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````// Include namespace system
using System;
/*
Csharp Program
Digital root of a large number using recursion
*/
public class DigitSum
{
// Find the digital root using recursion process
public String findDigitalRoot(String num)
{
if (num.Length == 1)
{
// Returning the result of single digit
return num;
}
int sum = 0;
// Sum of all digit
for (int i = 0; i < num.Length; ++i)
{
sum += num[i] - '0';
}
return this.findDigitalRoot("" + sum);
}
// Handles the request to find digital root of given string number
public void digitalRoot(String num)
{
// Display given number
Console.WriteLine(" Given number : " + num);
// Display calculated result
Console.WriteLine(" Digital root : " + this.findDigitalRoot(num));
}
public static void Main(String[] args)
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}
}``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````<?php
/*
Php Program
Digital root of a large number using recursion
*/
class DigitSum
{
// Find the digital root using recursion process
public	function findDigitalRoot(\$num)
{
if (strlen(\$num) == 1)
{
// Returning the result of single digit
return \$num;
}
\$sum = 0;
// Sum of all digit
for (\$i = 0; \$i < strlen(\$num); ++\$i)
{
\$sum += ord(\$num[\$i]) - ord('0');
}
return \$this->findDigitalRoot(strval(\$sum));
}
// Handles the request to find digital root of given string number
public	function digitalRoot(\$num)
{
// Display given number
echo (" Given number : ".\$num."\n");
// Display calculated result
echo (" Digital root : ".\$this->findDigitalRoot(\$num)."\n");
}
}

function main()
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}
main();``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````/*
Node JS Program
Digital root of a large number using recursion
*/
class DigitSum
{
// Find the digital root using recursion process
findDigitalRoot(num)
{
if (num.length == 1)
{
// Returning the result of single digit
return num;
}
var sum = 0;
// Sum of all digit
for (var i = 0; i < num.length; ++i)
{
sum += num.charAt(i).charCodeAt(0) - '0'.charCodeAt(0);
}
return this.findDigitalRoot("" + sum);
}
// Handles the request to find digital root of given string number
digitalRoot(num)
{
// Display given number
console.log(" Given number : " + num);
// Display calculated result
console.log(" Digital root : " + this.findDigitalRoot(num));
}
}

function main()
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}
main();``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````#    Python 3 Program
#    Digital root of a large number using recursion
class DigitSum :
#  Find the digital root using recursion process
def findDigitalRoot(self, num) :
if (len(num) == 1) :
#  Returning the result of single digit
return num

sum = 0
#  Sum of all digit
i = 0
while (i < len(num)) :
sum += ord(num[i]) - ord('0')
i += 1

return self.findDigitalRoot(str(sum))

#  Handles the request to find digital root of given string number
def digitalRoot(self, num) :
#  Display given number
print(" Given number : ", num)
#  Display calculated result
print(" Digital root : ", self.findDigitalRoot(num))

def main() :
# Case A :
# Given number : 123456
#    1 + 2 + 3 + 4 + 5 + 6 = 21
#    2 + 1 = 3
#    Result =  3
# Case B :
# Given number : 123908756245134574732783343268
#    1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
#    + 2 + 4 + 5 + 1 + 3 + 4
#    + 5 + 7 + 4 + 7 + 3 + 2 + 7
#    + 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
#    1 + 3 + 2 = 6
#    Result = 6

if __name__ == "__main__": main()``````

#### input

`````` Given number :  123456
Digital root :  3
Given number :  123908756245134574732783343268
Digital root :  6``````
``````#    Ruby Program
#    Digital root of a large number using recursion
class DigitSum
#  Find the digital root using recursion process
def findDigitalRoot(num)
if (num.length == 1)
#  Returning the result of single digit
return num
end

sum = 0
#  Sum of all digit
i = 0
while (i < num.length)
sum += num[i].ord - '0'.ord
i += 1
end

return self.findDigitalRoot(sum.to_s)
end

#  Handles the request to find digital root of given string number
def digitalRoot(num)
#  Display given number
print(" Given number : ", num, "\n")
#  Display calculated result
print(" Digital root : ", self.findDigitalRoot(num), "\n")
end

end

def main()
# Case A :
# Given number : 123456
#    1 + 2 + 3 + 4 + 5 + 6 = 21
#    2 + 1 = 3
#    Result =  3
# Case B :
# Given number : 123908756245134574732783343268
#    1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
#    + 2 + 4 + 5 + 1 + 3 + 4
#    + 5 + 7 + 4 + 7 + 3 + 2 + 7
#    + 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
#    1 + 3 + 2 = 6
#    Result = 6
end

main()``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6
``````
``````import scala.collection.mutable._;
/*
Scala Program
Digital root of a large number using recursion
*/
class DigitSum()
{
// Find the digital root using recursion process
def findDigitalRoot(num: String): String = {
if (num.length() == 1)
{
// Returning the result of single digit
return num;
}
var sum: Int = 0;
// Sum of all digit
var i: Int = 0;
while (i < num.length())
{
sum += num.charAt(i).toInt - '0'.toInt;
i += 1;
}
return findDigitalRoot( sum.toString());
}
// Handles the request to find digital root of given string number
def digitalRoot(num: String): Unit = {
// Display given number
println(" Given number : " + num);
// Display calculated result
println(" Digital root : " + findDigitalRoot(num));
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: DigitSum = new DigitSum();
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}
}``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````
``````import Foundation;
/*
Swift 4 Program
Digital root of a large number using recursion
*/
class DigitSum
{
// Find the digital root using recursion process
func findDigitalRoot(_ n: String) -> String
{
if (n.count == 1)
{
// Returning the result of single digit
return n;
}
let num = Array(n);
var sum = 0;
// Sum of all digit
var i = 0;
while (i < num.count)
{
sum += Int(UnicodeScalar(String(num[i]))!.value)
- Int(UnicodeScalar(String("0"))!.value);
i += 1;
}
return self.findDigitalRoot(""
+ String(sum));
}
// Handles the request to find digital root of given string number
func digitalRoot(_ num: String)
{
// Display given number
print(" Given number : ", num);
// Display calculated result
print(" Digital root : ", self.findDigitalRoot(num));
}
}
func main()
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}
main();``````

#### input

`````` Given number :  123456
Digital root :  3
Given number :  123908756245134574732783343268
Digital root :  6``````
``````/*
Kotlin Program
Digital root of a large number using recursion
*/
class DigitSum
{
// Find the digital root using recursion process
fun findDigitalRoot(num: String): String
{
if (num.length == 1)
{
// Returning the result of single digit
return num;
}
var sum: Int = 0;
// Sum of all digit
var i: Int = 0;
while (i < num.length)
{
sum += num.get(i).toInt() - '0'.toInt();
i += 1;
}
return this.findDigitalRoot(sum.toString());
}
// Handles the request to find digital root of given string number
fun digitalRoot(num: String): Unit
{
// Display given number
println(" Given number : " + num);
// Display calculated result
println(" Digital root : " + this.findDigitalRoot(num));
}
}
fun main(args: Array < String > ): Unit
{
/*
Case A :
Given number : 123456
1 + 2 + 3 + 4 + 5 + 6 = 21
2 + 1 = 3
Result =  3
*/
/*
Case B :
Given number : 123908756245134574732783343268
1 + 2 + 3 + 9 + 0 + 8 + 7 + 5 + 6
+ 2 + 4 + 5 + 1 + 3 + 4
+ 5 + 7 + 4 + 7 + 3 + 2 + 7
+ 8 + 3 + 3 + 4 + 3 + 2 + 6 + 8 = 132
1 + 3 + 2 = 6
Result = 6
*/
}``````

#### input

`````` Given number : 123456
Digital root : 3
Given number : 123908756245134574732783343268
Digital root : 6``````

## Time Complexity

The time complexity of this algorithm is O(k), where k is the number of digits in the input number. Since we sum up all the digits in each recursive call until we obtain a single-digit number, the time complexity is linear with respect to the number of digits in the input.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post