Counting & Combinatorics

Both totals count one collection: every reviewer set the roster can produce. Grouping that collection by size and adding the groups gives the sum of binomial coefficients; building a set by deciding in or out per engineer gives 2^n. One collection, two tallies, so they are equal.

Subtracting each filter's matches over-corrects records caught by several filters, so pairwise overlaps are added back, triples removed again, and so on. The alternating signs make every record matching at least one filter cancel to exactly zero.

Subtract from 1000 the multiples of 2, 3 and 5, add back the multiples of 6, 10 and 15, then subtract the multiples of 30. That is 1000 - 734 = 266 surviving IDs.

Split on the last slot. Idle leaves any valid (n-1)-schedule; maintenance forces the previous slot idle, leaving any valid (n-2)-schedule. The two cases are disjoint and exhaustive, so their counts add.

Dividing favourable outcomes by total outcomes is valid only when the outcomes are equally likely, mutually exclusive and exhaustive. A 1/16 share assumes the hash spreads the actual traffic uniformly, each request lands on exactly one shard, and the shard count is fixed.

At most 20%. The union bound says the chance that any bad event happens is no more than the sum of their individual chances, so 200 times 0.001 gives 0.2. It is an upper bound, and it needs no independence assumption.

Multiply when a job is built by making one independent choice on each axis, so the options on one axis never depend on another. Add when the jobs split into cases that no single job can belong to twice.

Find the object your enumeration reaches twice. The usual causes are cases that are not disjoint, an order imposed on something that has none, and a symmetry never divided out. Give each job one canonical name, count names, and compare.

The excluded side is usually the smaller and simpler one to describe, and it is often a clean product while the allowed side is not. Complementary counting is exact: full universe minus excluded, provided each excluded item is counted once.

Both sides count k-member reviewer sets on the combined roster. The right side splits that collection by how many members j come from the platform pool, then multiplies the choices within each pool. The split is a partition, so adding the cases reproduces the left side.

Roughly 37 percent - about 1/e - and from n = 5 onward the fraction barely moves as n grows. These no-fixed-point arrangements are derangements, counted by an alternating sum over the shards that could have stayed put.

Because the split point varies. The closer matching the first opener can fall anywhere, cutting the sequence into an inside part and a remainder, so C(n) is a sum of products C(i)*C(n-1-i) — products of unknowns, not a fixed-length weighted sum.

A closed form and a growth rate. Guessing f(n)=r^n turns the recurrence into r^2=r+1, whose roots (1+sqrt5)/2 and (1-sqrt5)/2 combine as Ar1^n + Br2^n; the larger root, about 1.618, is the per-step growth factor.

Attach one indicator per shard - worth 1 when that shard stays empty - and add the indicators' probabilities. Each shard is empty with probability (1 - 1/n)^n, so the expected count is n times that, about 0.37n for large n.

Because collisions happen between pairs, and k identifiers make about k^2/2 pairs, each colliding with probability 1/n. The summed risk reaches order 1 near k = sqrt(2n), so the tolerable count grows only as the square root of the space.

The row lists how many distinct k-member approver groups each choice of k admits. It is mirror-symmetric, rises to a peak near k = n/2, and totals 2^n. It sizes the space of approving groups - it says nothing about how strict or how satisfiable the rule is.

Decide by what you can touch. With the raw records in reach, one pass evaluating a compound predicate costs about n times k and is exact; the signed sum is for when only aggregate set sizes are available, and at twenty filters its million terms mean a million measurements.

Less than it first appears. Both counts are exponential, so neither space can be enumerated at realistic n; the tighter rule buys a growing factor — roughly 4,000 times fewer schedules at n=40 — which helps pruning and reach, not feasibility in kind.

Switch when the exceptions stop being a short, independent list. One product minus exceptions stays compact while exclusions are few; once exclusions interact, a sum of disjoint families keeps each part a plain product and makes the total verifiable.

Both sides count the 3-member panels formable from n+1 engineers ranked by seniority. Grouping those panels by their most senior member, a panel topped by rank m has its other two chosen from the m-1 below, and summing over m gives exactly that running total.

Take all k^n placements and remove those that miss at least one bucket by an alternating sum: sum over j of (-1)^j C(k,j) (k-j)^n. For 5 records into 3 buckets that is 243 - 96 + 3 = 150.

Because it collapses: Ar^n + Br^n is (A+B)r^n, one free constant where a second-order recurrence needs two, so it cannot match two independent starting values. The missing second solution is nr^n, giving (A + B*n)*r^n.

A ring has no first position, so each ring is written down once for every choice of which service you list first. With n distinct services, those n rotations are all different orderings but the same ring, so the ordering count is n times too large.

Set the budget from what a duplicate would actually cost, not from taste. Compare it with failures already tolerated, apply it to lifetime volume over the scope where uniqueness must hold, then invert the collision bound to get the required width.