This single-file Google DSA sheet is beginner-friendly and structured to guide candidates from interview overview to hands-on practice, with high-impact coding questions organized by topic.
Designed for clarity and SEO, this Google DSA sheet starts with a crisp overview of Google’s interview rounds, then for each topic gives a 1–2 line explanation followed by an easy-to-skim table of must-practice questions that mirror Google-style interviews.
🔹 Google SDE Interview Process: Complete Overview
Understanding the end-to-end process helps you focus prep time effectively. Google’s hiring funnel has multiple stages, each testing different skills. Here’s the streamlined breakdown:
- Online Application – Submit your resume and cover letter. Recruiters review role fit, skills, and impact.
- Online Assessments – Typically 2 algorithm/DSA coding questions in 90 minutes. Focus on correctness, edge cases, and clean code.
- Technical Phone Screen (30–60 min) – Conducted on Google Meet or phone, focused on coding and DSA. Communicate trade-offs and complexity clearly.
- Onsite (4–6 rounds) – Mix of coding, system design (for L5+), and Googliness interviews. Expect ~45 minutes per round, mostly coding heavy.
- Behavioral / Googliness – Soft skills evaluation: collaboration, leadership, humility, and problem-solving mindset.
How to use this Google SDE sheet: pick one topic per day, read the 1–2 line gist to activate patterns, then work through the tables while coding, testing, and articulating your approaches out loud.
🔹 Basic Maths
Basic Math problems involve number manipulation, divisibility, digit operations, and fundamental arithmetic. Core patterns include counting digits, reversing numbers, checking primes, calculating GCD/HCF, and generating divisors. These problems appear frequently in Google and other tech interviews as warm-ups and help build a strong foundation for algorithmic thinking.
| Problem | Solution |
|---|---|
| Count Digits | |
| Reverse a Number | |
| Check Palindrome Number | |
| GCD / HCF | |
| Armstrong Numbers | |
| Print All Divisors | |
| Check for Prime |
🔹 Arrays
Arrays are contiguous blocks with O(1) index access; core patterns include prefix/suffix, two-pointers, and in-place transforms that appear across many Google interview problems.
| Problem | Solution |
|---|---|
| Counting Frequencies of Array Elements | |
| Highest/Lowest Frequency Element | |
| Find Peak Element | |
| Search in Rotated Sorted Array I | |
| Search in Rotated Sorted Array II | |
| Find Minimum in Rotated Sorted Array | |
| Times Array Has Been Rotated | |
| Single Element in a Sorted Array | |
| Row with Maximum 1’s | |
| Matrix Median | |
| Spiral Matrix | |
| Sort K-Sorted Array | |
| Replace Each Element by Its Rank |
🔹 Strings
Strings are arrays of characters, widely used for parsing, pattern matching, and hashing. Interview focus: sliding window, hashing, KMP/Z algorithms.
| Problem | Solution |
|---|---|
| Remove Outermost Parentheses | |
| Reverse Words / Palindrome Check | |
| Largest Odd Number in a String | |
| Longest Common Prefix | |
| Isomorphic String | |
| String Rotation Check | |
| Anagram Check | |
| Longest Substring Without Repeating Characters | |
| Longest Substring with ≤ K Distinct Characters | |
| Minimum Window Substring / Subsequence | |
| Subarray with K Different Integers | |
| Binary Subarray With Sum |
🔹 Sliding Window
Sliding Window techniques reduce time complexity for contiguous subarray and substring problems often involving frequency counts and dynamic windows.
| Problem | Solution |
|---|---|
| Sliding Window Maximum | |
| Minimum Size Subarray Sum | |
| Longest Substring Without Repeating Characters | |
| Longest Substring With At Most K Distinct Characters | |
| Permutation in String | |
| Find All Anagrams in a String | |
| Minimum Window Substring |
🔹 Two Pointer
Two Pointer techniques allow efficient traversal and search within sorted arrays or for partitioning problems using paired indices.
| Problem | Solution |
|---|---|
| Two Sum II – Input Array Is Sorted | |
| Valid Palindrome II | |
| Container with Most Water | |
| Sort Colors | |
| 3Sum | |
| 4Sum | |
| Partition Labels |
🔹 Greedy
Greedy Algorithms make locally optimal choices aiming for a global optimum, commonly tested in interval scheduling, knapsack, and assignment problems.
| Problem | Solution |
|---|---|
| Activity Selection Problem | |
| Fractional Knapsack Problem | |
| Job Scheduling Problem | |
| Minimum Number of Platforms Required | |
| Gas Station | |
| Candy | |
| Assign Cookies | |
| Greedy Florist | |
| Rearrange Characters |
🔹 Linked List
Linked Lists allow dynamic memory usage with O(1) insertion/deletion. Interviews test reversing, merging, and cycle detection patterns.
| Problem | Solution |
|---|---|
| Insert/Delete/Search Node | |
| Find Length of LL | |
| Middle of Linked List | |
| Reverse LL (Iterative & Recursive) | |
| Detect Loop, Find Start, Length of Loop | |
| Check Palindrome LL | |
| Segregate Odd/Even Nodes | |
| Remove Nth Node From End | |
| Delete Middle Node | |
| Sort LL / Sort 0-1-2 LL | |
| Intersection Point of Y LL | |
| Add 1 to Number in LL | |
| Add Two Numbers in LL | |
| Delete All Key Occurrences (DLL) | |
| Reverse in Groups of K | |
| Rotate LL | |
| Flatten Linked List | |
| Clone LL with Random Pointer |
🔹 Stack
Stacks and Queues follow LIFO and FIFO principles. Used in expression evaluation, monotonic structures, and BFS traversal.
| Problem | Solution |
|---|---|
| Infix ↔ Prefix / Postfix Conversions | |
| Next Greater / Smaller Element (I, II) | |
| Number of NGEs to Right | |
| Trapping Rainwater | |
| Sum of Subarray Minimums | |
| Stock Span Problem | |
| Asteroid Collision | |
| Sum of Subarray Ranges | |
| Remove K Digits | |
| Largest Rectangle in Histogram | |
| Maximal Rectangle | |
| Implement Stack Using Recursion (Sort / Reverse Stack) |
🔹 Queue
Stacks and Queues follow LIFO and FIFO principles. Used in expression evaluation, monotonic structures, and BFS traversal.
| Problem | Solution |
|---|---|
| Sliding Window Maximum (Deque) | |
| Rotten Oranges | |
| LRU Cache | |
| LFU Cache | |
| Implement Queue Using Stacks | |
| Celebrity Problem |
🔹 Binary Search/Searching
Searching related problems.
| Problem | Solution |
|---|---|
| Binary Search to Find X | |
| Lower Bound / Upper Bound | |
| Search Insert Position | |
| Floor / Ceil in Sorted Array | |
| First / Last Occurrence | |
| Count Occurrences in Sorted Array | |
| Binary Search on 2-D Matrix | |
| Square Root via Binary Search | |
| Nth Root via Binary Search | |
| Minimum Days to Make M Bouquets | |
| Koko Eating Bananas | |
| Smallest Divisor Given Threshold | |
| Capacity to Ship Packages in D Days | |
| Aggressive Cows | |
| Book Allocation | |
| Split Array – Largest Sum | |
| Kth Missing Positive Number | |
| Minimize Max Distance to Gas Station |
🔹 Hash
Hashing underpins O(1) average-time lookups and supports fast lookup-based solutions for many common interview problems.
| Problem | Solution |
|---|---|
| Hashing Theory | |
| Power Set (Bitmask ∪ Hash) | |
| Counting Bits to Flip A→B | |
| Number Appearing Odd Times | |
| XOR of Numbers L to R | |
| Two Numbers Appearing Odd Times |
🔹 Recursion
Recursion enables divide-and-conquer, backtracking, and problem decomposition used across many algorithmic problems.
| Problem | Solution |
|---|---|
| Print Numbers from 1 to N | |
| Factorial | |
| Fibonacci Number | |
| Sum of Digits | |
| Tower of Hanoi |
🔹 Backtracking
Backtracking is recursion with pruning for constraint satisfaction like puzzles, combinations, and permutations.
| Problem | Solution |
|---|---|
| N-Queens | |
| Sudoku Solver | |
| Rat in a Maze | |
| Word Search | |
| Combination Sum | |
| Permutations | |
| Subsets |
🔹 Dynamic Programming
Dynamic Programming (DP) optimizes recursive solutions with overlapping subproblems. Most Google DP questions revolve around subsequences, knapsack, and matrix path problems.
| Problem | Solution |
|---|---|
| Climbing Stairs / Frog Jump | |
| Maximum Sum of Non-Adjacent (House Robber) | |
| LIS (Classic & Binary Log N) | |
| Coin Change | |
| Unique Paths | |
| Edit Distance | |
| DP on Grids (Max Rectangle, Count Squares) | |
| DP on Stocks (Buy & Sell Variants) | |
| Matrix Chain / Partition DP | |
| Subset & Subsequence Patterns | |
| Palindrome Partitioning | |
| Word Break | |
| Expression Add Operators | |
| N Queen | |
| Rat in Maze | |
| M Coloring | |
| Sudoku Solver |
🔹 Tree
Trees represent hierarchical data. Interviews focus on DFS, BFS, recursion, serialization, and BST properties.
| Problem | Solution |
|---|---|
| Root-to-Node Path | |
| LCA (Binary Tree & BST) | |
| Maximum Width of Binary Tree | |
| Children Sum Property | |
| Nodes at Distance K | |
| Burn Binary Tree | |
| Count Nodes in Complete Binary Tree | |
| Construct Tree (Inorder + Pre/Post) | |
| Serialize / Deserialize Binary Tree | |
| Morris Preorder / Inorder | |
| Flatten Binary Tree to LL | |
| Search / Insert / Delete in BST | |
| Ceil / Floor in BST | |
| Kth Smallest / Largest in BST | |
| Check Valid BST | |
| Construct BST from Preorder | |
| Inorder Successor / Predecessor | |
| Merge Two BSTs | |
| Two-Sum in BST | |
| Recover Swapped BST | |
| Largest BST in Binary Tree |
🔹 Heap
Heaps support priority queues and enable efficient top-k, scheduling, and streaming median queries.
| Problem | Solution |
|---|---|
| Intro to Priority Queue / Min vs Max Heap | |
| Check Array Is Min-Heap | |
| Convert Min Heap to Max Heap | |
| Merge M Sorted Lists | |
| Sort K-Sorted Array (Heap) | |
| Kth Largest/Smallest via Heap | |
| Task Scheduler | |
| Hands of Straights | |
| Find Median From Data Stream |
🔹 Graph
Graphs model real-world networks. Key techniques: DFS/BFS, Union-Find, Topological Sort, and Dijkstra’s Algorithm.
| Problem | Solution |
|---|---|
| Graph Representation & Traversals (BFS/DFS) | |
| Number of Provinces | |
| Connected Components in Matrix | |
| Flood Fill / Number of Enclaves | |
| Rotten Oranges (Graph BFS) | |
| Cycle Detection (Undirected & Directed) | |
| 0/1 Matrix | |
| Surrounded Regions | |
| Word Ladder I & II | |
| Distinct Islands | |
| Bipartite Check | |
| Topological Sort / Kahn’s Algo | |
| Course Schedule I & II | |
| Eventual Safe States | |
| Alien Dictionary | |
| Dijkstra Variants (Network Delay Time) | |
| Minimum Spanning Tree (Prim / Kruskal) | |
| Disjoint Set Problems (Accounts Merge, Make Network Connected) | |
| Bridges, Articulation Point, Kosaraju |
🔹 Trie
Tries efficiently handle prefix-based searches and dictionary problems common in string-heavy interviews.
| Problem | Solution |
|---|---|
| Implement Trie (Insert, Search, Delete) | |
| Longest Common Prefix Using Trie | |
| Count Words Matching a Prefix | |
| Replace Words | |
| Maximum XOR of Two Numbers in Array | |
| Concatenated Words | |
| Word Squares |
🔹 Math
Math & Miscellaneous questions test overflow safety, numeric edge cases, and string-based arithmetic.
🔹 System Design & OOD (Coding)
System Design & Object-Oriented Design surfaces in mid-senior interviews—expect coding-heavy OOD and high-level trade-offs.
🔹 How to Follow This Google DSA Sheet
Consistency is the real differentiator in interview prep. Don’t try to finish everything in a week—pace yourself:
- Pick one topic at a time (Arrays → Strings → Linked List → …).
- Read the 1–2 line concept gist before solving questions.
- Start with brute force, then optimize—this mirrors how Google expects you to think.
- Code daily, even if it’s just 1–2 problems—consistency beats last-minute cramming.
- Track progress by marking solved questions and revisiting weak areas.
🔹 Final Motivation
Preparing for Google or any top tech company can feel overwhelming, but remember:
- Every solved problem builds your problem-solving muscle.
- Patterns repeat—mastering them will make hard problems feel familiar.
- Even if you get stuck, the act of debugging, re-thinking, and improving is the exact skill interviewers want to see.
Stay disciplined, stay patient, and trust the process—if you stick with this sheet, you’ll be interview-ready with confidence. 🚀
🔹 FAQs:
Q1. How many questions should be completed before interviews?
Quality over quantity: mastering 150–200 mixed-difficulty problems with patterns (arrays, strings, graphs, DP) is a strong baseline.
Q2. What languages are preferred?
Any mainstream language (C++, Java, Python, Go) works—choose the one that allows writing correct solutions quickly and cleanly.
Q3. How to practice “Googliness”?
Prepare STAR stories on collaboration, ownership, ambiguity, conflict resolution, and learning from failures; keep answers concise and reflective.
Q4. Should brute force be discussed?
Yes—outline brute force to show problem framing, then iterate to optimal; always analyze complexity and test edge cases.
Q5. How to use this Google DSA sheet?
Study one topic per day, solve questions in the tables, and attach personal solution links to convert this into a navigable prep hub.