Phase 2Days 8-13

STL Foundations & Problem-Solving Reflex

Become fluent with the containers and algorithms you will reuse for the entire course

Phase Goal

Turn the standard library into muscle memory and build the reflex of translating a statement into clean code.

Progress

Day 8: pair, tuple, references & iterators

pair<A,B>: first/second, make_pair, and when to bundle two valuesComparing pairs: lexicographic order (first, then second)tuple for three or more values; tie for unpackingStructured bindings: auto [a, b] = p

begin() and end(); end() is one-past-the-lastDereference with *it, advance with ++itHalf-open ranges [begin, end) and why they compose cleanlyconst_iterator and when you cannot modify through an iterator

auto to let the compiler name a type; auto& to avoid a copyRange-for by value versus by referenceconst auto& for read-only traversal of big containersThe invalidated-iterator idea: changing a container while iterating

Choose one core problem from LeetCode, Codeforces, AtCoder, or CSES after checking its prerequisites; hide its technique labelSpend 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 9: vector mastery + the <algorithm> staples

Initializer lists, resize, assign, clearinsert and erase and their O(n) costfront, back, pop_back; emplace_back versus push_backswap and moving data cheaply

sort(v.begin(), v.end()) and default ascending orderreverse, min_element, max_element, accumulatecount, find, and count_if with a simple lambdalower_bound and upper_bound on a sorted vector (full binary search in Phase 5)

Sorting descending with greater<int>() or a lambdaSorting a vector of pairs or structs by a chosen keystable_sort and when stability mattersThe strict-weak-ordering rule a comparator must obey

Day 10: Ordered containers — set, multiset & map

set keeps unique elements sorted; O(log n) insert/find/eraseWhy sorted: it is a balanced binary search tree underneathmultiset allows duplicates; erasing one versus all occurrencesIterating a set yields sorted order for free

map<K,V> as a sorted dictionary; operator[] inserts a defaultThe [] auto-insert trap (accidentally creating keys)find versus count versus [] for lookups without insertingIterating a map yields keys in sorted order

lower_bound/upper_bound on a set for nearest-neighbor queriesFrequency maps: counting with map<int,int>begin() and rbegin() for min/max in a changing setCost model: everything is O(log n), not O(1)

Day 11: Hashing — unordered_set & unordered_map

Average O(1) insert/find via hashing; the bucket mental modelunordered_set and unordered_map mirror set/mapNo sorted order: iteration order is unspecifiedWhen O(1) average beats O(log n): huge lookups where order does not matter

Worst-case O(n) on collisions; anti-hash tests in CPWhy unordered_map<int,int> can be hacked to TLE on CodeforcesMitigations: a custom hash with a random seed, or fall back to a sorted mapHashing custom keys (pairs) needs a hash function

Frequency array versus hash map: pick the array when the key range is smallCounting characters with an int[26]Detecting duplicates and the first unique elementOne-pass versus two-pass counting

Day 12: Basic number crunching for problems

Extracting digits with % 10 and / 10Reversing a number and checking a palindrome numberCounting digits and summing digitsBase conversion: decimal to binary and back

Even/odd, divisibility, and modulo behavior with negativesGCD via the Euclidean algorithm and why it worksLCM from GCD with an overflow-safe order: a / gcd * b__gcd and C++17 gcd/lcm

Primality by trial division up to sqrt(n)Listing divisors in O(sqrt n) with the i, n/i pairingBinary exponentiation (fast power) and its codeWhy sqrt-time beats the naive O(n) loop

Day 13: Simulation & pattern problems (the translation reflex)

Mapping (row, col) to the character to printNested loops for triangles, pyramids, diamondsFinding the formula linking the row index to counts of spaces/starsDebugging alignment by dry-running two rows

Literally following the rules step by step (grid moves, event queues)Choosing the right container to model the stateBoundary handling and stopping conditionsKeeping simulation O(n) instead of rescanning each step

Meaningful names, small helpers, early returnsGuarding edge cases (n==0, single element, all same)Printing in the exact required formatA pre-submit checklist: overflow, bounds, format, sample match

Phase Complete!

After this phase, you'll be able to:

pair, tuple, references & iterators
vector mastery + the <algorithm> staples
Ordered containers — set, multiset & map
Hashing — unordered_set & unordered_map
Basic number crunching for problems
Simulation & pattern problems (the translation reflex)

After Phase 2, 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

STL Foundations & Problem-Solving Reflex

Phase Goal

Day 8: pair, tuple, references & iterators

Grouping values

Iterators as generalized pointers

References and auto

Practice, delayed recall, and independent transfer

Day 9: vector mastery + the <algorithm> staples

Building and reshaping vectors

The algorithms you use daily

Custom ordering with comparators

Practice, delayed recall, and independent transfer

Day 10: Ordered containers — set, multiset & map

set and multiset

map — key to value

When ordered structures shine

Practice, delayed recall, and independent transfer

Day 11: Hashing — unordered_set & unordered_map

Hash tables versus trees

How hashing breaks

The counting toolkit

Practice, delayed recall, and independent transfer

Day 12: Basic number crunching for problems

Digits and numbers

Divisibility and GCD

Primes and powers (basics)

Practice, delayed recall, and independent transfer

Day 13: Simulation & pattern problems (the translation reflex)

Pattern printing

Simulation problems

Clean coding habits that save contests

Practice, delayed recall, and independent transfer

Phase Complete!