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

# Total Occurrences of a Number 
The number of occurrences of a number means the frequency by which a number **n** appears in the array.

The following illustration clears the concept:

# Implementing the Code
The following code explains how to find the frequency of a number in an array using recursion.

Experiment with the code by changing the values of `array` and `num` to see how it works!

#include<iostream>
using namespace std;

// Recursive Function
int  NoOfOccurrence(int array[], int size, int num)
{
    int found = 0;
   //base case
    if (size< 0) //if the whole array has been traversed
        return 0;

    if (array[size] == num)// check if element is found
        ++found;// increment found
   //recursive case
    return (found + NoOfOccurrence(array, size- 1, num));
}
// 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
  int num=3;// define the number whose frequency of occurrence is to be found
  cout<<"Number of occurrences of "<<num<<" : ";
  cout << NoOfOccurrence( array, size-1,num);//call recursive function
  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 18** to **line 24**.

* In the driver code, from **line 19 to line 21** we have an `array` of `size` equal to 7 and the number `x` whose number of occurrence is to be found. 
* The function `NoOfOccurences` takes in 3 arguments i.e., `num` whose number of occurrences is to be found, `array` and `size` of the array.
When called, it returns the number of occurrences of x.
 
 
## Recursive Function
In the function, we define the base case and the recursive case.

### Base Case
The base case is defined from **line 9** to **line 10**. 
 * The size of the array is decremented by 1 in every recursive call, so the function exits when size is less than 0.

### Recursive Case
The recursive case is defined on **line 15**.
* The function takes in three arguments. The first argument is the `array`. The second argument is the `size` which gets decremented in successive recursive calls. The third argument is `num` - the number whose number of occurrences is to be found.  

* Each time the recursive function is invoked, the value of `array` at the specified index value equal to `size` is compared with `num` i.e., the number whose occurrence is to be found. 
* If the result of the comparison is true, the value of `found` is incremented and function is invoked again by **decrementing the value of size by 1** in order to compare the value of array at the next index value with `num`.

* 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 find the number of occurrences of a number in an array using recursion.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Count the Number of Occurrences of a Number in an Array

Total Occurrences of a Number