Meta·Software Engineer·Online Assessment (OA)·Intermediate

Intermediate

Jun 2026

Summary

Meta SWE online assessment, leveled coding problem around building an in-memory record store. Two levels: basic add/remove, then query by exact key and key prefix. Pretty straightforward if you're comfortable with dictionaries and string matching.

Questions Asked (1)

Implement an in-memory record store with add and remove operations, then extend it to support querying records by exact key match and by key prefix.

Algorithms & Data StructuresSystem DesignAPI & Integrations

Author's notes

The first two functions were basically just dictionary set and delete, no real trick there.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then design a data structure that supports O(1) add/remove and efficient exact and prefix queries. Implement a hash map for exact matches and a trie for prefix queries, ensuring synchronization between them. Discuss trade-offs and test with edge cases.

Pro tip: Demonstrate awareness of concurrency and memory management: mention thread-safety and potential memory leaks, and propose solutions like locks or concurrent data structures. Also, discuss how to handle large datasets and whether to use a trie or sorted array for prefix queries based on expected query patterns.

1. Clarify Requirements

Ask about expected operations, data size, concurrency needs, and performance requirements. Confirm whether keys are strings and if prefix queries are case-sensitive.

2. Design Data Structures

Propose using a hash map for exact key lookups and a trie for prefix queries. Explain how to keep them in sync during add/remove.

3. Implement Operations

Detail add: insert into hash map and trie. Remove: delete from both. Query exact: hash map lookup. Query prefix: traverse trie to collect all keys with given prefix.

4. Analyze Complexity and Trade-offs

Discuss time and space complexity: O(1) average for add/remove/exact, O(p + k) for prefix (p=prefix length, k=results). Mention alternatives like sorted arrays or balanced trees.

5. Handle Edge Cases and Extensions

Consider empty keys, duplicate adds, removing non-existent keys, and concurrent access. Suggest extensions like range queries or persistence.

Key Points to Mention

Use of hash map for O(1) exact match and trie for efficient prefix queries.
Synchronization between data structures to avoid inconsistencies.
Time and space complexity analysis for each operation.
Handling of edge cases: empty keys, duplicates, non-existent removals.
Concurrency considerations: thread-safety and locking strategies.
Trade-offs between trie and other structures (e.g., sorted array) for prefix queries.

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