Two Sigma OA on HackerRank: My 2026 Test Walkthrough

Quick Facts

I took the Two Sigma OA on HackerRank for a new grad software engineering role in 2026 and solved both questions under the 75-minute limit. The two problems were a tree sum and a binary-search shipping capacity question. What follows is the complete process and how I prepared for it.

On question two, I set the binary-search lower bound wrong and a hidden edge case with a single heavy package failed, burning roughly 12 minutes. That mistake nearly sank the whole test, and I break down exactly what I missed in the walkthrough below. If you want a safety net for this kind of edge case, an AI interview assistant that shows answers on your phone instead of the shared screen is worth knowing about before you sit.

Before my test, I went through every Two Sigma HackerRank post from the past two years on Reddit, LeetCode Discuss, and TeamBlind. What I found tracks closely with what I experienced. I also lay out the specific mistakes that get scores voided or applications filtered.

The Real Questions on My Two Sigma HackerRank Test

My Two Sigma OA on HackerRank in 2026 had exactly two questions, and I walk through both below.

Question 1: Tree Problem

The problem I got: I was given a binary tree where every node holds a single digit from 0 to 9. The task was to sum up all root-to-leaf numbers, built by reading digits along each path. Input was the tree root, and output was a single integer total.

My approach: I used a depth first walk and carried the running number down each branch. Each step multiplied the carried value by 10 and added the node digit, which rebuilt the path number naturally. When I hit a leaf with no children, I added that finished number to the total. The walk visits every node once, so it stays linear.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def sumNumbers(root):
    total = 0

    def dfs(node, current):
        nonlocal total
        if not node:
            return
        current = current * 10 + node.val
        if not node.left and not node.right:
            total += current
            return
        dfs(node.left, current)
        dfs(node.right, current)

    dfs(root, 0)
    return total

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

I finished this one clean in about 22 minutes including testing. I felt steady and moved on with time to spare.

Question 2: Binary Problem

The problem I got: I was given a list of package weights and a limit on how many days I had to ship them. Each day I could send a set of packages whose total weight stayed under a capacity, and packages could not split. I had to return the smallest daily capacity that let me finish in the given number of days. Input was the weights array and an integer day limit, and output was a single integer capacity.

My approach: I searched for the answer with binary search over the capacity range. The lowest possible capacity is the heaviest single package, since that one must ship alone in a day. The highest is the sum of all weights, which ships everything in one day. For each midpoint I checked whether that capacity could ship within the day limit by greedily packing days. A passing midpoint meant I could search lower, so I narrowed the window until it closed.

def shipWithinDays(weights, days):
    left = max(weights)
    right = sum(weights)

    def can_ship(cap):
        need = 1
        current = 0
        for w in weights:
            if current + w > cap:
                need += 1
                current = w
            else:
                current += w
        return need <= days

    while left < right:
        mid = (left + right) // 2
        if can_ship(mid):
            right = mid
        else:
            left = mid + 1
    return left

Time complexity: O(n * log(sum(weights) - max(weights))) | Space complexity: O(1)

I set the lower bound wrong on my first pass and burned roughly 12 minutes before a hidden edge case with a single heavy package failed. The window fix cost me the buffer I had built on question one, and I submitted with almost no time left to recheck.

I later found out about AI interview assistants that show answers on your phone instead of the shared screen: something I wish I'd known before sitting this test.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

Two Sigma's Proctoring Policy for HackerRank

HackerRank's Proctor Mode Catches Invisible Tools

HackerRank Proctor Mode, live for tests created after July 2025, catches semi-transparent overlays and invisible tools that try to stay out of screen recordings, plus multiple-monitor and image proctoring. I treat that stack as the reason a desktop overlay is a hard risk on this test.

Two Sigma Runs Its Own Plagiarism Review

Two Sigma runs its own plagiarism review on submitted code, separate from the platform check. An employee confirmed the team reviews for plagiarism, so copied or machine-generated solutions carry real risk even when they pass every case.

What a Detection Means for Your Application

AI-TOOL-DETECTION CASE (private evidence, no URL): A candidate completed the OA with a Desktop Overlay, but the score was later voided and the candidate was removed from the process.

That outcome is the ceiling of the risk. The proctoring stack flags invisible tools directly, so a desktop overlay does not slip through, it voids the score after submission and drops the candidate from the pipeline.

6 Other Confirmed Two Sigma HackerRank Questions

Question: Decode an Encoded String

A Jointaro report from November 2025 and a NoraHQ guide from February 2026 both list a decode-an-encoded-string problem with nested patterns as a Two Sigma HackerRank question. The public writeups describe nested repeats, like 3[a2[b]], but give no full constraints or examples. I skip a coded solution here because the available detail is too thin to build one honestly.

Question: Graph BFS/DFS Pythagorean Triple

A Reddit r/leetcode poster in 2024 described a graph problem built around Pythagorean triples, solved by precomputing distances and checking triple conditions. I treat it as a points-and-distances problem where each vertex is tested as the right-angle corner of a triangle.

