Problem Archetypes

22 archetypes · each represents a recurring structural pattern that drives problem generation. Sorted by number of member problems.

Arithmetic Expression Decomposition

451 problems Grade 5 –7

A multi-step numerical computation (sum of fractions, rate × time, area × thickness) is attacked by splitting it into a small number of independent subproblems whose answers are then combined. The key move is identifying the clean split, not the underlying topic.

Member problems

Exemplar problems

Transformable parameters

term_count Range: 2 to 5

How many independent sub-pieces the expression decomposes into

numeric_scale Range: single digits to thousands

Order of magnitude of the inputs (controls difficulty of the arithmetic)

surface_context Range: abstract | rate-over-time | area-times-thickness | fuel-economy

Real-world wrapper (fraction sum, CO2 rate, tape on a roll, paint coverage)

rounding_rule Range: exact | nearest 10 | nearest 100

How the final answer is rounded (exact, nearest 100, nearest integer)

Variant hints

  • Keep the structure (rate × time) but swap context from CO2 to bacteria population or tuition inflation
  • Make one of the sub-fractions reducible by 11 or 101 to mirror Problem 2's clean cancellation
  • Adjust numeric_scale so the convenient round-number shortcut (e.g. 1.5 × 50) still applies
Caveats for variants (2)
  • Ensure exactly one of A-E is correct after rounding — adjacent answer choices in rate problems often differ by less than the rounding tolerance
  • Sub-problem answers should be clean enough that mental arithmetic stays viable

Coordinate Plane Figure Computation

188 problems Grade 6

A polygon or other figure is given by coordinates; the task is to compute an unknown coordinate, length, or area. The structural move is reading off horizontal/vertical distances directly from coordinate differences, then applying a one-line geometric formula (base × height / 2, etc).

Member problems

Exemplar problems

Transformable parameters

figure_type Range: triangle | parallelogram | trapezoid | rectangle

Polygon being measured (triangle, parallelogram, trapezoid)

known_coords Range: any combination leaving exactly 1 unknown component

How many coordinates are pinned and which are unknown

target_quantity Range: coordinate | length | area

What the problem solves for (missing coordinate, area, side length)

alignment Range: axis-aligned | one-tilted | general

Whether sides are axis-aligned (easy base/height) or tilted (need Pythagorean or shoelace)

Variant hints

  • Keep base axis-aligned but rotate the apex location (e.g. unknown x instead of unknown y) — symmetric variant
  • Change figure_type to parallelogram so base × height is still the formula
  • For a harder variant, tilt the base so the height must be derived from the perpendicular distance formula
Caveats for variants (2)
  • Ensure the answer choices include both correct value and the natural off-by-one (forgetting the 1/2 in triangle area)
  • Pin the diagram orientation in the problem text to avoid two valid solutions (above vs below the base)

Compound Area by Decomposition / Difference

163 problems Grade 3 –7

A composite planar region is computed as a sum or difference of simpler shapes (rectangles, squares, circles, annular rings, triangles). The work is in choosing the decomposition; each piece uses a single elementary area formula.

Member problems

Exemplar problems

Transformable parameters

shape_family Range: square | circle | right-triangle | mixed

Base shape used (squares, circles/rings, 45-45-90 triangles, rectangles)

layer_count Range: 2 to 5

Number of nested or overlapping shapes

dimension_set Range: small integers 1-15 (keep arithmetic clean)

Specific side lengths / radii / heights used

configuration Range: concentric | corner-nested | overlapping-translates

How the pieces sit (concentric, corner-aligned nested, overlapping at an angle)

Variant hints

  • Change shape_family from squares to circles to convert area answers into multiples of pi
  • Add a layer (e.g. 5 nested squares) to scale difficulty without changing strategy
  • Shift dimension_set so both the total and difference areas remain in the answer-choice range
Caveats for variants (3)
  • After parameter changes, verify the visible shaded region is still a well-defined union/difference
  • For circle problems, keep pi out of the final answer (cancel) so a non-calculator student can finish
  • Be careful with overlaps that change topology when dimensions shift (e.g. overlap may vanish)

