Microsoft Placement Papers: Sample Questions and Prep Guide

Microsoft’s campus OA gives you two coding problems and 60 minutes. No aptitude paper, no verbal reasoning section, no logical reasoning warmup that other IT-services recruiters stack onto their tests.

That single structural fact changes how you should prepare. There are no easy marks to pad your score. Both problems count. The “placement papers” that circulate online are not a downloadable test bank; they are problem descriptions reconstructed from memory by candidates who cleared previous drives. That’s useful, but it means you need to treat them as a guide to question archetypes, not an exact answer key.

What “Placement Papers” Means for Microsoft

The phrase “placement paper” comes from the era of written aptitude tests that most Indian campus recruiters used in the 2000s and early 2010s. Companies printed question booklets, students answered in OMR sheets, and old papers circulated as study material.

Microsoft’s campus test has never followed that format. The online assessment is a live coding session on a shared platform. For the full test structure, CGPA cutoff details, and a topic-by-topic syllabus, the Microsoft placement papers test pattern guide covers that in detail.

What this guide covers: problem types that appear repeatedly across reported Microsoft OAs, classified by topic with brief notes on approach and difficulty. Treat each one as an archetype to practise, not a question to memorise.

Roles are listed on Microsoft Careers India; campus drives are coordinated through individual placement cells.

Sample Problem Types from Past Microsoft OAs

These problem archetypes appear across multiple candidate reports from Microsoft campus drives at Indian engineering colleges between 2020 and 2025. They are not a complete list, and exact wording varies. The purpose is calibration: understanding what category of problem shows up and at what difficulty level.

Arrays and Binary Search

• Rotated Sorted Array Search: Given a sorted array that has been rotated at an unknown pivot, find the index of a target value. Return -1 if not found.

  • Approach: Modified binary search. Determine which half is sorted at each step, then check whether the target falls in that range.
  • Difficulty: LeetCode Medium.

• Product of Array Except Self: Return an output array where each element is the product of all other elements, without using division.

  • Approach: Two-pass prefix/suffix product. No division needed.
  • Difficulty: LeetCode Medium.

Trees and BSTs

• BST Inorder Successor: Given a node in a BST, return the node with the next larger value (its inorder successor).

  • Approach: If the node has a right subtree, the successor is the leftmost node in that subtree. Otherwise, walk up ancestors.
  • Difficulty: LeetCode Medium.

• Sorted Array to Height-Balanced BST: Convert a sorted array into a height-balanced binary search tree.

  • Approach: Recursive. Pick the midpoint as root, recurse on left and right halves.
  • Difficulty: LeetCode Easy-Medium.

• Largest BST Subtree: In a binary tree (not necessarily a BST), find the subtree that is itself a valid BST and has the maximum number of nodes.

  • Approach: Post-order traversal. For each node, verify BST property and track size, min, and max.
  • Difficulty: LeetCode Hard.

Linked Lists

• Modified Linked List — Retain-Delete Pattern: Given a linked list, retain the first a nodes, delete the next b nodes, and repeat this pattern to the end of the list.
  • Approach: Pointer manipulation in a single pass. Maintain a current pointer; count a steps forward, then skip b nodes.
  • Difficulty: LeetCode Medium.

Backtracking and Combinatorics

• Power Set: Given a set of distinct integers, return all possible subsets (the power set).
  • Approach: Backtracking or bit manipulation. For a set of n elements, there are 2^n subsets.
  • Difficulty: LeetCode Medium.

Object-Oriented Design

• Calendar Class: Design a class that stores recurring calendar events and returns all events that fall between two given dates.

  • Approach: Define an event with a start date, recurrence type, and end date. The query method iterates through stored events and checks overlap. This tests class design and edge-case thinking more than algorithmic complexity.
  • Difficulty: Design (no direct LeetCode equivalent; assess OOP clarity).

• Process vs. Thread: Explain the differences. Not a coding problem, but a conceptual question that appears in written sections at some campuses.

  • Key points: Processes have separate memory spaces; threads within a process share memory. Context-switching between processes is heavier than between threads.

Topic Frequency in Microsoft Placement Papers

The table below maps topics to their relative frequency across reported Microsoft OAs and names representative LeetCode problems to practise for each.

Topic	Frequency	Representative problems
Binary trees and BSTs	High	LeetCode 285, 108, 1373, 98
Arrays and binary search	High	LeetCode 33, 238, 153
Linked lists	Medium-High	LeetCode 1474, 206, 143
Dynamic programming	Medium	LeetCode 322, 198, 62
Graphs (BFS/DFS)	Medium	LeetCode 200, 133, 207
Backtracking	Medium	LeetCode 78, 46, 79
OOP and design	Lower	Class design problems
OS concepts	Lower	Conceptual only

LeetCode’s Microsoft company tag filters problems that appear most frequently in Microsoft interview sessions. It is the closest thing to a curated practice set. Sort by frequency and start at the Medium level.

Four-Week Preparation Plan

This plan assumes basics are in place: you can write a loop, know what a pointer is, and have seen recursion at least once. If you are starting from zero, extend to six weeks using the plan in the Microsoft test pattern and syllabus guide.

Week	Focus	Daily target
Week 1	Arrays, strings, binary search	3 LeetCode Medium problems per day
Week 2	Trees (binary trees, BST, traversals)	3 problems per day; include at least 2 BST problems
Week 3	Linked lists, backtracking, DP foundations	3 problems per day; 1 design problem per day
Week 4	Graphs (BFS/DFS), mock OAs under 60-minute timer	2 problems per day plus 2 timed 60-minute sessions

A few specifics that matter in practice:

• Solve problems in C++ or Java if you have a choice. Python is accepted on most platforms but runtime constraints on large test cases can be tighter.
• When you reach a working solution, spend five more minutes asking: can the time complexity improve? What happens if the input has duplicates? This is exactly the follow-up pattern in the interview rounds described in the Microsoft freshers interview guide.
• If you cannot solve a problem in 30 minutes during practice, look at the approach, not the full solution. Read just enough to unblock, then implement from there.
• A second set of practice questions and worked examples is available in the Microsoft interview questions for freshers guide.

Common Mistakes in Microsoft OA Preparation

Solving too many easy problems

LeetCode Easy builds fluency; it does not build the problem-solving muscle the Microsoft OA tests. After the first week, the bulk of practice should be at Medium.

Ignoring the 60-minute timer

Most candidates practising on LeetCode never time themselves. The OA is 60 minutes for 2 problems, which means roughly 25 minutes per problem with buffer. Practise timed sessions starting in Week 4.

Preparing for an aptitude test that doesn’t exist

Some older “Microsoft placement paper” PDFs circulating online include verbal reasoning, logical reasoning, and quantitative sections. Microsoft’s current OA has none of those. Don’t spend time on sections the test doesn’t have.

Submitting without checking edge cases

A partial solution scores partial credit on some platforms, but the bar for shortlisting is a fully correct solution to at least one problem and a strong attempt at the second. Think about edge cases before submitting: empty arrays, single-node trees, null pointers.

The power-set and calendar-design problems in the sample section above both require you to decompose a problem into smaller, composable pieces before writing a single line of code. That same structured decomposition (breaking a complex task into well-defined sub-problems) is exactly what AI application development demands. TinkerLLM is a ₹299 entry point to apply that thinking to LLM-based applications, if the build side of software interests you alongside the placement side.