Google sounds is a bit scary. Every year, people quietly fail at this level. It doesn't matter how beautiful their resume is. For many fresh graduates, OA is the first real threshold in the entire process, and a large number of high-quality resumes are filtered out at this step. It turned out that it was not as mysterious as imagined.
The overall style of the 2026 Google OA continues as before: it is not a test of how many questions you have answered, but a test of your engineering thinking when facing problems - whether the code is clear, whether the boundaries are well handled, and whether the problem-solving ideas are structured. To put it bluntly, what Google wants is not a memorizing machine, but someone who can actually write reliable code. Below is my complete experience, with question ideas and test preparation suggestions. I hope it will be of reference value to students who are preparing.
Google 2026 New Grad OA Basic Information
| Project | Content |
|---|---|
| Evaluation platform | Part batch Codility, part batch HackerRank |
| Number of questions | 2 programming questions |
| Time limit | 60–90 minutes |
| Pre-process | Photo Verification → Start coding directly |
| Overall difficulty | Medium, not difficult but easy to think in the wrong direction |
Google NG OA real question memories (2026 new questions)
Question 1: Collect coins (Token movement problem)
Question description
StringBoardDepend onT(Token),C(coin),.(space) composition.
- The token can only move to the left, one step at a time, and can only move to spaces;
- Move to
CCollect coins while in position, the coins disappear and the position changes to.; - Tokens cannot overlap and cannot be moved to a location where other tokens are present. Find the maximum number of coins that can be collected.
Example
Board = "TT.T.CCCCC"→ output3Board = "T...CCCC"→ output1Board = "C..TT.CT.C"→ output2
Problem-solving ideas
- Greedy core: Process tokens from right to left, giving priority to the rightmost token to collect the nearest coins on the left to avoid seizing the left token resources;
- Simulation logic: Loop through, find the movable token → Match the coin to the left → Check that the path is unobstructed → Move and count until no new moves occur.
Code implementation (Python)
Def solution(board):
arr = list(board)
coins = 0
n = len(arr)
while True:
moved=False
for i in range(n-1, -1, -1):
if arr[i] == 'T':
j=i-1
while j >= 0 and arr[j] == '.': j -= 1
if j >= 0 and arr[j] == 'C':
# Check if the path is all spaces
if all(arr[k] == '.' for k in range(j+1, i)):
arr[j] = '.'
arr[i] = '.'
arr[j+1] = 'T'
coins += 1
moved=True
break
if not moved: break
return coins
Question 2: Maximum subset of shared-nothing numbers
Question description
Given a two-digit arrayNumbers, select the largest subset, requiring that no two numbers have the same number (for example, 52 and 25 share 5 and 2, and cannot be selected at the same time; 90 and 90 can be selected at the same time).
Example
Numbers = [52,25,11,52,34,55]→ output4Numbers = [71,23,57,15]→ output2Numbers = [11,33,55]→ output1
Problem-solving ideas
- Bit mask conversion: Convert each number to a 10-bit binary mask (numbers 0-9 correspond to bit marks), such as 52→
1<<5 | 1<<2; - Count frequency: use a dictionary to count the number of occurrences of each mask;
- Backtracking enumeration: traverse all mask combinations, filter ** non-intersection (mask &=0) ** combinations, and calculate the maximum element sum.
Code implementation (Python)
From collections import defaultdict
def solution(numbers):
def get_mask(num):
s = str(num)
mask=0
for c in s: mask |= 1 << int(c)
return mask
count = defaultdict(int)
for num in numbers: count[get_mask(num)] += 1
masks = list(count.keys())
max_size = 0
def backtrack(idx, used, size):
nonlocal max_size
if idx == len(masks):
max_size = max(max_size, size)
return
# Do not select the current mask
backtrack(idx+1, used, size)
# Select the current mask (no conflict)
if (used & masks[idx]) == 0:
backtrack(idx+1, used | masks[idx], size + count[masks[idx]])
backtrack(0, 0, 0)
return max_sizeGoogle online assessment process description
The OA link is valid for about 5-7 days. It is recommended to choose a time period when the status is good and the network is stable. After entering, you need to take photos for verification. After verification, you can start writing questions directly. There are no warm-up questions.
The platform supports mainstream languages such as Python, Java, and C++. You can run basic test cases, but it does not support line-by-line debugging like local IDEs, so you must think clearly about the logic before starting. After submission, the system will add several hidden cases for stress testing. If the boundaries are not handled well, it will be easy to fail.
Resource recommendations
If you are like me, when preparing for New Grad OA from major companies such as Google, Meta, Microsoft, etc., you feel that answering questions alone is not efficient, or you want to systematically improve Google's high-frequency question types, I strongly recommend it. Programhelp.
Their seniors have rich big factories OA assist experience , is particularly good at helping students sort out Google OA high-frequency questions, optimize code style and improve time management skills, and can provide targeted simulation exercises and real-time guidance.
Students in need can
