Akuna Capital Online Assessment: HackerRank Preparation by Role

Preparing for the wrong Akuna Capital online assessment (OA) can mean spending time on algorithms when your invitation calls for Python fundamentals or a role-specific project. Start with the exact role and assessment label. If the link opens in HackerRank, read the question types and instructions before deciding what to practice.

This guide helps you identify your track, choose practice that matches it, and decide whether a Reddit post or GitHub resource is relevant. It does not assume a standard Akuna question count, time limit, or passing score.

Independent guidance from SkillCopilotAI, based on public sources checked September 18, 2026. Candidate reports are unverified. The practice exercises are original teaching material; the separate Emma account uses contributor-supplied photographs.

Check your Akuna assessment invitation first

Before you begin any timed assessment, fill in this quick record for yourself. Keep the invitation private. You do not need to share the link or your candidate details to ask for general preparation advice.

HackerRank's candidate introduction explains where candidates can find the test duration, format, and sample test on the login page. Use your own page as the source of truth. If an important detail is missing, ask the hiring team. Treat the sample test as a way to learn the interface, not as a preview of Akuna’s questions. If the link or role seems wrong, contact the hiring team; HackerRank's pre-test FAQ tells candidates to reach out to their recruiter for a wrong test link or rescheduling.

If the stage label is unclear, you can ask: “My invitation names [assessment label] for [role and office]. Could you confirm the format, permitted language, duration, and allowed resources?” That is a logistics question, not a request for confidential test content.

Choose preparation by role

Akuna's early-careers page separates Technology, Trading, Quant, and Operations. Its Quant page describes researchers, developers, and strategists. Those categories are helpful when you read search results, but they are not the same as assessment specifications.

The practice directions below are editorial recommendations, not a confirmed Akuna syllabus. The three software internship postings are for Chicago, Summer 2027; they do not establish a universal assessment format.

For example, if your invitation says Python fundamentals, start with the shared-state MCQ below and explain every answer choice. If a later invitation mentions optimization, shift your practice toward a correct baseline, measurable objectives, and performance checks. This illustrates a study choice, not a predicted assessment sequence.

If you have a Python technical interview after the OA, also practice explaining your code out loud. Be ready to say why you chose a data structure, what failed during testing, and what changes when inputs get larger. A quiz-only plan will not prepare you for that kind of discussion.

Trading preparation is separate. Do not use a trader’s arithmetic or game-assessment report as a substitute for your software, research, or hardware invitation.

MCQs, coding, and longer tasks need different practice

For MCQs, explain the alternatives. Predict what a short program prints before running it. For each wrong answer, name the misunderstanding behind it. Keep a simple error log: mutation, scope, iteration, types, or complexity. Then review the rule you missed instead of memorizing the answer letter.

For coding tasks, write the contract before the implementation. Note valid inputs, required output, ordering, ties, and constraints. Test one ordinary case, one boundary case, and one case that would break your first idea. HackerRank distinguishes sample and hidden test cases; passing the visible examples does not prove your solution works for every valid input.

For a project, debugging, or optimization task, establish a baseline. Build the smallest version that satisfies the requirements first. Record how it behaves before making changes. For optimization, identify exactly what you are improving and which constraints must still hold. Compare alternatives on the same inputs. A faster wrong answer is still wrong.

There is a practical reason to separate these formats. In a Reddit discussion titled “Akuna Capital New Grad - Python OA”, the original poster describes a Python MCQ assessment, while replies discuss a later optimization task. These are candidate reports, not a verified sequence for your application. They are useful as a reminder to check the stage label, not as proof of question count or cutoff.

Original practice: diagnose the skill you need

These exercises are intentionally small. The goal is to see what went wrong and practice that specific skill again. They are original practice, not official or reported Akuna questions. They do not simulate a full hiring assessment.

Python MCQ: shared state

What does this Python 3 code print?

rows = [[0]] * 3
rows[1].append(4)
print(rows)

• A: [[0], [0, 4], [0]]
• B: [[0, 4], [0, 4], [0, 4]]
• C: [[0], [4], [0]]
• D: It raises an exception.

