Проблема с отладкой Sudoku

Question

Я работаю над программой, которая, как предполагается, принимает в качестве входных данных решаемую головоломку Sudoku и возвращается, если она является правильным решением или нет (true или false). Мой код написан и работает с несколькими вспомогательными методами.

Метод 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; 
} 

Answer 1

если вы проверяете головоломки до и после запуска //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 

Как вы можете видеть, оригинальная головоломка больше не является «оригинальной».

Итак, как я сказал вам на моем комментарии, перевертывание тестов вокруг НЕ НАСТОЯЩИМ исправит проблему. Вместо этого ошибка будет производиться; но без каких-либо тестов для запуска после того, как он не повлияет на код CURRENT.

Надежда, что помогает

EDIT: Я не знаю, если я буду в сети позже; поэтому в том случае, если даже этот намек не помог вам найти ошибку, поэтому я также дам вам решение: p

Проблема в том, что вы используете метод sort(), который не возвращает ТОЛЬКО массив отсортировано, НО ТАКЖЕ действительно сортирует входной массив! Чтобы избежать того, что вам просто нужно передать копию массива вместо самого массива всякий раз, когда вы вызываете метод сортировки: почему вы используете `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; 
    }