Pinterest·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026Remote

Summary

Pinterest system design phone screen for a software engineering role. The whole thing was one meaty design problem about a quiz-game ranking system, and most of the time was spent debating data structure trade-offs rather than writing actual code.

Questions Asked (1)

Design and implement an object-oriented quiz-game ranking system with n rooms and m players. Everyone starts in room 0 and moves forward by answering correctly. Support three operations: getTop(k) returns the top-k players ranked by room number (ties broken by who arrived earlier), proceedToNextRoom(personId) advances a player, and getPeople(roomNumber) returns how many players are in a given room.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

I went straight to a sorted set keyed by negative room and arrival sequence, which handles getTop cleanly but I fumbled explaining why that makes proceedToNextRoom more expensive since you're doing a delete and reinsert.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints (e.g., n, m, operation frequency, tie-breaking rules). Then propose an object-oriented design with classes like Player, Room, and RankingSystem, and discuss data structures for efficient getTop(k), proceedToNextRoom, and getPeople. Finally, analyze trade-offs and consider scalability and concurrency.

Pro tip: Demonstrate maturity by discussing how to handle ties consistently and how to scale the system for large n and m, possibly using a combination of hash maps and balanced trees or skip lists.

1. Clarify Requirements and Constraints

Ask about expected number of rooms and players, frequency of operations, and whether ties are broken by arrival time or other criteria. Confirm if players can move backward or if rooms are strictly increasing.

2. Design Object-Oriented Model

Identify core classes: Player (id, current room, arrival timestamp), Room (number, list of players), and RankingSystem (manages players and rooms). Define interfaces for the three operations.

3. Choose Data Structures for Efficiency

For getTop(k), consider a balanced BST or skip list keyed by (room, arrival time) to allow O(log m + k) retrieval. For getPeople(room), use a hash map from room number to count. For proceedToNextRoom, update player's room and adjust data structures.

4. Analyze Trade-offs and Scalability

Discuss time and space complexity of each operation. Consider alternatives like maintaining a sorted list (O(m) for getTop) vs. tree (O(log m + k)). Address concurrency if multiple threads access the system.

5. Summarize and Extend

Recap the design, mention potential extensions (e.g., persistence, distributed system), and invite feedback or questions.

Key Points to Mention

Tie-breaking rule: earlier arrival time gets higher rank when room numbers are equal.
Data structure choice: balanced BST or skip list for getTop(k) to achieve O(log m + k) time.
Hash map for O(1) getPeople(room) by maintaining counts per room.
Updating player's room in O(log m) time by removing and reinserting in the ordered structure.
Concurrency considerations: locking or concurrent data structures if multiple threads modify state.
Scalability: sharding by room or using distributed caches for large-scale systems.

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