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++

# Replacing Negative Values with Zero
Given an array, replace negative values in an array with 0.

The following illustration clears the concept:

# Implement the Code
The following code explains how to replace each negative value in the array with 0.

Experiment with the code by changing the values of `array` to see how it works.

#include <iostream>
using namespace std;

//Recursive function
void replaceNegativeValues(int array[], int size, int currentIndex) {
    if (currentIndex >= size) {
        return;
    }

    // Replace negative numbers with 0
    if (array[currentIndex] < 0) {
        array[currentIndex] = 0;
    }

    // Recursively call the function for the next index
    replaceNegativeValues(array, size, currentIndex + 1);
}

//Driver Function
int main()
{
   int array[7]={2,-3,4,-1,-7,8,3};//define an array
   int size=7; //define the size of array
   cout<<"Replace negative values with 0:\n"; 
   replaceNegativeValues(array,size,0); //call the recursive function
   for (int i=0;i<7;i++)//print the array
     cout<<array[i]<<' ';
 return 0;
  
}

# Understanding the Code
A recursive code can be broken down into **two parts**. The **recursive function** and the **main** where the function is called. 

## Driver Function
The driver code is from **line 17 to line 25**.
* In the driver code, we have an `array` of `size` equal to 7. 
* The function `replaceNegativeValues` takes in 3 arguments i.e., `array`, `size` and `0`(i.e., the first index of the array).
* When the function executes, all values less than zero in the array are replaced with zero
* **Line 23 to line 25** uses a for loop to print the updated array.

## Recursive Function
In the function, we define the base case and the recursive case.

### Base Case
The base case is defined on **line 7**. 
The function exists when the following condition is met:
* Since `size` is decremented in every call, the function terminates when size is less than 1.


### Recursive Case
The recursive case is defined on **line 13**.

* The function takes in three arguments. The first argument is the `array`. The second argument is the `size` and the third argument is the `currentIndex`. The `size` and `currentIndex` gets decremented and incremented respectively in successive recursive calls.

* Initially the value of `currentIndex` is 0.
Each time the recursive function is called it checks if the value at currentIndex is less than 0, then it replaces the value of the array at `currentIndex` with 0. The value of the `currentIndex` **is incremented by 1** in order to check the value of the array at the next index and the function is recursively called.

* The function keeps getting called recursively until the base condition is met.



 
# Understanding through a stack
The following illustration explains the concept:


This lesson will help you replace negative values in an array with 0 using recursion.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Replacing each Negative Integer with 0 in an Array

Replacing Negative Values with Zero