How Often Does Minesweeper Force You to Guess?
By Lucian — builder & engineer, LK Forge
Minesweeper looks like a pure logic game, and on the small board it nearly is. But feed the exact solver our game ships tens of thousands of boards and a different picture appears: on Expert, only 3.9% of boards can be cleared by logic alone. The other 96% force at least one guess — and even a solver that always clicks the safest cell wins just 34.9% of Expert games. Here is where logic ends and luck begins, measured.
· 6 min read · every number from a re-runnable headless benchmark
How we measured it
The solver under test is the one the Minesweeper game actually runs — a constraint solver that combines the single-cell rules (a satisfied number, an exact number), the subset rule that resolves 1-1 and 1-2-1 patterns, and, when no proof exists, an exact per-cell mine probability computed by enumerating every mine layout consistent with the visible numbers. We pulled it out of the production file and drove it headlessly, with no browser and no human.
Two things get measured. The no-guess rate asks: given a safe first click, can this exact board be cleared start to finish using deduction only, never guessing? That is a property of the board, so we sampled 20,000 Beginner, 8,000 Intermediate and 4,000 Expert layouts. The win rate asks how a real player does: the solver deduces every forced safe and mine cell, and when it is stuck it clicks the single hidden cell with the lowest mine probability, then continues — exactly the logic behind the game’s hint button. We played 5,000 Beginner, 3,000 Intermediate and 2,000 Expert games to a win or a loss.
Board layouts come from a seeded generator so the whole run is re-runnable, and the first click always opens into empty space, matching the game’s own first-click guarantee. A death can only ever happen on a guess: the solver never dies to a cell it deduced was safe. Re-running under a different seed reproduced every headline figure within about 1.5 percentage points.
Solvable with no guessing vs solver win rate, by difficulty. The logic-only share falls off a cliff — 80.6% to 3.9% — far faster than the win rate, because guessing well rescues most of the boards logic cannot finish.
Where logic runs out
The gap between the two bars is the story. On Beginner they nearly touch: 80.6% of boards need no guess and 96.1% are won, so the game really is mostly logic and the wins the solver adds by guessing are a thin top slice. On Expert the bars split wide apart — 3.9% against 34.9% — which means almost every Expert win is a won gamble, a board that logic alone could never have finished but good guessing carried through.
Why the cliff? Mine density. Beginner packs 12.3% of the grid with mines, Expert 20.6%. Denser boards produce more spots where the surrounding numbers are consistent with a mine being in either of two places — the classic 50/50 — and no amount of deduction resolves them. The solver is not weak here; it is running into a wall built into the board.
How many guesses a game forces
Win rate follows directly from how many times a board makes you gamble. Each forced guess is an independent chance to hit a mine, so wins decay roughly geometrically as guesses pile up. Beginner averages about a quarter of a guess per game; Expert averages nearly four.
Mean forced guesses per game. The jump from 0.89 to 3.83 between Intermediate and Expert is exactly why the Expert win rate falls to a third: four coin-flips are hard to survive even when each is the best coin-flip available.
Every number
| Difficulty | Grid | Mines | Density | No-guess | Win rate | Guesses/game | Won w/o guessing |
|---|---|---|---|---|---|---|---|
| Beginner | 9 × 9 | 10 | 12.3% | 80.6% | 96.1% | 0.26 | 83.9% |
| Intermediate | 16 × 16 | 40 | 15.6% | 53.2% | 85% | 0.89 | 63% |
| Expert | 30 × 16 | 99 | 20.6% | 3.9% | 34.9% | 3.83 | 11.5% |
Measured 10 September 2026 on one laptop. No-guess rates: 20,000 / 8,000 / 4,000 boards. Win rates: 5,000 / 3,000 / 2,000 games. “Won without guessing” is the share of the solver’s wins that needed no guess at all — 83.9% on Beginner, only 11.5% on Expert.
What this means when you play
If you lose an Expert board on what felt like a coin-flip, the data says you probably did nothing wrong: 96% of Expert boards reach a spot with no safe cell, and losing there is baked into the difficulty. The skill that separates players is not avoiding guesses — it is postponing them (clearing every forced cell first, so a guess exposes the most new information) and, when a guess is unavoidable, picking the lowest-probability cell rather than a convenient one. That is precisely what the solver does, and it is why it reaches 35% rather than the ~15% a careless guesser would.
It also explains why no-guess mode exists. Because only 3.9% of random Expert boards are logically solvable, a mode that guarantees a deduction-only board has to generate and solver-verify layouts until it finds one — the vast majority of random Expert boards are thrown away. The rarity we measured here is exactly the work that mode is doing behind the scenes.
Reproduce it yourself
The whole benchmark is two functions over the shipped engine. isNoGuess tests whether a board is deduction-only; analyze returns the forced safe/mine cells or, when stuck, each cell’s mine probability. Self-play is: deduce everything, else click the minimum-probability cell.
import { mulberry32, newGame, firstReveal, reveal, toggleFlag,
analyze, isNoGuess, randomLayout } from './engine.mjs';
// Expert: 30x16, 99 mines. Start from the centre (opens empty).
const w = 30, h = 16, mines = 99, start = 8 * w + 15;
const rng = mulberry32(12345);
// 1) Is a random board solvable with no guessing?
let solvable = 0, N = 4000;
for (let i = 0; i < N; i++) {
const layout = randomLayout(w, h, mines, start, rng);
if (isNoGuess(w, h, mines, layout, start)) solvable++;
}
console.log((100 * solvable / N).toFixed(1) + '% no-guess'); // ~3.9%
// 2) Full self-play win rate (deduce, else click lowest probability).
function play() {
const s = newGame(w, h, mines);
firstReveal(s, start, rng);
while (!s.won && !s.dead) {
const a = analyze(s);
let moved = false;
for (const m of a.mines) if (s.grid[m.idx].state === 'hidden') { toggleFlag(s, m.idx); moved = true; }
for (const f of a.safe) if (s.grid[f.idx].state === 'hidden') { reveal(s, f.idx); moved = true; }
if (s.won || s.dead || moved) continue;
let best = -1, p = Infinity;
for (const [idx, q] of a.probs) if (s.grid[idx].state === 'hidden' && q < p) { p = q; best = idx; }
reveal(s, best);
}
return s.won;
}
let wins = 0; for (let i = 0; i < 2000; i++) if (play()) wins++;
console.log((100 * wins / 2000).toFixed(1) + '% win'); // ~35%The engine module is public: download engine.mjs next to the script above and it runs unmodified in Node. It is the exact solver the Minesweeper game runs live — its explained hints and no-guess generator are this same code.
Play with the solver
Ask the Minesweeper AI for a hint and it shows you the deduction — or switch on no-guess mode and never hit a coin-flip again.