Answer: B. The outer list contains three references to the same inner list. Appending through one reference changes that shared object. To create independent rows, use rows = [[0] for _ in range(3)]; the same append then produces A. The Python FAQ on multidimensional lists explains this reference-sharing behavior.

Self-check: explain why C confuses appending with replacement and why D has no invalid index here. Then replace the append with rows[1] = [4]. That reassigns one outer-list slot and produces C. If that distinction is unclear, review references and mutation before adding harder puzzles.

Coding: count events in a moving window

Original specification: Given nondecreasing integer timestamps and a positive integer window width, return the number of events in the interval (t - width, t] at each event. Count only events encountered so far, including the current event. Repeated timestamps represent separate events. Return an empty list for empty input.

For timestamps [2, 2, 5, 8] and width 3, the answer is [1, 2, 1, 1]. At time 5, events at time 2 lie exactly on the excluded boundary.

def window_counts(times, width):
    if width <= 0:
        raise ValueError("width must be positive")
    left = 0
    counts = []
    for right, timestamp in enumerate(times):
        while times[left] <= timestamp - width:
            left += 1
        counts.append(right - left + 1)
    return counts

The left pointer removes events outside the window. It cannot pass the current event because a positive width keeps that event inside the interval. Each pointer advances at most once per input position, giving O(n) time and O(1) auxiliary space, excluding the O(n) returned list. The function assumes the specified sorted integer input; it does not validate that precondition.

Self-check: explain why changing <= to < breaks the exact-boundary example. Write a slow reference solution that scans all earlier events, then compare it with your implementation on small generated inputs. If the invitation names another language, implement this exercise in that language too.

Quantitative reasoning: conditional information

Original problem: Roll two independent fair six-sided dice. Given that at least one die shows 6, what is the probability that their sum is 9?

There are 11 equally likely ordered outcomes with at least one 6: six with the first die equal to 6, six with the second die equal to 6, minus the double-counted (6, 6). Two have a sum of 9: (3, 6) and (6, 3). The answer is 2/11.

Self-check: if the condition changes to “the first die is 6,” the answer becomes 1/6. Explain why the conditioning event changed. This exercise checks careful interpretation, not just arithmetic speed; it is not evidence that your Akuna assessment contains dice questions.

How to use Reddit and GitHub without studying the wrong test

Before you rely on a post, compare its role, office, hiring cycle, and stage with your own invitation record. If those details are missing, treat the post as something to investigate, not as a schedule to copy. A report about another invitation does not reveal the employer’s full decision process.

For GitHub practice, look for a clear problem statement, readable solution, tests, and stated assumptions. An employer name in a repository title does not verify the content. A good exercise should still be useful even if that name is removed.

Use public solutions carefully. Read the problem, close the solution, write your own answer, and compare only after testing. Add at least one case the repository did not include. If you cannot explain the complexity or reproduce the result, the solution has not yet become useful preparation.

This guide does not endorse an Akuna-specific question-dump repository or verify the meaning of “quant research B.” For platform practice, start with HackerRank's sample test; for a broader workflow, see our HackerRank OA preparation guide.

A preparation plan you can adapt to your deadline

1. Identify the task. Complete the invitation record and resolve missing logistics. Choose the matching role row above.
2. Run a diagnostic. Attempt a short exercise without a solution open. Record the time spent understanding, implementing, and checking it.
3. Repair one specific weakness. If you misread boundaries, add boundary tests. If language semantics caused the error, explain and rerun a small example. If performance failed, compare your baseline with an improved algorithm.
4. Rehearse the stated format. Use the language and tools permitted by your invitation. Reserve time for final checks. If your test allows navigation between questions, practice choosing an order instead of getting stuck on the first problem.
5. Check readiness. Confirm the deadline, environment, support contact, and rules. Stop adding new topics when reviewing your existing mistakes is more useful.

If you only have one evening left, focus on the invitation check, one diagnostic, and fixing the biggest issue it exposes. If you have more time, repeat the repair-and-retest cycle. This is a suggested study method, not a claim about the completion window Akuna gives candidates.

