Google Coding Questions

Practice with 30+ Google placement paper coding questions covering DSA problems, system design concepts, and technical fundamentals. These questions are representative of what you’ll encounter in Google’s online assessment and technical interviews.

What’s Included:

• 24 Coding Problems: Easy, Medium, and Hard level questions with Python solutions
• 6 System Design Questions: Basic and advanced system design problems
• Detailed Solutions: Step-by-step code explanations and time complexity analysis
• Practice Tips: Strategies for solving Google interview questions effectively

Google Placement Papers 2024→

Access 2024 Google placement paper questions with solutions and exam pattern analysis.

Google Placement Papers 2025→

Practice latest 2025 Google placement paper questions with updated patterns.

Complete Google guide→

Access complete Google placement papers guide with eligibility, process, and preparation strategy.

Coding problems

Easy Level

Two Sum

Given array of integers and target, return indices of two numbers that add up to target.

Example: [2,7,11,15], target=9 → [0,1]

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

Valid Parentheses

Check if string with brackets is valid.

Example: “()[]” → true, “([)]” → false

def isValid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping.values():
            stack.append(char)
        elif char in mapping:
            if not stack or stack.pop() != mapping[char]:
                return False
        else:
            return False
    return not stack

Merge Two Sorted Lists

Merge two sorted linked lists.

Example: [1,2,4] + [1,3,4] → [1,1,2,3,4,4]

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def mergeTwoLists(l1, l2):
    dummy = ListNode()
    curr = dummy
    while l1 and l2:
        if l1.val < l2.val:
            curr.next = l1
            l1 = l1.next
        else:
            curr.next = l2
            l2 = l2.next
        curr = curr.next
    curr.next = l1 or l2
    return dummy.next

Best Time to Buy and Sell Stock

Find maximum profit from buying and selling stock once.

Example: [7,1,5,3,6,4] → 5 (buy at 1, sell at 6)

def maxProfit(prices):
    min_price = float('inf')
    max_profit = 0
    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)
    return max_profit

Contains Duplicate

Check if array contains any duplicates.

Example: [1,2,3,1] → true, [1,2,3,4] → false

def containsDuplicate(nums):
    return len(nums) != len(set(nums))

Reverse Linked List

Reverse a singly linked list.

Example: 1→2→3→4→5 → 5→4→3→2→1

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_temp = curr.next
        curr.next = prev
        prev = curr
        curr = next_temp
    return prev

Medium Level

Add Two Numbers (Linked List)

Add numbers represented as linked lists.

Example: (2→4→3) + (5→6→4) = (7→0→8) Represents: 342 + 465 = 807

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def addTwoNumbers(l1, l2):
    dummy = ListNode()
    curr = dummy
    carry = 0
    while l1 or l2 or carry:
        v1 = l1.val if l1 else 0
        v2 = l2.val if l2 else 0
        val = v1 + v2 + carry
        carry = val // 10
        curr.next = ListNode(val % 10)
        curr = curr.next
        l1 = l1.next if l1 else None
        l2 = l2.next if l2 else None
    return dummy.next

Longest Substring Without Repeating

Find length of longest substring without repeating chars.

Example: “abcabcbb” → 3 (substring “abc”)

def lengthOfLongestSubstring(s):
    seen = {}
    left = 0
    max_len = 0
    for right, char in enumerate(s):
        if char in seen and seen[char] >= left:
            left = seen[char] + 1
        seen[char] = right
        max_len = max(max_len, right - left + 1)
    return max_len

Binary Tree Level Order Traversal

Return level order traversal of binary tree.

Example: [3,9,20,null,null,15,7] → [[3],[9,20],[15,7]]

from collections import deque
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def levelOrder(root):
    if not root:
        return []
    result, queue = [], deque([root])
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(level)
    return result

Longest Palindromic Substring

Find the longest palindromic substring in a string.

Example: “babad” → “bab” or “aba”

