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

Zomato Placement Papers 2025

Overview

This page is a working set of Zomato placement papers from 2025: from student reports questions, the 2025 online assessment pattern, and step-by-step solutions. Use it to see what Zomato actually asked in the latest cycle, how hard the rounds were, and which themes (DSA, system design, aptitude, or role-specific topics) mattered most. Practice the problems below under timed conditions, then cross-check with the interview and preparation guides if you are targeting an upcoming Zomato drive.

Zomato Online Assessment 2025 pattern

Section Questions Time Difficulty Focus Areas
Coding Problems 2-3 60-80 min Medium-Hard Arrays, trees, graphs, DP
Debugging 1-2 20-30 min Medium Code fixes, logic errors

Total: 3-5 problems, 90-120 minutes
Platform: HackerRank or Zomato’s internal platform
Languages Allowed: Java, C++, Python, Go
Success Rate: ~10-15% cleared OA and advanced to interviews

Zomato Placement Papers 2025 - actual questions & solutions

This section contains real coding questions from Zomato placement papers 2025 based on candidate experiences from GeeksforGeeks, LeetCode, and interview forums.

Question 1: two sum problem

Q1: Given an array of integers and a target sum, find two numbers that add up to the target.

Problem Statement: Return indices of the two numbers such that they add up to target.

Example:

Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explanation: nums[0] + nums[1] = 2 + 7 = 9

Solution (Python):

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


# Test case
nums = [2, 7, 11, 15]
target = 9
print(twoSum(nums, target))  # Output: [0, 1]

Time Complexity: O(n)
Space Complexity: O(n)
Algorithm: Hash Map approach

Question 2: coin change problem

Q2: Find the minimum number of coins needed to make a given amount.

Problem Statement: Given coins of different denominations and a total amount, find the minimum number of coins needed.

Example:

Input: coins = [1, 2, 5], amount = 11
Output: 3
Explanation: 11 = 5 + 5 + 1

Solution (Python):

def coinChange(coins, amount):
    dp = [amount + 1] * (amount + 1)
    dp[0] = 0


    for i in range(1, amount + 1):
        for coin in coins:
            if coin <= i:
                dp[i] = min(dp[i], dp[i - coin] + 1)


    return dp[amount] if dp[amount] <= amount else -1


# Test case
coins = [1, 2, 5]
amount = 11
print(coinChange(coins, amount))  # Output: 3

Time Complexity: O(amount × coins.length)
Space Complexity: O(amount)
Algorithm: Dynamic Programming (Bottom-up)

Question 3: merge intervals

Q3: Merge all overlapping intervals in a collection of intervals.

Problem Statement: Given an array of intervals, merge all overlapping intervals.

Example:

Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Intervals [1,3] and [2,6] overlap, merge into [1,6]

Solution (Python):

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


# Test case
intervals = [[1,3],[2,6],[8,10],[15,18]]
print(merge(intervals))  # Output: [[1,6],[8,10],[15,18]]

Time Complexity: O(n log n)
Space Complexity: O(n)
Algorithm: Sort and merge

Question 4: longest palindromic substring

Q4: Find the longest palindromic substring in a given string.

Problem Statement: Given a string, find the longest substring that is a palindrome.

Example:

Input: "babad"
Output: "bab" or "aba"

Solution (Python):

