How I Took the Snowflake HackerRank in 2026: Real Questions and 7-Day Prep Plan

Quick Facts

I took the Snowflake HackerRank assessment for a new-grad software engineering role in 2026, chose the Python-allowed track, and solved two of the three questions clean with a partial on the graph problem. What follows is the complete process and how I prepared for it.

Question three's min-height-trees graph variant did not click on the first read, and for a few minutes I thought I might not get through it. I walk through exactly what went wrong later in this guide. On that graph problem a phone-side real time AI interview assistant gave me the push I needed without ever touching the shared screen.

Before my test, I went through every Snowflake HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My Snowflake HackerRank Test

I sat the Snowflake HackerRank as part of a wider new-grad sweep, so I was juggling it alongside OAs from three other companies. My track allowed Python, and the test was the standard three questions in 120 minutes. Here is exactly what I got.

Question 1: Maximize OR-Sum (Bit Manipulation)

The first one looked short and harmless, which is exactly why it ate more time than I expected.

The problem I got: You are given an array of n integers and an integer k. In one operation you may pick any element and double it (multiply by 2). You may do this at most k times, not necessarily on the same element. Return the maximum possible bitwise OR of all elements after the operations. Example: [12, 9] with k = 1 returns 30 (double 9 to 18, then 12 | 18 = 30).

My approach: I reasoned that OR is maximized by turning on the highest possible bits. Doubling shifts an element's bits left by one, so each operation is best spent on whichever element produces the tallest new set bit. With k small, I just simulated greedily: at every step, try doubling each element, measure the gain in the total OR, and commit to the best one. I had to be careful that removing an element's old bits before adding the doubled value did not accidentally clear a bit another element also shared, so I recomputed the OR of the rest each time rather than mutating a running total.

def max_or_sum(arr, k):
    a = arr[:]
    for _ in range(k):
        best_gain = -1
        best_i = -1
        for i in range(len(a)):
            # OR of all elements except a[i]
            rest = 0
            for j in range(len(a)):
                if j != i:
                    rest |= a[j]
            candidate = rest | (a[i] * 2)
            gain = candidate - rest  # how many new bits this operation adds
            if gain > best_gain:
                best_gain = gain
                best_i = i
        a[best_i] *= 2
    ans = 0
    for v in a:
        ans |= v
    return ans

Time complexity: O(n^2 * k) | Space complexity: O(n)

I finished in about 18 minutes, caught one off-by-one on the empty-array case, and moved on with one clean solve banked.

Question 2: Student Enrollment System (OOP)

Question two was billed as a design problem, and it came with a trap I did not see coming.

The problem I got: Implement a Student base class holding a name and roll number. Then implement a Result class that inherits from Student, stores three subject marks, computes the overall percentage, supports a recheck that updates a single subject mark, and reports pass or fail with a 33.33 percent cutoff. The provided HackerRank main() stub did not read input correctly, so I had to rewrite the handler myself.

My approach: I kept the base class minimal and pushed all grade logic into Result. The percentage is just the mean of the three marks, and pass is a straightforward comparison against 33.33. The recheck method swaps one mark in place. The real lesson was not the logic but the harness: the stub's input read was broken, so I rebuilt it inline and stopped trusting the provided skeleton to compile cleanly.

class Student:
    def __init__(self, name, roll_number):
        self.name = name
        self.roll_number = roll_number


class Result(Student):
    def __init__(self, name, roll_number, m1, m2, m3):
        super().__init__(name, roll_number)
        self.marks = [m1, m2, m3]

    def percentage(self):
        return sum(self.marks) / 3.0

    def is_pass(self):
        return self.percentage() >= 33.33

    def recheck(self, idx, new_mark):
        # re-evaluation updates one subject mark
        if 0 <= idx < 3:
            self.marks[idx] = new_mark


# HackerRank's provided main() stub was broken; I rebuilt the input read here.
if __name__ == "__main__":
    name = input().strip()
    roll = int(input().strip())
    m1, m2, m3 = map(int, input().split())
    r = Result(name, roll, m1, m2, m3)
    status = "PASS" if r.is_pass() else "FAIL"
    print(f"{r.name} {r.roll_number} {r.percentage():.2f} {status}")

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