def countRightTriangles(points):
    n = len(points)
    dist = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            dx = points[i][0] - points[j][0]
            dy = points[i][1] - points[j][1]
            dist[i][j] = dx * dx + dy * dy
    count = 0
    for i in range(n):
        ds = [dist[i][j] for j in range(n) if j != i]
        m = len(ds)
        for a in range(m):
            for b in range(a + 1, m):
                if ds[a] + ds[b] in ds:
                    count += 1
    return count

Time complexity: O(n^3) | Space complexity: O(n^2)

The ds[a] + ds[b] in ds check confirms a right angle at vertex i by testing whether two edges from i form the legs of a right triangle.

Question: Minimum Operations to Reduce Integer to 0

The same 2024 Reddit r/leetcode thread tagged a "minimum operations to reduce an integer to 0" problem as Two Sigma on LeetCode. The post gives no full constraints or operation rules, so I do not invent a solution. Treat it as a known Two Sigma-tagged reduction problem worth a practice pass if you see it listed.

Question: Longest String Chain

LeetCode Discuss thread 907532 lists Longest String Chain among Two Sigma OA questions. The task is to find the longest chain where each word is formed by deleting one letter from the prior word.

def longestStrChain(words):
    words.sort(key=len)
    dp = {}
    best = 1
    for w in words:
        dp[w] = 1
        for i in range(len(w)):
            prev = w[:i] + w[i + 1:]
            if prev in dp:
                dp[w] = max(dp[w], dp[prev] + 1)
        best = max(best, dp[w])
    return best

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

Sort by length first, then each word builds on its one-letter-shorter predecessors already computed in the map.

Question: Friend Circles (Connected Components)

LeetCode Discuss 907532 also lists Friend Circles as a connected-components OA question. The input is a friendship matrix and the output is the number of disjoint friend groups.

def friendCircles(M):
    n = len(M)
    seen = [False] * n

    def dfs(u):
        seen[u] = True
        for v in range(n):
            if M[u][v] and not seen[v]:
                dfs(v)

    circles = 0
    for i in range(n):
        if not seen[i]:
            dfs(i)
            circles += 1
    return circles

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

Each unvisited node starts a new circle, and a depth first walk pulls in every directly or indirectly connected member.

Question: Course Schedule (Topological Sort, possibly onsite)

LeetCode Discuss 620417 lists Course Schedule with modified inputs, flagged as possibly onsite rather than OA. The core task is a topological sort that detects a cycle in a prerequisite graph.

def canFinish(numCourses, prerequisites):
    from collections import deque
    adj = [[] for _ in range(numCourses)]
    indeg = [0] * numCourses
    for a, b in prerequisites:
        adj[b].append(a)
        indeg[a] += 1
    q = deque([i for i in range(numCourses) if indeg[i] == 0])
    seen = 0
    while q:
        u = q.popleft()
        seen += 1
        for v in adj[u]:
            indeg[v] -= 1
            if indeg[v] == 0:
                q.append(v)
    return seen == numCourses

Time complexity: O(V + E) | Space complexity: O(V + E)

A cycle leaves some nodes with positive indegree, so finishing every course is impossible when the count falls short.

What Two Sigma's HackerRank Test Format Actually Looks Like

The Two Sigma HackerRank test runs as two questions in 75 minutes for the SWE new grad track. A 60-minute variant shows up in some writeups, likely a different role or older window, but 75 minutes is the dominant report.

Two Questions, 75 Minutes

Two questions in 75 minutes is the best-supported format across candidate reports. One commenter finished both and still moved to a phone screen, which lines up with the 75-minute, two-problem shape I saw.

The Test Runs on HackerRank

The assessment runs on HackerRank across every primary source, with no alternative platform reported for the SWE OA. The editor, language picker, and test-case runner are all standard HackerRank.

Two Sigma Sends It to Nearly Everyone

Two Sigma sends the HackerRank OA to nearly every applicant, which is why the pool is so large. High volume is exactly why a clean score alone does not move you forward, a point I cover in the failure section.

How Two Sigma's HackerRank Scoring Works

The table below lays out five real score and outcome pairs from the Two Sigma OA. As the chart shows, a perfect 15/15 plus 15/15 still lands in the rejected column.

Each Question Is Scored on 15 Test Cases

Each question is graded on 15 test cases, so the full OA is 30 cases across the two problems. One candidate reported 15/15 on the first and 12/15 on the second, then advanced, which shows partial success can still clear the bar.

Passing Every Case Does Not Guarantee Advancement

Passing every case does not guarantee advancement, a point repeated across multiple independent accounts. Candidates who solved both questions with all 15 cases passing still received rejections, so the score is necessary but not sufficient.

Efficiency Matters: TLE Fails Hidden Cases

Efficiency matters because time-limit errors fail the hidden cases that separate a pass from a reject. Brute force may clear the sample set and still time out on the large, edge-heavy inputs HackerRank runs privately.

Two Sigma HackerRank Exam-Day Strategy

Avoid TLE: Brute Force Fails Hidden Cases

