Addition Puzzles

How Addition Puzzles Actually Work (and How to Solve Them Yourself)

Addition Puzzles are a class of mathematical logic puzzles where you're given an addition problem with some digits missing, and your job is to fill in the blanks so the equation balances. They look deceptively simple when you first see one, but they test something very specific about how you handle constraints. Most people treat them as party tricks. That's not wrong, but it undersells what's actually happening under the hood.

The basic form goes like this: you get two or three numbers stacked vertically, some digits are shown, others are hidden, and you have to deduce the missing values. Classic example — a puzzle might show:    A 7  
 +  3 B  
-------  
 C D  E Where A through E are unknown digits. The puzzle is solvable only when there's enough constraint information baked in. A well-constructed Addition Puzzle will have exactly one solution. A poorly constructed one either has multiple answers or is broken entirely.

Starting With Addition Puzzles: The Column Method

The standard approach is to work column by column, right to left — same as you'd do long addition by hand. Start with the ones place, figure out what must be true there, then carry whatever constraint over to the tens place, and so on. This isn't theoretical. I've spent more hours than I want to admit staring at grids of numbers trying to see what column constraints force the next one. Here's a concrete example. Consider this puzzle:    5  A  3  
 +  B  7  C  
-----------  
 8  D  9

Working right to left: the ones column is 3 + C = something ending in 9. That means C must be 6 (since 3 + 6 = 9, no carry). Now move to the tens column: A + 7 = D, possibly with a carry from the ones. Since there's no carry from the ones (3 + 6 = 9 exactly), A + 7 must end in D. The hundreds column is 5 + B = 8, which means B = 3. Now check: B = 3, and we already have 3 in the top number's ones place. Unless the puzzle allows repeated digits, this is a problem. That's actually the most common trap people hit with these puzzles — assuming digits must be unique when the rules don't say that, or assuming they must be unique when they actually should be. The fix is simple: before you start solving, confirm whether digit repetition is allowed. If the puzzle doesn't explicitly state "each letter represents a unique digit," assume repetition is fine. Most casual Addition Puzzles online don't enforce uniqueness. Only formal cryptarithms do, and those follow different solving conventions entirely.

The Carry Trap

Here's where people mess up consistently. The carry from one column to the next is not just a number you write down. It's a constraint that changes the possible values in every subsequent column. A carry of 1 from the ones column means the tens column equation isn't just A + B = C. It's A + B + 1 = C or A + B + 1 = 10 + C. That second case creates a new carry into the hundreds column, which cascades further. Beginners often forget to account for the carry-in when checking their work, which means they solve correctly but then mark their answer wrong because they're verifying against the wrong equation. I ran into this exact issue on a puzzle once that had four columns and a hidden carry chain. I solved it three times, got three different answers, and kept discarding them all because my verification step ignored the carry from column two into column three. The workaround was writing out every possible carry state explicitly on paper before touching any digit — a simple table mapping "column 1 possible carries: 0 or 1" and "column 2 depends on column 1 carry." It added five minutes to the setup but cut the total solve time from about 25 minutes down to roughly 8.

Advanced Nuance: Constraint Propagation

Beyond the column method, there's a technique that works better for harder puzzles called constraint propagation. Instead of chasing carries, you list every digit (0-9) as a candidate for each blank, then eliminate impossibilities based on what you already know. If you determine that A can only be 1, 4, or 7, you write that down. Then when you look at a neighbor cell that shares a constraint with A, you cross off 1, 4, and 7 from that cell's candidates. This is essentially the same logic Sudoku solvers use, and it scales well when puzzles get to six or seven unknowns. The counter-intuitive part most guides miss: sometimes the hardest column to solve is the leftmost one, not the rightmost. In a three-digit plus three-digit puzzle where the result is a four-digit number, the thousands digit must be 1 (since the maximum sum of two three-digit numbers is 1998). That's an immediate anchor point that most solvers skip over because they're too focused on working right to left. Locking that digit first can collapse half the problem.

When Addition Puzzles Fall Apart

Not every puzzle labeled as an Addition Puzzle is actually solvable. Ambiguous puzzles are surprisingly common on puzzle websites — usually because the creator generated them randomly without checking for uniqueness of solution. You'll know you've hit one when you reach a point where two different digits for the same blank both seem to satisfy all constraints. In that case, the puzzle itself is flawed, not your logic. The only way to verify is to systematically enumerate all valid completions. There's no shortcut around that. For large puzzles with many variables, manual solving becomes impractical after about eight unknowns. The constraint propagation method still works but the candidate lists get unwieldy fast. At that point, writing a small backtracking solver in Python takes about twenty minutes and will solve any well-formed Addition Puzzle in under a second. I keep a basic template on hand for this — it's not glamorous, but it's the difference between spending an evening on a puzzle and spending ten minutes on it.

Adding More Challenges to Addition Puzzles

Some variants add extra constraints that change the solving dynamic entirely. Multi-digit carries across multiple layers — where you're adding four or five numbers instead of two — introduce carry values up to 4 in a single column instead of just 0 or 1. That dramatically increases the branching factor at each step. Cross-number puzzles where the same digit appears in multiple positions across different rows but isn't marked with the same letter are another common variant. These require you to track identity constraints separately from value constraints, which is a skill most people never develop because they only encounter the simpler version. The core skill underlying all of this is the ability to hold multiple conditional possibilities in your head at once. "If the carry is zero, then X must be Y. If the carry is one, then X could be A or B." That's it. Nothing mystical about it. Just disciplined tracking of what you know and what you don't.