Microsoft Online Assessment 2026: OA Pattern + Solutions

Quick answer (updated 8 June 2026): Microsoft's new-grad software engineering Online Assessment in 2026 is typically a timed coding test of two to three DSA problems, often delivered on Codility or a similar platform, with auto-graded hidden test cases and partial scoring. Common topics are arrays and strings, hashing, trees, graphs, greedy, and dynamic programming. The pattern below is compiled from 2023 to 2025 candidate reports, not an official spec, so confirm the platform, problem count, and timing in your assessment invite from the Microsoft careers portal.

Microsoft's OA is the first gate for new-grad and intern software roles. It is auto-graded, so there is no benefit of the doubt, only test cases passed. This guide covers the pattern, the topics that repeat, and full worked solutions.

Microsoft OA Structure for New Grads

Based on 2023 to 2025 candidate reports for India and global new-grad and intern batches:

Platform, problem count, and timing are candidate-reported (2023 to 2025) and vary by region and role. Your assessment invite lists the binding details for your test.

Microsoft OA problems are often framed as small business or product scenarios rather than abstract algorithm statements, so read carefully to extract the underlying DSA problem.

Topics That Repeat in the Microsoft OA

Compiled from candidate reports across 2023 to 2025; relative frequency, not an official syllabus:

Relative frequencies from candidate aggregates (2023 to 2025), labelled approximate. Arrays, strings, hashing, and greedy are the safest priorities.

Worked Solution 1: Greedy

Problem: Given start and end times of meetings, find the minimum number of rooms needed so no two overlapping meetings share a room.

Approach: Sort start and end times separately. Sweep through events; a start needs a room, an end frees one. Track the running count and its maximum.

def min_meeting_rooms(intervals):
    starts = sorted(i[0] for i in intervals)
    ends = sorted(i[1] for i in intervals)
    rooms = 0
    best = 0
    s = e = 0
    while s < len(starts):
        if starts[s] < ends[e]:
            rooms += 1
            best = max(best, rooms)
            s += 1
        else:
            rooms -= 1
            e += 1
    return best

Complexity: O(n log n) time for the sorts, O(n) space. Microsoft OA problems often dress this scheduling pattern as servers, CPUs, or platforms; recognise the shape.

Worked Solution 2: Strings and Hashing

Problem: Given a string, return the length of the longest substring with at most two distinct characters.

Approach: Sliding window with a hash map of character counts. Expand right; when distinct characters exceed two, shrink from the left until valid again.

def longest_two_distinct(s):
    count = {}
    left = 0
    best = 0
    for right in range(len(s)):
        count[s[right]] = count.get(s[right], 0) + 1
        while len(count) > 2:
            count[s[left]] -= 1
            if count[s[left]] == 0:
                del count[s[left]]
            left += 1
        best = max(best, right - left + 1)
    return best

Complexity: O(n) time, O(1) space (at most three keys). The generalisation to "at most k distinct" is a common follow-up; the same window works with k in the condition.

Worked Solution 3: Dynamic Programming

Problem: Given an array, return the length of the longest strictly increasing subsequence.

Approach: The O(n log n) patience-sorting method. Maintain a tails array; for each number, binary-search the first tail not less than it and replace it (or append if larger than all).

import bisect

def length_of_lis(nums):
    tails = []
    for x in nums:
        i = bisect.bisect_left(tails, x)
        if i == len(tails):
            tails.append(x)
        else:
            tails[i] = x
    return len(tails)

Complexity: O(n log n) time, O(n) space. The simpler O(n squared) DP also passes smaller inputs, but state the optimal if the interviewer pushes on large constraints.

Worked Solution 4: Graphs

Problem: Given prerequisites as directed edges, determine if you can finish all courses (no cycle).

Approach: Topological sort with Kahn's algorithm. Compute in-degrees, queue zero-in-degree nodes, and process; if you process every node, there is no cycle.

from collections import deque, defaultdict

def can_finish(num_courses, prerequisites):
    graph = defaultdict(list)
    indeg = [0] * num_courses
    for a, b in prerequisites:
        graph[b].append(a)
        indeg[a] += 1
    q = deque(i for i in range(num_courses) if indeg[i] == 0)
    seen = 0
    while q:
        node = q.popleft()
        seen += 1
        for nxt in graph[node]:
            indeg[nxt] -= 1
            if indeg[nxt] == 0:
                q.append(nxt)
    return seen == num_courses

