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

# Invert the Position of Elements
Given an array, you have to reverse the position of array elements.

# Implementing the Code
The following code explains the concept of reversing the elements of an array using recursion.

Experiment with the code by changing the `array` elements and `size` to see how the answer changes.

#include <iostream>
using namespace std;

//Recursive function for Reversing array
void reverseArray(int arr[], int startIndex, int endIndex) 
{
   //base case
    if (startIndex >= endIndex) //if the middle of array is reached
    return; 
      
    int temp = arr[startIndex];  //swap value at start with value at the end
    arr[startIndex] = arr[endIndex]; 
    arr[endIndex] = temp; 
      
    // recursive case
    reverseArray(arr, startIndex + 1, endIndex - 1);//call the recursive function  
} 
//Driver function
int main()
{
   int array[5]={1,2,3,4,5};//define the array
   int size=5;//define the size of array
   reverseArray(array,0,size-1); //call the recursive function
   cout<<"Reversed Array:"; 
   for (int i=0;i<5;i++)
     cout<<array[i];//print the array
   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 19** to **line 28**.

* In the driver code, we have an `array` of `size` equals to 5.
 * The function takes in 3 arguments i.e., `array`,`0`(i.e., starting index value) and `size-1` i.e. the end index of the array 
* After the function finishes executing, the reversed array is returned. 
* The array is printed using a `for` loop.

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

### Base Case
The base case is defined on **line 8**.
The function exists when the following condition is met:
* Function parameters `startIndex` and `endIndex` points to the start and end of the array respectively. They get incremented and decremented by 1 respectively in the successive recursive call.
Each value of the array at `startIndex` is compared with the value of the array at `endIndex`. So, when the middle of the array is reached,
the function that exits as the value of `startIndex` becomes greater than or equal to that of `endIndex`.


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

* The function takes in three arguments. The first argument is the `array`. The second argument is the `startIndex` which is the starting index of the array and the third argument is the `endIndex` which is the ending index of the array. Both `startIndex` and `endIndex` is updated in successive recursive calls.

* Initially, the value of `startIndex` is 0 and `endIndex` is equal to the size of array minus 1 i.e. the end index of the array. 
* In each recursive call,
  * On **line 11 to line 13** the value of the array at `startIndex` is swapped with the value of the array at `endIndex`.
  * The value of the  `startIndex` **is increased by 1 and** `endIndex` **is decremented by 1** in order to swap the values of the array at these indices in the next recursive call. 
* 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 us invert the position of elements in an array using recursion.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Invert the Position of Elements in an Array

Invert the Position of Elements #