Skip to content
Placement Papers - Free Placement Papers for Top CompaniesPlacement Papers - Free Placement Papers for Top CompaniesPlacement Papers

Google Placement Papers 2024

Overview

This page collects Google placement papers from 2024 with previous-year questions, solutions, and the 2024 exam pattern. It is useful when you want real drive history: what the OA looked like, which question types repeated, and how solutions were approached. Work through the papers below to build speed and accuracy, then compare against newer 2025 material so your prep matches both established Google patterns and the latest shifts.

Google Online Assessment 2024 exam pattern

Section Questions Time Difficulty Focus Areas
Coding Problem 1 1 30 min Medium Arrays, strings, two pointers
Coding Problem 2 1 30 min Hard Trees, graphs, dynamic programming
CS Fundamentals MCQs 18 30 min Medium DSA, time complexity, system design basics

Total: 20 questions, 90 minutes

Key Changes in 2024:

  • Basic system design questions introduced in online assessment
  • Increased emphasis on graph algorithms and dynamic programming
  • Time complexity analysis became more important
  • Product thinking questions added to behavioral round

Google Placement Papers 2024 - actual questions & solutions

This section contains practice questions styled on Google placement papers 2024 (previous-year pattern), with worked solutions. Use them as timed sectional drills - from student reports drives vary by college and role, so treat this as a high-signal practice bank, not an official paper dump.

Question 1: longest common prefix

Show solution

Problem Statement: Find the longest common prefix string amongst an array of strings.

Example:

Input: ["flower","flow","flight"]
Output: "fl"

Solution (Java):

public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) return "";
    String pref = strs[0];
    for (int i = 1; i < strs.length; i++) {
        while (!strs[i].startsWith(pref)) {
            pref = pref.substring(0, pref.length() - 1);
            if (pref.isEmpty()) return "";
        }
    }
    return pref;
}

Time Complexity: O(S)
Space Complexity: O(1)

Question 2: valid parentheses

Show solution

Problem Statement: Given a string of brackets, determine if it is valid.

Example:

Input: "()[]{}"
Output: true

Solution (Java):

public boolean isValid(String s) {
    Deque<Character> st = new ArrayDeque<>();
    Map<Character, Character> pair = Map.of(')', '(', ']', '[', '}', '{');
    for (char c : s.toCharArray()) {
        if (pair.containsValue(c)) st.push(c);
        else if (st.isEmpty() || st.pop() != pair.get(c)) return false;
    }
    return st.isEmpty();
}

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

Question 3: climbing stairs

Show solution

Problem Statement: You can climb 1 or 2 steps. How many distinct ways to climb n stairs?

Example:

Input: n = 4
Output: 5

Solution (Java):

public int climbStairs(int n) {
    if (n <= 2) return n;
    int a = 1, b = 2;
    for (int i = 3; i <= n; i++) {
        int c = a + b; a = b; b = c;
    }
    return b;
}

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

Question 4: first non-repeating character

Show solution

Problem Statement: Return the first non-repeating character in a string, or ‘_’ if none.

Example:

Input: "swiss"
Output: 'w'

Solution (Java):

public char firstUnique(String s) {
    int[] freq = new int[256];
    for (char c : s.toCharArray()) freq[c]++;
    for (char c : s.toCharArray()) if (freq[c] == 1) return c;
    return '_';
}

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

Question 5: reverse a string

Show solution

Problem Statement: Given a string, return it reversed.

Example:

Input: "placement"
Output: "tnemecalp"

Solution (Java):

public String reverse(String s) {
    return new StringBuilder(s).reverse().toString();
}

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

Question 6: detect cycle in linked list

Show solution

Problem Statement: Return true if the linked list has a cycle.

Example:

Input: 3→2→0→-4→(back to 2)
Output: true

Solution (Java):

public boolean hasCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

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

Question 7: binary tree level order

Show solution

Problem Statement: Return the level-order traversal of a binary tree.

Example:

Input: [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Solution (Java):

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    Queue<TreeNode> q = new ArrayDeque<>();
    q.add(root);
    while (!q.isEmpty()) {
        int sz = q.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < sz; i++) {
            TreeNode n = q.poll();
            level.add(n.val);
            if (n.left != null) q.add(n.left);
            if (n.right != null) q.add(n.right);
        }
        res.add(level);
    }
    return res;
}

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

Question 8

Q8: Which protocol is connection-oriented at the transport layer?

Solution:

TCP is connection-oriented; UDP is connectionless.

Answer: TCP

Question 9

Q9: Time complexity of binary search on a sorted array of n elements is?

Solution:

Each step halves the search space → O(log n).

Answer: O(log n)

Question 10

Q10: Which normal form removes transitive dependency?

Solution:

1NF: atomic values. 2NF: no partial dependency. 3NF: no transitive dependency.

Answer: 3NF

Question 11

Q11: In OOP, hiding internal details and showing only essential features is called?

Solution:

This is the definition of Encapsulation (often paired with abstraction in interviews).

Answer: Encapsulation

Hiring volume

  • Total Hires: 500+ freshers across India offices
  • Software Engineer L3: 450+ selections
  • Product Manager: 30+ selections
  • Data Scientist: 20+ selections
  • Growth: 15% increase from 2023

