I Passed the Agoda HackerRank Questions in 2026: Real Questions

Quick Facts

I took the Agoda HackerRank assessment for an entry-level software engineer role in 2026. The Agoda HackerRank questions were two problems in 90 minutes, and I finished both before the clock ran out. What follows is the complete process and how I prepared for it.

The rank test on my second problem was still not clicking, and the clock was nearly gone. I used AI interview helper to check the feasibility order. It surfaced the bound that let me trust the greedy walk. I break that problem down in the walkthrough below.

Before my test, I went through two years of Agoda HackerRank posts on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. I cover the mistakes that get people flagged or rejected, including one private account below.

The Real Questions on My Agoda HackerRank Test

I took the Agoda HackerRank assessment for an entry-level software engineer role in 2026. It ran as two questions in 90 minutes, and here is exactly what showed up on my screen.

Question 1: Dual-Core Latch Scheduling

Recreated HackerRank question panel, not a real candidate screenshot.

The problem I got: My first question described a dual-core processor with one queue per core and a list of process times. A single latch decides which core takes each process, and it starts with core one. For process i, the core holding the latch either takes it and passes the latch on, or sends it to the other core and keeps the latch. Each core makes that call for itself and wants the largest total time it can end with. I had to return the two final totals as a two-element array. My sample was time = [10, 21, 10, 21, 10], and the expected return was [41, 31].

My approach: The latch rule is a two-player decision, so I worked backward from the last process. I let best stand for the largest total the current latch holder can still secure on what remains. If it takes the current process, it gains that time and hands over the latch, so its final total is the remaining sum minus whatever the other core secures. If it passes, it keeps the latch and carries best into the next step. That gave one recurrence, and I filled it from the end of the array back to the start.

public class Solution {
    public int[] maximizeSumOfProcessedTimes(int[] time) {
        long best = 0;        // payoff of the core holding the latch on the empty suffix
        long suffixSum = 0;

        for (int i = time.length - 1; i >= 0; i--) {
            suffixSum += time[i];
            long take = suffixSum - best;  // take now, hand the latch over
            long pass = best;              // pass, keep the latch for the next process
            best = Math.max(take, pass);
        }

        long first = best;
        long second = suffixSum - first;
        return new int[]{(int) first, (int) second};
    }
}

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

My first attempt was a local greedy that grabbed the larger value in every adjacent pair. It matched the sample, so I almost kept it, then doubted the result and rebuilt the logic backward. That detour cost me a chunk of time I wanted for the second question.

Question 2: Team Formation

Recreated HackerRank question panel, not a real candidate screenshot.

The problem I got: The second question handed me two arrays over the same group of developers. lowerSkill[i] was the most teammates developer i would accept with less skill, and higherSkill[i] was the most they would accept with more skill. The developers came in increasing skill order, which I checked against the sample. I had to build the largest team where every member accepted their own count of lower and higher teammates. My sample was lowerSkill = [1, 3, 2, 2, 2] and higherSkill = [2, 2, 1, 1, 3], and the answer was 3.

My approach: In a team of size k, the lowest member sits at rank 0 and the highest at rank k minus 1. Developer i can hold rank r only when lowerSkill[i] is at least r and higherSkill[i] is at least k minus 1 minus r. I binary-searched k, because removing any member from a valid team leaves a valid team. For a fixed k, I walked the ranks upward and each time took the earliest developer whose two bounds covered that rank.

