Wiki

Learn the ideas behind each challenge. Find help with grading and results.

• Bloom Filter: Use a small set of bits to check whether an item may be present. Learn why it can say yes by mistake, but must never miss an added item.
• Circuit Breaker: Stop calling a service once it is clearly broken. Let one careful test call through later to see if it has recovered.
• Connection Pool: Keep a few connections open and share them, instead of opening a new one for every request. Never go over the limit, and give space back after a failed try.
• Consistent Hashing: Choose a server for each key using points on a circle. Move only a small share of keys when servers join or leave.
• Counters and Sets That Merge: Merge copies of counters and sets that live on different machines, safely, no matter how many times or in what order the merges happen.
• Cron Scheduler: Work out when a schedule should fire next, then wait and fire jobs on time without drifting.
• Double-Entry Ledger: Record money moving between accounts. Every transfer either fully happens or not at all, even when many callers act at the same time.
• Glossary: Short, plain meanings for the words used in the challenges and this wiki. Look up a word when a page uses one you do not know.
• Hash Map: Store keys and values in a table. Keep keys easy to find after deletes and growth.
• How grading works: Your solution runs through stages in order. Each stage checks one part of its behavior.
• Idempotency Keys: Save the result of a request so a retry does not repeat its work. Make callers with the same key share one result.
• Inventory Reservation: Hold stock for a buyer while they finish paying, give it back if they do not, and never sell the same unit twice.
• Message Log Reader: Read a message log in order and save your place on the server only after each message is done. Carry on from that place when a connection breaks.
• LFU Cache: Remove the least used key when a cache is full. Use the oldest touch to break ties.
• LRU Cache: Remove the key that has gone longest without use when a cache is full. Keep reads and updates fast.
• Many callers at once: What a race is, why "check, then change" breaks when calls overlap, and how a lock fixes it in Go, Python, Rust and JavaScript.
• Min Heap: Keep the smallest value ready to read or remove. Learn how values move up and down a tree stored in an array.
• Visibility Checker: Decide what a transaction can see. Each transaction gets its own fixed view of the data, so readers and writers never have to lock each other out.
• Rate Limiter: Limit how many requests each caller can make. Allow short bursts while keeping the long-term rate under control.
• Reading a verdict: Start with the first stage that did not pass. Read what was expected and what your code returned.
• RESP Codec: Read Redis messages from a stream of bytes. Keep unfinished messages until more bytes arrive.
• Retry with Backoff: Wait longer between failed attempts, and make each wait a random amount. This helps many clients avoid retrying together.
• Ring Buffer: Store values in a fixed-size array and read them in arrival order. Reuse space by wrapping back to the start.
• Task Queue: Add jobs to a queue, take them off one by one, and tell the queue a job is done only after the work is finished. Open a new connection when one breaks.
• TCP State Machine: Track how a TCP connection opens and closes. Choose the right state and actions for each event.
• Trie: Store words letter by letter in a tree, so a lookup costs only as many steps as the word is long.