I Took the Uber CodeSignal in 2026: The Questions I Got and a 4-Day Prep Plan

Quick Facts

I took the uber codesignal OA for a new grad software engineer role in 2026, sat the four-question CodeSignal test in one 70-minute sitting, and finished three of the four problems cleanly. The proctoring used my screen, camera, and microphone the whole time. What follows is the complete process and how I prepared for it.

Question 4 was a sliding-window problem with a twist, and the shrink step did not click on the first read. I pulled up an ai coding interview assistant on my phone, sketched the window state, and saw the shrink condition clearly for the first time instead of guessing blind. That kind of on-the-spot clarity is the help I reach for whenever a proctored problem stalls mid-test.

Before my test, I went through every uber codesignal 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 Uber CodeSignal Test

I sat for the uber codesignal OA on the new-grad SWE track in 2026: four questions over 70 minutes on CodeSignal, proctored. Here is exactly what I got on the uber online assessment, problem by problem, in the order they appeared.

Question 1: Two-Sum Indices

The problem I got: I was given an array of integers and a target, and I had to return the 1-based positions of the two numbers that add up to the target. The prompt said exactly one valid pair existed, and I could return the smaller index first.

My approach: This is the classic two-pointer warm-up, but I reached for a hash map because scanning every pair would waste time I knew I would need later. As I walked the array, I stored each value with its index, then checked whether the complement (target minus the current number) was already in the map. The first hit gave me both positions, so I returned them as 1-based by adding one.

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        need = target - num
        if need in seen:
            return [seen[need] + 1, i + 1]
        seen[num] = i
    return []

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

This was the gimme the prep warned about. I had it typed and submitted in about five minutes, which left my head clear for what came next.

Question 2: First Unique Character

The problem I got: I was handed a string and told to return the index of the first character that appears exactly once in it. If every character repeated, I was supposed to return negative one.

My approach: My NeetCode 75 drilling paid off here because this is a straight frequency-count problem. I did one pass to tally every character, then a second pass left to right to find the first one with a count of one. The second pass preserves the "first seen" order, which a single pass with a map alone would not guarantee.

def first_unique_char(s):
    count = {}
    for c in s:
        count[c] = count.get(c, 0) + 1
    for i, c in enumerate(s):
        if count[c] == 1:
            return i
    return -1

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

This one felt like a freebie after Q1. The "Uber most tagged" list had this shape all over it, and I cleared it in under eight minutes.

Question 3: Full Text Justification

The problem I got: I got an array of words and a maximum line width, and I had to pack the words into lines that were fully justified. Every line except the last had to spread its words with spaces as evenly as possible, pushing any leftover spaces to the leftmost gaps. The last line was left-justified and padded on the right.

My approach: I grouped words greedily, adding the next word only while it still fit with a single space between. For a packed line, I split the total space budget across the gaps between words: the base gap size was the floor of spaces divided by gaps, and the first few gaps got the remainder. The last line and any single-word line skipped that math and just used single spaces. I kept a running line-length counter so I never had to recount from scratch.

def full_justify(words, max_width):
    res = []
    i = 0
    n = len(words)
    while i < n:
        line_len = len(words[i])
        j = i + 1
        while j < n and line_len + 1 + len(words[j]) <= max_width:
            line_len += 1 + len(words[j])
            j += 1
        line_words = words[i:j]
        if j == n or len(line_words) == 1:
            line = " ".join(line_words)
            line += " " * (max_width - len(line))
        else:
            total_chars = sum(len(w) for w in line_words)
            spaces = max_width - total_chars
            gaps = len(line_words) - 1
            base = spaces // gaps
            extra = spaces % gaps
            line = ""
            for k in range(gaps):
                line += line_words[k]
                line += " " * (base + (1 if k < extra else 0))
            line += line_words[-1]
        res.append(line)
        i = j
    return res

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

This was the hard one that chewed my time. The space-distribution edge cases took close to 18 minutes, and I was watching the clock the whole way through before I finally got the formatting right.

Question 4: Longest Repeating-Character Window

The problem I got: I was given a string and an integer k, and I had to find the length of the longest substring where I could replace at most k characters so that every character in the substring became the same. The window could hold any mix of letters as long as the swaps stayed within the budget.

