Netflix Coding Questions 2025 - Interview Problems with Solutions

Netflix Coding Questions - Complete Problem Set

Practice 25+ Netflix coding interview questions with solutions. Netflix focuses on systems thinking and optimal solutions.

Netflix Interview Focus

Netflix values: Freedom & responsibility, Context not control, High performance, Stunning colleagues, Judgment over rules.

Arrays & Strings

1. Meeting Rooms II

Problem

Find minimum meeting rooms required.

Input: [[0,30],[5,10],[15,20]]
Output: 2

Python

import heapq

def min_meeting_rooms(intervals):
    if not intervals:
        return 0

    intervals.sort(key=lambda x: x[0])
    heap = []

    for interval in intervals:
        if heap and heap[0] <= interval[0]:
            heapq.heappop(heap)
        heapq.heappush(heap, interval[1])

    return len(heap)

2. Video Streaming Buffer

Problem

Design circular buffer for video streaming.

Python

class CircularBuffer:
    def __init__(self, capacity):
        self.buffer = [None] * capacity
        self.capacity = capacity
        self.head = 0
        self.tail = 0
        self.size = 0

    def write(self, data):
        self.buffer[self.tail] = data
        self.tail = (self.tail + 1) % self.capacity
        if self.size < self.capacity:
            self.size += 1
        else:
            self.head = (self.head + 1) % self.capacity

    def read(self):
        if self.size == 0:
            return None
        data = self.buffer[self.head]
        self.head = (self.head + 1) % self.capacity
        self.size -= 1
        return data

3. Find K Closest Elements

Problem

Find k closest elements to x in sorted array.

Input: arr = [1,2,3,4,5], k = 4, x = 3
Output: [1,2,3,4]

Python

def find_closest_elements(arr, k, x):
    left, right = 0, len(arr) - k

    while left < right:
        mid = (left + right) // 2
        if x - arr[mid] > arr[mid + k] - x:
            left = mid + 1
        else:
            right = mid

    return arr[left:left + k]

4. Recommendation Engine (Similarity)

Problem

Find similar movies based on feature vectors using cosine similarity.

Python

import math

def cosine_similarity(v1, v2):
    dot_product = sum(a * b for a, b in zip(v1, v2))
    magnitude1 = math.sqrt(sum(a * a for a in v1))
    magnitude2 = math.sqrt(sum(b * b for b in v2))

    if magnitude1 == 0 or magnitude2 == 0:
        return 0
    return dot_product / (magnitude1 * magnitude2)

def find_similar_movies(movies, target_movie, k):
    similarities = []
    target_features = movies[target_movie]

    for movie, features in movies.items():
        if movie != target_movie:
            sim = cosine_similarity(target_features, features)
            similarities.append((movie, sim))

    similarities.sort(key=lambda x: -x[1])
    return [movie for movie, _ in similarities[:k]]

5. LRU Cache (Streaming)

Python

from collections import OrderedDict

class StreamingCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return None
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

Graphs & Trees

6. Course Schedule

Python

from collections import defaultdict, deque

def can_finish(num_courses, prerequisites):
    graph = defaultdict(list)
    in_degree = [0] * num_courses

    for course, prereq in prerequisites:
        graph[prereq].append(course)
        in_degree[course] += 1

    queue = deque([i for i in range(num_courses) if in_degree[i] == 0])
    completed = 0

    while queue:
        course = queue.popleft()
        completed += 1
        for next_course in graph[course]:
            in_degree[next_course] -= 1
            if in_degree[next_course] == 0:
                queue.append(next_course)

    return completed == num_courses

7. Network Delay Time

Problem

Find time for signal to reach all nodes.

Python

import heapq
from collections import defaultdict

def network_delay_time(times, n, k):
    graph = defaultdict(list)
    for u, v, w in times:
        graph[u].append((v, w))

    dist = {k: 0}
    heap = [(0, k)]

    while heap:
        time, node = heapq.heappop(heap)
        if time > dist.get(node, float('inf')):
            continue

        for neighbor, weight in graph[node]:
            new_time = time + weight
            if new_time < dist.get(neighbor, float('inf')):
                dist[neighbor] = new_time
                heapq.heappush(heap, (new_time, neighbor))

    return max(dist.values()) if len(dist) == n else -1

Dynamic Programming

8. Edit Distance

Python

def min_distance(word1, word2):
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])

    return dp[m][n]

9. Longest Common Subsequence

Python

def longest_common_subsequence(text1, text2):
    m, n = len(text1), len(text2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if text1[i-1] == text2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])

    return dp[m][n]

10. Maximum Subarray

Python

def max_subarray(nums):
    max_sum = current_sum = nums[0]
    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    return max_sum

System Design Problems

11. Rate Limiter

Python

import time
from collections import defaultdict

class RateLimiter:
    def __init__(self, max_requests, window_seconds):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)

    def is_allowed(self, user_id):
        current_time = time.time()
        window_start = current_time - self.window_seconds

        # Clean old requests
        self.requests[user_id] = [
            t for t in self.requests[user_id] if t > window_start
        ]

        if len(self.requests[user_id]) < self.max_requests:
            self.requests[user_id].append(current_time)
            return True
        return False

12. Content Delivery Selector

Python

import heapq

class CDNSelector:
    def __init__(self):
        self.cdn_latencies = {}  # cdn_id -> (latency, capacity)

    def add_cdn(self, cdn_id, latency, capacity):
        self.cdn_latencies[cdn_id] = (latency, capacity)

    def select_best_cdn(self, user_region):
        available = []
        for cdn_id, (latency, capacity) in self.cdn_latencies.items():
            if capacity > 0:
                heapq.heappush(available, (latency, cdn_id))

        if available:
            _, best_cdn = heapq.heappop(available)
            return best_cdn
        return None

Related Resources

Netflix Interview Experience

Real interview experiences. Read Experiences →

Netflix Preparation Guide

Complete preparation strategy. View Guide →

Netflix Main Page

Complete Netflix guide. View Guide →

---

Practice these problems for Netflix interviews!

Last updated: February 2026