Google Interviews

I recently participated in the Google Online Assessment and a subsequent Phonescreen round for a Software Engineer L4 position. The OA presented two challenging algorithmic problems: one involving dynamic programming with modular arithmetic and the other a tree-based problem requiring subtree sum calculations. The Phonescreen round then focused on an interesting design problem related to playlist shuffling to minimize adjacent artists. I was able to approach all problems and provide solutions.

Started with an HR call that covered basic time and space complexity questions. The telephonic screening began with a sliding window problem involving fountains and safe places. I explained a brute force solution and then moved to an optimized approach using a monotonic stack and next greater element concepts. However, I couldn't fully fix the bug in the optimized solution.

The interview structure included 2 technical rounds and 1 Googliness round. The first technical round went well with a problem similar to Merge Intervals, solved in 15–30 minutes, and a follow-up question about finding Maximum among Minimums using a Deque in Java. The interviewer was satisfied but noted we didn't have time to code the solution.

The second technical round was challenging. The problem involved determining if a server times out based on RPC logs with timestamps. I implemented an optimal solution using a HashMap to track start events and check timeouts. However, the interviewer wanted a different approach involving a LinkedHashMap to manage insertion order and timeouts efficiently. I could only explain my idea in pseudocode, which led to a poor performance in this round.

The Googliness round went well, similar to Amazon's behavioral rounds. The outcome was uncertain, with feedback indicating an incorrect data structure choice in one of the technical rounds, possibly leading to rejection or additional rounds.

I was asked to solve a problem where I had to navigate a grid with zombies, walls, and open paths. The main challenge was to find the shortest path to the gate while staying as far away from zombies as possible. The problem required a custom approach to prioritize safety while maintaining path efficiency.

I applied for a software engineering role through Google’s career portal. After two weeks, I received a call from the recruitment team. We had a brief 15–20 minute discussion covering my background, soft skills, projects, current role, and salary expectations to assess my basic fit for the position. Following this, I filled out a candidate form. The next day, they explained the complete interview process and shared preparation resources for Data Structures and Algorithms (DSA). As a working professional focused on development, I requested two weeks to refresh my DSA fundamentals, which was approved. After 1.5 weeks, they checked on my progress and scheduled my Preliminary Phone Screen.

📞 Preliminary Phone Screen (45 mins)

The interview was conducted on Google Meet and lasted 45 minutes. The question type was Medium–Hard, specifically involving Trees. The process was structured:

• 5 mins: Understanding the problem
• 15 mins: Discussing the approach and edge cases
• 20 mins: Coding on the whiteboard
• 5 mins: Complexity analysis and wrap-up

I successfully handled all edge cases and optimized my code. The interviewer seemed happy and provided positive feedback, leading to my shortlisting for the Onsite (Online) rounds.

💻 Onsite Interviews (3 DSA Rounds in One Day)

Round 1 — DSA (Google Germany)

This round focused on Directory structure creation (Design + Edge cases) and was rated Medium difficulty. I provided an optimized solution quickly, clearly explaining my choice of data structures and handling follow-ups effectively. I confidently discussed time and space complexities. Although I couldn’t complete a follow-up question due to time constraints, I explained my approach clearly. This round went very well, and the interviewer was satisfied.

Round 2 — DSA (Google India)

This was a complex and tricky Graph Problem, rated Hard. The round started with a discussion about my projects. It took me 10–12 minutes to fully understand the question. Initially, I proposed a suboptimal approach, but after discussion, I found the optimal solution. Unfortunately, time ran out before I could complete the full implementation. The interviewer seemed unsatisfied with the outcome of this round.

Round 3 — DSA (Google California)

This round presented a Hard problem involving Strings. I discussed my approach thoroughly, identified failure cases, and refined my logic. I managed to write complete working code with 10 minutes remaining and confidently answered most follow-up questions. The interviewer was happy with my overall solution.

📬 Final Result

Two weeks after the onsite interviews, I was informed that I did not make it to the next stage. I believe the second interview was the deciding factor in my rejection.

💡 Reflection

Despite the rejection, the entire process was an incredible learning experience. I gained insights into Google’s structured and professional interview process, the critical importance of clear communication and handling edge cases, and the ongoing need to stay consistent with DSA, even while working in development-heavy roles. I am grateful for the opportunity and am looking forward to preparing better for my next attempt.

I recently interviewed for a Software Engineer L3 position at Google Europe. I have 1 year of experience and graduated from IIIT in 2024, with a LeetCode rating of 2500+.

Phone Screen

The problem presented was to count ordered pairs (i, j) in an array arr such that a[i] - a[j] = i - j, with 0 ≤ i, j < n. Important notes included that (i, j) and (j, i) are different, and (i, i) is also a valid pair. Examples were provided to clarify the problem. The verdict for this round was 'Position', though the recruiter didn't share exact feedback.

Onsite Round 1

In this round, I was given a directed graph where each edge has a security level. The task was to find a path from a startNode to an endNode such that the maximum edge security level in that path is minimized. I received a 'Strong hire' verdict for this round.

Onsite Round 2

The problem here involved splitting a given data size into the minimum number of packets, with each packet having a maximum capacity. If multiple solutions had the same minimum number of packets, I had to choose the one where the maximum packet size among all packets was minimized. This round also resulted in a 'Strong hire' verdict.

Onsite Round 3

This round presented a problem with a list of events, sorted by timestamp, each having a unique ID and timestamp, along with a timeout value. I needed to determine if there was any event where end_time - start_time > timeout. Follow-up questions included implementing an O(1) space solution and handling scenarios where events were stored in single or multiple files. I received a 'Strong hire' for this round as well.

Onsite Round 4 (Googlyness)

This round consisted of behavioral questions. All the questions asked were sourced from a frequently asked Googlyness questions post on LeetCode. I received a 'Strong hire' for this round.

Overall, my feedback across all rounds was very strong. My recruiter even considered me for an L4 position, but one interviewer felt I wasn’t the right fit for that level, so I am proceeding with L3. It was a great experience, and I am currently in the team matching phase.

The interviewer started off very chill — after a bit of small talk, he jumped straight into the questions. The first one was a classic high-frequency problem: Subarray Sum Equals K. Given an integer array, find the number of continuous subarrays whose sum equals K. The moment you hear this question, you know they’re not testing algorithms per se — they’re checking whether you can start with a brute-force solution and progressively optimize it. The student first mentioned the brute-force approach with O(n²) complexity. The interviewer smiled, nodded, and then asked: "if I asked you to optimize it to O(n), how would you think about it?" At that moment, our voice-assist system hinted: "Explain the prefix-sum + hashmap idea, don’t rush into coding yet." So the student naturally followed up with: "I’d use a hash map to record how many times each prefix sum has appeared. While iterating, I check whether prefixSum – K exists — that tells me how than subarrays ending at the current index sum to K." He then explained and wrote the solution step by step, even adding the important detail of initializing the map with {0: 1} to correctly handle cases where the subarray from index 0 already equals K. The interviewer immediately responded: "Good, that’s the reasoning I’m looking for."

I recently had my first onsite interview round for the Software Engineer, Site Reliability Engineer (SRE) role at Google. The interview focused heavily on file system operations and design. I was initially asked to implement several core file system utility functions, which served as building blocks for a more complex problem. The primary challenge involved efficiently deleting a directory tree.

I was reached out to by an HR on LinkedIn for an L4 Software Engineer opportunity in Poland and scheduled an initial call.

1. Initial HR Call (30 mins)

2. Screening Round (45 mins)

3. Round One - DSA (45 mins)

initialize(vector<pair<string, int>> slotsPerType, vector<pair<string, int>> costPerMinPerType);
bool onEnter(string plateNumber);
int onExit(string plateNumber); // returns calculated cost & -1 otherwise

4. Round Two - DSA (45 mins)

5. Round Three - Googleyness (45 mins)

Verdict

I had my Google L3 Technical Phone Screening yesterday, and I wanted to share my experience with the community. The interviewer presented a rather intriguing and somewhat abstract problem. It involved a sequence of Pi digits and their 1-indexed positions. The core task was to find indices where the digits of the index itself matched the Pi digits at those positions. For instance, if the index was 13, I had to verify if Pi[13] was 3 and Pi[12] was 1. This required a careful parsing strategy.

Initially, the interviewer only provided the Pi sequence up to index 9, which made it tricky to consider edge cases involving two-digit indices (like 10, 11, etc.) properly. They eventually provided a hint about the range, but I found that aspect of mapping index digits to Pi digits a bit confusing at first.

For the implementation, I was given the freedom to choose the input parameter's data type, and I opted for a String. I thought this would simplify working with individual characters and their conversion to integers. However, I did make a mistake early on by trying something like pi[i].toInt() directly. I haven't received any feedback on the interview yet, but I'm eager to see the outcome and will update this post once I do.

