Free through lesson 3

Competitive Programming for Beginners

From reading input and estimating time complexity to brute force, bit brute force, binary search, prefix sums, dynamic programming, and graph techniques. Across 30 lessons you'll get to the point where you "look at the constraints, pick an approach, and finish writing it within the time limit." Every lesson is an exercise in the form "task → implementation steps → sample solution → extra challenges," and every piece of code and every timing was actually run on Python 3.14.2.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into 6 chapters. We recommend going in order from chapter 1, but feel free to dip into whatever interests you. Note: all 30 lessons include a "task → implementation steps → sample solution → extra challenges" exercise. No lesson is explanation only. Note: the samples run right in your browser (they use only the standard library). For large benchmarks, try them with python3 on your own machine.

Chapter 1 — Foundations (lessons 1–5)

We nail down how to read input and how to work backward from the constraints to the complexity you can afford. We finish with overflow, floating-point numbers, and a pre-submission checklist, so you can catch problems yourself before they cost you.

1

Getting Started with Competitive Programming and Reading Input

The first stumbling block in a contest is reading input. Learn three patterns (one line, several values, N lines) and measure a 6x speed difference from reading alone.

Free
2

Working Backward from Constraints to Complexity

Look at the upper bound of N and decide what complexity is allowed. Starting from the measured fact that 10^8 iterations take about 3 seconds, judge whether O(N^2) will pass.

Free
3

Cutting the Constant Factor to Make It in Time

Same complexity, 10x difference. Measure three fixes: put work inside a function, let built-ins do it, and combine strings with join.

Free
4

Overflow and Floating-Point Traps

Python integers never overflow, but they break the moment they pass through a float. Build an example that is off by exactly 1 near 10^18, and avoid it with isqrt and integer math.

🔒 Basic
5

Common Pitfalls and a Pre-Submission Checklist

Shared 2D lists, 1-indexed off-by-ones, the recursion limit, edge-case inputs. Build a 5-item pre-submission checklist to catch bugs yourself before you get WA.

🔒 Basic

Chapter 2 — Brute Force (lessons 6–10)

First, you learn to write solutions that simply try everything: nested loops, bit brute force, permutations, recursion, and finally pruning that makes N-Queens 65 times faster.

6

Start by Enumerating Everything (Nested Loops and combinations)

First write a solution that counts everything, then use it as a baseline to build a faster one. Measure a 58x gap between a triple loop and a double loop plus a dict.

🔒 Basic
7

Bit Brute Force: Representing Pick or Skip as an Integer

Loop over every subset of n items as the integers 0 to 2^n-1. Measured at 2.6 ms for n=20 and 0.58 s for n=24, decide the practical upper limit.

🔒 Basic
8

Permutation Brute Force: Trying Every Ordering

Loop over all n! orderings with permutations. Measured at 18 ms for n=9 and 205 ms for n=10, conclude that n ≤ 8–9 is the limit.

🔒 Basic
9

Enumerating Everything with Recursion

Write pick-or-skip as recursion. Learn the pattern of carrying state through arguments, and how to lift the limit that stops you at depth 1000.

🔒 Basic
10

Making Brute Force Fast Enough with Pruning

Throw it away before you look at it. Compare all permutations with pruning on N-Queens: 65x faster at n=10, and pruning alone reaches n=13.

🔒 Basic

Chapter 3 — Binary Search and Prefix Sums (lessons 11–15)

You'll learn three ideas: binary search on the answer, never moving the right end backward, and preprocessing once to reuse many times. We measure the two-pointer technique running 1,358 times faster, and prefix sums making a difference of whole seconds.

11

Binary Search on the Answer

Discard half of the candidate answers, not half of the data. Learn how to check that the predicate is monotonic, and name your variables ok/ng so you never get the boundary wrong.

🔒 Basic
12

The Two-Pointer Technique: Never Move the Right End Back

Turn the nested loop that counts intervals into O(n). The right end never moves back, and that's why it's fast. On my machine it was 1,358 times faster.

🔒 Basic
13

Prefix Sums: Range Sums in an Instant

With O(n) preprocessing, range sums become O(1). Using half-open intervals keeps the subtraction boundaries right. Measure a difference of seconds over 200,000 queries.

🔒 Basic
14

2D Prefix Sums: Rectangle Sums with Four Additions and Subtractions

