← Sensim Lab Sensim Math

Problem Archetypes

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

Arithmetic Expression Decomposition

291 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

Compound Area by Decomposition / Difference

108 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

48 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

43 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

42 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

38 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

Coordinate Plane Figure Computation

26 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)

Lattice / Grid Pattern from Small Cases

20 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

Modular Cycle Frequency Count

18 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

Pair-Sum Invariant

13 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

11 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)

Grid Tiling / Packing with Divisibility

7 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

Units-Digit Tracking

7 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)

Path Length Comparison & Shortest Path

6 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

Paper Fold-and-Cut Symmetry

5 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

Net Folding / Face Adjacency

4 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