Overlap / Complement Counting

93 problems Grade 4 –7

Two classifications partition a population (red/white × high-top/low-top) or we want 'at least one' adjacent pair. Direct counting tangles the cases; the trick is either a 2×2 contingency table (inclusion-exclusion) or counting the complementary event and subtracting from 1.

Member problems

Exemplar problems

Transformable parameters

population_size Range: 10 to 30

Total count of items being classified or seated

classification_count Range: 2

Number of cross-cutting classifications (currently always 2 for AMC 8 level)

target_extremum Range: min-cell | max-cell | p-at-least-one

Minimize one cell of the table, OR compute P(at least one ...)

surface_context Range: free-form

Wrapping context (sneakers, dogs of color×breed, plane seating, lottery)

Variant hints

  • Change the two fractions in problem 19 (3/5 and 2/3) to (4/7 and 3/4) — table arithmetic changes, structure identical
  • For problem 25 style, change rows × seats from 4×3 to 3×4 or 5×2 — the per-row adjacent count formula updates
  • Try 'maximum red-high-top' instead of minimum to flip the optimization
Caveats for variants (3)
  • Verify every cell of the 2×2 table remains a non-negative integer for the chosen extremum
  • For probability variants, confirm the final fraction reduces to one of the offered choices
  • When changing seating layout, redefine 'adjacent' carefully (in-row only? or also vertically?)

Branching State Enumeration

88 problems Grade 2 –4

Starting from an initial state, a sequence of choices (each from a small fixed set of actions) generates a tree of reachable states. The question asks for the count of distinct outcomes or valid sequences. Strategy: build the tree level by level, merging duplicate states or pruning states that violate a constraint.

Member problems

Exemplar problems

Transformable parameters

step_count Range: 3 to 7

Number of moves / hops / days in the process

action_set Range: 2 to 4 actions

The set of allowed actions at each step (e.g. {+3, *2} or {U, D})

starting_value Range: 0 to 20

Initial state of the process

state_constraint Range: none | non-negative | bounded | endpoint-fixed

Boundary or filter rule on states (never negative, never above K, must end at start)

question_type Range: distinct-endpoints | valid-sequences

Count distinct end values, valid full sequences, or both

Variant hints

  • Increase step_count from 3 to 4 — tree size grows from 8 to 16 leaves, still listable
  • Add a third action (e.g. +1) to expand the tree without changing strategy
  • Add a 'never go below 0' constraint to convert a state-counting problem into a Dyck-path-flavored one
Caveats for variants (3)
  • Verify the answer (distinct count) lands among A-E choices — duplicate-state collisions are the hardest thing to anticipate
  • Keep the tree small enough (< 32 leaves) that hand enumeration is realistic
  • When adding constraints, make sure at least one valid sequence still exists

Multiplicative Ratio with Integrality Constraints

80 problems Grade 4

Quantities are linked by ratios (R = G/2, B = 2G, or a:b given). Combined with the requirement that all counts are whole numbers, the ratios force totals to lie in a specific arithmetic progression (multiples of some k). The unique answer is the choice that fits the multiplicative scheme.

Member problems

Exemplar problems

Transformable parameters

ratio_chain Range: any small integer ratio chain summing to 5..20

The list of ratios connecting the quantities (e.g. R:G:B = 1:2:4)

target_quantity Range: total | category | difference

What the question asks for (total, single category, difference)

surface_context Range: free-form

Real-world wrapper (marbles, frogs, classes, candies)

perturbation Range: none | one-step | two-step

Optional change-of-state move (e.g. 3 green become yellow) that re-balances the ratio

Variant hints

  • Change ratio_chain from 1:2:4 to 2:3:5 — totals must now be multiples of 10 instead of 7
  • Add a perturbation that changes the ratio from 3:1 to 5:2 (problem 21 style)
  • Convert from 'which is possible' to 'find the smallest total possible'
