The ultimate guide to recursion interviews with strategies developed by FAANG engineers. Practice with real-world interview questions, detailed explanations, and visualizations to prep faster.

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

# Replacing Negative Values with Zero

When given an array, replace all negative values in that array with 0.

The following illustration clears this concept:

# Implementing 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.

import java.io.*;

class ArrayClass {
    
  private static void replaceNegativeValues(int[] a, int currentIndex) {
    if (currentIndex == a.length) 
      return;
    else {
      if (a[currentIndex] < 0) {
        a[currentIndex] = 0;
        replaceNegativeValues(a, currentIndex+1);
      }
      else {
        a[currentIndex] = a[currentIndex];
        replaceNegativeValues(a, currentIndex+1);
      }
    }
  } 
  
  public static void main(String[] args) {
    System.out.println("Before: ");
    
    int[] array = {2,-3,4,-1,-7,8,-2};

    System.out.print("{ ");
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("} ");
    System.out.println("After: ");
    
    replaceNegativeValues(array, 0);

    System.out.print("{ ");
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.print("} ");
  }
}

Recursive

import java.io.*;

class sample {
  
  private static int[] negativesToZero(int[] arr) {
    for (int i=0; i<arr.length; i++) {
      if (arr[i] < 0)
        arr[i] = 0;
      else
        arr[i] = arr[i];
    }
    return arr;
  }
  
  public static void main(String[] args) {
    System.out.println("Hello world");
    
    int[] a = {1,-2,3,-8,2,2,-5};
    System.out.print("{ ");
    for (int i = 0; i < a.length; i++) {
      System.out.print(a[i] + ", ");
    }
    System.out.print("} ");
    
    System.out.println(" ");
    
    int ret[] = negativesToZero(a);
    System.out.print("{ ");
    for (int i = 0; i < ret.length; i++) {
      System.out.print(ret[i] + ", ");
    }
    System.out.print("} ");
    
  }
}

Iterative

# Understanding the Code

The code snippet above can be broken down into **two parts**: The **recursive method** and the **main** where the method is called. 

## Driver Method

The driver code is from **line 21 to line 38**.

* In the driver code, we have an `array` equal to 7. 

* The method `replaceNegativeValues` takes in two arguments: `array`, whose negative values are to be replaced and `0` (i.e., the first index of the array).

* When the method executes, all values less than zero in the array are replaced with the number zero.

* **Line 35 to line 37** uses a for loop to print the updated array.


## Recursive Method

The method `replaceNegativeValues` takes in two arguments:- an array of integers, whose negative values are to be replaced, and `currentIndex` which represents the current index of the array.

In this method, we define the base case and the recursive case as follows.

### Base Case
The base case is defined on **line 6**. 
The method exits when the following condition is met:

* Since `currentIndex` is incremented within every call, the method terminates when the value of `currentIndex` is equal to the size of the `array` this meaning that the whole array has been traversed.

### Recursive Case

The recursive case is defined on **line 9**. Initially the value of `currentIndex` is 0.
Each time the recursive method is called it checks if the value at the `currentIndex` is less than 0. 

* If the condition is true, it replaces the value of the array at `currentIndex` with 0 at **line 10**  The value of the `currentIndex` **is incremented by 1** in order to check the value of the array at the next index. Then, the method is recursively called on **line 11**.

* If the condition is false, the value of `array` at `currentIndex` remains the same at **line 14**. The value of the `currentIndex` **is incremented by 1** in order to check the value of the array at the next index. Then, the method is recursively called again on **line 15**.

* The method is continually called through recursion until the base condition is met.



This lesson will teach you how to replace negative values in an array with 0 using recursion.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Replacing each Negative Integer with a 0 in an Array