def longestPalindrome(s):
    def expand(left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return s[left+1:right]
    result = ""
    for i in range(len(s)):
        odd = expand(i, i)
        even = expand(i, i+1)
        result = max(result, odd, even, key=len)
    return result

Container With Most Water

Find two lines that together with x-axis form a container with most water.

Example: [1,8,6,2,5,4,8,3,7] → 49

def maxArea(height):
    left, right = 0, len(height) - 1
    max_area = 0
    while left < right:
        area = min(height[left], height[right]) * (right - left)
        max_area = max(max_area, area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return max_area

3Sum

Find all unique triplets that sum to zero.

Example: [-1,0,1,2,-1,-4] → [[-1,-1,2],[-1,0,1]]

def threeSum(nums):
    nums.sort()
    result = []
    for i in range(len(nums)-2):
        if i > 0 and nums[i] == nums[i-1]:
            continue
        left, right = i+1, len(nums)-1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if s < 0:
                left += 1
            elif s > 0:
                right -= 1
            else:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
    return result

Product of Array Except Self

Return array where each element is product of all other elements (without division).

Example: [1,2,3,4] → [24,12,8,6]

def productExceptSelf(nums):
    n = len(nums)
    result = [1] * n
    prefix = 1
    for i in range(n):
        result[i] = prefix
        prefix *= nums[i]
    suffix = 1
    for i in range(n-1, -1, -1):
        result[i] *= suffix
        suffix *= nums[i]
    return result

Hard Level

Median of Two Sorted Arrays

Find median with O(log(min(m,n))) complexity.

Example: [1,3], [2] → 2.0

def findMedianSortedArrays(nums1, nums2):
    A, B = nums1, nums2
    m, n = len(A), len(B)
    if m > n:
        A, B, m, n = B, A, n, m
    imin, imax, half = 0, m, (m + n + 1) // 2
    while imin <= imax:
        i = (imin + imax) // 2
        j = half - i
        if i < m and B[j-1] > A[i]:
            imin = i + 1
        elif i > 0 and A[i-1] > B[j]:
            imax = i - 1
        else:
            if i == 0: max_of_left = B[j-1]
            elif j == 0: max_of_left = A[i-1]
            else: max_of_left = max(A[i-1], B[j-1])
            if (m + n) % 2 == 1:
                return max_of_left
            if i == m: min_of_right = B[j]
            elif j == n: min_of_right = A[i]
            else: min_of_right = min(A[i], B[j])
            return (max_of_left + min_of_right) / 2.0

Serialize/Deserialize Binary Tree

Design algorithm to serialize and deserialize binary tree. Choose your format but ensure it works for any tree structure.

class Codec:
    def serialize(self, root):
        vals = []
        def dfs(node):
            if not node:
                vals.append('#')
                return
            vals.append(str(node.val))
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return ' '.join(vals)
    def deserialize(self, data):
        vals = iter(data.split())
        def dfs():
            val = next(vals)
            if val == '#':
                return None
            node = TreeNode(int(val))
            node.left = dfs()
            node.right = dfs()
            return node
        return dfs()

Edit Distance

Find minimum operations to convert one string to another (insert, delete, replace).

def minDistance(word1, word2):
    m, n = len(word1), len(word2)
    dp = [[0]*(n+1) for _ in range(m+1)]
    for i in range(m+1):
        for j in range(n+1):
            if i == 0:
                dp[i][j] = j
            elif j == 0:
                dp[i][j] = i
            elif word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
    return dp[m][n]

LRU Cache

Design and implement a data structure for Least Recently Used (LRU) cache with O(1) get and put operations.

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)

Trapping Rain Water

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

Example: [0,1,0,2,1,0,1,3,2,1,2,1] → 6

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

Word Ladder

Find length of shortest transformation sequence from beginWord to endWord, where you can change one letter at a time.

from collections import deque
def ladderLength(beginWord, endWord, wordList):
    wordSet = set(wordList)
    if endWord not in wordSet:
        return 0
    queue = deque([(beginWord, 1)])
    visited = {beginWord}
    while queue:
        word, length = queue.popleft()
        if word == endWord:
            return length
        for i in range(len(word)):
            for c in 'abcdefghijklmnopqrstuvwxyz':
                new_word = word[:i] + c + word[i+1:]
                if new_word in wordSet and new_word not in visited:
                    visited.add(new_word)
                    queue.append((new_word, length + 1))
    return 0

Merge k Sorted Lists

Merge k sorted linked lists into one sorted linked list.

import heapq
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def mergeKLists(lists):
    heap = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    dummy = ListNode()
    curr = dummy
    while heap:
        val, idx, node = heapq.heappop(heap)
        curr.next = node
        curr = curr.next
        if node.next:
            heapq.heappush(heap, (node.next.val, idx, node.next))
    return dummy.next

Longest Valid Parentheses

Find length of longest valid parentheses substring.

Example: “(()” → 2, “)()())” → 4

def longestValidParentheses(s):
    stack = [-1]
    max_len = 0
    for i, char in enumerate(s):
        if char == '(':
            stack.append(i)
        else:
            stack.pop()
            if not stack:
                stack.append(i)
            else:
                max_len = max(max_len, i - stack[-1])
    return max_len

System Design questions

Basic System Design

Design a URL Shortener (like bit.ly)

Requirements:

• Shorten long URLs to 6-8 character codes

• Redirect short URLs to original URLs

• Handle 100 million URLs per day

  Approach:

• Use base62 encoding for short codes

• Database: Store mapping of short code → long URL

• Cache: Use Redis for frequently accessed URLs

• Load balancer: Distribute traffic across servers

• Database sharding: Partition by hash of short code

Design a Distributed Cache

Requirements:

• Store key-value pairs in memory

• Support TTL (time-to-live) for cache entries

• Handle cache eviction (LRU policy)

• Scale to multiple servers

  Approach:

• Use consistent hashing for key distribution

• Implement LRU eviction per server

• Replication for high availability

• Cache invalidation strategies

Design a Rate Limiter

Requirements:

• Limit API requests per user/IP

• Support sliding window algorithm

• Handle 1 million requests per second

  Approach:

• Token bucket or sliding window algorithm

• Use Redis for distributed rate limiting

• Store counters with TTL

• Load balancer integration

Advanced System Design

Design a Search Engine

Requirements:

• Index billions of web pages

• Return relevant results in less than 100ms

• Handle 1 billion queries per day

  Approach:

• Web crawler for indexing

• Inverted index for fast lookups

• Ranking algorithm (PageRank, relevance)

• Distributed storage and processing

• Caching for popular queries

Design a Chat Application

Requirements:

• Real-time messaging

• Support 100 million users

• Message delivery guarantees

• Group chats and 1-on-1 chats

  Approach:

• WebSocket connections for real-time

• Message queue (Kafka) for reliability

• Database for message history

• Load balancer for WebSocket connections

• Push notifications for offline users

Design a Distributed Logging System

Requirements:

• Collect logs from millions of services

• Store logs for 30 days

• Support real-time log search

• Handle 1 TB logs per day

  Approach:

• Log aggregation service

• Distributed storage (HDFS, S3)

• Indexing for fast search (Elasticsearch)

• Stream processing for real-time analysis

Practice More Google Interview Questions →

Comments & Suggestions

Related resources

• Google Placement Papers - Complete guide with eligibility, process, and preparation strategy
• Google Placement Papers 2024 - Previous year questions and solutions
• Google Placement Papers 2025 - Latest questions and patterns
• Google Interview Experience - Real candidate stories and tips

Similar companies

Amazon · Microsoft · Meta · Apple · Netflix · LinkedIn