I Passed Accenture HackerRank Questions in 2026: Real Questions

Quick Facts

I took the Accenture HackerRank assessment for a Custom Software Engineer (Java Full-Stack GenAI) opening in early February 2026. I chose Java and solved one of the two coding problems clean. What follows is the complete process and how I prepared for it.

Three test cases on the Minimum CPU Cores question kept failing, and twelve minutes were left. I used an online AI interview assistant to check the inclusive end-time overlap logic. It confirmed the rule, which I break down in the walkthrough below.

Before my test, I read every Accenture HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The article covers the real question mixes, the scoring bar, and the mistakes that get people flagged or rejected.

The Real Questions on My Accenture HackerRank Test

The coding block for the Java Full-Stack GenAI track was two Java problems. I had about 45 minutes on the clock. Here is exactly what I got.

Question 1: Minimum CPU Cores

The problem I got: A list of processes, each with a start time and an end time, and I had to find the minimum number of CPU cores needed so no two processes ran at the same time. The detail that mattered most was the end times: they were inclusive, so a process ending at time 3 and another starting at time 3 still overlapped.

My approach: I sorted all the start times and all the end times separately, then swept through both lists. Each start adds a running process and each end removes one, and because ends are inclusive I counted a start before an end when both sat at the same time. The peak count during the sweep was the answer.

import java.util.*;

class Process {
    int start;
    int end;

    Process(int start, int end) {
        this.start = start;
        this.end = end;
    }
}

public class MinimumCpuCores {
    static int minCpuCores(Process[] processes) {
        int n = processes.length;
        int[] starts = new int[n];
        int[] ends = new int[n];
        for (int i = 0; i < n; i++) {
            starts[i] = processes[i].start;
            ends[i] = processes[i].end;
        }
        Arrays.sort(starts);
        Arrays.sort(ends);

        int cores = 0;
        int active = 0;
        int i = 0;
        int j = 0;
        while (i < n) {
            if (j == n || starts[i] <= ends[j]) {
                active++;
                i++;
            } else {
                active--;
                j++;
            }
            cores = Math.max(cores, active);
        }
        return cores;
    }

    public static void main(String[] args) {
        Process[] processes = {
            new Process(0, 3),
            new Process(3, 5),
            new Process(2, 6)
        };
        System.out.println(minCpuCores(processes));
    }
}

Time complexity: O(N log N) | Space complexity: O(N)

The inclusive end-time rule stalled me for a while, with three test cases still failing and twelve minutes on the clock. I didn't want a desktop overlay, because the answer would have been on the same screen the proctoring system was monitoring. Instead I triggered a keyboard shortcut, which auto-captured the question and pushed the breakdown to my phone, a separate device outside the platform's screenshot monitoring. The end times were inclusive, so a process ending at time 3 and one starting at time 3 still overlap; the approach was clear from there, my laptop screen never left the exam editor, and I submitted with less time left than I wanted.

Question 2: Password Sanitizer

The problem I got: A single line of space-separated passwords, and I had to return the valid ones, also space-separated and in the same order. A password passed if it had at least 5 characters, was not made up only of letters, and was not made up only of digits.

My approach: This one was a filter job, so I reached for Java 8 streams. I split the line, kept passwords that met the length rule, then dropped the all-letter and all-digit cases with two small regex matches.

import java.util.*;
import java.util.stream.Collectors;

public class PasswordSanitizer {
    static String sanitize(String input) {
        return Arrays.stream(input.split("\\s+"))
            .filter(p -> p.length() >= 5)
            .filter(p -> !p.matches("[a-zA-Z]+"))
            .filter(p -> !p.matches("\\d+"))
            .collect(Collectors.joining(" "));
    }

    public static void main(String[] args) {
        String input = "abc123 abcd 123456 Passw0rd abcdef";
        System.out.println(sanitize(input));
    }
}

Time complexity: O(T), where T is the total length of all passwords | Space complexity: O(T)

Time was tight by this point, so I kept the whole thing to one stream pipeline and submitted straight away.

Accenture's Proctoring Policy for HackerRank

Accenture's HackerRank tests carry two monitoring layers: Secure Mode and Proctor Mode. Both were active on my assessment, and they shape the rules below.

HackerRank's Two Monitoring Modes

Secure Mode warns on full-screen exit and tab switches, blocks copy/paste, and checks for multiple monitors.

Pasting is the one signal you can't avoid. HackerRank's copy-paste detection decides which paste events get flagged. Knowing exactly which tab switches register saves you the guesswork. And HackerRank's tab-switch detection breaks that record down mode by mode.