def longestPalindrome(s):
    def expand(l, r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return s[l+1:r]


    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


# Test case
s = "babad"
print(longestPalindrome(s))  # Output: "bab" or "aba"

Time Complexity: O(n²)
Space Complexity: O(1)
Algorithm: Expand around center

Question 5: debugging question - array rotation

Q5: Debug the code that rotates an array to the right by k positions.

Buggy Code:

def rotate(nums, k):
    n = len(nums)
    k = k % n
    for i in range(k):
        nums.insert(0, nums.pop())

Issues:

  1. Inefficient for large arrays (O(nk) time complexity)
  2. Works but can be optimized

Optimized Solution:

def rotate(nums, k):
    n = len(nums)
    k = k % n


    # Reverse entire array
    nums.reverse()
    # Reverse first k elements
    nums[:k] = reversed(nums[:k])
    # Reverse remaining elements
    nums[k:] = reversed(nums[k:])


# Alternative: Using extra space (simpler)
def rotate_simple(nums, k):
    n = len(nums)
    k = k % n
    nums[:] = nums[-k:] + nums[:-k]

Time Complexity: O(n)
Space Complexity: O(1) for reverse method, O(n) for simple method

Q9: Longest Increasing Subsequence - 2025 Real Question

Problem: Given an integer array nums, return the length of the longest strictly increasing subsequence.

Example:

Input: nums = [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101]

Solution (Java):

public int lengthOfLIS(int[] nums) {
    int[] dp = new int[nums.length];
    Arrays.fill(dp, 1);
    int max = 1;


    for (int i = 1; i < nums.length; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
        max = Math.max(max, dp[i]);
    }


    return max;
}

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

Q10: Course Schedule - 2025 Real Question

Problem: There are a total of numCourses courses you have to take. Some courses have prerequisites. Return true if you can finish all courses.

Example:

Input: numCourses = 2, prerequisites = [[1,0]]
Output: true

Solution (Java):

public boolean canFinish(int numCourses, int[][] prerequisites) {
    List<List<Integer>> graph = new ArrayList<>();
    for (int i = 0; i < numCourses; i++) {
        graph.add(new ArrayList<>());
    }


    int[] indegree = new int[numCourses];
    for (int[] edge : prerequisites) {
        graph.get(edge[1]).add(edge[0]);
        indegree[edge[0]]++;
    }


    Queue<Integer> queue = new LinkedList<>();
    for (int i = 0; i < numCourses; i++) {
        if (indegree[i] == 0) {
            queue.offer(i);
        }
    }


    int count = 0;
    while (!queue.isEmpty()) {
        int course = queue.poll();
        count++;
        for (int next : graph.get(course)) {
            indegree[next]--;
            if (indegree[next] == 0) {
                queue.offer(next);
            }
        }
    }


    return count == numCourses;
}

Time Complexity: O(V + E), Space Complexity: O(V + E)

Expected hiring

  • Total Hires: 250+ freshers
  • SDE-1: 225+ selections
  • SDE-2: 25+ selections
  • Locations: Gurugram, Bengaluru, hybrid/remote

Salary packages

  • SDE-1: ₹18-25 LPA
  • SDE-2: ₹28-35 LPA
  • Senior SDE: ₹50-65 LPA

Question trends

  • Medium: 50% of questions
  • Hard: 50% of questions
  • Focus: Optimal solutions required
Q6: Product of Array Except Self - 2025 Real Question

Problem: Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]. You must write an algorithm that runs in O(n) time and without using the division operator.

Example:

Input: nums = [1,2,3,4]
Output: [24,12,8,6]

Solution (Java):

public int[] productExceptSelf(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];


    // Left pass
    result[0] = 1;
    for (int i = 1; i < n; i++) {
        result[i] = result[i - 1] * nums[i - 1];
    }


    // Right pass
    int right = 1;
    for (int i = n - 1; i >= 0; i--) {
        result[i] *= right;
        right *= nums[i];
    }


    return result;
}

Time Complexity: O(n), Space Complexity: O(1) excluding output array

Q7: Container With Most Water - 2025 Real Question

Problem: You are given an integer array height of length n. Find two lines that together with the x-axis form a container, such that the container contains the most water.

Example:

Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49

Solution (Java):

public int maxArea(int[] height) {
    int left = 0, right = height.length - 1;
    int maxArea = 0;


    while (left < right) {
        int width = right - left;
        int area = Math.min(height[left], height[right]) * width;
        maxArea = Math.max(maxArea, area);


        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }


    return maxArea;
}

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

Q8: Find Peak Element - 2025 Real Question

Problem: A peak element is an element that is strictly greater than its neighbors. Given a 0-indexed integer array nums, find a peak element, and return its index.

Example:

