Top 15 Citadel Coding Interview Problems, Ranked by Frequency

Citadel interviews are not a gentler version of FAANG. The OA penalizes brute-force solutions even when they produce the right answer. The phone screen asks you to implement Dijkstra from scratch, not just describe it. And the problems wear finance clothing: employee scheduling windows, currency exchange graphs, order book simulations.

Prep on the standard FAANG list and assume the patterns transfer. I dare you.

This guide covers the 15 Citadel coding interview problems reported most frequently across candidate accounts, OA breakdowns, and LeetCode company tags from 2023 to 2026, with the pattern each one is testing and why Citadel reaches for it.

Citadel's Interview Is Genuinely Different

Three things stand out once you read enough Citadel interview reports.

First, dynamic programming is the dominant pattern, not trees. Algo.monster's analysis of Citadel-tagged problems counts DP as the top category by a meaningful margin, backed by candidate OA reports with finance-flavored variants: stock transaction optimization, cost minimization across intervals, path DP dressed as routing problems. If you have been doing tree traversals as your warm-up exercise, adjust.

Second, time complexity is an active gate. The OA runs hidden test suites that fail O(n²) solutions even when the output is correct. This is not a soft feedback mechanism. Your solution produces the right answer, the judge says "Wrong Answer," and you spend twenty minutes debugging logic that was never wrong. It is a feature, not a bug. Every problem on this list has an expected O(n log n) or better solution. Plan for that before you start typing.

Third, for Citadel Securities roles, the interview has an HFT accent: problems involving order books, throughput optimization, and concurrent interval overlap (modeling trading windows). The DSA is standard. The framing tests whether you can read a domain-specific problem without visibly losing the plot.

The 15 Citadel Coding Interview Problems

Rank	Problem	LC #	Difficulty	Pattern
1	Find Median from Data Stream	295	Hard	Two Heaps
2	Sliding Window Maximum	239	Hard	Monotonic Deque
3	Subarray Sum Equals K	560	Medium	Prefix Sum + Hash
4	Trapping Rain Water	42	Hard	Two Pointers / Stack
5	Maximum Concurrent Employees	custom	Medium	Sweep-Line / Intervals
6	LRU Cache	146	Medium	Hash + Doubly Linked List
7	Evaluate Division	399	Medium	Weighted Graph / BFS
8	Minimum Window Substring	76	Hard	Sliding Window
9	Best Time to Buy and Sell Stock with Transaction Fee	714	Medium	DP
10	Top K Frequent Elements	347	Medium	Heap / Bucket Sort
11	Non-overlapping Intervals	435	Medium	Greedy
12	Kth Largest Element in an Array	215	Medium	Heap / Quickselect
13	Maximal Square	221	Medium	2D DP
14	Cheapest Flights Within K Stops	787	Medium	BFS / Bellman-Ford
15	Number of Orders in the Backlog	1801	Medium	Heap / Simulation

Heap Problems: Where "I'd Use Two Heaps" Earns Zero Points

Find Median from Data Stream (LC 295) appears in more Citadel interview reports than any other single problem. The trick is two heaps: a max-heap for the lower half and a min-heap for the upper half, rebalancing after each insert so their sizes differ by at most one. Median is either the top of the larger heap or the average of both tops. You need to implement this in full, with rebalancing, not just describe it. Saying "I'd use two heaps" and waving your hands is worth approximately zero points.

Top K Frequent Elements (LC 347) and Kth Largest in an Array (LC 215) are the more approachable cousins. For 347, a min-heap of size k gives you O(n log k). For 215, quickselect does it in O(n) average. Knowing both solutions for 215 matters because interviewers sometimes ask for the O(n) version right after you give the heap answer. Consider this your warning.

Number of Orders in the Backlog (LC 1801) simulates a simple order book: buy orders and sell orders, each backed by a heap. It is a warm-up for the "Compute BBO from order data" problem that Citadel Securities rounds reportedly use. The LeetCode version is easier. Practicing it builds the mental model before you are staring at a trading system problem with fifteen minutes left on the clock.

The Hidden Test Suite Is Not Your Friend

Both Sliding Window Maximum (LC 239) and Minimum Window Substring (LC 76) appear on Citadel's list, and both are the hard versions of their respective patterns.

For Sliding Window Maximum, a simple max over each window is O(nk). It fails. A monotonic deque gives O(n): pop from the back anything smaller than the current element (it can never be a future window maximum), and pop from the front when the index falls outside the window. The deque front is always the window maximum.

Minimum Window Substring requires a two-pointer approach with a frequency map. Expand the right pointer until the window contains all required characters, then shrink the left to minimize length. Candidates report it both in OA rounds and as the harder follow-up after an easier string problem.

Interviewer telling a candidate "my grandma runs faster than your code" after they proposed bubble sort for sorting an array of 0s, 1s, and 2s

Citadel's hidden test cases have the same energy. Correct output, wrong complexity, full rejection.

Check out 12 Sliding Window LeetCode Problems That Cover Every Interview Variation for practice problems ordered by difficulty.

The Custom Citadel Problem You Will Not Find on LeetCode

This one has no official LeetCode number, but it shows up in multiple first-hand Citadel Securities OA accounts. You are given two arrays representing employee start and end times. Find the maximum number of employees active at the same time.