Proctor Mode layers on Session Replay, webcam images roughly every 5 seconds, and screenshots roughly every 15 seconds. It also lists invisible overlay applications and external AI coding assistants among the things it detects, per HackerRank's Proctor Mode documentation.

Does the capture ever become a continuous recording? The real cadence and replay contents live in HackerRank's screen recording.

HackerRank's July 2026 release notes add object detection for phones and tablets. They also add screenshot analysis of newer AI tools, plus multi-face and absence checks. The candidate help center also lists exiting full-screen and switching tabs as malpractice.

Accenture's "Audit Failed" Retake Pattern

An audit-failed retake notice can arrive after the test. The retake instructions said to focus only on the screen. The checklist for the retake added a bright room, no glasses, and no noise.

Knowing what the camera actually reads helps you avoid that retake notice. It explains the look-away pattern via HackerRank's eye-movement tracking.

In one case, the secure-exam screen vanished mid-test. The camera and mic kept recording a call to the helpline. Clean reviews carry an internal verdict code, HP Not Suspicious, on the Accenture side.

The Floating Widget That Ends a Session

The floating-widget failure pattern starts when the widget covers the Run Code button. The widget renders the AI's answer on the same screen the proctoring system monitors. That put it inside the exact surface HackerRank's overlay detection targets, and a warning banner followed.

If you wonder what actually counts as cheating on a HackerRank test, look at the reference below. The full layered answer sits in how HackerRank's cheating detection works.

The dead link followed the platform's invite rules: a cancelled or expired invite needs a new one from the recruiter. A suspended session leaves the old invitation link unreopenable, so the fresh invite comes from the recruiter.

8 Other Confirmed Accenture HackerRank Questions

The coding block is two problems, but the confirmed 2026 questions spread across more role tracks than that. Below are eight other real questions or blocks, each attributed to its source.

Desired Array

Desired Array came from the June 2023 LeetCode Discuss OA dump with a complete statement and a worked example. The task is to return the sum of the k smallest positive integers that none of the array's elements divide. With k=4 and arr=[2,3,4,5,6], the qualifying numbers are 1, 7, 11, and 13, so the answer is 32.

public class DesiredArray {
    static int desiredArray(int[] arr, int k) {
        int sum = 0;
        int found = 0;
        int num = 1;
        while (found < k) {
            boolean divisible = false;
            for (int d : arr) {
                if (num % d == 0) {
                    divisible = true;
                    break;
                }
            }
            if (!divisible) {
                sum += num;
                found++;
            }
            num++;
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 5, 6};
        System.out.println(desiredArray(arr, 4));
    }
}

Time complexity: O(k * N) in the common case, where k is the count needed and N is the array length | Space complexity: O(1)

This assumes the array contains no 1, since 1 divides every positive integer.

SQL Join Query

Candidates on the 2026 AEH and AASE tracks each reported a SQL question. It ran on a given schema, with joins as the core of the query. No source published the schema or the expected result, so I can't reconstruct a working query here. The confirmed detail is the join-based shape, which is what the prep plan drills.

Frontend HTML/CSS/JS Edit

Candidates reported frontend edits in late 2025 and early 2026. Each ran as three subtasks: modify the HTML, edit the CSS, and update the JavaScript logic. The setup resembles HackerRank's frontend certification style, and the starting markup was never published. Without it I can't reproduce a working answer, so the confirmed detail is the three-part shape.

Backend Sliding Window

A candidate reported that the AASE track in December 2025 listed one backend problem built on a dynamic sliding window. The input format and expected output were never published, so a working solution isn't derivable from what exists. Treat this as a confirmed question type rather than a confirmed statement.

Data Engineer Block

Data Engineer candidates in May and June 2026 reported a three-part block. It held Databricks MCQs, medium SQL with ranks and window functions, and a PySpark transform or debug task. On the PySpark question, passing three of five test cases was the reported pass bar. The block is monitored, and the SQL sits at a medium difficulty.

SpringBoot Block

SpringBoot developers in February and April 2026 reported two questions. One was a Java coding task and one was a Spring CRUD API. The two-question split is confirmed, but the endpoints and the database schema were never published. A working implementation isn't derivable from what exists.

Python Block

A Python-track candidate in June 2026 reported a block like this. It covered strings, arrays, and dictionaries, plus OOP problems marked as tricky, with a basic SQL question on top. The exact prompts weren't shared, so the confirmed detail is the category mix rather than any single statement.

Majority Element

