@johnmorrisdotca/kazu 1.2.0 → 1.3.0

package/dist/kakuroBuild.js

@@ -0,0 +1,337 @@
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { countCsp, logicCsp, openSlots } from "./csp.js";
+import { shuffled } from "./random.js";
+/** How the black squares are scattered, and the longest run a level allows. */
+export const SHAPE = {
+    easy: { black: .34, longest: 4 },
+    medium: { black: .3, longest: 5 },
+    hard: { black: .26, longest: 7 },
+    "extra-hard": { black: .22, longest: 9 },
+};
+/** Which squares are white: no run shorter than two, none longer than the level allows, and all of them one connected piece. */
+export function kakuroPattern(side, level, random) {
+    for (let attempt = 0; attempt < 60; attempt += 1) {
+        const white = laidRows(side, level, random);
+        if (white && oneStrip(side, white))
+            return white;
+    }
+    return null;
+}
+/**
+ * Lays the squares out row by row, each row left to right, so that a run is never one square or longer than the
+ * level allows: a column whose run is one square long must go on, one at the limit must stop, and a row's own
+ * runs are kept the same way. A square is white with the level's chance, except where a rule forces it.
+ */
+function laidRows(side, level, random) {
+    const { black, longest } = SHAPE[level];
+    const white = Array(side * side).fill(false), above = Array(side).fill(0);
+    const chance = 1 - black * (.85 + random() * .3);
+    for (let row = 1; row < side; row += 1) {
+        const last = row === side - 1, chosen = Array(side).fill(false);
+        let steps = 0;
+        const place = (col, run) => {
+            if (++steps > 4000)
+                return false;
+            if (col === side)
+                return run !== 1;
+            const mustWhite = above[col] === 1;
+            const mustBlack = above[col] === longest || last && above[col] === 0;
+            const options = [];
+            if (mustWhite && mustBlack)
+                return false;
+            if (mustWhite)
+                options.push(true);
+            else if (mustBlack)
+                options.push(false);
+            else
+                options.push(...(random() < chance ? [true, false] : [false, true]));
+            for (const isWhite of options) {
+                if (isWhite && run + 1 > longest)
+                    continue;
+                if (!isWhite && run === 1)
+                    continue;
+                chosen[col] = isWhite;
+                if (place(col + 1, isWhite ? run + 1 : 0))
+                    return true;
+            }
+            return false;
+        };
+        if (!place(1, 0))
+            return null;
+        for (let col = 1; col < side; col += 1) {
+            white[row * side + col] = chosen[col];
+            above[col] = chosen[col] ? above[col] + 1 : 0;
+        }
+    }
+    return white;
+}
+/** How many different sets of digits can make `sum` out of `length` squares. */
+export function kakuroWays(length, sum) {
+    let ways = 0;
+    for (let mask = 1; mask < 512; mask += 1) {
+        let n = 0, total = 0;
+        for (let d = 1; d <= 9; d += 1)
+            if (mask & 1 << d - 1) {
+                n += 1;
+                total += d;
+            }
+        if (n === length && total === sum)
+            ways += 1;
+    }
+    return ways;
+}
+const WAYS = Array.from({ length: 10 }, (_, length) => Array.from({ length: 46 }, (_, sum) => length < 2 ? 0 : kakuroWays(length, sum)));
+/** A random digit for every white square with no digit repeated in a run, or null when the search gives up. */
+export function kakuroDigits(side, white, random) {
+    const digits = Array(white.length).fill(0);
+    let steps = 0;
+    const fill = (at) => {
+        while (at < white.length && !white[at])
+            at += 1;
+        if (at === white.length)
+            return true;
+        if (++steps > 40000)
+            return false;
+        const used = new Set();
+        for (let left = at - 1; left >= 0 && white[left] && (left + 1) % side !== 0; left -= 1)
+            used.add(digits[left]);
+        for (let up = at - side; up >= 0 && white[up]; up -= side)
+            used.add(digits[up]);
+        for (const digit of shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d)), random)) {
+            digits[at] = digit;
+            if (fill(at + 1))
+                return true;
+        }
+        digits[at] = 0;
+        return false;
+    };
+    return fill(0) ? digits : null;
+}
+/**
+ * Changes digits one square at a time, keeping every run free of repeats, to make runs whose totals can be made in
+ * few ways: a run that says a lot about its digits lets the solver start from the rules alone. A change is kept when
+ * it does not raise the count of ways, summed over runs, which is `weight` raised to the number of ways.
+ */
+export function kakuroTighten(side, white, digits, random, rounds) {
+    const runsAt = (cell) => {
+        const across = [cell], down = [cell];
+        for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+            across.push(at);
+        for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+            across.push(at);
+        for (let at = cell - side; at >= 0 && white[at]; at -= side)
+            down.push(at);
+        for (let at = cell + side; at < white.length && white[at]; at += side)
+            down.push(at);
+        return { across, down };
+    };
+    const ways = (run, swap) => {
+        let sum = 0;
+        for (const at of run)
+            sum += swap && at === swap.cell ? swap.digit : digits[at];
+        return WAYS[run.length][sum];
+    };
+    const cells = white.flatMap((w, i) => w ? [i] : []);
+    for (let round = 0; round < rounds; round += 1) {
+        const cell = cells[Math.floor(random() * cells.length)];
+        const { across, down } = runsAt(cell);
+        const used = new Set();
+        for (const at of [...across, ...down])
+            if (at !== cell)
+                used.add(digits[at]);
+        const options = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d) && d !== digits[cell]);
+        if (!options.length)
+            continue;
+        const digit = options[Math.floor(random() * options.length)];
+        const before = ways(across) + ways(down), after = ways(across, { cell, digit }) + ways(down, { cell, digit });
+        if (after <= before)
+            digits[cell] = digit;
+    }
+}
+/** The totals of a pattern and its digits, as a board. */
+export function kakuroBoardOf(side, white, digits) {
+    const cells = white.map(w => w ? { kind: "white" } : { kind: "black", across: null, down: null });
+    for (let cell = 0; cell < white.length; cell += 1) {
+        if (white[cell])
+            continue;
+        const black = cells[cell];
+        if (cell % side < side - 1 && white[cell + 1]) {
+            let sum = 0;
+            for (let at = cell + 1; white[at]; at += 1) {
+                sum += digits[at];
+                if ((at + 1) % side === 0)
+                    break;
+            }
+            black.across = sum;
+        }
+        if (cell + side < white.length && white[cell + side]) {
+            let sum = 0;
+            for (let at = cell + side; at < white.length && white[at]; at += side)
+                sum += digits[at];
+            black.down = sum;
+        }
+    }
+    return { width: side, height: side, cells };
+}
+/** Whether the white squares are one connected piece. */
+function oneStrip(side, white) {
+    const first = white.indexOf(true);
+    if (first < 0)
+        return false;
+    const seen = new Set([first]), stack = [first];
+    while (stack.length) {
+        const at = stack.pop();
+        for (const next of [at - 1, at + 1, at - side, at + side]) {
+            if (next < 0 || next >= white.length || !white[next] || seen.has(next) || (next === at + 1 && next % side === 0))
+                continue;
+            seen.add(next);
+            stack.push(next);
+        }
+    }
+    return seen.size === white.filter(Boolean).length;
+}
+/** The squares in the same row or column strip as `cell` that have the given digit, to see what digits it may take. */
+function digitsAround(side, white, digits, cell) {
+    const used = new Set();
+    for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+        used.add(digits[at]);
+    for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+        used.add(digits[at]);
+    for (let at = cell - side; at >= 0 && white[at]; at -= side)
+        used.add(digits[at]);
+    for (let at = cell + side; at < white.length && white[at]; at += side)
+        used.add(digits[at]);
+    return used;
+}
+/**
+ * A board with exactly one answer, or null. While the board has other answers, each one is broken: a square the
+ * two answers disagree on is turned black (when every run stays two long and the squares stay one piece) or given
+ * another digit that still repeats nowhere in its runs, which changes two totals.
+ */
+export function candidateKakuro(side, level, random) {
+    // Easy and medium boards are also eased until the rules they promise are enough to solve them.
+    const eased = level === "easy" ? 0 : level === "medium" ? 1 : -1;
+    const white = kakuroPattern(side, level, random);
+    if (!white)
+        return null;
+    const digits = kakuroDigits(side, white, random);
+    if (!digits)
+        return null;
+    if (level === "easy" || level === "medium")
+        kakuroTighten(side, white, digits, random, side * side * (level === "easy" ? 60 : 25));
+    const valid = () => {
+        for (let cell = 0; cell < white.length; cell += 1) {
+            if (!white[cell])
+                continue;
+            let across = 1, down = 1;
+            for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+                across += 1;
+            for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+                across += 1;
+            for (let at = cell - side; at >= 0 && white[at]; at -= side)
+                down += 1;
+            for (let at = cell + side; at < white.length && white[at]; at += side)
+                down += 1;
+            if (across < 2 || down < 2)
+                return false;
+        }
+        return oneStrip(side, white);
+    };
+    for (let repair = 0; repair < 150; repair += 1) {
+        const board = kakuroBoardOf(side, white, digits);
+        if (!isKakuroBoard(board))
+            return null;
+        const model = kakuroModel(board, 1, random);
+        let found = countCsp(model.csp, openSlots(model.csp), 8, 3000);
+        for (let restart = 0; restart < 5 && found.exhausted; restart += 1)
+            found = countCsp(model.csp, openSlots(model.csp), 8, 3000);
+        if (found.exhausted) {
+            // Too many answers to even count: darken any square that can be darkened and look again.
+            const any = shuffled(white.flatMap((w, cell) => w ? [cell] : []), random).find(cell => { white[cell] = false; if (valid())
+                return true; white[cell] = true; return false; });
+            if (any === undefined)
+                return null;
+            continue;
+        }
+        if (found.count === 1 && eased < 0)
+            return { board, digits };
+        if (found.count === 1) {
+            const rules = kakuroModel(board, eased);
+            const run = logicCsp(rules.csp, openSlots(rules.csp), 0);
+            if (run.solved)
+                return { board, digits };
+            if (white.filter(Boolean).length < (side - 1) * (side - 1) * .42)
+                return null;
+            const open = rules.whites.filter((_, i) => { let n = 0; for (let k = 0; k < 9; k += 1)
+                n += run.alive[9 * i + k]; return n > 1; });
+            // Squares still open, then the others that share a run with one.
+            const near = new Set(open);
+            for (const cell of open) {
+                for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+                    near.add(at);
+                for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+                    near.add(at);
+                for (let at = cell - side; at >= 0 && white[at]; at -= side)
+                    near.add(at);
+                for (let at = cell + side; at < white.length && white[at]; at += side)
+                    near.add(at);
+            }
+            const stuck = [...shuffled(open, random), ...shuffled([...near].filter(cell => !open.includes(cell)), random)];
+            let eased_ = false;
+            for (const cell of stuck) {
+                white[cell] = false;
+                if (valid()) {
+                    eased_ = true;
+                    break;
+                }
+                white[cell] = true;
+            }
+            if (!eased_) {
+                const any = shuffled(white.flatMap((w, cell) => w ? [cell] : []), random).find(cell => { white[cell] = false; if (valid())
+                    return true; white[cell] = true; return false; });
+                if (any === undefined)
+                    return null;
+            }
+            continue;
+        }
+        const digitOf = (answer, cell) => { const index = model.index[cell]; let d = 0; for (let k = 0; k < 9; k += 1)
+            if (answer[9 * index + k])
+                d = k + 1; return d; };
+        let moved = false;
+        for (const answer of found.solutions) {
+            const differing = shuffled(white.flatMap((w, cell) => w && digitOf(answer, cell) !== digits[cell] ? [cell] : []), random);
+            if (!differing.length)
+                continue;
+            const blacken = () => {
+                for (const cell of differing) {
+                    if (!white[cell])
+                        continue;
+                    white[cell] = false;
+                    if (valid())
+                        return true;
+                    white[cell] = true;
+                }
+                return false;
+            };
+            const change = () => {
+                for (const cell of differing) {
+                    if (!white[cell])
+                        continue;
+                    const used = digitsAround(side, white, digits, cell);
+                    const options = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d));
+                    if (!options.length)
+                        continue;
+                    digits[cell] = options[Math.floor(random() * options.length)];
+                    return true;
+                }
+                return false;
+            };
+            if (random() < .5 ? blacken() || change() : change() || blacken())
+                moved = true;
+        }
+        if (!moved)
+            return null;
+    }
+    return null;
+}

