Meesho Coding Questions and Answers: SDE-1 OA and DSA Round (2026)

21 min read

Most guides to Meesho coding questions treat the process as a pure DSA exercise. Published candidate accounts say otherwise: alongside the three coding problems, people report an MCQ section on operating systems, networks and DBMS, and a machine-coding round where you build a working system from scratch. Grinding LeetCode alone leaves both of those uncovered.

This page gives you ten practice problems with worked solutions in JavaScript, Java and Python — every one compiled and run before publication — plus an honest account of what the rest of the process contains. These are practice problems matching the patterns candidates report, not a leaked question paper: Meesho does not publish its assessment.

What the Meesho SDE-1 Process Actually Looks Like

On a phone, scroll the table sideways. Compiled from published candidate interview experiences, not from Meesho — the company does not publish its assessment format, and the accounts genuinely differ on question counts and timings.

Introduction to Meesho’s Hiring Trends

Meesho is a product company, and it hires like one. That matters for preparation: the process leans on system thinking and CS fundamentals in a way IT-services assessments do not, and the bar in the live rounds is whether your code runs and you can defend its design.

Why Meesho is a Top Choice for Developers

• Fast-paced, product-oriented environment
  
• Opportunity to work on scalable systems from Day 1
  
• Flexible team dynamics
  
• Growth mindset + open-source contribution encouragement
  

What to Expect in the 2026 Hiring Process

Expect four things, not one: three coding problems, a CS-fundamentals block, a machine-coding or low-level design task, and a resume-driven conversation. Candidate accounts weight the last two far more heavily than most preparation guides do.

Meesho Recruitment Process Overview

Online Assessment Rounds

• Conducted via HackerRank in most reports, with HackerEarth used for some campus drives
  
• Three coding questions in every account seen; several also report an MCQ section on OS, networks, DBMS and language output
  
• Duration is inconsistently reported — one account states 75 minutes, others do not say. Do not plan around a figure from a guide
  
• Auto-submission at deadline
  

Technical Interview Rounds

1-2 rounds covering:

• DSA problems
  
• Time-space optimization
  
• Edge cases + real-world scenario-based questions
  
• System design questions for senior roles
  

HR and Cultural Fit Interview

This is more about your thinking style, adaptability, and ownership than textbook answers.

Meesho Coding Questions Round Breakdown

Number of Questions and Duration

• Three coding questions, consistently, across every published account
  
• Difficulty usually described as one easy, one medium, one hard
  
• Plus, in several accounts, an MCQ block on CS fundamentals — sometimes with negative marking, so guessing is not free
  

Coding Platforms Used by Meesho

• HackerRank — the one named most often, and the platform behind the CodePair sessions used for live technical rounds
  
• HackerEarth — used for some campus hiring drives
  
• Accounts differ here, and no source is authoritative. Your invitation email names the platform you will actually sit — trust that over any guide, including this one
  

Scoring and Cutoffs

• Accounts that mention a bar describe solving roughly two of the three Meesho coding questions as enough to progress — but cutoffs are set per drive and are not published
  
• Focus on code correctness, edge cases, and clean syntax
  

Top 10 Meesho Coding Questions and Answers

Each of the following Meesho coding questions comes with a worked solution in JavaScript, Java and Python. Every one was compiled and executed against test inputs before publication, so the behaviour described is the behaviour you will get.

Question 1: Two Sum

Problem:

Find indices of two numbers that add up to the target.

var twoSum = function(nums, target) {
const map = new Map();
for(let i = 0; i < nums.length; i++) {
let complement = target - nums[i];
if(map.has(complement)) {
return [map.get(complement), i];
}
map.set(nums[i], i);
}
};

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    return new int[] {};
}

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

Same logic as Java/Python using a hash map.

Time Complexity: O(n)

Space Complexity: O(n)

Question 2: Best Time to Buy and Sell Stock

var maxProfit = function(prices) {
let minPrice = Infinity;
let maxProfit = 0;
for(let price of prices) {
minPrice = Math.min(minPrice, price);
maxProfit = Math.max(maxProfit, price - minPrice);
}
return maxProfit;
};

public int maxProfit(int[] prices) {
    int min = Integer.MAX_VALUE;
    int profit = 0;
    for (int price : prices) {
        min = Math.min(min, price);
        profit = Math.max(profit, price - min);
    }
    return profit;
}

def maxProfit(prices):
    min_price = float('inf')
    max_profit = 0
    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)
    return max_profit

Time Complexity: O(n)

Space Complexity: O(1)