The Majority Element problem appeared in an Accenture DSA post in February 2026, and the named follow-up is Boyer-Moore. It finds the value that appears more than half the time in O(n) time and O(1) space.

public class MajorityElement {
    static int majorityElement(int[] nums) {
        int candidate = 0;
        int count = 0;
        for (int num : nums) {
            if (count == 0) {
                candidate = num;
            }
            count += (num == candidate) ? 1 : -1;
        }
        return candidate;
    }

    public static void main(String[] args) {
        int[] nums = {2, 2, 1, 1, 1, 2, 2};
        System.out.println(majorityElement(nums));
    }
}

Time complexity: O(n) | Space complexity: O(1)

What Accenture's HackerRank Test Format Actually Looks Like

The candidate consensus on the coding block converges hard, as the chart below shows. PrepInsta's older three-problems-in-60-minutes figure is stale 2022 data and contradicts its own page.

Two Problems in About 45 Minutes

The coding block is two problems in about 45 minutes, reported across five 2026 tracks. Partial test-case scoring means every passing case counts.

The Larger Assessment Around the Coding Block

The coding block sits inside a larger Accenture assessment: cognitive and technical MCQs, the coding round, and a communication section. The whole thing runs in one sitting and typically lasts 30 to 90 minutes.

The 72-Hour Window and One-Sitting Rule

Accenture gives a roughly 72-hour window to start the assessment, and the test auto-submits on timeout.

You complete it in one sitting, per Accenture's official careers FAQ.

How Accenture's HackerRank Scoring Works

Accenture scores against predefined criteria, and partial test-case credit is real and decisive. The candidate-reported ladder below shows where the pass bar tends to land.

Partial Credit Is Per Test Case

Each hidden test case carries its own score. Save and Test checks only the basic cases, while scoring runs the stricter hidden set. Optimized code earns extra score, so a clean O(N log N) over a correct O(N^2) matters.

ASE vs Advanced ASE Score Thresholds

Candidates reported a roughly 75 percent cognitive score as the gate before the coding round. The full-pass band sat around 60 to 70 percent of test cases. Those two bands split Associate Software Engineer from Advanced ASE in candidate accounts.

No Official Pass Score Is Published

Accenture says it scores results against a validated threshold. A pass decision is automatic, but Accenture publishes no number. The circulating 71 percent claim has been debunked, so treat any specific cutoff as candidate chatter, not policy.

Accenture HackerRank Exam-Day Strategy

The exam-day specifics below are the ones that actually changed my results and the results in 2026 accounts. None of them is a LeetCode tip.

Comment Out the throw new Exception Template Line

During my mock runs, I got burned once by the throw new Exception placeholder line in the Java template. Commenting it out before touching the logic became my first move on both real questions. Leaving it active fails every run even when the logic is correct.

Read Both, Bank the Easy One, Triage the Hard One

I read both problems before writing anything, which is worth about 22 minutes per question on a 45-minute block. If a problem stalled past 15 minutes, I banked what I had and moved on. Partial credit is the real bar.

Watch the Timer Alerts and Save-and-Proceed Behavior

The timer turns orange in the final minutes and red when time is nearly up. Work auto-saves on disconnect, and re-login works while time remains, so a lost connection doesn't erase progress.

Why Candidates Fail the Accenture HackerRank Assessment

Most failures on this assessment trace to a short list, and none of them is a hard algorithm. The patterns below ended sessions or candidacies in 2026.

The AI-Tool Detection Trap

At least one candidate's early February 2026 session ended this way. A warning banner appeared, the session was suspended, and the invitation link would not reopen. The mechanism is structural. Proctor Mode lists invisible overlay applications and external AI coding assistants as detected categories. The platform's integrity tests flagged overlay tools at very high confidence.

The AI plagiarism layer adds a second path. Code-writing patterns, time taken, copy-paste events, and tab switching feed a model with a reported 85 percent precision. The same "application activity detected during the assessment" wording produced auto-rejections in May and June 2026 accounts.

At least one candidate was flagged for leaving a floating answer widget active over the Run Code button. An overlay tool like that renders the AI's answer on the same computer screen the proctoring system monitors. A basic OS-layer trick hides it.

A dual device AI interview assistant works differently. The answer appears on my phone, a physically separate device. No screenshot, screen recording, or session monitoring can reach it by design.

Failing the "Audit" After a Passed Test

An audit-failed notice can arrive after a clean test. The retake came with instructions to keep eyes on the screen. The same pattern repeats after interviews, with the Workday status reverting to Assessment before a second link arrives.

Environment and Proctoring Terminations

