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

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

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

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

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