package/dist/kakuroGenerate.d.ts

@@ -1,3 +1,10 @@
-import type { KakuroPuzzle } from "./kakuro.types.ts";
-/** Makes a seeded 10×10 family of crossing runs and returns only a uniquely proved puzzle. */
-export declare function generateKakuro(seed?: number): KakuroPuzzle;
+import type { KakuroLevel, KakuroPuzzle } from "./kakuro.types.ts";
+/**
+ * Makes a seeded board of `size` squares a side (counting the row and column of totals) and proves it has one
+ * answer. A random pattern of black squares sets the runs, random digits fill them, and digits are changed until
+ * the answer is single. The board is then rated by solving it: easy by the single-run rules, medium once a digit
+ * that must appear has to be traced, hard by supposing, and extra-hard the most-supposing of several boards.
+ * If no board of the level is found within the attempts the next level down is tried, and the first generator
+ * (a 10×10 only) is the last resort, so a seed never throws.
+ */
+export declare function generateKakuro(seed?: number, level?: KakuroLevel, size?: number): KakuroPuzzle;

package/dist/kakuroGenerate.js

@@ -1,130 +1,62 @@
-import { KAKURO_GENERATION_ATTEMPTS, KAKURO_GENERATION_NODES, KAKURO_MAX_ATTEMPTS, KAKURO_MAX_NODES } from "./kakuro.constants.js";
-import { isKakuroBoard } from "./kakuroBoard.js";
+import { KAKURO_LEAST_GENERATED_SIDE, KAKURO_LEVELS, KAKURO_MAX_SIDE } from "./kakuro.constants.js";
+import { checkKakuro } from "./kakuroBoard.js";
+import { candidateKakuro } from "./kakuroBuild.js";
+import { kakuroModel } from "./kakuroLogic.js";
 import { solveKakuro } from "./kakuroSolve.js";