Complexity: O(V + E) time and space. Topological sort is a recurring Microsoft pattern, often disguised as build dependencies or task ordering.

Microsoft OA Timing Strategy

1. Read all problems first. Some OA platforms let you switch freely; solve the easiest first to bank marks.
2. Decode the scenario. Microsoft wraps DSA in product stories; extract the core problem before coding.
3. Use constraints to choose your approach. Large n rules out quadratic solutions.
4. Exploit partial scoring. Submit a working partial solution; do not leave a problem blank chasing optimality.
5. Test edge cases. Empty input, single element, all identical, and boundary values are common hidden tests.
6. Watch the clock per problem. Cap time on a stuck problem and move on; return if time remains.

How to Prepare for the Microsoft OA

• Drill arrays, strings, hashing, and greedy first; they dominate Microsoft OAs in candidate reports.
• Add trees, graphs (BFS/DFS, topological sort), and core DP for the harder slots.
• Practice on the platform your invite names (often Codility), since its editor and submission flow differ from LeetCode.
• Take timed two-to-three-problem mock sets to build the right pacing.

See the Microsoft placement papers 2026 and Microsoft off campus drive 2026 for the wider prep path.

More Worked Solutions

Worked Solution 5: Spiral Matrix Traversal

Return the elements of a matrix in spiral order by shrinking boundaries.

def spiral_order(matrix):
    res = []
    top, bottom = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1
    while top <= bottom and left <= right:
        for c in range(left, right + 1):
            res.append(matrix[top][c])
        top += 1
        for r in range(top, bottom + 1):
            res.append(matrix[r][right])
        right -= 1
        if top <= bottom:
            for c in range(right, left - 1, -1):
                res.append(matrix[bottom][c])
            bottom -= 1
        if left <= right:
            for r in range(bottom, top - 1, -1):
                res.append(matrix[r][left])
            left += 1
    return res

Time O(rows times cols). Simulation problems like this, dressed as a product scenario, are common in Microsoft OAs.

Worked Solution 6: Reverse Linked List in Groups of K

Reverse every k nodes, a frequent Microsoft variant.

def reverse_k_group(head, k):
    node = head
    for _ in range(k):
        if not node:
            return head
        node = node.next
    prev = reverse_k_group(node, k)
    cur = head
    for _ in range(k):
        nxt = cur.next
        cur.next = prev
        prev = cur
        cur = nxt
    return prev

Time O(n). Tests careful pointer handling and recursion.

Worked Solution 7: Min Stack (Design)

Support push, pop, top, and getMin all in O(1) using an auxiliary min stack.

class MinStack:
    def __init__(self):
        self.stack = []
        self.mins = []

    def push(self, x):
        self.stack.append(x)
        self.mins.append(min(x, self.mins[-1] if self.mins else x))

    def pop(self):
        self.mins.pop()
        return self.stack.pop()

    def top(self):
        return self.stack[-1]

    def get_min(self):
        return self.mins[-1]

Time O(1) per operation. A common design-flavoured Microsoft question.

Knowing Your Platform: Codility and Friends

A small but real edge in the Microsoft OA comes from being comfortable with the specific platform your invite names, most often Codility, with HackerRank and Microsoft-hosted variants also reported. These platforms differ from the LeetCode environment many candidates practise in, and the differences can cost time if you meet them for the first time during the timed assessment.

Codility, for instance, has its own editor, its own way of presenting problem statements and constraints, and its own submission and partial-scoring behaviour. Some platforms run your code against visible example tests before the hidden ones, some do not; some let you switch freely between problems, others lock a problem once submitted. Knowing these details in advance means you spend your assessment time solving rather than fumbling with the interface. If your invite names Codility, do a couple of practice problems on it beforehand so the editor, the test-running flow, and the way partial scores are reported are all familiar.

