Top Asked Meta (Facebook) Interview Questions for 2025#

Article: https://www.simplilearn.com/facebook-interview-questions-answers-article

Problems#

Here’s the list of problems from the article:

  • You are given a set of random numbers. Write a code to shift all the zeros to the left.

  • Write a code to merge overlapping intervals.

  • You are given a binary tree. Can you in-place convert it into a doubly-linked list?

  • Can you print the given binary tree’s nodes level by level, i.e., print all nodes of level 1 first, then level 2, and so on?

  • ‘The sky is dark blue.’ Can you reverse the order of this string?

  • You are given four words - apple, pear, pier, and pie. Can this be completely segmented? If yes, then how?

  • Here is a list of daily stock prices. Return the buy and sell prices to maximize the profit.

Solutions#

I wanted to get an idea of how hard the problems are, but didn’t want to spend time solving them. I let GPT 4o do it for me, and focused on writing tooling to execute and verify all code snippets on this page.

Shift zeros left#

def shift_zeros_left(arr):
    non_zero_pos = len(arr) - 1  # Position to place the next non-zero element

    # Traverse from right to left
    for i in range(len(arr) - 1, -1, -1):
        if arr[i] != 0:
            arr[non_zero_pos] = arr[i]
            non_zero_pos -= 1

    # Fill remaining positions with zeros
    for i in range(non_zero_pos + 1):
        arr[i] = 0

    return arr

# ✅ Test cases
assert shift_zeros_left([0, 1, 0, 3, 12, 0, 5]) == [0, 0, 0, 1, 3, 12, 5]
assert shift_zeros_left([1, 2, 3, 4, 0]) == [0, 1, 2, 3, 4]
assert shift_zeros_left([0, 0, 0, 0]) == [0, 0, 0, 0]
assert shift_zeros_left([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]
assert shift_zeros_left([0, 1, 0, 0, 0, 2, 3, 0]) == [0, 0, 0, 0, 0, 1, 2, 3]
assert shift_zeros_left([0]) == [0]
assert shift_zeros_left([1]) == [1]
assert shift_zeros_left([0, 0, 1, 2, 3, 0, 4, 5]) == [0, 0, 0, 1, 2, 3, 4, 5]

Merge intervals#

from functools import reduce

def merge_intervals(intervals):
    return reduce(lambda m, c: (m[-1].__setitem__(1, max(m[-1][1], c[1])) or m) if m and c[0] <= m[-1][1] else (m.append(c) or m),
                  sorted(intervals), [])

# Comprehensive test cases
assert merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]) == [[1, 6], [8, 10], [15, 18]]
assert merge_intervals([[1, 4], [4, 5]]) == [[1, 5]]
assert merge_intervals([[1, 10], [2, 6], [8, 10], [15, 18]]) == [[1, 10], [15, 18]]
assert merge_intervals([[6, 8], [1, 9], [2, 4], [4, 7]]) == [[1, 9]]
assert merge_intervals([[1, 3], [7, 9], [4, 6]]) == [[1, 3], [4, 6], [7, 9]]
assert merge_intervals([]) == []
assert merge_intervals([[1, 5]]) == [[1, 5]]
assert merge_intervals([[1, 2], [3, 4], [5, 6]]) == [[1, 2], [3, 4], [5, 6]]  # No merges
assert merge_intervals([[1, 10], [2, 3], [4, 5], [6, 7], [8, 9]]) == [[1, 10]]  # Fully merged
assert merge_intervals([[1, 100], [50, 200], [150, 300]]) == [[1, 300]]  # Large intervals

Tree to double-linked list#

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val, self.left, self.right = val, left, right

def tree_to_doubly_linked_list(root):
    """Converts a binary tree into a doubly linked list in-place."""
    def inorder(node):
        nonlocal prev, head
        if not node:
            return
        inorder(node.left)
        if prev:
            prev.right, node.left = node, prev
        else:
            head = node
        prev = node
        inorder(node.right)

    prev, head = None, None
    inorder(root)
    return head

def linked_list_to_list(head):
    """Converts a doubly linked list to a list representation."""
    result = []
    while head:
        result.append(head.val)
        head = head.right
    return result

assert tree_to_doubly_linked_list(None) is None
assert linked_list_to_list(tree_to_doubly_linked_list(TreeNode(1))) == [1]
assert linked_list_to_list(tree_to_doubly_linked_list(TreeNode(3, TreeNode(2, TreeNode(1))))) == [1, 2, 3]
assert linked_list_to_list(tree_to_doubly_linked_list(TreeNode(1, None, TreeNode(2, None, TreeNode(3))))) == [1, 2, 3]
assert linked_list_to_list(tree_to_doubly_linked_list(TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode(5)))) == [1, 2, 3, 4, 5]

Tree levels#

from collections import deque
from typing import List, Optional

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def level_order_traversal(root: Optional[TreeNode]) -> List[List[int]]:
    """Returns level order traversal of a binary tree."""
    if not root:
        return []
    
    result, queue = [], deque([root])
    while queue:
        level = [queue.popleft() for _ in range(len(queue))]  # Extract nodes at current level
        result.append([node.val for node in level])  # Store node values
        queue.extend(child for node in level for child in (node.left, node.right) if child)  # Add children
    
    return result

# Optimized Tree Builder for Testing
def build_tree(values: List[Optional[int]]) -> Optional[TreeNode]:
    """Builds a binary tree from a list of values (None represents missing nodes)."""
    if not values:
        return None
    nodes = [TreeNode(v) if v is not None else None for v in values]
    queue = deque(nodes)
    root = queue.popleft()
    
    for node in nodes:
        if node:
            node.left = queue.popleft() if queue else None
            node.right = queue.popleft() if queue else None
    
    return root

assert level_order_traversal(None) == []
assert level_order_traversal(build_tree([1])) == [[1]]
assert level_order_traversal(build_tree([1, 2, 3])) == [[1], [2, 3]]
assert level_order_traversal(build_tree([1, 2, 3, 4, 5, None, 7])) == [[1], [2, 3], [4, 5, 7]]
assert level_order_traversal(build_tree([1, 2, None, 3, None, 4])) == [[1], [2], [3], [4]]
assert level_order_traversal(build_tree([1, 2, 3, 4, 5, 6, 7])) == [[1], [2, 3], [4, 5, 6, 7]]

Reverse words#

Disqualified. LLM couldn’t come up with a meaningful solution that passes the tests.

Conclusion#

  • Meta uses simple problems, with concise solutions taking under 20 lines of code.

  • GPT 4o is pretty good at leet code. But it doesn’t produce a good code immediately. It takes a few rounds of “Make this code more concise” and “Optimize this code for speed”. Here’s my initial prompt template:

    Let’s practice for coding interviews. Write a solution for the following problem. After the function, add a comprehensive set of tests using assert statements.