Question 3: Valid Parentheses

var isValid = function(s) {
    const stack = [];
    const map = {')': '(', '}': '{', ']': '['};
    for (let char of s) {
        if (char in map) {
            const top = stack.length ? stack.pop() : '#';
            if (top !== map[char]) return false;
        } else {
            stack.push(char);
        }
    }
    return stack.length === 0;
};

def isValid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top = stack.pop() if stack else '#'
            if mapping[char] != top:
                return False
        else:
            stack.append(char)
    return not stack

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(') stack.push(')');
        else if (c == '{') stack.push('}');
        else if (c == '[') stack.push(']');
        else if (stack.isEmpty() || stack.pop() != c) return false;
    }
    return stack.isEmpty();
}

Question 4: Power Function

var myPow = function(x, n) {
    if(n < 0) {
        x = 1 / x;
        n = -n;
    }
    let result = 1;
    while(n) {
        if(n % 2 !== 0) result *= x;
        x *= x;
        n = Math.floor(n / 2);
    }
    return result;
};

def myPow(x, n):
    if n < 0:
        x = 1 / x
        n = -n
    result = 1
    while n:
        if n % 2:
            result *= x
        x *= x
        n //= 2
    return result

public double myPow(double x, long n) {
    if (n < 0) {
        x = 1 / x;
        n = -n;
    }
    double result = 1;
    while (n > 0) {
        if (n % 2 == 1) result *= x;
        x *= x;
        n /= 2;
    }
    return result;
}

Question 5: Course Schedule (Cycle Detection)

var canFinish = function(numCourses, prerequisites) {
    const graph = new Map();
    for (let i = 0; i < numCourses; i++) graph.set(i, []);
    for (let [a, b] of prerequisites) graph.get(a).push(b);

    const visiting = new Set();

    const dfs = (course) => {
        if (visiting.has(course)) return false;
        if (graph.get(course).length === 0) return true;

        visiting.add(course);
        for (let pre of graph.get(course)) {
            if (!dfs(pre)) return false;
        }
        visiting.delete(course);
        graph.set(course, []);
        return true;
    }

    for (let i = 0; i < numCourses; i++) {
        if (!dfs(i)) return false;
    }
    return true;
};

public boolean canFinish(int numCourses, int[][] prerequisites) {
    Map<Integer, List<Integer>> graph = new HashMap<>();
    for (int i = 0; i < numCourses; i++) graph.put(i, new ArrayList<>());
    for (int[] pre : prerequisites) graph.get(pre[0]).add(pre[1]);

    Set<Integer> visiting = new HashSet<>();
    for (int course = 0; course < numCourses; course++) {
        if (!dfs(course, graph, visiting)) return false;
    }
    return true;
}

private boolean dfs(int course, Map<Integer, List<Integer>> graph, Set<Integer> visiting) {
    if (visiting.contains(course)) return false;
    if (graph.get(course).isEmpty()) return true;

    visiting.add(course);
    for (int pre : graph.get(course)) {
        if (!dfs(pre, graph, visiting)) return false;
    }
    visiting.remove(course);
    graph.get(course).clear();
    return true;
}

def canFinish(numCourses, prerequisites):
    graph = {i: [] for i in range(numCourses)}
    for a, b in prerequisites:
        graph[a].append(b)

    visiting = set()

    def dfs(course):
        if course in visiting:
            return False
        if not graph[course]:
            return True

        visiting.add(course)
        for pre in graph[course]:
            if not dfs(pre):
                return False
        visiting.remove(course)
        graph[course] = []
        return True

    return all(dfs(course) for course in range(numCourses))

Question 6: Counting the Number of 1’s in Binary

var countBits = function(n) {
    const dp = new Array(n + 1).fill(0);
    for (let i = 1; i <= n; i++) {
        dp[i] = dp[i >> 1] + (i & 1);
    }
    return dp;
};

def countBits(n):
    dp = [0] * (n + 1)
    for i in range(1, n + 1):
        dp[i] = dp[i >> 1] + (i & 1)
    return dp

public int[] countBits(int n) {
    int[] dp = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        dp[i] = dp[i >> 1] + (i & 1);
    }
    return dp;
}

Question 7: Generate Parentheses

var generateParenthesis = function(n) {
    const res = [];
    const backtrack = (str, open, close) => {
        if (str.length === n * 2) {
            res.push(str);
            return;
        }
        if (open < n) backtrack(str + '(', open + 1, close);
        if (close < open) backtrack(str + ')', open, close + 1);
    };
    backtrack('', 0, 0);
    return res;
};

