Google Software Engineer Interview Experience — Four Interviews Across Months and Unfinished Team Matching

I applied to Google quite a while ago, probably in March, and got an interview in May. The process dragged on for a long time. I kept practicing problems, and fortunately I eventually passed, but unfortunately team matching didn't work out. I've now gone to NVIDIA.
The first round was online in May.
It was a coding question, roughly like this (I asked AI to summarize it):
Connected Crop Arrangement
You are given a garden represented by an
N x M
grid.
There are
K
different kinds of crops, labeled from
1
to
K
. For each crop
i
, you are given
count[i]
, representing exactly how many cells must contain that crop.
It is guaranteed that:
sum(count) = N * M
so every cell in the garden must be used.
For every crop type, all cells containing that crop must form
one connected component
. Two cells are considered connected if they share an edge, meaning you may move only:
up, down, left, right
Diagonal movement does not count.
Return
any valid arrangement
of the crops satisfying all requirements.
Requirements
Every grid cell contains exactly one crop.
Crop
i
appears exactly
count[i]
times.
All cells belonging to the same crop must be connected through horizontal or vertical moves.
Different crops do not need to have any particular relationship with each other.
Any valid arrangement is accepted.
Follow-up: Two Square Gardens
Instead of one
N x M
rectangular garden, there are now
two square gardens
:
Garden A: N x N
Garden B: M x M
The two gardens are placed directly next to each other and together form the available planting area.
The crop counts now satisfy:
sum(count) = N? + M?
The same connectivity requirement applies:
all cells containing the same crop must form one connected region using only horizontal and vertical adjacency.
Return any valid crop arrangement across the two gardens.
For example, when
N = 2
and
M = 3
, the garden shape could be represented as:
1|1|2|2|2
1|1|2|2|2
2|2|2
or:
1|1
1|1
2|2|2
2|2|2
2|2|2
The goal is still to place every crop the required number of times while keeping each crop connected.
The second round was scheduled for June. It was behavioral, not difficult overall, and online.
The third and fourth rounds were scheduled for August (there was one reschedule in between). They were onsite, writing code face to face, onsite.
Problem 3 was roughly like this (the original question is on the forum):
12. Longest Non-Decreasing Subarray With One Replacement
Tags:
Array, Dynamic Programming, Two Pointers
Difficulty:
Medium
Given an integer array
nums
, find the maximum length of a
contiguous non-decreasing subarray
if you may change
at most one element
to any value.
A subarray is non-decreasing if:
nums[i] <= nums[i + 1]
for every adjacent pair inside the subarray.
Return the maximum possible length.
Example
Input:
nums = [1, 0, 3, 4, 5, 2, 3]
Output:
5
Explanation:
Change
nums[1]
from
0
to
1
.
The array becomes:
[1, 1, 3, 4, 5, 2, 3]
Then:
[1, 1, 3, 4, 5]
is a non-decreasing contiguous subarray of length
5
.
Therefore, the answer is
5
.
Problem 4 was a question similar to topological sorting.
I almost didn't finish problem 4. Fortunately, the interviewer was very nice.
You're given two arrays and asked to merge them, but their relative positions determine their relative ordering. I asked GPT to find interview reports for me and found the original question.
Merge Two Ordered Sequences
Tags:
Graph, Topological Sort, Cycle Detection
Difficulty:
Medium
You are given two integer arrays
a
and
b
.
The order of elements in each array represents ordering constraints.
For example, if:
a = [1, 3, 5]
then
1
must appear before
3
, and
3
must appear before
5
.
Determine whether the two arrays can be merged into one sequence while preserving the relative order of elements in both arrays.
If the ordering constraints conflict with each other, return
false
.
Otherwise, return
true
(or any valid merged sequence).
Example 1
Input:
a = [1, 2, 3]
b = [2, 4, 5]
Output:
true
One valid merged order is:
[1, 2, 3, 4, 5]
Example 2
Input:
a = [1, 6, 4]
b = [4, 1]
Output:
false
The first array requires:
1 -> 6 -> 4
while the second array requires:
4 -> 1
These constraints create a contradiction, so no valid merged order exists.
Summary
The four interviews spanned several months. During that time, I worked through basically all the original questions from interview reports. Practicing more of those questions is quite useful. After the interviews, I was told I'd passed, but the team-matching process still hasn't finished. I guess I won't find a match at L3.
I also had offers from Microsoft and NVIDIA. I probably ended up going to NVIDIA.