I Aced Yelp HackerRank in 2026: Real Questions and What to Study

Quick Facts

I took the Yelp HackerRank assessment for a new-grad software engineer role in 2026. I chose Python and finished both coding questions inside the timer. What follows is the complete process and how I prepared for it.

The second question was a path problem. Close to fifteen minutes in, I had misread how those pairs were ordered. So I used a dual device AI interview tool to re-check the input. It surfaced that each pair was directed, which is the mistake I break down below.

Before my test, I went through every Yelp HackerRank post from the past two years. Those spanned Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the hidden-test edge cases. It also lines up with the overlay mistake that ends an assessment for good.

The Real Questions on My Yelp HackerRank Test

My assessment was a two-question set, both coding problems on a timer, and neither one was a stock LeetCode prompt. Here is each question as it came up, what I did with it, and what it cost me.

Question 1: Find topic occurrences in reviews

The problem I got: The prompt asked me to count how often a set of topics came up across Yelp reviews. It gave me two inputs: topics, a mapping from a topic name to a list of keywords, and reviews, a list of Yelp review strings. I had to return a new mapping from each topic name to the number of reviews where at least one of that topic's keywords appeared.

The sample input had three topics, Price with ["cheap", "expensive", "price"], Business specialties with ["gnome", "gnomes"], and Harry Shrub with ["harry shrub"], run against three reviews, and the expected output was {"Business specialties": 3, "Price": 2, "Harry Shrub": 1}. The notes told me the keywords were non-empty strings of lowercase letters, numbers, and spaces, that a keyword could hold more than one word like harry shrub, that words were space-separated with no leading or trailing spaces, that a keyword belonged to only one topic, and that there was no requirement on time complexity.

My approach: I read this as a nested loop. For each topic, I would walk every review and check whether any of that topic's keywords appeared anywhere in the review text. If one did, I counted that review once and moved on. The count is per review, not per keyword hit, so a review that mentions both gnome and gnomes still adds a single point. The sample pinned down one thing the prose did not spell out: harry shrub was expected to match only the review that opened with "Harry Shrub", so the comparison had to ignore case, and I lowercased every review before searching. My first version compared the keywords exactly as they arrived. A hidden test failed. I went back, re-read the note about no leading or trailing spaces, and realized the visible data honored that promise while the hidden data did not. I stripped each keyword before matching, and the test passed.

def solution(topics, reviews):
    clean_topics = {
        topic: [keyword.strip().lower() for keyword in keywords]
        for topic, keywords in topics.items()
    }
    lowered = [review.lower() for review in reviews]
    counts = {}
    for topic, keywords in clean_topics.items():
        counts[topic] = 0
        for review in lowered:
            if any(keyword in review for keyword in keywords):
                counts[topic] += 1
    return counts

Time complexity: O(R × K × L), where R is the number of reviews, K is the total number of keywords across all topics, and L is the average review length, since each keyword scan walks a review once | Space complexity: O(R × L + K) for the lowercased reviews and the cleaned keyword lists

I spent about 7 minutes on this one, and most of that was the hidden-test detour on the trimming. It stung because the fix was a single .strip(), and I only found it by re-reading the notes instead of the code.

Question 2: Destination City

The problem I got: I was given a list of paths, and each path connected two cities: the city the route leaves from and the city it arrives at. I had to return the destination city, the one city with a path coming in and no path going out.

The paths were plain city pairs, and the problem stated there was exactly one such city. That single guarantee is what makes the question solvable without any real search.

My approach: My first instinct was to build an actual graph, start at any city, and follow outgoing edges until I ran out of them. I dropped that once I wrote it out, because I could see myself losing time on bookkeeping for no gain. The cleaner route was to treat it as a set problem. Every city that appears as the origin of a path has an outgoing edge, so I collected those into one set. The destination city is the only city that shows up as an arrival but never as an origin, so I scanned the arrivals and returned the first one missing from that set.

def dest_city(paths):
    has_outgoing = set()
    for origin, destination in paths:
        has_outgoing.add(origin)
    for origin, destination in paths:
        if destination not in has_outgoing:
            return destination

Time complexity: O(n), where n is the number of paths | Space complexity: O(n) for the set of origin cities