public List<String> generateParenthesis(int n) {
    List<String> res = new ArrayList<>();
    backtrack(res, "", 0, 0, n);
    return res;
}

private void backtrack(List<String> res, String str, int open, int close, int max) {
    if (str.length() == max * 2) {
        res.add(str);
        return;
    }
    if (open < max) backtrack(res, str + "(", open + 1, close, max);
    if (close < open) backtrack(res, str + ")", open, close + 1, max);
}

def generateParenthesis(n):
    res = []
    def backtrack(s='', left=0, right=0):
        if len(s) == 2 * n:
            res.append(s)
            return
        if left < n:
            backtrack(s + '(', left + 1, right)
        if right < left:
            backtrack(s + ')', left, right + 1)
    backtrack()
    return res

Question 8: LRU Cache

class LRUCache {
    constructor(capacity) {
        this.capacity = capacity;
        this.cache = new Map();
    }

    get(key) {
        if (!this.cache.has(key)) return -1;
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, value);
        return value;
    }

    put(key, value) {
        if (this.cache.has(key)) {
            this.cache.delete(key);
        }
        this.cache.set(key, value);
        if (this.cache.size > this.capacity) {
            const firstKey = this.cache.keys().next().value;
            this.cache.delete(firstKey);
        }
    }
}

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

class LRUCache {
    private final int capacity;
    private final LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();

    LRUCache(int capacity) {
        this.capacity = capacity;
    }

    int get(int key) {
        if (!cache.containsKey(key)) return -1;
        int value = cache.remove(key);
        cache.put(key, value);
        return value;
    }

    void put(int key, int value) {
        if (cache.containsKey(key)) cache.remove(key);
        cache.put(key, value);
        if (cache.size() > capacity) {
            int oldest = cache.keySet().iterator().next();
            cache.remove(oldest);
        }
    }
}

Question 9: Encode and Decode Strings

class Codec {
    encode(strs) {
        return strs.map(s => `${s.length}#${s}`).join('');
    }

    decode(s) {
        const res = [];
        let i = 0;
        while (i < s.length) {
            let j = i;
            while (s[j] !== '#') j++;
            const length = parseInt(s.slice(i, j));
            res.push(s.slice(j + 1, j + 1 + length));
            i = j + 1 + length;
        }
        return res;
    }
}

class Codec:
    def encode(self, strs):
        return ''.join(f'{len(s)}#{s}' for s in strs)

    def decode(self, s):
        res, i = [], 0
        while i < len(s):
            j = i
            while s[j] != '#':
                j += 1
            length = int(s[i:j])
            res.append(s[j+1: j+1+length])
            i = j + 1 + length
        return res

public String encode(List<String> strs) {
    StringBuilder sb = new StringBuilder();
    for (String s : strs) sb.append(s.length()).append('#').append(s);
    return sb.toString();
}

public List<String> decode(String s) {
    List<String> res = new ArrayList<>();
    int i = 0;
    while (i < s.length()) {
        int j = i;
        while (s.charAt(j) != '#') j++;
        int length = Integer.parseInt(s.substring(i, j));
        res.add(s.substring(j + 1, j + 1 + length));
        i = j + 1 + length;
    }
    return res;
}

Question 10: Kth Largest Element in an Array

var findKthLargest = function(nums, k) {
    nums.sort((a, b) => b - a);
    return nums[k - 1];
};

import heapq

def findKthLargest(nums, k):
    return heapq.nlargest(k, nums)[-1]

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> heap = new PriorityQueue<>();
    for (int num : nums) {
        heap.offer(num);
        if (heap.size() > k) heap.poll();
    }
    return heap.peek();
}

Note the difference in approach: the JavaScript version sorts the whole array at O(n log n), while the Java version keeps a min-heap of size k at O(n log k). Both are accepted answers, but if an interviewer asks you to improve on the sort, the heap is the answer they are looking for — and this is exactly the kind of follow-up the Meesho coding questions rounds are reported to include.

More Meesho Coding Questions by Difficulty

The ten worked solutions above are the core. These six are the next tier of Meesho coding questions to practise, listed by difficulty with the approach that matters rather than a full solution — write these yourself, because typing them out is the point.

Easy Level Meesho Coding Questions

1. Reverse a Linked List

def reverseList(head):

    prev = None

    while head:

        next_node = head.next

        head.next = prev

        prev = head

        head = next_node

    return prev

2. Find Missing Number in Array

def missingNumber(nums):

    n = len(nums)

    return n * (n + 1) // 2 - sum(nums)

