У меня проблемы с программированием на Java. Я впервые сталкиваюсь с Java, так что проявите терпение, потому что я могу пропустить основы. Короче говоря, у меня есть судоку, и я столкнулся с несколькими проблемами. Мне нужно брать случайные числа, чтобы сделать доску судоку или, точнее, ее значения.

Если вы не знаете, что такое судоку, должны быть только цифры от 1 до 9, и они не могут повторяться в столбце строки и квадрате 3x3. Сама доска имеет размер 9x9, поэтому ее можно разделить на 9 квадратов 3x3.

И главная проблема в том, что случайно сгенерированные значения иногда затрудняют решение шаблонов. Поэтому я попытался повторить случайную отрисовку тех линий, которые невозможно решить, чтобы избежать таких ситуаций, но, как я понял, я не могу этого сделать. Вот код и спасибо за помощь;)

import java.util.Random;

public class tabela {
  public static void main(String[] args) {
      boolean bylo[] = new boolean[10];//this array tells me if the number is avalible to pick

      boolean wysw[][] = new boolean[9][9];//not used yet it is ment to be used while displaying array in GUI
      int tabela[][] = new int[9][9];//here will be generated values of sudoku

      for(int i=0; i<9;i++)
          for(int j=0;j<9;j++)
               tabela[i][j]=0; //filling array with 0s

      for (int i = 0; i < 9; i++) {


             // System.out.print("a"); <- debugging tools
          out:for (int j = 0; j < 9; j++) {
                  //System.out.print("b");
                  for (int h = 0; h < 10; h++)
                      bylo[h] = false;
                  //System.out.print("c");
                  {
                      int zaokr1 = i + 1, zaokr2 = j + 1; //setting values other than j and i +1 
                      int resz;                           //bcouse i want to set values divided by 3 
                      if (zaokr1 % 3 != 0) { //
                          resz = i % 3;
                          zaokr1 = zaokr1 + (3 - resz);//rounding up to 3 to determine in which 3x3 square we are
                      }
                      if (zaokr2 % 3 != 0) {            // 1 2 3
                          resz = j % 3;                 // 4 5 6
                          zaokr2 = zaokr2 + (3 - resz); // 7 8 9
                      }

                      int c = i, d = j;               //Here i take agan values from i and j 
                      while (c > 0) {                 //
                          c--;                        //and i set values of numbers in column true to 
                          bylo[tabela[c][d]] = true;  //reroll them later
                      }
                      c = i;d = j;                    //same here
                      while (d > 0) {                 //
                          d--;                        //this time for rows
                          bylo[tabela[c][d]] = true;  //
                      }

                      if (zaokr1 / 3 == 1 && zaokr2 / 3 == 1) //those are 3x3 squares from 1 - 9(
                                                              //this is first one
                      {

                          bylo[tabela[0][0]] = true;
                          bylo[tabela[0][1]] = true;
                          bylo[tabela[0][2]] = true;
                          bylo[tabela[1][0]] = true;
                          bylo[tabela[1][1]] = true;
                          bylo[tabela[1][2]] = true;
                          bylo[tabela[2][0]] = true;
                          bylo[tabela[2][1]] = true;
                          bylo[tabela[2][2]] = true;


                      }
                      if (zaokr1 / 3 == 1 && zaokr2 / 3 == 2)//second
                      {
                          bylo[tabela[0][3]] = true;
                          bylo[tabela[0][4]] = true;
                          bylo[tabela[0][5]] = true;
                          bylo[tabela[1][3]] = true;
                          bylo[tabela[1][4]] = true;
                          bylo[tabela[1][5]] = true;
                          bylo[tabela[2][3]] = true;
                          bylo[tabela[2][4]] = true;
                          bylo[tabela[2][5]] = true;

                      }
                      if (zaokr1 / 3 == 1 && zaokr2 / 3 == 3)//third
                      {
                          bylo[tabela[0][6]] = true;
                          bylo[tabela[0][7]] = true;
                          bylo[tabela[0][8]] = true;
                          bylo[tabela[1][6]] = true;
                          bylo[tabela[1][7]] = true;
                          bylo[tabela[1][8]] = true;
                          bylo[tabela[2][6]] = true;
                          bylo[tabela[2][7]] = true;
                          bylo[tabela[2][8]] = true;

                      }
                      if (zaokr1 / 3 == 2 && zaokr2 / 3 == 1)//fourth
                      {
                          bylo[tabela[3][0]] = true;
                          bylo[tabela[3][1]] = true;
                          bylo[tabela[3][2]] = true;
                          bylo[tabela[4][0]] = true;
                          bylo[tabela[4][1]] = true;
                          bylo[tabela[4][2]] = true;
                          bylo[tabela[5][0]] = true;
                          bylo[tabela[5][1]] = true;
                          bylo[tabela[5][2]] = true;

                      }
                      if (zaokr1 / 3 == 2 && zaokr2 / 3 == 2)//fifth
                      {
                          bylo[tabela[3][3]] = true;
                          bylo[tabela[3][4]] = true;
                          bylo[tabela[3][5]] = true;
                          bylo[tabela[4][3]] = true;
                          bylo[tabela[4][4]] = true;
                          bylo[tabela[4][5]] = true;
                          bylo[tabela[5][3]] = true;
                          bylo[tabela[5][4]] = true;
                          bylo[tabela[5][5]] = true;
                      }
                      if (zaokr1 / 3 == 2 && zaokr2 / 3 == 3)//sixth
                      {
                          bylo[tabela[3][6]] = true;
                          bylo[tabela[3][7]] = true;
                          bylo[tabela[3][8]] = true;
                          bylo[tabela[4][6]] = true;
                          bylo[tabela[4][7]] = true;
                          bylo[tabela[4][8]] = true;
                          bylo[tabela[5][6]] = true;
                          bylo[tabela[5][7]] = true;
                          bylo[tabela[5][8]] = true;
                      }
                      if (zaokr1 / 3 == 3 && zaokr2 / 3 == 1)//seventh
                      {
                          bylo[tabela[6][0]] = true;
                          bylo[tabela[6][1]] = true;
                          bylo[tabela[6][2]] = true;
                          bylo[tabela[7][0]] = true;
                          bylo[tabela[7][1]] = true;
                          bylo[tabela[7][2]] = true;
                          bylo[tabela[8][0]] = true;
                          bylo[tabela[8][1]] = true;
                          bylo[tabela[8][2]] = true;
                      }
                      if (zaokr1 / 3 == 3 && zaokr2 / 3 == 2)//eighth
                      {
                          bylo[tabela[6][3]] = true;
                          bylo[tabela[6][4]] = true;
                          bylo[tabela[6][5]] = true;
                          bylo[tabela[7][3]] = true;
                          bylo[tabela[7][4]] = true;
                          bylo[tabela[7][5]] = true;
                          bylo[tabela[8][3]] = true;
                          bylo[tabela[8][4]] = true;
                          bylo[tabela[8][5]] = true;
                      }
                      if (zaokr1 / 3 == 3 && zaokr2 / 3 == 3)//ninth
                      {
                          bylo[tabela[6][6]] = true;
                          bylo[tabela[6][7]] = true;
                          bylo[tabela[6][8]] = true;
                          bylo[tabela[7][6]] = true;
                          bylo[tabela[7][7]] = true;
                          bylo[tabela[7][8]] = true;
                          bylo[tabela[8][6]] = true;
                          bylo[tabela[8][7]] = true;
                          bylo[tabela[8][8]] = true;
                      }
                  }
                  //System.out.print("d");
                  int licznik=0;
                  for (int x = 0; x < 10; x++) {
                       if(bylo[x]==true){licznik++;} //here i count if all values are not blocked already
                  }
                  if(licznik==10)
                  {
                      if(i<=3){i=0;j=0;}
                      if(i>3&&i<=6) {i=3;j=0;}
                      if(i>6) {i=6;j=0;}
                      break out;//i read somwhere that this goes back to the certain point ;)
                  }

                  tabela[i][j] = RandomBeetween(1, 10);
                  if (bylo[tabela[i][j]] == true) {
                      do {

                          tabela[i][j] = RandomBeetween(1, 10);//randomizing numbers

                      } while (bylo[tabela[i][j]] == true);
                      bylo[tabela[i][j]] = true;//and setting their value in bool array to true
                      System.out.print(tabela[i][j]);
                  } else {
                      if (bylo[tabela[i][j]] == false) {
                          bylo[tabela[i][j]] = true;
                          System.out.print(tabela[i][j]);
                      }
                      //for(int x=0;x<10;x++)
                      //  System.out.print(bylo[x]+"   ");
                  }



                  //System.out.println("e  ");
              }
              for(int a=0;a<9;a++)
                  System.out.print(tabela[i][a]+"  ");System.out.print("f");


          }



      }
      static int RandomBeetween ( int min, int max)//just random  in custom range
      {
          Random random = new Random();
          int a1 = random.nextInt(max - min);
          int a2 = a1 + min;
          return a2;

      }


}
0
Just a normal guy II 19 Июн 2020 в 17:49

