Google Software Engineer Interview Experience — Phone Screens Then Three Onsite Rounds Including an AI Agent Rate Limiter

Phone Screen 1: Coding — Car Rental Optimization

Given N cars and a set of rental requests, where each request has pickupTime, returnTime, and id, you need to assign cars to these requests to maximize vehicle utilization while using as few cars as possible.

The same car can serve multiple requests as long as their times don't overlap. If one request returns the car at time 5 and another picks up a car at time 5, they can share the same car.

The problem is overall similar to meeting room scheduling — the key is how you sort the requests and reuse cars that have already freed up.

Phone Screen 2: BQ

Mainly asked these types of behavioral questions: how you handle conflict, how you work with cross-functional teams, how you deal with people who are difficult to work with, and how you move a project forward when there's disagreement.

Overall pretty standard BQ stuff — I'd recommend having a few complete project stories prepared ahead of time.

Onsite 1: Coding — Meeting Room Variant

This one is a variant of Maximum Meeting Rooms.

Not only do you need to compute the max number of meetings happening at any given time, you also need to output all the time intervals where exactly X meetings are happening concurrently.

The tricky parts to handle:

• meeting start and end events
• the ordering when a meeting starts and another ends at the same time
• how to output all the intervals where the concurrency equals X

Onsite 2: System Design — AI Agent Token Rate Limiter

Design a rate limiter to control the billing tokens consumed by an AI agent. Overall it's a variant of a standard rate limiter, using the token bucket approach.

Onsite 3: Coding — Determine Player Rankings

Given N players and M match results, you need to determine which players' rankings can be definitively determined.

If A beats B and B beats C, then you can infer A beats C.

For a given player, if you can determine the win/loss relationship between them and every other player, then their ranking is determined.

This is fundamentally a graph problem: players are nodes, win/loss relationships are directed edges, and you need to compute the transitive relationships to check whether each player has a determined relationship with every other player.

You can use Floyd-Warshall, or do a DFS/BFS for each player individually.