The ultimate guide to recursion interviews with strategies developed by FAANG engineers. Practice with real-world interview questions, detailed explanations, and visualizations to prep faster.

If you’ve got an interview coming up and want to brush up on your knowledge, or if you’ve ever struggled with solving coding problems using recursion, you'll find this course helpful.
 
You’ll start with the basics of what recursion is and why it’s important before diving into what it looks like in practice. You’ll see how recursion can help you solve a variety of different math, string, and data structure problems by using interactive code playgrounds that you can execute directly in your browser. You’ll have access to detailed explanations and visualizations for each problem to help you along the way.  
 
By the time you’re done, you’ll be able to use what you’ve learned to solve complex real-world problems and even advance more easily through your interviews at top tech companies.

Recursion for Coding Interviews in Java

The key to transforming iterative code to recursive code is to find the specific lines of code that get transformed between the two implementations. 

# Count number of digits in a number

When given a number, the code must print how many digits are present in that number. The two implementations of the same code are shown below. First, look through the two codes and spot the differences. Then read the explanation to better understand this transformation process.

The illustration below explains this concept.

$$$$

The code below shows the two types of code followed by an explanation.

class IterativeClass {
   public static int countDigits(int num) {
      int count = 1;
      while (num >= 10) {
        num = num / 10;
        count++;
      }
      return count;
    }

    public static void main( String args[] ) {
      
        int input = 1435043;
        int numDigits = countDigits(input);
        System.out.println("Number of digits in " + input + " = " + numDigits);
    }
}

Iterative

class RecursiveClass {
    public static int countDigits(int num) {
      if (num < 10) {
        return 1;
      }
      else {
        return 1 + countDigits(num/10);
      }
    }

    public static void main( String args[] ) {
      
        int input = 14333220;
        int numDigits = countDigits(input);
        System.out.println("Number of digits in " + input + " = " + numDigits);
    }
}

Recursive

## Transforming the Code

$$$$

### First Step

The first step is to identify the **loop** in the iterative code. This loop has a special feature: it **modifies** an integer variable, which will eventually be returned by the method.

**Lines 4 to 8** encompass the **single** while loop in our code (**lines 4–7**), and the `return` statement (**line 8**) which will return our output. Note that the **modification** happens in the loop from **line 4 to line 7**. This is the loop that we will be dealing with.

$$$$

### Second Step

The second step is that the **loop condition** in the _iterative code_ becomes the **base case** in the *recursive code* of the method defined.

Look at **line 3** of the *recursive code*. This defines the base case of our code where it says that the method should return $1$ when the `num` is less than or equal to $1$. Alternatively, in the case of the *iterative code*, the while loop keeps running as long as `num` is greater than $0$ where the variable `num` is modified inside the loop. Both these conditions serve as a termination of the method, eventually returning the output.

On **line 5 and line 6** in the *iterative code*, `num` is divided by $10$, and the `count` variable is incremented by $1$. Dividing `num` by $10$ essentially gets rid of the last digit of `num` and then increments the `count` by $1$ in order to count the single digit that we just got rid of. Similarly, in the *recursive code* on **line 7**, this part of code returns $1$ and then recursively calls the `countDigits` method with the argument `n/10` so that all digits are counted until the base condition is true. 

Learn how to change an iterative code to a recursive code.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Changing Iterative Code to Recursive

Count number of digits in a number

The Code

Transforming the Code