1 ответ

Лучший ответ

Я не собираюсь разгадывать весь ваш код. Я собираюсь предложить базовый процесс решения этой проблемы.

Во-первых, вы работаете на объектно-ориентированном языке программирования. Я бы начал с создания класса SudokuPuzzle. Я бы дал ему следующие методы (для начала):

class SudokuPuzzle {
    // A constructor that initializes to all zeros.
    public SudokuPuzzle() { ... }

    // Create a legal finished board
    public randomizeBoard() { ... }

    // Take the legal board and hide some squares to make it a puzzle
    public turnIntoAPuzzle() { ... }

    // Output
    public display() { ... }
}

Это даст вам красивый, чистый объект для работы и разбивает вашу проблему на части, с которыми легче справиться. Я думаю, вы обнаружите, что даже randomizeBoard () труден. Ведь учтите правила судоку:

  • Каждая строка должна содержать каждое число ровно один раз
  • Каждый столбец должен содержать каждое число ровно один раз
  • Каждый квадрат из 9 мини-квадратов должен содержать каждое число ровно один раз.

Так что randomizeBoard () - нетривиальная задача. Я программирую компьютеры 45 лет и не имею четкого представления о том, как бы это написать.

Но ТОГДА вы можете перейти в turnIntoAPuzzle (). На самом деле это, вероятно, более легкая проблема. Вы можете случайным образом выбрать ячейку и решить, можно ли безопасно скрыть эту ячейку на основе правил, которые вы запрограммировали. Например, в простом режиме, если эта ячейка скрыта:

  • Можно ли его определить на основе всех остальных ячеек в этом квадрате из 9?
  • Можно ли это определить по этой строке?
  • Можно ли это определить по этой колонке?

В таком случае клетку можно спрятать. Вы можете использовать случайную функцию, чтобы найти ячейки, которые еще не скрыты, и выполнить свои правила.

Для средней жесткости добавьте такие правила, как:

  • Могу ли я определить эту ячейку на основе комбинации этого квадрата 9, этой строки и этого столбца?

Если в какой-то момент все ваши тесты вернут «нет, я не могу», тогда вы удалите эту ячейку из будущего рассмотрения скрытия и случайным образом выберете из оставшихся еще не скрытых ячеек.

Цикл до тех пор, пока список ячеек "возможно скрыть" не станет нулевым.

-

В этом посте представлен образец того, как подходить к подобным проблемам. Сломай. Выясните, как бы вы сделали это вручную, без компьютера, а затем превратите это в инструкции для компьютера.

Я думаю, что рандомизировать доску на самом деле сложнее, чем скрыть некоторые ячейки, потому что это довольно простой алгоритм. Я не уверен, что рандомизировать доску просто, но, возможно, это действительно неплохо. Но я думаю, что можно пойти и по плохому пути.

1
Joseph Larson 19 Июн 2020 в 15:35