The Problem Solving (Basic) test asks two things of you, in order. First, can you reason about the core data structures on paper: say how the running time of a loop grows, what a short routine prints, and which structure suits a job and why. Second, can you turn that reasoning into code that passes a judge's hidden tests. The first half is multiple-choice questions; the second is easy problems from the coding catalogue, in whatever language you write best.
It is the right test once you have worked through arrays, hash maps, linked lists, stacks, queues and binary trees, and can solve an easy problem without looking anything up. Its questions do not cover graph algorithms, heap operations or dynamic-programming tables; those belong to the Problem Solving (Intermediate) test.
What the multiple-choice questions examine
Most questions show a short program in plain Python and ask what it prints or returns, or how its cost grows with the input. Others describe a structure or an algorithm and ask which statement about it holds. A few ask you to select every correct option. By topic:
- Complexity analysis. Give the tightest Big-O bound for loops and simple recursive functions by counting how many times the work runs, for time and for memory. Time and Space Complexity covers the method.
- Arrays and strings. Index arithmetic without off-by-one errors, in-place updates, and the scanning patterns that replace a quadratic search with a single pass: two pointers, prefix sums and the sliding window.
- Hashing. Counting and lookups with a map or a set, what a collision is and how a table resolves it, and when hashing's constant time actually holds. Hashing: Hash Maps and Hash Sets.
- Linked lists. Following and rewiring
nextpointers: traversal, insertion, deletion, reversal, and the cost of each operation next to an array's. Linked Lists. - Stacks and queues. LIFO against FIFO, the problems a stack solves naturally, and what each operation costs. Stack and Queues and Deques.
- Sorting and searching. Binary search and its boundary variants, the best and worst cases of the common sorts, and what a stable sort guarantees. Sorting Algorithms.
- Recursion and memoization. Base cases, tracing a call tree, and spotting the repeated subproblems a cache removes. Recursion.
- Trees and binary search trees. The three depth-first traversal orders, insertion and search in a BST, and how a tree's shape decides its cost. Binary Trees and Binary Search Tree.
How the coding round works
The coding problems are easy ones from the published catalogue, chosen for your sitting, and you may answer in any of the 13 languages the editor supports. In each language the editor gives you a function to complete, with its parameters and return type already written: the input is parsed and passed in for you, and the value you return is compared with the expected answer, so there is no input reading or output formatting to get wrong. The statement is shown on its own, with no topic tags, hints or links to related problems, so recognising that a problem wants a hash map or two pointers is part of what is being tested.
Run checks your code against the visible examples. Submit runs it against the hidden cases, and each case you pass earns its share of the problem's marks; your best submission per problem stands. That makes the order of work simple: get a correct solution in, even a slower one, then improve it if time allows. A submission that does not compile scores nothing, so a plain loop that works beats a clever one that does not.
The hidden cases go further than the examples. Before you submit, ask what your code does with an empty input, a single element, all-equal values, negative numbers and the largest sizes the statement allows. Pasting into the editor is switched off, and a solution that closely matches the problem's published editorial can be flagged for review, so practise writing your own code from a blank file.
A preparation path that fits the paper
The DSA roadmap covers this ground in order. Its Foundations tier (arrays, hashing, strings, two pointers, sliding window and prefix sums), the Stacks, Binary Search and Sorting & Greedy stages of the Core tier, and the linked-list, recursion and binary-tree lessons are the Basic syllabus; every stage has written lessons and a set of problems to clear. Topic hubs give you more of the same: arrays, strings, hash table, two pointers, stack, binary search, sorting and trees. For the multiple-choice style, the Data Structures & Algorithms MCQs are a good warm-up.
Two habits matter more than the number of problems you solve. Trace by hand: take a five-element input, write down every variable after each pass of the loop, and only then read the answer. The multiple-choice half rewards exactly that care, and it is how you catch your own bugs in the coding half. And say the complexity out loud before you write code: if the plan is O(n²) and the input can be large, find the O(n) idea first.
Where marks slip away
- Reading the shape instead of the work. Two nested loops are not automatically O(n²), and one loop is not automatically O(n); count what the inner work actually does each time round.
- Tracing in your head. A program that looks obvious is often the one with an off-by-one in its loop bound. Write the state down.
- Half-checking a "select all" question. Only the exact set of correct options scores, so judge every option on its own rather than stopping at the first true one.
- Saving the submission for the end. Partial credit is per case and the best submission counts, so an early working answer is insurance, not a commitment.
- Picking a language for the occasion. The coding round is not the place to try the language you mean to learn next.