Google Placement Papers 2026, Complete Guide with Solutions

Google receives 3 million+ applications per year and hires fewer than 1%. That's the reality. But here's what the numbers don't tell you: the process is structured, the patterns are learnable, and candidates who prepare strategically have a dramatically higher success rate.

This guide has been shaped by feedback from 400+ candidates who interviewed at Google, including those who got the offer and those who learned from rejection. We know you're anxious. Google's interview has an almost mythical reputation. But strip away the mystique, and it's a well-defined process testing specific skills. If you practice the exact patterns in this guide, you'll walk in prepared, not intimidated.

Google's India engineering centers in Hyderabad and Bengaluru are significant hiring hubs, working on products like Google Pay, Search, YouTube, and Maps that directly serve the Indian market. Engineers here build foundational infrastructure (Spanner, Borg, Colossus) and consumer products alike. The "Googley" culture, intellectual humility, collaboration, data-driven thinking, and genuine curiosity, means Google interviews are notably less behavioral and more deeply technical than Amazon or Microsoft.

The 2025-2026 cycle shows renewed aggressive hiring, especially in AI/ML and infrastructure roles. Google is filling positions NOW. This guide gives you the real picture, process, patterns, solved questions, and tactical advice that actually works. Bookmark this page, you'll come back to it multiple times before your interview.

Eligibility Criteria, What Google Actually Looks For

Google does not publish a formal CGPA cutoff, but recruiter screening at most campus drives in India effectively filters below 8.0. Competitive programming achievements (IOI, ICPC, Google Code Jam top percentile) can override academic performance.

The Exact Selection Process (2026)

