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 do we mean by spaces?

Given a particular string, we can find and remove the spaces in it. Spaces are the whitespaces in the text, 
 i.e., the empty gaps within textual data. The illustration below shows what we aim to do! 

# 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 <string>
#include <iostream>
using namespace std;

void removeSpaces(string &text, int index,int len)

{
  if (len==0){return;}
  
  if(index==len){return;}
  
  if(text[index]==' '){
      int i=index;
    while(i<len){
      text[i]=text[i+1];
        i++;
    }
    
    removeSpaces(text,index,len-1);
  }
  
  removeSpaces(text,index+1,len);
 
}

int main()
  
{ string text="  HO ME";
 cout<<text<<endl;
 removeSpaces(text,0,text.length());
 cout<<text<<endl;
}


# Understanding the Code

This 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 **line 28 to 32**. 

* The main function simply declares a **string** variable, `text`. 

* It first displays the `text` variable to show all the spaces in it.  

* The main method then calls on the `removeSpaces` method, in which it passes the string `text`, the initial `index` as **0** and the length through the *built-in* `length` function.

* Lastly, it displays the modified string `text` without any spaces. 

## Recursive Function

In this lesson, the recursive function is the `removeSpaces` method. Within this function, there are two parts; base case and recursive case. 

The method itself does not return any value therefore, its return type is `void`. It takes in three arguments; 
   * The first is the **address** to the `text` string. Indicated by the **&** sign, this ensures that the modifications to the string are also implemented beyond the function scope. 
* The second is the `index` variable which will be used to traverse the string in order to see if at any position it contains a space.
* The third is the `length` which will determine whether the entire string has been traversed or not. 

### Base Case
* This method has two base cases;
  * On **line 8** there is an `if` condition that simply returns if the length of the string is $0$. 
  * On **line 10** it states that given the `index`, whose value is to be checked whether it is a space or not, and the `length` of the string if they are equal that means the whole string has been traversed hence, `return`. 

### Recursive Case

The recursive call, i.e. the function that calls itself within its own body, occurs twice in this function. 

* The first time it occurs is in the body of the *if-condition* starting on **line 12** and ending on **line 20**. The *if-condition* states that if the given value at `index` position is equal to a **whitespace**, then you do the following: 
   * For each value starting from the given `index` until the end, move each element to the **left**. This ensures that the whitespace character is eliminated from the string `text`. 
   * Once the *while loop* has executed, then call the function `removeSpaces` again, this time with the same `index` as all values have moved to the left and so does the `text`. The length, `len` decreases by 1 as we move all elements to the left. 
* The second time the recursive call is made is on **line 22**. This simply states that, provided none of the above conditions are met, simply call the method again on the next `index` to see if a whitespace can be found on that position.

In this lesson you will learn how to find the total number of spaces in a string.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Removing Spaces in a String

What do we mean by spaces?

Implementing the Code

Understanding the Code

Driver Function