Google 2026 New Grad OA Complete Guide | SWE Early Career US — Three Real Question Categories

The Software Engineer, Early Career (United States) role is one of the most watched 2026 cycle openings at Google. The position targets seniors and ≤1-year-graduated candidates — and uniquely, you can enter the OA pool without a referral (applications are queued by timestamp). But surviving from 35,000+ resumes means the OA round decides ~70% of your fate.

This article distills 1point3acres, Reddit, and Glassdoor data from April-May 2026 to pin down the platform, scoring logic, and question types — with three real questions reconstructed from candidate debriefs and full Python solutions.

Google New Grad OA Overview

Dimension	Detail
Platform	Hackerrank (switched from ChromeOS Codejam in 2023)
Duration	90 minutes
Questions	2 (some batches report 3)
Difficulty	1 LC Medium + 1 LC Medium-Hard
Cutoff	Empirical: pass both, with at least one at 100% hidden tests
Turnaround	7-21 days
Next round	Onsite Loop (4× coding + 1× Googleyness)

2026 change: Google added a 10-minute "Behavior Insight" survey at OA stage — 30 Likert-scale items for early culture-fit screening. Not scored, but visible contradictions with your resume will trigger manual review.

Question 1: Set Difference Group

Problem

Given an array words of strings (length n) and integer k, group strings by "identical character set" (e.g., "aabbc" and "abc" share the group):

Find the group(s) of exactly size k
Among them, return the lexicographically smallest representative string (taking the min from each group)
If no group of size k exists, return ""

Approach

Classic hashmap-by-charset. Two subtle traps:

Character set must be sorted and de-duplicated: "".join(sorted(set(w)))
Within a group pick the lexicographically smallest original string — not the sorted charset

Python Solution

from collections import defaultdict

def find_set_diff_group(words, k):
    groups = defaultdict(list)
    for w in words:
        key = "".join(sorted(set(w)))
        groups[key].append(w)
    candidates = []
    for key, members in groups.items():
        if len(members) == k:
            candidates.append(min(members))
    return min(candidates) if candidates else ""

Time: O(n · L log L) Space: O(n · L)

Question 2: Currency Conversion Best Rate

Problem

Given rate list [(from, to, rate)] (bi-directional rates may differ; multiple pairs allowed), source src, target dst, and integer m.

Allowing at most m intermediate conversions, how much dst can you obtain from 1 unit src? Return -1 if unreachable.

Approach

Similar to LC 399 Evaluate Division plus an "at most m hops" constraint and "maximize product."

State: (currency, hops)
Edge weight: rate (multiplicative)
Algorithm: since we maximize a product (not a sum), use Dijkstra variant — either -log(rate) for shortest path or maintain raw values with a max-heap.

Python Solution

import heapq
from collections import defaultdict

def best_conversion(rates, src, dst, m):
    g = defaultdict(list)
    for a, b, r in rates:
        g[a].append((b, r))
    best = {(src, 0): 1.0}
    pq = [(-1.0, src, 0)]
    ans = 0.0
    while pq:
        neg_amt, u, hops = heapq.heappop(pq)
        amt = -neg_amt
        if amt < best.get((u, hops), 0):
            continue
        if u == dst:
            ans = max(ans, amt)
            continue
        if hops == m:
            continue
        for v, rate in g[u]:
            new_amt = amt * rate
            if new_amt > best.get((v, hops + 1), 0):
                best[(v, hops + 1)] = new_amt
                heapq.heappush(pq, (-new_amt, v, hops + 1))
    return ans if ans > 0 else -1

Time: O(E · m · log(V·m)) Pitfall: math.log + shortest-path has floating-point error in Python — 1-2 hidden tests will misalign. Keep raw values + max-heap.

Question 3: Tree Diameter with Edge Cost

Problem

Given an n-node undirected tree with positive edge weights and per-node node_cost, define a path's "effective cost" as:

sum(edge weights on path) + max(node_cost over path nodes)

Return the maximum effective cost.

Approach

