我正在开发一个程序,该程序应该将已解决的数独难题作为输入,如果它是有效的解决方案(正确或错误),则将其返回。
我的代码是用一些辅助方法编写并运行的。

isSolution方法通过4种不同的方法运行,以检查解决方案是否有效。
我写了一个有效的解决方案作为应返回true的输入。
当我分别检查这四个元素中的每个元素时,它们都返回true,当我一起检查它们时,它们返回false(这是错误的)

我已经花了几个小时分别,一起和以不同的组合对其进行测试。
我尝试了不同的输入。
我不知道为什么当它应该返回true时却返回false。

任何帮助将非常感激!谢谢

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;
}

最佳答案

如果在运行//Checks if every row is made up of unique entries之前和之后检查拼图,您将看到您实际上是在更改拼图的原始格式。因此,下一个测试不会遍历原始难题,而是经过排序的难题!如果您在第二次测试之前和之后添加一个简单的循环,您将理解我在说什么

  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();
  }


上面的代码将帮助您直观地查看测试前后拼图的外观。测试切勿更改任何测试内容的格式/内容/属性。以上结果将是:

835416927
296857431
417293658
569134782
123678549
748529163
652781394
981345276
374962815


123456789
123456789
123456789
123456789
123456789
123456789
123456789
123456789
123456789


如您所见,原来的难题不再是“原始的”。

因此,正如我在评论中告诉您的那样,翻转测试并不能真正解决问题。相反,该错误仍将产生;但之后没有任何运行测试不会影响当前代码。

希望能有所帮助

编辑:我不知道我以后是否会上网;因此,即使该提示也无法帮助您找到错误,因此我也将为您提供解决方案: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;
    }

关于java - Sudoku调试问题,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/33861329/

10-12 01:26
查看更多