AI InterviewSearch…Search problems, topics, or pages…Ctrl KGet started
All skill tests

Problem Solving (DSA) · Intermediate skill test

Problem Solving (Intermediate)

Trees, graphs, heaps, dynamic programming and the trade-offs between them — then two medium problems in the language of your choice.

Pass at 60%Distinction at 85%Proctored · full screenNo negative markingCode in any languageValid 2 years

Quick answer

What does the Problem Solving (DSA) Intermediate skill test cover?

It certifies that you can choose, justify and implement the right algorithm for a medium-sized problem. Multiple-choice questions examine binary search trees, heaps, graph algorithms, dynamic programming, greedy correctness, amortised and recursive complexity, hash-table internals and advanced searching and sorting. Then you solve medium problems from the coding catalogue in any of the 13 supported languages, judged on hidden test cases with partial credit.

The sitting

60% pass85%0100

60%

to pass

1h 20m

total time

17

questions

7 days

to retake

Start the test

The clock starts as soon as you click. Every sitting draws a fresh paper.

Proctored sitting

  • Laptop or desktop only, with a webcam. Phones and tablets can't start a test.
  • The test runs full screen, with the site's navigation hidden.
  • Your webcam stays on and is checked on your computer — nothing is recorded or uploaded.
  • Leaving full screen, switching tab or window or minimising blurs the paper — and so does the camera seeing no one, someone else, a phone, or you looking away. The clock keeps running.
  • Each is a warning; the third ends the sitting, graded as not passed.
  • Pasting, copying, right-click and printing are off.

The paper

2 sections, sat in order, each on its own clock — 1h 20m in all.

1

Concepts

15 Q · 15 marks

20 min

One mark a question, no negative marking. Some questions show a short program and ask what it returns or prints; others ask about complexity and the right structure for a job. A few ask you to select every correct option, and only the exact set scores.

2

Coding

2 problems · 35 marks

1h

Use any language. Run checks the visible cases; Submit runs every hidden case and your best submission per problem is what counts, with partial credit for each case passed.

What it covers

Every paper takes its share from each of these 8 topics, so no two sittings lean the same way.

  1. 01

  2. 02

  3. 03

  4. 04

  5. 05

  6. 06

  7. 07

  8. 08

Intermediate problem solving is less about knowing a structure and more about choosing between several, and being able to say why the choice is right. The concepts section hands you an algorithm, a recurrence or a claim about one and asks what it produces, what it costs, or whether it holds. The coding section then gives you medium problems from the catalogue, where the first idea that comes to mind is often too slow and the right one has to be found and written without help.

Sit it when a medium problem takes you one solid attempt rather than three, and when you can explain an algorithm's correctness as well as its steps. If arrays, hashing, linked lists and stacks still feel shaky, start with the Problem Solving (Basic) test; neither level requires the other.

What the concepts section asks

Questions are short and exact: a few lines of code to trace, a structure built up step by step, a recurrence to solve, or a statement about an algorithm to accept or reject. Several ask you to pick every correct option. Expect to be asked why as often as what.

Medium problems under the clock

The coding problems are medium ones from the published catalogue, chosen for your sitting, and you may answer in any of the 13 languages the editor offers. A medium problem usually joins two ideas: sort and then sweep, search a grid breadth-first, binary-search an answer with a greedy check inside, or fill a table over prefixes. The statement carries no topic tags and no hints, so naming the technique is the first part of the work. As in the practice workbench, you complete a function whose signature is given and return the answer; the judge supplies the input.

Spend the first minutes on a plan. Read the input limits, decide what complexity they allow, and write the approach as two or three comments before any code. Then get a correct version submitted, because each hidden case you pass earns its share and your best submission per problem stands; improve it afterwards if time allows. Keep in mind that the hidden cases run in large batches, each on one time budget: a solution that is far too slow can be stopped part-way through, and every case it had not reached scores nothing.

Expect the hidden cases to probe what easy problems forgive: graphs that are disconnected or contain cycles, repeated keys and ties, empty ranges, and chains long enough to overflow a deep recursion. In Python the default recursion limit is about a thousand frames, so a depth-first search over a long path is safer with an explicit stack. Pasting into the editor is switched off, and code that closely matches the problem's published editorial can be flagged for review.

A study plan built on the roadmap