Variant of classic tree diameter. Standard "two BFS" doesn't apply once you add the "max node cost" term — you need DFS maintaining two best subtree branches:

For each node u, DFS returns "longest path going into the subtree" carrying (sum_edges, max_node_cost_on_path)
At u, combine top-2 child branches: e1 + e2 + max(mx1, mx2, node_cost[u])

Python Solution

from collections import defaultdict

def tree_max_effective_cost(n, edges, node_cost):
    g = defaultdict(list)
    for u, v, w in edges:
        g[u].append((v, w))
        g[v].append((u, w))
    ans = [max(node_cost)]

    def dfs(u, parent):
        best = [(0, node_cost[u])]
        for v, w in g[u]:
            if v == parent:
                continue
            child_options = dfs(v, u)
            for e_sum, mx in child_options:
                best.append((e_sum + w, max(mx, node_cost[u])))
        best.sort(key=lambda x: x[0], reverse=True)
        if len(best) >= 2:
            e1, mx1 = best[0]
            e2, mx2 = best[1]
            ans[0] = max(ans[0], e1 + e2 + max(mx1, mx2))
        return best[:2]

    dfs(0, -1)
    return ans[0]

Time: O(n) Trap: ensure the two paths come from different subtrees. Collect all children's returns first, then merge — don't update the answer mid-traversal.

Prep Roadmap

Priority	Focus	Recommended LeetCode
⭐⭐⭐	Graph BFS/DFS/Dijkstra	LC 399, 787, 743, 1631
⭐⭐⭐	Tree DP / Diameter	LC 543, 124, 968, 1372
⭐⭐	Strings / Charsets	LC 49, 438, 76
⭐⭐	Composite Data Structures	LC 146, 460, 1146
⭐	Implementation	LC 271, 535

Time allocation: 90 min = easy question 30 min + hard question 50 min + review 10 min. Don't read all questions first — Hackerrank's IDE has 30-sec latency penalty, costing you time.

FAQ

Q1: Is New Grad OA the same as Intern OA?

Same format, but New Grad runs 0.5-1 difficulty tier higher. Intern is mostly 2× LC Medium in 90 min; New Grad's second question is often LC Medium-Hard or easy Hard. Cutoff is stricter too: Intern can pass with 1 full + 1 partial, New Grad needs both fully passed.

Q2: Can I get OA without a referral?

Yes. Google 2026 Early Career queues by submission timestamp — referrals speed you up, but don't auto-place in the OA pool. Apply early: per 1point3acres April 2026 data, first 2 weeks after roles open had ~30% OA placement; by late September it fell to ~10%.

Q3: How long from OA pass to onsite?

Historically 2-4 weeks to recruiter call; 6-10 weeks to finish all 5 onsite rounds. 2026 cycle is generally delayed: candidates passing OA in April are scheduling onsites in May-June.

Q4: How is Hackerrank different from CodeSignal?

Hackerrank's IDE is plain — no code completion, 5-10 sec compile delay. Two adaptations:

Write in local VS Code, then paste
Minimize print debug calls

Q5: Which language is safest?

Python remains first choice. Java / C++ are internally preferred at Google, but no OA bonus — pure hidden-test pass rate. Go / Rust: be careful, some Hackerrank helpers are incomplete.

Q6: What does Google New Grad Onsite look like?

After OA pass:

Recruiter Call (30 min): background + scheduling
Onsite × 5: 4× coding + 1× Googleyness
Hiring Committee (HC): committee doesn't meet you, scores based on rubrics
Team Match (2-6 weeks): only after HC approval
Offer Letter (2025-2026 cycle L3 SWE base ~$148K + sign-on)

End-to-end 3-5 months from OA to offer.

Preparing for Google New Grad / Intern OA?

The OA looks "manageable" but the bar is high and hidden tests are strict — pure LeetCode grinding hits limits. We've curated a 20+ question bank for the 2025-2026 Google New Grad cycle (with variants), organized into Graph / Tree / String / Design tracks.

Add WeChat Coding0201 or contact us.

Contact

Email: [email protected] Telegram: @OAVOProxy