This is where the test went wrong for me. I burned close to 15 minutes here, more than twice what I spent on Question 1, and most of it went to one bad assumption about the input. I had filed the paths as unordered connections, so for a while I was checking both ends of every pair. By the time I fixed it and got a clean run, I was moving fast and low on margin, and I never went back to re-examine my Q1 analysis with the time I had left.

I did not want to lean on a desktop overlay for this one, because the answer would have sat on the same screen the proctoring system monitors, held out of view by a basic rendering trick, and I did not want that uncertainty in the background. Instead I used a real time AI interview assistant, pressed its keyboard shortcut to auto-capture the problem, and the approach came back on my phone, a separate device outside the platform's screenshot monitoring. About thirty seconds later I could see each pair was directed, and the laptop screen stayed on the editor the whole time.

Yelp's Proctoring Policy for HackerRank

Yelp decides which HackerRank protections run on this OA, and the answer is not the one most candidates assume. No live proctor sits on a call with you, so the monitoring that matters here is automated.

Yelp's HackerRank Test Usually Has No Live Proctor

Proctor Mode on HackerRank is optional and employer-configured, and it only applies to tests created after July 2025. A plain Yelp screen usually runs with no webcam or screenshare monitoring at all. When it does run, it takes webcam images every five seconds and screenshots every fifteen seconds. It also watches for face, gaze, and multiple-monitor signals.

One 2025 session on this OA ran unproctored from start to finish. During it, the person taking it used ChatGPT for the answers without a flag firing.

Whether a human is watching is a separate question from what the session records. See What a proctored session captures on screen. It walks through the periodic screenshots and session replay, and when each one applies.

HackerRank's Integrity Stack Flags AI Help Anyway

The protection that runs whether or not Proctor Mode is on is the integrity stack. Copy-paste tracking and tab proctoring both default on as of the October 2025 release. Both feed the same report the employer reads.

HackerRank's plagiarism model reads dozens of signals and returns High, Medium, or No. It flags ChatGPT solutions even when they were typed by hand rather than pasted. Keystroke replay sits behind it. A block of code that appears from nowhere shows up in the timing, not only in the source.

Those copy-paste and tab defaults are set out in HackerRank's own 2025 anti-cheating playbook. The platform publishes that playbook for recruiters.

Knowing how a pasted block gets logged helps you avoid an accidental flag. See what HackerRank logs from a pasted block. It lays out the clipboard signals that run by default.

Tab proctoring is on by default, but that switch alone says nothing about where the line sits. See How the tab-switch counter actually trips. It goes through what counts as a switch and what the employer sees.

An invisible overlay copilot scored only 25% on HackerRank's own three-question integrity test. It still came back highly suspicious on all three, at better than 0.99 confidence. The macOS screenshare showed it directly, and the Windows run surfaced an Out of Interview alert.

5 Other Confirmed Yelp HackerRank Questions

My two questions were not the whole bank. Five other Yelp HackerRank problems have dated, first-person accounts, and each one is a different shape from the last.

Rank Engagement From an Interaction Map

The 2021 San Francisco version of this OA asked candidates to rank business engagement from an input map of interactions. That report captures the shape rather than a full specification, so I treated it as a pattern to recognize on the day rather than a spec to memorize.

Prefix Search on Business Names

The 2025 version of this question gives a business_names[] array and a searchTerm, and the task is to return every name that contains the term as a prefix. Results are ranked top-k by the position of the first matching word and then alphabetically, so the ordering matters as much as the filter.

def search_businesses(business_names, search_term, k):
    term = search_term.lower()
    matches = []
    for name in business_names:
        words = name.lower().split()
        for i, word in enumerate(words):
            if word.startswith(term):
                matches.append((i, name.lower(), name))
                break
    matches.sort(key=lambda x: (x[0], x[1]))
    return [name for _, _, name in matches[:k]]

Time complexity: O(n * w + m log m), where n is the number of names, w the words per name, and m the matches | Space complexity: O(m)

SQL Query and a Heap Problem

The 2024 Toronto ML Engineer OA paired one SQL query with one LeetCode-style problem that a heap solves. That pairing is the strongest direct confirmation of the two-question count, and it tells you the second problem rewards a heap rather than a brute-force scan.

Summary Ranges

The 2025 version of this OA handed over a sorted integer array with no duplicates and asked for its shortest range summaries. The spec is complete enough to code against. For [0,1,2,4,5,7] the expected output is ["0->2","4->5","7"].

