diff --git a/src/components/Modal/Types/Welcome.svelte b/src/components/Modal/Types/Welcome.svelte
index 5076e372..34775125 100644
--- a/src/components/Modal/Types/Welcome.svelte
+++ b/src/components/Modal/Types/Welcome.svelte
@@ -11,6 +11,7 @@
let sencode = data.sencode || '';
$: enteredSencode = sencode.trim().length !== 0;
+ //
$: buttonDisabled = enteredSencode ? !validateSencode(sencode) : !DIFFICULTIES.hasOwnProperty(difficulty);
function handleStart() {
diff --git a/src/components/Modal/Types/index.js b/src/components/Modal/Types/index.js
index 54b8810a..3eb94fad 100644
--- a/src/components/Modal/Types/index.js
+++ b/src/components/Modal/Types/index.js
@@ -5,6 +5,7 @@ import confirm from './Confirm.svelte';
import prompt from './Prompt.svelte';
import welcome from './Welcome.svelte';
import gameover from './GameOver.svelte';
+import nosolution from './Nosolution.svelte';
export default {
share,
@@ -13,5 +14,6 @@ export default {
confirm,
prompt,
welcome,
- gameover
+ gameover,
+ nosolution
}
\ No newline at end of file
diff --git a/src/main.js b/src/main.js
index 3b5b5314..ac240469 100644
--- a/src/main.js
+++ b/src/main.js
@@ -7,6 +7,9 @@ const app = new App({
export default app;
+// Ŀļ
+// App.svelte ص index.html еĸԪأ
+
// TODO: Warn when hint not possible
// TODO: Undo/Redo
// TODO: Import sudoku
diff --git a/src/node_modules/@sudoku/constants.js b/src/node_modules/@sudoku/constants.js
index 9f9ae36c..f390f3c5 100644
--- a/src/node_modules/@sudoku/constants.js
+++ b/src/node_modules/@sudoku/constants.js
@@ -12,10 +12,11 @@ export const DEFAULT_SETTINGS = {
darkTheme: false,
displayTimer: true,
hintsLimited: true,
- hints: 5,
+ hints: 100,
highlightCells: true,
highlightSame: true,
highlightConflicting: true,
+ hintLevel: 1, // 新增 hintLevel，默认值为 1
};
export const MAX_HINTS = 99999;
diff --git a/src/node_modules/@sudoku/game.js b/src/node_modules/@sudoku/game.js
index 16d1226e..83600823 100644
--- a/src/node_modules/@sudoku/game.js
+++ b/src/node_modules/@sudoku/game.js
@@ -1,10 +1,10 @@
import { cursor } from './stores/cursor';
import { difficulty } from './stores/difficulty';
import { gamePaused } from './stores/game';
-import { grid } from './stores/grid';
+import { grid, userGrid } from './stores/grid';
import { timer } from './stores/timer';
import { hints } from './stores/hints';
-
+import { sudokutreemanager } from '@sudoku/stores/state';
/**
* Start new game with a generated sudoku
*
@@ -16,8 +16,9 @@ export function startNew(diff) {
cursor.reset();
timer.reset();
hints.reset();
-
+ sudokutreemanager.generate(userGrid.getUserGridCopy());
location.hash = '';
+
}
/**
diff --git a/src/node_modules/@sudoku/sencode/index.js b/src/node_modules/@sudoku/sencode/index.js
index d12c770c..f34a783b 100644
--- a/src/node_modules/@sudoku/sencode/index.js
+++ b/src/node_modules/@sudoku/sencode/index.js
@@ -53,8 +53,26 @@ export function encodeSudoku(sudoku) {
/**
* @param {string} sencode
* @returns {number[][]}
+ * ֱӰַʽȻ˳ضӦһЩͺˡ
+ * һ
*/
+function validateLength(str){
+
+ return str.length==81
+}
+
+function isNumeric(str) {
+ return /^[0-9]+$/.test(str);
+}
+
+function isNumDot(str) {
+ return /^[0-9.]+$/.test(str);
+
+}
export function decodeSencode(sencode) {
+ if(sencode.includes("bd=") != -1){
+ sencode = sencode.split("bd=")[1]
+ }
let grid = [
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -67,38 +85,73 @@ export function decodeSencode(sencode) {
[0, 0, 0, 0, 0, 0, 0, 0, 0],
];
- const reversed = sencode.indexOf(SEPARATOR_REVERSE) !== -1;
-
- const [encodedStructure, encodedNumbers] = sencode.split(reversed ? SEPARATOR_REVERSE : SEPARATOR);
+ if(validateLength(sencode) && isNumeric(sencode)) {
+ let place =0
+ for(let row =0;row<9;row++){
+ for(let col=0;col<9;col++,place++){
+ grid[row][col] = sencode[place] - '0';
- const structure = Base62.decode(encodedStructure)
- .toString(2)
- .padStart(GRID_LENGTH, '0');
+ }
- let numberCount = 0;
- for (let cell = 0; cell < GRID_LENGTH; cell++) {
- if (structure[cell] === '1') {
- numberCount++;
}
+
+
}
+ else if(validateLength(sencode) && isNumDot(sencode)){
+ let place =0
+ for(let row =0;row<9;row++){
+ for(let col=0;col<9;col++,place++){
+ if(sencode[place] == '.') {
+ grid[row][col] = 0;
+ continue;
+ }
- let numbers = Base62.decode(encodedNumbers)
- .toString()
- .padStart(numberCount, '0')
- .split('');
+ grid[row][col] = sencode[place]- '0';
+
+ }
- for (let cell = 0; cell < GRID_LENGTH; cell++) {
- if (structure[cell] === '1') {
- const [row, col] = GRID_COORDS[cell];
- grid[row][col] = numbers.shift() * 1 + 1;
}
+
+
}
+ else{
+ const reversed = sencode.indexOf(SEPARATOR_REVERSE) !== -1;
+
+ const [encodedStructure, encodedNumbers] = sencode.split(reversed ? SEPARATOR_REVERSE : SEPARATOR);
+
+ const structure = Base62.decode(encodedStructure)
+ .toString(2)
+ .padStart(GRID_LENGTH, '0');
+
+ let numberCount = 0;
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ if (structure[cell] === '1') {
+ numberCount++;
+ }
+ }
+
+ let numbers = Base62.decode(encodedNumbers)
+ .toString()
+ .padStart(numberCount, '0')
+ .split('');
+
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ if (structure[cell] === '1') {
+ const [row, col] = GRID_COORDS[cell];
+ grid[row][col] = numbers.shift() * 1 + 1;
+ }
+ }
+
+ if (reversed) {
+ // Reverse Grid
+ grid = grid.reverse().map(row => row.reverse());
+ }
- if (reversed) {
- // Reverse Grid
- grid = grid.reverse().map(row => row.reverse());
}
+
+
+
return grid;
}
@@ -108,5 +161,20 @@ export function decodeSencode(sencode) {
* @returns {boolean}
*/
export function validateSencode(sencode) {
+
+
+
+ // ַʹܹ֮ʽurl
+ // https://www.sudokuwiki.org/sudoku.htm?bd=291.7...3...3....7.....6..83.....42....4.7....42......4..5.....8....1.......8.975
+ var p = sencode.slice()
+ if(p.includes("bd=")){
+ p = p.split("bd=")[1]
+ }
+
+ // type 1
+ if(validateLength(p) && isNumeric(p)) return true
+ // type 2
+ if(validateLength(p) && isNumDot(p) ) return true
+ // type 3
return sencode && sencode.trim().length !== 0 && SENCODE_REGEX.test(sencode);
}
\ No newline at end of file
diff --git a/src/node_modules/@sudoku/stores/grid.js b/src/node_modules/@sudoku/stores/grid.js
index f803807b..fbc35d11 100644
--- a/src/node_modules/@sudoku/stores/grid.js
+++ b/src/node_modules/@sudoku/stores/grid.js
@@ -1,106 +1,137 @@
import { BOX_SIZE, SUDOKU_SIZE } from '@sudoku/constants';
import { decodeSencode, encodeSudoku } from '@sudoku/sencode';
-import { generateSudoku, solveSudoku } from '@sudoku/sudoku';
+import { generateSudoku } from '@sudoku/sudoku';
import { derived, writable } from 'svelte/store';
+import { hintStore } from '@sudoku/stores/hintStore';
import { hints } from './hints';
+import { get } from 'svelte/store';
+import { sudokutreemanager } from '@sudoku/stores/state';
-function createGrid() {
- const grid = writable([
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- ]);
-
- return {
- subscribe: grid.subscribe,
-
- generate(difficulty) {
- grid.set(generateSudoku(difficulty));
- },
-
- decodeSencode(sencode) {
- grid.set(decodeSencode(sencode));
- },
-
- get(gridStore, x, y) {
- return gridStore[y][x];
- },
-
- getSencode(gridStore) {
- return encodeSudoku(gridStore);
- },
- };
+
+class Grid {
+ #grid;
+
+ constructor() {
+ this.#grid = writable(
+ Array(SUDOKU_SIZE).fill().map(() => Array(SUDOKU_SIZE).fill(0))
+ );
+ }
+
+ subscribe(callback) {
+ return this.#grid.subscribe(callback);
+ }
+
+ generate(difficulty) {
+ this.#grid.set(generateSudoku(difficulty));
+ }
+
+ decodeSencode(sencode) {
+ this.#grid.set(decodeSencode(sencode));
+ }
+
+ get(gridStore, x, y) {
+ return gridStore[y][x];
+ }
+
+ getSencode(gridStore) {
+ return encodeSudoku(gridStore);
+ }
+
+ getGridCopy() {
+ const currentValue = get(this.#grid);
+ // 深拷贝二维数组
+ const copy = currentValue.map(row => [...row]);
+ return copy;
+ }
}
-export const grid = createGrid();
-
-
-function createUserGrid() {
- const userGrid = writable([
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- ]);
-
- grid.subscribe($grid => {
- let newGrid = [];
-
- for (let y = 0; y < SUDOKU_SIZE; y++) {
- newGrid[y] = [];
- for (let x = 0; x < SUDOKU_SIZE; x++) {
- newGrid[y][x] = $grid[y][x];
- }
+export const grid = new Grid();
+
+class UserGrid {
+ #userGrid;
+
+ constructor(gridInstance) {
+ this.#userGrid = writable(
+ Array(SUDOKU_SIZE).fill().map(() => Array(SUDOKU_SIZE).fill(0))
+ );
+
+ gridInstance.subscribe($grid => {
+ const newGrid = $grid.map(row => [...row]);
+ this.#userGrid.set(newGrid);
+ });
+ }
+
+ subscribe(callback) {
+ return this.#userGrid.subscribe(callback);
+ }
+
+ set(pos, value) {
+ this.#userGrid.update($userGrid => {
+ console.log("The current node before:", sudokutreemanager.currentNode.grid);
+ $userGrid[pos.y][pos.x] = value;
+
+ const CopiedGrid = this.getUserGridCopy();
+ console.log("The current node:", sudokutreemanager.currentNode.grid);
+ sudokutreemanager.createChildNode(CopiedGrid);
+ return $userGrid;
+ });
+ }
+
+ /**
+ * 与 hints.js 交互，获取提示值并保存到 hintStore 中。
+ * @param {Object} pos 提示的坐标 { x, y }
+ */
+ applyHint(pos) {
+
+ const currentUserGrid = get(this.#userGrid);
+
+ let solve = hints.useHint(currentUserGrid);
+ console.log("Solve:", solve);
+
+ if (solve instanceof Array) {
+ hintStore.hint_array_set(solve);
}
- userGrid.set(newGrid);
- });
-
- return {
- subscribe: userGrid.subscribe,
-
- set: (pos, value) => {
- userGrid.update($userGrid => {
- $userGrid[pos.y][pos.x] = value;
- return $userGrid;
- });
- },
-
- applyHint: (pos) => {
- hints.useHint();
- userGrid.update($userGrid => {
- const solvedSudoku = solveSudoku($userGrid);
- $userGrid[pos.y][pos.x] = solvedSudoku[pos.y][pos.x];
- return $userGrid;
- });
- },
- };
+ }
+ getUserGridCopy() {
+ // 先取出当前的值
+ const currentGrid = get(this.#userGrid);
+
+ // 利用 map + 扩展运算符（或 row.slice()）进行二维数组的深拷贝
+ const deepCopiedGrid = currentGrid.map(row => [...row]);
+
+ return deepCopiedGrid;
+ }
+
+ setGrid(newGrid) {
+
+ if (
+ !Array.isArray(newGrid) ||
+ newGrid.length !== SUDOKU_SIZE ||
+ !newGrid.every(row => Array.isArray(row) && row.length === SUDOKU_SIZE)
+ ) {
+ throw new Error('Invalid grid format');
+ }
+
+ // 设置新的网格
+ this.#userGrid.set(newGrid);
+ // 打印当前的 #grid
+ console.log(this.#userGrid);
+ }
}
-export const userGrid = createUserGrid();
+export const userGrid = new UserGrid(grid);
export const invalidCells = derived(userGrid, $userGrid => {
const _invalidCells = [];
const addInvalid = (x, y) => {
- const xy = x + ',' + y;
+ const xy = `${x},${y}`;
if (!_invalidCells.includes(xy)) _invalidCells.push(xy);
};
for (let y = 0; y < SUDOKU_SIZE; y++) {
for (let x = 0; x < SUDOKU_SIZE; x++) {
-
const value = $userGrid[y][x];
if (value) {
@@ -129,9 +160,8 @@ export const invalidCells = derived(userGrid, $userGrid => {
}
}
}
-
}
}
return _invalidCells;
-}, []);
\ No newline at end of file
+}, []);
diff --git a/src/node_modules/@sudoku/stores/hintStore.js b/src/node_modules/@sudoku/stores/hintStore.js
new file mode 100644
index 00000000..31296f87
--- /dev/null
+++ b/src/node_modules/@sudoku/stores/hintStore.js
@@ -0,0 +1,39 @@
+import { writable } from 'svelte/store';
+
+class HintStore {
+ constructor() {
+ // 初始化一个可写的 Svelte store，用于存储提示列表
+ this.hints = writable([]);
+ }
+
+ // 订阅 store 的方法，用于在组件中获取提示数据
+ subscribe(run, invalidate) {
+ return this.hints.subscribe(run, invalidate);
+ }
+
+ // 添加一个提示到提示列表中
+ add(pos, [value]) {
+ this.hints.update(current => [...current, { x: pos.x, y: pos.y, value:[value] }]);
+ }
+
+ // 将一个列表直接设置为 hints
+ hint_array_set(list) {
+ if (list instanceof Array) {
+ this.hints.set(list);
+ }
+ }
+
+ // 根据索引移除指定的提示
+ remove(index) {
+ this.hints.update(current => current.filter((_, i) => i !== index));
+ }
+
+ // 清空所有提示
+ clear() {
+ this.hints.set([]);
+ }
+}
+
+// 导出 HintStore 实例
+export const hintStore = new HintStore();
+
diff --git a/src/node_modules/@sudoku/stores/hints.js b/src/node_modules/@sudoku/stores/hints.js
index 4b09e5a4..748fb491 100644
--- a/src/node_modules/@sudoku/stores/hints.js
+++ b/src/node_modules/@sudoku/stores/hints.js
@@ -1,46 +1,127 @@
-import { settings } from './settings';
import { writable } from 'svelte/store';
+import { settings } from './settings';
+import { solveSudoku } from '@sudoku/sudoku';
+import { strategymanager } from '@sudoku/strategy/strategymanager';
+
+
export const usedHints = writable(0);
-function createHints() {
- let defaultHints = Infinity;
+// 新增：用于存储提示文字的状态
+export const hintText = writable('');
+// 新增：用于存储提示文字的列表
+export const reasons_list = writable([]);
- const hints = writable(Infinity);
+export const hintstate = writable(true);
- settings.subscribe(($settings) => {
- if ($settings.hintsLimited) {
- defaultHints = $settings.hints;
- hints.update($hints => {
- if ($hints > $settings.hints) return $settings.hints;
+class Hints {
+ #hints;
+ #defaultHints;
+ #hintLevel;
- return $hints;
- })
- } else {
- defaultHints = Infinity;
- hints.set(Infinity);
- }
- });
+ constructor() {
+ this.#defaultHints = Infinity;
+ this.#hints = writable(Infinity);
- return {
- subscribe: hints.subscribe,
+ settings.subscribe(($settings) => {
+ this.#hintLevel = $settings.hintLevel;
+ if ($settings.hintsLimited) {
+ this.#defaultHints = $settings.hints;
+ this.#hints.update(($hints) => {
+ if ($hints > $settings.hints) return $settings.hints;
+ return $hints;
+ });
+ } else {
+ this.#defaultHints = Infinity;
+ this.#hints.set(Infinity);
+ }
+ });
+ }
- useHint() {
- hints.update($hints => {
- if ($hints > 0) {
- usedHints.update($usedHints => $usedHints + 1);
- return $hints - 1;
+ subscribe(callback) {
+ return this.#hints.subscribe(callback);
+ }
+
+ /**
+ * 使用提示功能，返回提示内容。
+ * @param {Array
>} currentGrid 当前用户数独网格
+ * @param {Object} pos 提示的坐标 { x, y }
+ * @returns {number|null} 提示的值，若无可用提示则返回 null
+ */
+ useHint(currentGrid) {
+ let hintValue = [];
+ let selections = [];
+ let solve = [];
+ let reason = [];
+ this.#hints.update(($hints) => {
+ if ($hints > 0) {
+ usedHints.update(($usedHints) => $usedHints + 1);
+ selections = this.Candidates_Selection(currentGrid);
+ if (this.#hintLevel === 1) { // 一级提示：提示所有仅剩一个候选值的单元格
+ if (selections[0] && selections[0].length > 0) {
+ solve = selections[0];
+ } else if (selections[1] && selections[1].length > 0) {
+ solve = selections[1];
+ } else {
+ solve = selections[2];
+ }
+ } else if (this.#hintLevel === 2) { // 二级提示：提示所有剩两个候选值的单元格
+ if (selections[1] && selections[1].length > 0) {
+ solve = selections[1];
+ } else {
+ solve = selections[2];
+ }
+ } else { // 三级提示：提示所有候选值 < 9 的单元格
+ solve = selections[2];
+ }
+ if (!solve || solve.length === 0) {
+ hintstate.set(false);
+ console.log("没有可用的解法了");
}
+
+ return $hints - 1;
+ }
+ return $hints; // 提示次数为 0，不进行更新
+ });
+ return solve;
+ }
+
+ Candidates_Selection(currentGrid) {
+ //三个等级提示的候选值列表
+ let level_one_list = [];
+ let level_two_list = [];
+ let level_three_list = [];
+
+ let candidates_and_reasons = strategymanager.inference(currentGrid);
+ let solvedsudoku = candidates_and_reasons[0];
+ console.log("Solve:____", candidates_and_reasons[1]);
- return 0;
- });
- },
+ reasons_list.set(candidates_and_reasons[1]);
+ for (let i = 0; i < solvedsudoku.length; i++) {
+ for (let j = 0; j < solvedsudoku[i].length; j++) {
- reset() {
- hints.set(defaultHints);
- usedHints.set(0);
+ if (solvedsudoku[i][j].length === 1) {
+ level_one_list.push({ x: j, y: i, value: solvedsudoku[i][j] });
+ }
+ if (solvedsudoku[i][j].length === 2) {
+ level_two_list.push({ x: j, y: i, value: solvedsudoku[i][j] });
+ }
+
+ if (solvedsudoku[i][j].length > 0) {
+ level_three_list.push({ x: j, y: i, value: solvedsudoku[i][j] });
+ }
+ }
}
- };
+
+
+ return [level_one_list, level_two_list, level_three_list];
+
+ }
+
+ reset() {
+ this.#hints.set(this.#defaultHints);
+ usedHints.set(0);
+ }
}
-export const hints = createHints();
\ No newline at end of file
+export const hints = new Hints();
diff --git a/src/node_modules/@sudoku/stores/state.js b/src/node_modules/@sudoku/stores/state.js
new file mode 100644
index 00000000..a29f2aa2
--- /dev/null
+++ b/src/node_modules/@sudoku/stores/state.js
@@ -0,0 +1,218 @@
+import { writable } from 'svelte/store';
+import { hintStore } from '@sudoku/stores/hintStore';
+import { grid, userGrid } from '@sudoku/stores/grid';
+
+// 用于存储所有提示内容
+let allHints = [];
+
+// 订阅 hintStore，获取所有提示数据
+hintStore.subscribe(hints => {
+ allHints = hints; // 保存整个 hintStore 列表
+});
+
+/****************************************
+ * 数独树节点类
+ ****************************************/
+class SudokuNode {
+ constructor(id, grid) {
+ this.id = id;
+ this.grid = grid;
+
+ // 父、子节点
+ this.parent = null;
+ this.children = null;
+
+ // 已经被证实无效的猜测 (比如本节点走到死胡同)
+ this.invalidhints = new Set();
+ }
+
+ /**
+ * 往本节点添加一个子节点
+ * @param {SudokuNode} childNode
+ */
+ addChild(childNode) {
+ childNode.parent = this;
+ this.children = childNode;
+ }
+}
+
+/****************************************
+ * 数独树管理器
+ ****************************************/
+class SudokuTreeManager {
+ /**
+ * @param {object} initialGameState - 初始的数独盘面数据
+ */
+ constructor() {
+ // 用于生成节点 id
+ this.nodeCounter = 0;
+ // 如果不想用全局 nodeMap，也可以单独在这里维护
+ this.localNodeMap = new Map();
+ this.rootNode = null;
+ // currentNode 表示当前所处的节点（“游标”）
+ this.currentNode = null;
+
+ // 栈，用于存储符合条件的节点 id
+ this.nodeStack = [];
+
+ // 建立一个内部的 store，专门用来让 Svelte 追踪变化
+ this._state = writable({
+ currentNode: this.currentNode,
+ nodeStack: this.nodeStack,
+ canGoToParent: false,
+ canGoToSon: false,
+ isStackEmpty: true
+ });
+ }
+
+ get store() {
+ // 组件中会通过 manager.store 拿到这个可写 store
+ return this._state;
+ }
+
+ // 内部方法：更新 store 状态
+ _updateStore() {
+ this._state.set({
+ currentNode: this.currentNode,
+ nodeStack: this.nodeStack,
+ canGoToParent: this.canGoToParent(),
+ canGoToSon: this.canGoToSon(),
+ isStackEmpty: this.isStackEmpty()
+ });
+ }
+
+ /**
+ * 内部方法：生成一个唯一节点 id
+ * @returns {string}
+ */
+ _genNodeId() {
+ const id = `node-${this.nodeCounter}`;
+ this.nodeCounter++;
+ return id;
+ }
+
+ generate(grid) {
+ // 创建根节点
+ const rootId = this._genNodeId();
+ this.rootNode = new SudokuNode(rootId, grid);
+ // 也放到本地 Map 里
+ this.localNodeMap.set(rootId, this.rootNode);
+ // currentNode 表示当前所处的节点（“游标”）
+ this.currentNode = this.rootNode;
+ console.warn("Create root node");
+
+ this._updateStore(); // 每次修改 currentNode 后，都更新一下
+ }
+
+ /**
+ * 创建一个新的子节点，并挂到指定的 parentNode 下
+ * @param {object} gameState - 新节点对应的游戏盘面
+ * @param {object} parentNode - 父节点
+ * @param {object} [options] - 包含 guessedCell, guessedValue 等
+ * @returns {SudokuNode} - 新创建的子节点
+ */
+ createChildNode(newgrid, parentNode = this.currentNode) {
+ console.log("The parent grid before:", parentNode.grid);
+ const newId = this._genNodeId();
+ const child = new SudokuNode(newId, newgrid);
+ parentNode.addChild(child);
+
+ // 本地也登记一下
+ this.localNodeMap.set(newId, child);
+ this.currentNode = child;
+ this._updateStore(); // 更新 store
+ console.log("Create child grid", grid);
+ console.log("The parent grid", parentNode.grid);
+ return child;
+ }
+
+ /**
+ * 把 currentNode 切换到指定的节点 id
+ * 这就是所谓的“快速跳”
+ * @param {string} nodeId
+ */
+ jumpToNode(nodeId) {
+ const targetNode = this.localNodeMap.get(nodeId);
+ if (!targetNode) {
+ console.error(`Node with id=${nodeId} not found in localNodeMap!`);
+ return;
+ }
+ this.currentNode = targetNode;
+ userGrid.setGrid(this.currentNode.grid);
+ console.log(`Jumped to node: ${nodeId}`);
+
+ this._updateStore(); // 更新 store
+ }
+
+ /**
+ * 回到父节点 (若有)
+ */
+ canGoToParent() {
+ return this.currentNode && this.currentNode.parent !== null;
+ }
+ goToParent() {
+ if (this.currentNode && this.currentNode.parent) {
+ this.currentNode = this.currentNode.parent;
+ console.log("this.currentNode.grid:", this.currentNode.grid);
+ userGrid.setGrid(this.currentNode.grid);
+
+ console.log(`Went back to parent: ${this.currentNode.id}`);
+ this._updateStore(); // 更新 store
+ } else {
+ console.warn("Current node has no parent!");
+ }
+ }
+
+ /**
+ * 回到子节点 (若有)
+ */
+ canGoToSon() {
+ return this.currentNode && this.currentNode.children !== null;
+ }
+ goToSon() {
+ if (this.currentNode && this.currentNode.children) {
+ this.currentNode = this.currentNode.children;
+ console.log("this.currentNode.grid:", this.currentNode.grid);
+ userGrid.setGrid(this.currentNode.grid);
+ console.log(`Went back to children: ${this.currentNode.id}`);
+ this._updateStore(); // 更新 store
+ } else {
+ console.warn("Current node has no children!");
+ }
+ }
+
+ /**
+ * 演示：标记当前节点的某个猜测值为无效
+ * @param {number} value
+ */
+ markInvalidGuess(value) {
+ this.currentNode.invalidGuesses.add(value);
+ console.log(`Marked guess "${value}" as invalid in node ${this.currentNode.id}`);
+ }
+
+ isStackEmpty() {
+ const empty = this.nodeStack.length === 0;
+ return empty;
+ }
+
+ pushToStack() {
+ this.nodeStack.push(this.currentNode.id);
+ console.log(`Pushed node id "${this.currentNode.id}" to stack.`);
+ }
+
+ /**
+ * 从栈中弹出最顶端的 id 并跳转到对应的节点
+ */
+ popFromStack() {
+ if (this.nodeStack.length === 0) {
+ console.warn("Stack is empty. Cannot pop.");
+ return;
+ }
+ const nodeId = this.nodeStack.pop();
+ console.log(`Popped node id "${nodeId}" from stack.`);
+ this.jumpToNode(nodeId);
+ }
+
+}
+
+export const sudokutreemanager = new SudokuTreeManager();
diff --git a/src/node_modules/@sudoku/strategy/3DMedusaStrategy.js b/src/node_modules/@sudoku/strategy/3DMedusaStrategy.js
new file mode 100644
index 00000000..ae863125
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/3DMedusaStrategy.js
@@ -0,0 +1,732 @@
+import { Strategy } from '@sudoku/strategy/strategy.js';
+import {basicStragety} from '@sudoku/strategy/basicStrategy.js'
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+
+const BOX_SIZE = 3;
+const SUDOKU_SIZE = 9;
+
+export class ThreeDMedusaStrategy extends Strategy {
+ constructor() {
+ super(4, "3D Medusa"); // "3D Medusa"是策略名称
+ }
+
+ apply(sudoku) {
+ // 获取所有可能候选值
+ const [allCandidates, allReason] = basicStragety.apply(sudoku);
+ console.log("初始候选数：", JSON.stringify(allCandidates));
+
+ // 确定推理起始单元格
+ const [inirow1, inicol1, inirow2, inicol2, num] = this.findOptimalMedusaStartPoint(allCandidates);
+ //const [inirow1, inicol1, inirow2, inicol2, num] = [1,6,2,6,9]
+ console.log([inirow1, inicol1, inirow2, inicol2])
+
+ // 构建强链接和弱链接
+ const links = this.buildLinks(inirow1, inicol1, inirow2, inicol2, num, allCandidates);
+ console.log(links)
+ //console.log("构建的链接：", JSON.stringify(links));
+
+ // 应用3D Medusa规则
+ //this.applyMedusaRules(links, allCandidates, allReason);
+ //console.log("最终候选数：", JSON.stringify(allCandidates));
+ //return [allCandidates, allReason];
+ const [updatedCandidates, updatedReason] = this.applyMedusaRules(links, allCandidates, allReason);
+ console.log("最终候选数：", JSON.stringify(updatedCandidates));
+
+ return [updatedCandidates, updatedReason];
+ }
+
+
+ /**
+ * 寻找并返回一个适合作为美杜莎链起点的单元格对。
+ * @param {Array>>} allCandidates - 包含每个单元格候选数的二维数组。
+ * @returns {[number, number, number, number, number]} - 选中的起始单元格对的行和列索引及共享的候选数。
+ */
+ findIniUnit(allCandidates) {
+ const SUDOKU_SIZE = allCandidates.length;
+
+ // 遍历所有单元格，寻找包含两个候选数的单元格作为潜在的起始点
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if (allCandidates[row][col].length === 2) {
+ const [num1, num2] = allCandidates[row][col];
+
+ // 检查行、列和九宫格内是否有其他单元格也包含相同的候选数之一
+ // 行内查找
+ for (let c = 0; c < SUDOKU_SIZE; c++) {
+ if (c !== col && allCandidates[row][c].includes(num1)) {
+ return [row, col, row, c, num1];
+ }
+ if (c !== col && allCandidates[row][c].includes(num2)) {
+ return [row, col, row, c, num2];
+ }
+ }
+
+ // 列内查找
+ for (let r = 0; r < SUDOKU_SIZE; r++) {
+ if (r !== row && allCandidates[r][col].includes(num1)) {
+ return [row, col, r, col, num1];
+ }
+ if (r !== row && allCandidates[r][col].includes(num2)) {
+ return [row, col, r, col, num2];
+ }
+ }
+
+ // 九宫格内查找
+ const boxRowStart = Math.floor(row / 3) * 3;
+ const boxColStart = Math.floor(col / 3) * 3;
+ for (let r = 0; r < 3; r++) {
+ for (let c = 0; c < 3; c++) {
+ let br = boxRowStart + r;
+ let bc = boxColStart + c;
+ if (br !== row && bc !== col && allCandidates[br][bc].includes(num1)) {
+ return [row, col, br, bc, num1];
+ }
+ if (br !== row && bc !== col && allCandidates[br][bc].includes(num2)) {
+ return [row, col, br, bc, num2];
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // 如果没有找到合适的起始单元格对，则返回默认值
+ console.warn("未找到合适的起始单元格对");
+ return [-1, -1, -1, -1, -1];
+ }
+
+ /**
+ * 寻找并返回一个最适合作为美杜莎链起点的单元格对。以二值格、强链接数量作为筛选标准。
+ * @param {Array>>} allCandidates - 包含每个单元格候选数的二维数组。
+ * @returns {[number, number, number, number, number]} - 选中的起始单元格对的行和列索引及共享的候选数。
+ */
+ findOptimalMedusaStartPoint(allCandidates) {
+ // 辅助函数：检查是否为二值单元格
+ function isBivalueCell(candidates) {
+ return candidates.length === 2;
+ }
+
+ // 辅助函数：查找强链接（行、列或九宫格内某候选数仅出现两次）
+ function findStrongLinks(unit, num) {
+ let positions = [];
+ for (let i = 0; i < unit.length; i++) {
+ if (unit[i].includes(num)) {
+ positions.push(i);
+ }
+ }
+ return positions.length === 2 ? positions : null;
+ }
+
+ // 辅助函数：计算某个二值单元格的强链接条数
+ function countStrongLinks(row, col) {
+ let links = 0;
+ const [num1, num2] = allCandidates[row][col];
+
+ // 行内的强链接
+ [num1, num2].forEach(num => {
+ let positions = findStrongLinks(allCandidates[row], num);
+ if (positions && positions.length === 2) {
+ links++;
+ }
+ });
+
+ // 列内的强链接
+ [num1, num2].forEach(num => {
+ let positions = [];
+ for (let r = 0; r < SUDOKU_SIZE; r++) {
+ if (allCandidates[r][col].includes(num)) {
+ positions.push(r);
+ }
+ }
+ if (positions.length === 2) {
+ links++;
+ }
+ });
+
+ // 九宫格内的强链接
+ [num1, num2].forEach(num => {
+ let positions = [];
+ const boxRowStart = Math.floor(row / BOX_SIZE) * BOX_SIZE;
+ const boxColStart = Math.floor(col / BOX_SIZE) * BOX_SIZE;
+ for (let r = 0; r < BOX_SIZE; r++) {
+ for (let c = 0; c < BOX_SIZE; c++) {
+ let br = boxRowStart + r;
+ let bc = boxColStart + c;
+ if (allCandidates[br][bc].includes(num)) {
+ positions.push([br, bc]);
+ }
+ }
+ }
+ if (positions.length === 2) {
+ links++;
+ }
+ });
+
+ return links;
+ }
+
+ // 收集所有二值单元格及其强链接条数
+ let bivalueCells = [];
+
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if (isBivalueCell(allCandidates[row][col])) {
+ const strongLinksCount = countStrongLinks(row, col);
+ bivalueCells.push({ row, col, strongLinks: strongLinksCount });
+ }
+ }
+ }
+
+ // 根据强链接条数排序，选择最多的
+ bivalueCells.sort((a, b) => b.strongLinks - a.strongLinks);
+
+ // 如果没有找到二值单元格，返回null
+ if (bivalueCells.length === 0) {
+ return [-1,-1,-1,-1,-1];
+ }
+
+ // 获取强链接条数最多的二值单元格
+ const bestBivalueCell = bivalueCells[0];
+ const [num1, num2] = allCandidates[bestBivalueCell.row][bestBivalueCell.col];
+
+ // 返回最优起始点，格式化为 [row1, col1, row2, col2, sharedNum]
+ return [bestBivalueCell.row, bestBivalueCell.col, bestBivalueCell.row, bestBivalueCell.col, num1];
+ }
+
+ /**
+ * 构建美杜莎链，从给定的起始单元格对开始，使用迭代而非递归。
+ * @param {number} inirow1 - 第一个起始单元格的行索引。
+ * @param {number} inicol1 - 第一个起始单元格的列索引。
+ * @param {number} inirow2 - 第二个起始单元格的行索引。
+ * @param {number} inicol2 - 第二个起始单元格的列索引。
+ * @param {number} sharedNum - 两个起始单元格共享的候选数。
+ * @param {Array>>} allCandidates - 包含每个单元格候选数的二维数组。
+ * @returns {Object} - 包含所有链接的对象。
+ */
+ buildLinks(inirow1, inicol1, inirow2, inicol2, sharedNum, allCandidates) {
+ if (inirow1 === -1 || inicol1 === -1 || inirow2 === -1 || inicol2 === -1 || sharedNum === -1) {
+ return {}; // 如果没有找到合适的起点，则返回空链接对象
+ }
+
+ const links = {};
+ const colors = new Map(); // 使用Map来存储颜色分配
+ const RED = 'red';
+ const BLUE = 'blue';
+
+ // 初始化颜色：从起始单元格的共享候选数开始，分别设为红色和蓝色
+ colors.set(`${inirow1},${inicol1},${sharedNum}`, RED);
+ //colors.set(`${inirow2},${inicol2},${sharedNum}`, BLUE);
+
+ // 辅助函数：检查并添加链接
+ function addLink(row, col, num, color) {
+ const key = `${row},${col},${num}`;
+ if (!links[key] || links[key].color===null) {
+ links[key] = {
+ row: row,
+ col: col,
+ num: num,
+ color: color,
+ linkedTo: []
+ };
+ }
+ return links[key];
+ }
+
+ // 队列用于迭代处理单元格和数字对
+ const queue = [
+ { row: inirow1, col: inicol1, num: sharedNum, color: RED },
+ //{ row: inirow2, col: inicol2, num: sharedNum, color: BLUE }
+ ];
+
+ while (queue.length > 0) {
+ const { row, col, num, color } = queue.shift();
+ const oppositeColor = color === RED ? BLUE : RED;
+
+ // 添加当前链接
+ const currentLink = addLink(row, col, num, color);
+
+ // 强链接的搜索与添加
+ // 同一单元格
+ if (allCandidates[row][col].length === 2){
+ let nextnum = -1;
+ if (allCandidates[row][col][0] !== num){
+ nextnum = allCandidates[row][col][0];
+ }
+ else {
+ nextnum = allCandidates[row][col][1];
+ }
+ const nextCellKey = `${row},${col},${nextnum}`;
+ if (!colors.has(nextCellKey)) {
+ colors.set(nextCellKey, oppositeColor);
+ const nextLink = addLink(row, col, nextnum, oppositeColor);
+ currentLink.linkedTo.push(nextLink);
+ queue.push({ row: row, col: col, num: nextnum, color: oppositeColor });
+ }
+ }
+ // 查找行、列、九宫格内的其他位置
+ let count = 1; //同一单元中值为num的候选值的个数，恰好为2时才是强链接
+ let nextrow = -1; let nextcol = -1;
+ let nextCellKey = `${-1},${-1},${-1}`;
+ // 行
+ nextrow = row;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== col && allCandidates[row][i].includes(num)) {
+ count = count + 1;
+ nextcol = i;
+ }
+ }
+ if (count === 2){
+ nextCellKey = `${nextrow},${nextcol},${num}`;
+ if (!colors.has(nextCellKey)) {
+ colors.set(nextCellKey, oppositeColor);
+ const nextLink = addLink(nextrow, nextcol, num, oppositeColor);
+ currentLink.linkedTo.push(nextLink);
+ queue.push({ row: nextrow, col: nextcol, num: num, color: oppositeColor });
+ }
+ }
+ // 列
+ count = 1;
+ nextcol = col;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== row && allCandidates[i][col].includes(num)) {
+ count = count + 1;
+ nextrow = i;
+ }
+ }
+ if (count === 2){
+ nextCellKey = `${nextrow},${nextcol},${num}`;
+ if (!colors.has(nextCellKey)) {
+ colors.set(nextCellKey, oppositeColor);
+ const nextLink = addLink(nextrow, nextcol, num, oppositeColor);
+ currentLink.linkedTo.push(nextLink);
+ queue.push({ row: nextrow, col: nextcol, num: num, color: oppositeColor });
+ }
+ }
+ // 九宫格
+ count = 1;
+ const boxRowStart = Math.floor(row / BOX_SIZE) * BOX_SIZE;
+ const boxColStart = Math.floor(col / BOX_SIZE) * BOX_SIZE;
+ for (let r = 0; r < BOX_SIZE; r++) {
+ for (let c = 0; c < BOX_SIZE; c++) {
+ let br = boxRowStart + r;
+ let bc = boxColStart + c;
+ if ((br !== row || bc !== col) && allCandidates[br][bc].includes(num)) {
+ count = count + 1;
+ nextrow = br;
+ nextcol = bc;
+ }
+ }
+ }
+ if (count === 2){
+ nextCellKey = `${nextrow},${nextcol},${num}`;
+ if (!colors.has(nextCellKey)) {
+ colors.set(nextCellKey, oppositeColor);
+ const nextLink = addLink(nextrow, nextcol, num, oppositeColor);
+ currentLink.linkedTo.push(nextLink);
+ queue.push({ row: nextrow, col: nextcol, num: num, color: oppositeColor });
+ }
+ }
+
+ // 检查当前单元格内的其他候选数（弱链接）
+ for (let otherNum of allCandidates[row][col]) {
+ if (otherNum !== num) {
+ const weakLinkKey = `${row},${col},${otherNum}`;
+ if (!links[weakLinkKey]) {
+ links[weakLinkKey] = {
+ row: row,
+ col: col,
+ num: otherNum,
+ color: null, // 弱链接不分配颜色
+ linkedTo: []
+ };
+ }
+ }
+ }
+ }
+
+ return links;
+ }
+
+ /**
+ * 应用3D Medusa规则更新候选数。
+ * @param {Object} links - 包含所有链接的对象。
+ * @param {Array>>} allCandidates - 包含每个单元格候选数的二维数组。
+ * @param {Array} allReason - 解题过程的理由记录。
+ * @returns {[Array>>, Array]} - 更新后的候选数列表和解题理由。
+ */
+ applyMedusaRules(links, allCandidates, allReason) {
+ const RED = 'red';
+ const BLUE = 'blue';
+
+ // 用于记录逻辑链的日志对象
+ let chainLog = [];
+
+ // 辅助函数：记录逻辑链
+ function logChainAction(action, details) {
+ chainLog.push({ action, details });
+ }
+
+ // 规则1: 单元格中有两个相同颜色的候选值
+ function ruleOne() {
+ for (const key in links) {
+ const link = links[key];
+ if (link.color) {
+ const otherCandidateKeys = allCandidates[link.row][link.col].map(num => `${link.row},${link.col},${num}`).filter(k => k !== key);
+ for (let otherKey of otherCandidateKeys) {
+ const otherLink = links[otherKey];
+ if (otherLink && otherLink.color === link.color) {
+ console.log(`规则1: 在(${link.row},${link.col})发现两个${link.color}颜色的候选数`);
+ return link.color;
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ // 规则2: 同一行/列/九宫格中的两个相同候选值具有相同的颜色
+ function ruleTwo() {
+ const seenColors = new Map();
+
+ for (const key in links) {
+ const link = links[key];
+ if (link.color) {
+ // 分别处理行、列和九宫格
+ const [rowColor, colColor, boxColor] = checkUnitColors(link.row, link.col, link.num, link.color);
+
+ // 如果任意一个单元中发现了相同的颜色，则返回该颜色作为矛盾颜色
+ if (rowColor || colColor || boxColor) {
+ console.log(`规则2: 在${rowColor ? '行' : ''}${colColor ? '列' : ''}${boxColor ? '九宫格' : ''}发现两个${link.color}颜色的候选数`);
+ return link.color;
+ }
+ }
+ }
+ return null;
+ }
+
+ // 检查行、列、九宫格内的颜色冲突
+ function checkUnitColors(row, col, num, color) {
+ let rowColor = false;
+ let colColor = false;
+ let boxColor = false;
+
+ // 行内查找
+ for (let c = 0; c < SUDOKU_SIZE; c++) {
+ if (c !== col && links[`${row},${c},${num}`]?.color === color) {
+ rowColor = true;
+ break;
+ }
+ }
+
+ // 列内查找
+ for (let r = 0; r < SUDOKU_SIZE; r++) {
+ if (r !== row && links[`${r},${col},${num}`]?.color === color) {
+ colColor = true;
+ break;
+ }
+ }
+
+ // 九宫格内查找
+ const boxRowStart = Math.floor(row / BOX_SIZE) * BOX_SIZE;
+ const boxColStart = Math.floor(col / BOX_SIZE) * BOX_SIZE;
+ for (let r = 0; r < BOX_SIZE; r++) {
+ for (let c = 0; c < BOX_SIZE; c++) {
+ let br = boxRowStart + r;
+ let bc = boxColStart + c;
+ if ((br !== row || bc !== col) && links[`${br},${bc},${num}`]?.color === color) {
+ boxColor = true;
+ break;
+ }
+ }
+ if (boxColor) break;
+ }
+
+ return [rowColor, colColor, boxColor];
+ }
+
+ // 获取同一行、列或九宫格的所有键
+ function getUnitKeys(row, col, num) {
+ const rowKeys = [];
+ const colKeys = [];
+ const boxKeys = [];
+
+ // 行内查找
+ for (let c = 0; c < SUDOKU_SIZE; c++) {
+ rowKeys.push(`${row},${c},${num}`);
+ }
+
+ // 列内查找
+ for (let r = 0; r < SUDOKU_SIZE; r++) {
+ colKeys.push(`${r},${col},${num}`);
+ }
+
+ // 九宫格内查找
+ const boxRowStart = Math.floor(row / BOX_SIZE) * BOX_SIZE;
+ const boxColStart = Math.floor(col / BOX_SIZE) * BOX_SIZE;
+ for (let r = 0; r < BOX_SIZE; r++) {
+ for (let c = 0; c < BOX_SIZE; c++) {
+ let br = boxRowStart + r;
+ let bc = boxColStart + c;
+ boxKeys.push(`${br},${bc},${num}`);
+ }
+ }
+
+ return [...new Set([...rowKeys, ...colKeys, ...boxKeys])];
+ }
+
+ // 规则3: 单元格中有两种颜色的候选值和其他候选值
+ function ruleThree() {
+ for (const key in links) {
+ const link = links[key];
+ if (link.color) {
+ const cellLinks = Object.values(links).filter(l => l.row === link.row && l.col === link.col && l.color);
+ const colorsInCell = new Set(cellLinks.map(l => l.color));
+ if (colorsInCell.size === 2) {
+ const [color1, color2] = colorsInCell;
+ const oppositeColor = color1 === RED ? BLUE : RED;
+
+ // 移除其他颜色的候选数
+ allCandidates[link.row][link.col] = allCandidates[link.row][link.col].filter(num => {
+ const candidateKey = `${link.row},${link.col},${num}`;
+ const candidateLink = links[candidateKey];
+ return !candidateLink || candidateLink.color === color1 || candidateLink.color === color2;
+ });
+
+ // 记录解题理由
+ allReason[link.row][link.col] = `3DMedusa 移除 (${link.row},${link.col}) 中非 ${color1}/${color2} 颜色的候选数`
+ console.log(`移除 (${link.row},${link.col}) 中非 ${color1}/${color2} 颜色的候选数`);
+
+ // 记录逻辑链
+ logChainAction('remove', {
+ position: [link.row, link.col],
+ reason: `因为存在两种颜色 ${color1} 和 ${color2}`
+ });
+ }
+ }
+ }
+ }
+
+ // 规则4: 某单元格中的某候选值，在它所在的行/列/九宫格中找到两种颜色的相同候选值
+ function ruleFour() {
+ for (const key in links) {
+ const link = links[key];
+ if (!link.color) { // 只考虑未着色的链接
+ const unitKeys = getUnitKeys(link.row, link.col, link.num);
+
+ // 获取单元内所有已着色且候选值相同的链接的颜色
+ const colorsInUnit = new Set(
+ Object.values(links)
+ .filter(l =>
+ l.color && // 已着色
+ unitKeys.includes(`${l.row},${l.col},${l.num}`) && // 在同一单元内
+ l.num === link.num // 候选值相同
+ )
+ .map(l => l.color)
+ );
+
+ if (colorsInUnit.size === 2) { // 如果在单元内找到了两种颜色的相同候选值
+ allCandidates[link.row][link.col] = allCandidates[link.row][link.col].filter(num => num !== link.num);
+
+ // 记录解题理由
+ allReason[link.row][link.col] = `3DMedusa 移除 (${link.row},${link.col}) 中的 ${link.num} 因为在其所在单元找到了两种颜色的相同候选值`;
+ console.log(`移除 (${link.row},${link.col}) 中的 ${link.num} 因为在其所在单元找到了两种颜色的相同候选值`);
+
+ // 记录逻辑链
+ logChainAction('remove', {
+ num: link.num,
+ position: [link.row, link.col],
+ reason: `因为在所在单元找到了两种颜色的相同候选值`
+ });
+ }
+ }
+ }
+ }
+
+ // 规则5: 未着色的候选值可以在其他地方看到一个有色的候选值（共享行/列/九宫格），而在自己的单元格中可以看到相反的有色候选值
+ function ruleFive() {
+ for (const key in links) {
+ const link = links[key];
+ if (!link.color) {
+ const unitKeys = getUnitKeys(link.row, link.col, link.num);
+ const sameUnitLinks = Object.values(links).filter(l => unitKeys.includes(`${l.row},${l.col},${l.num}`));
+
+ const coloredLinks = sameUnitLinks.filter(l => l.color);
+ if (coloredLinks.length > 0) {
+ const oppositeColor = coloredLinks.some(l => l.color === RED) ? BLUE : RED;
+ const oppositeLinkInCell = Object.values(links).find(l => l.row === link.row && l.col === link.col && l.color === oppositeColor);
+
+ if (oppositeLinkInCell) {
+ allCandidates[link.row][link.col] = allCandidates[link.row][link.col].filter(num => num !== link.num);
+
+ // 记录解题理由
+ allReason[link.row][link.col] = `3DMedusa 移除 (${link.row},${link.col}) 中的 ${link.num} 因为在同一单元看到了相反颜色 ${oppositeColor}`
+ console.log(`移除 (${link.row},${link.col}) 中的 ${link.num} 因为在同一单元看到了相反颜色 ${oppositeColor}`);
+
+ // 记录逻辑链
+ logChainAction('remove', {
+ num: link.num,
+ position: [link.row, link.col],
+ reason: `因为在同一单元看到了相反颜色 ${oppositeColor}`
+ });
+ }
+ }
+ }
+ }
+ }
+
+ // 规则6: 找到一个所有候选值都未着色的单元格,所有未着色的候选值都能看到相同颜色的对应候选值，则可以推断出另一颜色是正确的。
+ function ruleSix() {
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if (allCandidates[row][col].length > 1) {
+ const uncoloredCandidates = allCandidates[row][col].filter(num => !links[`${row},${col},${num}`] || !links[`${row},${col},${num}`].color);
+
+ if (uncoloredCandidates.length === allCandidates[row][col].length) {
+ // 检查每个未着色候选值是否能看到相同颜色的对应候选值
+ const colorMap = new Map();
+ for (const num of uncoloredCandidates) {
+ const unitKeys = getUnitKeys(row, col, num);
+ const seenColors = new Set(unitKeys.map(key => links[key]?.color).filter(color => color));
+
+ if (seenColors.size === 1) {
+ const [color] = seenColors;
+ colorMap.set(num, color);
+ } else {
+ break;
+ }
+ }
+
+ // 如果所有候选值都能看到相同颜色的对应候选值
+ if (colorMap.size === uncoloredCandidates.length) {
+ const oppositeColor = [...new Set([RED, BLUE])].find(color => ![...colorMap.values()].includes(color));
+
+ // 确定该单元格的唯一解决方案
+ const solutionNum = uncoloredCandidates.find(num => colorMap.get(num) !== oppositeColor);
+ allCandidates[row][col] = [solutionNum];
+
+ // 记录解题理由
+ allReason[link.row][link.col] = `确认 (${row},${col}) 的唯一解为 ${solutionNum} 因为其他颜色都看到了 ${oppositeColor}`
+ //allReason.push(`确认 (${row},${col}) 的唯一解为 ${solutionNum} 因为其他颜色都看到了 ${oppositeColor}`);
+
+ // 记录逻辑链
+ logChainAction('confirm', {
+ num: solutionNum,
+ position: [row, col],
+ reason: `因为其他颜色都看到了 ${oppositeColor}`
+ });
+
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ // 应用规则
+ function applyRules() {
+ let contradictoryColor = ruleOne();
+ if (contradictoryColor) {
+ updateCandidatesBasedOnContradiction(contradictoryColor, links, allCandidates, allReason);
+ }
+
+ contradictoryColor = ruleTwo();
+ if (contradictoryColor) {
+ updateCandidatesBasedOnContradiction(contradictoryColor, links, allCandidates, allReason);
+ }
+
+ ruleThree();
+ ruleFour();
+ //ruleFive();
+ //ruleSix();
+ }
+
+ // 根据找到的矛盾更新候选数
+ function updateCandidatesBasedOnContradiction(contradictoryColor, links, allCandidates, allReason) {
+ for (const key in links) {
+ const link = links[key];
+ if (link.color === contradictoryColor) {
+ allCandidates[link.row][link.col] = allCandidates[link.row][link.col].filter(num => num !== link.num);
+
+ // 记录解题理由
+ allReason[link.row][link.col] = `3DMedusa 移除 ${link.num} 在 (${link.row},${link.col}) 因为找到了${contradictoryColor}颜色的矛盾`
+ console.log(`移除 ${link.num} 在 (${link.row},${link.col}) 因为找到了${contradictoryColor}颜色的矛盾`);
+
+ // 记录逻辑链
+ logChainAction('remove', {
+ num: link.num,
+ position: [link.row, link.col],
+ reason: `因为找到了${contradictoryColor}颜色的矛盾`
+ });
+ }
+ }
+ }
+
+ // 执行规则
+ applyRules();
+
+ // 打印推理逻辑链
+ //console.log("最终确定唯一候选值的逻辑链：", JSON.stringify(chainLog, null, 2));
+
+ // 返回更新后的候选数列表和解题理由
+ return [allCandidates, allReason];
+ }
+}
+
+export const threeDMedusaStrategy = new ThreeDMedusaStrategy();
+
+/*
+// 调试信息
+let sudoku = [
+ [0, 0, 0, 3, 0, 0, 0, 8, 0],
+ [5, 0, 0, 0, 0, 1, 0, 0, 3],
+ [8, 0, 6, 0, 4, 0, 0, 0, 0],
+ [4, 0, 0, 8, 3, 0, 0, 0, 2],
+ [0, 0, 2, 0, 0, 0, 3, 0, 0],
+ [9, 0, 0, 0, 7, 2, 0, 0, 1],
+ [0, 0, 0, 0, 6, 0, 1, 0, 7],
+ [7, 0, 0, 1, 0, 0, 0, 0, 4],
+ [0, 9, 0, 0, 0, 5, 0, 0, 0],
+];
+
+let sudoku1 = [
+ [0, 9, 3, 8, 2, 4, 5, 6, 0],
+ [0, 8, 5, 6, 0, 0, 0, 0, 2],
+ [2, 0, 6, 0, 7, 5, 0, 0, 8],
+ [3, 2, 1, 7, 6, 9, 8, 4, 5],
+ [0, 0, 0, 2, 5, 8, 3, 0, 0],
+ [5, 7, 8, 0, 4, 0, 2, 9, 6],
+ [8, 5, 0, 0, 1, 6, 7, 2, 3],
+ [0, 0, 7, 0, 8, 2, 6, 5, 0],
+ [0, 0, 2, 5, 0, 7, 1, 8, 0],
+];
+
+let sudoku2 = [
+ [0, 9, 3, 8, 2, 4, 5, 6, 0],
+ [0, 8, 5, 6, 3, 0, 9, 0, 2],
+ [2, 1, 6, 0, 7, 5, 4, 0, 8],
+ [3, 2, 1, 7, 6, 9, 8, 4, 5],
+ [0, 0, 0, 2, 5, 8, 3, 0, 0],
+ [5, 7, 8, 0, 4, 0, 2, 9, 6],
+ [8, 5, 0, 0, 1, 6, 7, 2, 3],
+ [0, 4, 7, 0, 8, 2, 6, 5, 0],
+ [0, 0, 2, 5, 9, 7, 1, 8, 0],
+];
+
+let sudoku3 = [
+ [7, 9, 3, 8, 2, 4, 5, 6, 1],
+ [4, 8, 5, 6, 3, 1, 9, 7, 2],
+ [2, 1, 6, 9, 7, 5, 4, 3, 8],
+ [3, 2, 1, 7, 6, 9, 8, 4, 5],
+ [9, 6, 4, 2, 5, 8, 3, 1, 7],
+ [5, 7, 8, 1, 4, 3, 2, 9, 6],
+ [8, 5, 9, 4, 1, 6, 7, 2, 3],
+ [1, 4, 7, 3, 8, 2, 6, 5, 9],
+ [6, 3, 2, 5, 9, 7, 1, 8, 4],
+];
+
+const [allCandidates, allReason] = threeDMedusaStrategy.apply(sudoku3);
+console.log(allCandidates)
+//console.log(allReason)
+*/
\ No newline at end of file
diff --git a/src/node_modules/@sudoku/strategy/basicStrategy.js b/src/node_modules/@sudoku/strategy/basicStrategy.js
new file mode 100644
index 00000000..888bb111
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/basicStrategy.js
@@ -0,0 +1,237 @@
+//import { get_all_dirty_from_scope } from 'svelte/internal';
+import { Strategy } from './strategy.js';
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+
+
+
+
+const BOX_SIZE = 3;
+const SUDOKU_SIZE = 9;
+
+
+
+export class BasicStrategy extends Strategy {
+ constructor() {
+ super(0,"Basic Strategy");
+ }
+
+
+ apply(sudoku) {
+ const allCandidates = Array.from({ length: SUDOKU_SIZE }, () => Array(SUDOKU_SIZE).fill([]));
+ const allReason = Array.from({ length: SUDOKU_SIZE }, () => Array(SUDOKU_SIZE).fill([]));
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let column = 0; column < SUDOKU_SIZE; column++) {
+ if (sudoku[row][column] === 0) { // 检查单元格是否为空
+ const candidates = this.getCandidateNumber(sudoku, row, column);
+ allCandidates[row][column] = candidates; // 直接赋值，而不是 push
+ allReason[row][column] = allReason[row][column].concat(['Basic SUDOKU rules.']).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ }
+ }
+ }
+ // clue是线索，是文本list的形式
+ return [allCandidates, allReason];
+ }
+
+
+
+ getRow(sudoku, row) {
+ let nonZeroNumber = [];
+ for(let column = 0; column < SUDOKU_SIZE; column++) {
+ if (sudoku[row][column] !== 0) {
+ nonZeroNumber.push(sudoku[row][column]);
+ }
+ }
+ return nonZeroNumber;
+ }
+
+
+ getColumn(sudoku, column) {
+ let nonZeroNumbers = [];
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ if (sudoku[row][column] !== 0) {
+ nonZeroNumbers.push(sudoku[row][column]);
+ }
+ }
+ return nonZeroNumbers;
+ }
+
+
+ getBox(sudoku, row, column) {
+ let nonZeroNumbers = [];
+ const boxStartRow = Math.floor(row / BOX_SIZE) * BOX_SIZE;
+ const boxStartColumn = Math.floor(column / BOX_SIZE) * BOX_SIZE;
+ for (let i = 0; i < BOX_SIZE; i++) {
+ for (let j = 0; j < BOX_SIZE; j++) {
+ if (sudoku[boxStartRow + i][boxStartColumn + j] !== 0) {
+ nonZeroNumbers.push(sudoku[boxStartRow + i][boxStartColumn + j]);
+ }
+ }
+ }
+ return nonZeroNumbers;
+ }
+
+
+ isValid(sudoku, number, row, column) {
+ // 获取行中的非零数字
+ const rowNumbers = this.getRow(sudoku, row);
+ // 获取列中的非零数字
+ const columnNumbers = this.getColumn(sudoku, column);
+ // 获取九宫格中的非零数字
+ const boxNumbers = this.getBox(sudoku, row, column);
+
+ // 检查number是否在行、列或九宫格中的任何一个数组中
+ return (rowNumbers.indexOf(number) === -1 &&
+ columnNumbers.indexOf(number) === -1 &&
+ boxNumbers.indexOf(number) === -1);
+ }
+
+
+ getCandidateNumber(sudoku, row, column) {
+ const candidates = [];
+ // 遍历所有可能的数字
+ for (let number = 1; number <= SUDOKU_SIZE; number++) {
+ // 检查该数字是否在指定位置有效
+ if (this.isValid(sudoku, number, row, column)) {
+ candidates.push(number);
+ }
+ }
+ return candidates;
+ }
+
+
+
+ // 对于一行内除了特定位置position_list外消除特定的候选值candidate_list
+ removeInRow(allCandidates, allReason, position_list, candidate_list, row, strategy_name) {
+ for (let col = 0; col < SUDOKU_SIZE; col ++) {
+ if(!this.isPositionInList([row, col], position_list)) {
+ // 仅仅保留不在candidate_list内的候选数字
+ allCandidates[row][col] = allCandidates[row][col].filter(element => !candidate_list.includes(element));
+ allReason[row][col] = allReason[row][col].concat([`因为策略${strategy_name}, 候选值${candidate_list}被删除`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ }
+ }
+ }
+
+
+
+ // 对于一列内除了特定位置position_list外消除特定的候选值candidate_list
+ removeInCol(allCandidates, allReason, position_list, candidate_list, col, strategy_name) {
+ for (let row = 0; row < SUDOKU_SIZE; row ++) {
+ if(!this.isPositionInList([row, col], position_list)) {
+ // 仅仅保留不在candidate_list内的候选数字
+ allCandidates[row][col] = allCandidates[row][col].filter(element => !candidate_list.includes(element));
+ allReason[row][col] = allReason[row][col].concat([`因为策略${strategy_name}, 候选值${candidate_list}被删除`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ }
+ }
+ }
+
+
+ // 对于一个九宫格内除了特定位置position_list外消除特定的候选值candidate_list
+ removeInBox(allCandidates, allReason, position_list, candidate_list, boxRow, boxCol, strategy_name) {
+ for (let boxIndex = 0; boxIndex < BOX_SIZE*BOX_SIZE; boxIndex ++) {
+ const row = boxRow*BOX_SIZE + Math.floor(boxIndex / BOX_SIZE);
+ const col = boxCol*BOX_SIZE + boxIndex % BOX_SIZE;
+ if(!this.isPositionInList([row, col], position_list)) {
+ // 仅仅保留不在candidate_list内的候选数字
+ allCandidates[row][col] = allCandidates[row][col].filter(element => !candidate_list.includes(element));
+ allReason[row][col] = allReason[row][col].concat([`因为策略${strategy_name}, 候选值${candidate_list}被删除`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ }
+ }
+ }
+
+
+ // 用于解决position位置是否在位置列表position_list中作为其中一个元素
+ isPositionInList(position, position_list) {
+ return position_list.some(subArray =>
+ position.length === subArray.length &&
+ position.every((element, index) => element === subArray[index])
+ );
+ }
+
+
+ isSameRow(position_list) {
+ if(position_list.length < 2) {
+ return false;
+ }
+ const row = position_list[0][0];
+ for (let i = 1; i < position_list.legth; i++) {
+ if(position_list[i][0] !== row) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+
+ isSameCol(position_list) {
+ if(position_list.length < 2) {
+ return false;
+ }
+ const col = position_list[0][1];
+ for (let i = 1; i < position_list.legth; i++) {
+ if(position_list[i][1] !== col) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+
+
+ isSameBox(position_list) {
+ if(position_list.length < 2) {
+ return false;
+ }
+ let boxRow = [];
+ let boxCol = [];
+ for (let i = 0; i < position_list.length; i++) {
+ boxRow.push(Math.floor(position_list[i][0] / BOX_SIZE) * BOX_SIZE);
+ boxCol.push(Math.floor(position_list[i][1] / BOX_SIZE) * BOX_SIZE);
+ }
+ for (let i = 0; i < position_list.length; i++) {
+ if (boxRow[i] !== boxRow[0] || boxCol[i] !== boxCol[0]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+
+
+ getAmountCandidate(allCandidates) {
+ let amount = Array.from({ length: SUDOKU_SIZE }, () => Array(SUDOKU_SIZE).fill(null));
+ for (let row = 0; row < SUDOKU_SIZE; row ++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ amount[row][col] = allCandidates[row][col].length;
+ }
+ }
+ return amount;
+ }
+
+
+ isSameAmount(oldAmount, newAmount) {
+ for (let row = 0; row < SUDOKU_SIZE; row ++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if(oldAmount[row][col] !== newAmount[row][col]) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+
+}
+
+
+export const basicStragety = new BasicStrategy()
+
+
+
+
diff --git a/src/node_modules/@sudoku/strategy/hiddenPair.js b/src/node_modules/@sudoku/strategy/hiddenPair.js
new file mode 100644
index 00000000..5564a153
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/hiddenPair.js
@@ -0,0 +1,202 @@
+import { Strategy } from '@sudoku/strategy/strategy.js';
+import {basicStragety} from '@sudoku/strategy/basicStrategy.js'
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+
+
+const BOX_SIZE = 3;
+const SUDOKU_SIZE = 9;
+
+
+
+export class HiddenPairStrategy extends Strategy{
+ constructor() {
+ super(3, "Hidden Pair");
+ }
+
+ apply(sudoku) {
+ const [allCandidates, allReason] = basicStragety.apply(sudoku);
+ let change = true;
+ while(change) {
+ let oldAmount = basicStragety.getAmountCandidate(allCandidates);
+ // 检查行
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ this.findHiddenPairInRow(allCandidates, row, allReason);
+ }
+ // 检查列
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ this.findHiddenPairInCol(allCandidates, col, allReason);
+ }
+ // 检查九宫格
+ for (let boxRow = 0; boxRow < SUDOKU_SIZE/BOX_SIZE; boxRow++) {
+ for (let boxCol = 0; boxCol < SUDOKU_SIZE/BOX_SIZE; boxCol++) {
+ this.findHiddenPairInBox(allCandidates, boxRow, boxCol, allReason);
+ }
+ }
+ let newAmount = basicStragety.getAmountCandidate(allCandidates);
+ change = !basicStragety.isSameAmount(oldAmount, newAmount);
+ }
+ return [allCandidates, allReason];
+ }
+
+
+
+ // 寻找同一行的hidden pair
+ findHiddenPairInRow(allCandidates, row, allReason) {
+ const candidateCounts = Array.from({ length: SUDOKU_SIZE + 1 }, () => new Set());
+ // 统计每个数字在行中的出现位置
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ allCandidates[row][col].forEach(num => candidateCounts[num].add(col));
+ }
+ // 查找只在两个单元格中出现的数字对
+ for (let num1 = 1; num1 <= SUDOKU_SIZE; num1++) {
+ for (let num2 = num1 + 1; num2 <= SUDOKU_SIZE; num2++){
+ const combineSet = new Set([...candidateCounts[num1], ...candidateCounts[num2]]);
+ // 如果只有两个位置存在这两个候选值，就构成hidden pair
+ //if (combineSet.size === 2 && candidateCounts[num1].size >= 1 && candidateCounts[num2].size >= 1) {
+
+ if (combineSet.size === 2 && candidateCounts[num1].size === 2 && candidateCounts[num2].size === 2) {
+ // 将者两个位置赋值为nake pair，清除其他无关候选值
+ const combineList = [...combineSet];
+ allCandidates[row][combineList[0]] = allCandidates[row][combineList[0]].filter(element => element === num1 || element === num2);
+ allCandidates[row][combineList[1]] = allCandidates[row][combineList[1]].filter(element => element === num1 || element === num2);
+ allReason[row][combineList[0]] = allReason[row][combineList[0]].concat([`[${row}, ${combineList[0]}] 和 [${row}, ${combineList[1]}] 是一对行Hidden Pair, 只保留候选值${allCandidates[row][combineList[0]]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[row][combineList[0]] = [...new Set(allReason[row][combineList[0]])];
+ allReason[row][combineList[1]] = allReason[row][combineList[1]].concat([`[${row}, ${combineList[0]}] 和 [${row}, ${combineList[1]}] 是一对行Hidden Pair, 只保留候选值${allCandidates[row][combineList[1]]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[row][combineList[1]] = [...new Set(allReason[row][combineList[1]])];
+ // 将同一行的无关元素全部清除
+ basicStragety.removeInRow(allCandidates, allReason, [[row, combineList[0]], [row, combineList[1]]],
+ [num1, num2], row, this.description);
+ // 如果同时满足在同一个九宫格，同时消除九宫格里面的数字
+ if (basicStragety.isSameBox([[row, combineList[0]], [row, combineList[1]]])) {
+ basicStragety.removeInBox(allCandidates, allReason, [[row, combineList[0]], [row, combineList[1]]],
+ [num1, num2], Math.floor(row / BOX_SIZE), Math.floor(combineList[0] / BOX_SIZE), this.description);
+ }
+ }
+ }
+ }
+ }
+
+
+
+ // 寻找同一列的hidden pair
+ findHiddenPairInCol(allCandidates, col, allReason) {
+ const candidateCounts = Array.from({ length: SUDOKU_SIZE + 1 }, () => new Set());
+ // 统计每个数字在行中的出现位置
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ allCandidates[row][col].forEach(num => candidateCounts[num].add(row));
+ }
+ // 查找只在两个单元格中出现的数字对
+ for (let num1 = 1; num1 <= SUDOKU_SIZE; num1++) {
+ for (let num2 = num1 + 1; num2 <= SUDOKU_SIZE; num2++){
+ const combineSet = new Set([...candidateCounts[num1], ...candidateCounts[num2]]);
+ // 如果只有两个位置存在这两个候选值，就构成hidden pair
+ //if (combineSet.size === 2 && candidateCounts[num1].size >= 1 && candidateCounts[num2].size >= 1) {
+ if (combineSet.size === 2 && candidateCounts[num1].size === 2 && candidateCounts[num2].size === 2) {
+ // 将者两个位置赋值为nake pair，清除其他无关候选值
+ const combineList = [...combineSet];
+ allCandidates[combineList[0]][col] = allCandidates[combineList[0]][col].filter(element => element === num1 || element === num2);
+ allCandidates[combineList[1]][col] = allCandidates[combineList[1]][col].filter(element => element === num1 || element === num2);
+ allReason[combineList[0]][col] = allReason[combineList[0]][col].concat([`[${combineList[0]}, ${col}] 和 [${combineList[1]}, ${col}] 是一对列Hidden Pair, 只保留候选值${allCandidates[combineList[0]][col]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[combineList[0]][col] = [...new Set(allReason[combineList[0]][col])];
+ allReason[combineList[1]][col] = allReason[combineList[1]][col].concat([`[${combineList[0]}, ${col}] 和 [${combineList[1]}, ${col}] 是一对列Hidden Pair, 只保留候选值${allCandidates[combineList[1]][col]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[combineList[1]][col] = [...new Set(allReason[combineList[1]][col])];
+ // 将同一列的无关元素全部清除
+ basicStragety.removeInCol(allCandidates, allReason, [[combineList[0], col], [combineList[1], col]],
+ [num1, num2], col, this.description);
+ // 如果同时满足在同一个九宫格，同时消除九宫格里面的数字
+ if (basicStragety.isSameBox([[combineList[0], col], [combineList[1], col]])) {
+ basicStragety.removeInBox(allCandidates, allReason, [[combineList[0], col], [combineList[1], col]],
+ [num1, num2], Math.floor(combineList[0] / BOX_SIZE), Math.floor(col / BOX_SIZE), this.description);
+ }
+ }
+ }
+ }
+
+ }
+
+
+
+ // 寻找同一个九宫格的hidden pair
+ findHiddenPairInBox(allCandidates, boxRow, boxCol, allReason) {
+ const candidateCounts = Array.from({ length: SUDOKU_SIZE + 1 }, () => new Set());
+ // 统计每个数字在行中的出现位置
+ for (let boxIndex = 0; boxIndex < BOX_SIZE*BOX_SIZE; boxIndex ++) {
+ let row = boxRow*BOX_SIZE + Math.floor(boxIndex / BOX_SIZE);
+ let col = boxCol*BOX_SIZE + boxIndex % BOX_SIZE;
+ allCandidates[row][col].forEach(num => candidateCounts[num].add([row, col]));
+ }
+ // 查找只在两个单元格中出现的数字对
+ for (let num1 = 1; num1 <= SUDOKU_SIZE; num1++) {
+ for (let num2 = num1 + 1; num2 <= SUDOKU_SIZE; num2++){
+ const combineSet = new Set([...candidateCounts[num1], ...candidateCounts[num2]]);
+ // 如果只有两个位置存在这两个候选值，就构成hidden pair
+ //if (combineSet.size === 2 && candidateCounts[num1].size >= 1 && candidateCounts[num2].size >= 1) {
+ if (combineSet.size === 2 && candidateCounts[num1].size === 2 && candidateCounts[num2].size === 2) {
+ // 将者两个位置赋值为nake pair，清除其他无关候选值
+ const combineList = [...combineSet];
+ allCandidates[combineList[0][0]][combineList[0][1]] = allCandidates[combineList[0][0]][combineList[0][1]].filter(element => element === num1 || element === num2);
+ allCandidates[combineList[1][0]][combineList[1][1]] = allCandidates[combineList[1][0]][combineList[1][1]].filter(element => element === num1 || element === num2);
+ allReason[combineList[0][0]][combineList[0][1]] = allReason[combineList[0][0]][combineList[0][1]].concat([`[${combineList[0][0]}, ${combineList[0][1]}] 和 [${combineList[1][0]}, ${combineList[1][1]}] 是一对宫Hidden Pair, 只保留候选值${allCandidates[combineList[0][0]][combineList[0][1]]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[combineList[0][0]][combineList[0][1]] = [...new Set(allReason[combineList[0][0]][combineList[0][1]])];
+ allReason[combineList[1][0]][combineList[1][1]] = allReason[combineList[1][0]][combineList[1][1]].concat([`[${combineList[0][0]}, ${combineList[0][1]}] 和 [${combineList[1][0]}, ${combineList[1][1]}] 是一对宫Hidden Pair, 只保留候选值${allCandidates[combineList[1][0]][combineList[1][1]]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[combineList[1][0]][combineList[1][1]]= [...new Set(allReason[combineList[1][0]][combineList[1][1]])];
+ // 将同一九宫格的无关元素全部清除
+ basicStragety.removeInBox(allCandidates, allReason, [[combineList[0][0],combineList[0][1]], [combineList[1][0], combineList[1][1]]],
+ [num1, num2], boxRow, boxCol, this.description);
+ // 如果同时满足在同一个行，同时消除这一行里面的数字
+ if (basicStragety.isSameRow([[combineList[0][0],combineList[0][1]], [combineList[1][0], combineList[1][1]]])) {
+ basicStragety.removeInRow(allCandidates, allReason, [[combineList[0][0],combineList[0][1]], [combineList[1][0], combineList[1][1]]],
+ [num1, num2], combineList[0][0], this.description);
+ }
+ // 如果同时满足在同一个列，同时消除这一列里面的数字
+ if (basicStragety.isSameCol([[combineList[0][0],combineList[0][1]], [combineList[1][0], combineList[1][1]]])) {
+ basicStragety.removeInCol(allCandidates, allReason, [[combineList[0][0],combineList[0][1]], [combineList[1][0], combineList[1][1]]],
+ [num1, num2], combineList[0][1], this.description);
+ }
+
+ }
+ }
+ }
+ }
+}
+
+
+
+export const hiddenPairStrategy = new HiddenPairStrategy()
+
+
+
+/*
+// 调试信息
+let sudoku = [
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [9, 0, 4, 6, 0, 7, 0, 0, 0],
+ [0, 7, 6, 8, 0, 4, 1, 0, 0],
+ [3, 0, 9, 7, 0, 1, 0, 8, 0],
+ [7, 0, 8, 0, 0, 0, 3, 0, 1],
+ [0, 5, 1, 3, 0, 8, 7, 0, 2],
+ [0, 0, 7, 5, 0, 2, 6, 1, 0],
+ [0, 0, 5, 4, 0, 3, 2, 0, 8],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+];
+let sudoku1 = [
+ [7, 2, 0, 4, 0, 8, 0, 3, 0],
+ [0, 8, 0, 0, 0, 0, 0, 4, 7],
+ [4, 0, 1, 0, 7, 6, 8, 0, 2],
+ [8, 1, 0, 7, 3, 9, 0, 0, 0],
+ [0, 0, 0, 8, 5, 1, 0, 0, 0],
+ [0, 0, 0, 2, 6, 4, 0, 8, 0],
+ [2, 0, 9, 6, 8, 0, 4, 1, 3],
+ [3, 4, 0, 0, 0, 0, 0, 0, 8],
+ [1, 6, 8, 9, 4, 3, 2, 7, 5],
+];
+
+console.log(hiddenPairStrategy.apply(sudoku1));
+*/
+
diff --git a/src/node_modules/@sudoku/strategy/lastRemainStrategy.js b/src/node_modules/@sudoku/strategy/lastRemainStrategy.js
new file mode 100644
index 00000000..87a819c3
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/lastRemainStrategy.js
@@ -0,0 +1,100 @@
+import { Strategy } from '@sudoku/strategy/strategy.js';
+import {basicStragety} from '@sudoku/strategy/basicStrategy.js'
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+
+
+const BOX_SIZE = 3;
+const SUDOKU_SIZE = 9;
+
+
+
+export class LastRemianStrategy extends Strategy {
+ constructor() {
+ super(1, "Last Remian");
+ }
+
+
+ apply(sudoku) {
+ const [allCandidates, allReason] = basicStragety.apply(sudoku);
+ // 检查行
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ this.findLastRemainInRow(allCandidates, row, allReason);
+ }
+ // 检查列
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ this.findLastRemainInCol(allCandidates, col, allReason);
+ }
+ // 检查九宫格
+ for (let boxRow = 0; boxRow < SUDOKU_SIZE/BOX_SIZE; boxRow++) {
+ for (let boxCol = 0; boxCol < SUDOKU_SIZE/BOX_SIZE; boxCol++) {
+ this.findLastRemainInBox(allCandidates, boxRow, boxCol, allReason);
+ }
+ }
+ return [allCandidates, allReason];
+
+ }
+
+
+ // 寻找一行内的剩余数字
+ findLastRemainInRow(allCandidates, row, allReason) {
+ // 对每一个数字进行检查
+ for (let candidate = 1; candidate <= SUDOKU_SIZE; candidate++){
+ let position = []
+ for (let col = 0; col < SUDOKU_SIZE; col ++) {
+ if( allCandidates[row][col].length > 0 && allCandidates[row][col].includes(candidate)) {
+ position.push(col);
+ }
+
+ }
+ if(position.length === 1) {
+ allCandidates[row][position[0]] = [candidate];
+ allReason[row][position[0]] = [`Last Remaining in row. The last remaining candidate is ${candidate}`]
+ }
+ }
+ }
+
+
+ // 寻找一列内的剩余数字
+ findLastRemainInCol(allCandidates, col, allReason) {
+ // 对每一个数字进行检查
+ for (let candidate = 1; candidate <= SUDOKU_SIZE; candidate++){
+ let position = []
+ for (let row = 0; row < SUDOKU_SIZE; row ++) {
+ if( allCandidates[row][col].length > 0 && allCandidates[row][col].includes(candidate)) {
+ position.push(row);
+ }
+ }
+ if(position.length === 1) {
+ allCandidates[position[0]][col] = [candidate];
+ allReason[position[0]][col] = [`Last Remaining in column. The last remaining candidate is ${candidate}`]
+ }
+ }
+ }
+
+
+ // 寻找一个九宫格内的剩余数字
+ findLastRemainInBox(allCandidates, boxRow, boxCol, allReason) {
+ // 对每一个数字进行检查
+ for (let candidate = 1; candidate <= SUDOKU_SIZE; candidate++){
+ let position = []
+ for (let boxIndex = 0; boxIndex < BOX_SIZE*BOX_SIZE; boxIndex ++) {
+ let row = boxRow*BOX_SIZE + Math.floor(boxIndex / BOX_SIZE);
+ let col = boxCol*BOX_SIZE + boxIndex % BOX_SIZE;
+ if( allCandidates[row][col].length > 0 && allCandidates[row][col].includes(candidate)) {
+ position.push([row, col]);
+ }
+ }
+ if(position.length === 1) {
+ allCandidates[position[0][0]][position[0][1]] = [candidate]
+ allReason[position[0][0]][position[0][1]] = [`Last Remaining in box. The last remaining candidate is ${candidate}`]
+ }
+ }
+ }
+}
+
+
+
+export const lastRemianStrategy = new LastRemianStrategy()
+
+
+
diff --git a/src/node_modules/@sudoku/strategy/nakePair.js b/src/node_modules/@sudoku/strategy/nakePair.js
new file mode 100644
index 00000000..bf442045
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/nakePair.js
@@ -0,0 +1,157 @@
+import { Strategy } from '@sudoku/strategy/strategy.js';
+import {basicStragety} from '@sudoku/strategy/basicStrategy.js'
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+
+
+const BOX_SIZE = 3;
+const SUDOKU_SIZE = 9;
+
+
+
+export class NakePairStrategy extends Strategy {
+ constructor() {
+ super(2, "Nake Pair");
+ }
+
+
+ apply(sudoku) {
+ const [allCandidates, allReason] = basicStragety.apply(sudoku);
+ let change = true;
+ while(change) {
+ let oldAmount = basicStragety.getAmountCandidate(allCandidates);
+ // 检查行
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ this.findNakePairInRow(allCandidates, row, allReason);
+ }
+ // 检查列
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ this.findNakePairInCol(allCandidates, col, allReason);
+ }
+ // 检查九宫格
+ for (let boxRow = 0; boxRow < SUDOKU_SIZE/BOX_SIZE; boxRow++) {
+ for (let boxCol = 0; boxCol < SUDOKU_SIZE/BOX_SIZE; boxCol++) {
+ this.findNakePairInBox(allCandidates, boxRow, boxCol, allReason);
+ }
+ }
+ let newAmount = basicStragety.getAmountCandidate(allCandidates);
+ change = !basicStragety.isSameAmount(oldAmount, newAmount);
+ }
+ return [allCandidates, allReason];
+ }
+
+
+
+ // 寻找同一行的nake pair
+ findNakePairInRow(allCandidates, row, allReason) {
+ for (let firstCol = 0; firstCol !Array.isArray(element) || element.length !== 0);
+ allReason[row][firstCol] = [...new Set(allReason[row][firstCol])];
+ allReason[row][nextCol] = allReason[row][nextCol].concat([`[${row}, ${firstCol}] 和 [${row}, ${nextCol}] 是一对行Naked Pair, 候选值为${allCandidates[row][nextCol]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[row][nextCol] = [...new Set(allReason[row][nextCol])];
+ basicStragety.removeInRow(allCandidates, allReason, [[row, firstCol], [row, nextCol]],
+ [allCandidates[row][firstCol][0], allCandidates[row][firstCol][1]], row, this.description);
+ }
+ }
+ }
+ }
+ }
+
+
+ // 寻找同一列的nake pair
+ findNakePairInCol(allCandidates, col, allReason) {
+ for (let firstRow = 0; firstRow !Array.isArray(element) || element.length !== 0);
+ allReason[firstRow][col] = [...new Set(allReason[firstRow][col])];
+ allReason[nextRow][col] = allReason[nextRow][col].concat([`[${firstRow}, ${col}] 和 [${nextRow}, ${col}] 是一对列Naked Pair, 候选值为${allCandidates[nextRow][col]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[nextRow][col] = [...new Set(allReason[nextRow][col])];
+ basicStragety.removeInCol(allCandidates, allReason, [[firstRow, col], [nextRow, col]],
+ [allCandidates[firstRow][col][0], allCandidates[firstRow][col][1]], col, this.description);
+
+ }
+ }
+ }
+ }
+ }
+
+
+ // 寻找同一个九宫格的nake pair
+ findNakePairInBox(allCandidates, boxRow, boxCol, allReason) {
+ for (let firstBoxIndex = 0; firstBoxIndex < BOX_SIZE*BOX_SIZE; firstBoxIndex ++) {
+ let firstRow = boxRow*BOX_SIZE + Math.floor(firstBoxIndex / BOX_SIZE);
+ let firstCol = boxCol*BOX_SIZE + firstBoxIndex % BOX_SIZE;
+ // 找到第一个二元候选值
+ if (allCandidates[firstRow][firstCol].length == 2) {
+ for (let nextBoxIndex = firstBoxIndex + 1; nextBoxIndex !Array.isArray(element) || element.length !== 0);
+ allReason[firstRow][firstCol] = [...new Set(allReason[firstRow][firstCol])];
+ allReason[nextRow][nextCol] = allReason[nextRow][nextCol].concat([`[${firstRow}, ${firstCol}] 和 [${nextRow}, ${nextCol}] 是一对宫Naked Pair, 候选值为${allCandidates[nextRow][nextCol]}`]).filter(
+ element => !Array.isArray(element) || element.length !== 0);
+ allReason[nextRow][nextCol] = [...new Set(allReason[nextRow][nextCol])];
+ basicStragety.removeInBox(allCandidates, allReason, [[firstRow, firstCol], [nextRow, nextCol]],
+ [allCandidates[firstRow][firstCol][0], allCandidates[firstRow][firstCol][1]], boxRow, boxCol, this.description);
+ }
+ }
+ }
+ }
+ }
+}
+
+
+export const nakePairStrategy = new NakePairStrategy()
+
+
+
+
+/*
+// 调试信息
+let sudoku = [
+ [0, 8, 0, 0, 9, 0, 0, 3, 0],
+ [0, 3, 0, 0, 0, 0, 0, 6, 9],
+ [9, 0, 2, 0, 6, 3, 1, 5, 8],
+ [0, 2, 0, 8, 0, 4, 5, 9, 0],
+ [8, 5, 1, 9, 0, 7, 0, 4, 6],
+ [3, 9, 4, 6, 0, 5, 8, 7, 0],
+ [5, 6, 3, 0, 4, 0, 9, 8, 7],
+ [2, 0, 0, 0, 0, 0, 0, 1, 5],
+ [0, 1, 0, 0, 5, 0, 0, 2, 0],
+];
+let sudoku1 = [
+ [4, 0, 0, 0, 0, 0, 9, 3, 8],
+ [0, 3, 2, 0, 9, 4, 1, 0, 0],
+ [0, 9, 5, 3, 0, 0, 2, 4, 0],
+ [3, 7, 0, 6, 0, 9, 0, 0, 4],
+ [5, 2, 9, 0, 0, 1, 6, 7, 3],
+ [6, 0, 4, 7, 0, 3, 0, 9, 0],
+ [9, 5, 7, 0, 0, 8, 3, 0, 0],
+ [0, 0, 3, 9, 0, 0, 4, 0, 0],
+ [2, 4, 0, 0, 3, 0, 7, 0, 9],
+];
+
+console.log(nakePairStrategy.apply(sudoku1));
+*/
diff --git a/src/node_modules/@sudoku/strategy/strategy.js b/src/node_modules/@sudoku/strategy/strategy.js
new file mode 100644
index 00000000..7919a692
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/strategy.js
@@ -0,0 +1,21 @@
+
+
+export class Strategy {
+ constructor(name, description) {
+ if (new.target === Strategy) {
+ throw new Error("Cannot instantiate abstract class Strategy directly");
+ }
+ this.name = name;
+ this.description = description;
+ }
+
+ apply(sudoku) {
+ throw new Error("Abstract method 'apply' must be implemented by a subclass");
+ }
+
+}
+
+
+
+
+
diff --git a/src/node_modules/@sudoku/strategy/strategyManager.js b/src/node_modules/@sudoku/strategy/strategyManager.js
new file mode 100644
index 00000000..532dd3c6
--- /dev/null
+++ b/src/node_modules/@sudoku/strategy/strategyManager.js
@@ -0,0 +1,170 @@
+import { Strategy } from './strategy.js';
+// import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+import {basicStragety} from '@sudoku/strategy/basicStrategy.js'
+import { lastRemianStrategy } from '@sudoku/strategy/lastRemainStrategy.js';
+import { nakePairStrategy } from './nakePair.js'
+import { hiddenPairStrategy } from './hiddenPair.js'
+import { threeDMedusaStrategy } from './3DMedusaStrategy.js'
+
+
+export class StrategyManager {
+
+ constructor() {
+ this.strategyList = [];
+ this.candidateList = [];
+ this.reasonList = [];
+ }
+
+
+ register(strategy) {
+ if (strategy && strategy.apply) {
+ this.strategyList.push(strategy);
+ } else {
+ throw new Error('Invalid strategy: Strategy must have an apply method');
+ }
+ }
+
+
+ removeStrategy(strategy) {
+ this.strategyList = this.strategyList.filter(s => s !== strategy);
+ }
+
+
+ inference(sudoku) {
+ this.candidateList = [];
+ for (const strategy of this.strategyList) {
+ const [newCandidates, newReason] = strategy.apply(sudoku);
+ this.candidateList.push(newCandidates);
+ this.reasonList.push(newReason);
+ }
+ return this.intersection();
+ }
+
+
+
+ // 计算所有策略的结果取交集
+ intersection() {
+ if (this.candidateList.length === 0) {
+ return [];
+ }
+ // 初始化交集为第一个策略的结果
+ let intersectionResult = this.candidateList[0];
+ let intersectionReason = this.reasonList[0];
+ // 逐个计算交集
+ for (let i = 1; i < this.candidateList.length; i++) {
+ const currentCandidates = this.candidateList[i];
+ const currentReanson = this.reasonList[i];
+ for (let row = 0; row < intersectionResult.length; row++) {
+ for (let col = 0; col < intersectionResult[row].length; col++) {
+ // 候选值结果取交集
+ intersectionResult[row][col] = intersectionResult[row][col].filter(element => currentCandidates[row][col].includes(element));
+ // 理由取并集
+ intersectionReason[row][col] = intersectionReason[row][col].concat(currentReanson[row][col]);
+ intersectionReason[row][col] = intersectionReason[row][col].filter(element => !Array.isArray(element) || element.length !== 0);
+ }
+ }
+ }
+ // 返回交集结果
+ // 去掉重复元素
+ for(let row = 0; row < intersectionReason.length; row ++){
+ for (let col = 0; col < intersectionReason[0].length; col ++) {
+ intersectionReason[row][col] = [...new Set(intersectionReason[row][col])]
+ }
+ }
+ return [intersectionResult, intersectionReason];
+ }
+
+}
+
+
+
+
+
+
+
+
+// 调试代码
+export const strategymanager = new StrategyManager();
+
+
+// 注册策略
+strategymanager.register(basicStragety)
+strategymanager.register(lastRemianStrategy)
+strategymanager.register(nakePairStrategy);
+strategymanager.register(hiddenPairStrategy);
+strategymanager.register(threeDMedusaStrategy);
+
+
+/*
+let sudoku = [
+ [6, 0, 0, 9, 0, 8, 7, 0, 3],
+ [2, 0, 7, 0, 4, 0, 0, 0, 0],
+ [0, 5, 0, 0, 0, 0, 6, 0, 0],
+ [0, 0, 3, 0, 0, 1, 0, 5, 0],
+ [0, 0, 2, 0, 8, 0, 0, 9, 0],
+ [1, 4, 0, 0, 3, 0, 0, 0, 2],
+ [0, 0, 0, 0, 0, 0, 2, 0, 0],
+ [0, 8, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 1, 7],
+];
+
+
+let sudoku = [
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [5, 0, 9, 8, 0, 0, 0, 1, 0],
+ [0, 7, 3, 0, 5, 0, 0, 9, 0],
+ [2, 0, 8, 0, 0, 0, 7, 0, 0],
+ [0, 0, 0, 6, 8, 0, 0, 5, 0],
+ [0, 0, 0, 0, 2, 0, 0, 0, 3],
+ [8, 0, 0, 0, 0, 5, 0, 0, 1],
+ [7, 0, 0, 0, 0, 3, 0, 6, 0],
+ [0, 0, 0, 1, 9, 0, 3, 0, 0],
+]
+
+let sudoku = [
+ [7, 2, 0, 4, 0, 8, 0, 3, 0],
+ [0, 8, 0, 0, 0, 0, 0, 4, 7],
+ [4, 0, 1, 0, 7, 6, 8, 0, 2],
+ [8, 1, 0, 7, 3, 9, 0, 0, 0],
+ [0, 0, 0, 8, 5, 1, 0, 0, 0],
+ [0, 0, 0, 2, 6, 4, 0, 8, 0],
+ [2, 0, 9, 6, 8, 0, 4, 1, 3],
+ [3, 4, 0, 0, 0, 0, 0, 0, 8],
+ [1, 6, 8, 9, 4, 3, 2, 7, 5],
+]
+
+let sudoku = [
+ [6, 0, 0, 0, 1, 3, 8, 9, 0],
+ [0, 0, 0, 0, 7, 0, 6, 4, 0],
+ [0, 0, 0, 0, 4, 6, 3, 7, 1],
+ [0, 0, 0, 0, 0, 0, 2, 0, 4],
+ [5, 0, 0, 0, 0, 0, 1, 0, 6],
+ [0, 8, 0, 0, 0, 0, 7, 0, 9],
+ [0, 0, 5, 3, 6, 2, 9, 1, 8],
+ [0, 9, 0, 4, 8, 1, 5, 0, 7],
+ [8, 0, 1, 7, 5, 9, 4, 0, 3],
+]
+
+
+let sudoku = [
+ [0, 9, 3, 8, 2, 4, 5, 6, 0],
+ [0, 8, 5, 6, 0, 0, 0, 0, 2],
+ [2, 0, 6, 0, 7, 5, 0, 0, 8],
+ [3, 2, 1, 7, 6, 9, 8, 4, 5],
+ [0, 0, 0, 2, 5, 8, 3, 0, 0],
+ [5, 7, 8, 0, 4, 0, 2, 9, 6],
+ [8, 5, 0, 0, 1, 6, 7, 2, 3],
+ [0, 0, 7, 0, 8, 2, 6, 5, 0],
+ [0, 0, 2, 5, 0, 7, 1, 8, 0],
+];
+
+// 应用所有策略
+const [allCandidates, allReason] = strategymanager.inference(sudoku);
+console.log(allCandidates)
+console.log(allReason)
+*/
+
+
+
+
+
diff --git a/src/template.html b/src/template.html
index f31623e3..fbb2f7e0 100644
--- a/src/template.html
+++ b/src/template.html
@@ -25,3 +25,8 @@