# How to calculate Sum of Digits using Recursion in Java

This is the second part of our article to solve this coding interview question,   how to find the sum of digits of an integer number in Java. In the first part, we have solved this problem without using recursion i.e. by using a while loop and in this part, we will solve it by using recursion. It's good to know different approaches to solving the same problem, this will help you to do well on coding interviews. While finding a recursive algorithm, always search for a base case, which requires special handling. Once you find the base case, you can easily code the method by delegating rest of processing to the method itself, i.e. by using recursion.   In this problem, the base case is when the number becomes zero, at that time our program is complete and we return the sum of digits of given number. Another property of a recursive algorithm is that with each passing steps your program approaches to result and problems become shorter.

For example in this coding problem, after each call, one digit from the number is reduced. So if you provide 5 digit number then it will require five steps to complete. One key thing you need to know to solve this problem is the trick to get the last digit of an integral number. You can use modulo operator to do that, number%10 always return the last digit.

For more coding problems from interviews, you can also check the Cracking the Coding Interview: 150 Programming Questions and Solutions, one of the best collection of programming questions from reputed companies like Google, Microsoft, Amazon, and Facebook.

## Sum of Digits of a Number using Recursion

Here are my complete solution and code sample to solve this problem. I am using the main method to test the code but I encourage you to write JUnit test to test your code. Using unit tests to check your program is a good development practice, initially, it takes some time but once you get used to it, it's a cake walk. This is my personal experience that writing JUnit test triggers your thought process and think through ability, which eventually results in better code.

In this example, we are also using two methods to implement the recursive algorithm, a common practice. Since sometimes recursive method carries the current state of the program in function parameters itself, it's better to write a public method to accept input from the client and a private method to do the work.

As I said before, if you need more coding problems from interviews, you can also check the Cracking the Coding Interview: 150 Programming Questions and Solutions, one of the best collection of programming questions.

### How to calculate sum of digits using recursion

```/**
* Java program to find sum of digits using recursion.
*
* @author WINDOWS 8
*/

class SumOfDigitSolution {

public static void main(String args[]) {

System.out.printf("Sum of digit of number % d using recursion is : %d %n",
343, sumOfDigit(343));
System.out.printf("Sum of digit of using recursion for number %d is : %d %n",
287, sumOfDigit(287));
System.out.printf("Recursive Sum of digit of number % d is : %d %n",
657, sumOfDigit(647));
System.out.printf("Sum of digit of number % d using recursion is : %d %n",
1001, sumOfDigit(1001));
}

/*
* public method to calculate sumOfDigit using recursion
* it calls a private method which actual does the work
*/
public static int sumOfDigit(int input){
return sumOfDigitUsingRecursion(input, 0);
}

/*
* Java method to return sum of digit using recursion
* input 125
* output 8
*/
private static int sumOfDigitUsingRecursion(int number, int sum) {
if (number == 0) {
return sum;
}
sum += number % 10;
return sumOfDigitUsingRecursion(number / 10, sum);
}
}

Output
Sum of digit of number 343 using recursion is : 10
Sum of digit of using recursion for number 287 is : 17
Recursive Sum of digit of number 657 is : 17
Sum of digit of number 1001 using recursion is : 2
```

and here is the JUnit test class to test our sum of digit code. It tests the method for zero, positive and negative number, and boundary cases e.g. Integer.MAX_VALUE and Integer.MIN_VALUE.

You can also add as many tests as you want. Here we are also using static import feature of Java 1.5 to import static assert method e.g. assertEquals(), which you can see that we are using that as a regular member of the class itself.

```import static org.junit.Assert.*;
import org.junit.Test;
/*
* JUnit test cases to test our code
*/
public class Testing{

@Test
public void sumOfDigit(){
assertEquals(6, SumOfDigitSolution.sumOfDigit(123));
assertEquals(46, SumOfDigitSolution.sumOfDigit(Integer.MAX_VALUE));
assertEquals(0, SumOfDigitSolution.sumOfDigit(0));
assertEquals(-6, SumOfDigitSolution.sumOfDigit(-123));
assertEquals(-47, SumOfDigitSolution.sumOfDigit(Integer.MIN_VALUE));

}
}```

That's all about how to solve this coding problem of calculating the sum of digits in a given number using recursion in Java. Though recursion has several drawback e.g. hard to read, write and StackOverflow error, there is a situation where it fits nicely. Also, there are a couple of JVM language e.g.Scala, which optimize tail recursion to avoid StackOverFlowError, but Java doesn't do that. That's why to avoid using recursion in production code.

Further Learning
The Coding Interview Bootcamp: Algorithms + Data Structures
Data Structures and Algorithms: Deep Dive Using Java
Algorithms and Data Structures - Part 1 and 2

1. Very well explained!

2. public class RecSumOfDigit {

public static void main(String[] args) {
int a=123456;
int sod=SumofDig(a);
System.out.print(sod);
}

private static int SumofDig(int a) {
if(a==0)
return 0;
else
{

return (a%10)+SumofDig(a/10);
}
}

}