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

# What does removing duplicates mean?

When given a string that has repeating adjacent characters, we only want to keep one of each character. To do this, we must eliminate the repeating characters. 

The illustration below shows this process.

# Implementing the code

The code below shows how to do this with recursion. First, let’s see the code, and then we will go on to its explanation.

Try the code by changing the value of `text` to see how it works with other strings.

class RemoveDuplicatesClass {

    private static String remDuplicates(String text) {
        if (text.length() == 1) {
            return text;
        }
        
        if (text.substring(0,1).equals(text.substring(1,2))) {
            return remDuplicates(text.substring(1));
        }
        else {
            return text.substring(0,1) + remDuplicates(text.substring(1));
        }
    }

    public static void main( String args[] ) {
        String input1 = "Helloo";
        String input2 = "Thiss iiss aa teesstt";
        
        System.out.println( "Original string: " + input1);

        String output = remDuplicates(input1);

        System.out.println("String after: " + output);
    }   
}

# Understanding the code

The recursive code can be broken down into two parts: the recursive method and the main method where the recursive method is called.

## Driver method

The recursive method is called within the driver function. Let's first look at what the method does from **lines 17 to 24**. 

* The `main` method creates two **strings** called `input1` and `input2` which consist of multiple **adjacent repeating characters**. 

* The method `remDuplicates` is called with `input1` as an argument (try passing `input2` as the argument).

* The string `output` is displayed to show the changes. 

## Recursive method

Now let’s examine the recursive method: `remDuplicates`. This is the code segment from **line 4 to line 13** in the snippet above.

### Base case

* The first `if` condition from **line 4 to line 6** checks if the length of `text` equals $1$. If its length is 1, the method returns. This is our base case, as the method will terminate and return to the main method, and no more recursive calls will be made. 

### Recursive case

* The method takes in one argument: the string `text` that is to be reversed.  

* The `if` condition, from **line 8 to line 10**, checks if the character on the `0th` index is equal to the character on the `1st` index. If the condition is true, the recursive method `remDuplicates` is called again with the string that consists of only one character, i.e., the character from the `1st` index till the end of the string.

* If the above condition evaluates to be false, the character at the `0th` index is passed to the recursive method call `remDuplicates`. It then takes the string from the `1st` index until the end of that string. 




Learn how to remove duplicates in a string using recursion.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Removing Duplicates in a String

What does removing duplicates mean?