It is also worth confirming the practical setup before you start: a stable internet connection, the language you are fastest in among those offered (commonly C++, Java, Python, and C#), and an understanding of whether the session is proctored. Reading the platform's own instructions in the first minute, before the problem timer dominates your attention, prevents avoidable mistakes like missing that a section locks on submission. None of this replaces strong DSA, but at the margin, platform familiarity converts the same skill into a higher score.

How to Decode Microsoft's Scenario-Wrapped Problems

A distinctive feature of Microsoft's OA is that problems are often framed as small business or product scenarios rather than abstract algorithm statements, and candidates who do not practise for this lose time translating the story into a solvable problem. The skill is to read the narrative, strip away the framing, and identify the underlying data-structures-and-algorithms problem hiding inside it.

For example, a problem might describe users sending messages and ask for the longest stretch where no user repeats, which is the longest-substring-without-repeating-characters sliding-window problem in disguise. Another might describe servers handling requests and ask for the minimum number of servers needed at peak, which is the meeting-rooms interval problem. A third might describe a build system with dependencies and ask for a valid build order, which is topological sort. The narrative changes, but the core pattern is one of the familiar set: arrays and strings, hashing, greedy and intervals, trees, graphs, or dynamic programming.

The practical technique is to pause after reading and explicitly name three things: what the inputs really are (an array of intervals, a graph of dependencies, a string), what is being asked in algorithmic terms (a shortest path, a maximum window, a valid ordering), and what constraints apply (which tell you the target complexity). Once you have translated the scenario into these terms, the solution is usually a pattern you already know. Practising this translation step on a handful of scenario-style problems before your OA pays off directly, because it removes the time tax of decoding under pressure and lets you spend your minutes on the actual coding.

Why Candidates Lose Marks in the Microsoft OA

Candidate reports point to recurring reasons strong candidates underperform:

• Misreading the scenario. Microsoft wraps DSA in product stories; extract the core problem before coding.
• Leaving a problem blank. Partial scoring rewards passing some test cases; always submit a working partial.
• Ignoring constraints. Large inputs rule out quadratic solutions; read constraints to choose your approach.
• Skipping edge cases. Empty input, single element, and boundary values are common hidden tests.
• Poor pacing. Two to three problems in limited time means strict per-problem budgets.

Preparation Timeline (6 to 8 Weeks)

• Weeks 1 to 2: Foundations. Arrays, strings, hashing, and greedy. Solve 30 to 40 problems and practise decoding word problems.
• Weeks 3 to 4: Core DSA. Trees, graphs, BFS, DFS, topological sort, and basic DP.
• Weeks 5 to 6: Simulation and design. Spiral matrix, linked-list variants, and design problems like Min Stack.
• Weeks 7 to 8: Mocks. Timed two-to-three-problem mock OAs on the platform your invite names (often Codility).

Related Resources

• Microsoft off campus drive 2026, eligibility, timeline, and hiring cycle
• Microsoft interview process 2026, the full round-by-round loop after the OA
• Microsoft placement papers 2026, solved past-drive papers
• Microsoft system design pattern bank 2026, design prep for later rounds
• Microsoft fresher salary India 2026, package breakdown
• 7-day coding round crash plan 2026, last-week prep

FAQs: Microsoft Online Assessment 2026

Q: What platform does Microsoft use for its OA?

Candidate reports across 2023 to 2025 most often mention Codility, with HackerRank and Microsoft-hosted variants also reported. Your assessment invite names the exact platform; practise on it beforehand because the editor differs from LeetCode.

Q: How many problems are in the Microsoft OA?

Typically two to three DSA problems in a 60 to 90 minute window, per candidate reports. The count varies by role and region, so treat your invite email as the binding source.

Q: Is there partial scoring in the Microsoft OA?

Yes, candidate reports describe auto-graded hidden test cases with partial credit. Submit a working partial solution rather than leaving a problem blank, and prioritise passing as many test cases as possible.

Q: What topics should I focus on for the Microsoft OA?

Arrays and strings, hashing, and greedy appear most often in candidate reports, followed by trees, graphs (BFS/DFS and topological sort), and dynamic programming. Drill the high-frequency topics first.

Q: Does the Microsoft OA include a behavioural or aptitude section?

For software roles, candidate reports describe a primarily coding OA. Behavioural assessment generally comes later in the interview rounds. Some non-engineering roles include aptitude components; check your invite for the exact sections.

Q: How hard are Microsoft OA problems compared to interviews?

Candidate reports place OA difficulty at easy-medium to medium-hard, with the live interview rounds going deeper with follow-ups and design. Clearing the OA cleanly, with strong test-case coverage, sets up the interview loop.