Java 数独调试问题

我正在开发一个程序，该程序应该将已解决的数独难题作为输入，并返回它是否是有效的解决方案（正确或错误）。 我的代码是用几个helper方法编写和运行的

isSolution方法运行4个不同的步骤来检查解决方案是否有效。 我已经编写了一个有效的解决方案作为输入，它应该返回true。 当我分别检查这4个元素时，它们返回true，当我一起检查时，它们返回false（这是错误的）

我花了数小时分别、一起和以不同的组合测试它们。 我尝试了不同的输入。 我不明白为什么它返回false，而它应该返回true

任何帮助都将不胜感激！谢谢

public static void main(String[] args){
  int [][] solvedPuzzle = {
  {8,3,5,4,1,6,9,2,7},
  {2,9,6,8,5,7,4,3,1},
  {4,1,7,2,9,3,6,5,8},

  {5,6,9,1,3,4,7,8,2},
  {1,2,3,6,7,8,5,4,9},
  {7,4,8,5,2,9,1,6,3},

  {6,5,2,7,8,1,3,9,4},
  {9,8,1,3,4,5,2,7,6},
  {3,7,4,9,6,2,8,1,5}
  };

 System.out.println(isSolution(solvedPuzzle));
 }


////// Checks if the input is a valid sudoku solution
/* The solvedPuzzle input is a valid solution, so this method should return true.
 * Each of the elements in this method return true when tested individually, but for some reason, 
 * when I run them all together, the method returns false
 */
public static boolean isSolution(int [][] solvedPuzzle){
  //Checks if the rows and columns have 9 ints 
  if (solvedPuzzle.length != 9 || solvedPuzzle[0].length !=9){
    return false;
  }

//Checks if every column is made up of unique entries
  for (int j = 0; j < 9; j++){
    if (uniqueEntries(getColumn(solvedPuzzle, j)) !=true){
      System.out.println("HERE!"); //these are just here to try to figure out WHERE I've gone wrong
      return false;
    }
  }

  //Checks if every row is made up of unique entries 
  for (int i = 0; i < 9; i++){
    if (uniqueEntries(solvedPuzzle[i]) !=true){
              System.out.println("HERE!!!");
      return false;
    }
  }

  //Checks if every sub 3x3 grid is made up of unique entries
  for (int x = 0; x < 9; x = x+3){
    for (int y = 0; y < 9; y = y+3){
        if (uniqueEntries(flatten(subGrid(solvedPuzzle, x,y,3))) != true){
                  System.out.println("HERE22");
        return false;
      }
    } 
  }  

return true;
}




///Below are the helper methods

////// Creates a smaller grid of size m starting at indexI,indexJ (x,y). 
public static int [][] subGrid(int [][] original, int indexI, int indexJ, int m){
  int [][] subGrid = new int [m][m]; 
  for (int i = indexI; i < indexI+m ; i++){
       for (int j = indexJ; j < indexJ+m ; j++){ 
            subGrid [i - indexI][j - indexJ] = original[i][j];
       }
  }
  return subGrid;
}

////// Sorts the intergers in a 1D array in asceding order
public static int [] sort(int [] originalArray){
  int temp;
  for(int i = 0; i < originalArray.length - 1; i++){
      for(int j = 0; j < originalArray.length - 1; j++){
          if(originalArray[j] > originalArray[j+1]){
              temp = originalArray[j];
              originalArray[j] = originalArray[j+1];
              originalArray[j+1] = temp;
          }
      }
  }
  return(originalArray);
}

////// Checks if the intergers in a 1D array are all unique by first using the sort method
public static boolean uniqueEntries(int [] original){
  int [] sorted = sort(original);
  for (int i = 0; i < original.length-1; i++){
    if (sorted[i+1] == sorted[i]) {
        return false;
      }
     } 
  return true;
}

////// Takes a 2D array where each subarray is of the same size and creates a 1D array made up of the i-th element of each sub array
public static int [] getColumn(int [][] original, int indexJ){
  int [] column = new int[original[0].length];
    for (int i = 0; i < original[0].length; i++){
      column[i] = original[i][indexJ];
    } 
  return column;
}

////// takes a 2D array and flattens it into a 1D array 
public static int [] flatten(int [][] original){
  int [] flattenedArray = new int[original.length*original[0].length];
  int counter = 0;
  for (int i = 0; i < original.length; i++){
    for(int j = 0; j < original.length; j++) {
      flattenedArray[counter] = original[i][j];
      counter++;
      }
  }
  return flattenedArray;
}

