← Back to blog Akuna Capital Intern OA 2026 Guide｜HackerRank 70-Minute Order Book + Probability Walkthrough
OA Akuna Capital

Akuna Capital Intern OA 2026 Guide｜HackerRank 70-Minute Order Book + Probability Walkthrough

2026-05-16

Akuna Capital is a Chicago-based prop trading firm focused on options market making. Less famous in the international student circle than Citadel or Optiver, but its intern hiring volume is one of the largest in this size class — for 2026, ~90 global intern offers (40 SDE + 30 Trader + 20 Quant Research).

The OA runs on HackerRank, 70 minutes, 4-5 questions, and uniquely mixes coding + probability + business knowledge — pure-LeetCode candidates often clear the OA but stumble at onsite. Below is the 2026 spring cycle breakdown of question types, track differences, and a prep path.

Akuna Intern OA at a Glance

Dimension Detail
Platform HackerRank
Duration 70 minutes
Questions 4-5 (mix of MCQ + coding)
Difficulty LC Easy/Medium + 2 probability/math MCQs + 1 scenario
Pass Bar Coding 90%+ AC and MCQ all correct
Feedback 7-10 days
Next Step Super Day (3-4 onsite rounds + a trading game)

2026 change: Akuna partially split the OA banks for SDE / Trader / Quant Research. SDE leans algorithm + systems; Trader / Quant Research leans probability + mental math. A typical OA = 2 shared coding problems + 2-3 track-specific MCQs.

Question 1 — Order Book Simulator (SDE / Trader)

Problem

Implement a simplified limit order book that supports:

ADD <order_id> <BUY|SELL> <price> <qty>
CANCEL <order_id>
PRINT

After each ADD, perform matching: when buy meets sell at crossing prices, fill by price priority + time priority and print each fill as MATCH <buy_id> <sell_id> <price> <qty>.

PRINT outputs the best bid / best ask and total resting quantity at each.

Approach

A textbook limit order book using two heaps:

Realistically you can't ace every test in 70 minutes; doing ADD + matching well usually nets ~80% AC. Use lazy deletion for CANCEL (id → cancelled set) instead of removing from the heap.

Python Solution

import heapq
from collections import defaultdict

class OrderBook:
    def __init__(self):
        self.buy = []   # max heap: (-price, ts, id, qty)
        self.sell = []  # min heap: (price, ts, id, qty)
        self.qty = {}   # id -> remaining qty
        self.cancelled = set()
        self.ts = 0

    def _alive_top(self, heap):
        while heap and (heap[0][2] in self.cancelled or self.qty.get(heap[0][2], 0) == 0):
            heapq.heappop(heap)
        return heap[0] if heap else None

    def add(self, oid, side, price, qty):
        self.ts += 1
        self.qty[oid] = qty
        matches = []
        if side == "BUY":
            while qty > 0:
                top = self._alive_top(self.sell)
                if not top or top[0] > price:
                    break
                sp, sts, sid, sqty = top
                trade = min(qty, self.qty[sid])
                matches.append(("MATCH", oid, sid, sp, trade))
                qty -= trade
                self.qty[sid] -= trade
                self.qty[oid] -= trade
                if self.qty[sid] == 0:
                    heapq.heappop(self.sell)
            if qty > 0:
                heapq.heappush(self.buy, (-price, self.ts, oid, qty))
        else:  # SELL
            while qty > 0:
                top = self._alive_top(self.buy)
                if not top or -top[0] < price:
                    break
                bp, bts, bid, bqty = top
                trade = min(qty, self.qty[bid])
                matches.append(("MATCH", bid, oid, -bp, trade))
                qty -= trade
                self.qty[bid] -= trade
                self.qty[oid] -= trade
                if self.qty[bid] == 0:
                    heapq.heappop(self.buy)
            if qty > 0:
                heapq.heappush(self.sell, (price, self.ts, oid, qty))
        return matches

    def cancel(self, oid):
        self.cancelled.add(oid)
        self.qty.pop(oid, None)

Time complexity: amortized O(log n) per ADD Pitfall: always call _alive_top before matching — otherwise the heap top can be a cancelled order, producing a wrong MATCH event.

Question 2 — Coin Flip Expected Value (Trader / Quant)

Problem (MCQ-style)

A fair coin is flipped at most 10 times, but flipping stops as soon as two consecutive heads (HH) appear. Let X = total flips. Find E[X].

Approach

Classic state expectations — let $E_0$ = expected remaining flips when no recent H, $E_1$ = expected remaining flips after one H.

Without the cap: $$E_0 = 1 + 0.5 E_1 + 0.5 E_0 \implies E_0 = 6$$

With the "max 10" cap, do backward DP:

