Track 01 of 10

ComplexityBeginner Level~20 Mins

1. Big-O Complexity & Hardware Realities

Stop guessing performance — learn how CPU cycles and memory access dictate execution time.

The "WHY" Core Principle

CPUs execute billions of instructions per second, but memory access speed varies drastically. Big-O measures how operations scale as input size N grows toward infinity.

Interactive Visualizer

Interactive Big-O Complexity 2D Graph & Operation Profiler

Move the slider to observe operation growth curves smoothly scale as input size N increases.

Input N:25

Smooth 2D Growth Curves (X = Input N, Y = Relative Operation Growth)Hover over graph to inspect coordinates

N = 1 (Small Input)

N = 100 (Large Input)

Y = Operation Complexity

Toggle Curves:

O(1)Constant Time

Instant (<0.01 ms)

Operations at N = 25

Python Pattern:

def get_first(arr):
    return arr[0]  # Direct memory offset

Analogy: Jumping directly to a page number in an indexed book.

O(log N)Logarithmic Time

Ultra Fast (~0.02 ms)

Operations at N = 25

Python Pattern:

while low <= high:
    mid = (low + high) // 2  # Halve search space

Analogy: Finding a name in a phonebook by opening to the middle repeatedly.

O(N)Linear Time

Fast (~0.1 ms)

Operations at N = 25

Python Pattern:

for item in arr:
    if item == target: return True  # Single sweep

Analogy: Reading every page in a book line by line from front to back.

O(N log N)Linearithmic Time

Efficient (~0.8 ms)

116

Operations at N = 25

Python Pattern:

def merge_sort(arr):
    # Divide array (log N) & merge halves (N)

Analogy: Sorting a deck of cards by splitting into 2 piles recursively.

O(N²)Quadratic Time

Moderate (~15 ms)

625

Operations at N = 25

Python Pattern:

for i in range(n):
    for j in range(i + 1, n):  # Compare every pair

Analogy: Comparing every card in a deck against every other card.

O(2ⁿ)Exponential Time

CPU Crash Threat!

∞ (Explodes CPU)

Operations at N = 25

Python Pattern:

def fib(n):
    return fib(n-1) + fib(n-2)  # 2 recursive calls per step

Analogy: Trying every possible combination password lock.

WHY BIG-O MATTERS FOR HIGH-PERFORMANCE CODE:

Notice how O(1) and O(log N) remain near the bottom of the graph even as $N$ grows, while O(N²) and O(2ⁿ) curve steeply upward. This difference is why selecting the correct data structure prevents CPU bottlenecks!

Interactive Code Snippets (2 Lessons)

Lesson 01

O(1) Constant Time — Direct Memory Offset

O(1)O(1)

Why list indexing `arr[i]` or dict lookup `hashmap[key]` takes O(1) time regardless of whether N is 10 or 10,000,000.

WHY Under The Hood:

In memory, a Python list is stored as a contiguous block of memory pointers. Finding element i requires a simple hardware multiplication: address = base_address + (i * 8 bytes).

CPython C Struct Detail: CPython PyListObject stores `ob_item` as an array of `PyObject*` pointers.

O(1) Constant Time — Direct Memory Offset

Pyodide WASM Engine

Type, edit code, and click 'Run & Profile' to see live runtime ms and operation count!

Python 3.12 Code (Editable)

Expected:Time: O(1)Space: O(1)

Lesson 02

O(N²) Quadratic vs O(N) Linear Benchmark

O(N²)O(1)

Compare why nested loop duplicate check takes O(N²) while Set hash lookup drops execution time to O(N).

WHY Under The Hood:

In O(N²), for N elements, the inner loop executes N(N-1)/2 comparisons. In O(N), a hash set uses object hashes to jump directly to memory buckets.

CPython C Struct Detail: PySet_Contains uses C hash code computation PyObject_Hash(key) modulo set capacity.

O(N²) Quadratic vs O(N) Linear Benchmark

Pyodide WASM Engine

Type, edit code, and click 'Run & Profile' to see live runtime ms and operation count!

Python 3.12 Code (Editable)

Expected:Time: O(N²)Space: O(1)

Test Your Understanding

WHY does `arr[999]` execute in the exact same time as `arr[0]` in Python?

Next: 2. Python Memory Model & Pointers Under The Hood