Google India Placement Papers 2026

Meta Description: Get Google India placement papers 2026 with latest exam pattern, coding questions, interview tips, and preparation strategy. Crack Google SDE roles with PapersAdda!

---

Introduction

Google India is a dream destination for software engineers and fresh graduates across the country. Known for its cutting-edge technology, exceptional work culture, and lucrative compensation packages, Google hires top talent through rigorous campus placements and off-campus drives. This comprehensive guide covers everything you need to know about Google India's 2026 placement process, including exam patterns, sample questions, and proven preparation strategies.

---

Google India Exam & Interview Pattern 2026

Round	Type	Duration	Topics Covered
Round 1	Online Assessment (Coding)	90 mins	Data Structures, Algorithms, Problem Solving
Round 2	Technical Interview 1	45-60 mins	Coding, System Design basics, CS fundamentals
Round 3	Technical Interview 2	45-60 mins	Advanced algorithms, Problem-solving approach
Round 4	System Design (For experienced)	45-60 mins	Scalable systems, Architecture design
Round 5	Googliness Interview	45 mins	Behavioral, Cultural fit, Leadership principles

Key Highlights:

• Online assessment typically has 2 coding questions (medium-hard difficulty)
• Strong focus on data structures: Trees, Graphs, Dynamic Programming
• System design rounds for candidates with 2+ years experience
• Googliness round assesses collaboration, intellectual humility, and user focus

---

Practice Questions with Detailed Answers

Question 1: Two Sum Problem

Problem: Given an array of integers nums and an integer target, return indices of the two numbers that add up to target.

Solution:

def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

Time Complexity: O(n) | Space Complexity: O(n)

---

Question 2: Merge Intervals

Problem: Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals.

Solution:

def merge(intervals):
    if not intervals:
        return []
    
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    
    for current in intervals[1:]:
        if current[0] <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], current[1])
        else:
            merged.append(current)
    
    return merged

Time Complexity: O(n log n) | Space Complexity: O(n)

---

Question 3: LRU Cache Implementation

Problem: Design a Least Recently Used (LRU) cache with O(1) get and put operations.

Solution:

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity
    
    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]
    
    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

---

Question 4: Find Median from Data Stream

Problem: Implement a data structure that supports adding integers and finding the median in O(log n) time.

Solution:

import heapq

class MedianFinder:
    def __init__(self):
        self.small = []  # max heap (store negatives)
        self.large = []  # min heap
    
    def addNum(self, num):
        heapq.heappush(self.small, -num)
        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

---

Question 5: Word Break

Problem: Given a string s and a dictionary of strings wordDict, return true if s can be segmented into words from wordDict.

Solution:

def wordBreak(s, wordDict):
    wordSet = set(wordDict)
    dp = [False] * (len(s) + 1)
    dp[0] = True
    
    for i in range(1, len(s) + 1):
        for j in range(i):
            if dp[j] and s[j:i] in wordSet:
                dp[i] = True
                break
    
    return dp[len(s)]

Time Complexity: O(n²) | Space Complexity: O(n)

---

Question 6: Trapping Rain Water

Problem: Given n non-negative integers representing elevation map, compute how much water it can trap after raining.

Solution:

def trap(height):
    if not height:
        return 0
    
    left, right = 0, len(height) - 1
    left_max, right_max = height[left], height[right]
    water = 0
    
    while left < right:
        if left_max < right_max:
            left += 1
            left_max = max(left_max, height[left])
            water += left_max - height[left]
        else:
            right -= 1
            right_max = max(right_max, height[right])
            water += right_max - height[right]
    
    return water

---

Question 7: Longest Substring Without Repeating Characters

Problem: Given a string s, find the length of the longest substring without repeating characters.

Solution:

def lengthOfLongestSubstring(s):
    char_set = set()
    left = 0
    max_length = 0
    
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_length = max(max_length, right - left + 1)
    
    return max_length

---

Question 8: Clone Graph

Problem: Given a reference of a node in a connected undirected graph, return a deep copy of the graph.

Solution:

from collections import deque

class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors else []

def cloneGraph(node):
    if not node:
        return None
    
    old_to_new = {}
    queue = deque([node])
    old_to_new[node] = Node(node.val)
    
    while queue:
        current = queue.popleft()
        for neighbor in current.neighbors:
            if neighbor not in old_to_new:
                old_to_new[neighbor] = Node(neighbor.val)
                queue.append(neighbor)
            old_to_new[current].neighbors.append(old_to_new[neighbor])
    
    return old_to_new[node]

---

Question 9: Course Schedule (Topological Sort)

Problem: There are numCourses courses labeled from 0 to numCourses-1. Given prerequisites, determine if you can finish all courses.

Solution:

from collections import defaultdict, deque

