Data Structures & Algorithms
Spot the pattern, then watch each approach run and scale.
Sessions
Go in order. Each session is one idea you can drag, step and break.
DSA #01
LiveTwo Sum, three ways
Step through brute force, two pointers and a hash map. Then scale n and see the gap.
Open session →
Interactive
LiveHash map: group anagrams
Give every word a key, then one lookup per word puts anagrams in the same bucket.
Open session →
Interactive
LiveTwo pointers: most water
Start at both ends and always move the shorter line. One pass instead of every pair.
Open session →
Interactive
LiveSliding window
Slide a fixed window and watch each step add one cell and drop one.
Open session →
Interactive
LivePrefix sums: range sums in O(1)
Build running totals once, then any range is one subtraction.
Open session →
Interactive
LiveMonotonic stack: next warmer day
Keep the waiting days on a stack and answer each one the moment a warmer day arrives.
Open session →
Interactive
LiveBinary search
Halve the search space and see why it takes log n steps.
Open session →
Interactive
LiveFast and slow pointers
Two pointers at different speeds find a cycle, and where it starts, with no extra memory.
Open session →
Interactive
LiveLRU cache
A hash map plus a doubly linked list gives O(1) get, put and eviction.
Open session →
Interactive
LiveMerge overlapping intervals
Sort by start, then each interval only needs comparing with the last merged one.
Open session →
Interactive
LiveHeap: top k of a stream
Keep the k largest in a min-heap and reject most numbers with one comparison.
Open session →
Interactive
LiveTrees: let the children answer first
Find a tree's depth one call at a time and watch the call stack grow and shrink with it.
Open session →
Interactive
LiveTrie: prefix lookups
Walk one node per letter, then collect every word below.
Open session →
Interactive
LiveBFS vs DFS
Run both on the same graph and compare the order they visit nodes.
Open session →
Interactive
LiveUnion-find: connected groups
Merge groups as edges arrive and tell instantly whether two items are connected.
Open session →
Interactive
LiveTopological sort
Count prerequisites, start with the zeros, unlock the rest, and detect cycles.
Open session →
Interactive
LiveDijkstra: shortest paths
Settle the closest node, relax its edges, repeat.
Open session →
Interactive
LiveBacktracking: choose, explore, undo
Walk a decision tree of take-or-skip choices and prune branches that can't work.
Open session →
Interactive
LiveDynamic programming: coin change
Fill a table from 0 upward so every answer is worked out once, and see where greedy goes wrong.
Open session →
In production
Tools you can use
52 technologies across 19 live sessions. Same names in any language — pick a session to see how the idea maps to the real world.
Services, platforms, protocols and standards — not one stack.
The pattern is universal; runtimes give you hash maps and sorting without a separate product.
Grouping by a computed key is how databases and data tools group rows, not just an interview trick.
Two indices walking a sorted sequence is how merge joins and merge sort combine data.
Fixed windows are implemented with arrays or deques in memory — the technique, not a vendor SKU.
Running totals hide inside databases and image libraries.
“Next greater element” questions show up in stock spans, histograms and skyline problems.
Binary search is an algorithm on sorted data; libraries only save you from writing the loop.
Floyd's trick appears wherever memory is tight.
LRU and its approximations sit in front of most slow storage.
Interval merging runs in calendars and genome tools.
Heaps back every priority queue.
Trees are everywhere software keeps a hierarchy, and most code that walks them is this same recursion.
Tries power prefix search in many systems.
Graph search runs inside route planners, web crawlers, dependency resolvers and garbage collectors.
Union-find shows up in graphs, images and compilers.
Every build and package tool sorts dependencies.
Shortest-path search runs maps and networks.
Backtracking is the core of constraint solvers.
Dynamic programming shows up wherever a big choice splits into smaller ones that repeat.
- Optimal Round: DP problemsSoftware
Climbing stairs, coin change, edit distance and 15 more.
GitHub ↗ - git diffSoftware
Finds the smallest set of line edits between two files with a DP-style search.
Documentation ↗ - PostgreSQL query plannerSoftware
Picks the cheapest join order by building it up from smaller joins.
Documentation ↗
Roadmap
Coming soonA step-by-step path through the track, with sessions and practice at each stage.
- Stage 1
Arrays & hashing
- Stage 2
Two pointers & sliding window
- Stage 3
Stacks, queues & linked lists
- Stage 4
Trees & graphs
- Stage 5
Dynamic programming
Projects
Coming soonBuild something real to lock in the skill.
- Build an LRU cache
- Autocomplete with a trie
- Route finder with Dijkstra