Caveats for variants (3)
  • Exactly one answer choice should be a valid multiple of the ratio sum
  • If using a perturbation, the resulting equation must have a positive-integer solution that lands in the choice set
  • Watch for distractor answer choices that are multiples of a wrong sum

Casework by Position / Vertex Type

56 problems Grade 3

Positions in a configuration (squares on a grid, vertices of a polyhedron) split naturally into a small number of symmetry classes (corner / edge / center; edge-neighbor / face-diagonal / space-diagonal). Counting attacks each class separately and sums via the multiplication principle.

Member problems

Exemplar problems

Transformable parameters

ambient_shape Range: 3x3 grid | 4x4 grid | cube | regular tetrahedron

The host configuration (n×n grid, cube, tetrahedron, hexagonal grid)

position_classes Range: 2 to 4

Number of symmetry types of positions

counting_target Range: free-form

What configurations are being counted (non-attacking pairs, equilateral triangles, collinear triples)

object_count Range: 2 to 4

How many marked items are placed

Variant hints

  • Move from 3x3 chess grid to 4x4 — corner/edge/middle counts shift but the casework strategy is identical
  • Replace kings with knights (different attack pattern) so the per-class counts change
  • On the cube, ask for equilateral triangles NOT containing P, or right triangles containing P
Caveats for variants (3)
  • Check whether the symmetry classes really are distinct under the new piece's attack pattern
  • When the host shape grows, verify the total still fits a 5-choice spread (often the answer balloons)
  • Confirm by double-counting (or by listing one full case) that the per-class arithmetic is right

Similar-Triangle Length / Area Ratio

46 problems Grade 6 –8

A length or area inside a synthetic plane figure is recovered by spotting a pair of similar triangles — created by parallel lines, tangent circles, a shared angle, or a right-angle altitude — and solving a single proportion (for a length) or applying the squared linear ratio (for an area). The decisive move is identifying the matched triangles and the correspondence of sides; there are no coordinates and no axis-aligned Pythagorean leg decomposition.

Member problems

Exemplar problems

Transformable parameters

configuration Range: parallel-cut | tangent-circles | chord-in-circle | rectangle-diagonal

What generates the similar pair (parallel cut, tangent circles, chord-in-circle, rectangle diagonal with perpendicular foot)

similarity_criterion Range: AA | SAS | altitude-on-hypotenuse

Which similarity argument is invoked (AA from parallel lines or shared angle, SAS, or a right-angle altitude split)

target_quantity Range: length | area | ratio

What the proportion is solved for — a single length, an area, or a ratio of the two

scale_ratio Range: small rationals such as 1:2, 1:3, 3:4, or determined by given lengths

The linear ratio between the two similar triangles, which the answer is built from

Variant hints

  • Swap a parallel-line cut for a tangent-circle configuration — the similarity argument changes from AA to SAS but the single-proportion finish is identical
  • Ask for an area instead of a length to force the squared-ratio step (area scales as the square of the linear ratio)
  • Change the given lengths so the scale_ratio stays clean (small rationals) while the surface figure looks different
Caveats for variants (3)
  • Verify the triangle correspondence is forced by the figure — a mis-paired correspondence is the most common student error and must not yield a second valid answer
  • When the target is an area, confirm the answer uses the squared ratio, not the linear ratio
  • Keep the proportion solvable in one step with the given data; avoid configurations that secretly require coordinates or the law of cosines

Modular Cycle Frequency Count

43 problems Grade 4 –6

A sequence (often arithmetic, sometimes a schedule of dates) is distributed across residue bins modulo m, and the problem asks which residue is missing, which bin has the most or fewest, or which histogram matches. The decisive move is recognizing that the period m gives a uniform "base" count over a full cycle and a tail correction over the leftover entries.

Member problems

Exemplar problems

Transformable parameters

modulus Range: 5 to 12 (kid-tractable cycles)

Divisor m that defines the residue bins

sequence_kind Range: arithmetic-progression | calendar-dates | term-rule