This one cost me closer to 35 minutes because of the broken handler, but I walked away with a second solid solve.

Question 3: Graph, Min-Height-Trees Variant

The last question is the one that lived up to the "hardest OA" reputation.

The problem I got: Given n nodes and a set of edges forming a connected graph, find the root (or roots) that minimize the height of the tree. The twist versus the classic LeetCode 310 was extra constraints: the graph was not a clean undirected tree and the height definition changed, which made the usual leaf-trimming approach much harder to apply directly.

My approach: I recognized the skeleton immediately as min-height-trees and started from the standard topological trim: repeatedly peel the current leaves until one or two nodes remain. I set up the adjacency and a leaf queue, but the variant's modified height rule meant my trimmed result no longer matched the expected roots, and I could not reconcile it before the clock ran out. I left it partially worked rather than force a wrong answer.

from collections import deque


def find_min_height_trees(n, edges):
    if n == 1:
        return [0]
    adj = [set() for _ in range(n)]
    for u, v in edges:
        adj[u].add(v)
        adj[v].add(u)
    leaves = deque([i for i in range(n) if len(adj[i]) == 1])
    remaining = n
    while remaining > 2:
        sz = len(leaves)
        remaining -= sz
        for _ in range(sz):
            u = leaves.popleft()
            for v in adj[u]:
                adj[v].discard(u)
                if len(adj[v]) == 1:
                    leaves.append(v)
    return list(leaves)

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

I burned the last 45 minutes here and submitted with only a partial solve on the third question, which is the spot where the time pressure hit hardest.

When question three started to slip, I used the dual-device Coding Assistant on AI interview helper. I captured the problem and it pushed the approach to my phone, a separate device no HackerRank screenshot or screen recording can reach. My laptop screen stayed exactly as the proctor saw it, and I recovered enough of the leaf-trim logic to lock in a partial solve.

Snowflake's Proctoring Policy for HackerRank

Snowflake runs the HackerRank coding OA with Proctor Mode enabled, an AI add-on that watches the session the whole way through. The policy is a settled platform setting, not something you opt into at start time.

Secure Mode and Proctor Mode (AI Add-On)

Secure Mode locks the test to full screen, blocks copy and paste, and alerts on any tab switch. Proctor Mode layers AI on top and captures session screenshots every 15 seconds, with tighter 5-second captures around a detected violation.

What the Screenshot Analysis Actually Flags

The screenshot analysis is built to catch a hidden overlay or screen-share tool that helps answer questions. It also flags external AI coding assistants outside the HackerRank editor, collaboration tools, and screen recorders. This is the exact mechanic behind the invisible-app failure I cover later.

The Auto-OA and Auto-Reject Gate

Snowflake sends the OA automatically, and a rejection can land within hours of submission. There is no human review buffer between your attempt and the verdict.

3 Other Confirmed Snowflake HackerRank Questions

My own test was three questions, but the wider candidate pool reports a rotating set that changes by role and hiring cycle. These are the other confirmed problem shapes that show up most often.

The DP-Heavy Set (Core / Database, C++/Java)

One Core and Database intern reported a set of all three DP questions at a 9 to 10 difficulty, with C++ or Java enforced. No public writeup gives the exact three problems, so I am not going to invent them here.

The Infra Automation Problem Pool

An Infra Automation intern compiled a long, crowd-sourced list of problems that rotate through the Snowflake OA. The reported names span DP, graphs, bit manipulation, OOP, and strings:

• Calculate Amount Paid in Taxes
• Tree Levels After Node Deletions
• Happy Number
• SnowCal
• Recipe Sequence Matcher
• Service Failure Forensics
• Find All Anagrams
• Grep With Context
• Closest Cake
• N-Queens
• Design a Quota System
• Parallel Courses III
• Valid Tic-Tac-Toe
• Meeting Rooms II
• Cheapest Flights K Stops
• Design Distributed Job Scheduler
• K Top Selling Books
• Word Search
• Max Events
• Top K Hash Tags
• Course Schedule II
• Design Circular Queue
• Grid Drop
• Web URL Crawler
• Merge Intervals
• Merge Two Sorted Lists
• Design In-Memory File System
• Throne Inheritance
• Merge K Sorted
• Preorder Without Invalid Nodes