1. Resume Screening / Campus Shortlisting, Based on academics, projects, internships, CP achievements
2. Online Coding Test (some campuses), 3 problems in 90 minutes, platform varies (HackerEarth or Google's internal system)
3. Phone Screen, 45 minutes, one interviewer, 1-2 coding problems on Google Docs or CoderPad
4. Onsite / Virtual Onsite Loop, 4-5 rounds:
   • Round 1: Coding (Data Structures)
   • Round 2: Coding (Algorithms)
   • Round 3: Coding (Advanced, Graphs/DP)
   • Round 4: System Design (required for experienced; sometimes for New Grad)
   • Round 5: Googleyness & Leadership (behavioral + light coding)
5. Hiring Committee Review, Your packet (interview scorecards + resume) goes to a committee, not just the hiring manager
6. Team Matching, After committee approval, you're matched to a team
7. Compensation & Offer

The Hiring Committee is Google-specific and means your interviewers do not make the final decision. A separate group reviews standardized scorecards. This removes individual interviewer bias but adds time, the full process can take 8-12 weeks.

Exam Pattern, Online Coding Test

Google's online test (where applicable) does not have MCQs or aptitude sections, it is purely algorithmic. Each problem has multiple test cases; partial credit is given. The focus is on correctness, then efficiency.

Solved Questions, The Patterns Google Tests Again and Again

This is where your prep gets real. The questions below mirror the exact difficulty and patterns that appear in Google interviews. Solve these thoroughly and you'll recognize the patterns on interview day.

Section 1: Coding, Data Structures

Q1. Valid Parentheses (Extended)

Given a string containing just characters (, ), {, }, [, ], determine if the input string is valid. An input string is valid if open brackets are closed in the correct order.

Example: "([{}])" → true, "([)]" → false

def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in mapping:
            top = stack.pop() if stack else '#'
            if mapping[char] != top:
                return False
        else:
            stack.append(char)

    return not stack

# Time: O(n)  Space: O(n)

Q2. Find Median from Data Stream

Design a data structure that supports adding integers from a data stream and finding the median efficiently.

import heapq

class MedianFinder:
    def __init__(self):
        self.small = []  # max-heap (inverted min-heap) for lower half
        self.large = []  # min-heap for upper half

    def addNum(self, num):
        heapq.heappush(self.small, -num)

        # Balance: ensure small's max <= large's min
        if self.small and self.large and (-self.small[0]) > self.large[0]:
            heapq.heappush(self.large, -heapq.heappop(self.small))

        # Balance sizes: small can have at most 1 more than large
        if len(self.small) > len(self.large) + 1:
            heapq.heappush(self.large, -heapq.heappop(self.small))
        if len(self.large) > len(self.small):
            heapq.heappush(self.small, -heapq.heappop(self.large))

    def findMedian(self):
        if len(self.small) > len(self.large):
            return -self.small[0]
        return (-self.small[0] + self.large[0]) / 2.0

# addNum: O(log n)  findMedian: O(1)

Two-heap insight: Lower half in a max-heap, upper half in a min-heap. Maintain size balance and heap property. This is a Google favorite because it tests creative data structure combination.

Q3. Course Schedule (Topological Sort)

There are n courses labeled 0 to n-1. You are given prerequisites [a, b] meaning you must take course b before course a. Return true if you can finish all courses.

from collections import defaultdict, deque

def can_finish(numCourses, prerequisites):
    graph = defaultdict(list)
    indegree = [0] * numCourses

    for course, pre in prerequisites:
        graph[pre].append(course)
        indegree[course] += 1

    queue = deque([i for i in range(numCourses) if indegree[i] == 0])
    completed = 0

    while queue:
        node = queue.popleft()
        completed += 1
        for neighbor in graph[node]:
            indegree[neighbor] -= 1
            if indegree[neighbor] == 0:
                queue.append(neighbor)

    return completed == numCourses

# Time: O(V + E)  Space: O(V + E)
# If completed < numCourses, there's a cycle → can't finish

Section 2: Coding, Algorithms

Q4. Trapping Rain Water

Given n non-negative integers representing an elevation map where each bar has width 1, compute how much water it can trap after raining.

Example: height = [0,1,0,2,1,0,1,3,2,1,2,1] → Output: 6

def trap(height):
    if not height:
        return 0

    left, right = 0, len(height) - 1
    left_max = right_max = 0
    water = 0

    while left < right:
        if height[left] < height[right]:
            if height[left] >= left_max:
                left_max = height[left]
            else:
                water += left_max - height[left]
            left += 1
        else:
            if height[right] >= right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1

    return water

# Time: O(n)  Space: O(1) - two-pointer approach

Two-pointer insight: Water at any position = min(max_left, max_right) - height[position]. Move the pointer with the smaller boundary inward since that boundary is the limiting factor.

Q5. Serialize and Deserialize Binary Tree

Design an algorithm to serialize and deserialize a binary tree. No restriction on format.

class Codec:
    def serialize(self, root):
        """BFS level-order serialization"""
        if not root:
            return ""
        from collections import deque
        result = []
        queue = deque([root])
        while queue:
            node = queue.popleft()
            if node:
                result.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                result.append("null")
        return ",".join(result)

    def deserialize(self, data):
        if not data:
            return None
        from collections import deque
        vals = data.split(",")
        root = TreeNode(int(vals[0]))
        queue = deque([root])
        i = 1
        while queue and i < len(vals):
            node = queue.popleft()
            if vals[i] != "null":
                node.left = TreeNode(int(vals[i]))
                queue.append(node.left)
            i += 1
            if i < len(vals) and vals[i] != "null":
                node.right = TreeNode(int(vals[i]))
                queue.append(node.right)
            i += 1
        return root

Q6. Sliding Window Maximum

Given an integer array nums and a sliding window of size k, return the max of each window.

from collections import deque

def max_sliding_window(nums, k):
    dq = deque()  # stores indices, decreasing order of values
    result = []

    for i, num in enumerate(nums):
        # Remove elements outside window
        while dq and dq[0] < i - k + 1:
            dq.popleft()
        # Remove smaller elements (they'll never be max)
        while dq and nums[dq[-1]] < num:
            dq.pop()
        dq.append(i)

        if i >= k - 1:
            result.append(nums[dq[0]])

    return result

# Time: O(n)  Space: O(k)
# Monotonic deque maintains decreasing order - front is always the current max

Section 3: Advanced Algorithms (Hard-Level), Where Google Separates the Best

Keep reading, Google's onsite regularly features Hard-level problems. Unlike Amazon which focuses on Medium, you MUST be comfortable at this level to crack Google.

Q7. Regular Expression Matching

Given input string s and pattern p, implement regex matching where . matches any single character and * matches zero or more of the preceding element.

def is_match(s, p):
    m, n = len(s), len(p)
    # dp[i][j] = does s[:i] match p[:j]?
    dp = [[False] * (n + 1) for _ in range(m + 1)]
    dp[0][0] = True

    # Handle patterns like a*, a*b*, a*b*c* matching empty string
    for j in range(1, n + 1):
        if p[j-1] == '*':
            dp[0][j] = dp[0][j-2]  # zero occurrences of preceding

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if p[j-1] == '*':
                # Zero occurrences of preceding character
                dp[i][j] = dp[i][j-2]
                # One or more occurrences: preceding char matches current
                if p[j-2] == '.' or p[j-2] == s[i-1]:
                    dp[i][j] |= dp[i-1][j]
            elif p[j-1] == '.' or p[j-1] == s[i-1]:
                dp[i][j] = dp[i-1][j-1]

    return dp[m][n]

# Time: O(m*n)  Space: O(m*n)

Q8. Word Ladder II

Find all shortest transformation sequences from beginWord to endWord using a word dictionary.

This is a BFS + DFS problem. BFS builds the shortest-path DAG (tracking each word's parents at the same BFS level), then DFS reconstructs all paths through the DAG.

Key insight: Only explore each word at one BFS level, once a word is visited, don't re-add it to the queue from a later level. This ensures all paths found are shortest.

Section 4: System Design, Think at Google Scale

Google system design rounds expect depth in distributed systems, consistency models, and large-scale architecture. This is where experienced candidates shine and fresh grads can differentiate themselves.

Q9. Design Google Search

Scale: ~8.5 billion searches/day, 3 billion users, ~1 billion websites indexed.

Key Components:

Web Crawler → Document Store → Indexer → Inverted Index
                                              ↓
User Query → Query Parser → Query Expansion
                                 ↓
                        Index Lookup → Ranking (PageRank + ML)
                                           ↓
                                 Result Snippets → SERP

Inverted Index: Maps each word to a list of (docId, position, frequency). Stored in distributed key-value store (Bigtable). Sharded by word hash.

Ranking Signals: PageRank (graph-based authority), TF-IDF, query-document relevance (BERT embeddings), freshness, click-through rate, location signals.

Serving: Query parsed → spell-corrected → expanded with synonyms → parallel lookups across index shards → merge → rank → snippet generation → cache (memcached for popular queries).

Caching: >50% of queries are repeated. 3-tier cache: in-process, distributed (memcached), CDN for results.

Q10. Design YouTube

Scale: 500 hours of video uploaded/minute, 2 billion monthly users.

Upload Path:

1. Client uploads raw video to distributed storage (GCS)
2. Video processing pipeline: transcoding to multiple resolutions (360p, 720p, 1080p, 4K) via parallel workers
3. Metadata (title, tags, owner) stored in SQL; view counts in Bigtable (heavy writes)
4. CDN (Google's own network) caches popular videos globally

Streaming:

• HLS/DASH adaptive streaming, client selects quality based on bandwidth
• Segments stored in GCS, served via CDN edge nodes
• Recommendation: collaborative filtering + watch history + trending signals

Trade-offs: Strong consistency for upload confirmation; eventual consistency acceptable for view counts.

Section 5: Googleyness & Behavioral Questions

Q11. "Tell me about a time you had to work with someone very different from you." (Googleyness)

Google's "Googleyness" criteria includes: collaborative nature, comfort with ambiguity, proactiveness, genuine interest in technology, and treating colleagues with respect regardless of hierarchy.

Strong answer structure: Describe the difference concretely (working style, background, technical opinion). Explain how you adapted. Show the collaboration produced something better than either of you would have alone.

Q12. "How do you stay current with technology changes?"

Google wants intellectually curious engineers. Strong answers reference: reading research papers (arxiv), contributing to open source, experimenting with new tools (not just reading about them), attending conferences, participating in competitive programming.

Q13. "Give an example of a time your technical decision was wrong. What happened?"

This tests intellectual humility, a core Google value. Don't minimize the mistake. Describe what you learned, what you'd do differently, and whether you proactively fixed the downstream consequences.

Q14. "What's the most interesting algorithm or paper you've read recently?"

Genuine curiosity test. Be specific, a vague answer like "I read about transformers" won't cut it. Reference a specific paper (e.g., "Flash Attention 2, the I/O-aware tiling approach to reduce HBM bandwidth was surprisingly elegant"), explain why you found it interesting, and connect it to something practical.

Q15. "Why Google specifically? You could work at any company."

Avoid generic answers. Connect to something real: a specific Google product you use and want to improve, a Google research publication you admire, or a technical problem (reliability at 5-9s, ML at scale) that only Google's infrastructure makes possible to work on.

Section 6: Aptitude (Campus-Level Pre-screen)

Q16. Find the number of ways to climb n stairs if you can take 1 or 2 steps at a time.

Solution: This is Fibonacci. f(1)=1, f(2)=2, f(n) = f(n-1) + f(n-2). For n=10: 89 ways.

Q17. A clock shows 3:15. What is the angle between the hour and minute hands?

Solution: Minute hand at 90°. Hour hand at 3 hours + 15 min = 3×30 + 15×0.5 = 90 + 7.5 = 97.5°. Angle = 97.5 - 90 = 7.5°.

Q18. Two pipes can fill a tank in 12 and 15 hours respectively. A drain pipe empties it in 10 hours. If all three are open, in how many hours does the tank fill?

Solution: Net rate = 1/12 + 1/15 - 1/10 = 5/60 + 4/60 - 6/60 = 3/60 = 1/20. Time = 20 hours.

Salary & CTC Breakdown (New Grad SWE L3, India 2026), The Numbers That Make It Worth It

Google's RSUs vest quarterly after the first year cliff, a more engineer-friendly schedule than Amazon. For US-based New Grad roles, total comp is $180,000–$220,000 (base + bonus + RSU), among the highest in the industry.

At the L4 (Software Engineer II) level, India comp reaches ₹55-80 LPA. L5 (Senior SWE) often exceeds ₹1.2 Cr total comp with strong equity.

10 Proven Interview Tips (From Candidates Who Got the Offer)

1. Google interviews run on Google Docs, practice there. No syntax highlighting, no autocomplete. You must write clean code mentally. Practice in a plain text environment at least 20% of your prep time.

2. Think aloud at every step. Google interviewers score communication as heavily as correctness. Say "I'm considering a greedy approach here, but let me check if it works for this edge case...", silence is a yellow flag.

3. Master graph algorithms. BFS, DFS, Dijkstra, Bellman-Ford, Union-Find, Topological Sort, Google asks graph questions far more than Amazon.

4. Don't jump to code. Spend 5-8 minutes on approach, examples, and edge cases before typing a single line. Most candidates who rush to code fail to handle edge cases.

5. Target LeetCode Hard for final prep. Unlike Amazon (Medium focus), Google's onsite regularly features Hard-level problems. Aim for 50+ Hard problems solved before the interview.

6. System design: know Bigtable, Spanner, MapReduce, Borg. These are Google's foundational systems. Reading the original papers (freely available) signals genuine interest.

7. Ask clarifying questions that show systems thinking. "Is this read-heavy or write-heavy?" and "What's the consistency requirement?" are stronger questions than "Can input be empty?"

8. CGPA matters less at Google than competitive programming rank. If you have a strong CodeForces or ICPC record, lead with that. Google's sourcing team specifically scouts CP leaderboards.

9. The Hiring Committee means rejection isn't personal. Even good interviews can be rejected by the HC if the packet is borderline. Reapplication after 6 months with stronger signals is common and welcomed.

10. Know your Big-O instinctively. Google interviewers will ask "can you do better?" after every solution. Know the theoretical lower bounds for sorting (Ω(n log n)), searching (O(log n) with sorted), etc.

Previous Year Cutoffs, Know Where You Stand

🎯 Live Mock Test, May 2026 Edition

5 original questions written by Aditya Sharma, calibrated to the Google 2026 batch difficulty. Click any option to lock your answer; solutions reveal after.