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.