Phase 1Days 1-7

C++ & Complexity Foundations

Write, run, and put a price on small C++ programs before any data structure appears

Phase Goal

Get fluent enough with C++ and Big-O that every later problem is about the idea, not the syntax.

Progress

Day 1: Your first C++ program & the compile-run loop

What a compiler does: .cpp turns into an executable, and why compiled C++ is fastAnatomy of a program: includes, int main(), statements, semicolons, return 0Compile and run from the terminal: g++ file.cpp -o file, then run itReading a compiler error by its line number instead of panicking

cout and the << operator; a plain newline versus endl and why newline is fasterThe starter template every solution begins from (headers plus main)Bits/stdc++.h: what it pulls in and its trade-offusing namespace std: convenience versus the name-clash risk

cin and >> for reading multiple values; what >> skips (whitespace)sync_with_stdio(false) and cin.tie(nullptr): buffering, flushing, stream coordination and large-input trade-offs without a universal numeric thresholdDeclare an integer input slot before cin; trace one read and print (test-case loops arrive on Day 3)Matching the exact required output format

Start locally: predict, trace, write, and debug tiny programs using only syntax already taught; no judge quotaRebuild the smallest working program after closing the example; explain each partUse a five-task bank: guided warm-up, core, changed constraint, delayed recall, optional stretch; attempt one or two, not all five on a timerBefore a solution, produce a trace or brute-force plan; when stuck take one hint, act on it, then reassessRecord help used, the failing input, the corrected reasoning, and a next review date; start around 1/3/7/14/30 days and adaptReserve a weekly mixed review; after foundation readiness add a short virtual contest and upsolve one task with known prerequisitesProve progress through a delayed blank-editor reconstruction and a changed problem; a same-day quiz is supporting evidence only

Day 2: Data types, integer overflow & precision

int, long long, char, bool, double: sizes and value rangesWhy int caps near 2e9 and long long near 9e18When to reach for long long: sums and products of large arrayssizeof and numeric_limits to check a range

Signed overflow is undefined behavior: an observed wraparound is not a reliable rule; contrast unsigned arithmeticMultiplying two ints that fit but whose product does notCasting to long long before multiplying: (long long)a * bunsigned types and the signed/unsigned comparison pitfall

double versus float; why 0.1 + 0.2 is not exactly 0.3Integer division truncates (7/2 is 3) versus real divisionComparing doubles with an epsilon instead of ==When to avoid floating point and stay in integers

Start locally: predict, trace, write, and debug tiny programs using only syntax already taught; no judge quotaSpend 10–20 minutes retrieving one earlier mechanism and one earlier bug before new work; prioritize weak prerequisitesUse a five-task bank: guided warm-up, core, changed constraint, delayed recall, optional stretch; attempt one or two, not all five on a timerBefore a solution, produce a trace or brute-force plan; when stuck take one hint, act on it, then reassessRecord help used, the failing input, the corrected reasoning, and a next review date; start around 1/3/7/14/30 days and adaptReserve a weekly mixed review; after foundation readiness add a short virtual contest and upsolve one task with known prerequisitesProve progress through a delayed blank-editor reconstruction and a changed problem; a same-day quiz is supporting evidence only

Day 3: Conditionals, loops & turning a statement into code

if / else if / else and boolean conditionsComparison and logical operators (&&, ||, !) and short-circuit evaluationswitch-case: when it beats a chain of ifs, and the fallthrough trapThe ternary ?: for a compact conditional value

for, while, do-while: which to reach for and whybreak and continue and the readable use of eachNested loops and reading their combined cost (n times m)Off-by-one errors: <= versus <, and picking loop bounds deliberately

Reading a problem: input format, output format, constraintsRestating the task in one sentence before typingSketching the plan as comments, then filling in codeDry-running the sample by hand before submitting

Day 4: Functions, scope & the call stack

Declaring a function: return type, name, parameters, bodyWhy functions: naming a sub-task and reusing itvoid functions versus value-returning functionsOrdering and forward declarations

Pass by value copies the argument (and its O(n) cost for containers)Pass by reference (int&) lets a function change the caller's variableconst int& as a read-only reference; apply references to containers after vectors are taught on Day 5Local scope, shadowing, and where a variable lives

What a stack frame is: parameters, locals, return addressHow calls push frames and returns pop themA function calling itself: the seed of recursion (we build it fully in Phase 3)Stack overflow: what too-deep recursion actually does