What's being binned — even integers, dates, sequence terms

total_count Range: must produce a non-trivial tail (not a multiple of m)

How many entries are being binned

target Range: missing | max-bin | min-bin | match-histogram

What's asked — missing residue, max-bin count, matching histogram

Variant hints

  • Swap modulus 7 (days of week) for modulus 5 (school days) or modulus 12 (months) — the cycle bookkeeping is structurally the same
  • Replace 'which histogram matches' with 'which residue never appears' to force the same reasoning without picture options
  • Use a non-uniform tail (e.g. last few entries land in a specific cluster) to make the +1 correction step the load-bearing move
Caveats for variants (3)
  • Choose modulus so the full cycle fits comfortably below the total (otherwise there is no 'base' uniform count and the problem degenerates to plain listing)
  • Tail length should be ≥ 1 and ≤ m-1 — if it's 0, every bin gets the same count (trivial)
  • Answer must be uniquely determined; verify no two residues tie at the extremum being asked about

Lattice / Grid Pattern from Small Cases

41 problems Grade 6

The literal scale of the problem (thousands by thousands grid, etc.) makes brute enumeration impossible, but the underlying rule is local. Solve the smallest cases by hand on graph paper, look for a pattern (often involving gcd, lcm, or a sum of dimensions), and generalize to the stated size.

Member problems

Exemplar problems

Transformable parameters

delta_x Range: any positive integer; keep gcd small for cleanness

Horizontal extent of the segment / grid region

delta_y Range: any positive integer; keep gcd small for cleanness

Vertical extent of the segment / grid region

gcd_value Range: 1 to 100

GCD of (delta_x, delta_y) — controls how many lattice corners the segment hits

scale_factor Range: 100 to 10000

Multiplier applied to the small base case to reach the contest scale

Variant hints

  • Change (delta_x, delta_y) from (3000, 5000) to (4000, 6000) — gcd shifts from 1000 to 2000, formula stays the same
  • Apply the same dx + dy - gcd pattern to a 'cubes pierced by a diagonal in 3D' variant for harder problems
  • Phrase as a 'rectangle cut by a diagonal' problem instead of a segment on graph paper
Caveats for variants (3)
  • Pattern must be derivable from at most 4-5 small hand-drawn cases
  • Result must round / equal exactly one A-E choice
  • Avoid (delta_x, delta_y) with very large gcd that obscures the pattern

Pair-Sum Invariant

34 problems Grade 4 –7

Partition a universe into forced complementary pairs (or up/down segment pairs) so that any legal configuration has a fixed total. Key move: re-pair the items so the constraint becomes a closure/balance argument, reducing optimization or computation to invariant arithmetic.

Member problems

Exemplar problems

Transformable parameters

pair_structure Range: complementary-shift | perimeter-up-down | mirror-symmetry

How items are forced into pairs — complementary-value pairs (a, a+k), up/down perimeter segments, or symmetric mirror pairs

universe_size Range: 6 to 30

Total number of pair-eligible items in the universe (controls arithmetic load, not strategy)

target_invariant Range: sum | area | count | length

What stays constant across all legal configurations (sum, area, count, length)

surface_context Range: abstract-numbers | rectilinear-polygon | colored-tokens

Wrapping context (number sets with distance constraints, rectilinear polygons, balanced selections)

Variant hints

  • Replace the 1-10 / 11-20 sets with 1-12 / 13-24 (shift by 12) — pair-sum changes but the closure argument is identical
  • Build a new rectilinear-polygon closure problem where one vertical side X is unknown and the up-segs = down-segs equation pins it
  • Pair-with-target-sum partition: choose k items from {1..2n} such that no two sum to 2n+1; total is forced
  • Alternate-color balancing on a small graph (each edge has one black + one white endpoint) → counts of black, white are forced
