2,029 questions from 282 interviews · updated from reports 2015-2025
About
Microsoft is a technology company that builds software, cloud services, devices, and tools such as Windows, Azure, Microsoft 365, and GitHub. In India, it is known for hiring software engineers and software engineering interns for product, cloud, and platform teams.
The roles that come up most are Software Engineer, Software Engineering Intern and Software Engineer Intern. This covers 282 candidate interviews reported from 2015 to 2025. The largest group sat it at internship level (126 of 275 that recorded a level). Among the 196 that recorded either route, arrivals split between campus drives (129, 66%) and off-campus applications (67, 34%). Most questions fall under DSA and CS fundamentals.
Ans. Use level order traversal with a queue, linking each node to the next node removed from the same level. For each level, process exactly its current queue size, keep a previous pointer, set previous.next to current, and set the last node’s next to null. Time is O(n), space is O(width).
Ans. A process is an independent running program with its own memory space, while a thread is a smaller unit of execution within a process that shares that process’s memory. Processes are more isolated and cost more to create or switch between. Threads are lighter, but shared memory makes synchronisation and race conditions important.
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. Use expand around centres: for each index, expand once for an odd-length palindrome and once between indices for an even-length palindrome, tracking the best start and length. The key detail is handling both centre types. This uses only a few variables, runs in O(n squared) time, and uses O(1) extra space.
Ans. Use Kadane’s Algorithm by scanning the array once, keeping the best sum ending at the current index and the best sum seen overall. At each element, either extend the current subarray or start a new one there. It uses only variables, runs in O(n) time, and O(1) space.
Ans. Traverse the matrix layer by layer using four boundaries: top, bottom, left, and right. Print the top row, right column, bottom row, and left column, then move the boundaries inward. No extra data structure is needed apart from the output. Time complexity is O(mn), and space is O(1).
Ans. Use a single pass dynamic approach, keeping the maximum and minimum product ending at each position. The key detail is that a negative number can turn the minimum product into the maximum, so update both values for every element. Track the best maximum seen overall. This runs in O(n) time and O(1) space.
Ans. Use the Boyer Moore voting algorithm to find the majority element in one pass. Keep a candidate and a count: set the candidate when count is zero, increment for matches, decrement otherwise. If a majority is not guaranteed, verify the candidate with a second pass. Time is O(n), space is O(1).
Ans. Use Floyd’s slow and fast pointer method to detect the loop, then remove it by finding the node where the cycle starts and setting the previous node’s next pointer to null. After slow and fast meet, move one pointer to head and advance both one step at a time. Time is O(n), space is O(1).
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. Use the patience sorting approach: maintain an array where each position stores the smallest possible tail value for an increasing subsequence of that length. For each number, binary search the first tail greater than or equal to it and replace it. This gives the LIS length in O(n log n) time and O(n) space.
Ans. Check it by traversing the tree recursively with an allowed value range for each node. The root can have an infinite range; the left child must be less than the node, and the right child greater. Use the call stack as the data structure. Time complexity is O(n), space is O(h).
Ans. Use a recursive depth first search: if the current root is null or equals either target node, return it. Search left and right subtrees. If both return non-null, the current root is the LCA; otherwise return the non-null side. This uses the call stack, with linear time and tree-height space.
Ans. Use a sliding window and a hash map of each character’s most recent index to find the longest substring without repeats. Move the right pointer through the string; if a character was seen inside the current window, move the left pointer just after its previous index. Track the maximum window length. Time is O(n), space is O(k).
Ans. Use a greedy two pointer method after checking that at most one character has an odd frequency; otherwise it is impossible. Match the left character with the nearest same character from the right, then bubble it to the right position using adjacent swaps. If no match exists, move it one step towards the centre. Time is O(n²).
Ans. Clone it by first creating a copy node for every original node, storing original to copy in a hash map, then set each copy’s next and random using that map. The key detail is to create all nodes before wiring random pointers. This takes O(n) time and O(n) extra space.
Ans. Reverse the linked list, add 1 with carry from the least significant digit, then reverse it back. Traverse nodes, updating each digit and propagating carry while it is 1. If carry remains after the last node, append a new node with digit 1. This uses the list itself, runs in O(n) time and O(1) extra space.
Ans. Use breadth first search with a queue. Put the root in the queue, then repeatedly remove the front node, visit it, and add its left and right children if they exist. This visits nodes level by level from left to right. The time complexity is O(n), and the space complexity is O(w), where w is the maximum width.
Ans. A mutex is a lock for exclusive access by one thread, while a semaphore is a counter that allows a fixed number of threads to access a resource. The key difference is ownership: the thread that locks a mutex should unlock it, but a semaphore can be signalled by another thread.
Ans. Use an explicit stack to simulate the recursive calls. Start at the root, push nodes while moving left, then pop the top node, visit it, and move to its right child. Repeat until both the current node is null and the stack is empty. Time complexity is O(n), space is O(h).
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. I would choose NoSQL over an RDBMS when the data is large scale, fast changing, semi-structured, or needs horizontal scaling. The key trade-off is that NoSQL often relaxes strict relational modelling and joins to gain flexibility, high write throughput, distributed storage, and easier schema evolution.
Ans. Reverse the linked list in groups of k by first checking that k nodes exist, then reversing only that block. Use a dummy head and three pointers: previous group tail, current node, and next node. After each reversal, reconnect the reversed block to the list. Leave fewer than k remaining nodes unchanged. Time is O(n), space is O(1).
Ans. Use an eager static instance or a lazy holder pattern, where the class keeps one private static instance and exposes it through a public accessor. The constructor is private to stop external creation. Class loading gives thread safety without explicit locking. Access is constant time, and the only storage is one object reference.
Ans. Use dynamic programming where dp[i][j] stores the length of the longest palindromic subsequence inside s[i..j]. If s[i] equals s[j], set it to 2 plus dp[i+1][j-1], otherwise take the maximum of excluding either end. Fill by increasing substring length. Time is O(n²), space is O(n²).
Ans. Garbage Collection in Java automatically reclaims heap memory used by objects that are no longer reachable from live references. The collector starts from GC roots such as stack variables, static fields and active threads, marks reachable objects, then frees or compacts the rest. Most collectors are generational, because short-lived objects are common.
Ans. Reverse each group of k nodes by iterating through the list and reversing pointers within the current group, then connect the previous group’s tail to the new head. Use only node pointers, not an extra data structure. If fewer than k nodes remain, usually leave them unchanged. Time complexity is O(n), space is O(1).
Ans. Use two heaps: a max heap for the lower half and a min heap for the upper half. Insert each number into the correct heap, then rebalance so their sizes differ by at most one. The median is the larger heap’s top, or the average of both tops. Insertion is O(log n), median lookup is O(1).
Ans. Use a 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. If it does, search there, otherwise search the other half. For distinct elements, this takes O(log n) time and O(1) space.
Ans. React virtualization renders only the visible part of a large list or grid, plus a small buffer, instead of rendering every item in the DOM. It is needed because thousands of DOM nodes make rendering, scrolling, layout and memory usage slow. Libraries such as react-window calculate which items to show from scroll position.
Ans. Use a patience sorting approach: maintain an array tails, where tails[i] is the smallest possible tail value of an increasing subsequence of length i + 1. For each number, binary search its position in tails and replace or append it. The length of tails is the LIS length. Time complexity is O(n log n).
Ans. Use a hash map where the key is a canonical form of each string and the value is the list of words matching that key. For each word, sort its characters to form the key, then append the word to that group. Time complexity is O(n k log k), where k is word length.
Ans. Use level order traversal with a queue, and link each node to the next node removed from the same level. Track the number of nodes in the current level, keep a previous pointer, and set the last node’s next pointer to null. This takes O(n) time and O(w) space, where w is tree width.
Ans. Use a stack to convert infix to postfix by scanning the expression left to right and outputting operands immediately. Push opening brackets, pop until an opening bracket on closing brackets, and for operators pop higher or equal precedence operators before pushing the current one. Finally pop remaining operators. This runs in O(n) time.
Ans. Use reverse inorder traversal, visiting right, node, then left, and count visited nodes until the count reaches k. The kth visited node is the kth largest because BST inorder order is sorted. Use recursion or an explicit stack. Time is O(h + k) on average, O(n) worst case, with O(h) space.
Ans. Build a hashmap from node value or id to node reference, find the two nodes in O(1), then swap the nodes by updating their prev and next links. Handle adjacent nodes and head or tail changes carefully. Building the map takes O(n) time and O(n) space; the swap is O(1).
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 every cell, and when you find an unvisited 1, count one island and run DFS to mark all connected 1s. The DFS explores up, down, left and right using recursion or a stack, with a visited matrix or by changing 1 to 0. Time is O(rows × cols), space is O(rows × cols).
Ans. I would avoid forcing very large data through one reducer by repartitioning the key space or using a two-stage aggregation. The key detail is to reduce data before the final reducer, using combiners or partial reducers, so the last step only merges compact intermediate results rather than processing all raw records.
Ans. Virtual memory is a memory management technique where the operating system gives each process the illusion of a large, continuous private address space. It maps virtual addresses to physical RAM using page tables, and can store inactive pages on disk. The key benefit is isolation, efficient RAM use, and support for programs larger than physical memory.
Ans. Build it by scanning preorder once and inserting each value into the valid BST range using recursion. Keep a shared index and pass lower and upper bounds for each subtree; if the next value is outside the range, return null. This uses the call stack as the data structure and runs in O(n) time.
Ans. Implement it with a hash map plus a doubly linked list. The map stores keys to list nodes, and the list keeps usage order, with most recently used at the front and least recently used at the back. On get or put, move the node to the front. When full, remove the tail. All operations are O(1).
Ans. Use a hash map plus a doubly linked list to implement an LRU cache in O(1) get and put time. The map stores key to node, and the list stores usage order. On get, move the node to the front. On put, update or insert, and evict the tail if capacity is exceeded.
Ans. Use prefix minima and suffix maxima, then scan with two pointers to find the farthest valid pair. Build leftMin[i] as the minimum value up to i and rightMax[j] as the maximum value from j to the end. If rightMax[j] > leftMin[i], update the answer and move j; otherwise move i. Time is O(n), space is O(n).
Ans. Transpose the matrix in-place, then reverse each row in-place. Transposing swaps matrix[i][j] with matrix[j][i] across the main diagonal, and reversing each row moves columns into their clockwise rotated positions. This uses the matrix itself as the data structure, takes O(n²) time, and uses O(1) extra space.
Ans. Use a recursive DFS: if the current node is null, return null; if it is one of the target nodes, return it. Recurse into left and right subtrees. If both sides return non-null, the current node is the LCA; otherwise return the non-null side. Time is O(n), space is O(h).
Ans. Build parent pointers with one DFS, then run BFS from the given leaf treating left, right and parent as neighbours; print nodes reached at level K. Use a queue and a visited set to avoid going back and forth. This takes O(n) time and O(n) extra space.
Ans. Print root, then the right boundary top down excluding leaves, then all leaf nodes from right to left, then the left boundary bottom up excluding leaves. Use simple tree traversals: prefer right child on the right boundary, left child on the left boundary. Time is O(n), with O(h) recursion space.
Ans. Compute the intersection by solving the two parametric segment equations, then check that both parameters lie between 0 and 1. Write each segment as p + t r and q + u s. If cross(r, s) is zero, handle parallel or collinear overlap separately. Otherwise, the point is p + t r. Time is O(1).
Ans. Use a greedy max heap of character frequencies: repeatedly take the two most frequent remaining characters, append both, decrement their counts, and push back any still left. This avoids placing equal characters together. The key feasibility check is that no character may appear more than (n + 1) / 2 times. Time is O(n log k).
Ans. Use a hybrid fanout design: precompute feeds for normal users, but fetch and rank posts from celebrities or high fanout accounts at read time. Store posts, friendships, and per-user feed entries separately. A ranking service scores candidates by relevance, freshness, and engagement. Use caches, queues, sharding, deduplication, and eventual consistency for scale.
Ans. Find the two nearest multiples of m around n. Compute q = n divided by m, then take lower = m × floor(q) and upper = m × ceil(q). Compare n - lower with upper - n. The smaller difference gives the answer. If they are equal, use the rule stated in the question, often the larger multiple.
Ans. Choose a real situation with competing deadlines, changing priorities, and clear consequences. Emphasise how you assessed urgency and impact, clarified expectations, planned focused work, communicated trade-offs, and adjusted when needed. Interviewers listen for structure, judgement, reliability, stakeholder awareness, and evidence that you deliver important work without becoming reactive.
Ans. Pick a real conflict where you had a clear role in improving the outcome, not just blaming others. Emphasise listening, understanding each person’s priorities, staying calm, and moving the team towards a decision. Interviewers listen for maturity, accountability, communication, and evidence that the relationship and result both improved.
Ans. Each ant has two choices, clockwise or anticlockwise, so there are 2³ = 8 equally likely direction combinations. They avoid collision only if all three choose the same direction, giving 2 safe cases. Therefore the probability of no collision is 2/8 = 1/4, and the probability of collision is 3/4.
Ans. A strong answer should take a balanced view: India can become far more digital, but not completely cashless soon. Use examples like UPI growth, rural access, small merchants, trust, internet reliability and financial literacy. Emphasise inclusion, infrastructure and behaviour change. Interviewers listen for practicality, awareness of India’s diversity and avoidance of extreme claims.
Ans. For any twin primes greater than 3, write them as n − 1 and n + 1. Since both are odd primes, n is even. Among three consecutive numbers n − 1, n, n + 1, one is divisible by 3. It cannot be either prime, so n is divisible by 3. Hence n is divisible by 6. The pair 3 and 5 is the exception.
Ans. ABCD is 2178. Since 4 × ABCD is still four digits, A is 1 or 2. The last digit gives 4D ending in A. Testing possible carry values, A must be 2 and D must be 8. Then column multiplication gives C = 7 and B = 1, so 2178 × 4 = 8712.
Ans. Break the estimate into simple drivers, state clear assumptions, calculate step by step, then sanity check the result. Use population, frequency, time, capacity, or price as needed. Round numbers to keep it manageable. The exact answer matters less than a logical structure, reasonable assumptions, and checking whether the final number feels plausible.
Ans. You cannot find a number unless the triangle’s leg length is given. If equal legs are L and squares are parallel to the legs, split it into horizontal strips of height 2. In each strip fit floor((L minus strip top height) / 2) squares, then add the row counts. For L = 2n, total is n(n−1)/2.
No question matches those filters. Reset filters.
Showing 60 of 2,029 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 (63%) and CS fundamentals (23%).
Candidate interviews show an average of 4.1 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 30%, medium 60%, hard 10%.
