This 11.18 Akuna OA, our side with a few students overall feedback is relatively consistent: the topic is not difficult, but whether the writing is clean and sharp, the gap opened. Akuna itself is very sensitive to the quality of the code, the completeness of the idea, so this analysis we do according to the real experience of doing the questions review, I hope to give a clearer reference to the later.
Problem 1 - Find the shortest lexicographically smallest substring containing k 'I'
Given a string s And an integer K, return the shortest substring of s that contains at least K occurrences of the character 'I'.
If multiple substrings have the same shortest length, return the lexicographically smallest one.
This is a typical "don't think complicated, just write" type of question.
Summary of title:
Given the string s and the integer k, find a substring that contains at least/exactly k 'I's.
in all substrings that satisfy the condition:
Compare length first (the shorter the better)
Same length then compare dictionary order
Our suggested stabilization idea:
The outer loop enumerates each starting point i
Sweep backward through the inner layers until you have k 'I's.
Write down the current substring as long as the condition is met.
Finally, all substrings are sorted:
length → lexicographical order
This way of writing is easy to write, easy to debug, and convenient for quick AC in stressful environments.
Problem 2 - Compute accumulated left-side differences for each element
For an array arr of size N, for each position I, compute a value.
- For every
j < i:- If
arr[j] < arr[i], add(arr[i] - arr[j]) - Else subtract
(arr[j] - arr[i])
- If
Return the result array of size N.
We've encountered this problem many times with our students, and it's essentially an O(n²) stable problem that doesn't require fancy optimization.
Summary of title:
array arrFor each position I:
- Iterate over all
j < i - if
arr[j] < arr[i]→ plus(arr[i] - arr[j]) - if
arr[j] > arr[i]→ Less(arr[j] - arr[i])
Finally, the accumulated results for each position are stuffed back into the result array.
Real-world deliverable program:
- The two-level loop is written directly
- The boundaries are particularly clear and not easy to write wrong
- No tricky inputs, no flopping.
For Akuna, steadiness and accuracy are always more important than showmanship.
Problem 3 - Find the maximum-weight k-star subgraph
You are given a weighted undirected graph.
Each node has a weight.
A k-star is defined as choosing one node as the center and selecting up to K of its neighbors.
The score of this star is.
center_weight + sum of the weights of the selected neighbors
Only neighbors with positive weight should be selected.
Return the maximum score over all possible centers.
It's Akuna's ever-popular "light graph theory + intuitive greed" test.
Summary of title:
- weighting scheme
- Pick a node to be the center
- Pick the most from your neighbors.
KA node with positive weights - Score = center weight + sum of weights of first k neighbors
- To maximize this score
Programhelp gives trainees a pass program:
- Use adjacency list to store diagrams
- For each node:
- Grab all the neighbor weights.
- sort
- Take the first k positive values
- Calculate the sum and update the maximum value
It's a standard solution that is "basically a sure thing when you're done", with a clean, uncluttered style of writing.
We're here for you, from confusion to disembarkation.
If you are also preparing for the OA or VO of Akuna, HRT, Citadel, Optiver which are Quant/Trading series during this period of time, in fact, you don't need to carry it alone at all. We've already accompanied many students this year from the beginning to a solid landing, and the biggest takeaway is this:
As long as you have someone to help you navigate the questions, pacing, and notes, your play will be more consistent than you think.
- Remote connection via ToDesk
- Trace-free handling of the entire OA process in your environment
- All test cases 100% pass or no charge
- Suitable for various OA platforms (HackerRank / CodeSignal / Codility / HireVue code, etc.)
The point is:
The whole process will not leave any traces and will not be detected by the platform, which is really steady, fast and clean.
If you're stuck on a particular OA right now, or worried about flipping out due to time pressure, it's totally okay to come in and talk about your situation, and we'll help you plan the most stable way to pass based on the question type.