publicstaticvoidmain（字符串[]args）{
int[]solvedPuzzle={
{8,3,5,4,1,6,9,2,7},
{2,9,6,8,5,7,4,3,1},
{4,1,7,2,9,3,6,5,8},
{5,6,9,1,3,4,7,8,2},
{1,2,3,6,7,8,5,4,9},
{7,4,8,5,2,9,1,6,3},
{6,5,2,7,8,1,3,9,4},
{9,8,1,3,4,5,2,7,6},
{3,7,4,9,6,2,8,1,5}
};
系统输出打印LN（isSolution（solvedPuzzle））；
}
//////检查输入是否为有效的数独解决方案
/*solvedPuzzle输入是有效的解决方案，因此此方法应返回true。
*当单独测试时，此方法中的每个元素都返回true，但由于某些原因，
*当我一起运行它们时，该方法返回false
*/
公共静态布尔isSolution（int[][]solvedPuzzle）{
//检查行和列是否有9个整数
if（solvedPuzzle.length！=9 | | solvedPuzzle[0].长度！=9）{
返回false；
}
//检查每一列是否由唯一的条目组成
对于（int j=0；j<9；j++）{
if（uniqueEntries（getColumn（solvedPuzzle，j））！=true）{
System.out.println（“这里！”；//这些只是为了找出我的错误所在
返回false；
}
}
//检查每一行是否由唯一的条目组成
对于（int i=0；i<9；i++）{
if（uniqueEntries（solvedPuzzle[i]）！=true）{
System.out.println（“这里！！！”；
返回false；
}
}
//检查每个子3x3网格是否由唯一的条目组成
对于（int x=0；x<9；x=x+3）{
对于（int y=0；y<9；y=y+3）{
if（uniqueEntries（展平（子网格（solvedPuzzle，x，y，3）））！=true）{
系统输出打印号（“此处22”）；
返回false；
}
} 
}  
返回true；
}
///下面是助手方法
//////从indexI，indexJ（x，y）开始创建大小为m的较小网格。
公共静态int[][]子网格（int[][]原始，int indexI，int indexJ，int m）{
int[][]子网格=新的int[m][m]；
对于（int i=indexI；ioriginalArray[j+1]）{
温度=原始阵列[j]；
原始阵列[j]=原始阵列[j+1]；
原始阵列[j+1]=温度；
}
}
}
返回（原始数组）；
}
//////首先使用排序方法检查1D数组中的整数是否都是唯一的
公共静态布尔Uniquentries（int[]原始）{
int[]排序=排序（原始）；
对于（int i=0；i

如果您在运行前后检查拼图//检查每一行是否由唯一的条目组成您将看到您实际上正在更改拼图的原始格式。因此，下一个测试不是要运行在原始的难题，而是一个排序的一个！如果在第二次测试前后添加一个简单的循环，您将理解我所说的内容

  for (int i = 0; i < 9; i++){ //ADD THAT LOOP BEFORE AND AFTER THE TEST
    for (int j = 0; j<9; j++) {
        System.out.print(solvedPuzzle[i][j]);
    }
    System.out.println();
  }
  System.out.println('\n');

  //Checks if every row is made up of unique entries 
  for (int i = 0; i < 9; i++){
    if (uniqueEntries(solvedPuzzle[i]) !=true){
              System.out.println("HERE!!!");
      return false;
    }
  }

  for (int i = 0; i < 9; i++){
    for (int j = 0; j<9; j++) {
        System.out.print(solvedPuzzle[i][j]);
    }
    System.out.println();
  }

正如你所看到的，原来的拼图不再是“原来的”

因此，正如我在评论中告诉您的，翻转测试实际上并不能解决问题。相反，错误仍然会产生；但是如果没有任何测试来运行，它将不会影响当前代码

希望有帮助

编辑：我不知道以后是否会在线；所以在这种情况下，即使这个提示也不能帮助你找到bug，所以我也要给你一个解决方案：p

问题在于您使用的是

sort（）

方法，它不仅返回已排序的数组，而且还实际对输入数组进行排序！因此，为了避免在调用sort方法时只需传入数组的副本而不是数组本身：

    ////// Checks if the intergers in a 1D array are all unique by first using the sort method
    public static boolean uniqueEntries(int [] original){
        int [] sorted = sort(original.clone()); //pass in a copy of the array
        for (int i = 0; i < original.length-1; i++){
            if (sorted[i+1] == sorted[i]) {
                return false;
            }
        }
        return true;
    }

//首先使用排序方法检查一维数组中的整数是否都是唯一的
公共静态布尔Uniquentries（int[]原始）{
int[]sorted=sort（original.clone（））；//传入数组的副本
对于（int i=0；i

为什么要使用

i    ////// Checks if the intergers in a 1D array are all unique by first using the sort method
    public static boolean uniqueEntries(int [] original){
        int [] sorted = sort(original.clone()); //pass in a copy of the array
        for (int i = 0; i < original.length-1; i++){
            if (sorted[i+1] == sorted[i]) {
                return false;
            }
        }
        return true;
    }