Medium Level Meesho Coding Questions

3. Longest Substring Without Repeating Characters

def lengthOfLongestSubstring(s):

    seen = {}

    l = 0

    max_len = 0

    for r in range(len(s)):

        if s[r] in seen and seen[s[r]] >= l:

            l = seen[s[r]] + 1

        seen[s[r]] = r

        max_len = max(max_len, r - l + 1)

    return max_len

4. LRU Cache Implementation

Use OrderedDict or a custom DLL + Hashmap for optimal results.

Hard Level Meesho Coding Questions

5. Merge k Sorted Lists

Use MinHeap (heapq in Python) for optimal merging.

6. Word Break II

Use DFS with memoization to avoid Time Limit Exceeded (TLE).

The Meesho coding questions are the part candidates prepare for. The machine-coding round is the part that fails them.

The Machine-Coding Round Nobody Prepares For

This is the biggest gap between what guides cover and what candidates describe. More than one account reports a round that is not an algorithm problem at all: you are asked to build a small working system and implement its operations using object-oriented design.

One candidate describes being asked to build a cab-booking system with roughly ten functions, with code that actually runs. Other reported prompts include a parking system, a polling system, a payment flow and a reviews module. The format is typically fifteen to twenty minutes of clarifying questions, then an hour or so of coding, then a discussion of test cases.

Why solving Meesho coding questions does not prepare you for it

A LeetCode problem gives you a signature and a hidden test suite. A machine-coding round gives you an ambiguous brief and judges your class design, your naming, your separation of concerns and whether you asked what happens when two users book the same cab.

Practical preparation: pick three of the prompts above, give yourself seventy-five minutes each, and write them as real classes with an in-memory store and a small main method that exercises every operation. Do not stub anything. The discipline you are building is finishing something that runs, not finding an optimal algorithm.

The CS fundamentals block

The second thing the listicles miss. Candidate accounts of the later rounds are full of theory: DBMS schema design and SQL queries, SQL versus NoSQL, normalisation and ACID, DNS and ARP, the OSI model, semaphores versus mutexes, paging and virtual memory, threading. Several accounts also put this material in the assessment’s MCQ section, occasionally with negative marking.

If your revision plan is entirely DSA, this is where the time is going missing. Budget at least a couple of days for operating systems, databases and networking theory before a Meesho round.

Meesho DSA Concepts to Master Before the Coding Round

Across the published accounts, the Meesho coding questions cluster into a short list of patterns. If you know these five cold, very little in the assessment will be unfamiliar territory.

• Arrays and Strings – Sliding Window, Prefix Sum, Kadane’s
  
• HashMaps/Sets – Frequency counting, Two-sum variants
  
• Trees/Graphs – BFS, DFS, Topological Sort
  
• Dynamic Programming – Knapsack, Tabulation, Memoization
  
• Recursion/Backtracking – Subsets, N-Queens, Word Search
  

Meesho Coding Interview Tips That Actually Change Outcomes

Most advice here is generic. These three are the ones candidate write-ups keep coming back to when describing where the Meesho coding questions went wrong for them.

Time Management

• Read all questions at the start
  
• Attempt easiest first
  
• Allocate time wisely – max 20 mins per question
  

Problem-Solving Approach

• Clarify inputs/outputs
  
• Write pseudocode
  
• Dry-run with sample inputs
  

Mistakes to Avoid

• Skipping edge cases
  
• Blindly jumping into code
  
• Over-optimization early on
  

Tools & Resources to Practice

The single most useful thing you can read before a Meesho round is other candidates’ write-ups of theirs. GeeksforGeeks hosts a run of them under Meesho SDE-1 interview experiences, and they are where the details on this page come from — the MCQ section, the HackerRank CodePair rounds and the machine-coding task all appear there rather than in any listicle.

For timed practice, InterviewBit and LeetCode’s company tag are the usual choices. Both need a login, and neither publishes a verified Meesho question set — company tags are crowd-sourced from candidate recall.

Books

Cracking the Coding Interview — Gayle Laakmann McDowell

Elements of Programming Interviews

Data Structures and Algorithms Made Easy — Narasimha Karumanchi

Mock Interviews

• Pramp
  
• InterviewBuddy
  
• Reddit Threads: r/cscareerquestionsIN
  

Real Candidate Experiences

What published interview experiences actually describe

Rather than paraphrase, here is what candidates who wrote up their Meesho SDE-1 rounds consistently describe, with the disagreements left in.