Input: nums = [1,2,3,1]
Output: 2

Solution (Java):

public int findPeakElement(int[] nums) {
    int left = 0, right = nums.length - 1;


    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }


    return left;
}

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

Key insights from 2025 Zomato Online Assessment

  1. Coding Section is Critical: Must solve 2-3 coding problems correctly to advance
  2. Advanced Topics: More focus on DP, Graphs, and Design problems
  3. Optimization: Emphasis on optimal solutions (time/space complexity)
  4. System Design: More detailed for SDE-1 roles - food delivery systems
  5. Food Delivery Context: Questions often relate to Zomato’s food delivery domain
  6. Company Values: Strong focus on behavioral assessment
  7. Time Management: 2-3 problems in 90-120 minutes requires excellent speed
  8. Debugging: Always included - practice debugging skills thoroughly
  9. Success Rate: Only 10-15% cleared OA and advanced to interviews

Zomato 2025 interview experiences

Based on recent candidate experiences from 2025 Zomato interviews:

2025 Interview Process:

  1. Online Assessment (90-120 minutes): 2-3 coding problems + 1-2 debugging questions
  2. Technical Phone Screen (45-60 minutes): Coding problems, algorithm discussions
  3. Onsite Interviews (4-5 rounds, 45-60 minutes each):
  • Coding rounds (2-3): Algorithms, data structures, problem-solving
  • System Design round: Food delivery systems for SDE-1+ roles
  • Behavioral round: Problem-solving approach, teamwork, impact

2025 Interview Trends:

  • Increased emphasis on food delivery system design even for SDE-1 roles
  • More focus on optimal solutions with better complexity analysis
  • Enhanced behavioral questions about company values and impact
  • Questions about real-time systems and scalability

Common 2025 Interview Topics:

  • Coding: Arrays, strings, trees, graphs, dynamic programming, shortest path algorithms
  • System Design: Food delivery systems (order matching, restaurant recommendations, real-time tracking)
  • Debugging: Code fixes, logic errors, performance issues
  • Behavioral: Problem-solving examples, teamwork, impact on business metrics

2025 Interview Questions Examples:

  • Two Sum Problem
  • Design Zomato’s order matching system (System Design)
  • Design Zomato’s restaurant recommendation engine (System Design)
  • Real-time tracking system design

Success Tips:

  • Strong coding performance is essential - solve problems optimally
  • Practice debugging skills - this section is always included
  • Learn food delivery system design - order matching, recommendations, real-time tracking
  • Prepare examples demonstrating problem-solving and business impact
  • Practice explaining your thought process clearly
  • Focus on time management - 2-3 problems in 90-120 minutes

For detailed interview experiences from 2025, visit Zomato Interview Experience page.

Preparation tips for Zomato 2025 pattern

  1. Master Coding Fundamentals: Focus on solving 2-3 coding problems correctly - arrays, trees, graphs, DP
  2. Practice Previous Year Papers: Solve Zomato OA papers from 2020-2025 to understand evolving patterns
  3. Time Management: Practice completing 2-3 coding problems in 60-80 minutes, debugging in 20-30 minutes
  4. Debugging Practice: Practice debugging code - identify and fix logic errors, performance issues
  5. System Design Mastery: Learn food delivery system design - order matching, recommendations for SDE-1+
  6. LeetCode Practice: Solve 200+ LeetCode problems focusing on arrays, strings, trees, graphs (medium-hard difficulty)
  7. Food Delivery Focus: Practice problems related to food delivery scenarios
  8. Mock Tests: Take timed practice tests to improve speed and accuracy
  9. Graph Algorithms: Master graph algorithms - shortest path, matching algorithms
  10. Dynamic Programming: Practice DP problems - frequently asked
  11. Optimization Focus: Emphasize optimal solutions with better time/space complexity

Comments & Suggestions

2024 papers

Coding questions

Interview experience

Preparation guide

Zomato hub

Online assessment

HR interview questions

Similar companies

Swiggy · Flipkart · Paytm · Phonepe · Meesho · Blinkit