algo-coach teaches each technique, writes problems and verifies them by running them, names the misconception behind every failure, and measures your mastery until it holds. Whether you are learning a technique for the first time or getting it back.
Merge overlapping intervals
Sweep over sorted intervals
def merge(intervals):
merged = []
for start, end in sorted(intervals):
if merged and start < merged[-1][1]: merged[-1][1] = max(merged[-1][1], end)
else:
merged.append([start, end])
return merged[[1,3],[2,6],[8,10]][[1,4],[0,4]][[5,7]][[1,2],[2,3]]returned [[1,2],[2,3]], expected [[1,3]][[0,0],[1,4],[0,2]]< treats [1,2] and [2,3] as disjoint. Two problems that hinge on it are in your next sitting.1
The engine writes each problem with its test cases and two independent reference solutions. Nothing reaches you until both agree on every case.
2
Your code runs against those cases in a sandbox, including cases built to catch the mistakes people most often make with that technique.
3
A failure is traced to the misconception behind it, not only to the case it failed. We will publish the catalogue and how often the diagnosis is right.
4
Every attempt updates your mastery of the technique. It comes back when it is due, in a problem you have not seen, until it holds.
A 30-minute placement test marks each technique as solid, rusty or not yet learned. From there, each technique is taught and practised as one unit.
Briefing
The technique in one page: when it applies and the shape of the solution.
Worked example
One problem solved step by step, with the decisions made explicit.
Graded problems
From a direct application to one where the technique is hidden.
Misconception checks
Short cases aimed at the mistakes this technique invites.
A unit is done when you pass its misconception checks on problems you have not seen, not when you reach the end of it.
The technique is not named. Spotting it is half the problem, and the half that rusts first.
A ferry company lists every crossing as a start and end time. Find the fewest boats that cover them all.
A clock and no hints, once a technique holds without them.
An algorithm is only as good as the code that carries it. Alongside the algorithms track, the same engine writes and judges problems on how your language behaves: generators, the event loop, concurrency.
Open first
Your board shows mastery for each technique, so practice goes where it moves the number.
Next
Iterators and generators, context managers, decorators, async/await, cancellation and timeouts. Some problems ask you to write code; others ask what code does.
def take(n, it):
for _ in range(n):
yield next(it)
nums = iter([1, 2, 3])
print(list(take(2, nums)), list(nums))[1, 2] [3]. The generator and the second list draw from the same iterator, so the first two values are already gone.
Planned
Planned
Judged with the race detector and repeated runs.
We built algo-coach because the tools we had counted problems solved. None of them could say which technique had gone rusty, or why an answer was wrong beyond the case it failed.
So we measure the thing that matters and practise against it daily. The engine, the method and the diagnosis numbers will be published in the open.
We let people in in small groups and read every piece of feedback. One email when your seat is ready, nothing else.