Challenges

Data Structures & Algorithms

34 challenges34 playable now

Difficulty

Showing 34 of 34

Trie / Autocomplete

Build a prefix tree: insert and search words, test prefixes, collect autocomplete suggestions, delete with pruning, and count words under any prefix.

~45 minStart

beginnerFree

Binary Search (and its Variants)

Binary search turns a slow linear scan into a handful of comparisons by repeatedly halving a sorted range. It is the engine behind database indexes, autocomplete, and 'search the answer' optimization. In this challenge you implement the classic search, then the lower_bound and upper_bound variants that power range and count queries, then binary search on a rotated array, and finally the search-the-answer pattern that finds the smallest value satisfying a monotonic predicate.

~50 minStart

beginner

Build a Hash Map

Build a hash map from scratch using separate chaining, the same idea that powers Python dictionaries. You will implement buckets, collision handling, deletion, automatic resizing, and iteration, learning exactly how key lookups stay fast under the hood.

~55 minStart

beginner

Stacks & Queues

Master stacks and queues by building them from scratch and applying them to real problems: LIFO and FIFO containers, balanced-bracket parsing, a queue made of two stacks, an O(1) MinStack, and a monotonic stack for next-greater-element.

~55 minStart

beginner

Linked Lists

Build a singly linked list from the ground up. You will implement the node structure and conversion helpers, then reverse a list, detect cycles with Floyd's fast and slow pointers, find the middle node, and merge two sorted lists. These are the exact operations behind many queues and LRU chains, and they are classic interview staples.

~55 minStart

beginner

Two Pointers

Master the two-pointer technique on arrays and strings. Across five steps you will build converging-pointer search, palindrome checking, in-place reversal, in-place deduplication, and the classic container-with-most-water problem.

~50 minStart

beginner

Prefix Sums & Kadane

Master the toolkit behind fast range-sum queries and streaming analytics. You will build a prefix-sum class for O(1) range queries, count subarrays with a target sum, apply batched range updates with a difference array, find the maximum subarray with Kadane's algorithm, and locate a pivot index. These patterns power dashboards, time-series rollups, and interview favorites.

~50 minStart

beginner

Bit Manipulation

Master the bit tricks that power flags, bitsets, hashing, and low-level optimization. You will count set bits with Brian Kernighan's trick, detect powers of two, find a lone number with XOR, manipulate individual bits, and enumerate subsets with bitmasks.

~50 minStart

intermediateFree

LRU Cache

Build a least-recently-used cache with O(1) get and put, backed by a hash map and a doubly linked list. Add eviction at capacity, non-mutating peeks, and hit/miss statistics.

~50 minStart

intermediate

Bloom Filter

Build a probabilistic set: k hash functions over a bit array give O(1) membership tests with zero false negatives and a tunable false-positive rate. Add fill metrics, unions, and the false-positive formula.

~50 minStart

intermediate

Vector Clocks

Track causality across distributed processes: increment on local events, merge on message receipt, and compare clocks to tell causal ordering from true concurrency.

~50 minStart

intermediate

Priority Queue & Scheduler (Heap)

Build a binary min-heap from scratch and grow it into a real task scheduler. You will implement push and sift-up, then pop and sift-down, an O(n) heapify, a priority queue that breaks ties by insertion order, and finally a top-K selector. No heapq, no imports — just an array and the parent/child index math that makes heaps fast.

~55 minStart

intermediate

Dependency Resolver (Graphs & Topological Sort)

Build the engine behind package managers and build systems. Model software dependencies as a directed graph, then walk it with BFS and DFS, compute a safe install order with topological sort, and detect the circular dependencies that break real builds.

~55 minStart

intermediate

Connectivity (Union-Find)

Build a Disjoint Set Union step by step — find, union, union by size, path compression, and component counting — then apply it to count friend circles the way network connectivity and Kruskal’s MST do.

~55 minStart

intermediate

Sliding Window (Streaming Metrics)

Learn the sliding-window technique by building the tools behind streaming metrics, log analysis, and substring problems. You will implement fixed windows, variable windows with hash maps, a monotonic-deque maximum, and a streaming moving average class. Each step adds one function toward a small toolkit you could drop into a real metrics pipeline.

~55 minStart

intermediate

Sorting: Merge Sort & Quickselect

Build divide-and-conquer sorting from the ground up: merge two sorted lists, grow that into merge sort, implement Lomuto partition for quicksort, reuse partition for O(n)-average quickselect (top-K queries), and finish with a stable key-based sort for ordering records. A practical toolkit for ordering data and answering k-th smallest queries.

~55 minStart

intermediate

Ordered Map (Binary Search Tree)

Build an ordered map on an unbalanced binary search tree: insert and look up integer keys, walk them in sorted order, find the smallest and largest, delete any node, and answer range queries for all keys between two bounds.

~60 minStart

intermediate

Greedy & Intervals