def expected_flips(N=10):
    # dp[k][s] = expected flips remaining with k flips left, in state s
    # s = 0 (no recent H), 1 (one H), 2 (HH absorbed, contributes 0)
    dp = [[0, 0] for _ in range(N + 1)]
    for k in range(1, N + 1):
        # state 0: flip once, go to 1 if H else stay 0
        dp[k][0] = 1 + 0.5 * dp[k - 1][1] + 0.5 * dp[k - 1][0]
        # state 1: flip once, end if H else go back to 0
        dp[k][1] = 1 + 0.5 * 0 + 0.5 * dp[k - 1][0]
    return dp[N][0]

print(expected_flips(10))  # ≈ 5.97

Answer: ≈ 5.97, approaching 6 as N grows. Why this keeps appearing: Akuna wants confirmation you can handle a finite cap via backward DP, not just pattern-match the unbounded formula.

Question 3 — Pricing Permutations (SDE algorithm-leaning)

Problem

Given a length-n array of prices, for each starting index i compute the sum, modulo 1e9+7, of products $\prod prices[k]$ over all strictly increasing subsequences starting at i. Constraint: n ≤ 1000.

Approach

LIS sum-of-products variant:

Python Solution

MOD = 10 ** 9 + 7

def pricing_sum(prices):
    n = len(prices)
    f = [0] * n
    for i in range(n - 1, -1, -1):
        s = 1  # subsequence containing only i
        for j in range(i + 1, n):
            if prices[j] > prices[i]:
                s = (s + f[j]) % MOD
        f[i] = int(prices[i] * s) % MOD
    return sum(f) % MOD

Time complexity: O(n²) — fine for n=1000 Pitfall: float prices vs modular arithmetic. The problem usually states integer prices; if floats appear, round before applying MOD.

Track Differences

Track Coding Focus MCQ Focus Recommended Prep
SDE Data structures + systems (order book, cache, graphs) Complexity, memory model, concurrency basics LC + CTCI System Design
Trader Light coding + simulation Mental math, probability, game theory, market-making basics Heard on the Street + 100 Brainteasers
Quant Research numpy / pandas + light stats Expectation, variance, Brownian motion, option pricing intuition Hull "Options" + Cornell ORIE notes

Strongly recommended: apply to only one track — Akuna's ATS marks "applied to all three" as "focus unclear", which hurts recruiter screen.

4-Week Prep

Week Focus Resources
W1 50 LC Mediums (heap / DP / graph) LeetCode high-frequency for trading firms
W2 100 probability problems + mental math Heard on the Street + Akuna brainteaser archive
W3 Order book / market making basics Hull "Options" + Akuna engineering blog
W4 2-3 mock OAs + onsite trading game sims 1point3acres Akuna real-question threads

FAQ

Q1: How hard is the Akuna intern OA?

Coding is LC Easy-Medium, but the difficulty is the high pass bar + tight clock. 4-5 questions in 70 minutes ≈ 12-15 min/each. SDE candidates report that all coding solved + at most one MCQ wrong is the typical pass threshold.

Q2: What language for the Akuna OA?

HackerRank offers Python, C++, Java by default. Trader / Quant Research candidates lean Python (faster to write); SDE candidates lean C++ because Akuna's engineering culture favors C++. Recommendation: pick whatever you can debug end-to-end in 70 minutes — don't switch to a less familiar language for "culture fit".

Q3: Can I retake the Akuna OA after failing?

No retakes within 12 months for the same track, but switching track is allowed (e.g., SDE failure → re-apply as Quant Research). Akuna keeps prior OA scores internally, so a weak first attempt raises the bar for the second — choose your track carefully.

Q4: How long after passing OA until onsite?

1-2 weeks to a Recruiter Call → Super Day (3-4 rounds in one day). Super Day includes a Trading Game: 5-6 candidates team up, market-make and arbitrage in 30 minutes. This is Akuna's signature round — strong OA + weak Trading Game = ~70% rejection.

Q5: How do I prep for the Akuna Trading Game?

It's a market-making sim. Common scenarios: (1) given a true-price distribution, set a bid-ask spread; (2) the market hits or lifts you, manage inventory dynamically. Core skills: always compute expected value, cap single-trade loss, never chase prices. Search YouTube for "Akuna Trading Game" — there are several candidate post-mortems.

Q6: What does Akuna pay interns?

2026 cycle US internships:

Contact

If you're prepping Akuna Capital, Optiver, IMC, Belvedere — that is, options market-making + prop trading — the OA is just the entry gate. Onsite trading game + brainteaser is the real filter. We've curated 2025-2026 Akuna real questions + Trading Game post-mortems + brainteaser bank — feel free to reach out.

Add WeChat Coding0201, get the Akuna OA bank and Trading Game sim.