Ola Placement Papers 2025

Overview

This page is a working set of Ola placement papers from 2025: from student reports questions, the 2025 online assessment pattern, and step-by-step solutions. Use it to see what Ola 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 Ola drive.

2025 OA Updates

The 2025 Ola Online Assessment maintains the 90-120 minute format with 2-3 DSA problems. New additions include more debugging questions and scenario-based coding problems.

Ola Online Assessment 2025 pattern

The 2025 exam pattern remains similar to 2024. For detailed exam pattern, see 2024 Papers.

Note: The pattern may have minor variations. Check the latest updates from the company.

Ola Placement Papers 2025 - actual questions & solutions

This section contains practice questions styled on Ola placement papers 2025 (recent-cycle 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: rotate array right by k

Show solution

Problem Statement: Rotate the array to the right by k steps.

Example:

Input: [1,2,3,4,5,6,7], k = 3
Output: [5,6,7,1,2,3,4]

Solution (Java):

public void rotate(int[] nums, int k) {
    k %= nums.length;
    reverse(nums, 0, nums.length - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
}
void reverse(int[] a, int l, int r) {
    while (l < r) { int t = a[l]; a[l++] = a[r]; a[r--] = t; }
}

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

Question 2: 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 3: 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 4: 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 5: 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 6: merge two sorted lists

Show solution

Problem Statement: Merge two sorted linked lists and return a new sorted list.

Example:

Input: 1→2→4 , 1→3→4
Output: 1→1→2→3→4→4

Solution (Java):

public ListNode mergeTwoLists(ListNode a, ListNode b) {
    ListNode dummy = new ListNode(0), cur = dummy;
    while (a != null && b != null) {
        if (a.val <= b.val) { cur.next = a; a = a.next; }
        else { cur.next = b; b = b.next; }
        cur = cur.next;
    }
    cur.next = (a != null) ? a : b;
    return dummy.next;
}

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

Question 7: maximum subarray sum

Show solution

Problem Statement: Find the contiguous subarray with the largest sum.

Example:

Input: [-2, 1, -3, 4, -1, 2, 1, -5, 4]
Output: 6  // [4, -1, 2, 1]

Solution (Java):

public int maxSubArray(int[] nums) {
    int best = nums[0], cur = nums[0];
    for (int i = 1; i < nums.length; i++) {
        cur = Math.max(nums[i], cur + nums[i]);
        best = Math.max(best, cur);
    }
    return best;
}

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

Question 8

Q8: Virtual memory is typically implemented using?

Solution:

OS uses demand paging (and sometimes segmentation) to implement virtual memory.

Answer: Demand paging

Question 9

Q9: Which normal form removes transitive dependency?

Solution:

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

Answer: 3NF

Question 10

Q10: 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 11

Q11: Which data structure uses FIFO order?

Solution:

FIFO = First In First Out → Queue. Stack is LIFO.

Answer: Queue

2025 hiring trends

Hiring volume

• Total Hires: 600+ freshers expected
• SDE-1 Selections: 350+ selections expected
• SDE-2 Selections: 180+ selections expected
• Growth: 20% increase from 2024

Salary packages

• SDE-1: ₹18-22 LPA (slight increase from 2024)
• SDE-2: ₹24-30 LPA
• Senior SDE: ₹40-55 LPA
• Competitive packages with ESOPs

Process changes

• Virtual interviews standard
• System design rounds mandatory for all SDE roles
• Emphasis on real-world problem-solving
• Faster offer processing (2-4 weeks)

2025 question trends

DSA Focus:

• Similar distribution to 2024, with increased graph problems
• Arrays: 30% of problems
• Trees: 25% of problems
• Graphs: 25% of problems (increased)
• Dynamic Programming: 15% of problems
• Strings: 5% of problems

New Topics:

• More questions on system design basics
• API design discussions
• Database design concepts
• Scalability patterns

Difficulty:

• Maintained Medium-Hard difficulty
• Focus on optimal solutions

Key insights from 2025 Ola Online Assessment

1. Coding Section is Critical: Must solve 2-3 coding problems correctly to advance
2. Virtual Interviews: Became standard - candidates should be comfortable with online coding platforms
3. System Design Rounds: Now mandatory - all SDE roles require system design knowledge
4. Real-World Problem-Solving: Emphasis on ride matching, payment systems, scalability
5. Time Management: 2-3 problems in 90-120 minutes requires excellent speed
6. Ride-Hailing Focus: Problems often relate to ride matching, routing, logistics
7. Success Rate: Only 10-15% cleared OA and advanced to interviews
8. Interview Rating: 4.1/5 based on candidate experiences
9. Difficulty: 66% moderate, 29% easy, 4% hard
10. Process Duration: 74% completed in less than 2 weeks

Ola 2025 interview experiences

Based on recent candidate experiences from 2025 Ola interviews:

2025 Interview Process:

1. Online Assessment (90-120 minutes): 2-3 coding problems
2. Technical Phone Screen (45-60 minutes): Coding problems, algorithm discussions
3. Onsite/Virtual Interviews (3-4 rounds, 45-60 minutes each):

• Round 1: Problem-solving (DSA-based) - 1 hour
• Round 2: High-Level Design (HLD) and Low-Level Design (LLD) - 1 hour
• Round 3: Managerial Round - 45 minutes (behavioral questions)

2025 Interview Trends:

• Increased emphasis on system design for all SDE roles (not just SDE-2+)
• More focus on ride-hailing specific problems (matching, routing, logistics)
• Enhanced behavioral questions about Ola values and innovation
• Questions about AI agents and Kruti (Ola’s AI assistant)
• Virtual interviews became standard - comfort with online platforms essential

Common 2025 Interview Topics:

• Coding: Arrays, trees, graphs, dynamic programming, string manipulation
• System Design: Ride matching systems, payment gateways, notification systems, scalability
• Low-Level Design: SOLID principles, design patterns, class design, logging libraries
• High-Level Design: System architecture, microservices, database design, API design
• Behavioral: Ola values (customer focus, innovation, ownership), strengths/weaknesses, learning agility

2025 Interview Questions Examples:

• “Design and implement a logging library with multiple appenders” (LLD)
• “Design Ola’s internal notification system” (HLD)
• “Determine if a user is within a specific area to show available cabs” (Coding)
• “Sort an array containing 0s, 1s, and 2s while maintaining original order” (Coding)
• “Design Ola’s ride matching system” (System Design)
• “How would you approach learning about a task you’re completely unfamiliar with?” (Behavioral)

Success Tips:

• Strong coding performance is essential - solve problems optimally
• Practice system design for ride-hailing systems - matching, routing, payments
• Learn SOLID principles and design patterns for LLD rounds
• Prepare examples demonstrating Ola values - customer focus, innovation, ownership
• Practice explaining your thought process clearly
• Focus on time management - 2-3 problems in 90-120 minutes
• Be ready for both HLD and LLD discussions
• Get comfortable with virtual interview platforms

Interview Experience Rating: 4.1/5 (based on 321+ experiences) Process Duration: 74% completed in less than 2 weeks

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

Preparation tips for Ola 2025 pattern

1. Master DSA Fundamentals: Focus on arrays, trees, graphs, and dynamic programming
2. Practice Optimal Solutions: Time and space complexity matter - optimize your solutions
3. Learn System Design Basics: Ride matching, payment systems, scalability, notification systems
4. Prepare Behavioral Stories: Align with Ola values using STAR format - customer focus, innovation, ownership
5. Practice Previous Year Papers: Solve Ola OA papers from 2020-2025 to understand evolving patterns
6. Time Management: Practice completing 2-3 coding problems in 90-120 minutes
7. SOLID Principles: Master SOLID principles and design patterns for LLD rounds
8. LeetCode Practice: Solve 200+ LeetCode problems focusing on arrays, strings, trees, graphs (medium-hard difficulty)
9. Virtual Interview Practice: Get comfortable with online coding platforms
10. Ride-Hailing Knowledge: Understand ride matching algorithms and logistics optimization
11. Mock Tests: Take timed practice tests to improve speed and accuracy
12. Understand Ola’s Business: Ride matching, payments, AI agents (Kruti), electric mobility

Download 2025 Placement Papers

Ola 2025 paper 1→

Latest Ola OA 2025 paper with 3 coding problems and solutions.

Ola 2025 paper 2→

Ola OA 2025 paper with DSA problems and system design questions.

2025 System Design examples→

System design problems from 2025 Ola interviews.

Comments & Suggestions

Related resources

2024 papers→

Coding questions→

Interview experience→

Preparation guide→

Ola hub→

Similar companies

Uber · Zomato · Swiggy · Flipkart · Paytm · Zoho