The standard solution is sweep-line: create events (+1 for start, -1 for end), sort by time with end events before start events on ties, and scan for the running maximum. O(n log n). A harder variant asks for the count of overlaps per employee, requiring binary search per interval.

If you know Non-overlapping Intervals (LC 435) and Maximum Concurrent Employees, you have the two sides of the interval family covered. LC 435 is greedy: sort by end time, always select the interval ending earliest. They test opposite intuitions from the same raw material. Practice both cold.

Dynamic Programming, Finance-Flavored (Inescapable Edition)

Here is the part where you discover DP problems can wear a suit and tie.

Best Time to Buy and Sell Stock with Transaction Fee (LC 714) is the DP entry Citadel reaches for most. It combines the stock DP state machine (holding vs. not holding) with a transaction cost that makes pure greedy fail. The recurrence: hold[i] = max(hold[i-1], cash[i-1] - price[i]) and cash[i] = max(cash[i-1], hold[i-1] + price[i] - fee). O(n) time, O(1) space. If you have only practiced the simpler stock problems, this one will hurt.

Maximal Square (LC 221) tests 2D DP. The recurrence is dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1 when matrix[i][j] == '1'. The value represents the side length of the largest all-ones square with its bottom-right corner at (i, j). It is easy to derive this recurrence wrong on a first attempt, which is exactly what Citadel is testing. Wrong first attempt, caught mid-interview, gracefully corrected: that is actually the signal they want.

Delete and Earn (LC 740) is a disguised house robber problem. Choosing number x earns x * count(x) points but forces you to delete all x-1 and x+1 neighbors. Map earned points to indices and run house robber DP. Candidates who miss the reduction spend a lot of time designing needlessly complex solutions before running out of time.

Clown sitting at a computer coding, captioned "How it feels while failing to write basic logic through code"

Showing up to a Citadel OA confident in your DP skills.

For more DP practice see Top 11 Dynamic Programming Problems to Master for Coding Interviews.

Graphs with Finance Framing

Evaluate Division (LC 399) gives you equations like a/b = 2.0 and asks you to compute a/c from a chain. Each variable is a node, each equation is a directed edge weighted by the ratio, and query answers are products along the path. BFS with a weight accumulator solves each query in O(V+E).

Citadel favors this problem because currency exchange rate problems are their actual domain. The formulation is identical: currencies are nodes, exchange rates are edge weights, find the best conversion path. Candidates report seeing the currency exchange variant directly in phone screens, which should not be surprising in retrospect.

Cheapest Flights Within K Stops (LC 787) adds a depth constraint: no more than K+1 edges. Modified Bellman-Ford with exactly K+1 relaxation rounds works. The constraint prevents standard Dijkstra from applying directly. Citadel interviewers ask this as a follow-up. Expect it.

Prefix Sum + Hash

Subarray Sum Equals K (LC 560) is the prefix sum flagship. Build a running prefix sum; for each index check how many earlier prefix sums equal current_sum - k. A hash map makes that lookup O(1) per element. O(n) total.

The companion problem, Subarray Sums Divisible by K (LC 974), uses modular arithmetic: two prefix sums produce a subarray divisible by k if they share the same remainder mod k. Same structure, one extra modulo operation. If you know 560 cold, 974 is a ten-minute extension.

LRU Cache: Implementation, Not Recognition

LRU Cache (LC 146) requires O(1) get and O(1) put. The solution fuses a hash map (O(1) key lookup) with a doubly linked list (O(1) removal and insertion). Sentinel head and tail nodes eliminate null checks at the boundaries.

The interview is not testing whether you know this data structure exists. It is testing whether you can implement the full combination cleanly under time pressure. Those are different skills, and LeetCode Medium tags do not capture how implementation-intensive this problem gets in practice.

If you want to understand why sentinel nodes matter, What Is a Sentinel Node? The Dummy Trick Behind Cleaner Code covers the pattern.

How to Prepare

Start with the heap cluster (295, 347, 215): three problems, one core idea, and LC 295 is the single most likely problem to appear. Then sliding window (239, 76), both Hard, both non-negotiable. Then the DP trio and the interval pair. The graph problems (399, 787) are medium difficulty but easy to fumble if you have not seen them framed in finance terms before.

Citadel's OA does not accept O(n²) solutions that happen to produce correct output. For every problem on this list, know the optimal complexity and be ready to state it unprompted. SpaceComplexity runs voice-based mock interviews with rubric scoring, which builds exactly the habits Citadel interviewers watch for: complexity analysis, edge case narration, and composure when you hit a blocker.

For a complete picture of the full interview loop, see Citadel Onsite Interview: Every Round, What It Tests, and How to Prepare and Citadel Software Engineer Interview: The Full Process, Decoded.

Key Takeaways

DP is Citadel's top pattern by volume. Skip the finance-flavored variants at your own risk.
Heap and streaming problems (median, top-K, order book) appear more here than at most companies.
Maximum Concurrent Employees has no LeetCode number but shows up in real OAs. Practice interval sweep-line cold.
Both sliding window Hard problems (239, 76) require full, clean implementations. Not descriptions.
Graph problems arrive in finance framing (currency exchange, cheapest routes). The underlying algorithm is standard; the wrapping is not.
Brute-force solutions that produce correct output still fail Citadel's hidden tests. Know your complexity before you start coding.