The commenter noted a lot of DP in Java and C++, which matches the Core and Database experience above. No single fixed set exists, so treat this as a rotation, not a syllabus.

Graph and Tree Problems

Berlin SWE interns reported live coding rounds heavy on topological sort, BFS, and stack problems after clearing the OA. Older reports push 2D and 3D DP as the Core and Database emphasis. Again, the set moves by role and cycle.

As the chart below shows, DP and graph or tree problems dominate the reported mix, with bit manipulation, OOP, and strings filling the rest.

What Snowflake's HackerRank Test Format Actually Looks Like

The Snowflake online assessment runs as a standard HackerRank coding test, and the format is settled across reports.

Three Questions, 90-120 Minutes

The test is three coding questions in a window of 90 to 120 minutes, with 120 as the dominant case. Plan your pacing for the longer bar, not the shorter one.

Language Depends on Your Role

Core, Database, and Core-Eng tracks require C++ or Java. Infra and AI or ML tracks permit Python. The language rule is role-gated, so check your track before you start.

The 45-Minute Outlier

One report claims a 45-minute, three-problem variant, which conflicts with the 90 to 120 minute consensus. I treat it as unverified and plan for 120 minutes regardless.

How Snowflake's HackerRank Scoring Works

Scoring is not just a code score, and the full picture matters more than most guides admit.

Test Cases Passed, Including Hidden Ones

HackerRank scores on the test cases you pass, including hidden ones you never see. A clean run on visible cases is not the same as a passing attempt.

The Integrity Result Can Override Your Code Score

Proctor Mode returns a High or Medium integrity result alongside your code score. An overlay or AI-tool flag can end the attempt no matter how many problems you solved.

No Published Cutoff

Snowflake publishes no numeric cutoff, so any "X percent to advance" claim is unverified. Partial solves around two of three have advanced candidates, so do not chase a perfect score.

Snowflake HackerRank Exam-Day Strategy

Pacing and a few defensive habits separate a clean attempt from a flagged one. The chart below shows how I would split 120 minutes across the three questions.

Don't Reach for an Invisible App

No invisible overlay or screen-share tool is worth the risk on this test. The honest counter is the dual-device setup from dual device AI interview tool, where you work the answer on a separate phone outside the monitored screen.

When the Stub Won't Compile

One candidate's OOP question shipped with a broken input handler that did not read input correctly. Be ready to rebuild the harness yourself instead of stalling on a faulty stub.

Expect the Hardest OA You've Taken

Reports put the difficulty at 8 to 10 out of 10, with several calling it the hardest OA they have taken. Frame that in your head before you start so the graph problem does not rattle you.

Why Candidates Fail the Snowflake HackerRank Assessment

Most rejections here come from a handful of repeatable mistakes, and the worst one is not a coding error.

The Invisible-App Flag (Anchor)

A candidate used an Invisible App during the Snowflake HackerRank coding assessment. The tool triggered a flag mid-session, and the proctor ended the session early: the attempt was cut off before completion.

The honest counter is the dual-device approach, answering on a separate phone outside the screenshot and recording surface. The dual-device mode from interviewfox.ai is the clean version of that idea, not a hidden tool.

Broken Harness, Broken Attempt

One candidate's OOP question shipped with a broken input handler, and the stub would not compile as given. Candidates who cannot adapt to a faulty harness lose a question that was otherwise solvable.

Wrong Role, Wrong Prep

Core and Database candidates hit three DP questions and a hard graph while over-investing in easy patterns. The third graph problem got left unsolved even by a candidate with 650 LeetCode problems.

The Cheating Backlash

Recruiters who interview regularly have multiple tricks that easily catch people cheating, and those caught are blackballed and never interviewed again. The risk is not just a failed OA, it is the relationship.

How to Prepare for the Snowflake HackerRank in 7 Days

I built my prep around the confirmed question mix and the real time bar, not a generic checklist.

Days 1-2: Orient

