Bit Manipulation & Math

Because it silently zeroes the value when both operands are the same storage location — a partition routine that swaps an element with itself destroys it. It is also not faster than a swap through a temporary on modern hardware.

Flag 31 lands on the sign bit, so masks turn negative. Past that, shifting by 32 or more is not a reliable zero: many environments reduce the count modulo the width, so flag 32 silently aliases flag 0.

A shift count equal to the operand's width is outside what shifts define: languages variously wrap the count, yield zero, trap, or leave it undefined. Build the all-ones mask without shifting by the full width.

Barely, and only offline: 12! = 479,001,600 orderings is a few hundred million evaluations, roughly seconds to minutes on one core. But 13! is 6.2 billion and 15! is 1.3 trillion, so the approach dies within three more stops.

Pick by what a wrong number costs. Checked signals and suits values that must be exact; saturating clamps and suits gauges that may be understated; wrapping is correct only for genuinely modular quantities like sequence numbers.

Fold pairwise: start an accumulator at 0 and replace it with gcd(accumulator, next size). Zero is the identity, so zero-size entries change nothing, and once the accumulator reaches 1 you can stop early — it can never rise again.

Memory dominates, not time. The sieve keeps one flag per candidate, so a byte-per-flag run costs about ten megabytes at 10^7 but a gigabyte at 10^9, while the near-linear marking work stays affordable. Raising the ceiling breaks the flag array first.

A mask wins when the check path is hot and the flag list is stable; it loses when permissions must be read by humans, grow steadily, or are persisted — positions freeze into a contract and capacity is capped.

One hundredth is non-terminating in binary, so every amount held in a 64-bit float is approximate from the first assignment and error accumulates across millions of postings. Decimal or integer minor units make amounts exact and rounding an explicit, auditable rule.

Decide on what each buys beyond the answer. The fold runs in constant space and shards trivially, but returns a bare id and fails silently when the exactly-paired invariant breaks. A set costs memory but returns every anomaly with records you can investigate.

Subtracting one borrows through the lowest set bit, clearing it and setting all bits below; ANDing with m discards bits m does not own. The result is the next-smaller submask, so the loop descends through all of them.

Fix one element and split every selection by whether it is chosen: those including it pick k-1 more from the remaining n-1, those excluding it pick all k from those n-1. The cases are disjoint and exhaustive, so the counts add.

An unsigned integer cannot hold a negative value, so the guard i >= 0 is always true. When i reaches 0, decrementing wraps it to the maximum unsigned value — the bit pattern of -1 — and the scan runs past the array forever.

No. The loop costs one unpredictable branch per set bit, so its price rises with board density. At that call volume use a fixed-cost population-count instruction, with a branch-free shift-and-mask fallback where the hardware lacks one.

A 64-bit float carries a 53-bit significand, so it represents integers exactly only up to 2^53, about 9.0e15. Larger identifiers round to the nearest representable value with no error raised, so distinct IDs shift by one or collide with each other.

Fixed-width multiplication breaks. Two residues below 10^18 multiply to about 10^36, roughly 120 bits, which silently wraps a 64-bit accumulator. The conventional modulus is prime and sits just under 2^30 precisely so the squared product still fits.

One fold gives the combination of the two missing numbers, and any bit set in it marks a position where they disagree. Splitting the whole stream on that bit puts one in each half, so folding each half separately recovers both.