Forge Algorithm Lab

Implement push, pop, peek - understand why O(1) matters

Circular buffer - the right way to build a queue

Build a hashmap with separate chaining collision resolution

Reverse a linked list - the interview warm-up that trips people

Standard search, then rotated array - the real interview variant

From exponential to linear - the power of caching subproblems

Build a heap from scratch - the engine behind task schedulers

The pattern behind 50% of array interview problems

The most-asked interview question, plus its two most-asked variants

One array, three questions - all solved by never recomputing

Turning raw counts into the answer an interviewer actually wants

Deep-copying graphs hiding inside a list, and rewiring pointers in place

Finding rank-k without a full sort, once on a static array, once on a live stream

Two classic two-pointer problems that show up in almost every SDE3 loop

Two sliding-window techniques: shrink-to-fit, and the monotonic deque

Three stack-based interview staples: validation, O(1) min-tracking, and expression evaluation

The pattern behind 'next greater', 'days until warmer', and histogram-area problems

The linked-list pattern behind every log-merge and external sort

Carry propagation and fixed-size chunk reversal, both node by node

Two heaps for a running median, then the same idea over a sliding window

Combine everything - stack, queue, hashmap, and heap in one class

The most asked cache question - O(1) get and put

Evict the LEAST frequently used - smarter than LRU

Probabilistic membership - "definitely no" or "probably yes"

Add/remove servers without resharding everything

Expire entries by time - the foundation of session management

Understand consistency tradeoffs through implementation

Count frequencies in data streams using constant memory

Mutex lock + probabilistic early expiry

In-memory hot cache + larger persistent cache

Compare FIFO, LRU, LFU - choose the right one for the job

Custom slab allocator - why databases avoid malloc

LRU + TTL + stampede prevention + telemetry in 50 lines

Composition and size-based allocation - the classic LLD opener

State machine design - Idle, HasBalance, Dispensing

The canonical Singleton - one shared logger, filtered by severity

State-guarded authentication and withdrawal, no shortcuts

Multi-elevator dispatch - nearest-idle-first scheduling

O(1) get/put with least-recently-used eviction

Deterministic request throttling, no wall-clock flakiness

Checkout/return with per-member borrowing limits

Observer pattern - fan out to Email, SMS, and more

Piece movement legality and occupancy rules

Board state, move validation, and generalized win detection

Expense splitting and running balances between members

Seat booking across shows, no double-booking

1:1 and group messaging with membership-gated access

Order lifecycle state machine - placed to delivered

Nearest-driver matching and fare estimation

Date-range availability with overlap-safe booking

Price-time priority matching for a single security

The industry standard - Cloudflare, Stripe, AWS all use this

Precise rate limiting without fixed window boundary bugs

The Netflix pattern - fail fast, recover gracefully

Handle transient failures without overwhelming the service

Semaphore-based DB connection pooling

Build the ancient encryption that started it all

The unbreakable cipher (for 300 years)

Implement a cryptographic hash from scratch

Message authentication that prevents tampering

Build JSON Web Tokens from scratch - no libraries

Bcrypt, salting, and why MD5 passwords leak

Implement RSA key generation - the math of internet trust

Token bucket + circuit breaker + retry in one class

Implement the basic XOR cipher for symmetric encryption

Calculate shared secret key securely

Derive secure keys from user passwords

Bcrypt simulation - how passwords are actually stored

Escape inputs to prevent SQL Injection attacks

Verify origin matching rules

Simple slide window rate limiting per IP

Header.Payload.Signature - implement without libraries

Prevent session tampering using signed cookies

Verify anti-CSRF request tokens

HTML escape user inputs

Access control checker

bcrypt + JWT + HMAC API keys + token validation

Track causality in distributed systems

Maintain causality using Lamport Logical Clocks

Assign keys to nodes using hashing

Choose the highest ID node as coordinator

How databases survive crashes - log first, apply second

Acquire consensus lock across replicas

Coordinate atomic transaction commits

R + W > N - the math behind eventual consistency

Replicate log entries to cluster members

Sync node list statuses periodically

Coordinate word counts with Map and Reduce stages

Consistent hashing + quorum + gossip + WAL in one

Merge sort and quicksort - the two divide-and-conquer sorts everyone should be able to write

Sorting without ever comparing two elements

Insert, search, and delete - the three operations every BST needs

Pre-order, in-order, post-order, and level-order - and why each exists

The prefix tree behind every autocomplete box you've ever used

Tracking which things are connected, without ever redrawing the whole graph

The BST validation bug that trips up half of interview candidates

The recursive pattern behind every 'closest shared node' interview question

Two 'one more pass' interview traps disguised as easy tree problems

Design your own wire format - then prove it round-trips

Multi-pattern matching, the way autocomplete actually works

Combine what you've built into one ranked-suggestion engine

Choose, explore, un-choose - the template behind every brute-force search

Backtracking with pruning - cutting off bad branches before you fully explore them

Bottom-up tabulation, from climbing stairs to coin change

Grid-shaped subproblems - longest common subsequence and knapsack

When the locally-best choice is also the globally-best one

Representing relationships, and visiting every node exactly once

Finding the cheapest route through a weighted graph

Ordering tasks so every dependency comes before what depends on it

Flood-fill your way through the most common grid interview question

Deep-copy a graph with cycles, then sanity-check another one's shape

Non-adjacent max sum, straight and circular

Three classic greedy-array problems, one pattern

Topological sort - the backbone of every build system and course planner

BFS shortest paths and topological sort, both hiding inside strings

Enumerate every valid answer, not just find one

Can it be split? How many ways can it be decoded?

LIS in O(n log n), and a deterministic longest palindrome

Two classic 2D string DPs that look alike but aren't

Subset-sum DP, twice: equal split and signed-sum counting

Regex vs wildcard matching - two DPs that look identical and aren't

The heap-merge core powering every social feed's 'most recent' view

Shortest paths and budget-constrained reachability, in one delivery-routing engine