基于Javascript的数独解算器

我试图用Javascript构建一个数独解算器。代码确实解决了这个问题，但仍然有一些空白点。 我使用Javascript、回溯和递归

在第一个函数中，我可以在空白点（0）上检查一个数字，在第二个函数中，我调用第一个函数来检查空白点，并尝试在该点上放置一个介于1和9之间的数字

有人能看出我做错了什么吗

const userInput = [
  [5, 3, 0, 0, 7, 0, 0, 0, 0],
  [6, 0, 0, 1, 9, 5, 0, 0, 0],
  [0, 9, 8, 0, 0, 0, 0, 6, 0],
  [8, 0, 0, 0, 6, 0, 0, 0, 3],
  [4, 0, 0, 8, 0, 3, 0, 0, 1],
  [7, 0, 0, 0, 2, 0, 0, 0, 6],
  [0, 6, 0, 0, 0, 0, 2, 8, 0],
  [0, 0, 0, 4, 1, 9, 0, 0, 5],
  [0, 0, 0, 0, 8, 0, 0, 7, 9],
];


function possible(y, x, n) {
  for (let i = 0; i <= 8; i++) {
    if (userInput[y][i] === n) {
      return false;
    }
  }
  for (let i = 0; i <= 8; i++) {
    if (userInput[i][x] === n) {
      return false;
    }
  }
  let xSquare = Math.floor(x / 3) * 3;
  let ySquare = Math.floor(y / 3) * 3;
  for (let i = 0; i <= 2; i++) {
    for (let j = 0; j <= 2; j++) {
      if (userInput[ySquare + i][xSquare + j] === n) {
        return false;
      }
    }
  }
  return true;
}


function solve() {
  for (let y = 0; y <= 8; y++) {
    for (let x = 0; x <= 8; x++) {
      if (userInput[y][x] === 0) {
        for (let n = 1; n <= 9; n++) {
          if (possible(y, x, n)) {
            userInput[y][x] = n;
            solve();
          }
        }
      }
    }
  }
}

const userInput=[
[5, 3, 0, 0, 7, 0, 0, 0, 0],
[6, 0, 0, 1, 9, 5, 0, 0, 0],
[0, 9, 8, 0, 0, 0, 0, 6, 0],
[8, 0, 0, 0, 6, 0, 0, 0, 3],
[4, 0, 0, 8, 0, 3, 0, 0, 1],
[7, 0, 0, 0, 2, 0, 0, 0, 6],
[0, 6, 0, 0, 0, 0, 2, 8, 0],
[0, 0, 0, 4, 1, 9, 0, 0, 5],
[0, 0, 0, 0, 8, 0, 0, 7, 9],
];
可能的功能（y、x、n）{
对于（假设i=0；i您正在编写一个回溯算法，但这里没有回溯。当前算法假设每个猜测的值都是完美的——如果没有（这是有保证的，因为这些值是从1到9顺序猜测的），则无法取得任何进展

要回溯，您需要将无法扩展到已解决状态的单元格归零，并在单元格的所有可能性都用尽时将false返回到父状态

此外，函数最好采用参数和返回值，而不是改变全局状态

应用这些最小的修改会产生以下结果。仍有改进的余地；例如，
solve
函数必须重复“搜寻”下一个打开的方块


可能的功能（电路板，y，x，n）{
for（设i=0；i<9；i++）{
如果（板[y][i]==n | |板[i][x]==n）{
返回false；
}
}
常数x平方=数学楼层（x/3）*3；
常数平方=数学楼层（y/3）*3；
for（设i=0；i<3；i++）{
for（设j=0；j<3；j++）{
如果（电路板[ySquare+i][xSquare+j]==n）{
返回false；
}
}
}
返回true；
}
函数求解（板）{
for（设y=0；y<9；y++）{
for（设x=0；x<9；x++）{
如果（电路板[y][x]==0）{
对于（设n=1；n“+e））
为什么
solve
在最内部的if中调用自己，而不是仅仅向下一个x前进？这似乎缺少一点非常重要的逻辑。对于这种类型的解决方案，当你遇到死角时，你真的需要能够回溯。你还需要一些方法来检查你是否完成了这个谜题。谢谢！仍然需要很难理解这一点，但我仍然学到了很多！