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

# Array Subset

## Instructions

Write a function that accepts two parameters, both arrays. The arrays can have both strings and numbers. Return `true` if the second array is a subset of the first.

In other words, determine if every item in the 2nd array is also present somewhere in the 1st array.

**Input**: Array of Numbers & Strings, Array of Numbers & Strings

**Output**: Boolean

## Examples

    arraySubset([2, 1, 3], [1, 2, 3]); // -> true
    arraySubset([2, 1, 1, 3], [1, 2, 3]); // -> true
    arraySubset([1, 2], [1, 2, 3]); // -> false
    arraySubset([1, 2, 3], [1, 2, 2, 3]); // -> false

## Hints

- This problem has multiple solutions with different time complexities.
- We'll need to consider how to deal with repeats, such as when an item is present twice.

---

function arraySubset(arr, sub) {
    // Your code here
}

## How it Works

This function starts with a simple check. The subset can't be larger than the superset, by definition.

We continue by looping through every item in the second array. Our function then finds the index of this item in the first array. If that index is `-1`, indicating that it is not present, we can return `false` immediately.

Otherwise, we delete it from the first array. This ensures that if it is encountered again in the second array, it can't use the same value in the first array.

Once we get through the entire second array we can return `true`.

## Time

We have two inputs, so we'll refer to their lengths as `m` and `n`.

We loop over `n`, indicating `O(n)` already. Inside the loop, there is a call to `indexOf()`. This itself is a loop, as the engine has to go through the array to find the index.

So we're at:

### O(m * n),

which is our final time complexity.

## Space

We use the same amount of space no matter how large the inputs, so it's:

### O(1).

## Caveats

- Our function is not a pure function. We delete items out of the first array. To get around this, we could first make a copy of the first array and work with that instead. It would not change time complexity but would increase space complexity to `O(m)`. Solution 2 works around this problem.

---

Learn how to tell if two arrays contain the same values. We'll discuss how to deal with both primitive values and objects and we'll go over how a JavaScript Map helps us with this problem.

Introduction

Strings & Arrays

Advanced Strings & Arrays

Algorithms & Data Structures

JavaScript Mastery

Conclusion

Array Subset

Array Subset

Instructions

Examples