Data structures and algorithms, from nothing.

The thing being taught

Here is one problem solved twice. Both answers are correct. One of them is the reason candidates fail interviews, and by lesson 06 the difference will be obvious to you on sight.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62// Find the longest run of characters with no repeats. "abcabcbb" -> 3 ("abc")

let bruteSteps = 0, windowSteps = 0;

// Attempt one: check every substring. Correct, and unusably slow.
function longestBrute(s) {
  let best = 0;
  for (let start = 0; start < s.length; start++) {
    for (let end = start; end < s.length; end++) {
      bruteSteps++;
      const piece = s.slice(start, end + 1);                 // O(length) itself
      if (new Set(piece).size === piece.length) best = Math.max(best, piece.length);
    }
  }
  return best;
}

// Attempt two: one pass. A window that grows on the right and shrinks on the
// left, and a map remembering where each character last appeared.
function longestWindow(s) {
  const lastSeen = new Map();
  let best = 0, left = 0;

  for (let right = 0; right < s.length; right++) {
    windowSteps++;
    const ch = s[right];
    // If this character is already inside the window, jump the left edge past
    // it. Never backwards: that is what keeps the whole thing linear.
    if (lastSeen.has(ch) && lastSeen.get(ch) >= left) left = lastSeen.get(ch) + 1;

    lastSeen.set(ch, right);
    best = Math.max(best, right - left + 1);
  }
  return best;
}

// Both agree on every input, including the awkward ones.
for (const input of ['abcabcbb', 'bbbbb', 'pwwkew', '', 'dvdf']) {
  console.log(`"${input}" -> brute ${longestBrute(input)}, window ${longestWindow(input)}`);
}

// Now count the work as the input grows.
console.log('\n  n      brute steps   window steps       ratio');
for (const n of [100, 200, 400, 800]) {
  const input = Array.from({ length: n }, (_, i) => 'abcdefghij'[i % 10]).join('');

  bruteSteps = 0;
  windowSteps = 0;
  const a = longestBrute(input);
  const b = longestWindow(input);
  if (a !== b) throw new Error('the two disagree, which would be a bug');

  console.log(
    String(n).padStart(4),
    String(bruteSteps).padStart(14),
    String(windowSteps).padStart(14),
    (bruteSteps / windowSteps).toFixed(0).padStart(11) + 'x'
  );
}
console.log('\nDouble n: the window does twice the work, brute force four times.');
console.log('And each brute step costs more too, because slicing is not free.');
console.log('That gap is what Big-O measures, and it is lesson 01.');

What you are actually being tested on

A technical interview is not a memory test, though it is often mistaken for one. Four things are being assessed, and only the last one is about knowing algorithms.

How to work through it

The order matters. Lessons 01 to 07 are one continuous argument: what cost means, then the two structures that everything is built from, then the three techniques that turn a nested loop into a single pass. Skipping ahead to graphs before that lands is the most common way to waste a month.

1. Read one or two lessons a day with this page open in one window and your editor in the other.
2. Run every panel. When the output surprises you, change a line and run it again. That is the entire study method, and it is why the examples are executable rather than printed.
3. Do the task at the foot of each lesson before moving on. Editable panels keep what you type in this browser, so you can leave one half-finished.
4. After lesson 14, start mixing in problems. Do not wait until you have finished the course; recognition only develops on unfamiliar problems.
5. When something will not stick, write it out from memory on paper. The templates page is the target to reproduce, not to read.

How long this honestly takes

The reading is 6 hours. Becoming good enough to pass a big-tech loop is closer to two to three months at an hour or two a day, and the ratio that matters is roughly one part reading to four parts solving problems without help. The roadmap lays out eight weeks of that, but treat the dates as a shape rather than a promise: what determines the outcome is the number of problems you have worked through where you did not already know the answer.

What this is, honestly

A course written to be read offline. There is no account, no backend, no analytics and no network request of any kind; the fonts are inlined into the stylesheet and the syntax highlighter is a few hundred lines in assets/js/highlight.js. Your progress and anything you type into an editable panel are kept in this browser's localStorage under the dsa. prefix and nowhere else, so clearing site data clears them.

Code in a panel runs in your own browser, inside a function scope with a shadowed console, always under "use strict", with a loop guard that stops a runaway while rather than hanging the tab. That is what makes the examples honest, and it also means an editable panel will run whatever you paste into it. Treat it the way you would treat your own devtools console.

Problems are described in my own words and linked by number rather than reproduced, so the wording here will differ from the original site. Where a problem has a well-known name it is given, so you can find it.