Robinhood Software Engineer Phone Screen Questions

The following content requires a score of 200 or higher. You can already view it. To be honest, this was the most difficult interview I've ever seen. Although I prepared in advance, I still didn't pas

This post was last edited by WeChat user _hne9e on 2025-10-01 00:42. I was quite surprised that Robin Hood didn't do online assessments (OA) but instead had someone work with you on the questions. The

**Problem Statement** The objective is to architect a robust job scheduling service capable of defining, managing, and executing automated tasks. The system must address challenges related to distribu

Question Robinhood is famous for its referral program. It\u2019s exciting to see our users spreading the word across their friends and family. One thing that is interesting about the program is...

A trade is defined as a fixed-width string containing the 4 properties given below separated by commas: Symbol (4 alphabetical characters, left-padded by spaces) Type (either "B" or "S" for...

## Problem Given a list of words or a text corpus, find the most frequently occurring words, likely with a top-K constraint. ## Likely LeetCode equivalent Similar to Top K Frequent Words (LC 692) or Top K Frequent Elements (LC 347). ## Tags hash_table, heap, sorting, robinhood

## Problem You have a budget `B` (integer units) to allocate across `n` assets. Asset `i` has a function `value[i][k]` representing the value gained by investing `k` units in it (non-decreasing, not necessarily linear). You also have a risk score `risk[i][k]` for each investment level, and a total risk cap `R`. Maximize total portfolio value without exceeding `B` or `R`. ```python def max_portfolio_value( value: list[list[int]], # value[i][k]: value of investing k units in asset i risk: list[list[int]], # risk[i][k]: risk of investing k units in asset i B: int, R: int ) -> int: pass ``` ## Example ``` Input: value = [[0,3,5,6], [0,4,6,7], [0,2,4,8]] risk = [[0,1,2,4], [0,2,3,5], [0,1,3,6]] B = 4, R = 6 Output: 11 # Allocate 1 to asset 0 (v=3,r=1), 1 to asset 1 (v=4,r=2), 2 to asset 2 (v=4,r=3) # total value=11, total risk=6, total budget=4 ``` ## Follow-ups 1. What is the time complexity of your DP solution? Can you improve space usage? 2. How would you handle fractional allocations (continuous version)? 3. What changes if risk is a covariance matrix rather than per-asset scalars?

## Problem Given a graph, determine which nodes are reachable from a given source node, likely via BFS or DFS traversal. ## Likely LeetCode equivalent General graph reachability; similar to Number of Connected Components (LC 323) or Find the Town Judge variants. ## Tags graph, bfs, dfs, robinhood

## Problem A group of friends track shared expenses. Each transaction is `(payer, [participants], amount)`. After all transactions, compute the **minimum number of payments** needed to settle all balances (everyone ends at net 0). ```python def min_transfers(transactions: list[tuple[str, list[str], float]]) -> int: pass ``` ## Example ``` Input: transactions = [ ("Alice", ["Alice", "Bob", "Carol"], 90), # Alice paid $90 for 3 people ("Bob", ["Bob", "Carol"], 40), # Bob paid $40 for 2 people ("Carol", ["Alice", "Bob", "Carol"], 60), # Carol paid $60 for 3 people ] Net balances: Alice: paid 90, owes (90/3 + 60/3) = 50 -> net +40 Bob: paid 40, owes (90/3 + 40/2 + 60/3) = 90 -> net -50 Carol: paid 60, owes (90/3 + 40/2 + 60/3) = 90 -> net -30 Output: 2 # Bob -> Alice $40, Bob -> Carol $10, Carol -> Alice 0 ... optimally 2 transfers ``` ## Follow-ups 1. Why is minimizing transfers NP-hard in general? What structure allows greedy to work? 2. How would you handle multi-currency transactions? 3. Design a REST API for this service: what endpoints, data model, and consistency guarantees do you need?

## Round 1 - System Design ## Problem Design a trading system's **order matching engine** that processes buy and sell orders in real time. The engine must maintain an order book and match orders by price-time priority (best bid/ask first; ties broken by arrival time). Core operations: - `place_order(order_id, side, price, quantity)` — add a limit order - `cancel_order(order_id)` — remove an unmatched order - `get_best_bid() -> (price, quantity)` - `get_best_ask() -> (price, quantity)` - `get_trades() -> list[(buy_id, sell_id, price, qty)]` — trades executed since last call ## Example ``` place_order("B1", "buy", 100, 10) place_order("B2", "buy", 101, 5) place_order("S1", "sell", 101, 3) # Match: S1 fills against B2 (best bid=101): trade (B2, S1, 101, 3) get_best_bid() -> (101, 2) # B2 has 2 remaining get_best_ask() -> None # no unmatched sell ``` ## Follow-ups 1. What data structures give O(log n) insert/delete and O(1) best-bid/ask lookup? 2. How do you handle partial fills and order amendments? 3. How would you scale this to thousands of symbols with microsecond latency requirements? 4. What consistency guarantees are needed if the engine runs across multiple nodes?