I participated in the Google Apprenticeship SAD interview process, which commenced with a Google Online Challenge (GOC). During the GOC, I faced two data structures and algorithms questions. The first was an easy-level LeetCode problem, though with tricky framing: I had to pair lengths and breadths from two given arrays to form rectangles, with the goal of maximizing (or minimizing, I don't recall exactly) the total sum of the squares of the diameters of all the circumcircles around these rectangles. The second question was a medium-level dynamic programming problem: given a binary array, I needed to count the number of subarrays of a specified length 'x' that contained contiguous 1's. I successfully solved both questions within 25-30 minutes.

Following the GOC, I received a phone call from a Google recruiter. Although I initially couldn't chat as I was out, I later scheduled a formal meeting. Interestingly, the person who contacted me initially was different from my eventual interviewer. During the phone interview, I was first asked to introduce myself. Subsequently, I was informed that I was not eligible for the role because it's designed for individuals who already hold a degree and are looking for a career shift, rather than for those currently pursuing undergraduate studies or still in college. The interviewers were very polite and clearly explained the eligibility criteria for the role. Overall, it was an interesting experience.

I was contacted directly by a Google recruiter for the New Grad 2026 role and received an interview invite about two weeks later. Two rounds were initially scheduled for the same day, though one was rescheduled at the last moment.

Round 1 (60 minutes — 45 min DSA + 15 min Googlyness)

My interviewer joined around 25 minutes late, adding stress as I had another interview with a tight 20-minute gap. The problem itself was straightforward, and I was able to solve and code it. However, the overall interaction was uncomfortable. While I was coding and explaining my thought process, the interviewer abruptly told me to stop speaking and just write the code. After I completed my solution, she spent around 5–7 minutes checking it line-by-line against what seemed like an internal reference. The tone throughout our conversation felt irritated and dismissive, which made the experience quite difficult despite my maintaining professionalism.

Round 2 (45 minutes — DSA Only)

This round went significantly better. My interviewer was someone I recognized from Instagram/LinkedIn (a known tech influencer), and the interaction was smooth and positive. I clearly discussed my approach, covering edge cases, and walked through a dry run for the problem and its follow-up. My interviewer seemed genuinely satisfied with my solution and thought process.

Result

After about 1.5 months, my recruiter informed me that I was not selected. I had anticipated this result due to how the first round went, but it still stings when you’ve put in the effort. It was a learning experience regardless. You can prepare endlessly, but sometimes you simply cannot control the interviewer’s attitude or the environment you’re put into. Best of luck to everyone preparing. 🙏

Phone Screening

Solution

Verdict: Cleared

DSA Round

Solution

AI/ML Round

Solution

GnL Round

Current Status

I recently completed two rounds for Google's Software Development Apprenticeship program 2026. After the recruiter reached out in early November, a 15-minute call explained that the process would involve two rounds: one on Data Structures & Algorithms (DSA) and another on 'Googlyness' questions.

In the first round, the interviewer presented a simplified version of the Cheapest Flights Within K Stops LeetCode question. The key difference was that my graph had no weights, and I simply needed to determine if the destination was reachable from the source. I came up with a DFS approach and implemented it. The interviewer seemed satisfied but then asked why I didn't opt for BFS. I explained that both solutions have the same worst-case time complexity, and DFS was my initial thought, though in hindsight, BFS would have been a more intuitive choice for reachability in an unweighted graph.

The second round, which happened today, featured a famous question detailed in this blog post. Fortunately, I had encountered this problem during my preparation, so I instantly knew the intended solution and its follow-up. I still took about 5-10 minutes to think and then explained my approach, which the recruiter seemed happy with. After implementing the solution, I explained that the average time complexity would be O(log M) and the worst-case O(M). The recruiter then pointed out that I was missing a crucial detail from the problem statement – it was a 'sparse bit array', meaning the number of 1s would never be the size of the array, a detail I hadn't initially considered.

Overall, I believe both interviews went well, and I'm now just waiting for the final result.

I recently had a phone screen for a SWE SRE position at Google in Dublin. The interview lasted about 1 hour and 5 minutes and involved a series of algorithmic challenges. I started with a simple prime number problem, which then evolved into designing an algorithm for what they called 'supercut' prime numbers. I was asked to optimize my solution further. Following this, I was tasked with implementing the Sieve of Eratosthenes algorithm and then optimizing that solution as well. There were more than 5 follow-up questions throughout the discussion.

During my interview at Google, I was presented with a problem that simulated a filesystem using a Python dictionary. Each node could be a file with a size or a directory containing children. My primary task was to implement a function, get_size(), to determine the total size for any given key in the filesystem. Following this, we explored various approaches to optimize the size calculation, particularly focusing on caching techniques. The discussion also extended to the fundamental properties and invariants expected in a robust filesystem, such as the absence of cycles, ensuring every file belongs to a directory, and maintaining unique children per directory.

My interview process for the L4 role at Google in India took place in August 2025. It started with a screening round, followed by several onsite rounds, including coding, system design, and a 'Googlyness' interview.

Screening Round

In the screening round, I was presented with two coding problems:

1. The first problem was Remove All Adjacent Duplicates In String. I implemented a single-pass solution using a vector, which seemed to work well, and I successfully dry ran my approach.
2. The second problem was Russian Doll Envelopes. I solved this using the Longest Increasing Subsequence (LIS) algorithm combined with a binary search approach, and also performed a dry run.

Based on the feedback I received, my performance in this round was perceived as 'Strong Hire' (SH).

Onsite Rounds

Round 1: Coding

The first onsite round was a coding challenge. The interviewer presented a problem that seemed to be a variant of a Google L3 level question. I struggled with this one, and the feedback indicated a 'Strong Hire' (SH) decision for this round, which I found surprising given my performance.

Round 2: Coding

This round also involved two coding problems:

1. The first was an ad-hoc probability question, which unfortunately I don't recall the specifics of. It was conceptually similar to Maximum Students Taking Exam but was an easier variant. I managed to solve it and completed a dry run successfully.
2. The second problem was Path With Maximum Probability, or something very similar. I wasn't able to devise an optimal solution or perform a complete dry run. I also didn't take the hints provided by the interviewer, which likely contributed to my 'Not Hire' (NH) feedback for this round.

Round 3: System Design

This round started quite unusually. The interviewer presented a rather abstract problem related to a rhyming scheme, which was very unclear to interpret. After a brief, somewhat circular discussion where I tried to clarify the problem, the interviewer decided to switch gears after only about seven minutes, stating that candidates often find that problem difficult. We then moved onto a standard system design problem, for which I felt my explanation and approach were quite good. Despite not solving the initial coding problem, the feedback for the design part was positive, although the overall round was marked as 'Not Hire' (NH).

Round 4: Googlyness

The final round was a 'Googlyness' interview. I felt this went reasonably well, and the feedback was either 'Hire' (H) or 'Strong Hire' (SH), though at that point, it probably didn't significantly impact the overall outcome.

Ultimately, I received a reject for the L4 position.

My journey with Google began when a recruiter reached out to me via LinkedIn. After an initial application, I had a conversation with the recruiter who provided details about the role and posed a few fundamental computer science and web tech questions, touching upon HTML, CSS, JavaScript, and data structures & algorithms. Following this introductory round, I was informed that I would be moving forward to the next stage, and the overall interview process was thoroughly explained.

In my main technical round, which covered DSA, problem-solving, and web tech, I was challenged to design a Product Inventory System. The core requirement was that each seller could submit an order with a price and timestamp, and the system needed to efficiently support a getMinPrice() API to retrieve the order with the lowest price. I proposed a min-heap-based approach for this. A follow-up question required supporting the removal of orders by sellers at any time. I addressed this by suggesting lazy deletion to avoid the overhead of immediate heap updates. We also delved into time complexity trade-offs and explored potential optimizations, including the use of a self-balancing binary search tree, similar to Java's TreeMap, for more efficient removals and better order management. Despite arriving at an optimal solution and clearly articulating my design choices and their trade-offs, the outcome was a lean no-hire.

My Google L3 Interview Experience

I applied for the L3 position at Google Bangalore through a referral.

TPS Round

The first round focused on a problem involving family members' birthdays. I was asked to devise a data structure or function that could output the name of the member whose birthday is next from a given date, with the sequence being circular. I proposed a simple sorted array based on birthdays. The interviewer was very interested in exploring various modifications to the question and discussing all possible solutions.

Round 1 (Technical)

The first proper technical round started with a graph problem. I was given a graph of cities and travel times between them, and a source city A along with a list of favorite cities. The goal was to find the smallest time taken to reach any of the favorite cities from city A. I solved this using a simple Dijkstra's algorithm.

The follow-up to this question was more complex: in the same network, given city S and city T, and a list of favorite cities, I had to find the shortest path from S to T that must go through at least one of the favorite cities. I presented two approaches: one using Floyd Warshall and another using Dijkstra's algorithm twice (once from S and once from T) and then looping over the favorite cities to find the shortest combined distance.

Round 2 (Technical)

This round involved movies and their ratings within a network where movies with the same genre were connected. I needed to return a list of K most highly rated movies related to a given movie A. My solution involved building a graph from the movie relations and then performing a BFS from movie A while maintaining a Min Heap of size K to keep track of the top-rated movies.

As a follow-up, the interviewer asked me to explain the Quick Select method as an alternative to using a heap for this problem.

Round 3 (Technical)

This round presented a problem with pairs of strings, where each pair had exactly one character mismatch. This mismatch represented a parent-child relationship, forming character chains (e.g., 'abc','abe' -> c->e; 'abe','abf' -> c->e->f). Given a list of these pairs, I had to find the length of the longest such chain, with the constraint that each character would have only one parent and one child.

The follow-up modified the problem: from the pairs of strings, we could now form a Polytree (a tree with multiple children and multiple parents). The task was to find the length of the longest chain in this Polytree. I approached this using dynamic programming to find the longest chain for each child.

Round 4 (Googlyness)

This round consisted of generic behavioral questions, focusing on Google's 'Googlyness' principles.

Team Matching

After the interview rounds, it took about 2-3 months to get to the team matching round. This stage also involved generic behavioral questions to assess fit within potential teams.

I recently had my first-round interview for the Software Development Intern position at Google. The interview lasted 45 minutes. I was presented with a challenging Binary Tree problem that required me to implement several operations. First, I needed to replace each node's value with its reciprocal. Second, I had to swap the left and right children of each node (not their values). Finally, if a node's value was the arithmetic mode (the most repeated value in the entire tree), I had to remove that node and its entire subtree.

I managed to solve the problem efficiently, achieving O(n) time and space complexity by using a map for frequency counting and then traversing the tree to apply the transformations and removals. My solution involved a helper function to count frequencies and another to perform the transformations recursively.

The interviewer also asked a follow-up question on how to implement a function to swap two numbers.

My Google phone screen involved a task to design and implement a restaurant waitlist. I focused on ensuring the system could efficiently handle parties joining and leaving the list, and then intelligently seat the first suitable party when a table became available. We discussed various data structures and edge cases to ensure robustness.

During my Google L4 onsite round, I was presented with a challenging problem involving electoral votes. The interviewer asked me to find the number of different combinations of states won by Party 1 that would lead to their candidate being elected.

Hi Everyone,

I had my Google interview experience in April 2025. A recruiter approached me and scheduled an initial phone screen after I requested a week's preparation time. The phone screen involved a question that boiled down to using a Min Heap of size K to maintain the top K elements. I coded the solution and walked through it.

Ten days later, I received feedback: I solved the problem without hints but didn't walk through the code until asked. I was selected for onsite rounds and given 26 days to prepare.

All four onsite rounds (three DSA, one Googlyness) were scheduled for the same week.

📞 Round 1: This round had a straightforward Topological Sorting + BFS question. The interviewer, from an infra team, seemed disengaged, yawning and toggling her camera. She struggled to understand Kahn's algorithm, but was satisfied once I coded and explained it.

📞 Round 2: Rescheduled as the interviewer didn't join.

📞 Round 3: With a Principal Engineer who joined late. He started by asking if I was tense, which paradoxically made me tense. The question was a Medium-level Line Sweep Algorithm problem with intervals. I answered and coded, seeming to satisfy him. At the 37-minute mark, he asked about duplicates in interval ranges. I began explaining the necessary logic changes, but he told me to stop, saying we might run out of time. Lesson learnt: Always consider duplicates, even if not explicitly in sample input or initially mentioned.

📞 Round 3 (Rescheduled): Interviewer didn't join.

📞 Round 4 (Googlyness): Rescheduled as interviewer didn't join.

📞 Rescheduled Round 2: This interviewer was super interactive. The initial question involved log messages (string + timestamp) and printing only if a message hadn't appeared in the last 10 seconds. I used a simple map<string, int> and updated timestamps. I coded the approach, modifying the structure based on his expectations.

Follow-up 1: He asked about the bottleneck in real-time. I identified memory if all messages were unique. I proposed a cleanup using a queue and map, which he agreed with, and I coded it quickly.

Follow-up 2: A log message should be printed only if it hadn't occurred in the previous 10 seconds and wouldn't occur in the next 10 seconds. I couldn't figure it out in 5 minutes, even with a hint to use the previous cleanup function. I solved it just after the interview. Lesson learnt: Always focus on the interviewer's hints.

Rescheduled Googlyness 2: A Russian interviewer joined, thinking it was a DSA round, so it was cancelled and rescheduled.

Rescheduled Googlyness 3: Recruiter emailed that the interviewer had an emergency, so it was rescheduled again.

Rescheduled Googlyness 4: Finally, an L3 interviewer from Warsaw who was super cool. After four postponements, I had mastered all Googlyness questions and was ready with four STAR pattern stories. She was very impressed, and I felt confident about a strong hire here.

Final Verdict: ❌ Rejection. No feedback was provided. I'm now in a 12-month cooldown period, but the recruiter said she'd reach out again. I will definitely try again after the cooldown.

I recently had a phone interview with Google for an L4 position in the U.S. The interviewer presented me with a geometric problem involving 2D integer coordinates. I had to identify all unique squares whose four corners were present in the input list of points and return their top-left corner and side length. I managed to come up with an O(n*m) solution, but the interviewer pressed for optimizations. Unfortunately, I wasn't able to devise a better approach within the given time. The interview concluded with my rejection.

I had an onsite interview at Google in the US. The session started with a unique problem: 'Count the number of lakes in an island.' I was given a large m * n grid and an island coordinate. The task was to determine the number of lakes within that island. A critical detail was that any lake connected to the surrounding ocean should not be counted. The problem statement initially had some ambiguities, and I spent the first 15 minutes asking clarifying questions to fully grasp the requirements, especially regarding how to handle the large grid size and distinguish lakes from the ocean.

I recently had my interview experience for a Google University Graduate 2026 position.

My first round was a 45-minute Data Structures & Algorithms (DSA) session. The question involved an implementation-heavy graph problem where the nodes themselves were strings. It could be solved using standard graph traversal techniques. I implemented a BFS solution and was able to complete it within the allotted time, without needing any hints from the interviewer, who was very friendly. There was also a follow-up question which I managed to solve easily using a heap. My prediction for this round was a Strong Hire / Hire.

The second round also lasted 45 minutes for DSA, followed by 15 minutes for a Googliness assessment. The DSA question was described as a variation of the classic Coin Change problem, which is available on LeetCode. Unfortunately, this interviewer was not as friendly and provided no hints. I spent the entire time trying different approaches to figure out the solution, but I couldn't land on the correct one, and as a result, I wasn't able to write any code within the given 45 minutes. The Googliness portion of the interview, however, went fine. My prediction for this round was Strong No Hire / No Hire / Lean No Hire.

It's been two weeks since my last interview, and I haven't received any response, which likely means I was rejected.

Overview

I was approached by a recruiter for an L4 position at Google India. After discussing the process and location options, a phone screening was scheduled for me. I had been grinding LeetCode for about a month, and the interview went smoothly—I coded the follow-up well within time and even had some time left for chit-chat. I felt confident I’d be called for onsites soon.

However, I was met with radio silence for almost 3 months.

After 3 months, the recruiter reached out saying they had “missed” giving me feedback earlier. They told me it was a Strong Hire and invited me to proceed with onsites. They gave me a little over 3 weeks, saying the position might close soon, so the process needed to be wrapped up quickly. I agreed, and 3 onsite rounds were scheduled across consecutive days.

The first onsite didn’t go very well, as I rushed through the solution. The recruiter later told me the interviewer had flagged missed test cases and asked me to be more careful in the next rounds.

The second onsite didn’t even happen—the interviewer didn’t show up. When I contacted the recruiter, they promised to reschedule.

The third onsite did happen and went very well—I solved everything optimally, including the follow-up. Feedback was positive, which gave me some hope.

But the rescheduled second onsite was a disaster: the interviewer didn’t show up again. It got rescheduled twice more, and both times the interviewer didn’t show up. After three no-shows, I was frustrated and asked for a break before trying again.

Finally, the second onsite happened after three reschedules. It was tough—I couldn’t complete the follow-up, though the interviewer assured me completion wasn’t expected. I was doubtful about feedback, but the interviewer appreciated my critical thinking and gave positive feedback.

Then came the G/L round, which went average. I stumbled on a question about handling cultural diversity and couldn’t give a strong example. Feedback: Lean Hire.

Next, I went through Hiring Manager / Team Matching rounds, which both went very well. I matched with two teams, and both managers gave positive feedback. After the first HM round, the recruiter even told me my packet was “very good” and ready for the Hiring Committee (HC).

HC, however, flagged concerns about my first coding round and suggested another round for certainty.

I did the additional coding round and it went well. I coded the follow-ups on time, and we even discussed some Java intricacies afterward. The recruiter told me feedback was positive.

When I asked about my chances, the recruiter replied: “100%—we’ll close the offer next week.”

But from here things went downhill. No updates for over a week, then suddenly I was told my packet had been down-leveled to L3. I asked if I could do more rounds to bring it back to L4, but got no response. After a month of silence, I finally received a rejection email.

This entire experience left me physically and emotionally drained—so much so that I delayed writing this post for almost a year and a half. The lesson: until the offer is in your hands, don’t get your hopes up when interviewing at Google.

I recently had a phone screen interview for an L3 position at Google in the USA. The interview focused entirely on a single coding problem. I was given a task to map IP addresses to their corresponding prefixes based on a given list of prefix rules. I struggled significantly with the problem, failing to identify the correct data structure and approach, and ultimately couldn't come up with a working solution. This directly led to my rejection from the role.

I had an insightful onsite interview experience with Google for an L3 position, which was structured into three main coding rounds.

First onsite:
This round focused on data structure design. I was tasked with implementing a restaurant waitlist. The key requirements were to allow parties to join, leave, and to serve the first suitable party based on available table size. This required careful consideration of efficient insertion, deletion, and search operations, likely involving a combination of data structures like a min-heap or priority queue along with a hash map for quick lookups.

Second onsite:
The second challenge involved string manipulation and parsing. I was given a formula of letters with parentheses and asked to simplify it by removing the parentheses, ensuring correct sign propagation and handling nested structures. This problem tested my ability to manage state during string traversal, possibly using a stack-based approach to keep track of current signs and parenthesis levels. Examples like a-(b+c) -> a-b-c and a-(a-b) -> b were provided to clarify the expected behavior.

Third Onsite:
The final coding round was another complex string parsing problem: decompressing an encoded string. The encoding involved repeating groups of characters within parentheses, with the repetition count specified in curly braces, and supporting nested parentheses. For instance, a(bcd){3}e should become abcdbcdbcde, and a(bc(d){4}e){3}f should expand to abcddddebcddddebcddddef. This was a classic stack-based string decoding problem, demanding careful handling of nested structures and repetition counts.

My onsite interview for an L4 role at Google was quite an experience. During the technical round, the interviewer presented me with a coding challenge. It turned out to be a variation of the well-known 'Partition Equal Subset Sum' problem. While it wasn't exactly the standard problem, understanding the underlying principle made it straightforward to approach. I developed and explained a solution using the 0-1 Knapsack algorithm, which seemed to satisfy the interviewer.

During my Google L4 phone screen, I was presented with an interesting data structure problem. The task involved continuously processing a stream of integers. For each new number, I needed to determine if a triplet could be formed from the current set of numbers in memory such that the difference between the maximum and minimum of the three numbers was at most a given value d. If such a triplet was found, it had to be immediately removed and returned. This required careful consideration of how to efficiently manage the numbers in memory and quickly identify valid triplets as they arrived.

I recently completed an onsite interview round with Google for an L4 position. The interviewer I spoke with was from India. The core of the interview revolved around a challenging problem regarding a blind robot navigating a maze, which required me to devise a set of commands to ensure escape from any valid starting point.

My recent coding round at Google began with an interesting geometry problem. I was given a list of [x, y] coordinates and asked to determine the total number of squares that could be formed using these points. The interviewer first clarified that the sides of the squares must be parallel to the x and y axes. After discussing this, a follow-up modified the problem to consider squares with any orientation, making it a more complex challenge.

My Google L4 Fullstack interview experience in India involved four rounds. The first three were focused on Data Structures and Algorithms, and the final round was Googlyness. The HR mentioned that Google has shifted to 3 DSA interviews instead of 4, with a perceived increase in question complexity.

Round 1: DSA Round - Hire (Very Positive)

Round 2: DSA Round - Hire (Positive)

Round 3: DSA Round - No Hire

Round 4: Googlyness Round - Hire (Positive)

Final Verdict: Rejected, primarily due to my performance in Round 3.

I recently underwent a phone screening interview for an L3 position at Google. The interview focused heavily on my problem-solving skills, and I was given two distinct coding challenges related to string encoding and decoding. I managed to solve both problems during the interview session, feeling confident in my approaches.

Recently, I completed my Google onsites after several rescheduling issues. My interviews were all technical and focused heavily on graph-related problems, which were not easy but manageable. I solved the problems, answered follow-ups, and had solid conversations with the interviewers, though I didn't 'nail' every round perfectly. A notable slip-up was in the third round where I miscalculated time complexity, using a putIfAbsent inside nested loops leading to an incorrect n*n*logn complexity instead of n(n + logn).

The interview process started with a phone screening in June, followed by multiple follow-ups and a change in recruiting partners. I was eventually called for onsites in July, but due to a requested mock interview and interviewer unavailability, the dates were rescheduled to mid-August. The questions were all graph-based, with the third round being medium-hard and requiring some time to figure out the approach. I managed to write working code, but there were follow-up questions on syntax, time complexity, and the choice between BFS and DFS.

Had my 2nd Google round today, and the question was to design 2 APIs/functions for insert into a data stream and return any number between the nearest powers of 2 of the current median.

I started with a multiset + iterator to the median approach.

But then the interviewer reminded me it’s an infinite stream, so O(N) space won’t work.

Then I thought in terms of ranges instead of storing elements. I wrote down buckets like [2^0,2^1], [2^1,2^2], …, [2^63,2^64] and realized I could just maintain the bucket index of the median. Took me a bit of struggle, but with hints from the interviewer, I came up with an O(1) space solution. Finally coded it up.

Follow-ups

Handling negatives: I suggested skipping them / treating separately.

Interviewer pointed out not to use while(1){} (I did that in the code 😅).

At the nadir we had a nice casual talk since he was from my college too (noticed from his Google ID photo, clg alumini what a coincidence lol....).

Felt like it went fine maybe hire / strong hire, not sure, but let’s hope 🤞.

I just cleared the Google L4 phone screen and have my final loop scheduled next week (4 coding rounds, as confirmed by the recruiter). Could anyone share what specific topics Google tends to focus on, or any recent interview experiences that might help?

Today I had a phone screen with Google for the L4 SWE III role in Zurich. The interview was a single coding problem, which was similar to LeetCode #56, the merge intervals problem. However, there was a unique twist to the problem that made it more challenging. I rephrased the problem using GPT to avoid any conflict with Google's NDA. I performed very badly during the interview, but I wanted to share the question type so that others can use it for preparation.

My journey to Google began with applying through the careers page in April, and a recruiter reached out on April 28th. The first technical interview on May 23rd involved a simple tree traversal problem, which I handled well, leading to a positive verdict. The subsequent rounds included a stack-based problem (LeetCode Medium), a Binary Search Tree question with a follow-up, and a Heap problem. Each round had its challenges, but I managed to demonstrate my skills effectively. The Googlyness round was a great conversation about leadership and teamwork, and the team-matching interview confirmed my fit for the role. Finally, the offer was accepted, marking the culmination of a successful interview process.

I applied via referral in April and received hiring interest form in May, with interview confirmations in June. The first technical round was a 45-minute session where the interviewer joined 10 minutes late but ended on time. The problem was based on Priority Queue (LeetCode Medium level). I discussed my brute force and optimal approach, then implemented the optimal one. The interviewer mentioned a follow-up question, but there wasn't enough time to discuss it further.

The second technical round was also 45 minutes on June 23. The question was Stack-based (LeetCode Hard level). I shared my approach step by step, but the interviewer didn't respond or clarify my questions. Still, I managed to solve the main problem optimally and completed the follow-up within time.

The third round was technical + Googliness on July 16. This was my best round—the interviewer was very friendly and encouraging. The problem set was Graph-based, and I solved both the main problem and the follow-up within the given time. The last 15 minutes were Googliness questions about leadership and teamwork experiences, which I answered confidently.

I felt confident after the final round and was hopeful for a positive result. However, on July 12 I received a rejection call, and the recruiter didn't share detailed feedback despite asking. It was tough to digest, especially after putting so much effort into preparation and execution. Still, I see this as a learning experience—sometimes rejection isn't about capability but about timing, fit, or just circumstances. This interview gave me a lot of confidence and clarity, and I believe it has prepared me better for future opportunities. I'll keep pushing forward and come back stronger.

I recently completed a comprehensive four-round interview process with Google. The first round was focused on coding, presenting a challenging graph problem about finding the lowest total cost for two individuals traveling to a common destination. I struggled with this, perhaps overthinking for an optimal solution instead of starting with a brute-force approach as hinted by the interviewer. I couldn't fully solve it during the interview.

The second coding round involved designing a function to store integers in a data stream and, after each insertion, identify a triplet where all pairwise absolute differences were within a given distance. Initially, I considered dynamic programming, but with a subtle hint from the interviewer to view the stream as a number line, I pivoted to an approach involving maintaining a sorted order and using a linear scan. I further optimized this with monotonic and temporary stacks, which the interviewer appreciated, and I felt quite confident about my performance in this round.

My third coding interview asked me to identify ambigrams from a list of words. This felt more straightforward; I used a double-pointer method with character-to-bidirectional character conversion, and the interviewer seemed satisfied. A follow-up question about 'interesting words' was too vague to provide a concrete solution.

Finally, the fourth round was the Googleyness interview. Here, I was asked about past failures and experiences where I created something from nothing. I believe that by understanding Google's culture and preparing relevant stories using the STAR method, one can navigate this round successfully.

I was contacted by a Google recruiter via LinkedIn for an MLE-III position in Hyderabad, India. After receiving preparation materials and guides, my first round was scheduled for July 23rd, 2025.

1. Online Coding Interview (Round 1)

This 45-minute Google Meet interview presented me with a problem involving a multiline log of friend connections with timestamps. The goal was to find the earliest timestamp when everyone became friends with each other. The log could be stored in memory. I immediately recognized it as a graph problem. My first approach involved preprocessing the log to identify unique individuals, assigning them unique indices, and then constructing a graph. I planned to treat every individual as a separate connected component and decrease a global component count as I traversed each log entry and added edges between nodes. The timestamp at which the component count reached 1 would be the answer. My second, more refined approach, utilized the Union-Find algorithm. I initialized a parent array where each person was their own parent. While traversing the logs and performing union operations, I kept track of the component count. The moment it became 1, I returned that timestamp.

2. Online Coding Interview (Round 2)

In this second 45-minute Google Meet coding interview, I was given a list of lists of words, where each nested list represented a sentence. I was required to implement a method to predict bigrams. For each query with a single word, I had to return the next word that most frequently follows it in the data. For example, for input [['I', 'am', 'king'], ['I', 'am', 'travelling'], ['I', 'like', 'mangoes']] and the query 'I', the method should return 'am', since 'am' appears twice after 'I'. Unfortunately, I struggled to come up with the solution in time. I overthought the problem, assuming it would be more complex, and overlooked the simple approach of using nested maps: the outer map would store the first word as the key, and the inner map would keep a count of each word occurring after it. For each prediction call, the solution should look up the next word with the highest count.

Result

I was unfortunately rejected after the second round. The recruiter called and informed me that I did not perform well in the second round, and they would not be moving forward with my application.

During my interview at Google for the L4 position, I was presented with a problem involving a matrix representing a video frame. The task was to identify a solid square of 1s, which represented a book tag. If such a square existed, I needed to return its upper-left corner coordinates and the size of the square. If not, the size should be 0. Additionally, the square was guaranteed to be at least sqrt(n) x sqrt(n) in size. The expected solution had to achieve a time complexity of O(m or n), which I found challenging to implement efficiently.

Phone Screen
Evaluate arithmetic expressions with nested operations.
Examples:
a - (b - c) should simplify to a - b + c
a + (b - a) should simplify to b

Onsite Interview – Round 1:
Design and implement an BookManager class with the following functionalities:

insert(bookNumber, score): Insert a new book with its corresponding score.

get(): Retrieve the book with the highest score. After retrieval:
Its score is decreased by 1.

It becomes temporarily ineligible for the next get() call.

Follow-up 1:
Extend the logic so that once a book is retrieved, it becomes ineligible for the next n get() calls.

Follow-up 2:
Now each book also has an associated delay. Once a book is retrieved at time T1, it should not be eligible again until T1 + book.delay.

Onsite Interview – Round 2:
Can't recall completly but it was related to 2 pointers.

Onsite Interview – Round 3:
Similar to onsite-2 question here - https://leetcode.com/discuss/post/6812909/chances-of-swe-3-at-google-by-anonymous_-2wwd/

and couple of follow ups.

Googleyness:
This round focused on behavioral questions and understanding cultural fit.

Entire process took ~4 months.

All the best!

Recently, i got the chance to interview at Google for their SWE Internship 2026. The recruiter had reached out to me through mail saying that they would like to interview me for further processes.

First, i had a small chat with HR, it was a friendly discussion about what language i'm comfortable for the next round and explaining one of my projects. I noted that they wanted to verufy your leetcode account and remarked on the number of questions solved. 400+ seems to be a good number for them.

Technical Round-1: 45 mins, but cut short to around 35-40 mins due to interviewer's busy-schedule.

Due to google's policy, disclosing questions isnt allowed. But it was a medium level string-unordered-map question with some tweaks in a storing rotated order of string too. This round went good, she had asked me TC, SC, optimisations and edge cases. However understanding the question was slightly tricky.

I cleared this round!

Technical Round-2: 45 mins

It was similar to round-1 but the interviewer was a little stricter and the question was similar to median of a data-stream, but here the datastream consisted of all subarrays in order. (Not disclosing the exact question, the question was worded slightly more complicated and it took me time to understand what it meant). I took too much time to understand the question and find the approach as it was relatively tougher than the original problem. I was able to get the solution by the end and the code seemed to be perfect. I was really nervous during my interview and wasn't sure about my approach. I believe this is why i got rejected.

Verdict: rejected :(

But i learnt a lot in this process and I'm grateful for this opportunity as it came out of the blue! It was an amazing experience overall! Everything happens for a reason and I believe something better awaits! Key-takeaways: be confident in your approach and read the question very carefully! Just solving the question doesnt make you safe, you should be more confident and stern that what you're saying is right so that the interviewer doesnt cross question everything you're saying!

Hope this helps someone! Thanks and all the best!! Something better awaits!

Recently, i got the chance to interview at Google for their SWE Internship 2026.

The recruiter had reached out to me through mail saying that they would like to interview me for further processes.

First, i had a small chat with HR, it was a friendly discussion about what language i'm comfortable for the next round and explaining one of my projects. I noted that they wanted to verufy your leetcode account and remarked on the number of questions solved. 400+ seems to be a good number for them.

Technical Round-1: 45 mins, but cut short to around 35-40 mins due to interviewer's busy-schedule.

Due to google's policy, disclosing questions isnt allowed. But it was a medium level string-unordered-map question with some tweaks in a storing rotated order of string too. This round went good, she had asked me TC, SC, optimisations and edge cases. However understanding the question was slightly tricky.

I cleared this round!

Technical Round-2: 45 mins

It was similar to round-1 but the interviewer was a little stricter and the question was similar to median of a data-stream, but here the datastream consisted of all subarrays in order. (Not disclosing the exact question, the question was worded slightly more complicated and it took me time to understand what it meant). I took too much time to understand the question and find the approach as it was relatively tougher than the original problem. I was able to get the solution by the end and the code seemed to be perfect. I was really nervous during my interview and wasn't sure about my approach. I believe this is why i got rejected.

Verdict: rejected :(

But i learnt a lot in this process and I'm grateful for this opportunity as it came out of the blue! It was an amazing experience overall! Everything happens for a reason and I believe something better awaits! Key-takeaways: be confident in your approach and read the question very carefully! Just solving the question doesnt make you safe, you should be more confident and stern that what you're saying is right so that the interviewer doesnt cross question everything you're saying!

Had my Google phone screen round in april for L3 role at Google Banglore. Interviewer was from Georgia and asked a simple question.

Question:
Given entry node, corrupted node and network of nodes, for each node check if it is reachable or not. corrupted node is node where incoming is possible but outgoing is not possible.

Exaple:

entry node : 5
corrupted node : 3
network : [
[3],
[2,3],
[1,4],
[0,1,4],
[2,3,5],
[4]
]

Output: [False,True,True,True,True,True]

• entry node != corrupted node
• network will be single component connected undirected graph

My Google Summer Internship 2026 Interview Experience

Google visited our campus for the 2026 Summer Internship hiring. The process started with an Online Assessment (OA) consisting of 2 DSA problems. I was able to solve both completely, and based on my performance, I was shortlisted for the interview rounds.

📌 Technical Interview Round 1 – 45 Minutes
In the first round, the interviewer gave me a graph-based DSA problem. I approached the problem using Binary Search + BFS, explained my thought process clearly throughout the discussion, implemented the solution within the time limit, and also performed a dry run on the given example. The interviewer seemed satisfied with my approach and explanation.

After about 30 minutes, I received the link for the next round.

📌 Technical Interview Round 2 – 45 Minutes
This round focused on another DSA problem. The question involved an infinite sequence with a certain pattern, and I was asked to find the nth number in that sequence. While I was able to make some progress and share my approach, I couldn’t fully solve the problem within the time limit.

❌ Outcome
Unfortunately, after an hour, I got to know that I wasn’t selected for the internship.

I had a initial screening round at Google where I was asked exactly same question.

Question 1

K Criss-Cross Problem Statement You are given:

An array of N integers: arr

An integer: P

Q queries, each containing two integers: A and K

For each query:

Add the value A to the array arr.

Find the K-th largest element X in the updated array.

Update P as: P=(P^X )mod(10^9+7) You need to determine the value of P after each query, and return the results.

Input You are given the following inputs:

An integer N: number of elements in the array

A list of N integers: arr

An integer P: initial value

An integer Q: number of queries

A list of Q queries, where each query is a pair of integers A and K

Output Return a list of Q integers, where each element represents the value of P after that query.

Question 2 :

Problem: Bits Transformation You’re given:

An array A of size N containing only 0s and 1s.

An integer K.

In one operation, you must flip exactly K elements in the array. Flipping means:

0 becomes 1

1 becomes 0

You can do this operation any number of times.

Your goal is to find the minimum number of operations needed to turn the entire array into all 1s.

If it's not possible, return -1.

My journey with Google for the SWE L3 role began in mid-January 2025 when I first connected with a recruiter. After expressing my interest and staying in touch for about a month, my interviews were scheduled.

The eliminator round took place in early March. The interviewer promptly started with introductions and then presented an open-ended problem: "Create a Python class for implementing a directory structure to store files in a file system." After asking several clarifying questions, I quickly implemented a solution using a Trie. The interviewer was satisfied and extended the problem to incorporate file sizes, requiring me to report the total size of a given folder or file. I successfully implemented this, and the problem was further extended to include a delete feature, which I also managed to implement within the time limit. I even optimized my solution, coded everything properly, and demonstrated a dry run.

Two weeks later, I received the good news that I had cleared the eliminator round and would be moving on to the onsite interviews, which consisted of three technical rounds and one 'Googlyness' round.

Towards the end of March, I commenced my onsite interviews.

• Round 1: This round started with introductions, followed by a DFS-based question. It involved graph creation from an array using intuition and determining node connections, somewhat akin to topological sorting, moving from top-most nodes to leaf nodes.
• Round 2: I was asked to implement a PowerShell-style system. The problem statement initially felt vague, so I asked many clarifying questions to understand the requirements fully. I was specifically asked to implement error handling for invalid inputs, such as circular dependencies or incorrect string formats.
• Round 3: This round featured a series of easy DSA questions, posed rapidly. Topics included sorting, iterating, and optimizing for memory and time. Examples included printing the next 'n' odd numbers starting from 't', and grouping and sorting class objects while preserving the relative order of identical elements.
• Round 4: This was a standard 'Googlyness' round. It went exceptionally well, and I had a very interesting and healthy discussion covering my work experience, hobbies, and academics.

About two weeks after the onsite rounds, I received a call from the recruiter, who congratulated me on clearing all interviews. I received strong hire feedback across all my rounds.

Over the next two months, I participated in team matching rounds, one for the Bangalore office and one for the Hyderabad office. I politely declined one team match as I felt it didn't align with my career aspirations. Finally, at the end of June, I received the call that they were proceeding with an offer, and I received my offer letter shortly thereafter.

Overall, my experience was positive. I have no complaints, understanding the immense scale of Google's hiring process, with hundreds of candidates interviewed monthly. I knew it would take months. My recruiter was consistently helpful, always responding to my concerns and follow-ups. All interviewers were punctual and very kind throughout the process.

Recently I gave round 1 for SWE III ML at Google, this was a dsa coding round. I have 4 years experience as a data scientist in a mid-size company. The interview was 45 minutes and was in the first week of July. I was asked a question and an advanced follow up on the same.

Initial Question

Given a list of events, each with a message and a timestamp. Please extract the most frequent one and give me its timestamps for further analysis.

Example ->

Event: ['error_1: 123', 'error_1: 234', 'error_2: 456'] Return: error_1 [123, 234]

My Answer

Initially I created a dictionary of events with list of timestamps as the values. For the maximum I was using a max heap but soon realised the heap is not needed and proceeded with coding the optimal solution with a max_counter.

class Solution:
  def returnMost_frequent_better(self, events):
    # O(n)
    event_dict = {}
    max_counter = 0
    max_key = None
    
    for event in events:
      key, value = event.split(':')
      value = int(value.strip())
      if key not in event_dict:
        event_dict[key] = [value]
      else:
        event_dict[key].append(value)
        
      if len(event_dict[key]>max_counter):
        max_counter = len(event_dict[key])
        max_key = key
    return event_dict[max_key]

Time complexity - O(n) for the dictionary creation

Advanced Question

For the follow up, imagine that it's going to become a realtime system, and I will maintain a queue of N such events. When the queue is full, I will remove the oldest event from the queue. Every time a new event comes in, I will update the structure and get the most frequent event among the N events.

Example ->

N=2 (queue size) Event: ['error_1: 123', 'error_1: 345'] event_element = 'error_1: 234' delete- 'error_1: 123' New_list= ['error_1: 345', 'error_1: 234'] return: error_1

My Answer

I actually misunderstood the question a bit and wrote a solution considering we have all the list of events and are not being passed one by one. Still was able to come up with a fair solution as given below. Here the major dilemma was how to update and maintain the max_counter when an element is deleted.

class Solution:
  def returnMost_frequent_better(self, events, N):
    # O(n)
    # We are passed all event_list and we handle >N, <N cases
    event_dict = {}
    max_counter = 0
    max_key = None
    time_heap = []
    for i, event in enumerate(events):
      key, value = event.split(':')
      value = int(value.strip())
      heapq.heappush(time_heap, (value, key))
      size+=1
      if size<N:
        if key not in event_dict:
          event_dict[key] = [value]
        else:
          event_dict[key].append(value)
        if len(event_dict[key]>max_counter):
          max_counter = len(event_dict[key])
          max_key = key
      else:
        val_d, key_d = heapq.heappop(time_heap)[1]
        event_dict[key].remove(val_d)
        size-=1
        new_max_key = None
        new_max = 0
        for key, val in event_dict.items():
          if len(val)>new_max:
            new_max_key = key
            new_max = len(val)
        max_key = new_max_key
    return max_key

I was later told that I misunderstood the question and was told to write down my assumption. Overall it went well, prepping for the further rounds now.

Recruiter reached out to me via LinkedIn in 2023. The process was painfully slow. This is from Nov, 2024 till June, 2025. I got rejected in the DSA rounds and didn't make it to the system design round. I have 8 YOE.

I got relatively easier questions and still managed to mess it up by not explaining my thought process properly.

Googleyness: The common Googleyness questions.

DSA Round 1:

• https://leetcode.com/problems/top-k-frequent-words/?envType=company&envId=adobe&favoriteSlug=adobe-six-months
• Another post I found : https://leetcode.com/discuss/post/5075278/google-phone-screen-by-anonymous_user-qens/

Exact same question and I gloriously f*ed it up. Not blaming the interviewer at all, I wouldn't have cleared this round anyway but the interviewer was not responsive at all. He came late and gave the question. I asked him a clarifying question and he said let me check, I have forgotten. Then he read something and answered. In general, he wasn't responsive at all but I could have handled this better.

DSA Round 2: https://leetcode.com/problems/top-k-frequent-elements/description/ Question was very similar to this. It was worded as some search words are given and you need to find some top frequent elements and lots of ambiguities were there. I asked clarifying questions. The interviewer was pushing me hard to come up with the Bucket sort and then Trie solution.

The interviewer was so nice. I enjoyed this round. Felt more like a discussion.

DSA Round 3: Given a > b, b > c (Valid) or a> b, b > c , c > a (Not valid)

List of List of String is given with each list having 2 elements eg. a and b. ">" is the only relation b/w them. Find out if it is valid or not.

I should have given the detect cycle solution first but I feel I jumped too quickly to Kahn's as I was expecting the follow up to be finding the order. The follow up was that that but I didn't explain too well. I was trying to communicate with the interviewer but he stopped and told me you are driving this and do what you feel like. And I panicked to say the least! Again, I should have handled this better.

If you came to the post for the questions then you may stop reading here. And all the best!!

Some random thoughts

Process was painfully slow and recruiter didn't respond for 2 months in between. At this point, I thought I was ghosted and stopped preparing but she reached back again with another round of interview. I was preparing on/off during the 1.5 years as I kept losing interest. That was a mistake I made. Luckily, I got into another FAANG while preparing for Google. I am currently happy with the role. I want to focus on the job and my health (which I neglected) and a second source of income given how the market is. The recruiter asked me to reach back again after 6 months (which I think they do for everyone).

Hi, I appeared for the 3 onsite rounds for L4 position. Currently working as an SDE 2 at Amazon.

Phone Screen: Oncall schedule problem. Given a list of items {name, startTime, endTime} find out the oncall schedule.

Experience: Solved it but I took my sweet time. So, I think I got "bad-positive" rating.

Anyways, moved to the onsites.

Onsite R1: Similar to range module question. The difference is: support only union queries, search queries but for a number rather than a range

Experience: Solved it. Interviewer pointed a bug and I fixed it immediately. He asked if the run-time analysis is going to be same after fixing the same. I verified and said yes. But, not sure, if that was the answer he was looking for. Expecting LH / LNH here.

Onsite R2: Swap adjacent in LR string but worded differently.

Experience: Solved it. Interviewer asked me to write some corner cases I can think of. Wrote a few. Then he said he was done with the questions. I asked him if there will not be any follow-ups / another question but he said he had prepared only 1. Expecting H here (I might be feeling ambitious though.)

Onsite R3: Given edges and a list of vertices, find all the nodes that you can go to from the given vertex.

Follow up 1: What if there are redundant searches. Follow up 2: Given a list of vertices return only the minimum set of vertices that you need in a way that using those you can traverse the rest of nodes from your input list.

Experience: Solved Q1 and the first follow up. For the second approach, interviewer gave me a hint but I couldn't catch it. Also, they were rushing me to arrive at a solution. So couldn't answer this.

They said that Google has the smartest bunch compared to companies like Amazon or Apple. So I have a feeling that they might be thinking that I am not smart enough / cut for google. So might not be receiving a positive feedback. Expecting LNH.

Googlyness was not yet scheduled. I am not expecting anything either for some reason.

Hoping for the best.

Thanks and good luck guys!

Recruiter from Google's Talent Acquisition Partner companies reached out via call.

Pre - screeing Round

• Interviewer was from Switzerland (about 35y)
• Asked a question to implement few APIs for Restaurant table allocation.
• JoinWaitlist() (A group of people will join the restaurant waitlist)
• LeaveWaitlist()
• AllocateTable(int size) => Allocate the table to the first group which has a groupsize = size, if no such group allocate to size-1,-2 etc.
• It was not that difficult I would rate the difficulty somewhere between implementing a LRU Cache and LFU Cache.
• Feedback - Very good

Onsite Round 1

• Interviewer from Bangalore/Hyderabad (about 28y)
• Implement few Chat related APIs (I dont exactly remember)
• You have kind of a fream of messages of format
• (From, To, Message),(From, To, message)...
• Needed to implement APIs like
• UserWithMostChats()
• DeleteUser() => (all chats should be removed from other users as well)
• Some other APIs I dont remember
• This was also not that difficult
• Feedback : Good

Onsite Round 2

• Interviewer from Bangalore/Hyderabad (about 40-45y)
• Given Ip address ranges and their corresponding city
• (IP_Start, IP_End, "Arizona"),... etc
• You will be given an IP address find which city it belongs to
• Binary search question, asked in google interviews several times
• I though it will be very simple
• Got kind of confused while writing high/low update conditions, missed 2 edge cases also :(
• Feedback : Bad (Comment : Missed edge cases, quoted wrong Time Complexity (Dont when when this happened!))

Onsite Round 3

• Interviewer from Bangalore/Hyderabad (about 28y)
• Started with simple greedy question (almost same as fractional knapsack)
• Modified it to be a Heap based greedy question
• I arrived at the optimal solution during discussion but there was no time to code it.
• Feedback : Bad (Comment: Didnt leave enough time to complete question)

Rejected after this, Round 4 didnt happen (Behavioral)!

Phone Screen - 45 Min

Q - You’re given an endless stream of integers and a non-negative threshold d; your job is to pull off three numbers as soon as they “fit together,” meaning the difference between the smallest and largest of the three is at most d, discard those three so they can’t be reused, and continue until the stream ends, returning the list of all triplets in the order they were completed

d = 2 inputStream: [10, 5, 7, 6, 8, 3, 4, 1, 2] Result - [[5, 6, 7], [1, 2, 3]]

Interview 1 - 45 Min

Q - Given a directed graph of n nodes labeled from 0 to n-1, find the minimum number of edges in any path from a start node A to a target node B, excluding any “obstacle” nodes through which traversal is forbidden. If no such path exists, return -1.

Interview 2 - 45 Min

Q - Merged Interval (Tweaked a little)

Hi all! I’d like to share my Google interview experience in case it helps someone who’s currently preparing or going through a similar phase. 🔹 Quick Background I have around 4 years of experience, primarily as a Frontend Developer working with the React.js tech stack. My main programming language is JavaScript. To be honest, I wasn't very consistent with LeetCode, and only began solving problems regularly when I started preparing for this interview — because like many, Google has always been one of my dream companies. 🔹 Getting the Call A recruiter reached out to me via LinkedIn, and I requested one month to prepare. They were kind enough to accommodate and even rescheduled the interviews multiple times 🫤 . Kudos to the Google recruiting team for being so supportive throughout the!

🧪 Round 1: Screening / Elimination Round This was the initial elimination round, and I’m glad to say I cleared it.

	○ Duration: (e.g., 45 minutes)

Question : Implement the function "GetTotalCount(num_docs: int)", which returns the total number of words in documents with ID numbers in the range [0, num_docs).

E.g. GetTotalCount(5) -> # words for docIds 0,1,2,3 and 4 return the sum of those # words.

Candidates have the following Web API available to retrieve the number of words in a document id.

https://www.count-words.com/document/?worker_id=

Response: { count: <# of words for document-id> }

worker_id = there are infinite worker and the worker_id is a non-negative integer [0, infinity). One worker can perform only one computation at a time.

https://www.count-words.com/document/1?worker_id=1 --> trigger #words on worker 1 for docId 1 https://www.count-words.com/document/2?worker_id=1 --> Cause an error if the above call is in progress. --> If that call is finished, trigger #words for docId 2 on worker 1 => It could take a long time for the a API call to finish (for e.g. if doc has a lot of words).

Follow-up: "GetTotalCount(num_docs: int, num_workers: int)" where num_worker is the max workers that available with ids [0, num_workers).

GetTotalCount(5, 3) => Have to get # words for docIds [0, 1, 2, 3, 4 using workerIds [0, 1, 2].

Selected in Round 1

Round 2 , 3, 4 - All three are DSA round (45 minutes : The interview is strictly limited to 45 minutes, and the recruiter won’t allow even a single extra second.)

Interview 1 : https://leetcode.com/problems/car-pooling/description/

Interview 2 : https://leetcode.com/problems/sequence-reconstruction/description

Interview 3 : Based on OOPs concepts Create an online match-making algorithm that receives players and dispatches a call to a game server when it finds players with close enough skill ratings to play against each other.

Specifically, the candidate should create a class MatchMaker with a single public method to a add a player to the match-making logic. They can assume that a class GameServer with a StartGame(player1, player2) function, as well as a class Player with a GetRating() function already exist.

Players should be added to a match as soon as a valid match is found and not wait for a more optimal match coverage solution that may occur with additional players.

The max skill rating difference allowed is the same for all games (the candidate may assume that they can get this via the MatchMaker constructor, but a global constant is also acceptable), and should be inclusive.

Result is still pending ...

I was contacted by a Google recruiter via LinkedIn for an onsite interview opportunity. There was no initial assessment round. My interview process consisted of four rounds.

Round 1: Screening Round

The first round focused on data structures and algorithms. I was asked a question about finding the shortest path in a graph, followed by a modification where obstacles were added. I successfully passed this round.

Round 2: DSA Round

In this round, I was challenged to build a movie recommendation system. Given a movie graph containing names and ratings, the task was to return a list of similar top N movies. I was able to provide an optimal solution, although I did receive some hints for space optimization. The verdict for this round was 'Hire' or 'Low Hire' due to the hints I took.

Round 3: DSA Round

This round also focused on DSA. I was given an array of strings and asked to group strings that are 'buddies' to each other. Two strings are considered buddies if they have equal length and each character has the same distance from its corresponding character (for example, 'aab' and 'bbc' are buddies). I performed well and received a 'Strong Hire' verdict.

Round 4: DSA Round

The final technical round involved a binary tree problem. I needed to determine if, given a binary tree and a possible path range [lmin, lmax], there was any path whose node sum equaled kSum. This was similar to LeetCode's Path Sum III. Unfortunately, I couldn't provide an optimal solution during the interview, only an exponential recursive brute force. I solved it later with O(h) time complexity. The verdict for this round was 'No Hire'.

After completing all rounds, I was ultimately rejected.

The interviewer joined and directly jumped into the question. He verbally told me the problem statement, which you see in the first two lines of the question. No input/output was given. Just:

Given two screenshots of a single web page. Return single long screenshot merging both given screenshots with no overlapping content. 

I misunderstood the question, thinking of two arrays instead of two 2D matrices. Later, the interviewer wrote the example input and output. I wasted 10 minutes here due to the open-ended problem statement. Yes, a screenshot is a 2D grid with pixels, but it didn't strike me at that moment.

Then I explained my solution (brute force):

The idea is: if the bottom rows of screen1 match the top rows of screen2 (in the same order), remove those overlapping rows from screen2 only before merging.

He agreed and asked me to write the time complexity. I wrote it as O(h * h * w), and he mentioned it was correct. This discussion went on for 15 minutes. I thought I could start coding now. But he stopped me and asked me to optimize it.

I fumbled a lot here. I was thinking about whether I could optimize it to avoid any recalculations. I was going completely in the wrong direction, and I felt the interviewer didn't help me much here. I wasn't getting any other ideas and told him I would write the brute-force solution first and then see if I could optimize it, as I might get some ideas while looking at the code. He initially didn’t agree, but since only 10–13 minutes were left, he agreed. I understood I had already lost the opportunity, but I didn’t give up. I quickly started writing the code, hoping to find some optimization, but I ran out of time.

After the interview, I asked ChatGPT the same question. It also gave the same solution (brute force) with the same time complexity. Then I asked it to optimize, and it gave a slightly optimized solution using precomputed hashes for each row, reducing the time complexity to O(h * w + h * h). You can see the code & conversation here with ChatGPT. This is not a huge deal, but it was still my fault for not even mentioning the precomputed hash optimization. I genuinely don't know if the interviewer was expecting this or some other optimization. What do you think?

Problem 1: You have an array A of length n, where each element is either 1, 2 or 3. You will be given q queries. In the i‑th query you’re given two integers x and y:

x (1 ≤ x ≤ n): the index in the array to update

y ∈ {1, 2, 3}: the new value to assign

After performing the update A[x] ← y, you must compute and print the minimum number of swaps (each swap exchanges two elements at arbitrary positions) required to sort the entire array in non‑decreasing order. Constraint 1 <= n <= 1e5 1 <= q <= 1e5 A[i]∈ {1, 2, 3} Problem 2:

You’re given an integer array A of length n. A subsequence is any sequence you get by deleting zero or more elements (without reordering). We want to count how many subsequences of A satisfy both of these parity‑run constraints:

No three evens in a row: You never pick three consecutive elements in your subsequence that are all even numbers.

No three odds in a row: You never pick three consecutive elements in your subsequence that are all odd numbers.

Compute the total number of non‑empty valid subsequences.

Constraint 1 <= n <= 1e5 1 <= A[i] <= 1e9

Recently I interviewed for SWE(L4) role at Google, and I wanted to share the experience.

Recruiter initially reached out to me on LinkedIn and scheduled a phone call for 2 days later. The phone call went on for almost 35-40 mins. During this conversation he asked me to rate myself in Coding, discussed about different projects I have worked on, why do I want to join google, On which products I want to work in google etc. After this discussion he asked me, how much time I want to take in order to prepare well. I asked for 2 weeks. At last he told me that he'll share a form and interview schedule. I was waiting for the interview link but didn't get. After 1.5 weeks I received a mail from recruiter saying that he won't be in loop with my interview schedules and a different recruiter (name xyz) will be looking into my profile.

Current Recruiter(xyz) asked me for time to prepare and I asked for 2 weeks again, And xyz scheduled 3 onsite rounds (I was skipped phone screen round, lucky me). 5 days prior to interviews I asked for 1 more week and the recruiter agreed, and rescheduled the interviews.

Fast forward to interview date.

Onsite round 1: https://leetcode.com/problems/separate-squares-i/description/

Wording were different, stating array of cakes (sqare sized) are put on a table having x and y co-ordinates. A horizontal blade is swinging and you need to stop horizontal blade such that total area of cakes get divided into two equal parts. input : (x,y, size_of_cake)

Experience: Positive I started with follow-ups like, will the cakes be centrally placed, what if there are multiple positions at which blade can be stopped then what would be the answer in that case. About all the follow-ups he asked me to assume however I like. I came up with the binary search approach and Wrote the working code (written only required function).

Follow-up: What if Y is too large, On which I said in real world scenarios it will loop for 60-70 times, on which he said what if correctness is upto multiple decimal points. On which I talked about ternary search, to which he said, that's what I was expecting.

Onsite round 2:

crux of the question: There are multiple routers placed, having description (name:string,pos_x:double, pos_y:double). Each router can transmit to a distance of dis:double, I was asked to find whether router_A(could be any) can transmit message to router_B(could be any).

Experience: Not so good

Interviewer voice was not so clear, so I was having difficulty listening to him, I took a lot of time to understand the question and clarifying my doubts, and came up with bfs solution, after that he asked me to code.

On the footsteps of 1st round I tried to write the required function only (and here the things got complicated). He started asking multiple questions while writing code, like you are creating adjacency graph multiple times(that's how we do in leetcode, if questions are not about mutiple queries :)). Finally I started writing class based implementation.In the meantime he prompted that write code fast since he has follow-up questions. Anyway I was able to complete the code 3 mins prior. But interviewer didn't ask follow-ups stating time is almost complete and interviewer didn't seem so happy :(

Onsite round 3:

Given a list of key_value something like this: [{"x", "ab"}, {"kz", "kabl"}, {"xk", "bl"}] and a key (%kz%_p%xk%) what would be the answer. In the above case answer would be : "kabl_pbl"

basically keys would be wrapped b/w modulo operator.

Experience: Great I started with clarifying questions like, what if modulos are not even (won't be the case), what if keys b/w modulos are not present (if not present throw error) etc..

I iterated my solution with the test case, after iterating after my test case, he added on more test case: [{"x", "ab"}, {"kz", "kabl"}, {"xk", "%x%bl"}] and asked me to find the answer for this: (%kz%_p%xk%).

answer would be: "kabl_pabbl"

I came with a recursive solution, and he asked me to implement it.

Learnt from the previous round, I started with class based solution and written the helper method.

Follow up 1: After writing the code, he asked me what if certain keys are repeated multiple times inside a value, eg: %kz%_p%xk%%xk%%xk%%xk%%xk%%xk%%xk%%x%xk%%xk%%xk%

I added memoization in my recursive solution and he was happy.

Follow up 2: What if key_x depends on key_y and key_y depends on key_x, how would you handle that.

On which I replied, I will create an adjacency graph at the start, and apply cycle detection algorithms like DSU, and asked him if he wants me to write code, on which he replied not necessary, and said he just wanted to know the thinking process.

After 3rd round recruiter informed me that feedback is positive, and need to schedule googlyness round.

Googlyness round: basic HR questions like, how will you respond if someone steals your credit, how will you approach if you don't know something and you need to ask from senior or vice-a-versa etc..

After Googlyness, recruiter told that he'll schedule a Team-fit call round, and he got the buy-in from a manager in 2 days only.

Team fit (Director): Instead of manager, Director joined the call and we talked about 30 mins about the project i'm going to work on, and what have I worked on in previous companies, at last he told that, he is setting up a new team, and the manager under which I'll work is switching internally and will start officially in this team in 2 weeks, so my to-be manager will also talk to me.

Team fit(Reporting manager): To be manager, joined the call and we discussed for almost 45 min about the project i have worked on , and what i'll be working on this team, and I was pretty sure that I'm going to join this team, but that didn't happen.

I asked the recruiter, and he kept on saying that he didn't recieve the fit-call round feedback yet. After 2 weeks recruiter reached out to me on mail asking about some additional info like, legal name, promotion history, companies i worked for, expected salary etc, and it was mentioned in the mail that he'll let me know about the outcome in coming week. At this point of time I was sure that manager has given the positive feedback and maybe offer drafting is in progress that's why 1 week of time is required.

Meanwhile I kept on asking my recruiter whether my profile has passed the Hiring Committee round or not, which he ignored :(

After 1 week I ping the recruiter only to get my hopes shattered. Recruiter informed me that position has been filled internally, and the he'll try to map me with some other team.

Hoping to get matched with a team and get an offer soon :)

Hello everyone,

My background includes graduating from a Tier-1 college in 2023 with 2 years of experience as an SDE-1. I recently interviewed for the Google SWE II (L3) position for a phone screening round.

The interview questions primarily tested my understanding of recursion and tree traversal. Fortunately, I received what I considered easy questions, but the interviewer thoroughly questioned me on the worst and best time and space complexities for each solution. We had about 10-15 minutes remaining at the end, which we used to have a casual discussion about our typical workdays.

I later received an update from the recruiter informing me that I have cleared the interview. However, they also mentioned that hiring is currently frozen, so there are no further updates as of now.

Hi All,

I want to share my experience from my recently concluded Google interviews for MLE role to give back to the community which has helped me prepare for my Google dream.

Interview Process:

1. Phone Screen (DSA) - this round is elimination round.
2. 2 DSA rounds
3. 1 ML round
4. 1 Googlyness

Timeline: Recruiter reached out through linkedin around early April -> Phone screen one month later -> Onsites one month later. All onsites done within a week.

Questions: 1. Phone screen: https://leetcode.com/discuss/post/6626514/google-l3-tpsmarch-by-bhima2001-x7jv/

Exact same question with same follow up. Solved the first question quickly within 25 mins, discussed the approach for the follow up in the next 10 mins. Interviewer did not want me to code it up. Interview was over in 35 mins, last 10 mins I had a good discussion with the interviewer on their work. Result: Positive, moving to onsites.

2. Onsites R1 (DSA): It was a relatively easier question. You are given a list of sentences. Design an API which takes one word as an input and predicts the next word based on the sentences provided. E.g. Sentences = [["I","AM","SAM"], ["SAM","LIKES","ICECREAM"], ["I","AM","TALL"], ["I","WANT","COOKIE"]] For the first part, the predicted word should be the most frequent word that appears next to the input word in the sentences. For e.g: Input: "I", Output: "AM"

Follow up: Randomly pick the next word based on the probability. Probability is calculated as: Frequency of a word/Total count of words.

E.g: For the input "I", there are 2 next words in the example - "AM" and "WANT". Probability of "AM" : 2/3 and probability of "WANT": 1/3

This is very similar to this question on leetcode - https://leetcode.com/problems/random-pick-with-weight/description/

I solved the first part optimally using hashmap, tracking the most frequent next word for each word. Solved the follow up quickly as well and covered the edge cases (there were many).

Result: Positive

3. Onsites R2 (DSA): Word to word - https://codeforces.com/problemset/problem/448/C

This was a tough round. The interviewer just pasted the question and did not want me to discuss anything but just solve it in 35 mins. I still kept him engaged because I had seen this question a while back and I knew it was a tricky one. Keeping him engaged really helped as I corrected my approach through his verbal and non-verbal feedback. I quickly came up with the Divide and Conquer approach and the interviewer was quite impressed by that and asked me to code it up. However while coding, I realised there are a lot of things to consider. I juggled with the right approach and landed very close to the optimal (O(N2)) solution by the end of the interview, but there were a few more optimizations that were required.

Resut: Negative. Not sure if the interviewer expected the linear complexity solution for this which uses segment trees. My O(N2) solution was pretty close to optimal but still got negative rating

4. Onsites R3 (ML): This was again a very surprising round for me. I had spent a lot of time preparing for ML system design rounds but this was on completely different lines. I had specifically asked my recruiter to arrange a call with a Google MLE to get an understanding before this round but none of his advise resembled the problem I was given. I am choosing to not reveal the problem as I believe it could easily reveal my identity because I don't think many people are asked this type of question for ML rounds. Also there's no benefit in preparing for this type of problem because chances of getting asked such questions are very very low. Generally it's a system design round for ML such as content moderation, video recommendation etc. but this was a problem which is an active area of research. The solution required a combination of Topo sort + ML.

Result: Negative. I identified topo sort solution pretty quickly and did fairly well on the follow up, but it seems that the interviewer was expecting me to come up with the exact solution to this problem.

Got a call few days later that I did not make it. Googlyness did not get scheduled. I asked for another DSA round to make up for the 2nd DSA round but the recruiter said it's not possible given the ML round rating is also not very positive.

While the result this time did not turn out in my favor, I have my head held high for making it this far into the very rigorous Google interview process. From not giving myself more than 5% odds of success when I started to actually feeling like I have a shot at qualifying by the end has been one hell of an experience. It sucks to get this close to such an amazing opportunity but missing just enough to go back to where you started. I guess life is going to suck for a few days and then we move on to better things.

Recruiter reached out to me on linkedin. I asked 3 weeks for preparation Background: YOE: 2.5 years, Currently working at a PBC

Round 1 : Phone Screen (45 min) I was asked a graph-based problem that involved identifying the number of connected components in a graph and making decisions based on that. Was asked follow-up questions about the time and space complexity of my approach.

Feedback: Positive (Received after a week)

Round 2 : DSA (45 min)

I was given a problem similar to finding the largest files in a file system that contains both files and directories. As a follow-up, I was asked to return the top-sized directories, where the size of a directory is defined as the total size of all files it contains.

Round 3 : DSA (45 min)

I couldn't recall the exact question as it was quite descriptive and required careful attention to fully understand. I managed to come up with a solution, but missed a few edge cases during implementation. Since I spent a significant amount of time understanding the problem and clarifying test cases, there wasn't enough time left for follow-up questions.

Round 4 : DSA (45 min)

The question was related to operating system scheduling algorithms, along with a follow-up based on that. I was able to successfully solve both parts.

Round 5 : Googlyness (45 min)

I was asked behavioral questions focused on topics like demonstrating customer empathy and addressing personal weaknesses etc.,

Feedbacks: (Received almost after a month) Round 2 : Positive Round 3 : Mixed - Because I missed edge cases Round 3 : Mixed - I am not sure why!! Round 4 : Mixed - I felt I was not confident enough while answering

My recruiter mentioned that, with these feedbacks my packet looks weak and will not be proceeding further.

Status: Screening Round
Duration: 45 minutes (5 mins intro + 15 mins explanation + 25 mins coding)

[IMP] Final Thoughts
I gave my best during the interview. The problem was interesting and implementation-heavy under time constraints, but I felt confident in my approach and communication.

However, despite following up 3–4 times, I never received any feedback — neither a rejection nor a selection.
Honestly, this part was disappointing.
As candidates, we invest a lot of time preparing and genuinely care about the process, so some form of closure would go a long way.

Interview Experience – L5

YOE: 8+ years
Prep time: ~4 months
Language: Java

Qualifying Round

Question:
Implement the internal workings of a HashMap.
(The question was indirect, not "implement HashMap" literally.)

My approach:

• Explained hashing, collision resolution (separate chaining), resizing.
• Discussed load factor, capacity thresholds.
• Answered all follow-ups thoroughly.

Verdict:

• Self-assessment: ✅ Strong hire
• Actual: ✅ Passed

Notes:
Understand not just how to implement, but why you choose a collision strategy and resizing approach.

Round 1

Question:
Given an expression, insert + and * operators to evaluate to a target.

My approach:

• Used DFS/backtracking to explore all operator placements.
• Built expression string carefully.
• Explained time and space complexity.

Follow-ups:

• Handling 0 (leading zeros).
• Handling negative numbers.

Outcome:

• Solved all parts in the interview.

Verdict:

• Self-assessment: ✅ Strong hire
• Actual: ❌ No hire

Notes:
Even if you solve the problem, interviewers will still evaluate how clearly you explain your reasoning, handle edge cases, and write clean code.

Round 2

Question:
Given employee names with entry and exit times, for specific times, find how many employees are present.

My approach:

• Took some time clarifying the problem.
• Used sorting and line-sweep technique.
• Completed core logic.

Issue:

• Ran out of time for follow-up questions.
• Made mistakes explaining time complexity.

Verdict:

• Self-assessment: ✅ Hire
• Actual: ❌ No hire

Notes:
Make sure you can clearly and quickly explain your time/space analysis. Practice summarizing approaches like line-sweep and prefix sums under time pressure.

Round 3

Question:
How would you implement a counter for a given userId?
(uId, counter) map

Follow-ups:
Handling in a multi-threaded environment.

My approach:

• Suggested using a basic map.
• Mentioned ConcurrentHashMap.
• Talked about AtomicInteger per user.
• Discussed synchronized blocks.

Verdict:

• Self-assessment: ✅ Hire
• Actual: ❌ No hire

Notes:
Concurrency questions often require deep understanding of Java primitives. Be ready to discuss race conditions, consistency guarantees, and practical implementation details.

Final Verdict

• L5: ❌ No hire
• Also tried for L4: ❌ No hire

Key Takeaways

• Master fundamentals like HashMap internals, DFS/backtracking, interval/line-sweep techniques.
• Always explain time and space complexity clearly and confidently.
• Be fast at clarifying problem statements to avoid losing time.
• Practice multi-threading patterns in your chosen language, including specifics like ConcurrentHashMap and AtomicInteger.
• Don’t just “make it work” — be able to explain why your approach is correct and optimal.

Chess Tournament Ranking

Note: This problem is based on a Google interview question, with additional explanations and examples added for clarity.

Credits

• Original Problem Source: Google Technical Interview
• Enhanced by: Additional test cases, detailed explanations, and algorithmic analysis
• Problem Category: Graph Theory, Topological Sorting, Transitive Closure

If you found this problem interesting, consider exploring similar graph-based ranking problems or other Google interview questions involving partial ordering and transitive relationships.

integer a,b,c,d,e given d is cost of incrementing 1 in every integer and e is cost of incrementing 1 only in any one integer u have to calculate step1 a,b,c are divisible by 3 and step 2 a,b,c are not divisible by 3 a = 1, b=2, c=3 , d=1 ,e=1 for step 1 we increment b by 1 following e cost and then increment a by 2 following 2 times e operations total cost = 3, now a,b,c are divisible by 3 for step 2 increment c by 1 following e cost, now a,b,c are not divisible by 3 answer 3,1

constraints 0<a,b,c<1000

My journey to Google Warsaw for an SRE-2 role was both challenging and rewarding. I had been preparing intensely since March 2024, having already solved over 1500 LeetCode questions. This was my first MAANG interview, so I was quite nervous during the onsites.

My screening round was detailed, as described in this LeetCode post.

The first onsite round was a Googlyness (behavioral) round with an interviewer from Switzerland. I was asked to describe a time when I had to pivot midway at work, and another time when my actions positively impacted my team. There were in-depth follow-up questions on both scenarios. From what I could tell, my performance was 'SH' (Strongly Hinted).

Onsite 2 was a coding round with an interviewer from the US. The main question was challenging, relating to filesystem size calculation. I solved it using DFS. The interviewer asked many clarifying questions, such as how to handle cycles in the filesystem. For follow-ups, I discussed caching results for multiple queries on the same filesystem, and how to reduce space by only storing folder sizes, as file sizes had O(1) lookup. I also suggested using a visited set for cycles and considered Union-Find for multiple filesystems. However, I felt I overcomplicated the solution and might have missed a bug, resulting in a 'LNH' (Low Not Hire) performance.

Onsite 3, my second coding round, was truly the best for me. The interviewer, also from the US, was incredibly cool. The problem involved validating a string based on its length l, a maximum of k similar consecutive characters, and a given set of alphabets. I solved this with a stack in O(N) time and O(N) space, mentioning that an O(1) space optimization was possible. The interviewer actually helped me with the O(1) solution without me getting stuck, and I quickly coded it.

The follow-up was to count the number of valid strings under the same l, k, and alphabets constraints, but without being given an initial string s. I initially misunderstood and began discussing Monotonic Stack and DP, assuming s was still an input. When the interviewer clarified, I realized my mistake and quickly switched to a backtracking approach, explaining its complexity and implementation. The interviewer was very happy with my quick adaptation. I even suggested an optimized solution as time was running out. My performance here was 'H' (Hire) despite the initial misunderstanding.

I received positive feedback from HR and am now moving forward to Team Matching.

given a string and a tree to decode the string
Example -
s = "ABGHBCDDE"
()-> A -> B -> G -> H "Hello"
-> B -> C -> D " "
-> D -> E "there"

Write a class implementing below interface

public interface Iterator<Character> {
Character next();
boolean hasNext();
}

Here next() returns the next character of decoded String.
hasNext() returns true if there are more characters in the decoded string.

Background

• Experience: 2 years in Full-Stack Development
• Competitive Programming: Master on Codeforces
• Application: Applied via the Google Careers portal (no referral)

Recruiter Call

I received a call in the first week of April. The recruiter inquired about my background, experience, and salary expectations. I was asked to share five available dates for interviews, with a maximum of two weeks' preparation time. However, the actual interviews were scheduled for later dates than initially discussed. Each round was set for 45 minutes.

Elimination Round (45 mins)

Timezone: US
Problem: A MEX-like problem involving sequence numbers (long long int) and an initial sequence number x. Two types of queries were involved:

1. Add a sequence number y
2. Fetch the minimum missing sequence number from the current set

Solution:
I used a HashSet to store the incoming sequence numbers and a variable to track the current missing sequence. With each insertion, the tracker increments until it hits the next missing value. For query type 2, we return this number. I also discussed time complexity in detail.

Follow-up Questions:

• Why not trigger the increment in the "get minimum" call?
  I explained that placing the increment depends on the query pattern. If query type-2 is less frequent, it’s more efficient to place it during the insertion step.
• Real-world application and the role of the initial sequence number?
  I related it to a video loading use case, where the initial sequence number represents the starting frame. Missing frames indicate a need for retransmission.
• How to detect unprocessed (corrupted) frames?
  By inserting each received frame into a HashSet and removing it upon processing.
• How to distinguish between corrupted and unprocessed frames?
  Through timestamp-based invalidation.

Timeline:

• Question & clarification: 5–10 mins
• Approach: 8 mins
• Implementation: 8 mins
• Follow-up: 10 mins
• Interviewer questions: 5 mins
• Ended early

Result: Advanced to next rounds — 3 Technical + 1 Googleyness & Leadership (G&L)

Technical Interview 1 (45 mins)

Timezone: India
Problem: An array (garland) contains d diamonds and r rubies (both even). You are allowed up to 2 cuts to divide it into two parts such that both parts contain the same number of diamonds and rubies.

Approach:

• For 1 cut: Only the middle position works.
• For 2 cuts: First and last segments form one group; use a sliding window of fixed length n/2. Achieved an O(n) time solution using O(1) space.

Follow-up:

• What if there's a third type of stone and up to 3 cuts allowed?
  I used the same logic for up to 2 cuts. For 3 cuts, fixed the first segment and iterated possible joins for a rough O(n²) solution. Did not implement.

Timeline:

• Question & clarification: 5–10 mins
• Approach: 5–10 mins
• Implementation: 20–25 mins
• Follow-up: 2–3 mins
• Interviewer questions: 2 mins

Technical Interview 2 (50–55 mins)

Timezone: India
Problem: In an undirected graph where nodes represent homes, two persons (nodes a and b) must reach a destination node c. They may travel independently or meet up on the way and then travel together. Joint travel on an edge counts as a single unit of cost.

Approach:
Precomputed all shortest paths between node pairs. For each node, considered it as a meeting point for a and b, then both travel together to c. Computed the minimum total cost.

Time Complexity: O(n²)

Follow-up:

• Now suppose there are 3 friends: a, b, and d—how would all of them reach c?
  I considered 3 possible groupings: (a & b), (b & d), (d & a), with each pair meeting before the third joins. For each, iterated over potential join points to compute the best path. Did not implement.

Timeline:

• Question & clarification: 5–10 mins
• Approach explanation: 15–20 mins
• Implementation: 15–20 mins
• Follow-up: 5 mins
• Interviewer questions: 5 mins

Technical Interview 3 (45 mins)

Timezone: Australia

Problem 1: Remove a node with a given value from a linked list
Response: Implemented quickly

Problem 2: Create an n × m maze such that there is exactly one valid path between every two cells.
Initial Idea:
Start from cell (1,1), go straight if possible, else turn left—creates a spiral path. Explained this for ~10 mins before self-correcting.

Final Idea:
A simpler method—draw all horizontal lines, but skip one column per row to maintain a unique path between all cells.

Timeline:

• Problem 1: 20 mins
• Problem 2: Question & clarification (5 mins), Idea 1 (10–15 mins), Idea 2 (2 mins)
• Interviewer questions: 5 mins

Technical Interview 4 (45 mins)

Timezone: US
Note: This was supposed to be a G&L round, but the interviewer decided to conduct a technical interview.

Problem: Inside an n × m rectangle with a set of horizontal and vertical lines, find how many squares can be formed.

Approach:
Used preprocessing to store the maximum length of consecutive horizontal/vertical lines ending at each point. For each potential square, checked if it could be formed using these precomputed values.

Timeline:

• Interviewer joined late (~5–10 mins delay); I created and shared a Google Doc
• Question & clarification: 5–10 mins
• Solution explanation + pseudocode: 25–30 mins
• Interviewer questions: 5 mins

Final Result

Rejected. The recruiter shared that the last two rounds received negative feedback. Surprisingly, during the final interview, the interviewer actively followed my approach, asked relevant questions, and signaled understanding throughout the session. The rejection note cited that the interviewer was “not able to understand the solution,” which was inconsistent with the actual interaction.

This post provides a compilation of technical interview questions for Google L3 and L4 roles, gathered from various discussions, rather than a single candidate's personal interview experience.

Interviewer told we will be having 6-7 questions, will try to cover up the entire thing in 30 minutes. After that I can ask questions if any.

Also he told that all questions will be based on your past experiences and if you have not had any similar experience as per the respective question, you can skip that one.

Questions

1. Describe a time when you had a disagreement with your colleage and how you resolved it?
2. Describe a time where a strict deadline project was pushed away from you in the middle. How did you feel about it?
3. Describe a time where you worked with other teams and had to make an influence on them
4. Describe a time when your teammates were not stisfied with your work. How did you work around it?
5. Describe a time when you were not able to complete the project on deadline. What approach you took?

Not able to remember but there was 1-2 more questions similar to above.

Interviewer completed within 30 minutes and I asked some questions regarding culture at Google to stretch the interview a little and closed the call in 40 minutes total

Round 1 you are given a few api

API that is responsible to calculate a callback function after relative_time_stamp_in_mills from the time of the call setCallBackHandler. void setCallBackHandler(int relative_time_stamp_in_mills);

API that gives current system time in mills. int getSysTime();

You have to write a method called ScheduleCallback(call_back_func_pointer, time_in_mills) that does the job of scheduling a call to call_back_func_pointer after time_in_mills from the call.

1. The calls might come in parallel.
2. setCallBackHandler can only save ONE TRIGGER AT A TIME. So if the new request is supposed to get executed first, you need to handle that gracefully.
3. setCallBackHandler takes in relative time.

Round 2 You are given a Class with two methods

Class CWFuture{
	CWFuture(Const int machine_id, const int doc_id);
	int join() // Returns the number of words in the document file. This is a blocking call, it won't return if the process is still calculating the words in the document
	int isDone() // Returns true if the calculation is done else false
}

Given max_doc_ids, you need to write a method, use CWFuture class and calculate the total number of words in doc ids ranging from [0, max_doc_ids) and return that number.

Scenario 1: You have unlimited number of machines available. Follow up scenario 2: What if you have at max N number of machines with you. Scen 3: Discussion: How would you improve the accuracy of your result if the API is not accurate every time. Let's say 90% of the time it returns correct response.

Write C++ code for both scenarios separately and implement a method called CountWords.

Round 3: You are given a data structure of HTML Content and tags. Looks like this. A node can be an html tag OR a string text.

class Node{
	bool isText();
	string getText();
	vector<Node*> getChildren();
}

You need to implement a method that takes in Head of the node and a string to search. And you should return the nodes that cover the search string within the structure.

<span><b>This</b> is a <i>funny Text.</i> </span>

         <span> 1
         /  |   \
        /   |    \
       /    |     \
     2<b> 4" is a"  <i>5
     /\t\t\t\t \
    /\t\t\t\t  \
   /\t\t\t\t   \
3"This"\t\t\t\t" funny Text."6

Case 1: Search = "is a" Returns Node 4

Case 2: Search "a fun" Returns Node 4 and Node 6.

vector<Node*> GetNodes(Node* head, string& search);

Implement GetNodes.

Overall it was a reject. You'll find the answers on Chat GPT. Apparently interviewer for the first round was expecting me to use threads and mutexes and actually implement it. That's where I lost.