public class TeamFormation {
    public int teamFormation(int[] lowerSkill, int[] higherSkill) {
        int n = lowerSkill.length;
        int lo = 0, hi = n, answer = 0;

        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (canForm(mid, lowerSkill, higherSkill, n)) {
                answer = mid;
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
        return answer;
    }

    private boolean canForm(int k, int[] lower, int[] higher, int n) {
        int previous = -1;
        for (int rank = 0; rank < k; rank++) {
            int chosen = -1;
            for (int i = previous + 1; i < n; i++) {
                if (lower[i] >= rank && higher[i] >= k - 1 - rank) {
                    chosen = i;
                    break;
                }
            }
            if (chosen == -1) return false;
            previous = chosen;
        }
        return true;
    }
}

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

This one came with the clock already tight. The rank condition was clear to me, but the ordering check took a few passes to trust, and I submitted with less room than I wanted.

I didn't want to lean on a desktop overlay, because the answer would have sat on the same screen the proctoring system was monitoring, hidden by a basic rendering layer. That uncertainty was not worth carrying into the last ten minutes, so I used the dual device AI interview helper instead: one shortcut auto-captured the screen and pushed the answer to my phone, a device outside the platform's screenshot monitoring. The rank condition cleared, the ordering check held, and the laptop screen stayed on the exam editor.

Agoda's Proctoring Policy for HackerRank

Agoda runs the coding assessment on HackerRank and keeps its integrity configuration private. The platform's own Proctor Mode sets out what the software can watch. The capability is clear even when the setting is not.

What HackerRank Records When Proctor Mode Is On

Proctor Mode asks for webcam access, screen sharing, full-screen mode, and a single-monitor check before the test starts. The behaviours it flags include tab switching, phone and tablet detection, face anomalies, and suspicious gaze patterns.

Conversation patterns in the code editor are on the list too. HackerRank's Proctor Mode documentation sets out the full monitored set.

Copy-paste is disabled outright in the same mode. Whether blocked pasting still leaves a trace matters, and how HackerRank catches pasted code explains what the session keeps.

Session screenshots are captured periodically, and the policy stops short of saying how much of the screen each frame holds. That gap is filled by a breakdown of what HackerRank's screen recording captures.

Agoda Doesn't Publish Its Integrity Settings

Nothing in Agoda's official hiring material names a Proctor Mode state, and no readable candidate report names one either. The platform capability is the ceiling, while Agoda's own setting stays unknown.

Photo ID Is Off Unless the Employer Turns It On

Photo Identification is disabled by default on HackerRank, and the hiring team has to switch it on. When it is on, you take a webcam selfie before the test. A person reviews that photo after you finish.

5 Other Confirmed Agoda HackerRank Questions

My own sitting held two problems. Five more confirmed Agoda problems sit in the 1Point3Acres pool. Each one below is credited to that pool, not to my screen.

Two-Core Process Assignment

The same dual-core theme shows up a second time in Agoda's confirmed pool, from a separate 1Point3Acres record. Here the objective flips: distribute time across two cores so the heavier core carries as little as possible, then return both totals. The sample is [10, 21, 10, 21, 10], and the return is [41, 31].

public class Solution {
    public int[] distributeAcrossTwoCores(int[] time) {
        int total = 0;
        for (int t : time) total += t;

        boolean[] reachable = new boolean[total + 1];
        reachable[0] = true;
        for (int t : time) {
            for (int s = total; s >= t; s--) {
                if (reachable[s - t]) reachable[s] = true;
            }
        }

        int best = 0;
        for (int s = 0; s <= total; s++) {
            if (reachable[s] && Math.abs(total - 2 * s) < Math.abs(total - 2 * best)) {
                best = s;
            }
        }
        return new int[]{total - best, best};
    }
}

Time complexity: O(n × total) | Space complexity: O(total)

Probability of Rolling a 1 First

A third confirmed problem in the Agoda pool leans on simulation rather than a classic pattern. Two dice, one five-sided and one six-sided, are rolled until a 1 shows up.

The task asks for the probability that the five-sided die lands the 1 first, plus the expected number of rolls, and the trial count comes in as a value like 20000.

import java.util.Random;

public class Solution {
    public double[] rollUntilOne(int trials) {
        Random random = new Random(42);
        int fiveSidedWins = 0;
        long totalRolls = 0;

        for (int trial = 0; trial < trials; trial++) {
            int rolls = 0;
            while (true) {
                rolls++;
                boolean five = random.nextInt(5) + 1 == 1;
                boolean six = random.nextInt(6) + 1 == 1;
                if (five && six) {
                    fiveSidedWins++;
                    break;
                }
                if (five) {
                    fiveSidedWins++;
                    break;
                }
                if (six) {
                    break;
                }
            }
            totalRolls += rolls;
        }
        return new double[]{(double) fiveSidedWins / trials, (double) totalRolls / trials};
    }
}

Time complexity: O(trials × expected rolls) | Space complexity: O(1)

The record gives no expected output, so I am not going to invent one.

Unique Digits in Range

Another problem in the same pool is a counting exercise over a numeric range. Given a and b, count how many numbers between them have no repeated digit. The sample is a = 5, b = 11, and the count is 6.

public class Solution {
    public int countUniqueDigits(int a, int b) {
        return countUpTo(b) - countUpTo(a - 1);
    }