Make rectangle sums on a grid O(1). Check by eye on a small table how you add back what was subtracted twice, then implement it.

🔒 Basic
15

The Imos Method: Batching Range Additions

Turn range additions into "marking the boundaries," then take a prefix sum just once at the end. Adding to 200,000 ranges finishes in 24 ms.

🔒 Basic

Chapter 4 — Dynamic Programming (lessons 16–22)

Over 7 lessons, you practice deciding "what to store in dp." We cover knapsack, 2D DP, interval DP, and bitDP, comparing each one against a naive solution every time.

16

Setting Up a DP: Define the State, Write the Transitions

First write in plain words "what goes in dp." Learn push DP vs. pull DP, and measure a 400,000x gap against naive recursion.

🔒 Basic
17

0-1 Knapsack: A Table of Pick or Skip

Keep the best value for each capacity in a 1D array and loop backward. Versus 2^n brute force, it's 26,549 times faster with 22 items.

🔒 Basic
18

Subset Sum and Unbounded Knapsack

Just flipping the loop direction turns it into "use each item as many times as you like." Using one integer as a bitset makes subset sum 1,111 times faster.

🔒 Basic
19

2D DP: Longest Common Subsequence and Edit Distance

A table that lines up two strings. Naive recursion takes 118 ms at length 13, while DP finishes two 500-character strings in 24 ms.

🔒 Basic
20

Interval DP: From Short Intervals to Long Ones

Fill in intervals from shortest to longest, trying every split point. Versus naive recursion, it's 12,027 times faster with 15 matrices.

🔒 Basic
21

bitDP: Using the Set of Visited Nodes as an Index

Represent "where you've been" as a single integer and use it as a DP index. All n! permutations shrink to 2^n × n^2, reaching 18 cities.

🔒 Basic
22

[Practice] Designing Your Own Transitions (Longest Increasing Subsequence)

Write a straightforward O(n^2) DP, then change what you store to get O(n log n). Same problem, 1,442 times faster.

🔒 Basic

Chapter 5 — Graph Techniques (lessons 23–27)

Starting from adjacency lists, we move on to four shortest-path tools, Union-Find, minimum spanning trees, and topological sort. They're all connected by a single idea: "process things in the right order."

23

Reading Graphs and Adjacency Lists

Nail down the pattern for turning an edge list into an adjacency list. Covers fixing 1-based indices, multi-edges and self-loops, and treating a grid as a graph.

🔒 Basic
24

Shortest Paths: Choosing Among Four Tools

BFS, 0-1 BFS, Dijkstra, and Floyd-Warshall. Choose by the shape of the weights and what's being asked. A priority queue makes an 88x difference.

🔒 Basic
25

Union-Find: Keeping Track of Connections

Two operations, connect and ask "same group?", in nearly constant time. 717x faster than running BFS each time, and path compression alone is worth 340x.

🔒 Basic
26

Minimum Spanning Tree: The Cheapest Way to Connect Everything

Look at edges from lightest to heaviest and take only those that don't form a cycle. Kruskal's algorithm is Union-Find's first application, and sorting takes half the time.

🔒 Basic
27

Topological Sort and DP on a DAG

Build an order that satisfies the ordering constraints, starting from in-degree 0. Run DP in that order and problems with dependencies solve themselves.

🔒 Basic

Chapter 6 — Contest Practice (lessons 28–30)

You'll walk through one problem end to end, choosing an approach from the constraints, then solve three classic problems in a row. We wrap up by building a tool that automatically finds counterexamples and shrinks them.

28

How to Solve Within the Time Limit

Read, check constraints, choose an approach, write, test, submit. Go through one problem in this order and find out for yourself where you get stuck.

🔒 Basic
29

[Practice] Solving Three Classic Problems in a Row

One each of the two-pointer technique, BFS with extra state, and DP. Each is practice in deciding "which tool" from the constraints before you write.

🔒 Basic
30

Debugging Patterns and Where to Go Next

For WA, randomly compare against brute force; for TLE, recount the complexity. We wrap up by building a tool that automatically finds and shrinks counterexamples.

🔒 Basic

Once you've finished all 30 lessons, it's time to strengthen these tools from a different angle. Measure the complexity of real-world code in Algorithms for Beginners, build your ability to read formulas in Math for Programmers for Beginners, and solidify how you write code itself in Python for Beginners. Each one picks up where this course leaves off. A membership unlocks every course.