I graduated with a master's degree from a top 30 university in North America. After attending CSOAsupport's three-month intensive Google interview coaching at the end of last year, I contacted a friend working at Google in March 2025 to ask for a recommendation. Soon, I received an interview arrangement from the recruitment team.
Phone interview(VO)
During the initial introduction call, the recruiter explained Google's interview process in detail, including the initial screening and the subsequent four rounds of interviews: two coding rounds, one system design round, and one behavioral interview round. I requested a month of preparation time and was supported.
Preparation for the screening round
During the preparation process, I decided to use Python for programming to improve my code-writing efficiency. Then, I systematically reviewed data structures and algorithms, including heaps, hash tables, and graph-related problems, and solved about 70 LeetCode problems, focusing on problems with a high acceptance rate.
Programming Exam
In March 2025, I took Meta's first round of programming exams, which lasted 45 minutes. The interviewer was a middle-aged man, about 40 years old, wearing a simple black T-shirt and jeans, looking very casual. His hair was slightly gray, but he was in good spirits, with a hint of humor and friendliness in his eyes. Throughout the process, his tone was relaxed, making me feel like chatting with a friend.
At the beginning, he briefly introduced himself and the team, and then quickly got to the point. The interviewer didn't like to drag his feet, and his questions were direct and clear. He asked questions in a very open way, encouraging me to express my thoughts when thinking, rather than simply giving answers.
Interviewer asked: Given an array, find the element whose number of occurrences exceeds half of the length of the array (if any).
My answer: I first checked the boundary conditions, then used a hash table to record the number of occurrences, and finally gave a complete solution within 10 minutes.
1) Boundary condition check: If the array is empty, directly return a null value or a specific flag to indicate that there is no solution. If the array has only one element, then that element is the one you want (because it naturally exceeds half of the length of the array).
2) Use a hash table to record the number of times an element appears: traverse the array, and for each element, use a hash table (dictionary) to record the number of times it appears.
3) Find elements that exceed half the length of the array: Traverse the hash table and check whether the number of times each element appears exceeds half the length of the array. If found, return the element.
If the hash table is not found after traversing it, return a null value or a specific flag to indicate that there is no solution.
The interviewer asked the second question: given an array of integers arranged in non-decreasing order, after rotating it an unknown number of times, you need to find the minimum value in the rotated array. You are required to design a solution with a time complexity of O(log n) and implement the code within 15 minutes.
My Point：
The problem of finding the minimum value in a rotated array can be solved by binary search, because we know that the original array is ordered. Through binary search, we can gradually narrow the search range until the minimum value is found.
The Answer
Initialize pointers: set two pointers, left and right, to point to the start and end positions of the area, respectively.
Middle position judgment: calculate the middle position mid.
Compare the middle and right elements: If nums[mid] < nums[right], it means that the minimum value is on the left side of mid or mid, because the right side of mid is still the ordered part of the original array. If nums[mid] > nums[right], it means that the minimum value is on the right side of mid, because mid is after the rotation point, and the minimum value after rotation is between mid and right.
Update the boundary: Update the position of left or right according to the judgment in the previous step.
End condition: When left and right meet, the search ends, and the position pointed to by left (or right) is the minimum value.
Technical interview
The interviewer was a young woman in her early thirties. She wore a gray Meta sweatshirt and black trousers, looking professional and casual. She had short curly hair, a sunny smile, and a smart and energetic look in her eyes.
She was very cheerful and asked a few light-hearted questions at the beginning, which helped me relax a lot. Throughout the interview, she not only paid attention to my technical thinking but also inserted some humorous comments from time to time to make the atmosphere relaxed and pleasant. When I got stuck in solving a complex problem, she would encourage me: "It's okay, take your time, we can think about it together." This support made me feel very comfortable. At the end, she said kindly, "No matter what the result is, you did a great job today!"
My logic for this question is as follows:
This problem can be solved by dynamic programming (DP). We can create a two-dimensional array, dp, of the same size, where dp[i][j] represents the minimum path sum from the upper left corner to grid[i][j].
My answer
Initialization: dp[0][0] is equal to grid[0][0], because the upper left corner is the starting point. Each position dp[0][j] in the first row can only be reached by the path from left to right, so dp[0][j] = dp[0][j-1] + grid[0][j]. Each position dp[i][0] in the first column can only be reached by the path from top to bottom, so dp[i][0] = dp[i-1][0] + grid[i][0].
State transition: For other positions dp[i][j], they can be reached by dp[i-1][j] above or dp[i][j-1] to the left. Therefore, dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j].
Result: The minimum path sum is dp[m-1][n-1]. Since we only need to traverse the entire two-dimensional array once, the time complexity is O(m*n).
Second round of technical interview
Interviewer’s question: Given an array (or string), find all possible permutations.
For example, for the array [1, 2, 3], its full permutations are: [ [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2] ]
My answer:
The core idea of recursively solving the full permutation problem is: for each element in the array, treat it as a fixed point, then recursively perform full permutations on the remaining elements, and finally insert the fixed point into all possible positions of these permutations.
Baseline case: If the array is empty or contains only one element, then directly return the array as a permutation (or add it to the result set).
Recursive steps: For each element in the array, swap it with the first element, and then recursively perform full permutations on the remaining elements (except the first element).
Time complexity analysis
Generation of each permutation: For each element, we need to swap it with each subsequent element once, which will generate a new permutation. For an array of length n, each element may need to be swapped with the next n-1 elements.
Number of recursive calls: In the deepest recursion, we will have n! (n factorial) permutations, because for each position, we have n choices, and then for the remaining n-1 positions, we have (n-1)! choices, and so on.
Swap operations: Each swap operation is constant time O(1). However, for each element, we may need to perform n-1 swaps to generate all possible permutations.
Therefore, the total time complexity is O(n!), because we need to generate n! permutations, and the generation process of each permutation involves O(n) swap operations, but O(n) is negligible compared to n!
System Design Interview
When I designed a photo sharing system similar to Pinterest, the interviewer was a middle-aged man, about 45 years old. He wore a dark blue shirt and khaki pants, which made him look professional and casual, like a "fashion godfather" walking out of the office. His hair was a little gray, as if he had experienced a lot of ups and downs, but the wisdom behind his glasses made me feel that he must have seen a lot of the world.
He was very friendly and smiled throughout the interview, just like chatting with an old friend. Whenever I analyzed in depth, he would listen carefully and ask some "sharp" questions from time to time, such as: "Have you considered the scalability of data storage?" At that moment, I wanted to answer: "I'm just designing a place to share photos, do I have to worry about storage problems?" However, I still held back.
The interview atmosphere was very relaxed. Although we talked about technology, he would insert some humor, such as: "I hope the system you design will be as popular as my wife's circle of friends!" Finally, he gave positive feedback on my plan and expressed his expectation to see my future performance. I was so happy, it was like I won the medal of "Best Designer"!
Core user needs include:
- User registration, login and information management
- Image upload, processing and sharing
- Comments, replies and interactions
- Likes and real-time feedback
- Search, discovery and popular content
- Notification and private message functions
System architecture design
- Front-end: React/Vue framework, responsive design
- API gateway: Nginx/Traefik, load balancing and routing
- Service layer: microservice architecture, including user, image, comment, like, search and notification services
- Database: MySQL/PostgreSQL (structured data), MongoDB (unstructured data), Redis (cache)
- Storage: Amazon S3/Alibaba Cloud OSS, CDN acceleration
- Load balancing and redundancy: ensure high availability and fault tolerance of the system
Behavioral interview
During the final round of interviews at Google E4, I had the opportunity to share in-depth the key roles I played in past team projects. I elaborated on how I took leadership roles, promoted team collaboration, and successfully resolved a series of complex conflicts. These experiences not only demonstrated my professional skills but, more importantly, they highlighted my high degree of alignment with Google's core values, such as the pursuit of excellence, innovation, and teamwork.
During the interview, I used specific examples to support my views, so that the interviewer could intuitively feel my work style and problem-solving ability. I talked about how to remain calm and analyze when facing project bottlenecks, and lead the team to find the best solution through effective communication and coordination. At the same time, I also shared how to use wisdom and patience to promote consensus and ensure the smooth progress of the project when there are disagreements within the team.
Offer Succeed
After a long week of waiting, I finally received an offer from Google and successfully obtained the position of E4 algorithm engineer. At that moment, my mood was like rising from the bottom of the sea to the surface of the water quickly, and I was so excited that I almost danced in the office.
To fight for a reasonable salary, I made a lot of preparations in advance. A few days ago, I was curled up on the sofa, surrounded by industry reports and salary comparison tables, holding a mobile phone in my hand, and conducted a simulated negotiation of "salary psychological warfare" with several mentors from CSOAsupport. Imagining my future life, I silently calculated an ideal salary figure in my mind, and even set a small goal for myself: to live in a high-end apartment near the company with a monthly rent of $4,000!