The DSA roadmap teaches this level in its later stages: Heaps, Intervals and Sorting & Greedy in the Core tier, the two graph stages in the Advanced tier, and Dynamic Programming I and II in Mastery. Each stage has written lessons, problems to clear, and a chest at the end of its tier. For more practice on one technique, the topic hubs order their problems from easy to hard: heap, graph, breadth-first search, depth-first search, shortest path, topological sort, union-find, minimum spanning tree, dynamic programming, memoization, greedy, intervals and binary search.

Two habits turn practice into the kind of understanding the concepts section examines. After each medium problem you solve, write one sentence on why the approach is correct (the invariant, the exchange argument or the recurrence) and one on its running time. And for each algorithm you learn, find out what kind of input it was not built for; knowing where a technique stops working is half of knowing when to reach for it.

Problem Solving (DSA) Certification Test (Intermediate)

A free 80-minute Problem Solving (DSA) skill test at intermediate level. Pass with 60% to earn a verifiable CodeKairo credential and a profile frame.

  • Skill: Problem Solving (DSA)
  • Level: Intermediate
  • Duration: 80 minutes
  • Questions: 17
  • Pass mark: 60% (distinction at 85%)
  • Credential: Verifiable, valid for 2 years

Trees, graphs, heaps, dynamic programming and the trade-offs between them — then two medium problems in the language of your choice.

What does the Problem Solving (DSA) Intermediate skill test cover?

It certifies that you can choose, justify and implement the right algorithm for a medium-sized problem. Multiple-choice questions examine binary search trees, heaps, graph algorithms, dynamic programming, greedy correctness, amortised and recursive complexity, hash-table internals and advanced searching and sorting. Then you solve medium problems from the coding catalogue in any of the 13 supported languages, judged on hidden test cases with partial credit.

Sections

SectionQuestionsTimeKindMarks each
Concepts1520 minMultiple choice1
Coding260 minCoding17.5

What it covers

Intermediate problem solving is less about knowing a structure and more about choosing between several, and being able to say why the choice is right. The concepts section hands you an algorithm, a recurrence or a claim about one and asks what it produces, what it costs, or whether it holds. The coding section then gives you medium problems from the catalogue, where the first idea that comes to mind is often too slow and the right one has to be found and written without help.

Sit it when a medium problem takes you one solid attempt rather than three, and when you can explain an algorithm's correctness as well as its steps. If arrays, hashing, linked lists and stacks still feel shaky, start with the Problem Solving (Basic) test; neither level requires the other.

What the concepts section asks

Questions are short and exact: a few lines of code to trace, a structure built up step by step, a recurrence to solve, or a statement about an algorithm to accept or reject. Several ask you to pick every correct option. Expect to be asked why as often as what.

Medium problems under the clock

The coding problems are medium ones from the published catalogue, chosen for your sitting, and you may answer in any of the 13 languages the editor offers. A medium problem usually joins two ideas: sort and then sweep, search a grid breadth-first, binary-search an answer with a greedy check inside, or fill a table over prefixes. The statement carries no topic tags and no hints, so naming the technique is the first part of the work. As in the practice workbench, you complete a function whose signature is given and return the answer; the judge supplies the input.

Spend the first minutes on a plan. Read the input limits, decide what complexity they allow, and write the approach as two or three comments before any code. Then get a correct version submitted, because each hidden case you pass earns its share and your best submission per problem stands; improve it afterwards if time allows. Keep in mind that the hidden cases run in large batches, each on one time budget: a solution that is far too slow can be stopped part-way through, and every case it had not reached scores nothing.

Expect the hidden cases to probe what easy problems forgive: graphs that are disconnected or contain cycles, repeated keys and ties, empty ranges, and chains long enough to overflow a deep recursion. In Python the default recursion limit is about a thousand frames, so a depth-first search over a long path is safer with an explicit stack. Pasting into the editor is switched off, and code that closely matches the problem's published editorial can be flagged for review.

A study plan built on the roadmap

The DSA roadmap teaches this level in its later stages: Heaps, Intervals and Sorting & Greedy in the Core tier, the two graph stages in the Advanced tier, and Dynamic Programming I and II in Mastery. Each stage has written lessons, problems to clear, and a chest at the end of its tier. For more practice on one technique, the topic hubs order their problems from easy to hard: heap, graph, breadth-first search, depth-first search, shortest path, topological sort, union-find, minimum spanning tree, dynamic programming, memoization, greedy, intervals and binary search.