def canFinish(numCourses, prerequisites):
    graph = defaultdict(list)
    in_degree = [0] * numCourses
    
    for course, prereq in prerequisites:
        graph[prereq].append(course)
        in_degree[course] += 1
    
    queue = deque([i for i in range(numCourses) if in_degree[i] == 0])
    courses_taken = 0
    
    while queue:
        course = queue.popleft()
        courses_taken += 1
        for next_course in graph[course]:
            in_degree[next_course] -= 1
            if in_degree[next_course] == 0:
                queue.append(next_course)
    
    return courses_taken == numCourses

---

Question 10: Design Hit Counter

Problem: Design a hit counter which counts the number of hits received in the past 5 minutes.

Solution:

from collections import deque

class HitCounter:
    def __init__(self):
        self.hits = deque()
    
    def hit(self, timestamp):
        self.hits.append(timestamp)
    
    def getHits(self, timestamp):
        while self.hits and self.hits[0] <= timestamp - 300:
            self.hits.popleft()
        return len(self.hits)

---

Question 11: Binary Tree Maximum Path Sum

Problem: Given a non-empty binary tree, find the maximum path sum.

Solution:

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def maxPathSum(root):
    max_sum = float('-inf')
    
    def max_gain(node):
        nonlocal max_sum
        if not node:
            return 0
        
        left_gain = max(max_gain(node.left), 0)
        right_gain = max(max_gain(node.right), 0)
        
        price_newpath = node.val + left_gain + right_gain
        max_sum = max(max_sum, price_newpath)
        
        return node.val + max(left_gain, right_gain)
    
    max_gain(root)
    return max_sum

---

Question 12: Serialize and Deserialize Binary Tree

Problem: Design an algorithm to serialize and deserialize a binary tree.

Solution:

class Codec:
    def serialize(self, root):
        def encode(node):
            if not node:
                return 'N,'
            return str(node.val) + ',' + encode(node.left) + encode(node.right)
        return encode(root)
    
    def deserialize(self, data):
        def decode(values):
            val = next(values)
            if val == 'N':
                return None
            node = TreeNode(int(val))
            node.left = decode(values)
            node.right = decode(values)
            return node
        
        values = iter(data.split(','))
        return decode(values)

---

Preparation Strategy

Step 1: Master Data Structures (Weeks 1-4)

• Arrays, Strings, Linked Lists
• Stacks, Queues, Heaps
• Trees (Binary, BST, AVL, Red-Black)
• Graphs (BFS, DFS, Dijkstra, Union-Find)
• Hash Tables, Tries

Step 2: Algorithm Patterns (Weeks 5-8)

• Two Pointers, Sliding Window
• Binary Search variations
• Dynamic Programming (Top-down & Bottom-up)
• Greedy Algorithms
• Backtracking

Step 3: Practice on LeetCode (Weeks 9-12)

• Solve 200+ problems (Easy → Medium → Hard)
• Focus on Google-tagged questions
• Practice mock interviews weekly

Step 4: System Design (For experienced candidates)

• Design scalable systems (URL shortener, Twitter)
• Study distributed systems concepts
• Practice with mock design interviews

Step 5: Behavioral Preparation

• Prepare STAR format stories
• Research Google's culture and values
• Practice Googliness questions

---

Resources & Books to Follow

Coding Practice

• LeetCode - Primary platform for Google questions
• InterviewBit - Structured learning path
• HackerRank - Additional practice

Books

• "Cracking the Coding Interview" by Gayle Laakmann McDowell
• "Elements of Programming Interviews" by Adnan Aziz
• "Introduction to Algorithms" (CLRS)
• "Designing Data-Intensive Applications" by Martin Kleppmann

Online Resources

• Google Tech Dev Guide (official)
• YouTube: ByteByteGo for System Design
• Educative.io: Grokking the Coding Interview

---

Google India Salary & Package Details 2026

Role	Experience	CTC (LPA)	Breakdown
Software Engineer L3	0-2 years	₹25-35 LPA	Base + Stocks + Bonus
Software Engineer L4	2-5 years	₹40-60 LPA	Base + Stocks + Bonus
Senior Engineer L5	5+ years	₹70-100 LPA	Base + Stocks + Bonus
Staff Engineer L6	8+ years	₹1.2-1.8 Cr	Base + Stocks + Bonus

Additional Benefits:

• Health insurance for family
• Free meals and snacks
• Gym membership
• Education reimbursement
• Generous parental leave

---

Conclusion

Cracking Google India requires consistent effort, strategic preparation, and strong problem-solving skills. Start early, practice daily, and focus on understanding concepts rather than memorizing solutions. Remember, Google values not just technical excellence but also your ability to collaborate and think from the user's perspective.

Ready for more? Explore more placement papers and interview guides on PapersAdda.com - your ultimate destination for job preparation resources!

---

Keywords: Google placement papers 2026, Google interview questions, Google coding questions, Google recruitment process, Google India careers