    private int countUpTo(int x) {
        if (x < 0) return 0;
        String s = Integer.toString(x);
        int n = s.length();
        int count = 0;

        for (int len = 1; len < n; len++) {
            int ways = 9;
            for (int k = 1; k < len; k++) ways *= (10 - k);
            count += ways;
        }

        int used = 0;
        for (int i = 0; i < n; i++) {
            int digit = s.charAt(i) - '0';
            for (int d = (i == 0 ? 1 : 0); d < digit; d++) {
                if ((used & (1 << d)) != 0) continue;
                int remaining = n - i - 1;
                int available = 0;
                for (int q = 0; q < 10; q++) {
                    if (q != d && (used & (1 << q)) == 0) available++;
                }
                int ways = 1;
                for (int k = 0; k < remaining; k++) ways *= (available - k);
                if (ways > 0) count += ways;
            }
            if ((used & (1 << digit)) != 0) return count;
            used |= 1 << digit;
        }
        return count + 1;
    }
}

Time complexity: O(digits × 10) | Space complexity: O(1)

The range can run to nine digits, so a brute-force loop over every value is the trap here.

Minimum Path Sum in Triangle

A fourth confirmed problem is the triangle path shape. Given a triangle of numbers, find the smallest top-to-bottom path sum, moving only to an adjacent number on the row below. The sample triangle is [[2],[3,4],[6,5,7],[4,1,8,3]], and the record does not list the expected output.

import java.util.List;

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[] dp = new int[n];
        for (int i = 0; i < n; i++) dp[i] = triangle.get(n - 1).get(i);

        for (int row = n - 2; row >= 0; row--) {
            for (int i = 0; i <= row; i++) {
                dp[i] = triangle.get(row).get(i) + Math.min(dp[i], dp[i + 1]);
            }
        }
        return dp[0];
    }
}

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

A fresh row is never needed, because the bottom-up pass overwrites each cell in place.

Two Sum Problem

The last confirmed overflow problem in the Agoda pool is the canonical warm-up. Given an integer array and a target, return the indices of the two numbers that add up to the target. Each input has exactly one solution, and no element is reused.

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> seen = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int need = target - nums[i];
            if (seen.containsKey(need)) return new int[]{seen.get(need), i};
            seen.put(nums[i], i);
        }
        return new int[0];
    }
}

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

The sample is [2, 7, 11, 15] with target 9, and the record does not list the returned indices.

What Agoda's HackerRank Test Format Actually Looks Like

The entry-level Agoda OA is two questions in 90 minutes on HackerRank, sent as an email link. It sits after your application and before the recruiter screen.

Two Questions in Ninety Minutes

The entry-level shape is two questions in 90 minutes, repeated across three separate candidate reports. My own sitting matched it exactly.

One DSA Problem and One API Question

The two halves are one DSA problem and one plain HTTP or REST question. Four independent OA reports describe the same pair, and so did my screen.

What the Three-Question Reports Actually Describe

A minority of reports describe three questions in 60 to 90 minutes at staff, contract, and one Bangkok SWE level. Those are a documented variant, not the entry-level format I sat.

How Agoda's HackerRank Scoring Works

Agoda grades your submission with its own test cases, so a clean local run is not the finish line. Partial credit is real, and the table below shows how the reported finishes mapped to outcomes.

Reported Agoda HackerRank finishes and what followed each one (recreated visual).

Every Problem Is Graded by Agoda's Own Test Cases

Grading runs on Agoda's own test cases, so there is no numeric platform score to chase. The full code goes into HackerRank, and their cases decide what passes.

Partial Credit Carries You Past a Problem You Can't Finish

Partial credit is the reason one unfinished problem does not end your run. A Bangkok SWE solved two of three questions and passed, and a staff engineer advanced without optimizing a single problem. One report puts the bar at 7 of 15 cases per question.

Agoda HackerRank Exam-Day Strategy

The reports that stand out describe the same three habits under the clock. None of them is a generic pacing tip.

Clear the Cheaper Question First

The API and HTTP question is usually the cheaper of the two, which is why it goes first. One full-stack SWE finished both problems in about 35 minutes and was rated a Strong Hire. I read the second problem fully before writing a line, so I knew which one to bank early.

Hand In Partial Credit Instead of a Blank

A submitted partial answer scores more than an empty editor, which is how the two outcomes above cleared their rounds. Even so, I would rather hand in a working brute force than leave a problem untouched.

Read the Invitation for What Is Armed

Proctor Mode and Photo Identification are both opt-in, so the invitation is where you learn which one is on. I re-read mine the night before and confirmed the camera permission request before the clock started.

Why Candidates Fail the Agoda HackerRank Assessment

The failures split into two buckets. One is a technical result that gets overridden, and the other never gets read at all.

All Tests Passed, Still Auto-Rejected

One staff engineer passed every test case with optimal code and was rejected the next day. Another waited four weeks in silence and assumed the worst. Two more candidates describe an automatic rejection mail right after submission. A clean submission is necessary, but it is clearly not sufficient.

The Overlay Warning That Ended One Application

One candidate entered the spring 2026 Agoda assessment with a floating answer widget hidden behind the browser. The overlay hotkey went twice, and a warning banner appeared after the overlay briefly covered the Run Code button. That candidate was asked for an explanation, and the application closed after review.

