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.

2025 Updates

The 2025 Zomato placement process maintains focus on DSA and system design with enhanced emphasis on company values. The online assessment includes 2-3 coding problems and debugging questions. Practice these Zomato placement papers 2025 to prepare effectively.

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)

2025 hiring trends

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

Related resources

Zomato 2024 papers→

Previous year Zomato placement papers with DSA questions and solutions

Zomato coding questions→

Complete collection of Zomato coding problems with detailed solutions

Zomato interview experience→

Real interview experiences from candidates who cleared Zomato placement

Zomato preparation guide→

Comprehensive preparation strategy for Zomato placement process

Zomato main page→

Complete Zomato placement guide with eligibility, process, and salary

Zomato Online Assessment→

Complete guide to Zomato online assessment format and preparation

Zomato HR interview→

Common HR interview questions and answers for Zomato placement

Similar companies

Swiggy · Flipkart · Paytm · Phonepe · Meesho · Blinkit

---

Practice 2025 papers to stay updated!