Roblox Software Engineer Phone Screen Questions

The HR person I recently interviewed with found me through LinkedIn. I only managed one question and one follow-up in 45 minutes. Hidden cases aren't visible unless you've run them. The following cont

I'm out of points and failed the interview. Hoping for some help! Two rounds of back-to-back interviews, 2 hours each. Before the interview, the HR called and mentioned using CoderPad, emphasizing...

**Task** Design an algorithm to optimize Roblox avatar load times by determining the correct loading order of components (body parts, accessories, animations) based on a dependency graph. **Rules and

The interviewer was an EM from India, and the questions were the same ones from online interview experiences: designing a feature. The required functions included like/unlike, showing the total like c

## Problem Simulate or analyze a call stack, tracking function calls and returns to determine execution order or detect issues. ## Tags stack, simulation, design

## Problem Determine or track when functions complete execution, likely involving async simulation, event loop, or stack-based tracking. ## Tags stack, simulation, design

## Round 1 - System Design Design a backend system that tracks player activity for a multiplayer game and answers real-time queries. **Requirements:** - Record events: player logs in, logs out, completes a match, earns XP. - Query: is player X currently online? What is player X's XP for today? - Query: top 100 players by XP in the last 24 hours (leaderboard). - Scale: 5 million concurrent players, 100K events/second. ## Architecture **Event Ingestion:** - Events published to Kafka partitioned by player_id for ordering guarantees. **Online Status:** - Redis key `player:{id}:online` with TTL refreshed on each heartbeat (60s). O(1) lookup. **XP Tracking:** - Redis sorted set `leaderboard:YYYYMMDD` with player_id as member, XP as score. - `ZINCRBY` on each XP event. `ZREVRANGE 0 99` for top 100. - Expire after 48 hours. **Persistence:** - Kafka consumer writes events to Cassandra (partition key = player_id, clustering by timestamp). ## Follow-ups 1. How do you handle the case where a player earns XP offline (mobile game, sync on reconnect)? 2. What happens to the leaderboard at midnight when the key rolls over? 3. How do you prevent cheating clients from inflating XP events? 4. How would you expose a REST API for these queries and ensure p99 latency < 20ms?

## Problem Implement a simple email template engine. A template is a string that may contain: - Variable substitutions: `{{name}}`, `{{order_id}}` - Conditional blocks: `{% if premium %}...{% endif %}` Given a template string and a context dict, render the final email string. Unknown variables render as empty string. Conditions are truthy/falsy based on the context value. ```python def render_email(template: str, context: dict) -> str: pass ``` **Example:** ``` template = """Hi {{name}}, Your order {{order_id}} is confirmed. {% if premium %}You get free shipping!{% endif %} Thanks!""" context = {"name": "Alice", "order_id": "ORD-99", "premium": True} Output: "Hi Alice,\nYour order ORD-99 is confirmed.\nYou get free shipping!\nThanks!" With premium=False: the conditional block is omitted. ``` ## Follow-ups 1. How would you handle nested conditionals `{% if a %}{% if b %}...{% endif %}{% endif %}`? 2. How would you add a `{% for item in items %}...{% endfor %}` loop construct? 3. What security issues arise if template strings come from user input? (SSTI) 4. How would you unit test this engine exhaustively, including edge cases like missing `{% endif %}`?

## Problem You are given a list of player scores and a fraction `f` (0 < f <= 1.0). Find the minimum integer threshold `t` such that at least `ceil(f * n)` players have a score >= `t`. Return -1 if no valid threshold exists. ```python from math import ceil def min_threshold(scores: list[int], f: float) -> int: pass ``` **Example:** ``` Input: scores = [40, 55, 70, 85, 90], f = 0.6 Required: ceil(0.6 * 5) = 3 players must pass. At t=55: scores >= 55 are [55,70,85,90] -> 4 players. Valid. At t=70: scores >= 70 are [70,85,90] -> 3 players. Valid. At t=85: scores >= 85 are [85,90] -> 2 players. Invalid. Minimum t where exactly >= 3 pass: t=40 (all 5 pass). But "minimum threshold" = lowest t that achieves the requirement = 40? Clarify: find the HIGHEST t where the condition still holds. Output: 70 ``` ## Follow-ups 1. How would you solve this with binary search? What is the predicate? 2. What is the time complexity with and without sorting? 3. What if scores are streamed in and you need to update the threshold after each new score? 4. Extend to multiple game modes: each mode has its own score list. Find a single universal threshold satisfying the fraction constraint for all modes simultaneously.