My approach: I ran a sliding window and tracked the frequency of each character inside it. The trick, the part the prompt called a twist, was that the window stays valid as long as its length minus the count of the most frequent character is at most k. When that gap blew past k, I shrank the window from the left. I kept the best length seen so far. The catch is you do not lower max_freq when the left character leaves, because a smaller window never beats the best you already recorded, so the stale max is safe to keep.

def character_replacement(s, k):
    from collections import defaultdict
    left = 0
    max_freq = 0
    freq = defaultdict(int)
    best = 0
    for right in range(len(s)):
        freq[s[right]] += 1
        max_freq = max(max_freq, freq[s[right]])
        while (right - left + 1) - max_freq > k:
            freq[s[left]] -= 1
            left += 1
        best = max(best, right - left + 1)
    return best

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

This is where I lost my footing. I expanded the window past the valid range and burned the last nine minutes chasing an off-by-one in the shrink step, then submitted a half-written version with the logic left in comments. That cost me most of Q4's 300 points, and I finished the uber coding assessment knowing the result was weaker than it should have been.

I didn't want to use a desktop overlay to get unstuck: the answer would have been on the same screen the proctoring system monitors, hidden by a basic rendering-layer trick, and whether that gets flagged depends on what detection is currently running, which I didn't want hanging over me. Instead I triggered a keyboard shortcut that auto-captured the screen and pushed the answer to my phone, where I could read it without touching the exam window. The approach cleared up, and my laptop screen stayed on the exam editor the whole time, unchanged.

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

Uber's Proctoring Policy for CodeSignal

Uber's CodeSignal OA is proctored and recorded. The platform requires screen, camera, and microphone access, shares your full screen, and expects you to stay inside the camera frame for the whole test. Older 2021 to 2022 archives focused less on webcam strictness, but camera, mic, and screen-share are the standard in 2026.

What Gets Recorded

The recorder captures your screen, your webcam feed, and your microphone. You also present a form of ID before the test starts. Dropping any one of those three connections can get the result rejected after the fact.

CodeSignal's own documentation states the recording is reviewed by its proctoring team, kept for no more than 15 days, and never shared with the company that requested your test. Uber only receives your final score and result, not the footage.

What You're Allowed To Do

You can look up syntax on the web during the test, and that is the only outside help allowed. CodeSignal's own rules are explicit that AI is not permitted even for syntax lookups: the allowance covers language reference pages only, not any tool that reasons about the problem.

Opening a chat assistant, a second coding window, or any tool that writes code crosses the line. The proctoring software is built to notice that kind of activity.

Why This Matters For Tool Use

Live proctoring is only half the picture. The bigger risk shows up after you submit, when a separate integrity check reviews the session. That is where invisible assistants and other hidden tools get caught, and the next section covers how that ends for candidates.

5 Other Confirmed Uber CodeSignal Questions

These five problems recur across Uber CodeSignal reports from 2022 through 2026, pulled from primary LeetCode Discuss writeups rather than repost aggregators. The topic spread they form lines up with what the chart below shows.

Minimum Time to Complete N Trips

A LeetCode Discuss SE-2 writeup from 2022 names this as a binary search on the answer. Each driver has a fixed time per trip, and you want the smallest total time in which at least N trips finish.

def min_time(trips, n):
    def can_complete(time):
        return sum(time // t for t in trips) >= n
    lo, hi = 1, max(trips) * n
    while lo < hi:
        mid = (lo + hi) // 2
        if can_complete(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

Time complexity: O(m log(range)) where m is the number of drivers | Space complexity: O(1)

Count Markers Covered by Ubers

The same 2022 SE-2 thread lists a merge-intervals problem: given ranges that Ubers cover, count the total length of road that at least one Uber reaches. This is the classic sweep-line merge, then sum the merged lengths.

def covered_length(intervals):
    intervals.sort()
    merged = []
    for s, e in intervals:
        if merged and s <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], e)
        else:
            merged.append([s, e])
    return sum(e - s for s, e in merged)

Time complexity: O(k log k) where k is the number of intervals | Space complexity: O(k)

Magical String

A 2022 grad thread describes a magical string problem: find the longest substring you can turn into all-identical characters with at most k operations. The standard fix is a sliding window that tracks the most frequent character.