Caveats for variants (4)
  • Ensure the forced pairs actually exist and partition the universe cleanly — if items are unpaired the invariant collapses
  • Verify the invariant is genuinely closed under every legal move (test 2-3 configurations by hand before publishing)
  • Don't conflate with a simple summation problem; the diagnostic feature is that re-pairing exposes the constraint, not raw addition
  • Answer should be unique and land on a single A-E choice; near-misses by ±k often appear when pair-shift k is misread

Meeting Time with Piecewise Rates

29 problems Grade 5 –7

Two or more travelers move along a shared route with piecewise-constant speeds (or with discrete schedules like stops and waits). Find when or where they meet, board, pass, or are at the same position. The decisive move is identifying the segments where each traveler's rate is constant and using "closing-speed × time = gap" or a side-by-side schedule table rather than a single algebraic equation.

Member problems

Exemplar problems

Transformable parameters

traveler_count Range: 2

Number of moving entities (typically 2)

rate_segments Range: 1 to 4 per traveler

How many constant-rate segments each traveler has

schedule_style Range: continuous | discrete | mixed

Continuous-rate (e.g. mph) or discrete (e.g. one stop every N minutes)

target Range: meet-time | meet-position | catch-which | time-saved

What is asked: meeting time, meeting location, time gap on arrival, or which bus they catch

Variant hints

  • Swap one traveler's continuous-rate leg for a 'stops every N min' discrete schedule — the simulation table cleanly handles both
  • Introduce a midpoint speed change (e.g. faster on the return trip) to force two-segment reasoning per traveler
  • For an easier Gr5 variant use integer-only meeting times; reserve fractional/decimal meet points for Gr6+ variants
Caveats for variants (3)
  • Verify the meet point falls within the shared route (no traveler overshoots before they meet)
  • Side-by-side schedule table should fit in ≤ 8 rows for the target grade — longer tables need a pattern shortcut
  • Avoid framings that require solving a continuous inequality across multiple segments (that pushes the grade above 7)

Units-Digit Tracking

15 problems Grade 4

Determine the last digit of a multi-digit arithmetic expression by tracking only the units digit through additions and subtractions. Exploits that the ones column is closed under mod 10, so the bulk of the digits can be ignored.

Member problems

Exemplar problems

Transformable parameters

digit_count Range: 3 to 8

Maximum number of digits in any operand (controls how scary the expression looks without changing the strategy)

repeated_digit Range: 1 to 9

The digit that is repeated to build each operand (e.g. 2 in 222222)

operation_mix Range: subtraction | addition | mixed

Whether the expression is pure subtraction, pure addition, or mixed

term_count Range: 3 to 8

Number of operands in the expression

Variant hints

  • Swap repeated_digit from 2 to 7 — units digit pattern shifts but strategy is identical
  • Mix in one addition among the subtractions to force students to track sign carefully
  • For an easier Grade-3 variant use addition only with 3-digit operands
Caveats for variants (3)
  • Answer must be a single digit 0-9 to fit a clean A-E choice set
  • Ensure none of the wrong choices accidentally becomes a valid units digit under a sub-step misread
  • When mixing operations, verify no intermediate borrow propagates from a higher column into the ones (it cannot for pure addition; for mixed, double-check)

Solid Volume by Decomposition

14 problems Grade 5 –8

The volume of a three-dimensional region is found by expressing it as a sum, difference, or fixed fraction of primitive solids — prisms, cylinders, spheres, pyramids, cones, or tetrahedra — whose dimensions are read off the configuration. The 3D analog of compound-area decomposition: the work is choosing the split, not any single volume formula. Often a total volume is given and a length is back-solved.

Member problems

Exemplar problems

Transformable parameters

primitive_solids Range: prism | cylinder+hemispheres | box+tetrahedra | cone | mixed

Which primitive solids the target region decomposes into (prism, cylinder, hemisphere, pyramid, cone, tetrahedron)

decomposition_mode Range: sum | difference | fixed-fraction-of-whole

How the pieces combine to give the target volume

target_quantity Range: volume | back-solved-length

What is solved for — the volume itself, or a length back-solved from a given volume

