Meta (Facebook) Coding Questions 2025 - Interview Problems with Solutions

Meta Coding Questions - Complete Problem Set

Practice 25+ Meta coding interview questions with solutions. Meta focuses on optimal solutions, clean code, and problem-solving speed.

Meta Interview Focus

Meta values: Optimal time/space complexity, Clean and bug-free code, Fast problem-solving, Communication skills, Move fast mindset.

Arrays & Strings

1. Subarray Sum Equals K

Problem

Find total number of subarrays with sum equal to k.

Input: nums = [1,1,1], k = 2
Output: 2

Python

from collections import defaultdict

def subarray_sum(nums, k):
    count = 0
    prefix_sum = 0
    prefix_counts = defaultdict(int)
    prefix_counts[0] = 1

    for num in nums:
        prefix_sum += num
        count += prefix_counts[prefix_sum - k]
        prefix_counts[prefix_sum] += 1

    return count

Time: O(n), Space: O(n)

2. Minimum Window Substring

Problem

Find minimum window in s containing all characters of t.

Input: s = “ADOBECODEBANC”, t = “ABC”
Output: “BANC”

Python

from collections import Counter

def min_window(s, t):
    if not t or not s:
        return ""

    dict_t = Counter(t)
    required = len(dict_t)
    formed = 0
    window_counts = {}

    ans = float('inf'), None, None
    left = 0

    for right, char in enumerate(s):
        window_counts[char] = window_counts.get(char, 0) + 1

        if char in dict_t and window_counts[char] == dict_t[char]:
            formed += 1

        while left <= right and formed == required:
            if right - left + 1 < ans[0]:
                ans = (right - left + 1, left, right)

            window_counts[s[left]] -= 1
            if s[left] in dict_t and window_counts[s[left]] < dict_t[s[left]]:
                formed -= 1
            left += 1

    return "" if ans[0] == float('inf') else s[ans[1]:ans[2]+1]

3. Valid Palindrome II

Problem

Check if string can become palindrome by removing at most one character.

Input: “abca”
Output: true (remove ‘c’ or ‘b’)

Python

def valid_palindrome(s):
    def is_palindrome(left, right):
        while left < right:
            if s[left] != s[right]:
                return False
            left += 1
            right -= 1
        return True

    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return is_palindrome(left + 1, right) or is_palindrome(left, right - 1)
        left += 1
        right -= 1
    return True

4. Merge Intervals

Problem

Merge overlapping intervals.

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]

Python

def merge(intervals):
    intervals.sort(key=lambda x: x[0])
    merged = []

    for interval in intervals:
        if not merged or merged[-1][1] < interval[0]:
            merged.append(interval)
        else:
            merged[-1][1] = max(merged[-1][1], interval[1])

    return merged

5. Random Pick with Weight

Problem

Pick index randomly with probability proportional to weight.

Python

import random
import bisect

class Solution:
    def __init__(self, w):
        self.prefix_sums = []
        prefix_sum = 0
        for weight in w:
            prefix_sum += weight
            self.prefix_sums.append(prefix_sum)
        self.total_sum = prefix_sum

    def pickIndex(self):
        target = random.random() * self.total_sum
        return bisect.bisect_left(self.prefix_sums, target)

Trees & Graphs

6. Binary Tree Vertical Order Traversal

Problem

Return vertical order traversal of binary tree.

Python

from collections import defaultdict, deque

def vertical_order(root):
    if not root:
        return []

    column_table = defaultdict(list)
    queue = deque([(root, 0)])

    while queue:
        node, column = queue.popleft()
        column_table[column].append(node.val)

        if node.left:
            queue.append((node.left, column - 1))
        if node.right:
            queue.append((node.right, column + 1))

    return [column_table[col] for col in sorted(column_table.keys())]

7. Clone Graph

Problem

Deep clone a graph.

Python

def clone_graph(node):
    if not node:
        return None

    visited = {}

    def dfs(node):
        if node in visited:
            return visited[node]

        clone = Node(node.val)
        visited[node] = clone

        for neighbor in node.neighbors:
            clone.neighbors.append(dfs(neighbor))

        return clone

    return dfs(node)

8. Diameter of Binary Tree

Python

def diameter_of_binary_tree(root):
    diameter = 0

    def dfs(node):
        nonlocal diameter
        if not node:
            return 0

        left = dfs(node.left)
        right = dfs(node.right)

        diameter = max(diameter, left + right)
        return max(left, right) + 1

    dfs(root)
    return diameter

9. Lowest Common Ancestor III

Problem

Find LCA where p or q may not exist in tree.

Python

def lowest_common_ancestor(root, p, q):
    found = [False, False]

    def dfs(node):
        if not node:
            return None

        left = dfs(node.left)
        right = dfs(node.right)

        if node == p:
            found[0] = True
            return node
        if node == q:
            found[1] = True
            return node

        if left and right:
            return node
        return left or right

    lca = dfs(root)
    return lca if all(found) else None

