Waymo·Machine Learning Engineer·Technical Phone Screen·Senior

Senior

May 2026

Summary

Waymo ML Engineer interview with a coding round focused on data structures. The problem was a trie implementation for prefix search, which sounds straightforward until you're also expected to walk through complexity tradeoffs on the spot.

Questions Asked (1)

Given a list of words, design a data structure that takes a prefix string and returns all words in the list that start with that prefix. Walk through your implementation and analyze the time complexity.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

I went with a trie, which felt like the obvious move.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: the list is static or dynamic, and whether we need to return all matching words or just count them. Then propose a trie (prefix tree) as the primary data structure, explaining how each node represents a character and stores a list of words that pass through it. Walk through insertion and query operations, and analyze time complexity in terms of prefix length and number of matches.

Pro tip: Mention that for a static list, you can preprocess by sorting the words and using binary search to find the range of words with the given prefix, which can be more space-efficient than a trie. Also, discuss how to handle large result sets with pagination or streaming, which is relevant for production systems.

1. Clarify requirements and constraints

Ask whether the word list is static or dynamic, the expected size, and if the function should return all words or just a count. Also consider case sensitivity and memory constraints.

2. Propose a trie-based solution

Describe building a trie where each node represents a character and stores a list of words that have the prefix up to that node. Explain insertion and query operations.

3. Walk through an example

Use a small example (e.g., words: ['apple', 'app', 'apricot']) to illustrate how the trie is built and how a query for 'ap' returns the correct words.

4. Analyze time and space complexity

For a query with prefix length L and K matching words, the time is O(L + total characters in matches) if returning all words, or O(L + K) if just returning references. Space is O(total characters in all words).

5. Discuss trade-offs and alternatives

Compare with sorting + binary search (O(L log N + K) time, O(N) space) and mention that tries are better for dynamic insertions and frequent prefix queries.

Key Points to Mention

Trie (prefix tree) structure and its operations
Time complexity: O(L) for traversal plus O(K) for retrieving matches, where L is prefix length and K is number of matches
Space complexity: O(total characters) for trie, which can be optimized with compression (radix tree)
Alternative approach: sorting words and using binary search to find the range of words with the prefix
Handling dynamic updates: trie supports insertions efficiently, while sorted array requires re-sorting
Practical considerations: memory usage, case sensitivity, and returning results in lexicographical order

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