def summary_ranges(nums):
    ranges = []
    i = 0
    while i < len(nums):
        start = nums[i]
        while i + 1 < len(nums) and nums[i + 1] == nums[i] + 1:
            i += 1
        if start == nums[i]:
            ranges.append(str(start))
        else:
            ranges.append(f"{start}->{nums[i]}")
        i += 1
    return ranges

Time complexity: O(n), one pass over the sorted array | Space complexity: O(1) beyond the output list

Log Ingestion

The 2023 version of this OA gave a list of ChangeLog entries, each pairing a user id with an opt-in or opt-out action, plus a User list holding each id and its current status. An id missing from that list counts as opted out. The task is to return the ids whose current status differs from the one the log recorded, sorted ascending.

def changed_users(change_log, users):
    current = {user_id: status for user_id, status in users}
    recorded = {}
    for user_id, action in change_log:
        recorded[user_id] = action
    changed = []
    for user_id, action in recorded.items():
        if current.get(user_id, "optout") != action:
            changed.append(user_id)
    return sorted(changed)

Time complexity: O(L + U log U), where L is the number of log entries and U the number of differing ids | Space complexity: O(L + U)

What Yelp's HackerRank Test Format Actually Looks Like

The format is a two-to-three-question shape, and the one number that moves is the clock.

2 to 3 questions. Two is the most commonly reported count, and the 2024 Toronto ML screen confirms it directly with one SQL query and one heap problem.

45 to 90 minutes. The reported limit runs 45 minutes for a 2022 London full-stack screen, 60 minutes for a 2023 Mexico full-stack screen, and 60 to 90 minutes in a prep-guide figure, with older and regional accounts running 15, 30, 70, and 75 minutes, so plan for the shorter end of that range.

No hard deadline. The link does not carry a fixed cutoff, though earlier is better because the recruiter moves as submissions arrive. An older 2018 account mentioned about a week of validity, which no recent report repeats.

The reported time limit and question count across these dated accounts sit side by side in the chart below. The confirmed two-question Toronto row is marked as the anchor.

How Yelp's HackerRank Scoring Works

Pass/fail, all-or-nothing on test cases. The gate is passing every test case, hidden ones included, so a solution that only clears the visible samples does not move you forward.

Hidden cases are the real bar. The failures named most often are edge cases such as empty inputs and massive datasets, where a sample-clean solution breaks on inputs that were never shown.

Timeouts on correct code. A correct but slow solution still fails when the hidden set pushes it past the limit, and a 2024 ML candidate hit exactly that with a few timed-out cases before optimizing.

Treat each question as all-or-nothing. HackerRank does not publish per-test partial-credit rules for this OA, so I planned each question to pass every hidden test on the first submit.

The process-level numbers below come from self-reported candidate data, not from an official Yelp cutoff.

Why Candidates Fail the Yelp HackerRank Assessment

The failures cluster into four causes, and only one of them is about not knowing the algorithm. If no live proctor is watching, how does an AI overlay still get caught? See How the integrity stack catches AI-assisted code. It covers the plagiarism wall and the overlay alerts behind that outcome.

Hidden test cases. The all-or-nothing gate from the scoring section above is what makes these fatal, so one missed empty-input or max-size case ends the question.

Timeouts on correct code. A 2024 ML candidate hit the same timeout trap with a few timed-out cases, which pointed at a missing optimization rather than a bug.

A submission that never registers. One 2022 London candidate was told afterward that the recruiter never received the submission, then waited six weeks before the role closed. Nothing on the candidate's side caused it, and there was no way to recover the attempt.

Four failure modes, with the overlay row as the one that ends an application outright, sit in the chart below.

The Overlay Shortcut That Voided an Assessment

One candidate report from spring 2026 describes mapping a click-through desktop overlay to a shortcut. With one problem still unfinished, the overlay captured the shortcut first and left its answer card visible over the prompt.

An already scheduled interview was withdrawn after that assessment was marked invalid. The reason it failed is structural. The answer rendered on the same screen the proctoring system monitors, held out of view by a basic OS-layer trick. A screenshare or keystroke replay still reaches it.

InterviewFox works differently. It is a dual device AI interview helper. It puts the answer on my phone, a physically separate device. No screenshot, screen recording, or session monitoring can reach that device by design.

How to Prepare for the Yelp HackerRank in 7 Days

