The idea behind ALGO
Learn the logic. Build the mechanism. Understand the system.
You can know the syntax of a language and still feel unsure when faced with a blank editor. ALGO gives you a small, clear problem to start with: something you can reason through, write yourself, and see working. From there, you can explore the ideas inside the software you use every day.
Practice algorithms in focused coding problems, or build a simplified system one behavior at a time. Both paths help you connect what your code does with why it works.
What you can practice
- Coding Prequels
- 120
- System tracks
- 20
- System levels
- 125
- Supported languages
- 5
Python, C++, Rust, Go, and Java. Choose a language you know and spend your attention on the problem.
Two ways to learn
Practice coding. Explore systems. Choose your starting point.
Each system has six Coding Prequels and a sequence of System levels. You can use either track on its own and move between them whenever you feel ready.
Prequels: learn to reason through code
One focused problem, a clear goal, examples, and unseen tests. Practice arrays, strings, maps, trees, graphs, and other algorithm patterns through Easy, Medium, and Hard problems.
The problems are grouped around useful system ideas, but each one explains the task without requiring you to understand that system first.
Useful as standalone coding practice.
System levels: make the ideas work together
Build a small working model of a system. Read commands, maintain state, follow rules, and handle the cases described in the problem. Later levels introduce more behavior to reason about.
Use the story, diagram, and input/output contract to understand the mechanism you are implementing and the decisions behind it.
Useful for systems thinking through implementation.
A small example: the command shell
A line of text becomes something you understand.
Someone types echo hello world into a terminal. To us, the words are obvious. A program needs a rule for finding them, especially when there are extra spaces. In the first Shell Prequel, you solve just that problem: split a line into words and return them in order. It is a small task, but it gives you a useful piece of logic you can explain.
Coding practice: find the words
- Input
- echo hello world
- Output
- echo,hello,world
Think about word boundaries, repeated spaces, and preserving order. The starter code handles reading and printing.
Try the PrequelSystem practice: act on the words
echo hello world exit
In Shell Level 1, recognize the command, print its arguments, and keep reading until exit. You now have to connect parsing with command behavior.
The parsing idea carries over. You implement the System level separately; it does not automatically call your Prequel solution.
Explore the System levelThat is the connection ALGO aims to make: a coding idea you can solve on its own, followed by an opportunity to apply similar reasoning inside a system.
How to use a challenge
Make one decision, test it, and learn from the result.
You do not need the complete answer before you start. A traced example or a first attempt gives you something concrete to work with.
- 01
Understand the problem
Read the story, identify what goes in and what should come out, and trace one example by hand.
- 02
Work out your approach
Decide what to keep track of. Use the hint or diagram when you need help seeing the next step.
- 03
Write and test
Complete the starter code, run the samples, and try your own input. Use each failure to improve your reasoning.
- 04
Explain your solution
Submit against unseen cases, then describe why your approach works and which edge cases it handles.
For Prequels, Run checks the five visible samples; Submit also checks ten hidden cases. Passing them is evidence that your code handles those inputs. Understanding the approach helps you handle the next problem, too.
What systems practice means here
Build a small model you can inspect and explain.
A cache is easier to understand when you decide which item leaves a full store. A queue becomes clearer when you track who receives the next job. ALGO turns these mechanisms into runnable exercises with explicit rules.
State
What information must stay available between operations?
Rules
What must stay true when an item is added, changed, or removed?
Failure
What should happen when input is invalid or a resource is missing?
Trade-offs
Why choose this approach, and what would change at a larger scale?
Understand the scope of each level
These are simplified learning models. Some levels simulate processes, networking, or failures; others calculate statistics from supplied data. Follow the level's contract to see what it actually implements. A passing solution is a tested exercise, not evidence that you have built a production server or measured real infrastructure performance.
Where your curiosity can take you
Twenty systems, many ways to think.
Start with a familiar idea, then explore a system you have wondered about. You can return to coding practice whenever you want to strengthen a particular skill.
Core systems
Explore how a shell handles commands, a server reads requests, Git tracks changes, and caches and indexes organize data.
Distributed systems
Model how queues share work, traffic is balanced, tasks are scheduled, and several machines keep information in agreement.
Search and AI systems
Explore search indexes, vector similarity, inference state, and the messages that connect an application to its tools.
Learning when AI can write code
Make understanding the part you own.
AI can help you understand an unfamiliar error, compare approaches, or review a solution. Before asking for a complete answer, try tracing the example and writing a first attempt. When you use help, return to the code and explain each decision in your own words.
A useful check is simple: can you predict what happens for a new input, explain why the output is correct, and change the solution when a rule changes? Those are the habits ALGO is designed to help you practice.
Bring basic familiarity with one programming language. The starter code helps you get into the task; examples, hints, and diagrams help you reason through it. You can start without prior systems knowledge.
Your first step
Start with one problem you can make sense of.
Read the example. Work out the logic. Write your version. Each small result gives you something to understand, improve, and build on.