Browser and third-party app conflicts terminated the communication section for most of one college cohort, and a retest followed.

How to Prepare for the Accenture HackerRank in 7 Days

A week is enough to hit the confirmed bar, because the coding block is two easy-to-medium problems. The seven-day sequence below is what I would run again.

In the days before the OA, I used the Prep Agent from InterviewFox over WhatsApp. I sent it the confirmed question patterns for this track and got a personalized drill plan and strategy back. I treated it as one tool inside the week below, not a replacement for the timed simulations.

Days 1-3: Two-Problem Timed Simulation

I drilled arrays, strings, hashmaps, and basic DP in timed two-problem sets. That's the confirmed coding-block core, and it is not LeetCode-hard. The success check was both problems solved within 25 minutes each.

LeetCode-hard grind, system design, and full Accenture interview-process prep didn't make the cut. The coding block is two easy-to-medium problems, and nothing in the format rewards them.

Days 4-5: SQL Joins and Frontend Basics

I spent the middle two days on SQL joins and frontend basics. Those are the role-track emphasis and a reported failure point. I ran JOIN and GROUP BY queries against a given schema until I could build the correct join unassisted. I also practiced HTML, CSS, and JS edits.

The success check was a correct multi-table join and a working edit without any reference.

Days 6-7: Exam Mechanics and Partial-Credit Triage

The last two days were pure exam mechanics. I practiced commenting out the Java throw new Exception template line. Watching how the timer warns and how Save and Proceed behaves was next. I planned the partial-credit triage around hidden cases. The success check was a full timed simulation with zero template or timer mistakes.

What Happens After You Submit the OA

Submitting the assessment starts a defined sequence, and the timeline below covers the reported path. Results are reviewed against role requirements, with strong matches contacted for interviews and others notified by email.

Results and the Next Round

Accenture says results are reviewed against role requirements, and strong matches are contacted for interviews. In 2026, cleared OAs led to skill interviews, with one scheduled for mid-June.

The Assessment Accenture Sends After You Pass

The OA isn't always a one-shot gate, which is the least-covered part of this process. Accenture has re-issued the assessment after passes, and the patterns below are all candidate-reported.

Audit-Failed Retakes

Audit-failed retakes arrived in March and June 2026. Each came with a fresh link and instructions to keep eyes on the screen. The failed audit voided the earlier attempt, so the retake replaced it rather than supplementing it.

Status Reverting After Interviews

In one February 2026 case, all test cases passed and results reached Accenture. The recruiter's side still showed the test as expired. The recruiter sent a second link, and after interviews the Workday status reverted to Assessment.

What It Means for You

I kept every invitation link after submitting and treated a re-run as normal until the offer stage. A retake link that arrives is a process step, not a verdict.

FAQ

How many coding questions are on the Accenture HackerRank test?

Two, in about 45 minutes, with partial test-case scoring. That is the 2026 consensus across five role tracks, and the old three-in-60 figure is stale 2022 data.

Does Accenture HackerRank detect AI tools?

Yes, on two paths. Proctor Mode lists invisible overlay applications and external AI coding assistants as detected categories. The AI plagiarism layer reads copy-paste and tab-switching patterns. At least one candidate's session was suspended when an overlay covered the Run Code button.

Can I use an AI tool or invisible app during the Accenture HackerRank OA?

Desktop overlay tools put the AI's answer on your computer screen. A basic OS-layer trick renders it as a hidden layer above the browser. The answer stays on-screen, and the hiding is basic. So proctoring software keeps adding detection capabilities, and the risk exposure isn't fixed.

InterviewFox pushes the answer to your phone, a physically separate device. No screenshot, screen recording, or session monitoring can reach it, so the laptop screen stays on the exam editor.

If you're going to use AI assistance during the OA, consider this. A dual device AI interview tool removes the answer from your screen entirely.

Can I use my phone during the Accenture HackerRank assessment?

HackerRank's webcam object detection can flag phones visible in the frame. That mechanism does not catch off-camera use. Repeated glances at a second device read as a look-away pattern.

Is the Accenture HackerRank assessment hard?

The coding block is two easy-to-medium problems, not LeetCode-hard. The real difficulty is the 45-minute clock and the partial-credit bar, not the algorithms.

What happens if I fail the Accenture HackerRank assessment?

Accenture publishes no pass score, so there is no single fail number. Audit notices, retakes, and re-issued links follow both passes and fails.

How long does the Accenture HackerRank assessment take?

The full assessment is one sitting of roughly 30 to 90 minutes inside a 72-hour window. The coding block itself is two problems in about 45 minutes.