Copy<\/button><\/div>\n\ndef reverse_list(head):\n\n prev = None\n\n curr = head\n\n while curr:\n\n nxt = curr.next\n\n curr.next = prev\n\n prev = curr\n\n curr = nxt\n\n return prev\n<\/code><\/pre><\/div>Detect and find the start of a cycle in a linked list<\/span>Linked Lists<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Floyd’s cycle detection, the “tortoise and hare.” Move a slow pointer one step and a fast pointer two steps at a time. If they meet, a cycle exists. To find where the cycle begins, reset one pointer to the head and advance both pointers one step at a time; they meet exactly at the cycle’s start node.<\/p>\n
LeetCode #141 (detect) and #142 (find the start) both sit in the Microsoft-tagged set, and 2024 Blind write-ups mention this as a common opener before a harder tree or graph problem in the same round. Interviewers sometimes skip straight to “how would you do this with O(1) extra space,” which rules out the hash-set approach and forces Floyd’s method.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\ndef has_cycle(head):\n\n slow = fast = head\n\n while fast and fast.next:\n\n slow = slow.next\n\n fast = fast.next.next\n\n if slow == fast:\n\n return True\n\n return False\n<\/code><\/pre><\/div>Why Microsoft? What specifically about the team or product interests you?<\/span>Behavioral<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Every company asks some version of this. Microsoft’s version carries more weight than most because the interviewers can usually tell within one sentence whether you’ve researched the team’s actual work. “I want to work on Azure” is not an answer. “I want to work on the Azure Service Bus reliability team because I read the 2024 engineering post about their exactly-once delivery work and I’ve been solving a similar problem at my current company” is an answer.<\/p>\n
If you don’t know which team you’re interviewing with, ask your recruiter before the loop. It’s a completely reasonable question and the recruiter will tell you. Then read the team’s public blog posts, GitHub repos, or recent conference talks. Microsoft’s engineering teams publish more publicly than most people realize.<\/p>\n
<\/div><\/div><\/div>\n
Tell me about a time you had to deliver under a tight deadline. What trade-offs did you make?<\/span>Behavioral<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Be specific about what you cut, what you deferred, and what the cost of those cuts turned out to be in retrospect. The best answers include an honest assessment of whether the trade-off was the right call: “We deferred the error handling to hit the deadline. It turned out that was fine for the initial release but we paid for it three months later when a new edge case hit production. If I were doing it again, I’d have pushed for one more week to add the error handling.”<\/p>\n
Microsoft interviewers don’t expect you to have made perfect calls. They expect you to have reflected on your calls and learned from them. An answer where every trade-off worked out exactly as planned is less credible than one where something went wrong and you can say precisely what you’d do differently.<\/p>\n
<\/div><\/div><\/div>\n
What level is SDE-2 at Microsoft?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
SDE-2 at Microsoft spans two internal levels: Level 61 and Level 62. Level 61 is the entry point for SDE-2 and typically requires 2 to 5 years of industry experience. Level 62 is the senior end of SDE-2, typically 4 to 6 years of experience, and carries higher compensation and a slightly harder interview bar, especially for system design. Some candidates apply for one level and get offered the other based on how the loop goes. Total compensation at L61 averages around $197K; at L62, around $207K, both lower than equivalent levels at Google or Meta.<\/p>\n
<\/div><\/div><\/div>\n
How long does the Microsoft SDE-2 interview process take?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Most candidates report 6 to 10 weeks from application to verbal offer. Internal referrals can compress the timeline to 4 to 5 weeks. The online assessment or phone screen usually happens within 2 weeks of application. The virtual onsite loop is typically 2 to 4 weeks after that. After the loop, debrief and offer turnaround take 1 to 2 weeks, though it can stretch to 3 to 4 weeks if an AA round needs to be scheduled separately.<\/p>\n
<\/div><\/div><\/div>\n
What is the AA round at Microsoft and should I be nervous about it?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
The AA round (As Appropriate) is an additional interview conducted by a senior engineer or principal within the same org. Getting an AA invite is generally a positive signal, it typically means your loop performance was strong enough to warrant a closer look at senior level. The content varies by interviewer: some conduct a coding question plus behavioral, others focus entirely on a systems discussion or on “selling Microsoft” to a candidate they want to hire. A short AA round with a very senior interviewer is not a bad sign. Treat it like another loop round and prepare accordingly.<\/p>\n
<\/div><\/div><\/div>\n
Does Microsoft ask system design questions at SDE-2 level?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Yes, for Level 61 and Level 62 positions. System design is not standard at Level 59 or 60 (new grad SDE and early SDE-1). At SDE-2, expect one dedicated design round of 45 to 60 minutes covering high-level distributed system design. Some loops also include a low-level design (LLD) round focused on object-oriented design and class hierarchy, particularly for roles on platform or API teams. Ask your recruiter before the loop whether both HLD and LLD rounds are included.<\/p>\n
<\/div><\/div><\/div>\n
How important is behavioral preparation for a Microsoft SDE-2 interview?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
More important than most candidates expect. Microsoft evaluates behavioral signals in every round, not just a standalone behavioral interview. The “growth mindset” framework, a company-wide cultural initiative that has been active since 2014 under Satya Nadella, is explicitly used in interview debriefs. Candidates who perform well technically but signal “know-it-all” behavior in their stories, specifically by describing conflicts where they were fully right and others were wrong, have failed loops despite strong coding performance. Have 4 to 5 STAR stories ready with genuine failure examples and genuine learning outcomes.<\/p>\n
<\/div><\/div><\/div>\n
What programming languages does Microsoft accept for coding interviews?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Microsoft accepts any major language for coding rounds. Python, Java, C#, C++, and JavaScript are all reported from recent loops. C# gets a mild reception given Microsoft’s product ecosystem, but it’s not required and offers no scoring advantage. The collaborative code editor in Teams supports all major languages. If your strongest language is Python, use Python. Interviewers at Microsoft are looking at your problem-solving approach, not your language loyalty. The one exception: if you’re interviewing for a role explicitly in the .NET or C# ecosystem, knowing the language idioms will matter for the coding quality discussion.<\/p>\n
<\/div><\/div><\/div>\n
How many coding rounds are in the Microsoft SDE-2 loop?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Typically 2 to 3 dedicated coding rounds inside the virtual onsite loop, plus whatever coding already happened during the OA or phone screen stage. A hiring-manager round often folds in one more coding question alongside behavioral topics, which some candidates count separately and some don’t, which is why the “4 to 6 rounds total” figure shows up in several write-ups. The exact split depends on whether a dedicated system design round is scheduled (L61 and above) and whether an AA round gets added.<\/p>\n
<\/div><\/div><\/div>\n
Is LeetCode practice alone enough to prepare for Microsoft's coding rounds?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
No, not on its own. The algorithmic difficulty at Microsoft SDE-2 sits at LeetCode Medium, which most candidates who’ve done 150 to 200 problems can handle technically. What LeetCode practice alone doesn’t build is the habit of narrating your reasoning out loud before writing code, which Microsoft interviewers weight heavily and note negatively when it’s missing. Practicing the same problems while explaining your approach to another person, or recording yourself, closes that gap faster than doing more problems in silence.<\/p>\n
<\/div><\/div><\/div>\n
If I don't get invited to an AA round, does that mean I failed the loop?<\/span>FAQ<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
Not necessarily. Some teams and some levels skip the AA round entirely as a matter of process, independent of how the loop went. It’s more accurate to say that getting an AA invite is a positive signal, your performance was strong enough that someone wanted a closer look at senior-level judgment, than that skipping it is a negative one. If you’re unsure, it’s reasonable to ask your recruiter directly whether an AA round is part of your specific loop before assuming its absence means anything.<\/p>\n
<\/div><\/div><\/div>\n
What is the difference between a process and a thread?<\/span>OS Fundamentals<\/span>Easy<\/span><\/span><\/span><\/button><\/p>\n
A process is an independent unit of execution with its own memory space, its own set of file handles, and its own address range. The operating system isolates one process from another, so if one process crashes it doesn’t take down another one. Starting a process is relatively expensive because the OS has to allocate a new address space and set up page tables from scratch.<\/p>\n
A thread is a unit of execution that lives inside a process and shares that process’s memory, open file descriptors, and heap with every other thread in the same process. Threads within a process can read and write the same variables directly, which makes communication fast but also introduces race conditions if you’re not careful with locks or other synchronization. Creating a thread is much cheaper than creating a process because the OS only needs to set up a new stack and register set, not a whole new address space.<\/p>\n
The practical tradeoff comes up constantly in system design and in day to day engineering. If you want strong isolation, say running untrusted plugin code or separate services, you reach for processes even though context switching between them costs more. If you need many workers cooperating on the same in-memory data structure, like a thread pool processing requests against a shared cache, threads are the right tool, but you own the responsibility of protecting shared state with mutexes, atomics, or higher level constructs.<\/p>\n
<\/div><\/div><\/div>\n
<\/span>Medium questions<\/h2>24<\/span><\/div><\/div><\/div>\n
Implement an LRU cache<\/span>Data Structures<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Use a hash map for O(1) key lookups combined with a doubly linked list to track access order. The most recently used entry sits at the list head; the least recently used sits at the tail. On a get, move the node to the head. On a put that exceeds capacity, evict the tail node and remove its key from the map.<\/p>\n
This specific problem shows up in multiple independent Microsoft SDE-2 reports from 2024, including at least one account where Round 2 was described as “implement LRU cache, then extend it to support multiple eviction policies.” The eviction policy extension is a natural follow-up: how would you swap LRU for LFU or FIFO without rewriting the entire cache? The answer uses a strategy pattern with an abstracted eviction interface.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\nfrom collections import OrderedDict\nclass LRUCache:\n\n def __init__(self, capacity: int):\n\n self.cap = capacity\n\n self.cache = OrderedDict()\n def get(self, key: int) -> int:\n\n if key not in self.cache:\n\n return -1\n\n self.cache.move_to_end(key)\n\n return self.cache[key]\n def put(self, key: int, value: int) -> None:\n\n if key in self.cache:\n\n self.cache.move_to_end(key)\n\n self.cache[key] = value\n\n if len(self.cache) > self.cap:\n\n self.cache.popitem(last=False)\n<\/code><\/pre><\/div>Find the k-th largest element in an unsorted array<\/span>Heap<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Two approaches: sort and index (O(n log n), trivial to implement), or a min-heap of size k (O(n log k), better for large n with small k). For the heap approach, iterate through the array, push each element, and pop when the heap exceeds size k. At the end, the heap’s minimum is the k-th largest.<\/p>\n
Reported as a phone screen question. Follow-ups probe the space complexity trade-off and whether you’ve heard of Quickselect (O(n) average, O(n^2) worst). Microsoft interviewers don’t always require Quickselect, but knowing it and explaining when you’d choose it over the heap approach demonstrates the kind of reasoning they want to see.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\nimport heapq\ndef find_kth_largest(nums, k):\n\n # min-heap of size k\n\n heap = []\n\n for n in nums:\n\n heapq.heappush(heap, n)\n\n if len(heap) > k:\n\n heapq.heappop(heap)\n\n return heap[0]\n<\/code><\/pre><\/div>Merge k sorted linked lists<\/span>Linked Lists \/ Heap<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Use a min-heap seeded with the head node from each list. At each step, pop the minimum node, append it to the result list, and push that node’s next pointer into the heap (if non-null). Total time complexity O(N log k) where N is the total number of nodes and k is the number of lists.<\/p>\n
Reported from a 2024 onsite. The key correctness trap is what you push into the heap: you need to push the node itself (or a tuple of (value, node) with a tiebreaker) rather than just the value, because you need the pointer to the next node in that list. Python’s heapq doesn’t handle ties on non-comparable objects without an explicit comparator or index tiebreaker.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\nimport heapq\n\nfrom typing import Optional\nclass ListNode:\n\n def __init__(self, val=0, next=None):\n\n self.val = val\n\n self.next = next\ndef merge_k_lists(lists):\n\n heap = []\n\n for i, node in enumerate(lists):\n\n if node:\n\n heapq.heappush(heap, (node.val, i, node))\n dummy = ListNode(0)\n\n curr = dummy\n\n while heap:\n\n val, i, node = heapq.heappop(heap)\n\n curr.next = node\n\n curr = curr.next\n\n if node.next:\n\n heapq.heappush(heap, (node.next.val, i, node.next))\n\n return dummy.next\n<\/code><\/pre><\/div>Find the longest substring without repeating characters<\/span>Sliding Window<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Sliding window with a set or hash map tracking the current window’s characters. Expand the right pointer on each step. When a duplicate character enters the window, advance the left pointer until the duplicate is removed. Track the maximum window length throughout.<\/p>\n
Reported from a 2022 technical round at Microsoft (India), and appears repeatedly in Microsoft-tagged LeetCode problems. It’s a warm-up question in some loops and the main question in others. The follow-up often asks you to return the actual substring rather than just the length, and then asks how you’d handle Unicode multi-byte characters.<\/p>\n
<\/div><\/div><\/div>\n
Group anagrams<\/span>Strings \/ Hashing<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
For each word, compute a canonical key (sorted characters, or a 26-length character count tuple) and use it to bucket words into a hash map. Sorting each word costs O(k log k) for a word of length k; the count-tuple approach is O(k) per word and faster for longer strings. Return the map’s values as the grouped lists.<\/p>\n
LeetCode #49, Microsoft-tagged, reported repeatedly as a phone-screen question in 2024 and 2025 GeeksforGeeks candidate write-ups. The follow-up worth preparing for: what if the input has hundreds of millions of words and doesn’t fit on one machine? That turns a 10-minute coding question into a short distributed-systems tangent (shard by hash of the key, reduce locally, merge), and interviewers tend to like watching candidates make that jump unprompted.<\/p>\n
<\/div><\/div><\/div>\n
Search in a rotated sorted array<\/span>Binary Search<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Modified binary search. At each step, at least one half of the array (left of mid or right of mid) is guaranteed to be properly sorted. Check which half is sorted, then check whether the target falls inside that half’s range. If it does, search there; if not, search the other half. This keeps the O(log n) guarantee without ever fully sorting the rotated array.<\/p>\n
LeetCode #33, one of the most frequently cited Microsoft-tagged problems across Glassdoor and LeetCode Discuss write-ups from 2023 through 2025. The follow-up almost always adds duplicates to the array, which breaks the “at least one half is sorted” invariant; the fix is a linear-time fallback when nums[left] equals nums[mid] equals nums[right].<\/p>\n
python<\/span>Copy<\/button><\/div>\n\ndef search(nums, target):\n\n lo, hi = 0, len(nums) \u2013 1\n\n while lo <= hi:\n\n mid = (lo + hi) \/\/ 2\n\n if nums[mid] == target:\n\n return mid\n\n if nums[lo] <= nums[mid]:\n\n if nums[lo] <= target < nums[mid]:\n\n hi = mid \u2013 1\n\n else:\n\n lo = mid + 1\n\n else:\n\n if nums[mid] < target <= nums[hi]:\n\n lo = mid + 1\n\n else:\n\n hi = mid \u2013 1\n\n return -1\n<\/code><\/pre><\/div>Rotate an N x N matrix 90 degrees in place<\/span>Arrays \/ Matrix<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Two passes, no extra matrix. First, transpose the matrix (swap element [i][j] with [j][i] across the diagonal). Second, reverse each row. The combination produces a clockwise 90-degree rotation using O(1) extra space. Doing it in a single pass with four-way cell swapping, layer by layer, is the harder but more elegant version some interviewers ask for as a follow-up.<\/p>\n
LeetCode #48, reported in Microsoft phone screens and in at least one 2025 onsite account on GeeksforGeeks. The trap most candidates fall into: reversing columns instead of rows, or transposing after reversing instead of before, which rotates the matrix the wrong direction. Walking through a 3×3 example on paper before touching the keyboard catches this early.<\/p>\n
<\/div><\/div><\/div>\n
Zigzag level order traversal of a binary tree<\/span>