Algorithms Practitioner is an interactive space to learn algorithms and data structures by watching them run, step by step.
Each exercise is made up of:
- Graphic
- Steps
- Navigation
- Data loading (presets and saved inputs)
- Source code
- External references
Goal
This platform flips the usual approach: instead of showing you a problem to solve, it presents the exercise ready for you to practice, understand how it works guided by the step-by-step walkthrough, and even compare it against your own version.
It is meant to complement your learning strategy — and what better way than a visual representation that makes the idea easier to grasp.
Using it well
But remember, in case you are tempted: copying and pasting is easy, and so is rote memorization, but neither will help you grow or land a good job. Recruiters want to see how you think, how you reach a solution that is efficient, defensible and resistant to edge cases. So add Algorithms Practitioner to your study plan: practice a lot, compare, picture the flow and ask yourself the why behind every line. How would you do it?
Notes
- Every exercise is written in JavaScript.
- The code was generated with Claude. While each exercise has its own unit test and the author has reviewed and run them all, it cannot be guaranteed 100% bug-free; there may even be more efficient solutions (I dare you to find them).
- There are, of course, many other platforms in this style; this is not meant to be a clone, but a custom project that also grew out of its author's own study plan.
- If you are about to start a formal coding assessment or are already in one, you should close this site; do not open it unless the rules allow it. Do not risk being disqualified, and stay honest and act with integrity at all times.
Recommendations for your study plan
- Try to solve the exercise yourself before revealing the code.
- Step through the visualization and predict the next step before advancing it.
- Use custom inputs and edge cases to test your understanding, not just the default example.
- Once it makes sense, close the code and re-implement the algorithm the way you understood it; don't force yourself to do it from memory.
- Compare versions, both your own and from other sources: why was pattern X used? Which one saves more memory? Which one takes fewer steps?