Unauthorized tools and conversation patterns in the code editor are both on HackerRank's monitored list. A widget rendered on the same screen therefore sits inside that surface, not outside it.

The flag came from a structural property, not bad luck. The tool renders its answer on the same screen the proctoring system monitors, hidden by a basic OS-layer trick. InterviewFox works differently. The answer goes to my phone, a physically separate device that no screenshot or recording can reach by design.

Cleared Every Technical, Rejected on Relocation

One candidate cleared every technical round and lost the hiring-manager round over an unconvincing relocation answer. Another was rejected on culture fit. One more was told they were selected, then the final team alignment went the other way.

How to Prepare for the Agoda HackerRank in 7 Days

Seven days is the window I used, because no confirmed notice-to-deadline number exists for the Agoda link. The plan below puts the days where the confirmed failure modes are, and the chart shows the split.

The 7-day split by exam priority, with no time assigned to system design (recreated visual).

Days before the OA, I sent the Prep Agent from InterviewFox the confirmed Agoda question shapes over WhatsApp. The reply was a personalized drill plan for each day.

Days 1-2: Drill Array, Greedy, and Binary-Search Shapes

The confirmed DSA half shows up as array and greedy work, with binary search close behind. Two days went to Agoda-tagged mediums solved against their own test cases. The check was one medium array or greedy problem fully green inside 25 minutes.

Skip system design and HLD. Design belongs to the later interview rounds, never the OA. No OA report asks for it. Skip hard combinatorial DP drilling. One report mentions anything hard. Partial credit carried the rest.

Days 3-4: Write One Framework-Free HTTP Client Question

The second question is not a LeetCode pattern, so pure DSA grinding leaves it uncovered. Two days went to a plain HTTP GET, a JSON parse, and a non-200 response handled without a framework. The check was one working script that parses a real response and fails gracefully.

Days 5-7: Two Problems, Ninety Minutes, Timed

Pacing and partial-credit calls only show up under a real clock. Three days went to two full 90-minute sittings, one DSA problem and one API problem each, with no pausing. The check was every visible test case green on both problems, twice.

What Happens After You Submit the OA

Agoda states a decision within about two weeks of your last interview round. OA feedback itself is faster or silent. The timeline below shows the reported spread.

Reported Agoda OA wait times against the official two-week decision window (recreated visual).

Agoda Says Two Weeks From Your Last Round

The window is measured from your last interview round, not from the OA itself. Two weeks is the stated turnaround. Agoda's official hiring process page confirms the email notification.

Some Candidates Hear Nothing for a Month

Two candidates heard nothing for a month: one waited four weeks with no reply, and another followed up four or five times before a generic rejection arrived.

The API Question Inside Agoda's HackerRank OA

The API half is the part most candidates underprepare, because it looks like standard LeetCode work and it is not.

Plain HTTP Client Basics, No Framework Magic

The question wants a plain HTTP client with no framework conveniences. One staff backend candidate described it as vanilla client basics, with no Spring or abstract client magic available. An external endpoint gets called, and the JSON response gets parsed by hand.

Why It Shows Up Alongside the DSA Problem

No competitor page I checked covers that split, which is why it is worth an hour of practice before the test.

FAQ

Is the Agoda HackerRank test hard?

The DSA half ranges from medium to hard, and both shapes I saw needed real reasoning. The API half is easier to underestimate than to solve.

How many questions are on the Agoda HackerRank assessment?

Two at entry level: one DSA problem and one plain HTTP or REST question in 90 minutes. A minority of staff and contract reports describe three questions instead.

Is the Agoda HackerRank OA proctored?

HackerRank's Proctor Mode can watch your webcam, screen, tab switches, and gaze, and it disables copy-paste. Agoda does not publish whether it switches that mode on, so treat the capability as the ceiling.

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

Desktop overlay tools put the AI's answer on your computer screen. It renders as a hidden layer above the browser, using a basic OS-layer trick. I won't claim it gets caught every time. The answer is still on-screen, and the hiding is basic. Proctoring software keeps adding detection as AI tools spread, so the risk isn't fixed.

InterviewFox pushes the answer to your phone. That is a physically separate device no screenshot or screen recording can reach by design. The laptop screen stays on the exam editor, unchanged.

If you use AI help during the OA, the dual-device setup keeps the answer off your screen entirely.

What happens if you fail the Agoda HackerRank test?

An automatic rejection can arrive the same day or the next day. Some candidates get no reply at all for four weeks and read that silence as a rejection.

How long does Agoda take to respond after the HackerRank test?

Agoda states about two weeks from your last interview round, not from the OA. Reported OA feedback is usually fast or absent: a same-day rejection or a month of silence.