• Three coding questions in the online assessment. Every account agrees on three. The difficulty split is usually described as one easy, one medium, one hard.
• An MCQ section that catches people out. Several accounts report multiple-choice questions on operating systems, computer networks, DBMS and C/C++/Java output — one describes negative marking. Other accounts describe a coding-only assessment, so this may vary by drive.
• HackerRank CodePair for the live rounds. Named directly in more than one account.
• A machine-coding or low-level design task. One account describes being asked to build a cab-booking system with around ten functions using OOP concepts, with working code expected. This is the round that pure LeetCode practice does not cover.
• Serious CS-fundamentals questioning. DBMS schema design and SQL, DNS and ARP, the OSI model, semaphores versus mutexes, paging and virtual memory, ACID and normalisation.

The shortlist numbers reported vary widely by campus and drive — one account mentions 28 candidates reaching interviews, another 15, another 35 — so treat any single conversion figure you read as that person’s drive, not a company-wide rate.

Common Pitfalls

• Treating the Meesho coding questions as the whole assessment, and walking into the machine-coding round cold
  
• Not optimizing after brute force
  
• Forgetting test cases
  

Final Week Preparation Strategy

By this point the Meesho coding questions should be revision, not new learning. Use the last week to protect what you know and close the two gaps this page has argued about.

Days 1–2: the ten Meesho coding questions on this page, solved cold and out loud, with edge cases.
Day 3: operating systems, DBMS and networking theory — the block most people skip.
Days 4–5: two machine-coding exercises written end to end, seventy-five minutes each, code that runs.
Day 6: resume projects — be ready to defend every technology choice on it.
Day 7: rest. Arriving tired costs more than one more problem gains.

FAQs

Is Meesho harder than other product companies?

The coding problems themselves sit around LeetCode easy-to-medium, which is not unusually hard. What raises the difficulty is breadth: a machine-coding round and a CS-fundamentals block on top of the algorithms, so a candidate who prepared only DSA can clear the assessment and still come unstuck in round two.

How many rounds are there in Meesho coding interviews?

Three to four in published accounts: the online assessment, one or two technical rounds, then an HR or manager round. The number of technical rounds varies by drive — some candidates report one combined technical-plus-HR round, others two separate technical rounds before HR.

What language should I use in Meesho coding tests?

C++, Java, or Python. Choose the one you’re strongest in.

Does Meesho allow open-book tests?

Assessments are time-bound, and proctoring varies by drive — Meesho does not publish its policy, so the instruction screen on the day is the only reliable answer. One published account notes that candidates in a live round could request their own IDE, which is a different thing from the assessment being open-book.

Can freshers crack Meesho coding interviews?

Yes — the published accounts on this page are mostly on-campus SDE-1 candidates who received offers. The pattern among them is breadth rather than brilliance: they could code the problems, explain their design out loud, and answer DBMS and OS questions without stalling.

Do I need to prepare system design for an SDE-1 role?

Not distributed-systems design, but yes to low-level design. The machine-coding round described above is an object-oriented design exercise: classes, responsibilities, and an interface that makes sense. That is a fair thing to expect of a fresher, and it is the single most under-prepared part of the Meesho process.

Is there negative marking in the Meesho assessment?

One published account reports negative marking on the MCQ section, at plus three and minus three. Others do not mention MCQs at all. Since it appears to vary by drive, read your own instruction screen before guessing on anything.

Conclusion

The ten Meesho coding questions above cover the algorithmic patterns that recur in published accounts: hash maps, stacks, greedy scans, graph cycle detection, backtracking and cache design. Clear them cold and the assessment’s coding section should not be what stops you.

Then spend your remaining time on the two things this page argues are under-prepared. Write three machine-coding exercises end to end until you can finish one in seventy-five minutes with code that runs. And revise operating systems, DBMS and networking properly, because that material shows up both in the assessment’s MCQ block and again in the later interview rounds.

One honest caveat, repeated because it matters: Meesho publishes neither its syllabus nor its question bank. Everything above is drawn from candidates’ published write-ups of their own rounds, and those accounts disagree with each other on question counts, timings and whether an MCQ section appeared at all. Where they disagree, this page says so rather than picking a version.

One last thing. Volume is not the goal — a hundred half-remembered Meesho coding questions are worth less than these ten solved cold, out loud, with the edge cases handled. Depth beats a bookmark folder.

Want more guides like this? Stay tuned on ccodelearner.

Meesho coding questions and answers PDF: every question above is free to read on this page — no download required.

Preparing for other companies too? See our complete coding interview questions guide, organized by company.