Entfernen Sie ein beliebiges Element aus jeder Zeile und Spalte in einer Sudoku-Matrix

Question

In einem früheren Post erwähnte ich, wie Sie ein Element in einer Sudoku-Matrix aus jeder Zeile entfernen können. Jetzt denke ich über Möglichkeiten nach, ein Element aus der Sudoku-Matrix zu entfernen, aber für jede Zeile und Spalte. Ich denke darüber nach, ein Array zu erstellen, in dem der Spaltenindex gespeichert wird, aus dem das Element in der Zeile entfernt wurde. In der nächsten Zeile wurde dann iteriert, um eine weitere Elementprüfung zu entfernen, um festzustellen, ob die entfernte Nummer im zuvor gespeicherten Spaltenindex enthalten ist. Obwohl ich nicht denke, dass es ein sehr effizienter Algorithmus sein wird.

Remove Element aus Zeile Methode

public static void remove_Sud (int [][] S){ // Remove sudoku method 
    for(int i = 0; i < S.length; i++){ // For loop iterate through length of matrix array 
     int randomPosition = (int) Math.floor(Math.random() * S.length); //Random number between 0 and 2 
     S[i][randomPosition] = 0; // 0 or whatever you use to represent blank 
    } 

} 

Sudoku Matrix

Answer 1

es effizient zu tun, würde ich zwei Anordnungen von Indizes (eine für die Spalten, eine für die Reihen) schlagen zu schaffen, die jeweils 9 int lange . Es ist effizienter als die Verwendung von Listen. Wir füllen sie dann mit einer Permutation von Ints 0-8 ohne Wiederholungen, und sie als eine Karte, welche Elemente in der Matrix 0

Hier ist ein Beispielcode eingeben:

public static void removeSudoku(int[][] sudoku) { 
    Random rand = new Random(); 
    int[] cols = {-1,-1,-1,-1,-1,-1,-1,-1,-1}; 
    int[] rows = {-1,-1,-1,-1,-1,-1,-1,-1,-1}; 

    //We need to choose an index for each number 0-8 inclusive. 
    for (int i=0;i<9;i++) { 

     //get a random index on the column array for i 
     int randomInt = rand.nextInt(9); 
     //In case this random index is already populated - 
     //rand again until an empty spot is available. 
     while (cols[randomInt]!=-1) { 
     randomInt = rand.nextInt(9); 
     } 
     cols[randomInt] = i; 

     //Same thing for the rows - get a random index in the 
     //array for i, rand again if needed. 
     randomInt = rand.nextInt(9); 
     while (rows[randomInt]!=-1) { 
     randomInt = rand.nextInt(9); 
     } 
     rows[randomInt] = i; 
    } 

    //Now that we have the two arrays filled in with a random 
    //permutation of ints 0-8, we can use it to remove the 
    //elements from the sudoku. 
    for (int i=0;i<9;i++) { 
     sudoku[rows[i]][cols[i]] = 0; 
    } 
    } 

    //Just for printout 
    public static void printSoduku(int[][] sudoku) { 
    for (int i=0;i<9;i++) { 
     for(int j=0;j<9;j++) { 
     System.out.print(sudoku[i][j]+" "); 
     if (j==2 || j==5) { 
      System.out.print("|"); 
     } 
     } 
     System.out.println(); 
     if (i==2 || i==5) { 
     System.out.println("-------------------"); 
     } 
    } 
    } 

    public static void main(String[] args) throws IOException { 

    int[][] soduku = new int[][] {{1,2,3,4,5,6,7,8,9}, 
    {4,5,6,7,8,9,1,2,3},{7,8,9,1,2,3,4,5,6}, 
    {2,3,4,5,6,7,8,9,1},{5,6,7,8,9,1,2,3,4}, 
    {8,9,1,2,3,4,5,6,7},{3,4,5,6,7,8,9,1,2}, 
    {6,7,8,9,1,2,3,4,5},{9,1,2,3,4,5,6,7,8}}; 
    printSudoku(sudoku); 
    removeSudoku(sudoku); 
    System.out.println(); 
    printSudoku (sudoku); 
    } 

