Data structure widgets

```array id=two-sum caption="Two-pointer sweep on a sorted array"
values: [2, 7, 11, 15, 19]
pointers:
  - {index: 0, label: lo}
  - {index: 4, label: hi}
steps:
  - note: "2 + 19 = 21 > 9 — move hi left"
    activeIndices: [0, 4]
    line: 3
  - note: "2 + 15 = 17 > 9 — move hi left"
    pointers: [{index: 0, label: lo}, {index: 3, label: hi}]
    activeIndices: [0, 3]
  - note: "2 + 7 = 9 — found it"
    pointers: [{index: 0, label: lo}, {index: 1, label: hi}]
    activeIndices: [0, 1]
    breakpoint: true
code: |
  lo, hi = 0, len(a) - 1
  while lo < hi:
      s = a[lo] + a[hi]
      if s == target: return lo, hi
      if s > target: hi -= 1
      else: lo += 1
lang: python
```

```matrix id=lcs caption="Longest common subsequence of ABC and AC"
rowHeaders: ["", A, B, C]
colHeaders: ["", A, C]
values:
  - [0, 0, 0]
  - [0, 1, 1]
  - [0, 1, 1]
  - [0, 1, 2]
steps:
  - note: "Characters match: take the diagonal and add one"
    activeCells: [[1, 1]]
    readCells: [[0, 0]]
    line: 4
  - note: "No match: carry the better of above and left"
    activeCells: [[2, 2]]
    readCells: [[1, 2], [2, 1]]
    line: 6
  - note: "Match again — the answer is 2"
    activeCells: [[3, 2]]
    readCells: [[2, 1]]
    path: [[3, 2], [2, 1], [1, 1]]
code: |
  for i in range(1, n + 1):
      for j in range(1, m + 1):
          if a[i-1] == b[j-1]:
              dp[i][j] = dp[i-1][j-1] + 1
          else:
              dp[i][j] = max(dp[i-1][j], dp[i][j-1])
lang: python
```

```table id=sev caption="Severity ladder"
columns:
  - {key: sev, label: Sev, pk: true}
  - {key: response, label: Response}
  - {key: ack, label: Ack target, align: right}
rows:
  - {sev: SEV1, response: Page IM + exec bridge, ack: 5m}
  - {sev: SEV2, response: Page on-call + team lead, ack: 15m}
  - {sev: SEV3, response: "Slack #platform-oncall", ack: 1h}
why:
  SEV2.response: >
    Team lead, not the exec bridge: a SEV2 that pulls in leadership stops
    being a SEV2 and starts being a meeting.
```

```tree id=heap caption="Sift-down after popping the root"
fromArray: [1, 3, 2, 7, 5, 9]
steps:
  - note: "Pop the root; move the last element up"
    activeNodes: [0]
  - note: "9 is bigger than both children — swap with the smaller, 2"
    activeNodes: [0, 2]
    highlightNodes: [1]
  - note: "Heap property restored"
    dimNodes: [0, 1, 2]
```

```list id=floyd caption="Floyd's cycle detection"
nodes:
  - {value: 1}
  - {value: 2}
  - {value: 3}
  - {value: 4}
  - {value: 5, next: 2}
steps:
  - note: "slow and fast both start at the head"
    pointers: [{index: 0, label: slow}, {index: 0, label: fast}]
  - note: "slow moves one, fast moves two"
    pointers: [{index: 1, label: slow}, {index: 2, label: fast}]
  - note: "fast has entered the cycle"
    pointers: [{index: 2, label: slow}, {index: 4, label: fast}]
  - note: "They meet inside the cycle — there is one"
    pointers: [{index: 3, label: "slow,fast"}]
    activeIndex: 3
    breakpoint: true
```

```stack id=monotonic title=stack caption="Next greater element"
values: []
steps:
  - note: "Push 2"
    values: [2]
  - note: "1 is smaller — push it too"
    values: [2, 1]
  - note: "5 pops everything smaller: 1 and 2 both get their answer"
    values: [2, 1]
    activeIndex: 1
  - note: "Stack holds only 5"
    values: [5]
```

```queue id=ring caption="A ring buffer wrapping past the end"
layout: ring
capacity: 6
values: [null, null, null, null, null, null]
front: 0
back: 0
steps:
  - note: "Empty: front and back coincide"
    size: 0
  - note: "Enqueue three; back advances"
    values: [a, b, c, null, null, null]
    back: 3
    size: 3
    activeIndices: [2]
  - note: "Dequeue two; front advances, the slots are not cleared"
    values: [a, b, c, null, null, null]
    front: 2
    back: 3
    size: 1
    dimIndices: [0, 1]
  - note: "Enqueue four more — back wraps past the end to slot 1"
    values: [g, h, c, d, e, f]
    front: 2
    back: 2
    size: 6
    activeIndices: [0, 1]
```

```map id=probe caption="Linear probing into a full-ish table"
mode: open
capacity: 8
hashOf: {apple: 3, mango: 3}
slots:
  - null
  - null
  - null
  - {key: apple, value: 1}
  - null
  - null
  - null
  - null
steps:
  - note: "h(mango) = 3, but slot 3 is taken by apple"
    activeKey: mango
    activeSlots: [3]
    probePath: [3]
  - note: "Probe forward: slot 4 is free"
    activeKey: mango
    activeSlots: [4]
    probePath: [3, 4]
  - note: "Inserted. α = 2/8 — plenty of headroom"
    slots:
      - null
      - null
      - null
      - {key: apple, value: 1}
      - {key: mango, value: 2}
      - null
      - null
      - null
```

```bits id=subsets caption="Bitmask DP: visiting city 2"
bits: 4
labels: [A, B, C, D]
steps:
  - note: "Start at A only"
    value: 1
    activeBits: [0]
  - note: "Add C to the visited set"
    value: 5
    activeBits: [2]
    readBits: [0]
  - note: "All four visited — the subproblem is complete"
    value: 15
    activeBits: [1, 3]
```

```memory id=alias caption="Why mutating b changed a"
frames:
  - name: "<module>"
    vars: {a: [REF, 1], b: [REF, 1]}
heap:
  1: [LIST, 1, 2, 3]
steps:
  - note: "a = [1, 2, 3] allocates one list"
    frames:
      - {name: "<module>", vars: {a: [REF, 1]}}
    activeIds: [1]
  - note: "b = a copies the pointer, not the list — both names are the one object"
    frames:
      - {name: "<module>", vars: {a: [REF, 1], b: [REF, 1]}}
    activeIds: [1]
  - note: "b.append(4) mutates that object, so a sees it too"
    heap:
      1: [LIST, 1, 2, 3, 4]
    activeIds: [1]
    breakpoint: true
```