+import { templateKakuro } from "./kakuroTemplate.js";
+import { logicCsp, openSlots } from "./csp.js";
 import { isKazuSeed, seededRandom } from "./random.js";
-/** Makes a seeded 10×10 family of crossing runs and returns only a uniquely proved puzzle. */
-export function generateKakuro(seed = 1) {
-    if (!isKazuSeed(seed))
-        throw new RangeError("Invalid Kakuro seed.");
+const MOST_ATTEMPTS = 400;
+/**
+ * Makes a seeded board of `size` squares a side (counting the row and column of totals) and proves it has one
+ * answer. A random pattern of black squares sets the runs, random digits fill them, and digits are changed until
+ * the answer is single. The board is then rated by solving it: easy by the single-run rules, medium once a digit
+ * that must appear has to be traced, hard by supposing, and extra-hard the most-supposing of several boards.
+ * If no board of the level is found within the attempts the next level down is tried, and the first generator
+ * (a 10×10 only) is the last resort, so a seed never throws.
+ */
+export function generateKakuro(seed = 1, level = "medium", size = 10) {
+    if (!isKazuSeed(seed) || !KAKURO_LEVELS.includes(level) || !Number.isInteger(size)
+        || size < KAKURO_LEAST_GENERATED_SIDE || size > KAKURO_MAX_SIDE)
+        throw new RangeError("Invalid Kakuro settings");
     const random = seededRandom(seed);
-    const budget = { attempts: KAKURO_GENERATION_ATTEMPTS, nodes: KAKURO_GENERATION_NODES };
-    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
-        budget.attempts -= 1;
-        const rowGroups = random() < .5 ? [2, 2, 2] : random() < .5 ? [2, 3] : [3, 2];
-        const columnGroups = rowGroups.length === 3 ? [2, 2, 2] : [2, 3];
-        if (random() < .5)
-            columnGroups.reverse();
-        const rowStarts = groupStarts(rowGroups, random);
-        const columnStarts = groupStarts(columnGroups, random);
-        const cells = Array.from({ length: 100 }, () => ({ kind: "black", across: null, down: null }));
-        const solution = Array(100).fill(0);
-        const board = { width: 10, height: 10, cells };
-        let failed = false;
-        for (const [rowIndex, rowStart] of rowStarts.entries()) {
-            for (const [columnIndex, columnStart] of columnStarts.entries()) {
-                const shape = { height: rowGroups[rowIndex], width: columnGroups[columnIndex] };
-                const local = chooseUniqueTile(shape.width, shape.height, random, budget);
-                if (!local) {
-                    failed = true;
-                    break;
-                }
-                placeTile(board, solution, rowStart, columnStart, local);
-            }
-            if (failed)
-                break;
-        }
-        if (failed)
-            continue;
-        if (!isKakuroBoard(board))
-            throw new Error(JSON.stringify(board));
-        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(KAKURO_MAX_NODES, budget.nodes) });
-        budget.nodes -= Math.min(budget.nodes, proof.nodes);
-        if (proof.complete && proof.count === 1 && proof.solution) {
-            return { ...board, seed, solution: proof.solution };
+    for (let aim = KAKURO_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = KAKURO_LEVELS[aim];
+        const wanted = aimed === "extra-hard" ? 3 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const built = candidateKakuro(size, aimed, random);
+            if (!built)
+                continue;
+            const score = scored(built.board, aimed);
+            if (score === null)
+                continue;
+            found += 1;
+            if (!best || score > best.score)
+                best = { board: built.board, score };
         }
-    }
-    throw new Error("No uniquely solvable Kakuro board was proved within the generation budget.");
-}
-function groupStarts(groups, random) {
-    const used = groups.reduce((sum, size) => sum + size, 0) + groups.length - 1;
-    let at = 1 + (8 - used > 0 && random() < .5 ? 8 - used : 0);
-    return groups.map(size => { const start = at; at += size + 1; return start; });
-}
-function chooseUniqueTile(width, height, random, budget) {
-    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
-        budget.attempts -= 1;
-        const candidate = randomRectangle(width, height, random);
-        if (!candidate)
-            continue;
-        const board = tileBoard(candidate);
-        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(25000, budget.nodes) });
-        budget.nodes -= Math.min(budget.nodes, proof.nodes);
-        if (!budget.nodes)
-            return null;
-        if (proof.complete && proof.count === 1)
-            return proof.solution ? splitSolution(proof.solution, width, height) : candidate;
-    }
-    return null;
-}
-function randomRectangle(width, height, random) {
-    const rows = [];
-    for (let y = 0; y < height; y += 1) {
-        let row = null;
-        for (let attempt = 0; attempt < 100; attempt += 1) {
-            const available = shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9], random);
-            const candidate = available.slice(0, width);
-            if (candidate.every((digit, x) => rows.every(previous => previous[x] !== digit))) {
-                row = candidate;
-                break;
+        if (best) {
+            const proof = solveKakuro(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkKakuro(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
             }
         }
-        if (!row)
-            return null;
-        rows.push(row);
-    }
-    return rows;
-}
-function tileBoard(solution) {
-    const height = solution.length + 1, width = solution[0].length + 1;
-    const cells = Array.from({ length: width * height }, () => ({ kind: "black", across: null, down: null }));
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            cells[(y + 1) * width + x + 1] = { kind: "white" };
-    for (let y = 0; y < solution.length; y += 1)
-        cells[(y + 1) * width].across = solution[y].reduce((sum, value) => sum + value, 0);
-    for (let x = 0; x < solution[0].length; x += 1)
-        cells[x + 1].down = solution.reduce((sum, row) => sum + row[x], 0);
-    return { width, height, cells };
-}
-function placeTile(board, full, top, left, solution) {
-    const width = board.width;
-    const cells = board.cells;
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            full[(top + y) * width + left + x] = solution[y][x];
-    for (let y = 0; y < solution.length; y += 1) {
-        const clue = (top + y) * width + left - 1;
-        cells[clue].across = solution[y].reduce((sum, value) => sum + value, 0);
-    }
-    for (let x = 0; x < solution[0].length; x += 1) {
-        const clue = (top - 1) * width + left + x;
-        cells[clue].down = solution.reduce((sum, row) => sum + row[x], 0);
-    }
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            cells[(top + y) * width + left + x] = { kind: "white" };
-}
-function splitSolution(values, width, height) {
-    const result = [];
-    for (let y = 1; y <= height; y += 1)
-        result.push(values.slice(y * (width + 1) + 1, y * (width + 1) + width + 1));
-    return result;
-}
-function shuffled(items, random) {
-    const result = [...items];
-    for (let i = result.length - 1; i > 0; i -= 1) {
-        const j = Math.floor(random() * (i + 1));
-        [result[i], result[j]] = [result[j], result[i]];
     }
-    return result;
+    if (size === 10)
+        return { ...templateKakuro(seed), level };
+    throw new Error("No uniquely solvable Kakuro board was found within the generation budget; try another seed");
+}
+/** Whether a board suits a level, and how well: higher is harder. */
+function scored(board, level) {
+    const weak = kakuroModel(board, 0), strong = kakuroModel(board, 1);
+    if (logicCsp(weak.csp, openSlots(weak.csp), 0).solved)
+        return level === "easy" ? 0 : null;
+    if (level === "easy")
+        return null;
+    if (logicCsp(strong.csp, openSlots(strong.csp), 0).solved)
+        return level === "medium" ? 0 : null;
+    if (level === "medium")
+        return null;
+    const probing = logicCsp(strong.csp, openSlots(strong.csp), 1);
+    return probing.solved ? probing.probes : level === "extra-hard" ? 1000 : null;
 }

package/dist/kakuroLogic.d.ts

@@ -0,0 +1,13 @@
+import type { Csp } from "./csp.ts";
+import type { KakuroBoard } from "./kakuro.types.ts";
+/**
+ * Kakuro as variables: one per white square, nine slots for the digits 1 to 9. A run's pruning keeps only the digit
+ * sets that add up to its total and fit what its squares can still be, so a square keeps only digits some such
+ * set uses; a digit that every such set uses must appear somewhere (`strength` 1), and a digit that only one square
+ * can take is that square's.
+ */
+export declare function kakuroModel(board: KakuroBoard, strength?: 0 | 1, random?: () => number): {
+    csp: Csp;
+    whites: readonly number[];
+    index: Int32Array;
+};