Der Ausgang wird die ursprüngliche Sudoku-Matrix sein und dann die entfernt ein: kann

1 2 3 |4 5 6 |7 8 9 
4 5 6 |7 8 9 |1 2 3 
7 8 9 |1 2 3 |4 5 6 
------------------- 
2 3 4 |5 6 7 |8 9 1 
5 6 7 |8 9 1 |2 3 4 
8 9 1 |2 3 4 |5 6 7 
------------------- 
3 4 5 |6 7 8 |9 1 2 
6 7 8 |9 1 2 |3 4 5 
9 1 2 |3 4 5 |6 7 8 

1 2 3 |0 5 6 |7 8 9 
4 5 6 |7 8 9 |0 2 3 
0 8 9 |1 2 3 |4 5 6 
------------------- 
2 3 0 |5 6 7 |8 9 1 
5 6 7 |8 0 1 |2 3 4 
8 9 1 |2 3 0 |5 6 7 
------------------- 
3 0 5 |6 7 8 |9 1 2 
6 7 8 |9 1 2 |3 4 0 
9 1 2 |3 4 5 |6 0 8 

Answer 2

Sie diesen Code verwenden. Ich habe die Matrix nicht mit perfekten Werten von Sudoku gemacht, aber Sie können die Ausgabe sehen. Die Funktion ist deleteRandom()

8 1 5 4 2 5 3 0 2 1 
3 6 0 4 5 5 3 3 5 8 
6 9 4 3 8 2 3 8 0 7 
2 9 9 1 0 5 7 6 9 2 
4 0 6 7 7 9 5 6 6 2 
2 9 1 8 8 7 9 9 8 0 
0 4 6 2 7 3 8 5 8 1 
1 8 5 2 1 8 0 4 8 7 
4 7 5 0 6 6 6 4 3 3 
9 6 3 5 6 0 4 7 1 6 

In jeder Zeile und jede Spalte gibt es nur eine Null, und es wird das Programm ausgeführt wird, jedes Mal geändert werden.

import java.util.ArrayList; 
import java.util.LinkedHashSet; 
import java.util.Random; 
import java.util.Set; 

public class test { 
    public static void main(String[] args) { 
     int[][] sodoku = new int[10][10]; 
     for (int i = 0; i < 10; i++) { 
      for (int j = 0; j < 10; j++) { 
       Random random = new Random(); 
       int max = 9; 
       int min = 1; 
       sodoku[i][j] = random.nextInt(max - min + 1) + min; 
      } 
     } 
     print(sodoku); 
     deleteRandom(sodoku); 
    } 

    private static void deleteRandom(int[][] sodoku) { 
     Random r = new Random(); 
     Set<Integer> rowSet = new LinkedHashSet<>(); 
     while (rowSet.size() != 10) { 
      int answer = r.nextInt(10); 
      rowSet.add(answer); 
     } 
     ArrayList<Integer> rowList = new ArrayList<>(); 
     rowList.addAll(rowSet); 

     Set<Integer> colSet = new LinkedHashSet<>(); 
     while (colSet.size() != 10) { 
      int answer = r.nextInt(10); 
      colSet.add(answer); 
     } 
     ArrayList<Integer> colList = new ArrayList<>(); 
     colList.addAll(colSet); 
     for (int i = 0; i < 10; i++) { 
      sodoku[rowList.get(i)][colList.get(i)] = 0; 
     } 
     System.out.println(); 
     print(sodoku); 
    } 

    private static void print(int[][] sodoku) { 
     for (int i = 0; i < 10; i++) { 
      for (int j = 0; j < 10; j++) { 
       System.out.print(sodoku[i][j] + " "); 
      } 
      System.out.println(); 
     } 
    } 
}