Algorithms
you can see.

Complexity, patterns, recursion and hashing — the foundation.

The classic sorts — watch the bars fall into order.

Trade memory for speed — hash maps turn lookups into O(1).

Two indices sweeping an array — from both ends or at two speeds.

A window that grows and shrinks over a run of elements.

Halve the search space — on 1D arrays, on the answer, and in 2D grids.

Characters are just arrays — two pointers, counts and parsing.

Pointers you rewire in place — reverse, detect cycles, merge.

Choose, recurse, un-choose — patterns that build every path.

AND, OR, XOR and shifts — the classic constant-space tricks.

Last-in first-out — perfect for matching and 'nearest' problems.

Precompute running totals — range queries in O(1).

Always pull the best element next — top-k, streaming, merging.

Take the locally best choice — when it's provably optimal.

Choose, explore, un-choose — walk the tree of all solutions.

Traversals and divide-and-conquer over left and right subtrees.

Ordered trees — left is smaller, right is larger, search in O(h).

Dive deep first — trees, recursion, and connectivity.

Level by level with a queue — the shortest unweighted path.

Nodes and edges — traversal, shortest paths, connectivity.

Prefix tree — shared prefixes stored once, fast lookups.

2-D grids — rotate, spiral, and in-place tricks.

Sort by an endpoint, then sweep for overlaps.

Overlapping subproblems — solve each once, reuse forever.