Start one prerequisite-safe LeetCode task only after explaining its function/class harness; local drills remain validSpend 10–20 minutes retrieving one earlier mechanism and one earlier bug before new work; prioritize weak prerequisitesUse a five-task bank: guided warm-up, core, changed constraint, delayed recall, optional stretch; attempt one or two, not all five on a timerBefore a solution, produce a trace or brute-force plan; when stuck take one hint, act on it, then reassessRecord help used, the failing input, the corrected reasoning, and a next review date; start around 1/3/7/14/30 days and adaptReserve a weekly mixed review; after foundation readiness add a short virtual contest and upsolve one task with known prerequisitesProve progress through a delayed blank-editor reconstruction and a changed problem; a same-day quiz is supporting evidence only

Day 5: Arrays & std::vector — the workhorse

Declaring an array, indexing from 0, contiguous memoryIterating with a for loop and the sizeOut-of-bounds access is undefined behavior (no safety net)2D arrays and row-major layout

Why vector over raw arrays: it knows its own size and can growCreating and sizing: vector<int> v(n, 0)push_back, size, empty, back, and indexing with []Range-based for and iterating by reference

Count copies over repeated push_back calls; geometric capacity growth is typical, exact growth is implementation-dependent; formalize amortized cost on Day 7The invalidated-reference trap after push_backPassing vectors by reference to avoid copies2D vectors: vector<vector<int>> to build a grid

Day 6: Strings in C++

Creating strings, length/size, indexing charactersConcatenation with + and += and its costReading strings: >> reads one token, getline reads a whole lineIterating characters and modifying in place

A char is an integer: 'a' has an ASCII codec - 'a' maps a lowercase letter to 0..25 (the frequency-array trick)c - '0' turns the char '7' into the number 7toupper, tolower, isalpha, isdigit helpers

substr, find, and comparing stringspush_back and pop_back on a stringBuilding a string efficiently versus repeated + in a loopto_string and stoi for number-string conversion

Day 7: Time & space complexity — putting a price on code

Why we count operations: rough timing estimates depend on language, hardware, memory access, and operation cost; measure rather than assume 1e8 per secondCounting the dominant operation in a loopBig-O as a growth rate: drop constants and lower-order termsThe common classes: O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n)

Mapping n to an allowed complexity (n<=20 to 2^n; n<=1e3 to n^2; n<=1e5 to n log n; n<=1e7 to n)Worst / average / best case and why we design for worstSpace complexity: extra memory versus in-placeAmortized cost: why push_back is O(1) on average

Predicting a time-limit-exceeded from constraints before writing a lineNested loops multiply; sequential loops addRecursion cost as (number of calls) times (work per call)A worked example: turning an O(n^2) idea into O(n) with a plan

Phase Complete!

After this phase, you'll be able to:

Your first C++ program & the compile-run loop
Data types, integer overflow & precision
Conditionals, loops & turning a statement into code
Functions, scope & the call stack
Arrays & std::vector — the workhorse
Strings in C++
Time & space complexity — putting a price on code

After Phase 1, explain a core invariant, reconstruct a solution after a delay, diagnose a bug, and solve one unlabelled variation. Repair a failed prerequisite before advancing; record help separately from independent work.

Back to all phases

C++ & Complexity Foundations

Phase Goal

Day 1: Your first C++ program & the compile-run loop

From source to a running program

Printing and the CP skeleton

Reading input and fast I/O

Practice, delayed recall, and independent transfer

Day 2: Data types, integer overflow & precision

Primitive types and their ranges

The overflow trap

Floating point and precision

Practice, delayed recall, and independent transfer

Day 3: Conditionals, loops & turning a statement into code

Branching

Loops and iteration

From problem statement to first program

Practice, delayed recall, and independent transfer

Day 4: Functions, scope & the call stack

Writing and calling functions

Pass by value versus pass by reference

The call stack (mental model for recursion later)

Practice, delayed recall, and independent transfer

Day 5: Arrays & std::vector — the workhorse

Fixed arrays

std::vector as a resizable array

Common vector operations and their cost

Practice, delayed recall, and independent transfer

Day 6: Strings in C++

std::string basics

Characters are numbers

Useful string operations

Practice, delayed recall, and independent transfer

Day 7: Time & space complexity — putting a price on code

Counting operations

Reading constraints to pick an approach

Estimating before coding

Practice, delayed recall, and independent transfer

Phase Complete!