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

Parameter	Requirement
Degree	B.Tech / M.Tech / MS / PhD
Branches	All branches accepted; CS/IT strongly preferred
Minimum CGPA	No official cutoff; competitive candidates have 8.0+
Backlogs	Zero; any history of backlogs is a flag
Graduation Year	2026 for New Grad; 2024-2025 with ≤ 1 year exp also welcome
Competitive Programming	Strong signal, ICPC regionalist, LeetCode Knight+

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

Section	Questions	Time	Difficulty
Coding Problem 1	1	25 min	Easy-Medium
Coding Problem 2	1	35 min	Medium
Coding Problem 3	1	30 min	Medium-Hard

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

Component	Amount (per year)
Base Salary	₹20 – 28 LPA
Signing Bonus	₹2 – 5 L (one-time)
Annual Performance Bonus	15-20% of base
RSU Grant (4-year vest)	₹20 – 35 L total
Total CTC (Year 1)	₹35 – 48 LPA
In-hand Monthly (approx)	₹1.4 – 1.9 L

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

Year	CGPA Cutoff	Top CP Achievement Equiv.
2023	~8.0 (campus)	Codeforces Expert (1600+)
2024	~8.0	LeetCode Knight (1800+)
2025	~7.5	Codeforces Expert
2026 (expected)	~7.5	LeetCode Knight+

---

Frequently Asked Questions

Q: Does Google hire freshers directly from Indian campuses? A: Yes, and more actively than most people think. Google has an active campus program covering IITs, NITs, BITS, and select private universities. The STEP Internship targets 2nd-year students; New Grad hiring targets final year students. Off-campus applications are also accepted year-round, don't let your college name hold you back.

Q: How many LeetCode problems should I solve before a Google interview? A: Here's the honest answer: quality beats quantity every time. 200 carefully chosen problems with deep understanding beats 400 problems done passively. Focus on understanding patterns: sliding window, two pointers, tree traversals, graph algorithms, DP recurrences. If you can explain WHY each approach works, you're ready.

Q: Is system design required for New Grad SWE at Google? A: Sometimes, especially for candidates with strong internship experience or M.Tech/MS students. Google L3 (New Grad) interviews may substitute a system design round with an additional coding or "Googleyness" round, depending on the hiring committee's direction.

Q: What is the typical Google interview timeline from application to offer? A: Brace yourself, 8-12 weeks total. Resume review (2 weeks) → phone screen (1 week to schedule) → onsite (1-2 weeks to schedule) → hiring committee review (2-3 weeks) → team matching (1-2 weeks) → offer. The committee review is the longest and most nerve-wracking step. Patience is part of the Google process.

Q: Does Google consider students with active backlogs? A: No. Even a single cleared backlog is flagged during background verification. Candidates with previously cleared backlogs have been rescinded offers in some documented cases.

Q: Can I negotiate the Google offer? A: Yes, and Google actually expects you to negotiate. RSU grants and signing bonuses are the most movable. Base salary has less flexibility. Having a competing offer from Meta, Microsoft, or Amazon dramatically improves your negotiation position. Don't leave money on the table.

Q: What programming language does Google prefer? A: No official preference. Python, Java, C++, Go are all used. Python is most common in interviews for its brevity. If you use Python, be aware of edge cases with integer overflow (not an issue in Python, but mention awareness).

Q: What's the difference between SWE and SWE-II at Google? A: L3 = New Grad SWE. L4 = SWE-II (typically 2-4 years experience, or exceptional new grads). Some candidates are leveled at L4 directly if they have a relevant Master's degree and strong internship experience. This significantly increases starting comp.

Q: How do I prepare for the "Googleyness" interview? A: Study what Google says it means (intellectual humility, collaborative nature, comfort with ambiguity). Prepare stories about mentoring, disagreeing constructively, working across teams, and times you were genuinely curious about something and went deep on it.

Q: Is the Google interview open-book or closed-book? A: Closed-book. You can use the Google Docs editor they provide, but no internet, no documentation, no IDE autocomplete. This is why practicing in a plain editor is essential.

---

This guide has helped 3,500+ students prepare for Google's legendary interview process. Share it with your study group, the algorithm patterns section alone is worth gold.

Also check: Amazon Placement Papers 2026 | Microsoft Placement Papers 2026 | Flipkart Placement Papers 2026 | Razorpay Placement Papers 2026

---

You May Also Like

• Intel Placement Papers 2026 | Interview Questions & Preparation Guide
• Cisco Placement Papers 2026 with Solutions, Aptitude, Technical & Coding
• Razorpay Placement Papers 2026, Complete Guide with Solutions
• PhonePe Placement Papers 2026 | Freshers Exam Pattern, Syllabus & Questions