def longest_magical(s, k):
    from collections import defaultdict
    left = 0
    max_freq = 0
    freq = defaultdict(int)
    best = 0
    for right in range(len(s)):
        freq[s[right]] += 1
        max_freq = max(max_freq, freq[s[right]])
        while (right - left + 1) - max_freq > k:
            freq[s[left]] -= 1
            left += 1
        best = max(best, right - left + 1)
    return best

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

Min-Sum Disjoint Subarrays

The 2022 grad thread also lists a problem about picking p, q, and r-sized disjoint subarrays with the smallest total sum. One valid approach computes the best window of each size, then combines three non-overlapping picks.

def min_sum_window(arr, size):
    n = len(arr)
    pref = [0] * (n + 1)
    for i, v in enumerate(arr):
        pref[i + 1] = pref[i] + v
    best = [float('inf')] * n
    for i in range(size - 1, n):
        best[i] = pref[i + 1] - pref[i + 1 - size]
    return best

def min_sum_three(arr, p, q, r):
    bp = min_sum_window(arr, p)
    bq = min_sum_window(arr, q)
    br = min_sum_window(arr, r)
    n = len(arr)
    pre = [float('inf')] * n
    cur = float('inf')
    for i in range(n):
        cur = min(cur, bp[i])
        pre[i] = cur
    suf = [float('inf')] * n
    cur = float('inf')
    for i in range(n - 1, -1, -1):
        cur = min(cur, br[i])
        suf[i] = cur
    ans = float('inf')
    for j in range(n):
        if bq[j] == float('inf'):
            continue
        left = pre[j - q] if j - q >= 0 else float('inf')
        right = suf[j + q] if j + q < n else float('inf')
        if left != float('inf') and right != float('inf'):
            ans = min(ans, left + bq[j] + right)
    return ans

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

Tree Max Total Distance

The same 2022 grad thread describes N cities joined by N-1 highways, a tree, and asks for the node that maximizes the sum of distances to every other city. A reroot dynamic programming pass solves it in one linear sweep.

A 2025 to 2026 variant candidates call the "driver hierarchy" problem follows the same tree shape: model drivers as nodes in a reporting hierarchy and compute a per-node aggregate across the subtree. The reroot technique above carries straight over.

def max_total_distance(n, edges):
    from collections import defaultdict
    adj = defaultdict(list)
    for u, v, w in edges:
        adj[u].append((v, w))
        adj[v].append((u, w))
    dist_sum = [0] * n
    size = [1] * n
    def dfs1(u, p, d):
        dist_sum[0] += d
        for v, w in adj[u]:
            if v != p:
                dfs1(v, u, d + w)
                size[u] += size[v]
    dfs1(0, -1, 0)
    def dfs2(u, p):
        for v, w in adj[u]:
            if v != p:
                dist_sum[v] = dist_sum[u] + w * (n - 2 * size[v])
                dfs2(v, u)
    dfs2(0, -1)
    return max(dist_sum)

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

Difficulty and Topic Mix Reported

Candidates report the mix as "easy, medium, medium, medium" or "two mediums and two hards." The recurring clusters are arrays, strings, 2-D matrix, sliding window, hash map, and graphs or trees. Dynamic programming is useful but not core, and tries or segment trees essentially never show up.

What Uber's CodeSignal Test Format Actually Looks Like

The standard uber oa in 2025 and 2026 runs four questions over about 70 minutes on the CodeSignal General Coding Assessment, proctored. That is the format you should prep for, because it is what most recent candidates actually received.

The Standard 4-Question GCA

The four-question GCA gives you Q1 and Q2 as warm-up arrays or strings problems. Q3 tends to be an implementation-heavy 2-D matrix or text problem, and Q4 is the algorithmic hash map or sliding-window finisher. Crushing Q1 and Q2 fast is what buys you room for the back half.

Variants You Might Hit

Historical tracks used 90 minutes for two questions, 60 minutes for three, and even 90 minutes for three image-based questions. A multiple-choice variant has also been reported. These are not the dominant format, so treat them as possible but unlikely.

The Take-Window, Not a Fixed Slot

You do not get a fixed exam time. The link opens and you have several days, about four, to complete the test before it expires. Plan your prep to finish inside that window instead of waiting for a set date.

