Akuna OA — “Not Hard, Just Don’t Mess Up

Just wrapped up the 11.18 Akuna OA, and the feedback was surprisingly consistent:

“The questions look easy… but one messy implementation and you’re done.”

Akuna doesn’t reward clever tricks — it rewards clean logic + zero-bug code under pressure.

Below is a beginner-friendly, stable-pass breakdown of all three problems.

If you’re prepping for Quant / Trading / Strategy, feel free to copy and practice directly.

---

🟦 Problem 1 — Shortest Substring Containing k ‘I’s

Task:

Given a string s and an integer k, return the shortest substring containing at least k occurrences of 'I'.

If multiple substrings have the same length, pick the lexicographically smallest one.

This problem looks like it needs sliding window, but honestly the safest OA solution is much simpler:

✅ Stable-Pass Approach (Brute Force + Sorting)

1. Loop i through every starting index.
2. From i, expand j forward until the substring has ≥ k 'I's.
3. Record every valid substring.
4. Sort them by:
   • length ↑
   • lexicographical order ↑
5. The first one is your answer.

Why this works

Akuna’s OA input sizes are small — brute force won’t TLE.

And sorting removes all tie-break headaches.

Super easy to debug, nearly impossible to mess up.

---

🟦 Problem 2 — Accumulated Left-Side Differences

Task:

Given an array arr, for each index i, check all j < i:

• If arr[j] < arr[i]: add (arr[i] - arr[j])
• If arr[j] > arr[i]: subtract (arr[j] - arr[i])

Return the result array.

✅ Stable-Pass Approach (O(n²), fully acceptable)

1. Initialize result array res with zeros.
2. For each i from 1 → n-1:
3. For each j from 0 → i-1:
   • Apply the rule and accumulate into res[i].
4. Return res.

Why O(n²) is totally fine

This is a classic OA trap — many candidates overthink optimizations.

But Akuna cares more about correctness than cleverness.

A clean double loop is the safest way to guarantee no edge-case bugs.

---

🟦 Problem 3 — Maximum Score of a k-Star Subgraph

You’re given a weighted undirected graph.

A k-star consists of:

• 1 center node
• up to k neighbors Score = center weight + sum of chosen neighbors’ weights (only positive-weight neighbors can contribute)

✅ Stable-Pass Approach (Greedy)

1. Build adjacency list.
2. For each node as the center:
   • Collect neighbor weights.
   • Sort them descending.
   • Take the largest positive k weights.
   • Add center weight → get current score.
3. Track the global maximum score.

Why this is safe

No tricky graph theory required.

Just take the positive weights and pick the top k — straightforward and robust.

---

🟧 Final Truth

Akuna / HRT / Citadel OA isn’t about being "algorithm god-tier".

It’s about:

➡️ Simple logic

➡️ Clean structure

➡️ Zero surprises in edge cases

Write stable code, and you’re already ahead of most candidates.

---

🟩 If You’re Preparing for Quant OA/VO

You don’t have to grind alone:

• We can remote into your environment and assist you invisibly during OA (HackerRank / CodeSignal all supported)
• 100% pass → pay only if all test cases pass
• If you’re stuck on a specific problem or worried about timing — just reach out We’ll help you stabilize the pacing and logic so your performance stays solid.

Quant recruiting is a game of avoiding mistakes and saving time —

Get the right support, skip the detours, and focus on landing the offer.

If you’re prepping, drop a “prep” in the comments —

and feel free to ask anything specific.