795 questions from 127 interviews · updated from reports 2012-2025
About
Flipkart is an Indian e-commerce company that sells products online across categories such as electronics, fashion, groceries, home goods, and more. In India, it commonly hires technical roles such as SDE-1, Software Engineer, SDE-2, data engineers, mobile app developers, and product-focused engineering roles.
The roles that come up most are SDE-1, Software Engineer and SDE-2. This covers 127 candidate interviews reported from 2012 to 2025. Most sat it at entry level (80 of 122 that recorded a level), with 13 internship interviews alongside. Among the 77 that recorded either route, arrivals split between campus drives (34, 44%) and off-campus applications (43, 56%). Most questions fall under DSA and CS fundamentals.
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 the max heap have one extra element. Insert into the correct heap, then rebalance. The median is the max heap top, or the average of both tops. Insert is O(log n), median is O(1).
Ans. Use a modified merge sort to count inversions in O(n log n) time. While merging two sorted halves, if an element from the right half is smaller than one from the left, it forms inversions with all remaining elements in the left half. Add that count, merge normally, and return the total.
Ans. Use a deque to store indices of useful elements in decreasing value order as you scan the array. Remove indices outside the current window from the front, remove smaller elements from the back, then add the current index. Once the first window is formed, the front gives each maximum. Time is O(n), space is O(k).
Ans. Use a trie where each node represents a prefix and stores the top suggestions for that prefix, ranked by frequency, recency or relevance. On each keypress, traverse to the prefix node and return its cached top results. Lookup is O(p), where p is prefix length, with updates handled asynchronously to keep typing fast.
Ans. A strong answer should describe using realistic synthetic or anonymised data, built from production patterns and edge cases. Pick a situation where you clarified data needs, involved product or data owners, created test data deliberately, and documented gaps. Emphasise risk-based testing, privacy, traceability, and how you validated behaviour despite imperfect data.
Ans. Print the first node visible at each depth when the tree is viewed from the left. Do a level order traversal using a queue, and for each level print the first node removed from the queue. This visits every node once, so the time complexity is O(n), with O(w) space for the queue.
Ans. Binary tree traversal visits every node in a defined order: preorder visits root, left, right; inorder visits left, root, right; postorder visits left, right, root; level order visits nodes breadth first. Depth-first traversals use recursion or a stack, while level order uses a queue. Time is O(n), space is O(h) or O(n).
Ans. Cookies are small client-side values stored by a browser, access codes are credentials or tokens used to prove permission, and HTTP status codes are server responses describing request results. The key detail is separation of roles: cookies maintain state, access codes control authorisation, and status codes communicate success, redirects, client errors, or server errors.
Ans. Sort the subarray from index 0 to k minus 1 in ascending order, then sort the subarray from index k to n minus 1 in descending order. Use the language’s built-in sort with reverse order for the second part. The time complexity is O(k log k plus (n-k) log(n-k)).
Ans. Use dynamic programming to compute the minimum coins needed for each amount from 0 to the target. Keep a one-dimensional array dp where dp[0] is 0 and each dp[x] is updated using every coin value. The time complexity is O(amount times number of coins), with O(amount) space.
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 a dynamic array plus a hash map from value to its index in the array. Insert appends the value and records its index. Delete swaps the value with the last array element, updates that element’s index, then pops. GetRandom picks a random array index. All operations are O(1) average time.
Ans. Use binary search to find any peak element by comparing the middle element with its right neighbour. If arr[mid] is less than arr[mid + 1], a peak must exist on the right; otherwise, it exists on the left including mid. This takes O(log n) time and O(1) space.
Ans. Use KMP to find all occurrences of a pattern in a text in linear time. Precompute the longest proper prefix which is also a suffix array for the pattern, then scan the text without moving backwards. The key data structure is the prefix table. Time complexity is O(n + m), with O(m) extra space.
Ans. Use breadth first search from the entrance to find the nearest exit, because BFS explores cells in increasing distance. Put the entrance in a queue with distance zero, mark visited by changing the maze or using a visited set, and stop when a non-entrance boundary cell is reached. Time and space are O(mn).
Ans. Use level order traversal with a horizontal distance for each node, taking the first node seen at every distance. Store nodes in a queue with their distance, put the first value for each distance in an ordered map, then print map values from left to right. Time is O(n log n), or O(n) with hashing plus min and max distance.
Ans. Group the strings by converting each string into a canonical key that represents the given criteria, then store strings with the same key together in a hash map. For anagrams, the key is usually the sorted string or character counts. This takes O(n k log k) with sorting, where k is maximum string length.
Ans. Use recursion to clone the stack, with no auxiliary data structure apart from the destination stack. Pop each element until the original is empty, then during recursion unwinding push the element back onto the original and also onto the clone. This preserves order. Time is O(n); recursion uses O(n) call stack space.
Ans. Use level order traversal with a queue storing each node and its positional index, as if the tree were a complete binary tree. For each level, the width is last index minus first index plus one. Normalise indices at each level to avoid overflow. Time complexity is O(n), space complexity is O(w).
Ans. Use a bounded blocking queue protected by a mutex, with two condition variables or semaphores for not full and not empty. Producers wait when the buffer is full, lock, enqueue an item, unlock, and signal consumers. Consumers wait when empty, lock, dequeue, unlock, and signal producers. Each produce or consume operation is O(1).
Ans. Redis Sentinel provides high availability for a single primary with replicas, while Redis Cluster provides both high availability and horizontal scaling by sharding data across multiple primaries. Sentinel monitors failures and promotes a replica. Cluster splits the key space into hash slots, so clients must understand cluster topology and redirections.
Ans. The CAP theorem says a distributed data system cannot simultaneously guarantee consistency, availability and partition tolerance. During a network partition, it must choose between returning only consistent, up-to-date data or staying available and possibly serving stale data. In practice, partition tolerance is necessary, so systems trade off consistency and availability.
Ans. Design it around entities for Series, Teams, Players, Matches, Innings, Overs, Balls and Scorecards, with services for scheduling, live scoring, standings and notifications. The most important detail is making ball-by-ball events the source of truth, so scorecards, player stats, points tables and live feeds can be rebuilt consistently after corrections.
Ans. Use a stack of character and count pairs, scanning the string from left to right. If the current character matches the stack top, increase its count; otherwise push a new pair. When a count reaches k, pop it, which naturally handles cascading removals. The time complexity is O(n) and space is O(n).
Ans. Currying is turning a function that takes several arguments into a chain of functions that each take one argument. It enables partial application and reusable specialised functions. Hoisting is JavaScript’s creation-phase binding of declarations before execution. Function declarations are usable early, var is undefined until assigned, and let and const are in the temporal dead zone.
Ans. Use a min heap of size k plus 1 to repeatedly output the smallest possible next element. Insert the first k plus 1 elements, then for each remaining element, extract the minimum to the array and insert the new element. Finally drain the heap. Time complexity is O(n log k), space is O(k).
Ans. Kafka is a distributed event streaming platform built around producers, brokers, topics, partitions, consumer groups and ZooKeeper or KRaft for metadata management. Producers write records to topic partitions, brokers store and replicate them, and consumers read independently by offset. It is used for logs, messaging, stream processing, event sourcing and real-time data pipelines.
Ans. Use a hash map plus a doubly linked list. The map gives O(1) access to cache nodes by key, and the list keeps usage order, with most recent at the front and least recent at the back. On get or put, move the node to the front. When capacity is exceeded, remove the back node.
Ans. Find each cell’s sink by repeatedly moving to the lowest adjacent cell, then count how many cells end at each sink and return the largest count. Use DFS with memoisation or union find to avoid recomputing paths. With four-directional neighbours, the time complexity is O(rows × cols), and space is O(rows × cols).
Ans. An AVL tree is a self-balancing binary search tree where, for every node, the height difference between left and right subtrees is at most one. It is implemented by storing each node’s height or balance factor, updating it after insertions and deletions, and restoring balance using single or double rotations. Operations are O(log n).
Ans. Use a hash map where the key represents the letters of a word and the value is the list of words with that key. For each string, sort its characters to form the key, then append it to the matching group. This takes O(n k log k) time and O(n k) space.
Ans. Use level order traversal while assigning each node a horizontal distance, with root at 0, left child minus 1 and right child plus 1. Store values in a map from distance to list. BFS preserves top to bottom order within each column. Print columns from smallest to largest distance. Time is O(n).
Ans. Use a min-heap to repeatedly take the smallest current element from the k arrays and append it to the result. Store each heap entry as the value plus its array index and position, then push the next element from that array. For N total elements, time is O(N log k) and space is O(k).
Ans. Use a tree where each employee node stores id, details, parent pointer and a list of direct reports, plus a hash map from employee id to node. Create adds a node under a manager, read uses the map, update changes stored details, and delete removes or reassigns subtrees. Lookup is O(1); hierarchy changes are O(number of affected reports).
Ans. Create a new node for each original node and use a hash map from original node to cloned node. First pass copies all nodes and stores the mapping. Second pass sets each clone’s next and random using the map. This runs in O(n) time and uses O(n) extra space.
Ans. Use two pointers, one starting at each head. Move each pointer one node at a time; when it reaches the end, redirect it to the other list’s head. If the lists intersect, the pointers meet at the shared node. If not, both become null. Time is O(m+n), space is O(1).
Ans. Pick a real disagreement where the stakes were meaningful but professional. Emphasise listening first, checking your assumptions with data, explaining your reasoning calmly, and accepting the final decision once made. Interviewers listen for respect, judgement, emotional control, openness to feedback, and the ability to disagree without damaging the relationship.
Ans. Use NoSQL databases when data is large, fast changing, semi-structured, or needs to scale horizontally across many servers. Their main advantages are flexible schemas, high write and read throughput, easy sharding, high availability, and data models suited to documents, key-value access, wide columns, or graphs instead of fixed relational tables.
Ans. Multithreading is running multiple threads within one process so work can happen concurrently while sharing the same memory space. It is useful for keeping user interfaces responsive, handling many web server requests, downloading files while processing data, or running background tasks. The key detail is managing shared data safely with locks or other synchronisation.
Ans. Use a binary trie to store the numbers bit by bit, then for each number greedily choose the opposite bit at each position to maximise XOR. Insert all numbers, query each number against the trie, and keep the best result. For 32-bit integers, time is O(32n), effectively O(n), with O(32n) space.
Ans. Take K elements split between the start and end, and maximise that total by trying every possible split efficiently. First sum the first K elements, then one by one remove an element from the left side of that selection and add an element from the right end, tracking the maximum. Time is O(K), space is O(1).
Ans. Use breadth first search over board squares to find the minimum dice throws from start to finish. Treat each square as a node, add up to six moves for dice outcomes, and if the target has a snake or ladder, move to its destination. Keep a queue, visited set, and distance. Time is O(n), space is O(n).
Ans. Use Kahn’s algorithm: compute indegree for every vertex, push all zero indegree vertices into a queue, repeatedly remove one, append it to the ordering, and reduce indegree of its neighbours. Any neighbour reaching zero is queued. The result is a topological order. Time complexity is O(V + E), with O(V) extra space.
Ans. Use an in-order traversal, because it visits BST nodes in sorted order, and return the node reached at count k. Implement it iteratively with a stack: go left as far as possible, pop, increment the count, then go right. Time is O(h + k), worst case O(n), and space is O(h).
Ans. Use dynamic programming to store the length of the common suffix ending at each pair of positions. If the characters match, set the cell to the diagonal value plus one, otherwise set it to zero. Track the maximum length and end index. Time is O(nm), space can be O(min(n,m)) with rolling rows.
Ans. Use dynamic programming where dp[i] is the minimum penalty for wrapping words from index i to the end. For each i, try ending the current line at every valid j, add squared unused spaces to dp[j + 1], with zero cost for the last line. Store breaks to reconstruct lines. Time is O(n²), space O(n).
Ans. Build clients, an API gateway, user and catalogue services, playlist and recommendation services, streaming service, and object storage/CDN for audio files. Store metadata in a relational database, search index tracks, and keep play state in a fast key value store. The key detail is serving audio through CDN using adaptive bitrate streaming, not from application servers.
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. Pick a real decision where goals, data, or ownership were unclear. Emphasise how you framed the problem, identified assumptions, gathered enough evidence, aligned stakeholders, made a reversible decision, and measured the result. Interviewers listen for structured thinking, comfort with uncertainty, collaboration, customer focus, and a bias to action without being reckless.
Ans. Use a hash map plus a doubly linked list to implement an LRU cache in O(1) time for get and put. The hash map stores key to node, and the list stores usage order. On access or update, move the node to the front. When capacity is exceeded, remove the tail.
Ans. Use a hash map plus a doubly linked list to implement an LRU cache. The map gives O(1) access from key to node, and the list keeps usage order. On get or put, move the node to the front. When capacity is exceeded, remove the tail in O(1).
Ans. Scan digits from right to left to find the first digit smaller than the digit after it. Swap it with the smallest larger digit to its right, then sort or reverse the suffix into ascending order. If no such digit exists, no greater number is possible. This is the next permutation algorithm, O(n) time.
Ans. Use Kahn’s algorithm: compute the indegree of every vertex, put all zero-indegree vertices in a queue, repeatedly remove one, add it to the ordering, and reduce the indegree of its outgoing neighbours. When a neighbour reaches zero, enqueue it. The adjacency list and queue give O(V + E) time and O(V) extra space.
Ans. Place each element at the position specified by its corresponding index value. The simplest approach is to create a temporary array, set temp[index[i]] to arr[i] for each element, then copy it back. This uses an auxiliary array, runs in O(n) time, and needs O(n) extra space.
Ans. Use dynamic programming where dp[i][w] stores the maximum value using the first i items with capacity w. For each item, either skip it or take it if its weight fits, choosing the better value. The table size is n by capacity, so time is O(nW) and space is O(nW), reducible to O(W).
Ans. Generalise the cricket series into a multi-sport competition model. Keep common entities such as tournament, venue, schedule, participant, team, match or event, result and standing, then add sport, discipline and event types. The key detail is to make scoring, qualification and ranking rules pluggable per sport, since cricket, athletics and gymnastics rank results differently.
Ans. Use long division with repeated subtraction. First subtract |y| from |x| until the remainder is smaller, counting the integer part. For each decimal digit, make the remainder ten times larger by adding it to itself ten times, then repeat the subtraction. Do this twice. Apply the sign at the end.
Ans. Put three 0s and three 6s on the blank die. There are 36 equally likely outcomes, so each of the 12 sums must occur 3 times. Sum 1 can only be made by 1 plus 0, so three faces must be 0. Then sums 1 to 6 are covered. Three 6s cover sums 7 to 12.
Ans. Convert the Excel column labels to numbers: A = 1, Z = 26, AA = 27, AB = 28. Treat the two points as numeric coordinates, then check whether x1 y2 equals x2 y1. For (2, 27) and (1, 28), 2 × 28 is not 1 × 27, so the line does not pass through the origin.
Ans. Take any 20 coins and put them in one group. Put the remaining 80 in the other group. Then flip every coin in the group of 20. If the 20-coin group originally had k heads, the other group had 20 minus k heads. After flipping, the 20-coin group also has 20 minus k heads.
No question matches those filters. Reset filters.
Showing 60 of 795 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 (70%) and CS fundamentals (13%).
Candidate interviews show an average of 3.9 rounds per experience, with a typical sequence of Online test → Technical → Technical → Managerial. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 18%, medium 61%, hard 21%.