## Problem You are given an `m x n` integer matrix. You may eliminate at most `k` rows and at most `k` columns. After elimination, the score is the sum of all remaining cells. Maximize the score. ```python def max_score(matrix: list[list[int]], k: int) -> int: pass ``` **Example:** ``` matrix = [[-1, 2, 3], [ 4, -5, 6], [ 7, 8, -9]] k = 1 Eliminate row 0 (-1+2+3=4, smallest row sum) and column 2 (3+6-9=0): Remaining: [[4,-5],[7,8]] -> sum = 14 Or eliminate col 1 and row 2: ... Find the combination maximizing the total. Output: (depends on best elimination choice) ``` ## Follow-ups 1. For small k, is brute force (try all C(m,k)*C(n,k) combinations) feasible? When does it break? 2. Is greedy (always eliminate the row/column with the smallest sum) always optimal? Prove or give a counterexample. 3. If you can eliminate exactly k rows AND exactly k columns (not at most), does the problem change? 4. How would you solve this for k up to min(m,n)/2 efficiently?

## Problem Manage a pool of unique IDs with allocate and release operations, likely using a set or sorted structure for efficient ID tracking. ## Tags hash_table, design, arrays

## Round 1 - Frontend Build a React image feed component that: 1. Fetches images from a paginated API `GET /images?page=N&limit=20`. 2. Displays images in a responsive masonry or grid layout. 3. Loads more images automatically when the user scrolls near the bottom (infinite scroll). 4. Shows a loading spinner during fetch and an error message on failure. ```jsx function ImageFeed() { // Use IntersectionObserver or scroll event for infinite scroll trigger // State: images[], page, loading, error, hasMore } ``` **Example interaction:** ``` Page loads -> fetch page 1 -> render 20 images User scrolls to 80% -> fetch page 2 -> append 20 more API returns empty array -> set hasMore=false, stop fetching ``` ## Round 2 - System Design Design the image serving backend: - CDN strategy for image delivery - Thumbnail generation pipeline - Handling 10K concurrent users loading feeds ## Follow-ups 1. How do you prevent duplicate API calls when the user scrolls rapidly? 2. How would you implement virtual scrolling to avoid rendering thousands of DOM nodes? 3. What accessibility considerations apply to a lazy-loaded image feed? 4. How would you cache the first 2 pages of results so the feed loads instantly on revisit?

## Problem Detect bot-like IP patterns from logs or access data, likely involving string parsing and frequency analysis. ## Tags strings, hash_table, arrays

## Problem Find the next available server from a pool, likely using a min-heap ordered by availability time or load. ## Tags heap, design, arrays

## Problem A "run" is a maximal contiguous subarray of equal elements. Given an array, return the number of runs. ```python def count_runs(arr: list) -> int: pass ``` **Example:** ``` Input: [1, 1, 2, 3, 3, 3, 1] Runs: [1,1], [2], [3,3,3], [1] Output: 4 Input: [5] Output: 1 Input: [] Output: 0 ``` ## Round 2 - Variant Return not just the count but also the encoded form: `[(value, length)]` pairs (run-length encoding). ```python def run_length_encode(arr: list) -> list[tuple]: pass ``` **Example:** ``` Input: [1, 1, 2, 3, 3, 3, 1] Output: [(1,2), (2,1), (3,3), (1,1)] ``` Then decode it back: ```python def run_length_decode(encoded: list[tuple]) -> list: pass ``` ## Follow-ups 1. What is the time and space complexity of encoding and decoding? 2. For what types of data does run-length encoding provide the most compression? 3. How would you handle this for a stream of data (you cannot load the full array into memory)? 4. Extend to 2D: encode each row independently, then encode the rows of encodings. What are the tradeoffs?

## Problem Count paths in a binary tree where the path sum equals a target value. ## Likely LeetCode equivalent LC 437 - path-sum-iii ## Tags binary_tree, recursion, hash_table

## Problem Remove all strings from a list that are prefixes of another string in the list, likely using a trie or sort-based approach. ## Tags strings, arrays, sorting

## Problem Enforce rate limiting by tracking requests within a sliding time window, likely using a deque or sliding window technique. ## Tags sliding_window, queue, design

## Problem Determine if a word can be formed from a tree path or trie structure, likely a DFS traversal problem. ## Tags binary_tree, DFS, strings

## Round 1 - Frontend / Coding Implement a traffic light component and its underlying state machine. The light cycles: green (30s) -> yellow (5s) -> red (25s) -> green ... Implement a `TrafficLight` class: ```javascript class TrafficLight { constructor() { // states: 'green', 'yellow', 'red' // durations: green=30000ms, yellow=5000ms, red=25000ms } start() { /* begin cycling */ } stop() { /* halt, stay in current state */ } getCurrentState() { /* returns current state string */ } onStateChange(callback) { /* callback(newState) on each transition */ } } ``` **Example:** ``` const light = new TrafficLight(); light.onStateChange(s => console.log(s)); light.start(); // logs: "green" after 30s -> "yellow" after 5s -> "red" after 25s -> "green" ... light.stop(); // stops wherever it is ``` ## Round 2 - React Component Render the light as a visual component with three circles. The active state's circle should be colored; others gray. ## Follow-ups 1. How do you handle the case where `stop()` is called before the first timeout fires? 2. How would you make the durations configurable per state at construction time? 3. How would you test this class without waiting for real timers? (hint: Jest fake timers) 4. How would you coordinate multiple traffic lights at an intersection so they never show green simultaneously?