Programming practice

Data Structures & Algorithms

It is not 500 problems.
It is ten patterns and one way of seeing.

Most people grind hundreds of problems and still freeze in the interview, because they were memorizing answers instead of learning to recognize shapes. We do it the other way around. You learn to measure code, master the handful of structures everything is built from, and see the pattern hiding inside the question. Do that, and the problems start solving themselves.

Start with Big O25 lessons · 33 problems · about 9 hours

The whole subject, in one breath

1Measure

Big O: judge any solution before you trust it.

2Store

Arrays, lists, stacks, hash maps, trees, graphs.

3Traverse

Recursion, DFS and BFS: visit everything, cleanly.

4Recognize

The named patterns that win interviews.

By the end, you can

Read any solution and know if it scales

Glance at code and call its Big O before you run it.

Turn brute force into elegant

Spot when a hash map or two pointers drops O(n squared) to O(n).

Walk trees and graphs without fear

DFS and BFS become one calm, reusable habit.

Recognize the pattern under the question

See the five shapes that most interview problems are built from.

The climb, ten steps

Each step is motivated by the last. The color warms as the ground gets steeper.

Step 1

Complexity & Thinking

2 lessons

Before you write a line, you learn to judge code. Two correct answers exist for every problem, and Big O is how an interviewer tells which one gets hired.

1

Big O Notation

The universal language for talking about algorithm efficiency

2

Space Complexity & Trade-offs

Every algorithm trades time for space, learn to navigate that trade-off

Step 2

Linear Structures

5 lessons

The containers. Arrays, linked lists, stacks, queues. Nine out of ten problems are one of these four wearing a costume, so you learn to see through it.

1

Arrays & Dynamic Arrays

The foundation of almost every data structure you'll ever use

2

Two Pointers Technique

Turn O(n²) brute force into elegant O(n) solutions

3

Linked Lists

A chain of boxes, each one knows only where to find the next

4

Stacks

Last-in, first-out, the structure behind function calls, undo buttons, and expression parsing

5

Queues & Deques

First-in, first-out, the fairness principle behind BFS and task scheduling

Step 3

Search & Sort

3 lessons

Stop looking at everything. Binary search is the first time a million items shrink to twenty steps, and the moment it clicks, it never leaves.

1

Binary Search

You've been doing this your whole life, now let's write it in code

2

Sorting Algorithms

From bubble sort to Tim sort, why algorithm choice matters

3

Merge Sort & Quick Sort

Divide and conquer, the strategy behind the fastest general-purpose sorts

Step 4

Recursion

2 lessons

The scary one, made calm. A function that trusts itself to solve the smaller version. Get comfortable here and trees and graphs stop being hard.

1

Recursion

A function that asks a smaller version of itself for help, until the answer is easy

2

Backtracking

Explore every possibility, but smartly prune dead ends

Step 5

Hash Maps & Sets

2 lessons

The cheat code. A surprising number of "hard" problems quietly collapse to O(n) the second you reach for a hash map. This is the highest-leverage rung.

1

Hash Maps

O(1) lookups that power everything from databases to frequency counting

2

Hash Sets & Their Patterns

Membership testing in O(1), eliminating duplicates and tracking visited nodes

Step 6

Trees

3 lessons

Hierarchy. File systems, the DOM, org charts, search. Once you have recursion, walking a tree is just recursion with somewhere to look.

1

Binary Trees

Hierarchical data, the structure behind file systems, compilers, and search

2

Binary Search Trees

Ordered trees that combine the speed of binary search with the flexibility of trees

3

Tree Traversals

DFS vs BFS, the two ways to visit every node in a tree

Step 7

Graphs

2 lessons

Almost everything is a graph: maps, friend lists, dependencies, the internet. Two traversals, BFS and DFS, and you can reason about all of it.

1

Graph Fundamentals

Networks of nodes and edges, the structure behind maps, social networks, and dependencies

2

BFS & DFS on Graphs

Two essential traversal strategies, and when to use each

Step 8

Dynamic Programming

2 lessons

The one people fear most, defused. Dynamic programming is just recursion that remembers what it already worked out. We make it boring, in the good way.

1

Dynamic Programming

A fancy name for one lazy trick: never solve the same small problem twice

2

Core DP Patterns

Knapsack, longest subsequence, and matrix paths, the templates behind 80% of DP problems

Step 9

Greedy & Heaps

2 lessons

Sometimes the greedy, obvious choice is the right one, and sometimes it is a trap. You learn to tell which, and heaps keep the best option one peek away.

1

Greedy Algorithms

Make the locally optimal choice at each step, sometimes that's globally optimal

2

Heaps & Priority Queues

Always-sorted access to the minimum or maximum, O(log n) insert, O(1) peek

Step 10

Interview Patterns

2 lessons

The payoff. Sliding window plus a handful of named patterns unlock roughly four in five interview questions. This is where everything above becomes recognition.

1

Sliding Window

Process subarrays in O(n) by maintaining a window that slides through the data

2

Top Interview Patterns

The 5 pattern recognition skills that unlock 80% of coding interview problems

Start at the bottom. It is closer to the top than it looks.

Big O first. Twenty minutes, and you will read code differently for the rest of your career.

Start with Big OSign in to save progress