Course

Data Structures & Algorithms

11 problems across 7 techniques

Problems grouped by technique · Interactive step-through visualizers · Editable JavaScript solutions

Technique 01Arrays & Hashing- 2 problems · Trade memory for speed: keeping what you have seen in a map or set means a lookup is one step instead of another pass over the data

Two SumEasy

Find the indices of two numbers that add up to a target.

need = target - num seen need? -> answer else remember num -> index

Time O(n) · Space O(n)

Longest Consecutive SequenceMedium

Length of the longest run of consecutive numbers, in a single pass.

set = new Set(nums) num - 1 in set? skip else count num, num+1, ...

Time O(n) · Space O(n)

Technique 02Two Pointers- 3 problems · Two positions moving through the data replace a loop inside a loop - usually once the data is sorted

Remove Duplicates from Sorted ArrayEasy

Squeeze a sorted array so each value appears once, reusing the same array rather than building a new one.

read scans every value k marks the next free slot new value? nums[k++] = it

Time O(n) · Space O(1)

3SumMedium

All unique triplets that sum to zero.

sort fix nums[i], then L and R sum < 0 -> L++; > 0 -> R--

Time O(n²) · Space O(1) beyond sorting

Trapping Rain WaterHard

How much water an elevation map holds after rain.

water = min(leftMax, rightMax) - h lower side is the limit move the lower pointer

Time O(n) · Space O(1)

Technique 03Sliding Window- 2 problems · Slide a stretch of the input along, growing and shrinking it, instead of re-checking every possible stretch from scratch

Best Time to Buy and Sell StockEasy

Maximum profit from one buy followed by one later sell.

minPrice = cheapest so far profit = price - minPrice best = max(best, profit)

Time O(n) · Space O(1)

Longest Substring Without Repeating CharactersMedium

Length of the longest substring with all-distinct characters.

R extends the window repeat inside it? L = lastSeen + 1 best = max(best, R - L + 1)

Time O(n) · Space O(min(n, charset))

Technique 04Stack- 1 problems · Last in, first out: the most recent thing you opened is the first thing that has to close

Valid ParenthesesEasy

Are the brackets in a string properly opened and closed?

open -> push close -> pop must match end: stack empty?

Time O(n) · Space O(n)

Technique 05Linked List & Design- 1 problems · Put two data structures together so that every operation stays fast

LRU CacheMedium

A cache of fixed size that throws out the key nobody has touched for longest - and does it in a constant number of steps.

Map: key -> node doubly linked list = recency hit -> move to front; full -> drop tail

Time O(1) get / put · Space O(capacity)

Technique 06Binary Search- 1 problems · Cut the range you are searching in half at every step, when the answer sits somewhere in a sorted range

Square Root without Math.sqrtEasy

Find a square root to 2 decimal places by repeatedly halving the range.

low = 0, high = max(1, n) mid² < n ? low = mid : high = mid repeat until precise

Time O(log(n / ε)) · Space O(1)

Technique 07Recursion- 1 problems · Structures that contain themselves: solve the smallest case directly, then trust the same function to handle each smaller part

Flatten Nested ArrayMedium

Flatten an array nested to any depth into one level, without flat().

array? -> flatten it, same function value? -> push to result same order, any depth

Time O(n) · Space O(n)

Learn the technique, not the problem. Each group is a pattern that transfers: once two pointers clicks on 3Sum, it is the same move on any sorted-array question.