dimension_set Range: small integers (keep arithmetic and any pi cancellation clean)

The given radii, edge lengths, and heights used in the configuration

Variant hints

  • Swap the bounding primitive from a box to a cylinder — the wedge / fraction argument is structurally identical
  • Give the total volume and ask for a missing length (back-solve) instead of asking for the volume directly
  • Change decomposition_mode from fraction-of-whole to sum-of-primitives (e.g. a capsule = cylinder + two hemispheres)
Caveats for variants (3)
  • Verify the decomposition actually partitions (or cleanly subtracts from) the target with no double-counted overlap
  • If pi appears, arrange the numbers so it cancels or the answer stays a clean multiple of pi
  • Keep the 3D configuration unambiguous from the figure or text — readers must see which pieces are included

Geometric Probability by Area

12 problems Grade 6 –8

In a continuous uniform sample space a probability equals the measure of the favorable region divided by the measure of the whole — for planar problems, the favorable area over the total area. The decisive move is translating the stated condition (a comparison, a triangle inequality, an obtuse-angle test) into a planar region bounded by lines and circular arcs, then computing its area as a triangle, a rectangle fraction, or a circular sector plus or minus a triangle.

Member problems

Exemplar problems

Transformable parameters

sample_space Range: single interval | unit square | general rectangle | planar region

The continuous space the outcomes are drawn from

favorable_boundary Range: lines only | circular arcs | mixed lines-and-arcs

What bounds the favorable region whose area is measured

condition_type Range: comparison | triangle-inequality | obtuse-or-right test | distance threshold

The geometric condition that is translated into the favorable region

area_method Range: triangle | rectangle-fraction | sector-plus-or-minus-triangle

How the favorable area is ultimately computed

Variant hints

  • Keep the unit-square setup but change the condition from y > x (a triangle, P = 3/4) to an arc boundary to force a sector computation
  • Scale the two intervals to different lengths so the sample space is a rectangle rather than a square
  • Replace a line-bounded favorable region with one bounded by a circular arc to push the difficulty up a grade
Caveats for variants (3)
  • Confirm the draws are genuinely uniform and independent so that probability really equals the area ratio
  • When arcs are involved, verify the sector and triangle pieces are correctly added or subtracted (sign errors are the common failure)
  • Ensure the final probability reduces to exactly one clean answer choice

Grid Tiling / Packing with Divisibility

11 problems Grade 4

A geometric region must be covered or partitioned by pieces subject to area / divisibility constraints. The decisive observation is usually arithmetic: total area mod tile-area gives the minimum waste, or the constrained items must fit inside a small bounding rectangle.

Member problems

Exemplar problems

Transformable parameters

grid_dimensions Range: 3x7 to 10x10

Width × height of the region to be covered or filled

tile_set Range: any combination of 1x1, 2x2, 1x4, L-tromino, etc.

Which tile shapes (or markers) are allowed

divisor_d Range: 2 to 6

The divisibility constant that controls the packing arithmetic (e.g. mod 4 for 4-area tiles, mod 3 for problem 16)

optimization_goal Range: minimize | maximize

Minimize a count (1x1 tiles, contaminated rows+cols) or maximize coverage

Variant hints

  • Change grid_dimensions to 4x9 and reuse the same tile set — the mod-4 leftover shifts to a different value
  • Replace 1x4 with 1x3 tiles to change divisor_d from 4 to 3
  • For an extremal-configuration variant, ask for the MAXIMUM number of clean rows/cols instead of minimum
Caveats for variants (2)
  • The trivial area lower bound must actually be achievable — exhibit a concrete tiling or packing
  • Beware of parity / coloring obstructions (e.g. checkerboard arguments) that may rule out a numerically possible packing

Paper Fold-and-Cut Symmetry

9 problems Grade 3 –5

A square (or other shape) is folded one or more times, a piece is cut out of the folded stack, and the unfolded result must be predicted. The underlying mechanic is that each fold creates a reflection axis, so the cut is reflected back across every fold line on unfold. Solving without physically folding requires mentally composing reflections about each fold axis.