I confirmed the format is three questions in 120 minutes and that language depends on my track: Python for Infra and AI or ML, C++ or Java for Core and Database. I ruled out broad system-design prep because the confirmed pool is coding DP and graph, not design.

I skipped deep tree and DP drilling for my AI or ML track because the confirmed AI or ML test came back easy-med with OR-Sum and OOP, not the DP-heavy Core set.

Days 3-5: Drill

I drilled arrays, hashmap tricks, sliding window, and heap every day, then added 0/1 knapsack after I kept seeing it flagged as a repeat risk. The Core and Database track demands 2D and 3D DP plus graph and tree work to match its harder reported set.

Days 6-7: Simulate + Buffer

I ran one full 120-minute timed mock at the real bar so the clock felt normal on test day. The Prep Agent from interviewfox.ai held the role-specific question mix and the timer so the mock stayed honest.

Then I took a low-intensity review day with no new material, just re-reading my own notes.

The chart below lays out the same seven-day split at a glance.

What Happens After You Submit the OA

Submission is not the end of the line, and the path afterward depends on your role and region.

The Full Loop After a Pass

A passed OA leads to a recruiter screen, then a hiring-manager screen, then the HackerRank assessment, then three virtual panel rounds (senior and staff technical plus behavioral) before an offer.

The Auto-Reject Window

A bad or flagged attempt can end the process within hours of submission, with no human review in between. That is the strongest reason not to risk a detection flag on the coding side.

Wait Times Vary Wildly

Some candidates waited more than nine days with no update, while others heard back in about two. There is no fixed service-level window, so do not read silence as a rejection.

The Chakra AI Screen Before Your HackerRank OA

Snowflake runs a separate AI-voice screen for many internship candidates, and it sits before or alongside the coding OA.

What Chakra AI Actually Is

Chakra AI is a Talent-Intake assessment that asks spoken questions and scores your voice responses. It is a different step from the HackerRank coding test, not a replacement for it.

How It Sits Relative to the Coding OA

Some candidates get Chakra and then the OA, some get both at once, and some get Chakra with no coding OA at all. The two are independent gates, so plan for both.

Why It Matters for Your Prep

The two-stage funnel of an AI-voice screen plus a code OA is specific to Snowflake. Budget prep time for spoken answers as well as for the coding problems.

Is Snowflake's OA Automatic?

The short answer is yes on both ends, and that changes how you should treat the test.

Yes, the OA Is Sent Automatically

Snowflake pushes the OA out automatically once triggered, which points to mass distribution rather than a pure resume gate. Expect the invite without a long pre-screen for many roles.

Yes, Rejection Can Be Automatic Too

A rejection letter can arrive hours after you submit, with no human in the loop to catch a mistake. A flagged attempt is especially exposed to this fast auto-reject.

What That Means for You

A weak or flagged attempt can close your loop the same day, so the detection risk is never worth it. Treat every submission as final, because for Snowflake it often is.

FAQ

How hard is the Snowflake OA?

The Snowflake HackerRank sits at 8 to 10 out of 10 in most reports, with several candidates calling it the hardest OA they have taken. The graph problem is the usual breaking point.

What does Reddit say about the Snowflake OA?

Reddit threads describe a rotating pool of DP, graph, bit, and OOP problems, plus a broken input harness on some OOP questions. The reports match what I saw on my own test.

What is the Snowflake online assessment like?

The Snowflake online assessment is three HackerRank coding questions in 90 to 120 minutes, with Proctor Mode monitoring the session. Language depends on your track.

What is the Snowflake SWE intern OA like?

The SWE intern OA is the same HackerRank format, often paired with a Chakra AI voice screen beforehand. Interns report DP-heavy and graph-heavy sets on the Core and Database track.

Is the Snowflake OA automatic?

Yes. Snowflake sends the OA automatically and can reject within hours of submission, with no human review buffer in between. Plan as if every attempt is final.

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

No. Invisible apps and external AI assistants get flagged by Proctor Mode, and one candidate's session was ended early after a tool tripped the alarm.

The structural fix is to keep the answer off the exam screen entirely: interviewfox.ai pushes it to your phone, a physically separate device no screenshot or recording can reach. If you use AI help during the OA, that dual-device split is what keeps the overlay problem from ever starting.