Salary packages

  • Software Engineer L3: ₹30-45 LPA
  • Product Manager: ₹35-60 LPA
  • Data Scientist: ₹40-80 LPA
  • 15% increase from 2023 packages

Process changes

  • System design basics introduced in OA
  • Extended behavioral round
  • Faster decision making (6-8 weeks)
  • More remote opportunities

Coding Problems:

  • Increased focus on dynamic programming (40% of problems)
  • Graph algorithms became more common (30%)
  • Array/string manipulation (30%)

System Design:

  • Basic scalability concepts
  • Database design basics
  • API design principles

Key insights from 2024 Google Online Assessment

  1. Coding Section is Critical: Must solve both problems correctly with optimal solutions to advance
  2. System Design Basics: Introduced in online assessment for entry-level roles - focus on scalability basics
  3. Time Management: 90 minutes for 20 questions requires excellent speed and accuracy
  4. Preparation Strategy: Practice 15-20 previous year papers - focus on graph problems and string manipulation
  5. Googleyness: Behavioral round emphasizes collaboration, innovation, and problem-solving approach
  6. Difficulty Level: Google interviews rated 3.4-3.5/5 difficulty - most challenging among FAANG companies
  7. CS Fundamentals: MCQs test deep understanding of DSA, time complexity, and system design basics
  8. Product Thinking: Product thinking questions added to behavioral round
  9. Competitive Process: Only 15-20% of candidates cleared online assessment

Google 2024 interview experiences

Based on candidate experiences from 2024 Google interviews:

2024 Interview Process:

  1. Online Assessment (90 minutes): 2 coding problems + 18 CS fundamentals MCQs
  2. Technical Phone Screen (45-60 minutes): Coding problems, algorithm discussions
  3. Onsite Interviews (4-5 rounds, 45 minutes each):
  • Coding rounds (2-3): Algorithms, data structures, problem-solving
  • System Design round: For experienced candidates
  • Behavioral round: “Googleyness” - collaboration, innovation, impact

Common 2024 Interview Topics:

  • Coding: Graph algorithms, dynamic programming, string manipulation, tree problems
  • System Design: URL shortener, distributed systems basics, scalability
  • Behavioral: Collaboration examples, innovation stories, problem-solving approach
  • Product Thinking: Design products, identify competitors, improve existing products

2024 Interview Questions Examples:

  • “Design a URL Shortener” (System Design)
  • “Serialize and Deserialize Binary Tree” (Coding)
  • “Choose a product you like and explain how you would identify its competitors” (Product)
  • “Design a voice assistant product for kids” (Product Design)

Success Tips:

  • Strong coding performance is essential - solve problems optimally with clean code
  • Practice explaining your thought process clearly
  • Prepare examples demonstrating collaboration and innovation
  • Focus on “Googleyness” - show how you think about problems and impact
  • Practice system design basics even for entry-level roles
  • Be ready for product thinking questions

Difficulty Rating: 3.4-3.5/5 (Most challenging among FAANG)

For detailed interview experiences, visit Google Interview Experience page.

Preparation tips for Google 2024 pattern

  1. Master Coding Fundamentals: Focus on solving 2 coding problems optimally - graph algorithms, DP, string manipulation
  2. Practice Previous Year Papers: Solve Google OA papers from 2020-2024 to understand patterns
  3. Time Management: Practice completing 2 coding problems in 60 minutes, 18 MCQs in 30 minutes
  4. CS Fundamentals: Deep understanding of DSA, time complexity analysis, system design basics
  5. System Design Basics: Learn scalability concepts, distributed systems fundamentals
  6. Mock Tests: Take timed practice tests to improve speed and accuracy
  7. LeetCode Practice: Solve 200+ LeetCode problems focusing on Google tag (medium-hard difficulty)
  8. Googleyness Preparation: Prepare examples demonstrating collaboration, innovation, and impact
  9. Product Thinking: Practice product design questions and competitor analysis
  10. Master Dynamic Programming: Practice 50+ DP problems covering all patterns
  11. Graph Algorithms: Focus on BFS, DFS, shortest paths, and topological sort
  12. Time Complexity: Always analyze and optimize time/space complexity

Download 2024 Placement Papers

Google 2024 paper 1

Complete 2024 online assessment with coding problems and MCQs

Google 2024 paper 2

Additional 2024 questions with detailed solutions

2024 coding examples

Collection of 2024 coding problems with solutions

Preparation tips for Google 2024

Based on 2024 Online Assessment Pattern:

  1. Master Coding Fundamentals: Focus on solving 2 coding problems optimally - graph algorithms, DP, string manipulation
  2. Practice Previous Year Papers: Solve Google OA papers from 2020-2024 to understand patterns
  3. Time Management: Practice completing 2 coding problems in 60 minutes, 18 MCQs in 30 minutes
  4. CS Fundamentals: Deep understanding of DSA, time complexity analysis, system design basics
  5. System Design Basics: Learn scalability concepts, distributed systems fundamentals
  6. Mock Tests: Take timed practice tests to improve speed and accuracy
  7. LeetCode Practice: Solve 200+ LeetCode problems focusing on Google tag (medium-hard difficulty)
  8. Googleyness Preparation: Prepare examples demonstrating collaboration, innovation, and impact
  9. Product Thinking: Practice product design questions and competitor analysis

Comments & Suggestions

Similar companies

Amazon · Microsoft · Meta · Apple · Netflix · LinkedIn