🎲 Random & Time

Modern C++ random numbers separate the engine (raw random bits) from the distribution (the shape you want). Write roll_sum: roll a fair six-sided die n times with a std::mt19937 engine seeded by seed, and return the sum.

Two objects, then a loop:

std::mt19937 rng(seed);                        // engine: Mersenne Twister — same seed, same sequence
std::uniform_int_distribution<int> die(1, 6);  // distribution: shapes raw bits into 1..6, without bias
int total = 0;
for (int i = 0; i < n; ++i) {
    total += die(rng);                         // each call advances the engine by one step
}

Why not rng() % 6 + 1? The engine's range is not a multiple of 6, so % makes the low faces slightly more likely; the distribution corrects for that.

For a real game you would seed from std::random_device{}() instead of a constant — the tests use a fixed seed because they need the same rolls every run.

Write shuffled(n, seed): the numbers 1..n in a random order produced by std::shuffle driven by a std::mt19937 seeded with seed. std::shuffle takes the engine explicitly; the old std::random_shuffle used a hidden global one and was removed in C++17.

std::vector<int> v(n); std::iota(v.begin(), v.end(), 1); fills 1..n (std::iota writes consecutive values starting from the third argument). Then std::mt19937 rng(seed); std::shuffle(v.begin(), v.end(), rng); return v;. std::shuffle implements Fisher–Yates: it walks the range once, swapping each element with a random one at or after it, so every permutation is equally likely.

Write total(h, m, s): add an hours, a minutes and a seconds value and return the sum as std::chrono::seconds. Each argument is a different type, yet no cast is needed — converting a coarse unit into a finer one loses nothing, so the compiler does it implicitly. The std::chrono_literals suffixes (1h, 30min, 15s, 250ms) build these values in the tests.

return h + m + s; — hours + minutes yields minutes, minutes + seconds yields seconds; the compiler picks the finest unit involved and returns a typed duration, so t == 125000ms and t > 2min compare correctly without you converting anything. Only the reverse direction (seconds → minutes) needs an explicit duration_cast.

std::chrono durations carry their unit in the type, so the compiler converts between them for you — but only when nothing is lost. Going from a fine unit to a coarser one can lose the remainder, so it must be explicit. Write whole_minutes: how many complete minutes fit in s.

return std::chrono::duration_cast<std::chrono::minutes>(s).count(); — duration_cast is the explicit, truncating conversion; .count() unwraps the plain number. If you want rounding instead of truncation, C++17 adds std::chrono::floor, ceil and round with the same shape.

Write elapsed_ms(work): run the callable work and return how many whole milliseconds it took. Use std::chrono::steady_clock — a monotonic stopwatch clock that never jumps backwards, unlike system_clock, which follows the wall clock and can be adjusted mid-measurement.

auto start = std::chrono::steady_clock::now(); gives a time_point; call work();, take now() again, and subtract — time_point - time_point is a duration in the clock's native unit (nanoseconds here). std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() truncates it to whole milliseconds. std::function<void()> is the parameter type: it can hold any callable with no arguments and no result — a lambda, a function pointer, a functor.