StudyDSA logoStudyDSA

Command Palette

Search for a command to run...

Sign InSign Up
Sign Up
StudyDSA

Where complexity meets clarity.
By Armas Zarra.

Topics

  • Data Structures
  • Algorithms
  • Big-O Notation
  • Robotics
  • AI Research
  • Machine Learning

Practice

  • Blind 75
  • LeetCode 75
  • NeetCode 150

Legal

  • Privacy Policy
  • Terms of Service

© 2026 Armas Films LLC

Master the foundations.
Build anything.

An evolving library of technical knowledge, from data structures and algorithms to AI, robotics, and beyond.

Create AccountStart Exploring

Topics

Everything you need

A complete library of technical knowledge, from fundamentals to cutting-edge research.

Data Structures
Arrays, Linked Lists, Trees, Graphs, Heaps, and more.
Explore→
Algorithms
Two Pointers, Binary Search, DFS, BFS, Dynamic Programming.
Explore→
115°90°
Robotics
Kinematics, control systems, path planning, and sensor fusion.
Explore→
AI Research
Dive into transformer architectures, break down landmark research papers, and understand what makes LLMs tick under the hood.
Explore→
Machine Learning
Regression, classification, clustering, and deep learning.
Explore→

The grind isn't working.

You open a problem, stare at it for twenty minutes, then peek at the solution and nod along. Two weeks later the same problem comes back, and so does the blank stare. That's not learning, that's a loop.

Open a problem
Stare at it
Peek at the solution
“Makes sense”
Forget it

repeat

Memorizing a solution solves one problem. Understanding the pattern solves every version of it.

Here's what that looks like

See it

Concepts you can actually see

A wall of text can't show you how a pointer moves. Every page on StudyDSA explains with animated diagrams, and the diagrams are the explanation, not decoration.

This one's searching a sorted array right now. Every comparison throws away half of what's left.

target = 70

4
9
15
23
31
42
57
70
88

In your language

Every example in your language

Python, TypeScript, Java, C#, C++, PHP, Go, and Rust. Every code sample on the site exists in all eight, one click apart.

Pick one here and the whole site follows. Try it.

In order

A path, not a pile

Topics build on each other in an order that makes sense, with cross-references between pages. You always know what to learn next and why, instead of guessing which random video to watch.

Arrays

Static & dynamic arrays

Memory layout, indexing, and why appends are usually cheap.

Hash Tables

Hashmaps & sets

Hash functions, collisions, and constant-time lookups.

Linked Lists

Singly & doubly linked lists

Pointers, traversal, and trading indexing for cheap inserts.

Trees

Binary trees & BSTs

Hierarchies, traversals, and logarithmic search.

Graphs

Graphs

Where everything you learned so far comes together.

Then practice

204 problems, chosen on purpose

Every problem in our three curated lists earns its place by teaching a technique you'll see again. Mark problems complete, track your mastery from first attempt to interview ready, and pick up where you left off.

Not another random 500-problem dump.

Try it. No account needed.
  • Two SumEasy
  • Valid AnagramEasy
  • 3SumMedium
  • Longest Substring Without Repeating CharactersMedium
  • Trapping Rain WaterHard

Two ways to get good at this

Grinding blind

StudyDSA

Solve 500 random problems and hope
Follow a path where each topic builds on the last
Memorize the solution, forget it in two weeks
Learn the pattern once, recognize it everywhere
Solutions in whatever language the author liked
Every example in 8 languages, one click apart
Progress measured in vibes
Mastery tracked per problem

11

data structure guides

7

algorithm deep dives

204

curated problems

8

languages per example

$0

right now

The library is still growing. We'd rather publish deep guides slowly than shallow ones fast, so when a topic is up, it's worth your time.

Start understanding.

A free account saves your progress, bookmarks, and language preference across every page.

Create free accountBrowse the library

binary_search.py

def binary_search(nums: list[int], target: int) -> int:
    # Start left and right at both ends of the array
    left, right = 0, len(nums) - 1

    while left <= right:
        # Calculate the mid point
        mid = (left + right) // 2

        # Move left to search higher values
        if nums[mid] < target:
            left = mid + 1
        # Move right to search lower values
        elif nums[mid] > target:
            right = mid - 1
        # Found target at mid
        else:
            return mid

    # Target not found
    return -1