Meta·Software Engineer·Onsite - Coding / Algorithms·Senior

SeniorPrefer not to say

Jun 2026

Summary

Meta SWE coding round focused on a substring-in-list problem, with the expectation that you'd walk through brute force first and then pitch progressively better solutions yourself. The AI assistant was available to implement, but the ideas and complexity analysis had to come from you. Felt more like a design conversation than a pure coding screen.

Questions Asked (1)

Given a list of strings, find a string in the list that contains at least one other string from the list as a substring. Then optimize your solution across two or three successive approaches, explaining time and space complexity for each.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

The AI could write the code but the interviewer wanted the optimization ideas to come from me, which I wasn't fully prepared for.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start with a brute-force O(n^2 * L) solution comparing every pair of strings, then optimize using sorting by length and a trie or hash set to reduce redundant comparisons. Clearly explain the time and space complexity at each step, and discuss trade-offs between approaches.

Pro tip: Mention that sorting strings by length allows early termination and avoids checking longer strings against shorter ones, and that a trie can efficiently check substrings while sharing prefixes. Also, clarify whether the list can contain duplicates and how that affects the solution.

1. Clarify requirements and constraints

Ask about input size, string lengths, duplicates, and whether we need to return any valid string or all. This determines the optimal approach.

2. Brute-force approach

Compare each string against every other string using substring checks. Explain O(n^2 * L) time and O(1) extra space, where n is number of strings and L is average length.

3. Optimize with sorting and early termination

Sort strings by length ascending. For each string, only check against longer strings, and stop early if a substring is found. Complexity remains O(n^2 * L) worst-case but often faster in practice.

4. Optimize with a trie or hash set

Build a trie of all strings or use a hash set for O(1) substring lookups. For each string, check all its substrings against the set. Time O(n * L^2) and space O(n * L).

5. Compare and discuss trade-offs

Summarize the time and space complexity of each approach, and discuss when each is preferable based on input characteristics and memory constraints.

Key Points to Mention

Time and space complexity analysis for each approach
Sorting by length to reduce unnecessary comparisons
Using a trie for efficient prefix sharing and substring search
Using a hash set for O(1) substring lookups
Handling edge cases like empty strings, duplicates, and no valid pair
Trade-offs between simplicity, time, and space

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.