10. Alien Dictionary

Problem

Find order of characters in alien language.

Python

from collections import defaultdict, deque

def alien_order(words):
    graph = defaultdict(set)
    in_degree = {c: 0 for word in words for c in word}

    for i in range(len(words) - 1):
        w1, w2 = words[i], words[i + 1]
        min_len = min(len(w1), len(w2))

        if len(w1) > len(w2) and w1[:min_len] == w2[:min_len]:
            return ""

        for j in range(min_len):
            if w1[j] != w2[j]:
                if w2[j] not in graph[w1[j]]:
                    graph[w1[j]].add(w2[j])
                    in_degree[w2[j]] += 1
                break

    queue = deque([c for c in in_degree if in_degree[c] == 0])
    result = []

    while queue:
        c = queue.popleft()
        result.append(c)
        for neighbor in graph[c]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                queue.append(neighbor)

    return ''.join(result) if len(result) == len(in_degree) else ""

Dynamic Programming

11. Continuous Subarray Sum

Problem

Check if array has continuous subarray of size >= 2 with sum multiple of k.

Python

def check_subarray_sum(nums, k):
    remainder_index = {0: -1}
    prefix_sum = 0

    for i, num in enumerate(nums):
        prefix_sum += num
        remainder = prefix_sum % k

        if remainder in remainder_index:
            if i - remainder_index[remainder] >= 2:
                return True
        else:
            remainder_index[remainder] = i

    return False

12. Decode Ways

Problem

Count ways to decode number string to letters.

Input: “226”
Output: 3 (“BZ”, “VF”, “BBF”)

Python

def num_decodings(s):
    if not s or s[0] == '0':
        return 0

    n = len(s)
    dp = [0] * (n + 1)
    dp[0] = 1
    dp[1] = 1

    for i in range(2, n + 1):
        one_digit = int(s[i-1:i])
        two_digit = int(s[i-2:i])

        if 1 <= one_digit <= 9:
            dp[i] += dp[i-1]
        if 10 <= two_digit <= 26:
            dp[i] += dp[i-2]

    return dp[n]

13. Range Sum Query 2D - Mutable

Python

class NumMatrix:
    def __init__(self, matrix):
        self.matrix = matrix
        self.m, self.n = len(matrix), len(matrix[0])
        self.prefix = [[0] * (self.n + 1) for _ in range(self.m + 1)]
        self._build_prefix()

    def _build_prefix(self):
        for i in range(self.m):
            for j in range(self.n):
                self.prefix[i+1][j+1] = (self.matrix[i][j] +
                                         self.prefix[i][j+1] +
                                         self.prefix[i+1][j] -
                                         self.prefix[i][j])

    def sumRegion(self, r1, c1, r2, c2):
        return (self.prefix[r2+1][c2+1] - self.prefix[r1][c2+1] -
                self.prefix[r2+1][c1] + self.prefix[r1][c1])

Design Problems

14. Design Add and Search Words Data Structure

Python

class WordDictionary:
    def __init__(self):
        self.root = {}

    def addWord(self, word):
        node = self.root
        for char in word:
            if char not in node:
                node[char] = {}
            node = node[char]
        node['#'] = True

    def search(self, word):
        def dfs(node, i):
            if i == len(word):
                return '#' in node

            if word[i] == '.':
                for child in node:
                    if child != '#' and dfs(node[child], i + 1):
                        return True
                return False
            else:
                if word[i] not in node:
                    return False
                return dfs(node[word[i]], i + 1)

        return dfs(self.root, 0)

15. LRU Cache

Python

from collections import OrderedDict

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

    def get(self, key):
        if key not in self.cache:
            return -1
        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)

Meta-Specific Problems

16. Buildings With an Ocean View

Problem

Find buildings with ocean view (no taller building to the right).

Python

def find_buildings(heights):
    result = []
    max_height = 0

    for i in range(len(heights) - 1, -1, -1):
        if heights[i] > max_height:
            result.append(i)
            max_height = heights[i]

    return result[::-1]

17. Nested List Weight Sum

Python

def depth_sum(nested_list):
    def dfs(nested, depth):
        total = 0
        for item in nested:
            if isinstance(item, int):
                total += item * depth
            else:
                total += dfs(item, depth + 1)
        return total

    return dfs(nested_list, 1)

18. Moving Average from Data Stream

Python

from collections import deque

class MovingAverage:
    def __init__(self, size):
        self.size = size
        self.queue = deque()
        self.window_sum = 0

    def next(self, val):
        self.queue.append(val)
        self.window_sum += val

        if len(self.queue) > self.size:
            self.window_sum -= self.queue.popleft()

        return self.window_sum / len(self.queue)

Related Resources

Meta Interview Experience

Real interview experiences. Read Experiences →

Meta Preparation Guide

Complete preparation strategy. View Guide →

Meta Main Page

Complete Meta placement guide. View Guide →

---

Practice these problems for Meta interviews!

Last updated: February 2026