Citadel New Grad Three-Round VO Debrief: Permutation Equation / DMV Load Balancing / Char Topological Sort

Online resources on Citadel's three-round video interview are scarce, especially the new grad version. This post records the full flow, with emphasis on the coding content of the three VO rounds. Citadel's problems aren't just rote grinding—many sit close to real work: model design, system simulation, greedy strategy—and most critically, communication.

Citadel New Grad Interview at a Glance

Screening: Permutation Equation (Backtracking)

Place the digits 1 to 9 into the positions of three 3-digit numbers ABC, DEF, GHI such that ABC + DEF = GHI, with no repeated digits. How many valid combinations exist?

Reframe: a classic backtracking problem. Enumerate all permutations of 1-9, split each into ABC, DEF, GHI, and check the equation. The interviewer noted "some people get stuck on generating valid permutations."

from itertools import permutations

def count_valid():
    count = 0
    for p in permutations(range(1, 10)):   # all permutations of 9 digits
        abc = p[0] * 100 + p[1] * 10 + p[2]
        de_f = p[3] * 100 + p[4] * 10 + p[5]
        ghi = p[6] * 100 + p[7] * 10 + p[8]
        if abc + de_f == ghi:
            count += 1
    return count

Post-mortem: 9! = 362,880 permutations, so brute force is fine. The interviewer ran a few samples to verify at the end. Time: O(9!). Space: O(1) (excluding permutation generation).

VO Round 1: DMV Task Allocation Load Balancing

A DMV office: each employee has a multiplier for work speed (multiplier=2 means a task takes double time). Each task has a base duration (the standard time at multiplier=1). Employees work serially; tasks can't be split. Decide the allocation yourself and return the minimum total completion time.

Reframe: a textbook load balancing problem. Sort tasks by duration descending, use a min-heap to simulate each employee's accumulated finish time, and greedily assign each task to the currently freest employee, multiplying by that employee's multiplier.

import heapq

def min_completion_time(base_durations, multipliers):
    # heap stores each employee's current accumulated finish time, init 0
    heap = [(0.0, m) for m in multipliers]
    heapq.heapify(heap)
    # assign large tasks first to avoid leftovers that can't fit well
    for dur in sorted(base_durations, reverse=True):
        finish, mult = heapq.heappop(heap)
        finish += dur * mult            # actual time for this employee on this task
        heapq.heappush(heap, (finish, mult))
    return max(finish for finish, _ in heap)

Post-mortem: you write all the I/O too, so the implementation is verbose, but the logic isn't hard. The interviewer confirmed it passed, noting "there are many valid allocations; any reasonable logic works." Time: O(n log m) (n tasks, m employees). Space: O(m).

VO Round 2: Unfamiliar Problem + Communication Stall (the Main Reason I Failed)

This round was the main reason for the rejection. The problem was one I hadn't practiced, and I was briefly lost. The interviewer stayed cold and gave no hints. My approach was actually viable—I wanted a structure to store state—but the interviewer insisted on a different type. We got tangled on the representation for a long time, and forcing myself to adapt led to confusing type conversions, a logic bug, and no time to debug.

Biggest lesson: with an unfamiliar problem + poor communication + time pressure, how you keep the interviewer in sync with your pace and find a compromise during disagreement can matter more than the problem itself. In hindsight, my original approach would have worked—the gap was purely in mutual understanding and code style.

VO Round 3: Character Topological Sort

Input is several character pairs representing directed edges A -> B, plus a full character set. Output a valid character ordering satisfying all constraints; multiple answers are allowed, return any one.

Reframe: a variant topological sort (similar to Alien Dictionary). Build the graph + in-degree table, and use Kahn's algorithm (BFS + in-degree) to emit a valid order.

from collections import deque, defaultdict

def find_order(pairs, all_chars):
    graph = defaultdict(list)
    indeg = {c: 0 for c in all_chars}
    for a, b in pairs:                  # a -> b
        graph[a].append(b)
        indeg[b] += 1

    q = deque(c for c in all_chars if indeg[c] == 0)
    order = []
    while q:
        c = q.popleft()
        order.append(c)
        for nxt in graph[c]:
            indeg[nxt] -= 1
            if indeg[nxt] == 0:
                q.append(nxt)
    return order if len(order) == len(all_chars) else []   # cycle => no solution

Post-mortem: I'd practiced similar problems, so it went smoothly. The interviewer verified with sample inputs, all correct, and even offered optimization tips—a great exchange. Time: O(V+E). Space: O(V+E).

Post-Interview Summary

A rejection came three or four days later. Citadel's process is fast and technically demanding, and communication truly matters, especially with unfamiliar or complex problems.

FAQ

Does the Citadel New Grad require an OA?

Not necessarily. This was a cold application with no referral, and the screening phone invite came without even an OA—they likely picked a batch from resumes straight into screening.

What's the pace of Citadel's three VO rounds?

2h15m of three back-to-back rounds with no breaks. Each is ~45 minutes: resume / BQ first, algorithm coding in the second half. It runs on Citadel's proprietary video + editor platform, not HackerRank or CoderPad.

Are Citadel's problems hard? What do they test?

More than rote grinding. Many sit close to real work—model design, system simulation, greedy strategy, like the DMV load-balancing problem. There are also standard ones like character topological sort and permutation backtracking. The difficulty often lies in live communication rather than the algorithm.

How do I avoid a Round-2-style communication crash?

When an interviewer insists on a representation, confirm their intent before coding, and if needed, state that your approach works and ask to keep it. In practice, deliberately simulate a "cold interviewer + unfamiliar problem" scenario to train compromise under conflict. Our VO support / VO proxy / interview assistance can rehearse exactly these high-pressure communication scenarios with you.

Preparing for the Citadel New Grad VO?

Citadel's back-to-back rounds are intense—greedy / simulation / topological problems plus live communication all matter. If you want timed mocks of these three problems, focused drills on load balancing / topological sort, or "cold interviewer" communication training, reach out: share the job description so we can predict the problem set and plan practice, with live VO support / VO proxy / interview assistance pairing available.

Add WeChat Coding0201 to get Citadel VO problems and mocks.

Contact

• WeChat: Coding0201
• Email: [email protected]
• Telegram: @OAVOProxy