How Uber's CodeSignal Scoring Works

Uber's CodeSignal OA shows two different score numbers, and mixing them up is one of the most common candidate mistakes. The chart below shows how the two displays relate and why a perfect score still is not a guaranteed pass.

The Two Score Displays

During the test you see a per-task raw total: four tasks at 300 points each, so 1200 is the max. You also receive a converted GCA Assessment Score on a 200 to 600 scale.

CodeSignal's own documentation defines the Assessment Score as a single number from 200 to 600, where a higher value means more questions were completed cleanly. The raw total is the in-test number, and the GCA score is the one recruiters quote.

Score vs Outcome

A 900 out of 1200 raw, from three clean tasks, lines up with a strong pass. A GCA of 534 is a clear pass, while 390 sits in the middle with outcome unstated.

CodeSignal only certifies and releases your score after a review confirms no unusual activity during the session. That is the same review covered in the failure section, and it is why a high raw number is not the whole story.

One recruiter cited roughly 420 as the "score to call" cutoff in their region. A perfect 600 out of 600 has still produced rejections, so the score is necessary but not sufficient.

Retake Limits and Shareable Score

A proctored GCA result can be shared to multiple companies, which is useful when you apply to several at once. Retake limits run about two attempts per 30 days and three per 180 days. Spend your attempts carefully because they do not reset quickly.

Uber CodeSignal Exam-Day Strategy

The tactics below are specific to the Uber CodeSignal format, not generic test advice. The time budget chart shows where the minutes actually go across the four questions.

The 1-2-4-3 Question Order

Solve the questions in 1, 2, 4, 3 order. Question 3 is usually the toughest implementation problem, so jump to Question 4 first and return to Question 3 with whatever time remains. This matches the difficulty curve most people report.

Per-Question Time Budget

Crush Q1 and Q2 in roughly five to ten minutes each. Give Q3, the 2-D matrix or text implementation, about 15 to 20 minutes. Give Q4, the algorithmic hash map or sliding window, 20 to 30 minutes. Speed on the first two is what protects the back half.

CodeSignal's own GCA task spec lines up with this shape: Task 1 targets about 10 minutes and 5 to 10 lines of code, scaling to Task 4 at about 25 minutes and 20 to 35 lines.

When Stuck, Brute-Force Over Blank

Write a brute-force solution or at least your reasoning in comments rather than leaving a question blank. Partial credit exists on the current GCA, so a commented approach beats a zero. One candidate who left Q4 as comments scored zero on that task, a avoidable loss.

CodeSignal saves your work when you submit a task, and it keeps your highest-scoring submission for each question. Submitting an early brute-force version is safe and never locks you out of a better later attempt, so there is no reason to sit on a blank editor.

Syntax Lookup Is The Only Allowed Help

You may open a browser tab to check syntax during the test, and nothing else. A chat assistant or any tool that writes or edits code is off-limits and detectable. Keep your help to language reference lookups only.

Why Candidates Fail the Uber CodeSignal Assessment

Most rejections do not come from a single hard question. They come from a handful of repeatable failure patterns, and the first one is the quietest.

AI-Tool Detection Voided My Result

One candidate used an Invisible App during the test and got no warning at the time. A later integrity check caught it, voided the result, and ended the application. The tool left no visible error during the session, which is exactly why the trap is so easy to walk into.

An Invisible App renders the AI's answer on the same screen the proctoring system monitors, hidden by a basic OS-layer trick. on-phone AI interview helper works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

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

The Silent Integrity Check

CodeSignal runs a post-submission integrity check called the Suspicion Score after you finish. Detection rates for proctored assessments more than doubled from 16 percent to 35 percent in 2025. A clean-looking session during the test means nothing once that review runs.

It is not theoretical. One candidate reported their submission marked "unverified" after they pasted a Swift heap class copied from their desktop into the editor; CodeSignal support refused to reverse it.

A widely upvoted r/leetcode thread documents that Interview Coder, Cluely, and Final Round AI are "100% detectable" in coding assessments. The pattern is consistent: the flag lands after you submit, not while you test.

Technical Freeze Glitches

