Master the JavaScript interview with expertly curated questions and solutions. Strategies developed by FAANG engineers help you prep faster, boost confidence, and refine your problem-solving skills.

Master the JavaScript interview by practicing 20 carefully curated interview questions and solutions. These problems will provide the tools you need to tackle any question you find in an interview. Allow ~1 hour per question.

Most questions have multiple solutions presented. All solutions are thoroughly explained and time and space complexity are discussed. A passing familiarity with these ideas is expected. You'll learn how to tackle different types of problems so you can proceed with confidence in your interviews.

These questions go beyond the common problems that we've all seen. FizzBuzz and bubble sort? We start past those.

We'll discuss how to refine algorithms. We'll go over clever, advanced ways of manipulating data that interviewers are looking for. You'll walk away more skilled and confident in your problem solving and interviewing abilities.

This course is taught in ES2015.

Master the JavaScript Interview

# Sorted Search

## Instructions

Write a function that accepts a sorted array of integers and a number. Return the index of that number if present. The function should return `-1` for target values not in the array.

**Input**: Array of Integers, Integer

**Output**: An integer from `-1` onwards.

## Examples:

    search([1, 3, 6, 13, 17], 13); // -> 3
    search([1, 3, 6, 13, 17], 12); // -> -1



---

function search(numbers, target) {
    // Your code here
}

function search(numbers, target) {
    for(let i = 0; i < numbers.length; i++) {
        if(numbers[i] === target) {
            return i;
        }
    }
    
    return -1;
}

This solution is very simple. We go through the array and try to find our target.

## Time

Since we're going through the whole array, the time complexity is:

### O(n).

## Space

Since we store a set number of variables, space complexity is:

### O(1).

---

# Binary Search

We can come up with a better solution. Since the array is sorted, we can essentially jump around the array until we find the index we're looking for.

## Finding a Word

Imagine looking for a word in a dictionary. Would it be efficient to go through every single word until we find the one we want? No, that would be horribly inefficient.

A better approach would be to open the dictionary halfway. If our word is alphabetically before the words in the middle page, we know our word is in the first half of the book.

We can then flip to ~1/4 of the way through the dictionary. Again, repeating the above process, we can eliminate another half of the remaining pages.

We can repeat the above steps again and again until we find our word. This ensures that even if the dictionary is huge, we can find our word much faster than if we were to go through each word individually.

## Scaling

In fact, if we double the size of the dictionary by adding in more words, we would only have to repeat this process one more time. That's not much more work even though the dictionary is much thicker.

Let's turn this approach into code.

# Solution 2

Learn two different ways to complete the search of a sorted array. We'll go over the brute force method and a more elegant method.

Introduction

Strings & Arrays

Advanced Strings & Arrays

Algorithms & Data Structures

JavaScript Mastery

Conclusion

Sorted Search

Sorted Search

Instructions

Examples:

Solution 1