Pinterest·Machine Learning Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Jul 2026Remote

Summary

Pinterest ML Engineer interview with a coding round that leaned more data-structures-heavy than I expected. The main problem was about tracking people moving through numbered rooms and answering count and ranking queries efficiently. Solid problem, took me a while to get the full solution clean.

Questions Asked (1)

Design a data structure to track n people moving through n rooms (all starting in room 0). Support two operations: count(roomId) returning the number of people in that room in O(1), and topKFastest(k) returning the k people who have moved the farthest, with ties broken by who arrived in their current room earliest.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The count part came to me fast, just a counter array per room.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the requirements and constraints first, then propose a hybrid data structure that combines a hash map for O(1) room counts and a balanced BST or heap for efficient top-K queries. Discuss trade-offs between update and query costs, and consider whether the movement pattern allows optimizations like lazy updates or bucketing.

Pro tip: Mention that in real-world systems, you'd often use a combination of a hash map and a sorted container like a skip list or a Fenwick tree to balance update and query costs, and discuss how you'd handle concurrent updates if needed.

1. Clarify Requirements and Constraints

Ask about the frequency of count vs. topKFastest operations, whether movements are monotonic (people only move forward), and if there are any memory constraints. This helps determine the optimal data structure.

2. Design Core Data Structures

Propose a hash map (roomId -> count) for O(1) count queries, and a balanced BST or max-heap keyed by distance moved, with ties broken by arrival time, for topKFastest. Explain how to maintain both structures on each move.

3. Analyze Operations and Trade-offs

Detail the time complexity for count (O(1)) and topKFastest (O(k log n) with BST or O(k log n) with heap). Discuss how updates affect these structures and whether lazy updates or bucketing could improve performance.

4. Handle Edge Cases and Optimizations

Address ties in distance and arrival time, and consider if people can move backward. Mention potential optimizations like maintaining a separate index for arrival times or using a Fenwick tree for prefix sums if needed.

5. Summarize and Discuss Scalability

Conclude with a summary of the proposed solution, its complexities, and how it would scale with n. Mention any alternative approaches and why the chosen one is preferable for the given constraints.

Key Points to Mention

Hash map for O(1) room counts
Balanced BST or heap for top-K queries with tie-breaking
Time complexity analysis: O(1) for count, O(k log n) for topKFastest
Handling ties by arrival time (e.g., using a composite key)
Trade-offs between update and query costs
Potential optimizations like lazy updates or bucketing

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