@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/fillominoLogic.js

@@ -0,0 +1,177 @@
+import { fillominoNeighbours } from "./fillominoBoard.js";
+/** The most any square can be: a region holding a given or an entry is that number, and one with none lies among the squares with neither. */
+export function fillominoMostValue(board, fixed) {
+    let most = 1;
+    for (const value of fixed)
+        if (value > most)
+            most = value;
+    const seen = new Uint8Array(fixed.length);
+    for (let start = 0; start < fixed.length; start += 1) {
+        if (fixed[start] || seen[start])
+            continue;
+        let size = 0;
+        const stack = [start];
+        seen[start] = 1;
+        while (stack.length) {
+            const cell = stack.pop();
+            size += 1;
+            for (const next of fillominoNeighbours(board, cell))
+                if (!fixed[next] && !seen[next]) {
+                    seen[next] = 1;
+                    stack.push(next);
+                }
+        }
+        if (size > most)
+            most = size;
+    }
+    return most;
+}
+/**
+ * Fillomino as variables: one per square, a slot for each number it can be (1 up to `most`). A finished group of
+ * equal numbers keeps its neighbours off that number; a group still short must be able to grow, to squares that can
+ * still be that number, until it is the right size, and settles on them when there is exactly room; and a square
+ * can only be a number if the squares that can still be it, joined up, make a group big enough.
+ */
+export function fillominoModel(board, fixed, most = fillominoMostValue(board, fixed)) {
+    const cells = board.width * board.height, values = most;
+    const nb = new Int32Array(cells * 4).fill(-1);
+    for (let cell = 0; cell < cells; cell += 1)
+        fillominoNeighbours(board, cell).forEach((next, k) => { nb[cell * 4 + k] = next; });
+    const starts = Int32Array.from({ length: cells + 1 }, (_, i) => i * values);
+    const only = new Int32Array(cells), label = new Int32Array(cells), size = new Int32Array(cells + 1), stack = new Int32Array(cells + 1), members = new Int32Array(cells), seen = new Int32Array(cells);
+    const dirty = new Uint8Array(values + 1);
+    let stamp = 0;
+    const propagate = (alive) => {
+        let changed = true;
+        dirty.fill(1);
+        while (changed) {
+            changed = false;
+            for (let cell = 0; cell < cells; cell += 1) {
+                let left = 0, last = 0;
+                const base = cell * values;
+                for (let v = 0; v < values; v += 1)
+                    if (alive[base + v]) {
+                        left += 1;
+                        last = v + 1;
+                    }
+                if (!left)
+                    return false;
+                only[cell] = left === 1 ? last : 0;
+            }
+            // Groups of squares already settled on the same number.
+            label.fill(0);
+            for (let start = 0; start < cells; start += 1) {
+                const v = only[start];
+                if (!v || label[start])
+                    continue;
+                let count = 0, top = 0;
+                stack[top++] = start;
+                label[start] = 1;
+                while (top) {
+                    const cell = stack[--top];
+                    members[count++] = cell;
+                    for (let k = 0; k < 4; k += 1) {
+                        const next = nb[cell * 4 + k];
+                        if (next >= 0 && only[next] === v && !label[next]) {
+                            label[next] = 1;
+                            stack[top++] = next;
+                        }
+                    }
+                }
+                if (count > v)
+                    return false;
+                if (count === v) {
+                    for (let m = 0; m < count; m += 1)
+                        for (let k = 0; k < 4; k += 1) {
+                            const next = nb[members[m] * 4 + k];
+                            if (next >= 0 && only[next] !== v && alive[next * values + v - 1]) {
+                                alive[next * values + v - 1] = 0;
+                                dirty[v] = 1;
+                                changed = true;
+                            }
+                        }
+                    continue;
+                }
+                // Short of its size: grow through squares that can still be v.
+                stamp += 1;
+                let reached = count, frontier = 0, lastFrontier = -1;
+                for (let m = 0; m < count; m += 1)
+                    seen[members[m]] = stamp;
+                for (let at = 0; at < reached; at += 1) {
+                    const cell = members[at];
+                    for (let k = 0; k < 4; k += 1) {
+                        const next = nb[cell * 4 + k];
+                        if (next < 0 || seen[next] === stamp || !alive[next * values + v - 1])
+                            continue;
+                        seen[next] = stamp;
+                        members[reached++] = next;
+                        if (at < count) {
+                            frontier += 1;
+                            lastFrontier = next;
+                        }
+                    }
+                }
+                if (reached < v)
+                    return false;
+                if (reached === v) {
+                    for (let m = 0; m < reached; m += 1) {
+                        const base = members[m] * values;
+                        for (let other = 0; other < values; other += 1)
+                            if (other !== v - 1 && alive[base + other]) {
+                                alive[base + other] = 0;
+                                dirty[other + 1] = 1;
+                                changed = true;
+                            }
+                    }
+                }
+                else if (frontier === 1 && !only[lastFrontier]) {
+                    const base = lastFrontier * values;
+                    for (let other = 0; other < values; other += 1)
+                        if (other !== v - 1 && alive[base + other]) {
+                            alive[base + other] = 0;
+                            dirty[other + 1] = 1;
+                            changed = true;
+                        }
+                }
+            }
+            // A number needs room: the squares that can be it, joined up, must make a group at least that big.
+            for (let v = 2; v <= values; v += 1) {
+                if (!dirty[v])
+                    continue;
+                dirty[v] = 0;
+                label.fill(0);
+                let components = 0;
+                const slot = v - 1;
+                for (let start = 0; start < cells; start += 1) {
+                    if (label[start] || !alive[start * values + slot])
+                        continue;
+                    components += 1;
+                    let count = 0, top = 0;
+                    stack[top++] = start;
+                    label[start] = components;
+                    while (top) {
+                        const cell = stack[--top];
+                        count += 1;
+                        for (let k = 0; k < 4; k += 1) {
+                            const next = nb[cell * 4 + k];
+                            if (next >= 0 && !label[next] && alive[next * values + slot]) {
+                                label[next] = components;
+                                stack[top++] = next;
+                            }
+                        }
+                    }
+                    size[components] = count;
+                }
+                for (let cell = 0; cell < cells; cell += 1) {
+                    if (label[cell] && size[label[cell]] < v) {
+                        alive[cell * values + slot] = 0;
+                        dirty[v] = 1;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts, propagate }, most: values };
+}

package/dist/fillominoMount.js

@@ -1,4 +1,5 @@
 import { checkFillomino } from "./fillominoBoard.js";
+import { fillominoMostValue } from "./fillominoLogic.js";
 import { drawFillomino } from "./fillominoDraw.js";
 import { decodeFillomino, encodeFillomino, hintFillomino, newFillomino, restartFillomino, setFillominoCell, undoFillomino } from "./fillominoGame.js";
 import { FILLOMINO_PLAY_STYLE } from "./fillominoStyle.js";
@@ -98,7 +99,9 @@ export function mountFillomino(host, initial) {
         const number = document.createElement("select");
         number.setAttribute("aria-label", words.selectNumber);
         number.dataset.number = "true";
-        for (let value = 1; value <= game.entries.length; value += 1) {
+        // Only numbers an answer can hold: more than the biggest given only fits among squares that have no given.
+        const most = Math.max(fillominoMostValue(game.board, game.board.givens), ...game.entries);
+        for (let value = 1; value <= most; value += 1) {
             const option = document.createElement("option");
             option.value = String(value);
             option.textContent = String(value);

package/dist/fillominoRate.d.ts

@@ -0,0 +1,3 @@
+import type { FillominoBoard, FillominoRating } from "./fillomino.types.ts";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one number at a time. */
+export declare function rateFillomino(board: FillominoBoard): FillominoRating;

package/dist/fillominoRate.js

@@ -0,0 +1,57 @@
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoModel } from "./fillominoLogic.js";
+import { decide, logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one number at a time. */
+export function rateFillomino(board) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    const { csp, most } = fillominoModel(board, board.givens);
+    const start = openSlots(csp);
+    board.givens.forEach((value, cell) => { if (value)
+        decide(csp, start, cell, cell * most + value - 1); });
+    const proof = solveCsp(csp, start, 2, 200000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Fillomino rating needs a board with one answer");
+    const plain = logicCsp(csp, start, 0);
+    const probing = plain.solved ? plain : logicCsp(csp, start, 1);
+    const answer = Array.from({ length: board.givens.length }, (_, cell) => { for (let v = 0; v < most; v += 1)
+        if (proof.solution[cell * most + v])
+            return v + 1; return 0; });
+    const regions = new Map();
+    const label = Array(answer.length).fill(-1);
+    let count = 0, largest = 0, unnamed = 0;
+    for (let first = 0; first < answer.length; first += 1) {
+        if (label[first] >= 0)
+            continue;
+        const members = [first];
+        label[first] = count;
+        for (let at = 0; at < members.length; at += 1) {
+            const cell = members[at], x = cell % board.width, y = Math.floor(cell / board.width);
+            for (const [nx, ny] of [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]) {
+                if (nx < 0 || ny < 0 || nx >= board.width || ny >= board.height)
+                    continue;
+                const next = ny * board.width + nx;
+                if (label[next] < 0 && answer[next] === answer[first]) {
+                    label[next] = count;
+                    members.push(next);
+                }
+            }
+        }
+        largest = Math.max(largest, members.length);
+        if (!members.some(cell => board.givens[cell]))
+            unnamed += 1;
+        regions.set(String(count), members.length);
+        count += 1;
+    }
+    const givens = board.givens.filter(Boolean).length;
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        givens,
+        givenShare: givens / board.givens.length,
+        regions: count,
+        unnamed,
+        largest,
+        meanRegion: board.givens.length / count,
+    };
+}

package/dist/fillominoSolve.js

@@ -1,5 +1,7 @@
 import { FILLOMINO_MOST_NODES } from "./fillomino.constants.js";
-import { fillominoNeighbours, isFillominoBoard } from "./fillominoBoard.js";
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoModel } from "./fillominoLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
 /** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
 export function solveFillomino(board, entries = board.givens, options = {}) {
     if (!isFillominoBoard(board))
@@ -21,91 +23,16 @@ export function solveFillomino(board, entries = board.givens, options = {}) {
     });
     if (fixed.some(value => value < 0))
         return { count: 0, solution: null, complete: true, nodes: 0 };
-    const resolved = Array(entries.length).fill(0);
-    const state = { nodes: 0, stopped: false };
-    let count = 0;
-    let solution = null;
-    const visit = () => {
-        if (++state.nodes > budget) {
-            state.stopped = true;
-            return;
-        }
-        let anchor = -1;
-        for (let cell = 0; cell < resolved.length; cell += 1) {
-            if (resolved[cell] === 0) {
-                anchor = cell;
-                break;
-            }
-        }
-        if (anchor < 0) {
-            count += 1;
-            solution ?? (solution = [...resolved]);
-            if (count >= limit)
-                state.stopped = true;
-            return;
-        }
-        const choices = fixed[anchor] ? [fixed[anchor]] : Array.from({ length: entries.length }, (_, index) => index + 1);
-        for (const value of choices) {
-            const shapes = regionShapes(board, anchor, value, resolved, fixed, state, budget);
-            if (state.stopped)
-                return;
-            for (const shape of shapes) {
-                for (const cell of shape)
-                    resolved[cell] = value;
-                visit();
-                for (const cell of shape)
-                    resolved[cell] = 0;
-                if (state.stopped)
-                    return;
-            }
-        }
-    };
-    visit();
-    const complete = !state.stopped;
-    return { count, solution, complete, nodes: Math.min(state.nodes, budget) };
-}
-function regionShapes(board, anchor, area, resolved, fixed, state, budget) {
-    if (fixed[anchor] !== 0 && fixed[anchor] !== area)
-        return [];
-    const shapes = [];
-    const seen = new Set();
-    const grow = (cells) => {
-        if (state.stopped)
-            return;
-        if (++state.nodes > budget) {
-            state.stopped = true;
-            return;
-        }
-        const key = [...cells].sort((a, b) => a - b).join(",");
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        if (cells.length === area) {
-            const members = new Set(cells);
-            for (const cell of cells) {
-                for (const next of fillominoNeighbours(board, cell)) {
-                    if (members.has(next))
-                        continue;
-                    if (resolved[next] === area || fixed[next] === area)
-                        return;
-                }
-            }
-            shapes.push([...cells]);
-            return;
-        }
-        const frontier = new Set();
-        for (const cell of cells) {
-            for (const next of fillominoNeighbours(board, cell)) {
-                if (cells.includes(next) || resolved[next] !== 0)
-                    continue;
-                if (fixed[next] !== 0 && fixed[next] !== area)
-                    continue;
-                frontier.add(next);
-            }
-        }
-        for (const next of frontier)
-            grow([...cells, next]);
-    };
-    grow([anchor]);
-    return shapes;
+    const { csp, most } = fillominoModel(board, fixed);
+    const start = openSlots(csp);
+    fixed.forEach((value, cell) => { if (value)
+        decide(csp, start, cell, cell * most + value - 1); });
+    const found = solveCsp(csp, start, limit, budget);
+    const solution = found.solution ? Array.from({ length: fixed.length }, (_, cell) => {
+        for (let v = 0; v < most; v += 1)
+            if (found.solution[cell * most + v])
+                return v + 1;
+        return 0;
+    }) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/groupSolve.d.ts

@@ -60,6 +60,15 @@ export declare function applySingles(grid: Grid, layout: Layout): SinglesResult;
  * has no answer. Meant for a grid already known to have exactly one.
  */
 export declare function guessDepth(grid: Grid, layout: Layout): number;
+/**
+ * What reasoning with at most `guesses` guesses proves about a grid: 0 when it proves there is no answer, 1
+ * when it proves there is exactly one, 2 when it proves neither (it could not finish, or there are several).
+ * A guess is made at the most constrained empty cell and every value is tried, each followed by everything
+ * singles find; the grid has one answer when exactly one value leads to one and every other leads to none.
+ * This is a person's proof, and it stops where theirs would, so it costs a bounded few hundred passes of
+ * singles however sparse and large the grid is: counting every answer of a sparse 25×25 grid does not.
+ */
+export declare function provedByGuessing(grid: Grid, layout: Layout, guesses: number): 0 | 1 | 2;
 /**
  * A full grid for this layout, drawn at random, or null when the search runs
  * past `budget` steps — which for a jigsaw means these regions are a poor

package/dist/groupSolve.js

@@ -121,6 +121,8 @@ export function countSolutions(grid, layout, limit = 2) {
  * rather than keeping a browser waiting.
  */
 export function countSolutionsWithin(grid, layout, limit, budget, first) {
+    if (layout.size > LARGEST_SEARCHED_BARE)
+        return countByReasoning(grid, layout, limit, budget, first);
     const work = [...grid];
     const taken = used(work, layout);
     let found = 0;
@@ -150,6 +152,41 @@ export function countSolutionsWithin(grid, layout, limit, budget, first) {
     step();
     return steps > budget && found < limit ? null : found;
 }
+/**
+ * Up to this side the search guesses at the most constrained cell and nothing else, which is how every
+ * 4×4 to 16×16 grid has always been counted. Past it (the 25×25) a sparse grid thrashes that way for
+ * minutes, so a search there lets singles finish whatever they can before each guess.
+ */
+const LARGEST_SEARCHED_BARE = 16;
+/** The same count for a large grid: at every step all the singles are filled in first, and only what they leave is guessed at. */
+function countByReasoning(grid, layout, limit, budget, first) {
+    let found = 0;
+    let steps = 0;
+    const step = (from) => {
+        if (found >= limit || steps > budget)
+            return;
+        steps += 1;
+        const singles = applySingles(from, layout);
+        if (singles.contradiction)
+            return;
+        if (singles.solved) {
+            if (found === 0)
+                first?.([...singles.grid]);
+            found += 1;
+            return;
+        }
+        const { index, mask } = mostConstrained(singles.grid, layout, used(singles.grid, layout));
+        for (let left = mask; left !== 0; left &= left - 1) {
+            const next = [...singles.grid];
+            next[index] = lowestBit(left);
+            step(next);
+            if (found >= limit || steps > budget)
+                return;
+        }
+    };
+    step(grid);
+    return steps > budget && found < limit ? null : found;
+}
 /**
  * THE ANSWER, WORKED OUT FROM THE GIVENS: a finished puzzle kept before its
  * grid was, drawn solved rather than as dealt. Every puzzle made here has
@@ -245,6 +282,35 @@ export function guessDepth(grid, layout) {
     }
     return deepest === Infinity ? Infinity : deepest + 1;
 }
+/**
+ * What reasoning with at most `guesses` guesses proves about a grid: 0 when it proves there is no answer, 1
+ * when it proves there is exactly one, 2 when it proves neither (it could not finish, or there are several).
+ * A guess is made at the most constrained empty cell and every value is tried, each followed by everything
+ * singles find; the grid has one answer when exactly one value leads to one and every other leads to none.
+ * This is a person's proof, and it stops where theirs would, so it costs a bounded few hundred passes of
+ * singles however sparse and large the grid is: counting every answer of a sparse 25×25 grid does not.
+ */
+export function provedByGuessing(grid, layout, guesses) {
+    const singles = applySingles(grid, layout);
+    if (singles.contradiction)
+        return 0;
+    if (singles.solved)
+        return 1;
+    if (guesses < 1)
+        return 2;
+    const work = singles.grid;
+    const { index, mask } = mostConstrained(work, layout, used(work, layout));
+    let ones = 0;
+    for (let left = mask; left !== 0; left &= left - 1) {
+        const next = [...work];
+        next[index] = lowestBit(left);
+        const outcome = provedByGuessing(next, layout, guesses - 1);
+        if (outcome === 2)
+            return 2;
+        ones += outcome;
+    }
+    return ones === 0 ? 0 : ones === 1 ? 1 : 2;
+}
 /**
  * A full grid for this layout, drawn at random, or null when the search runs
  * past `budget` steps — which for a jigsaw means these regions are a poor

package/dist/hitori-entry.d.ts

@@ -3,4 +3,5 @@ export * from "./hitori.constants.ts";
 export * from "./hitoriBoard.ts";
 export * from "./hitoriSolve.ts";
 export * from "./hitoriGenerate.ts";
+export * from "./hitoriRate.ts";
 export * from "./hitoriGame.ts";

package/dist/hitori-entry.js

@@ -3,4 +3,5 @@ export * from "./hitori.constants.js";
 export * from "./hitoriBoard.js";
 export * from "./hitoriSolve.js";
 export * from "./hitoriGenerate.js";
+export * from "./hitoriRate.js";
 export * from "./hitoriGame.js";

package/dist/hitori.constants.d.ts

@@ -1,2 +1,8 @@
 export declare const HITORI_MAX_NODES = 300000;
-export declare const HITORI_SIZES: readonly [5, 7];
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export declare const HITORI_SIZES: readonly [5, 6, 7, 8, 9, 10, 12];
+export declare const HITORI_MOST_SIDE = 12;
+export declare const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export declare const HITORI_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+export declare const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.constants.js

@@ -1,2 +1,8 @@
 export const HITORI_MAX_NODES = 300000;
-export const HITORI_SIZES = [5, 7];
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export const HITORI_SIZES = [5, 6, 7, 8, 9, 10, 12];
+export const HITORI_MOST_SIDE = 12;
+export const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export const HITORI_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+export const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.types.d.ts

@@ -1,11 +1,28 @@
 export type HitoriBoard = {
-    size: 5 | 7;
+    size: number;
     numbers: readonly number[];
 };
+export type HitoriLevel = "easy" | "medium" | "hard" | "extra-hard";
 export type HitoriPuzzle = HitoriBoard & {
     seed: number;
+    level: HitoriLevel;
     solution: readonly boolean[];
 };
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the rules solve it, 1 that somebody has to suppose a
+ * square shaded or white and watch it break, 2 that more than that is needed. `reach` says the rule that the white
+ * squares stay in one piece was needed at depth 0. `probes` is the suppositions depth 1 needed.
+ */
+export type HitoriRating = {
+    depth: 0 | 1 | 2;
+    reach: boolean;
+    probes: number;
+    shaded: number;
+    /** Shaded squares as a share of the board. */
+    shadedShare: number;
+    /** Squares whose number repeats in their row or column, as a share of the board. */
+    repeatShare: number;
+};
 export type HitoriSolve = {
     count: number;
     solution: readonly boolean[] | null;

package/dist/hitoriBoard.js

@@ -1,5 +1,6 @@
+import { HITORI_LEAST_SIDE, HITORI_MOST_SIDE } from "./hitori.constants.js";
 export function isHitoriBoard(board) {
-    return !!board && (board.size === 5 || board.size === 7)
+    return !!board && Number.isInteger(board.size) && board.size >= HITORI_LEAST_SIDE && board.size <= HITORI_MOST_SIDE
         && Array.isArray(board.numbers)
         && board.numbers.length === board.size * board.size
         && board.numbers.every(value => Number.isInteger(value) && value >= 1 && value <= board.size);

package/dist/hitoriBuild.d.ts

@@ -0,0 +1,12 @@
+import type { HitoriBoard, HitoriLevel } from "./hitori.types.ts";
+import type { Random } from "./random.ts";
+export declare const SHARE: Record<HitoriLevel, number>;
+/** A board with one answer, or null when the random choices did not lead to one. How the numbers are chosen leans on the level. */
+export declare function candidateHitori(size: number, level: HitoriLevel, random: Random, base?: readonly number[]): {
+    board: HitoriBoard;
+    shaded: readonly boolean[];
+} | null;
+/** A random Latin square: every number once in each row and column, built row by row with backtracking. */
+export declare function latinSquare(size: number, random: Random): number[] | null;
+/** The same square with its rows, columns and numbers renamed at random: still one of each in every line. */
+export declare function isotope(square: readonly number[], size: number, random: Random): number[];