Questions to settle before test day

How long is the Akuna HackerRank test, and what score passes?

Use the duration and scoring instructions on your own invitation and test page. The official pages reviewed for this guide do not establish one question count, duration, or passing threshold across roles. Do not treat a reported “two out of three” result as a universal rule, and do not assume visible test cases guarantee advancement.

Is the assessment proctored?

Check your invitation and setup instructions. HackerRank's pre-test FAQ says candidates are notified if their test is proctored. That platform guidance does not confirm which settings Akuna enables for your assessment.

Can I use AI assistance?

The reviewed Akuna C++ internship posting explicitly prohibits AI assistance during interviews and assessments and states that use results in disqualification. The reviewed Python and Full Stack Web postings carry the same rule. Keep preparation separate from the live assessment and follow the employer's instructions.

What should I do after submission?

Keep any submission confirmation and follow the contact instructions in your invitation. While you wait, prepare to discuss your own projects and technical decisions. Another candidate’s response time cannot tell you whether your application has passed or failed.

Practice explaining your solution with SkillCopilotAI

Once you can solve an exercise, practice explaining why the solution works. SkillCopilotAI is our desktop AI interview assistant. Our product page describes suggested answer outlines based on spoken questions and context, such as your resume and target role. The photographs below concern image-based guidance, not a test of those audio or context features. Use your own practice material before the assessment.

After working through the original exercises above, ask a practice partner to question your reasoning. For example: “Why is the lower boundary excluded?” or “How do you know this algorithm is linear?” Compare any suggested guidance with your code and test results. Verify every technical claim. Then close the assistant and explain the solution again in your own words. This is a suggested practice workflow, not a measured claim that the product improves Akuna assessment results.

Emma's reported HackerRank workflow: screenshots, guidance, and a code run

Evidence note: This contributor-reported session illustrates the interface, not a recommended assessment workflow or evidence that AI use was permitted. The AI-use rules in the FAQ above apply.

A contributor provided the three photographs below and identified them as Emma’s HackerRank session from an Akuna interview invitation. The contributor also described the sequence. The photographs show the attached images, a generated response, and a code-run result. They do not independently confirm the invitation’s employer or the overall assessment outcome. Test addresses, including the one shown in the attached-image preview, have been covered for privacy. The rest of each photograph is unchanged.

Capture the question across two images

According to the contributor, Emma captured the question in two screenshots because its text extended below the visible area. She attached both images to SkillCopilotAI and entered the prompt analyze this screeshot and provide insights (spelling as supplied). The first photograph shows two attached images alongside the question's constraints and sample case.

Figure 1. Two attachments are visible. The contributor reports that scrolling was needed to capture the complete question; this photograph alone does not verify that every requirement was captured.

Read the suggested approach and write the code

The second photograph shows SkillCopilotAI returning a solution strategy and code suggestion for a pagination task. Its response identifies the generator requirement and proposes yielding successive slices of the input. The contributor reports that Emma then entered the implementation in the HackerRank editor.

Figure 2. A suggested approach and implementation are visible. A generated explanation is not proof of correctness; the selected language and the task's requirements still matter.

Check what Run Code actually reported

After Emma clicked Run Code, according to the contributor, the final photograph shows “All available test cases passed” and a “Success” compiler message. The editor contains the pagination implementation. This supports a narrow observation: the displayed run passed the test cases available in that view. It does not establish final submission, an Akuna OA pass, advancement to another round, or an offer.

Figure 3. The visible result of one code run. The test date, SkillCopilotAI version, model, and full assessment result were not supplied. The editor displays PyPy 2, so this is not evidence of a Python 3 run.

About the author: Emma is SkillCopilotAI's Article Editor & Website Operations manager. This guide was prepared with AI-assisted research and editing. The contributor identified Emma as the participant in the screenshot account; the editor preparing this page did not independently witness that session. No Akuna employment or specialist human review is claimed. SkillCopilotAI has a commercial interest in interview-preparation tools and is not endorsed by Akuna.