160 questions from 21 interviews · updated from reports 2014-2024
About
Myntra is an Indian e-commerce platform for fashion and lifestyle products, including clothing, footwear, accessories, and beauty items. In India, it commonly hires Software Engineers, Software Engineering Interns, and Senior Software Engineers for product, backend, mobile, and data-related teams.
The roles that come up most are Software Engineer, Software Engineering Intern and Senior Software Engineer. This covers 21 candidate interviews reported from 2014 to 2024. The largest group sat it at entry level (8 of 20 that recorded a level), with 6 internship interviews alongside. Among the 9 that recorded either route, arrivals split between campus drives (8, 89%) and off-campus applications (1, 11%). Most questions fall under DSA and CS fundamentals.
Ans. Use sorting and a two pointer sweep to find the maximum number of trains present at the station at the same time. Sort arrival times and departure times separately, then move through them: if the next arrival is before or at the next departure, need one more platform; otherwise free one. Time complexity is O(n log n).
Ans. Use a min heap to repeatedly take the smallest current element among the k arrays and append it to the result. Initially push the first element of each non-empty array with its array index and position. After popping one, push the next element from the same array. Time complexity is O(N log k), where N is total elements.
Ans. Use two stacks: one for operands and one for operators. Scan left to right, push numbers, handle opening brackets, and before pushing an operator, apply any stacked operator with higher or equal precedence. On closing brackets, apply until the matching opening bracket. This evaluates the expression in O(n) time and O(n) space.
Ans. Implement an LRU cache with a hash map from key to list node and a doubly linked list ordered by recent use. On get, return the value and move the node to the front. On put, update or insert at the front. If capacity is exceeded, remove the tail. Both operations are O(1).
Ans. Find the peak using binary search, then binary search the increasing left half and the decreasing right half for the target. The key detail is that comparisons differ on each side: normal binary search on the left, reversed binary search on the right. This takes O(log n) time and O(1) space.
Ans. Use an array where the minimum element is always at index 0. For 0-based indexing, parent is (i - 1) / 2, left child is 2i + 1, and right child is 2i + 2. Insert by bubbling up. Remove min by swapping with the last element, deleting it, then heapifying down. Both take O(log n).
Ans. Delete by searching for the key, then handle three cases: leaf, one child, or two children. A leaf is removed directly, and a node with one child is replaced by that child. For two children, replace its value with the inorder successor or predecessor, then delete that replacement node. Time is O(h), space O(h) recursively.
Ans. Use a min-heap of size k: insert each element, and whenever the heap grows beyond k, remove the smallest. After processing the array, the heap root is the k-th largest element. This takes O(n log k) time and O(k) space, and handles duplicates naturally.
Ans. Reverse each block of k nodes by rewiring next pointers, then connect the previous block’s tail to the new head of the reversed block. Use three pointers to reverse a block in place, and first check that k nodes remain if partial groups should stay unchanged. Time complexity is O(n), space complexity is O(1).
Ans. CPU scheduling algorithms decide which ready process runs next. Common ones are First Come First Served, Shortest Job First, Priority Scheduling, Round Robin, and Multilevel Queue. The key trade-off is between fairness, response time, throughput, and starvation. Preemptive algorithms can interrupt running processes, while non-preemptive ones wait until completion or blocking.
Ans. Use a dummy head and add corresponding digits while carrying overflow, creating one result node per digit. Traverse both lists together, treating missing digits as zero, and continue while either list has nodes or carry remains. This handles different lengths and final carry. Time is O(max(m, n)); extra space is the output list.
Ans. Use a sweep line: turn each interval into two events, start adds 1 and end subtracts 1, then sort events by position and scan while tracking the current and maximum count. For closed intervals, process starts before ends at the same coordinate. The position where the maximum is first reached is the answer. Time is O(n log n).
Ans. Transpose the matrix, then reverse each row to rotate it 90 degrees clockwise. The transpose swaps matrix[i][j] with matrix[j][i] across the main diagonal, and reversing each row moves columns into their final rotated positions. This uses the existing 2D array in place, with O(n²) time and O(1) extra space.
Ans. Use orientation tests on the two endpoints of each segment. Segments AB and CD intersect if C and D lie on different sides of AB and A and B lie on different sides of CD. The key detail is handling collinear cases separately by checking whether a collinear point lies within the other segment’s bounding box. Time is O(1).
Ans. Compute the longest increasing subsequence ending at each index and the longest decreasing subsequence starting at each index, then maximise LIS[i] + LDS[i] - 1. The subtraction avoids counting the peak twice. Using dynamic programming with nested loops takes O(n²) time and O(n) space; binary search optimisation is possible but more complex.
Ans. Model the board as 64 squares holding pieces, with a game state tracking side to move, castling rights, en passant target, move clocks and history. Generate pseudo-legal moves per piece, then filter moves that leave the king in check. This handles checkmate, stalemate, promotion, castling and en passant correctly. Move generation is roughly constant bounded work per turn.
Ans. Use a depth first search from the root, and print a node when the target is found in either its left or right subtree. The recursion returns true if the target exists below the current node. This uses the call stack only, takes O(n) time, and O(h) space.
Ans. Use a recursive DFS: if the current node is null, p, or q, return it. Recurse into left and right. If both sides return non-null, the current node is the LCA. Otherwise return the non-null side. This uses the call stack and runs in O(n) time, with O(h) space.
Ans. Implement Heap Sort in C by storing the elements in an array, building a max heap, then repeatedly swapping the root with the last unsorted element and heapifying the reduced heap. The key detail is maintaining the heap property after each swap. Time complexity is O(n log n), with O(1) extra space.
Ans. Use a distributed trie or prefix index where each node stores the top K ranked suggestions for that prefix. On each query, fetch the prefix node and return cached results in O(length of prefix). Build rankings from query frequency, freshness, location and personalisation. Shard by prefix, cache hot prefixes, and update scores asynchronously from logs.
Ans. Google’s basic ranking idea, PageRank, is to rank pages by both relevance to a query and the authority implied by links from other pages. A link acts like a vote, but votes from important pages count more. In practice, Google also uses many other signals such as content quality, freshness, location and user intent.
Ans. Use level order traversal and keep replacing the sum with the sum of the current level, so the last recorded sum is the answer. Store nodes in a queue, process one level at a time, and add only that level’s node values. This takes O(n) time and O(w) space, where w is maximum width.
Ans. Expose an API like GET /parking/vehicles/{vehicleNumber}/slot that returns the current slot, level, status, and entry time for that vehicle. Maintain a vehicleNumber to activeTicket or slot mapping, updated on park and exit APIs. The key detail is indexing vehicle number for constant time lookup, rather than scanning all slots.
Ans. Expose a layout API where clients send component IDs, sizes, constraints and viewport, and receive absolute or grid positions plus z-index. Model the page as a tree of containers with flex, grid or anchor rules. The key detail is deterministic conflict resolution, so overlapping, resizing and responsive breakpoints produce stable, cacheable layouts.
Ans. Use a hash set or frequency map and count value pairs, not index pairs. For k greater than 0, insert all values, then count each distinct x where x + k exists. For k equal to 0, count values with frequency at least two. This runs in O(n) time and O(n) space.
Ans. Maintain an index from vehicle colour to a set of occupied parking slot IDs. When a vehicle parks, add its slot to the colour’s set; when it leaves, remove it. Store colours in a normalised form, such as lowercase. Lookup returns the set in constant time, plus time to output results.
Ans. Auto-suggest predicts likely next words or completions from the typed prefix, while auto-correct replaces probable mistakes with the closest intended word. Phones use dictionaries, often stored in tries for fast prefix lookup, plus language models that rank candidates using context, frequency and personal habits. Corrections commonly use edit distance and keyboard-neighbour errors.
Ans. Use a frequency map and a queue of candidate characters, updating both as each stream character arrives. Increment the character’s count, push it into the queue if first seen, then remove queue front items whose count is greater than one. The queue front is the current first non-repeating character. Each update is O(1) amortised time.
Ans. Use breadth first search with a queue, processing the tree level by level and reversing the direction after each level. Store values for the current level in a list, append left to right or right to left depending on a flag, then flip it. Time complexity is O(n), space is O(n).
Ans. Use two heaps: a max heap for the lower half of numbers and a min heap for the upper half. Keep their sizes equal, or let one heap have one extra element. The median is the top of the larger heap, or the average of both tops. Insertion is O(log n), median lookup is O(1).
Ans. Use Floyd’s slow and fast pointer method to detect a loop, then find the loop start and set the last node in the loop to NULL. After slow and fast meet, move one pointer to head and advance both one step until they meet. Then traverse the loop to find its previous node. Time is O(n), space is O(1).
Ans. Sort the numbers as strings using a custom comparator: for two values a and b, put a before b if the concatenation ab is larger than ba. Then join the sorted strings. The key detail is handling all zeros, where the result should be “0”. Time complexity is O(n log n) comparisons.
Ans. Choose a relational database when the data is structured, relationships matter, and you need strong consistency, joins, and transactions. Choose a non-relational database when the data shape changes often, scale-out and high write throughput are more important, or the access pattern fits documents, key-value, wide-column, or graph storage.
Ans. Use the already populated next pointers to traverse each level, while building the next level’s links with a dummy head and tail pointer. For each node on the current level, attach its left and right children to tail. Move to dummy.next for the next level. Time is O(n), extra space is O(1).
Ans. Use level order traversal and return the size of the last level visited. Keep a queue of nodes, process the tree level by level, and store the number of nodes in the current level before expanding their children. When the queue becomes empty, that last stored count is the answer. Time is O(n), space is O(w).
Ans. Define classes Bus, Route, Trip, Seat, Passenger, Booking and Payment, with services SearchService, BookingService and PaymentService. Key functions are searchTrips(source, destination, date), getAvailableSeats(tripId), holdSeats(user, seats), confirmBooking(holdId, payment), cancelBooking(bookingId) and issueRefund. The critical detail is concurrency: seat holds must be atomic with expiry to prevent double booking.
Ans. Build the tree by taking the next preorder value as the root, finding it in inorder, then recursively building the left and right subtrees from the inorder split. Use a hashmap from value to inorder index and a shared preorder pointer. This gives O(n) time and O(n) extra space.
Ans. Use modified binary search: compare the middle element with the ends to decide which half is sorted, then check whether the target lies inside that sorted half and discard the other half. Repeat until found or range is empty. It uses the array in place, runs in O(log n) time and O(1) space.
Ans. Use a modified binary search to find the element in O(log n) time and O(1) space. At each step, compare the middle value with the ends to identify which half is sorted, then decide whether the target lies in that half or the other half.
Ans. CAP says a distributed system with multiple nodes handling reads and writes cannot guarantee consistency, availability, and partition tolerance all at once during a network split. The key detail is that partition tolerance is unavoidable in real distributed systems, so designers usually choose between consistent but sometimes unavailable, or available but sometimes stale responses.
Ans. Scan the string once and build a result containing only characters outside tags. Use a boolean flag, initially false; set it true when you see <, set it false after >, and append characters only when the flag is false. This uses a string builder and runs in O(n) time.
Ans. Use two stacks: a normal stack for values and an auxiliary stack for current minimums. On push, also push the value to the min stack if it is less than or equal to the current minimum. On pop, remove from the min stack if the popped value equals its top. Push, pop, and getMin are O(1).
Ans. Build a max heap from the array, remove the largest element once, and the new heap root is the second largest element. This uses the heap structure from heap sort without fully sorting the array. Building the heap takes O(n), removing the maximum takes O(log n), and space is O(1) if done in place.
Ans. Insert in a binary search tree by comparing keys and walking left or right until a null child is found. Delete has three cases: remove a leaf directly, replace a node with its only child, or for two children replace its value with the inorder successor or predecessor, then delete that node. Time is O(h).
Ans. Toss the coin twice. If the result is heads then tails, choose option A. If it is tails then heads, choose option B. If it is heads heads or tails tails, ignore it and try again. This is fair because heads tails and tails heads both have probability p(1-p).
Ans. Use a modified binary search. At each step, compare the middle element with the left and right ends to find which half is sorted, then check whether the target lies inside that sorted half and discard the other half. This keeps the search in O(log n) time and O(1) space for distinct elements.
Ans. Simulate writing the characters row by row while moving down and then up between the rows, then join the rows in order. Use an array of strings, one per row, and a direction flag that flips at the top and bottom rows. This runs in O(n) time and uses O(n) space.
Ans. Use a sliding window with two pointers and a map from character to its last seen index. Move the right pointer through the string, and when a repeated character appears inside the current window, move the left pointer just after its previous position. Track the maximum window length. This runs in O(n) time.
Ans. C is usually compiled directly into a native executable for a specific platform, while C# is compiled into intermediate language in a .NET assembly that runs under the CLR. At runtime, C# depends on the .NET runtime for JIT compilation, garbage collection, type safety and exception handling, whereas C has minimal runtime support.
Ans. Traverse the binary tree and, whenever a node has no left or right child, print it or append it to the leaf doubly linked list. Keep two pointers, head and previous, to connect leaves in order. An inorder traversal prints leaves from left to right. Time complexity is O(n), with O(h) recursion space.
Ans. Sort all arrival times and departure times separately, then scan them with two pointers, counting active trains. If the next arrival is before or at the next departure, one more platform is needed; otherwise one is freed. Track the maximum active count. This uses arrays only and runs in O(n log n) time.
Ans. Track the lowest price seen so far and the best profit from selling at each current price. For each day, update the minimum buy price, then update maximum profit using current price minus that minimum. No extra data structure is needed beyond two variables. Time complexity is O(n), space complexity is O(1).
Ans. Compute 100! by multiplying numbers 1 to 100 while storing the result in an arbitrary precision integer. Primitive types like int, long or double cannot store all 158 digits exactly. Use BigInteger in languages that provide it, or store digits in an array or vector and implement multiplication with carry. Time complexity is O(n × d).
Ans. Build a pipeline that ingests the book file, extracts and normalises text, splits it into speech-sized chunks, sends each chunk to a text-to-speech engine, then concatenates the audio files into chapters or one final audiobook. The key detail is chunking with stable ordering and metadata, so failures can be retried without regenerating everything.
Ans. Use breadth first search from the knight’s start position, because each knight move has equal cost and BFS finds the shortest path in an unweighted graph. Put positions and their distance in a queue, mark visited squares, and try all eight knight moves. Time is O(rows × columns), with the same space for visited.
Ans. Use dynamic programming with a monotonic deque to keep the best reachable score from the last K positions. Let dp[i] be nums[i] plus the maximum dp value among valid previous indices. The deque stores indices with decreasing dp values, removing expired indices. This runs in O(n) time and O(k) space.
Ans. Tilt the cylindrical glass slowly until the water just reaches the rim but does not spill. Look at the bottom inside the glass. If any part of the bottom is exposed, it is less than half full. If the bottom remains covered, it is more than half full. At exactly half, the water plane reaches the rim and the opposite bottom edge.
Ans. Assume A guesses first. Fix random orders in which A would try his n+1 possible cards and B his m+1 possible cards. The hidden card’s positions are independent uniform values i and j. A wins iff i <= j. Therefore compute P(i <= j), then print to 9 decimals using the closed form or summation.
Ans. Reverse a linked list by iterating through it and changing each node’s next pointer to point to the previous node. Keep three pointers: previous, current, and next, so you do not lose the rest of the list. At the end, previous is the new head. Time complexity is O(n), space complexity is O(1).
Ans. A strong answer defines good teams by trust, clear goals, accountability, respectful challenge, and shared ownership. Pick a real team experience where behaviours affected results. Emphasise how communication, decision making, and handling conflict shaped outcomes. Interviewers listen for self-awareness, collaboration, and whether you recognise that culture is built through daily actions.
No question matches those filters. Reset filters.
Showing 60 of 160 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover DSA (71%) and CS fundamentals (13%).
Candidate interviews show an average of 3.6 rounds per experience, with a typical sequence of Online test → Technical → Technical. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 28%, medium 55%, hard 16%.