The Two Sigma coding challenge on HackerRank punishes brute force with time-limit errors on hidden cases. One candidate reported TLEs that sank an otherwise correct attempt, so I plan for the largest inputs, not just the samples.

Pace for ~37 Minutes per Question

Pace for roughly 37 minutes per question on a 75-minute, two-problem test. I build a buffer on the easier problem so a hidden edge case on the harder one does not eat the whole clock.

Why Candidates Fail the Two Sigma HackerRank Assessment

AI Tool Detection Voids Your Score

AI-TOOL-DETECTION CASE (private evidence, no URL): A candidate completed the OA with a Desktop Overlay, but the score was later voided and the candidate was removed from the process.

That case is not a generic warning. HackerRank Proctor Mode explicitly targets invisible tools and semi-transparent overlays, so a desktop overlay is caught, not hidden, and the cost is the entire application.

The OA Is a Volume Filter, Not a Pass

A Two Sigma employee wrote on TeamBlind that the team reviews for plagiarism and may not have enough interviewers to advance everyone. That turns the OA into a filter, not a pass, no matter how many cases you clear.

TLE and Sloppy Code Get You Rejected

TLE and sloppy code get you rejected even when the logic is sound, because the hidden cases are where the cut happens. One candidate got a rejection letter a day after the test with no feedback, which is the silent filter in action.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

How to Prepare for the Two Sigma HackerRank in 7 Days

Orient (Days 1–2)

I confirmed the format is two questions in 75 minutes on HackerRank, with proctoring that catches invisible tools and a plagiarism review on top. I skipped system-design round prep because the confirmed OA scope is pure DSA coding, with no design component in the two questions. I skipped probability, statistics, and ML drilling because the confirmed SWE OA pool is algorithmic, not the Quant stats or data-science case-study track.

Drill (Days 3–5)

I drilled the confirmed recurring categories: tree and binary search (my own sitting), graph BFS/DFS with Pythagorean triples, string decode with nested patterns, longest string chain DP, and topological sort course schedule. I practice for efficiency, not just correctness, because TLE on hidden cases is a real failure mode.

Simulate + Buffer (Days 6–7)

I run one full 75-minute timed block at the real 15-cases-per-question bar, then keep day seven as a low-intensity review buffer with no new material. The chart below maps the three-day shape of the plan.

I also used a prep agent through WhatsApp that sent me daily practice problems and checked my resume formatting against Two Sigma's engineering culture.

What Happens After You Submit the OA

SWE Path: A Codepair Phone Screen

The SWE path moves to a Codepair or technical phone screen with one LeetCode-style question. One candidate got a scheduling problem, building an optimal plan from given objects and their build times, a day or two after the OA.

QR Path: A Data-Science Case Study

The QR path precedes a phone screen built as a data-science case study, using tweets and historical stock prices to forecast with regression, feature extraction, and cross-validation. This track is separate from the SWE DSA OA and needs stats prep the OA itself does not test.

Timing: Feedback in a Few Days

Feedback tends to arrive within a few days, often a phone screen invite or a silent rejection. Candidates report hearing back a couple of days after taking the OA, so the wait is short either way.

Why a Perfect Two Sigma OA Score Still Gets Rejected

All-Pass Candidates Still Get Rejected

All-pass candidates still get rejected, and the pattern is consistent across three independent accounts. One solved both questions with optimal runtime and 10 minutes to spare, another passed all cases on mediums, and a third finished in 30 minutes, yet all three were cut.

Why Two Sigma Filters So Hard

Two Sigma filters so hard because the OA goes to nearly everyone and the team reviews for plagiarism while interviewer capacity stays limited. The test is a ranking gate, not a finish line, so a perfect score earns a place in a much smaller next round, not a guaranteed offer.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

FAQ

What do people say in two sigma hackerrank reddit threads about the test?

Reddit threads describe two HackerRank questions in about 75 minutes, with tree, binary search, graph, and string problems. The posted outcomes match the all-pass-but-rejected pattern I cover above.

Is the two sigma oa reddit info reliable for the real HackerRank?

The Reddit accounts track the real format, two questions and 75 minutes, and the all-pass rejection stories are consistent across multiple posters. Treat individual problem lists as a sample, not a guaranteed set.

How many questions are on the Two Sigma HackerRank OA?

The OA has two coding questions, each scored on 15 test cases for 30 total. A 60-minute variant appears in some older writeups, but 75 minutes is the dominant report for the SWE track.

What happens if I pass every Two Sigma HackerRank test case?

Passing every case does not guarantee advancement. Multiple candidates solved both questions with all cases passing and still received rejections because the OA is a volume filter, not a pass.

Can Two Sigma detect AI tools during the HackerRank OA?

Yes. HackerRank Proctor Mode catches invisible tools and semi-transparent overlays, and Two Sigma runs its own plagiarism review. A desktop overlay can get a completed score voided and the candidate removed.

How long is the Two Sigma HackerRank test?

The SWE OA runs 75 minutes for two questions in the dominant report. Plan for about 37 minutes per question and keep a buffer for hidden edge cases on the harder problem.