Solve classic calendar and scheduling problems with greedy interval algorithms: merge and insert intervals, detect conflicts, count meeting rooms, and select the most non-overlapping activities.

~55 minStart

intermediate

Grid Search (BFS & DFS)

Traverse 2D grids with breadth-first and depth-first search. Build a neighbor helper, then use it for flood fill, island counting, shortest paths, and largest-region sizing — the same tools behind paint-bucket fills, maze solvers, and image region detection.

~55 minStart

intermediate

Count-Min Sketch

Count frequencies in a stream using a fraction of the memory a hash map would need. Build the sketch grid, add and query with the min-across-rows trick, prove it never under-counts, and merge two sketches — the probabilistic counter behind heavy-hitter and traffic-analytics systems.

~45 minStart

intermediate

Geohash

Turn a latitude/longitude into a short string that encodes location AND proximity — nearby places share a prefix. Interleave lat/lon bits, encode to base32, decode back to a bounding box and center, and compute neighboring cells. The spatial index behind 'find things near me'.

~50 minStart

intermediate

Quadtree

Index 2-D points so 'what's in this region?' is fast instead of a full scan. Build the bounding-box math, insert points, subdivide a node into four quadrants when it fills up, and answer rectangular range queries — the spatial tree behind collision detection, maps, and nearest-neighbor search.

~45 minStart

advanced

Consistent Hashing

Distribute keys across nodes with a hash ring so that adding or removing a node reshuffles only a small fraction of keys. Add virtual nodes for balance, replica sets for redundancy, and node weights.

~70 minStart

advanced

Dynamic Programming Foundations

Learn dynamic programming from the ground up by building five classic solvers. Start with memoization on a Fibonacci-style stair climb, then move to tabulation for change-making, packing (0/1 knapsack), and text diffing (edit distance and longest common subsequence). Each step adds one function that powers a real-world use.

~60 minStart

advanced

Shortest Path (Dijkstra)

Build Dijkstra's shortest-path algorithm from scratch on a weighted graph, the engine behind map routing and lowest-latency network paths. Across five steps you assemble a weighted graph, compute shortest distances with a heap-based priority queue, reconstruct the actual route, expose a clean distance query, and rank the nearest destination.

~60 minStart

advanced

Backtracking

Master the explore, choose, unchoose pattern by generating subsets, permutations, combinations, combination sums, and counting n-queens solutions - each in a strict deterministic order.

~60 minStart

advanced

Segment Tree

Build a segment tree for fast range queries with point updates. You will implement range-sum and range-min variants, an increment helper, and finally a generic tree parameterized by an associative combine function, mirroring how analytics engines answer range queries over live-updating data.

~60 minStart

advanced

Minimum Spanning Tree

Design least-cost networks by building a Minimum Spanning Tree. You will implement a Union-Find (disjoint set) structure, then Kruskal's and Prim's algorithms, and finally use the MST to test whether a graph is connected. Graphs are undirected with integer nodes 0..n-1 and edges given as (u, v, weight).

~60 minStart

advanced

Bellman-Ford & Floyd-Warshall

Shortest paths when edges can be negative. Build Bellman-Ford to relax edges from a single source, detect negative-weight cycles, combine both into one safe contract, then compute all-pairs distances with Floyd-Warshall. Edges are directed tuples (u, v, w) and unreachable pairs use float('inf').

~60 minStart

advanced

String Matching (KMP & Rabin-Karp)

Build the substring-search toolkit that powers grep, DNA sequence search, and plagiarism detection. Start with brute force, then implement the KMP failure function and linear-time scan, add a Rabin-Karp rolling hash, and finish with hash-based repeated-substring detection.

~60 minStart

advanced

HyperLogLog

Estimate how many DISTINCT items a stream has seen using a few kilobytes instead of storing them all. Derive a bucket and rank from a hash, keep the max rank per bucket, turn the registers into a cardinality estimate, correct the small-range bias, and merge sketches — the count-distinct engine behind Redis PFCOUNT and analytics at scale.

~60 minStart

advanced

Cuckoo Filter

A Bloom filter that supports deletion. Store compact fingerprints in two candidate buckets, look items up in O(1), relocate entries with cuckoo 'kicking' to make room under load, and delete cleanly — the approximate-membership structure used when you need to remove items, not just add them.

~50 minStart

advanced

Skip List

Get O(log n) search, insert, and delete on an ordered set using stacked linked lists and a coin flip instead of tree rotations. Build randomized levels, express-lane insertion that keeps the list sorted, fast search, and deletion — the structure behind Redis sorted sets and LevelDB memtables.

~55 minStart

advanced

Merkle Tree

Prove a piece of data belongs to a huge dataset by checking a handful of hashes. Hash the leaves, fold them pairwise into a single root, generate an inclusion proof for any leaf, and verify it — the tamper-evident structure behind Git, Bitcoin, and database anti-entropy.

~55 minStart