Meesho SDE-1 Online Assessment Interview Experience (Remote) - Rejected

• Company: Meesho
• Role: Software Development Engineer 1 (SDE-1)
• Interview Type: Online Assessment (Remote)
• Duration: 90 Minutes
• Number of Rounds Attended: 1
• Coding Questions: 3
• Difficulty Level: Medium
• Result: Rejected

A few weeks ago, I took the Meesho SDE-1 Online Assessment, which was the first stage of the hiring process. The test was conducted remotely and consisted of three coding problems to be solved within 90 minutes.

None of the questions were impossible, but quick pattern recognition and solving them within the time limit was the real challenge. The questions weren't completely new, two of them were based on problems, i did seen before during my DSA preparation. Even if a problem looks familiar, solving it within the time limit is a completely different challenge. Under interview pressure, you still need to identify the correct approach quickly and implement it without making mistakes.

I solved two of the three questions. Unfortunately, that wasn't enough to move to the next stage and my application was rejected. From what I've observed, Meesho's online assessments are highly competitive and candidates often need very strong performance to get shortlisted. Similar experiences shared by other candidates also indicate that the OA usually emphasizes medium to hard DSA questions rather than language-specific concepts.

The assessment was entirely focused on coding. There were no multiple-choice questions or core computer science questions in my round. The biggest challenge wasn't writing code—it was choosing the right algorithm quickly and managing time effectively.

Coding Questions

Question 1 : Integer to Roman

The first question was Integer to Roman, a classic implementation problem.

If you've solved it before, it's fairly straightforward. The key is understanding how Roman numerals work, especially the special values like IV (4), IX (9), XL (40), XC (90), CD (400) and CM (900). A greedy approach using predefined symbol-value pairs works well here.

Topics Covered

• Greedy
• String Manipulation
• Implementation

Difficulty: Easy to Medium

using System;
using System.Text;

public class Solution
{
    public string IntToRoman(int num)
    {
        int[] values = {
            1000, 900, 500, 400,
            100, 90, 50, 40,
            10, 9, 5, 4, 1
        };

        string[] symbols = {
            "M", "CM", "D", "CD",
            "C", "XC", "L", "XL",
            "X", "IX", "V", "IV", "I"
        };

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < values.Length; i++)
        {
            while (num >= values[i])
            {
                result.Append(symbols[i]);
                num -= values[i];
            }
        }
        return result.ToString();
    }
}

Question 2 : Maximum Earnings From Taxi

The second question was based on Maximum Earnings From Taxi, which is a well-known dynamic programming problem.

Initially, it may look like a greedy scheduling problem, but choosing rides greedily doesn't always produce the maximum profit. The optimal solution involves sorting the rides and combining Dynamic Programming with Binary Search to efficiently find the next compatible ride.

If you've practiced weighted interval scheduling or similar DP problems, you'll probably recognize the pattern quickly.

Topics Covered

• Dynamic Programming
• Binary Search
• Sorting

Difficulty: Medium

using System;
using System.Collections.Generic;

public class Solution
{
    public long MaxTaxiEarnings(int n, int[][] rides)
    {
        // Sort rides by start time
        Array.Sort(rides, (a, b) => a[0].CompareTo(b[0]));
        int m = rides.Length;
        long[] dp = new long[m + 1];
        // Store all start times for binary search
        int[] startTimes = new int[m];
        for (int i = 0; i < m; i++)
        {
            startTimes[i] = rides[i][0];
        }
        // Process from last ride to first
        for (int i = m - 1; i >= 0; i--)
        {
            int nextRide = LowerBound(startTimes, rides[i][1]);
            long earnings = (rides[i][1] - rides[i][0]) + rides[i][2];
            dp[i] = Math.Max(
                dp[i + 1],                  // Skip current ride
                earnings + dp[nextRide]     // Take current ride
            );
        }
        return dp[0];
    }

    // Binary Search: Find first ride with start >= target
    private int LowerBound(int[] arr, int target)
    {
        int left = 0;
        int right = arr.Length;
        while (left < right)
        {
            int mid = left + (right - left) / 2;
            if (arr[mid] < target)
                left = mid + 1;
            else
                right = mid;
        }
        return left;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Solution solution = new Solution();
        // Example 1
        int[][] rides1 =
        {
            new int[] {2, 5, 4},
            new int[] {1, 5, 1}
        };
        Console.WriteLine("Example 1");
        Console.WriteLine(solution.MaxTaxiEarnings(5, rides1));
        Console.WriteLine();
        // Example 2
        int[][] rides2 =
        {
            new int[] {2, 3, 6},
            new int[] {8, 9, 8},
            new int[] {5, 9, 7},
            new int[] {8, 9, 1},
            new int[] {2, 9, 2},
            new int[] {9, 10, 6},
            new int[] {7, 10, 10},
            new int[] {6, 8, 9},
            new int[] {1, 6, 1},
            new int[] {3, 7, 2},
            new int[] {3, 5, 9},
            new int[] {2, 8, 10},
            new int[] {4, 9, 7}
        };
        Console.WriteLine("Example 2");
        Console.WriteLine(solution.MaxTaxiEarnings(10, rides2));
    }
}
// Output
Example 1
7

Example 2
33

Question 3 : Minimum Cost Walk in Weighted Graph

The final problem was the toughest one in my assessment.

It involved finding the minimum-cost walk in a weighted graph. The exact approach depends on the constraints, but the problem required strong graph fundamentals and careful analysis before implementation. This question consumed most of my remaining time and I couldn't complete it successfully.

Topics Covered

• Graph Algorithms
• Shortest Path
• Weighted Graphs

Difficulty: Medium to Hard

My Experience

I genuinely enjoyed solving the assessment because the questions tested problem-solving ability instead of language-specific tricks. One thing I liked was that the problems rewarded understanding rather than memorization. Even though I had seen similar questions before, I still needed to think carefully about edge cases, optimize my solution and manage my time efficiently.

I solved the first two questions confidently, but the third graph problem took longer than expected. Looking back, I probably spent too much time trying to optimize that solution instead of moving on earlier. Although I wasn't shortlisted, I still consider it a valuable experience because it highlighted the areas where I need more practice, especially advanced graph algorithms and solving medium-level problems under strict time constraints.

Preparation Tips

If you're planning to take the Meesho SDE-1 Online Assessment, my biggest suggestion is to focus on problem-solving patterns instead of memorizing specific questions. The following topics are worth practicing thoroughly:

• Arrays
• Strings
• Hash Maps
• Binary Search
• Dynamic Programming
• Graph Algorithms
• Trees
• Greedy Algorithms
• Sliding Window
• Prefix Sum
• Union-Find (Disjoint Set Union)

Also, make sure you're comfortable writing clean and bug-free code quickly. During an online assessment, even a correct approach won't help if you spend too much time debugging. Based on publicly shared interview experiences, graph algorithms, dynamic programming and medium-to-hard DSA questions appear frequently in Meesho's hiring process.

General Advice

Don't get discouraged if you can't solve every question. It's completely normal to get stuck on one difficult problem during an online assessment. Instead of trying to force a solution, maximize your score by completing the questions you're confident about first. After every interview, spend some time reviewing the problems you couldn't solve. That's where the real learning happens.

Consistency matters much more than one interview result. The more medium and hard DSA problems you solve, the better you'll become at recognizing patterns and finding solutions under pressure.

Questions Asked