Member problems

Exemplar problems

Transformable parameters

fold_count Range: 1 to 3

Number of folds applied before cutting (each fold doubles the symmetry)

fold_type Range: half | quarter | diagonal

Whether folds are along straight edges (half) or diagonals (quarter / triangle)

cut_shape Range: corner-triangle | edge-notch | interior-shape

Shape of the cut piece relative to the folded stack

cut_location Range: corner | edge | interior

Where on the folded stack the cut is made

Variant hints

  • Fold once vs twice — single fold gives mirror image, double fold gives 4-fold symmetry
  • Move a triangular cut from a corner to an edge — answer changes from rhombus to bow-tie
  • Use a fold diagonal to introduce 45° rotation into the reflected shape
Caveats for variants (3)
  • Answer must be one of the 5 distinct unfolded patterns — verify no two A-E choices are congruent
  • Distractors should be near-misses (e.g. correct shape but rotated 90°)
  • Keep fold count ≤ 3 so the mental composition stays tractable for the target grade

Path Length Comparison & Shortest Path

9 problems Grade 2

Compare or minimize total length over a finite collection of routes. The routes may be drawn on a figure (visual comparison: straight vs curved vs zigzag) or described as a small weighted graph (numerical shortest path). The structural move is the same: identify the candidate routes, compute or compare their lengths.

Member problems

Exemplar problems

Transformable parameters

route_count Range: 3 to 8

Number of paths to compare or routes through the graph

edge_count Range: 5 to 15

Number of segments / arrows in the figure or graph

comparison_mode Range: visual | numerical | mixed

Purely visual (no numbers) vs numerical (weights given)

surface_context Range: free-form

Wrapping context (ice rink, road map, hiking trails, school halls)

Variant hints

  • Replace one curved segment with a zigzag of the same endpoints to keep the visual ordering intact while changing the look
  • Add a single edge to the graph that opens a tempting longer route, so students must check more options
  • For a numerical variant, choose edge weights so the optimum is unique and not on an obvious 'all small numbers' path
Caveats for variants (2)
  • For visual variants, ensure the figure is unambiguous — students should not need numerical measurement
  • For graph variants, verify the shortest distance matches exactly one A-E choice

Net Folding / Face Adjacency

5 problems Grade 4 –7

Given a 2D net of a polyhedron (typically cube, tetrahedron, or octahedron) with labels or markings on the faces, determine which faces are adjacent (share an edge) or opposite once the net is folded into 3D. The decisive move is tracking which net edges glue together during folding, often by rotating around a single fold axis at a time.

Member problems

Exemplar problems

Transformable parameters

polyhedron Range: cube | tetrahedron | octahedron

Which polyhedron the net folds into

net_shape Range: cross | T-shape | staircase | strip

Layout of the unfolded net (which arrangement of faces)

target_relation Range: adjacent-to-X | opposite-to-X | shares-edge-with-X

What relation between labelled faces the problem asks about

marking_style Range: free-form

How faces are labelled (numbers, letters, colors, dot patterns)

Variant hints

  • Swap cube for octahedron — face count doubles, but the edge-gluing argument is structurally identical
  • Move the cut/fold sequence so a different face becomes the 'anchor' that stays still
  • Replace 'which face is adjacent to Q?' with 'which face is opposite to Q?' to flip the target relation
Caveats for variants (3)
  • Answer must be uniquely determined by the net (no ambiguity in which way you fold)
  • Distractors should be faces that are adjacent in 2D but NOT adjacent after folding (and vice versa)
  • Keep the net to a single connected piece — disconnected nets are not standard at AMC 8 level

Geometric Series Share

4 problems Grade 5 –7

A self-similar process repeats at a fixed multiplicative ratio: each cycle (or each iteration) shrinks the remaining quantity — share, area, length, count — by the same factor r with |r| < 1. The target quantity is a participant's cumulative share, the total shaded region, or the limiting sum of all stages. Key move: identify the first relevant term a and the per-cycle ratio r, then apply S = a/(1-r) for an unbounded process or S_n = a(1-r^n)/(1-r) for n stages. Often the answer reduces to a clean closed form (e.g. 4/7 of the whole) because the ratio is rational.