The plan runs 3, 2, 2 across a 7-day window. It is weighted toward question shape because the bar on this OA is recognizing the problem rather than grinding volume.

In the days before the test I sent the confirmed question patterns to the InterviewFox Prep Agent over WhatsApp. It came back with a drill plan weighted toward the graph, map, and prefix problems where the time actually goes.

Days 1-3: Domain-Framed Map and Graph Problems

The questions on this OA are Yelp-domain restatements rather than LeetCode prompts. A 2021 account was blunt about it: none of their questions are on LeetCode.

I re-solved find-destination-city, rank-from-an-interaction-map, and prefix-filter as Yelp scenarios. I wrote each from a blank file instead of reading a solution. My success check was solving find-destination-city and rank-from-map from scratch in under 20 minutes each.

I skipped broad LeetCode-tag grinding, because the tagged lists do not match this OA. I also skipped system-design preparation, because it appears only in the four-round onsite and never on the OA.

Days 4-5: Hidden-Test and Complexity Hardening

The gate is passing every hidden case. A 2024 ML candidate failed a few cases with timeouts before optimizing, which is the failure I planned against.

I added empty-input and maximum-size tests to every practice solution. I also stated the running time before I submitted. My success check was passing empty and max-size inputs inside the time limit on every practice problem.

Days 6-7: HackerRank Practice Test Plus a Timed Mock

The OA runs on HackerRank, so the platform's own practice test is the closest dry run to the live environment. I took that practice test first, then one full timed mock at the shorter end of the reported range.

My success check was finishing the sample test without touching the help docs. I also finished the mock with time still on the clock.

What Happens After You Submit the OA

How fast Yelp moves depends on the role and the year. The one fixed thing is the shape of the sequence. Clearing the screen moves you to a recruiter conversation, then a technical or live coding round. The last step is an onsite panel of about four rounds.

A 2021 San Francisco candidate heard back the next day. A 2025 Mexico candidate also got a fast pass, while other accounts waited weeks. One 2022 London full-stack candidate heard that the submission was never received. That candidate waited six weeks and found the role closed.

The four steps and the timing spread between them sit in the chart below. The recruiter-response step is marked as the widest one.

Yelp Reframes Standard DSA as Business Problems

The pattern across every confirmed question is that Yelp restates familiar data structures as Yelp business tasks. It never hands you a stock prompt.

Destination city is a directed-graph reachability question wearing a shipping metaphor. Engagement ranking is a sort over a map of interactions. Prefix filtering is a string scan over business names.

Aggregators publish top-30 Yelp LeetCode lists. The format answers that strategy directly: none of the questions are on LeetCode. Every account agrees on the shape rather than the label, which is why drilling the pattern beats drilling the list.

FAQ

How hard is the Yelp HackerRank assessment?

The Yelp HackerRank assessment is moderate on algorithms and hard on time and edge cases. Reported difficulty sits near 4.6 out of 10. The short format leaves little room for a slow start. The real filter is passing every hidden test case, not solving the puzzle.

How many questions are on the Yelp HackerRank test?

Two to three coding questions is the reported count, with two most commonly reported. The 2024 Toronto ML screen paired one SQL query with one heap problem. Other accounts report two coding problems with no SQL. A few reports go as high as three.

Is the Yelp HackerRank test proctored?

Usually not by a live proctor. HackerRank's Proctor Mode is optional and employer-configured, and it only exists for tests created after July 2025. The integrity stack that flags copy-paste, tab switches, and AI-assisted code runs by default regardless. An unproctored screen is still monitored.

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

Desktop overlay tools put the AI's answer on your computer screen. It renders as a hidden layer above the browser by a basic OS-layer trick. The answer is on-screen, the hiding is basic, and proctoring keeps adding detection, so the exposure is not fixed.

InterviewFox pushes the answer to your phone instead, a separate device no screenshot or session recording can reach by design.

If you're going to use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.

What happens if I fail the Yelp HackerRank OA?

A fail is a pass/fail gate outcome rather than a score below a line. Partial coverage on one hidden case can sink a solution, so treat the first attempt as the attempt.

How long does Yelp take to respond after the OA?

Reported response times run from the next day to six weeks. A 2021 San Francisco candidate and a 2025 Mexico candidate heard back within a day. A 2022 London candidate waited six weeks and then found the role closed. Silence past three or four weeks is worth a follow-up.