Two habits turn practice into the kind of understanding the concepts section examines. After each medium problem you solve, write one sentence on why the approach is correct (the invariant, the exchange argument or the recurrence) and one on its running time. And for each algorithm you learn, find out what kind of input it was not built for; knowing where a technique stops working is half of knowing when to reach for it.

Sample question

Topic: Trees & BSTs

height returns the number of nodes on the longest downward path from a node and records something else along the way. What does this program print?

class Node:
    def __init__(self, name, left=None, right=None):
        self.name, self.left, self.right = name, left, right

root = Node("A",
            Node("B",
                 Node("D", Node("F", Node("G"))),
                 Node("E", None, Node("H", None, Node("I")))),
            Node("C"))

best = 0

def height(node):
    global best
    if node is None:
        return 0
    left = height(node.left)
    right = height(node.right)
    best = max(best, left + right)
    return 1 + max(left, right)

height(root)
print(best)
  1. 5
  2. 6
  3. 7
  4. 4
Show the answer

B. 6

At each node, left + right is the number of edges on the longest path that bends there, and best keeps the largest: the tree's diameter. The longest path is G–F–D–B–E–H–I, six edges, and it bends at B, not at the root. 5 is the longest path through the root (B's height 4 plus C's height 1), the answer you get by checking only the root. 7 counts the nodes on the path instead of its edges, and 4 is the root's height in edges. Returning one value while recording another is the pattern behind most tree problems of this kind; the whole walk is O(n).

Common questions

Which algorithms should I be able to write from memory for the DSA Intermediate test?

Breadth-first and depth-first search, Dijkstra's algorithm with a priority queue, a topological sort, union-find, binary search over a range of candidate answers, and one- and two-dimensional dynamic-programming tables. Pasting is switched off in the coding round, so each has to come out of your head cleanly, with its boundary conditions right.

The code in the questions is Python. What if Python is not my language?

You can still read it. The programs are short and use only a handful of library helpers: heapq for a binary min-heap kept in a list, deque for a queue with fast removal at the front, bisect for binary search on a sorted list, and float("inf") as infinity. Learn what those do and the rest reads like pseudocode. The coding round accepts any language.

Does a correct but slow solution earn any marks?

Some. Every hidden case your code passes earns its share of the marks, and your best submission per problem counts, so a working brute force is worth submitting early. But the hidden cases run in large batches on a shared time budget: a run stopped for time scores nothing for the cases it had not reached, so at this level the intended complexity is part of the answer.

How much dynamic programming does the Intermediate test expect?

The classic families rather than exotic variants: subsequences, knapsack, counting paths and ways, string distances. You should be able to define a state, write its recurrence, decide which entries must be filled first, and say what the whole table costs. In the coding round, a medium problem may need a table you design yourself from the statement.

Is Java or C++ a safer choice than Python for the coding round?

Choose the language you are fluent in. The judge gives no language extra time, so Python pays its constant factor on heavy loops, but at medium level the gap between an O(n log n) and an O(n²) idea decides far more cases than the language does. Deep recursion is the one thing to plan for in Python.

Rules

This is a certification test. Pass with 60% and you earn a verifiable CodeKairo credential — 85% earns it with distinction. It is valid for 2 years.

  • The sections are timed separately and taken in order. A section you leave cannot be reopened.
  • The server keeps the clock. Closing the tab or reloading does not pause it.
  • Your answers save as you go and survive a refresh.
  • The coding section takes any language. Run checks the visible cases; Submit runs every hidden case.
  • You may sit this test again 7 days after a sitting ends. Your best result stands.

Integrity. Work alone and from what you know, on a laptop or desktop with a webcam — phones and tablets cannot sit a skill test. The test runs full screen and must stay in front the whole time, and the webcam must see you, alone: leaving full screen, switching to another tab or window, minimising, or the camera seeing no one, someone else, a phone or you looking away blurs the paper and counts against you — the first 2 are warnings, and the third ends the sitting, graded as not passed. The camera check runs in your browser; nothing is recorded or uploaded. Pasting into the editor is switched off. A sitting that looks assisted can be reviewed, and a credential earned that way is revoked.

The answers are never shown — not during the test and not after it. Your result breaks the score down by topic and points you to what to practise.