Google · Phone screen → Onsite
In processGoogle SWE Intern Interviews: 85 Experiences (Part 1 of 8)
Google Summer 2027 SWE intern reports, late Sep 2026: two 45-minute coding rounds on graphs, intervals and heaps, where the follow-ups decided the result.
At a glance
- Process: two back-to-back 45-minute coding rounds (phone screen or virtual onsite), with no separate behavioral part (01, 06, 07). Strong rounds led to team matching (01).
- Asked recently: graph or tree search in 3 of 8 reports (02, 06, 09), intervals or heaps in 2 (04, 06), DP or prefix sums in 2 (03, 07), and object-oriented or concurrent design in 2 (06, 08).
- Difficulty: the first solution was usually reachable; follow-ups on negative weights, streams, memory or thread safety were where candidates ran out of time (01, 02, 06, 09). One candidate was rejected after struggling with an unfamiliar difference-array question (07).
- Practise first: Minimum Direction Violations, Minimum Cars for Rental Requests, High-Traffic IPs in a Sliding Window and Shortest Hop Path Between Machines.
Coverage: Google Summer 2027 SWE / SDE intern phone screens and virtual onsites, U.S. where stated. Eight candidate reports posted September 29 to October 2, 2026, plus one October coaching recap kept apart from the counts.
In this series
- Part 1 (current): graphs, intervals and OOD from the first wave of 2027 intern loops.
- Part 2: paths, grids and trees.
- Part 3: prefix sums and heaps.
- Part 4: full loops and team matching.
- Part 5: grids, DP, OOP and AI.
- Part 6: trees and knapsack.
- Part 7: PhD and return offers.
- Part 8: updates and host calls.
What came up
The first answer was rarely the problem. Most of these candidates got a clean base solution, then met a follow-up that changed the constraints: negative edges, a stream, limited memory or threads.
| Topic | Reports | Last seen |
|---|---|---|
| Graph or tree search (BFS, 0-1 BFS, codecs) | 3 of 8 | Sep 2026 (report date) |
| Intervals and heaps | 2 of 8 | Sep 2026 (report date) |
| Prefix sums or difference arrays | 1 of 8 | Sep 2026 (report date) |
| Dynamic programming (memoized search) | 1 of 8 | Sep 2026 (report date) |
| Two pointers | 1 of 8 | Sep 2026 (report date) |
| Sliding window over logs | 1 of 8 | Sep 2026 (report date) |
| Object-oriented or concurrent design | 2 of 8 | Sep 2026 (report date) |
A candidate can appear in more than one row; 01 did not disclose topics.
Questions we found
Algorithms / Data Structures
| Question | Reports | Last seen |
|---|---|---|
| Minimum Direction Violations | 1 | Sep 2026 (report date) |
| Count Triplets With Sum at Most Target | 1 | Sep 2026 (report date) |
| Word Break | 1 | Sep 2026 (report date) |
| Target Interval Conflict | 1 | Sep 2026 (report date) |
| Minimum Cars for Rental Requests | 1 | Sep 2026 (report date) |
| K Closest Stars from a Data Stream | 1 | Sep 2026 (report date) |
| N-Ary Tree BFS Serialization and Deserialization | 1 | Sep 2026 (report date) |
| 2D prefix-sum problem (details not shared) | 1 | Sep 2026 (report date) |
| Zero Array Transformation I (LeetCode 3355) | 1 | Sep 2026 (report date) |
| High-Traffic IPs in a Sliding Window | 1 | Sep 2026 (report date) |
| Shortest Hop Path Between Machines | 1 | Sep 2026 (report date) |
Low-Level Design (LLD/OOD)
| Question | Reports | Last seen |
|---|---|---|
| Concurrent Priority Task Scheduler with Timeout Cancellation | 1 | Sep 2026 (report date) |
8 detailed candidate timelines, loops, and screens
01: An optimal first round, then a rule mismatch
Report date: Oct 2, 2026 · Role: Summer 2027 SWE Intern · Location: United States · Status: Team matching
Round 1
- About 25 minutes to clarify, explain the approach and complexity, code and dry-run. The interviewer confirmed it was optimal.
- Two follow-ups: the brute-force complexity, and an extension they discussed with its edge cases without coding it.
Round 2
- The interviewer broke their first approach with a counterexample. They switched quickly to a linear-time idea that was approved before coding.
- In the dry run, the two of them expected different outputs because they read one rule differently.
- About 35 minutes in came a harder generalization. They named the technique and wrote the full algorithm and complexity, but time ran out before one concern was settled.
Format
- No separate behavioral section beyond a short intro and closing questions; communication and Googleyness were judged through the problem solving.
- A later edit confirmed team matching. Neither prompt was disclosed.
02: 0-1 BFS, then negative edges
Report date: Sep 30, 2026 · Role: Software Engineer Intern · Stage: Virtual onsite · Result: Strong hire (per the post title)
Round 1
- Minimum Direction Violations: a directed graph where any edge can be used either way; going with the arrow costs 0, against it costs 1. Find the cheapest route from
starttoend. - The expected answer was 0-1 BFS: zero-cost moves go to the front of a deque, one-cost moves to the back, for
O(V + E). - Follow-up: negative edge weights, where 0-1 BFS stops working, so Bellman-Ford. Then multiple sources and destinations, handled with a super-source and super-sink.
Round 2
- Count Triplets With Sum at Most Target: count index triplets whose sum is at most a target.
- Sort, fix the first value, and run two pointers on the rest; when a sum is small enough, count a whole range of partners at once.
O(n²)overall.
03: Word Break without repeated work
Report date: Sep 30, 2026 · Role: Software Engineer Intern · Stage: Virtual onsite
- Word Break: can string
sbe split entirely into dictionary words? - The approach:
dfs(i)for the suffix starting ati, trying each next word. Put the dictionary in a set and memoizedfs(i), since different splits reach the same suffix.O(n²)time,O(n)extra space.
04: Interval conflicts and rental-car reuse
Report date: Sep 30, 2026 · Stage: Phone screen
Question 1
- Target Interval Conflict: does any interval in a list conflict with one target interval?
- Intervals are half-open,
[start, end): two do not overlap whena.end <= b.startorb.end <= a.start. One query needs only a linear scan; sorting helps for many queries or for listing every conflict.
Question 2
- Minimum Cars for Rental Requests: requests have an order ID, pickup and return time. Assign them to cars with no overlaps on a car, and return each car's list.
- Sort by pickup and keep cars in a min-heap by next free time; reuse the top car when possible, else add one.
- With only K cars, report failure or the unassigned request when all are busy, never overwrite. Edge cases named: touching endpoints, equal start and end, unsorted input and
K = 0.
06: Top K, a concurrent scheduler and an N-ary tree codec
Report date: Sep 30, 2026 · Role: SDE Intern · Stage: Virtual onsite, two rounds of about 45 minutes
Round 1
- K Closest Stars from a Data Stream: from a huge stream of
(star_id, distance)pairs, return the K smallest distances. - Sorting costs
O(N log N); a size-K max-heap getsO(N log K). The interviewer asked aboutK = 0,K > Nand equal distances.
Round 2
- Concurrent Priority Task Scheduler with Timeout Cancellation: priorities, timeout cancellation and thread safety, using a priority queue and a
ReentrantLock. - N-Ary Tree BFS Serialization and Deserialization: encode and decode an N-ary tree level by level, with null markers and level boundaries.
- The hard part was finishing the concurrency rules and the encoding under time pressure, not picking the data structure.
08: Every follow-up first, implementation-heavy OOD second
Report date: Sep 30, 2026 · Role: SWE Intern · Location: United States · Status: Awaiting outcome
Round 1
- They needed a little guidance and a one-line fix, then finished the task, every follow-up and the optimal solution.
Round 2
- The interviewer nudged them toward the right data structure for an implementation-heavy, object-oriented problem. They finished about 70–80% of the code; the design was sound but some helpers had bugs.
- Near the end the interviewer had them skip the helpers and write one key function, then asked for time and space complexity.
- The object model was not disclosed, so no problem is linked here.
07: 2D prefix sums, then an unfamiliar difference array
Report date: Sep 29, 2026 · Role: Summer 2027 SWE Intern · Stage: Two back-to-back coding rounds · Result: Rejected
- Round 1: a 2D prefix-sum problem; no operation, inputs or follow-ups were shared.
- Round 2: a difference-array question they matched to Zero Array Transformation I (LeetCode 3355): each query covers an inclusive range, and you may subtract one from any covered position; can everything reach zero? Count coverage per index with a difference array and one prefix scan, then check coverage is at least each value.
- They had not practiced difference arrays, struggled, and eventually wrote an answer. Both rounds were algorithms; no behavioral.
- The decision came four business days later: a rejection with no feedback, mentioning other openings and future applications.
09: A request window and a shortest path through machines
Report date: Sep 29, 2026 · Role: SDE Intern · Stage: Virtual onsite
Round 1
- High-Traffic IPs in a Sliding Window: logs arrive in time order; find every IP with more than 100 requests in any ten-minute window.
- Brute force first, then a sliding window with a hash map for one linear pass. Follow-ups: very large data, streaming input, less memory and missed boundary cases.
Round 2
- Shortest Hop Path Between Machines: fewest hops from machine A to B, printing the path.
- BFS for the distance, a parent map for the path. Follow-ups: huge graphs, cycles, full path recovery and less extra space.
Supplementary: an October coaching recap
This recap of two rounds on October 12, 2026 came from someone describing coaching experience, not a candidate's own interview. It is kept for its questions but left out of every count and table above.
Recap 01: Window averages, then a strict dominant maximum
Rounds dated: Oct 12, 2026 · Posted: Oct 14, 2026 · Role discussed: Google SWE Intern
- Round 1: keep the average of the latest K integers. Follow-up: drop the x smallest and x largest values in the window before averaging, tracked with a frequency TreeMap (Sliding Window Average After Trimming Both Ends).
- Round 2: return the maximum's original index only if it is strictly more than twice the second largest, else -1, in one scan with three variables. Follow-up: take the largest M+1 values, sorted ascending, and require each to be more than twice the one before (Dominant Index with Strict Doubling Gaps).
- Both were described as medium variations with changed wording, with an emphasis on explaining complexity. No behavioral questions.
Patterns across the reports
- Follow-ups change the constraints. Negative edges and multiple sources (02), stream and memory limits (06, 09), thread safety (06) and harder generalizations (01).
- Two coding rounds, no behavioral block. Three candidates said both rounds were pure coding (01, 06, 07).
- Edge cases are asked early.
K = 0and equal values (04, 06), touching intervals (04) and missed window boundaries (09).
Common questions
How many rounds is the Google SWE intern interview?
Two coding rounds of about 45 minutes, often back to back (06, 07). Strong candidates then moved to team matching (01).
Does the Google intern interview have behavioral questions?
Not as a separate section in these reports (01, 07); communication and Googleyness were judged during the coding (01).
What kinds of questions does Google ask 2027 interns?
Graph search with a twist (02, 09), intervals and heaps (04, 06), memoized DP (03), prefix sums or difference arrays (07) and an object-oriented build (08).
How long does the Google intern decision take?
One candidate heard four business days after the onsite (07).
What to practise
- Minimum Direction Violations and Shortest Hop Path Between Machines: BFS variants with follow-ups, the most common topic here (02, 09).
- Minimum Cars for Rental Requests and K Closest Stars from a Data Stream: heap problems with edge-case questions (04, 06).
Keep practicing
- Google problem bank: every Google coding question on FastPrep (sign-in needed).
- Google LLD bank: Google object-oriented design questions (sign-in needed).
- Google SWE intern extra interviews: two extra-round timelines that go with this series.
- Google interview page and Google hiring insights: rounds, recent questions and hiring trends.
- Experience feed: the latest interview write-ups.
In this series
Sources: Anywhere useful interview info can be found.
Comments
0No comments yet — be the first to share what you know.