Meta E4 Phone Screen + VO (Passed): Max Parenthesis Depth, Max Leaf-to-Leaf Path Sum, Design Dropbox

Process and timeline

• Phone screen: heard back 4 days later that I was moving to the final round; I gave myself two weeks to prepare.
• Final round: four interviews over two days — two coding, one system design, one behavioral.
• Finished on Monday; HR called on Friday to say I was moving to team matching.

Phone screen

Questions: LC 125 (Valid Palindrome) and LC 938 (Range Sum of BST)

Coding round 1

• Kth Largest Element
• LC 827 (Making A Large Island)

Coding round 2

Q1: Maximum parenthesis depth

Given a string, return the maximum parenthesis nesting depth. For example (21)(((233)))(1) returns 3; if the parentheses don't match, return -1.

I solved it quickly with a stack; the interviewer hinted there was an optimization, so I switched to a single int balance counter. Given the time, I explained the idea and asked to move on to the second question.

def max_paren_depth(s):
    depth = best = 0
    for c in s:
        if c == "(":
            depth += 1
            best = max(best, depth)
        elif c == ")":
            depth -= 1
            if depth < 0:
                return -1               # too many closing parentheses
    return best if depth == 0 else -1   # too many opening parentheses

Q2: Maximum leaf-to-leaf path sum in a binary tree

Follow-up: what about an N-ary tree?

def max_leaf_to_leaf(root):
    """Max leaf-to-leaf path sum; None if the tree has fewer than two leaves"""
    best = None

    def down(node):                    # max path sum from node down to a leaf
        nonlocal best
        if not node.left and not node.right:
            return node.val
        if node.left and node.right:
            l, r = down(node.left), down(node.right)
            cand = l + r + node.val
            best = cand if best is None else max(best, cand)
            return max(l, r) + node.val
        return down(node.left or node.right) + node.val

    if root:
        down(root)
    return best

N-ary follow-up idea: for each node, compute every child's best downward path sum, take the two largest plus the node's value to update the answer, and return the largest plus the node's value to the parent.

System design round

Problem: design Dropbox. At E4 level, Hello Interview's material is mostly enough.

Follow-ups:

• How do you handle concurrent writes (two people updating the same file)?
• How do you handle stale files? — I couldn't answer this one; the interviewer hinted at long polling.

Behavioral round

• Have you taken on a project nobody else on the team wanted? Why did you take it?
• A project that failed.
• How do you ramp up on a new project? (This one comes up at other companies too.)

Reflections

Meta was always my dream company and a benchmark for whether I'm a solid SDE. I finally made it to team matching — on my third try.

• Coding: went through the last 30 days of LeetCode's Meta-tagged questions twice, practicing a "two problems in 30 minutes" pace.
• System design: studied the frequent questions on 1point3acres; Hello Interview, an SD mentor and peer mocks all helped a lot.
• Behavioral: prepared answers based on Amazon's Leadership Principles and did several mocks with a mentor.