Member problems

Exemplar problems

Transformable parameters

common_ratio Range: 1/2 | 1/3 | 1/4 | 1/8

Per-cycle shrink factor r (controls how fast the series converges and the final closed form)

number_of_participants Range: 2 to 4

How many actors share the resource each cycle (drives where a particular actor lands in the cycle)

stage_count Range: finite n (5-100) | unbounded

How many iterations the process runs — finite n vs. unbounded ('until too small')

surface_context Range: sharing-resource | nested-similar-figures | repeated-bisection

Wrapping context that motivates the recurrence (food-sharing, nested-figure area, repeated halving, fading echoes)

target_participant Range: first | last | aggregate

Which participant's cumulative share is asked (first, last, or aggregate)

Variant hints

  • Replace 3 sharers (Sarika-Dev-Rajiv) with 4 sharers — first sharer's series becomes 1/2 + 1/32 + ... with r = 1/16
  • Change ratio from 1/2 (halving) to 1/3 (third-removal) — first-sharer share drops from 4/7 to 9/26
  • Nest squares instead of triangles, with each inscribed square at 1/2 the side — area ratio becomes 1/2 instead of 1/4
  • Ask for total area of the UNSHADED region (1 - geometric sum) to flip the answer
Caveats for variants (4)
  • Make sure the ratio r is the cycle ratio (across one full rotation of participants), not the within-cycle slice ratio
  • If the stage count is finite, you can still approximate by the infinite sum when r^n is tiny — say so in the prompt
  • Answer should be a clean rational; pick a/(1-r) that lands on a single A-E choice
  • Distractors should look like adjacent answers from a different participant in the cycle (e.g. Dev's share if asked for Sarika's)

Constraint Graph Coloring

3 problems Grade 5 –8

Vertices (pods, children, slots) are assigned distinct labels from a small finite set so that every connected/related pair satisfies a pairwise constraint — labels differ by at least k, labels match on at least one attribute, or labels are forbidden to clash. Key move: rank vertices by degree (or by number of incident constraints) and force the most constrained vertices first; high-degree vertices are pinned to extreme labels because their neighbors must fit in a shrunken pool. Then propagate by elimination and check the residual assignment against the remaining constraints.

Member problems

Exemplar problems

Transformable parameters

label_pool Range: {1..7} | {A,B} | trait-combos

Set of labels assigned to vertices ({1..n} integers, {A,B} families, two-attribute combinations)

pairwise_constraint Range: diff ≥ k | share ≥ 1 attribute | distinct

What must hold between connected vertices (label difference threshold, shared-attribute requirement, forbidden clash)

graph_size Range: 4 to 10 vertices, 4 to 15 edges

Number of vertices and number of edges (controls how much elimination is needed)

degree_asymmetry Range: uniform | hub-and-spoke | star

How concentrated the high-degree vertices are (uniform degree vs. two hub vertices vs. star)

Variant hints

  • Replace diff ≥ 2 with diff ≥ 3 on the same pod graph — fewer valid assignments, hubs get more extreme
  • Swap the trait table: change which attributes overlap to flip which pair is forced as siblings
  • Add or remove one edge to make the same target vertex either over- or under-constrained
  • Frame as 'assign colors to map regions so adjacent regions are at least 2 hues apart' for a geography wrapper
Caveats for variants (4)
  • High-degree vertices must remain genuinely forced — if more than one extreme label survives elimination, the puzzle is ambiguous
  • Verify uniqueness of the asked quantity even when intermediate assignments have multiple solutions (case symmetry)
  • Don't oversize the label pool relative to vertex count — leftover labels create distractor solutions
  • Pigeonhole-style constraint arguments (n labels, n+1 forbidden positions) are the cleanest deductions; favor those