Google OA is usually conducted on the CodeSignal platform, and the standard configuration is 2 coding questions, 60-90 minutes. Although the question bank has been updated in 2026, it is still mainly Medium. Many questions are slight variations of the original LeetCode questions or add small constraints. Purely violent solutions can easily time out in large cases. Understanding the rules + reasonable optimization is the key to passing.
Let’s share the 2026 Google OA real question dismantling and speed-passing ideas organized by Programhelp.
Google Drive Folder Hierarchy Sync Problem
In the architecture of Google Drive, folders are maintained in a hierarchical structure, and folders can be nested within each other (from folder 1 to folder n). Each folder has a specific access level, represented by an integer.
A hierarchical structure is called "Synced" when it meets the following conditions: The absolute difference in access levels (the absolute value of the difference) between any two directly connected folders (parent folder and its subfolder) does not exceed 1.
Due to a recent update, the access levels of some folders have changed. To maintain security integrity and ensure that the hierarchy is "in sync", you need to increase the access level of other folders.
Your goal is to find the minimum total access level increase required to bring the entire folder hierarchy into sync.
Note: You can only increase access levels, not lower them.
Example
Consider the following hierarchical tree:
- Input Tree:
- Root folder 1: Access level 1
- Folder 3 (child of Folder 1): Access level 3
- Folder 2 (child of Folder 3): Access Level 2
- Folder 4 (child of Folder 3): Access Level 6
- Folder 5 (child of Folder 2): Access level 5
- Modified Tree:
- Folder 1: Access Level 4 (Promoted 3)
- Folder 3: Access Level 5 (Boost 2)
- Folder 2: Access Level 4 (Promoted 2)
- Folder 4: Access Level 6 (unchanged)
- Folder 5: Access level 5 (unchanged)
In a given hierarchical tree, the optimal solution to achieve synchronization is:
- Folder 3's access level increased by 2
- Folder 2's access level increased by 2
- Folder 1's access level increased by 3
After completing these adjustments, the hierarchy tree becomes synchronized and the minimum required total access level increase is 2 + 2 + 3 = 7(Note: The question example is marked 6, which should be a clerical error and should be corrected according to logic).
Function description
Complete function in editor FindMinIncrease, the parameters are as follows:
Int tree_nodes: The total number of folders in the hierarchical treeInt tree_from[tree_nodes-1]: an endpoint of each edgeInt tree_to[tree_nodes-1]: the other endpoint of each edgeInt access_level[tree_nodes]: Access level for each folder
Return value:Long Type, the total amount of minimum access level increase required to synchronize the hierarchical tree.
Problem-solving ideas
- Tree structure processing: First convert the input edge list into a rooted tree starting from the root node (usually 0 or 1), recording the parent/child relationship of each node.
- Dynamic programming state definition: for each node
U,definitionDp[u][x]Represents: the nodeUThe access level is adjusted toX(X ≥ original access level a[u]), withUIs the minimum total lift of the root subtree. - State transfer: for nodes
UEach child node ofV:VThe final value ofYMust be satisfied|x - y| ≤ 1AndY ≥ a[v],thereforeDp[u][x] = (x - a[u]) + Σ( min{ dp[v][y] | y ∈ {x-1, x, x+1}, y ≥ a[v] } )
Answer extraction: root node Dp[root][x] The minimum value in is the global minimum total improvement.
Maximum Group of Two-Digit Numbers Sharing a Common Digit
An array consists of N two-digit integers. A group of numbers is selected from an array if all the numbers in the group share at least one digit.
For example: the numbers 52, 25, and 55 can be picked together (they all contain the number 5), but 11, 52, and 34 cannot be picked together.
Find: The maximum number of array elements that can be selected together.
Function requirements
Write function:
Int solution(vector &numbers);
This function receives an array of integers Numbers, returns the maximum number of selectable elements that meet the conditions.
Example
- Enter
Numbers = [52, 25, 11, 52, 34, 55]52, 25, 52, 55 (shared number 5) can be selected and the function should return 4. - Enter
Numbers = [23, 57, 15]Only up to 2 elements can be selected and the function should return 2. - Enter
Numbers = [11, 33, 55]No two numbers share digits, the function should return 1. - Enter
Numbers = [90, 90, 90]All numbers can be selected and the function should return 3.
Assumptions
- N is an integer in the range of 1~100
- Array
NumbersEach element of is an integer in the range 10~99 - When solving problems, priority is given to ensuring correctness, and performance is not the focus of evaluation.
Problem-solving ideas
- Split the digits of each number: For each two-digit number in the array, split its "tens" and "units" digits. For example, 52 is divided into 5 and 2, and 90 is divided into 9 and 0.
- Count the number of occurrences of each digit: Use an array of length 10 to record the total number of occurrences of each number from 0 to 9 in all two-digit numbers.
- Take the maximum value as the result: the maximum value in the statistical array is the maximum number of elements that can be selected.
For more real questions, please refer to:
- LeetCode Google OA discussion thread (e.g. Https://leetcode.com/discuss/interview-question/352460/Google-Online-Assessment-Questions)
- Google Code Jam History Questions (Practice Competition Style)
- Organized by Programhelp team
Preparation Tips and Strategies
Preparing for Google OA requires planning ahead as you usually only have a few days. It is recommended to study the Google high-frequency questions on LeetCode (at least 20 questions) before applying. First, lay the foundation without timing, and then do a 90-minute timed simulation of 2 questions. Usually, you should record ideas and error-prone points, write code locally to verify, pay attention to code readability, boundary cases and clarify the meaning of the question first. The overall preparation period is controlled at 3-4 weeks: basics first, then DP/pictures, and finally focus on simulation and rhythm training.
After passing OA, the next step is to continue to answer Google high-frequency questions, and prepare for system design and Behavioral (answer with STAR + Google values).
Recommended additional resources:
- LeetCode Google Tagged + OA Discussion Forum
- Google Official Coding Practice
- Programhelp:supply OA ghostwriting, real-time idea assistance and full-process inclusive services, suitable for students who are short of time to pass the customs efficiently.
