The ultimate recursion guide! Master basics, solve real-world problems, and get interview-ready in hours with FAANG engineers’ proven strategies.

If you’ve ever struggled with solving coding problems using recursion, or if you need to brush up your recursion skills for an interview, this course is for you! We will start with the basics of recursion before we practice solving actual coding problems. You’ll have access to detailed explanations and visualizations for each problem to help you along the way.

By the time you have completed this course, you’ll be able to use all the concepts of recursion to solve complex, real-world problems. We hope that this course will help you ace all the recursion related questions during interviews at top tech companies!

Recursion for Coding Interviews in Python

# What does "Removing Adjacent Duplicates from a String" Mean?
This means that we will remove all extra instances of a character when multiple instances are found together. In other words, only one instance should remain after this process. 

> Lower and upper case letters are considered different characters. Example: string `Hhelo` does not contain any duplicates.

def removeDuplicates(string):
    # Base Case1
    if not string:
        return ""

    # Base Case2
    elif len(string) == 1 :
        return string

    # Recursive Case1
    elif string[0] == string[1] :
        return removeDuplicates(string[1:])

    # Recursive Case2
    return string[0] + removeDuplicates(string[1:])

# Driver Code
print(removeDuplicates('Hellloo')) #returns Helo

## Explanation
To remove duplicates, we must reduce the length of the string with each recursive call. If the current character is similar to the following character, we discard it, meaning that we will not append it later on in the process. However, if the current character is not similar to the following character, we keep it. We append it when the child function returns.


The code snippet above checks for $4$ cases:
1. If the input to the function is not a string.
   * In this case, we return an empty string: `""`.

2. If the length of the string is $1$.
   * There can be no duplicates in a string that contains only $1$ character so we return the string variable in this case.

> Conditions $1$ and $2$ are the **base case** since there is no string manipulation occurring in either.

3. If the first and second elements of the string are same.
   * In this case, we discard the first occurrence and recursively call the same function with the first letter removed.

4. If none of these $3$ conditions are satisfied, we save the first element for later use and call the same function again with the first element removed. The saved element will be later appended to the beginning of the string when the recursive call returns.

Let's take a look at the sequence of function calls:

In this lesson, we will learn how to remove all adjacent duplicates from a string using recursion.

Recursion Fundamentals

Iteration Vs. Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Conclusion

Remove All Adjacent Duplicates from a String

What does “Removing Adjacent Duplicates from a String” Mean?

Implementation

Explanation