The ultimate guide to recursion interviews. Developed by FAANG engineers, practice with real-world C++ problems, interactive code playgrounds, and get interview-ready in just a few hours.

If you’ve ever struggled with solving coding problems using recursion, or if you’ve just got an interview coming up and want to brush up on your knowledge, you’ll definitely 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, using interactive code playgrounds 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 C++

# What does removing duplicates mean?

Given a string that has repeating adjacent characters, we only want to keep one of each character. To do this, we aim to 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, then we can go on to its explanation.

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

#include <iostream>
#include <string>
using namespace std; 


void remDuplicates(string &text, int index) 
{ 
	if (text[index] == '\0') {return;}
  
	if (text[index] == text[index+1]) { 
    
		for(int position = index;position < text.length();position++) 
    { 
			text[position] = text[position + 1]; 
		} 

		remDuplicates(text,index); 
	} 
  
	remDuplicates(text,index+1); 
} 

int main() 
{ 
	string greeting = "Hello Woorldd"; 
	remDuplicates(greeting,0); 
	cout << greeting << endl; 

} 



# Understanding the Code

The recursive code can be broken down into two parts. The first is the recursive function and the second is the main where the function is called.

## Driver Function

The recursive function is called within the driver function so lets first look at what it does, from **lines 24 to 29**. 

* The `main` method simply creates a **string** called `greeting` which has multiple **adjacent repeating characters**. 

* The function `remDuplicates` is then called with `greeting` as the first and **0** as the second argument. 

* The string `greeting` is then displayed to show the changes. 

## Recursive Function

Now let’s explain the recursive function; `remDuplicates`. This is the code segment from line 6 to 25 in the snippet above.

### Base Case

* The first if condition, on **line 8**, checks if the string passed is null. If it is found to be **null**, the function returns as this denotes the *end of the string.* This is our base case, as at this point, the function will terminate and return to the main function and no more recursive calls will be made. 

### Recursive Case

* The function takes in two arguments, the **first** is the address of the string being passed to it. This is denoted by the `&` sign. We take the address to ensure that the string is being altered outside the scope of the function as well. The **second** argument is the index at which the function will compare with the next index to see if a duplicate is present. 

* The `if` condition, on **line 10**, now compares the **characters** at `index` and `index+1` places in the string. If they are found to be **equal**, we move into the body of the *if condition*. 

* Within the body of the *if condition* is a **for loop**. This loop sets a `position` iterator which is set to start the loop at `index` where the duplicate is found. It iterates over the **entire string** moving each element to the **left**. Hence, removing the duplicate found at `index` by replacing it with the one at `index+1`. 

* Once, the *for loop* finishes execution, it then calls the `remDuplicates` function again, without changing any parameters as the same index needs to be checked for any further duplicates. 

* Provided that the **third** *if condition* is not met, the `remDuplicates` function is called again but this time with the **second** argument as `index + 1` because a duplicate was not found at `index` within the string. 


This lesson will teach you how to remove duplicates in a string.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Removing Duplicates in a String

What does removing duplicates mean?

Implementing the Code

Understanding the Code