A screen freeze in the final minutes has stalled more than one candidate. One report describes the screen locking with six to seven minutes left, leaving the score stuck at 400 out of 600. Save drafts often, use a supported browser, and contact CodeSignal support if the client misbehaves.

Perfect Score, Automatic Reject

Several candidates with a perfect 600 out of 600 still received rejection emails. Uber's OA is automated and the company is selective, so a top score opens the door without guaranteeing entry. Your resume gets reviewed alongside the result, and that review can still go against you.

How to Prepare for the Uber CodeSignal in 4 Days

Your prep window is the take-window, because the link expires in about four days. I built the plan below around that four-day limit using a confirm, drill, and simulate structure.

In the days before the test, I used the Prep Agent from InterviewFox over WhatsApp. I sent it the confirmed question patterns for Uber's CodeSignal OA and got back a personalized drill plan and strategy. It was one practical tool among several in my prep workflow, not the whole plan.

Day 1: Orient

I confirmed the format was four questions over 70 minutes on the GCA, with screen, camera, and microphone proctoring. I locked my topic list to arrays, strings, 2-D matrix, sliding window, hash map, and graphs or trees.

I skipped tries and segment trees because candidates report Uber does not ask them, and I did not over-invest in dynamic programming because it is not on the standard GCA.

Days 2-3: Drill

I ran a speed pass on graphs and trees and practiced 10 to 20 graph questions on LeetCode. I worked the NeetCode 75 and 150 sets alongside the Uber most-tagged problems, since those covered what showed up on my test. I kept light dynamic programming revision from a standard sheet, but I treated it as backup rather than core.

Day 4: Simulate + Buffer

I ran one full timed 70-minute mock with four questions at real pressure, then dropped the intensity. I reviewed my weakest patterns from the mock and touched nothing new. Walking in calm beat cramming a fresh topic at the last hour.

What Happens After You Submit the OA

Submission is not the end of the process, and a good score is not the end of the risk. Here is what follows.

The Pipeline After the OA

The path runs your application, then the CodeSignal OA, then a recruiter screen, a technical phone screen, an onsite or loop, and finally an offer. The OA is an early filter, not the whole decision. Each later stage weighs different signals.

Wait Times Vary Wildly

Some candidates hear from a recruiter about three days after the OA. Others wait weeks with no message at all. The spread is real, so silence in the first week is not itself a rejection.

Passing Isn't The Finish Line

One 2026 new grad passed the OA and then got a message that all interview slots were full. Auto-reject is also common even after a strong OA, and the recruiter review covers both resume and solution. A pass earns you a look, not a seat.

FAQ

Is the Uber CodeSignal OA proctored?

Yes. The test records your screen, webcam, and microphone, and you must stay in the camera frame. CodeSignal also runs an integrity check after you submit.

Can I use an AI tool or invisible app during the Uber CodeSignal OA?

Desktop overlay tools put the AI's answer on your computer screen: rendered as a hidden layer above the browser using a basic OS-layer trick; the answer is on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools become more common, so the risk exposure isn't fixed.

dual-device AI interview assistant pushes the answer to your phone: a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so the laptop screen stays on the exam editor, unchanged.

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

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 many questions are on the uber oa and how long is it?

The dominant format is four questions over about 70 minutes. Some older tracks used two or three questions, but four over 70 minutes is what most 2025 to 2026 candidates report.

What programming languages can I use for the uber coding assessment?

CodeSignal supports Python, Java, JavaScript, C++, and several other languages. You pick one when the test starts, and you cannot switch mid-test.

How long do I have to finish the uber oa after I get the link?

You get a take-window of about four days from when the link opens to when it expires. Plan your prep inside that window instead of waiting for a fixed slot.

Where do candidates post uber oa reddit and uber codesignal reddit writeups?

Candidates post them on r/leetcode and r/csMajors. Read them for topic patterns, not for leaked answers.

The r/leetcode consensus on the Uber CodeSignal is consistent: the four-question GCA runs easy-medium-medium-medium, a 600/600 GCA is common yet still draws rejections, and the 1-2-4-3 question order is the move most top scorers recommend. The threads are best read for topic patterns, not for leaked answers.

What happens if I fail or get rejected?

Auto-reject is common even after a strong score, and a retake is limited to two attempts per 30 days. Your resume still gets reviewed alongside the result.