数独的java实现

最新推荐文章于 2024-02-04 09:14:37 发布
最新推荐文章于 2024-02-04 09:14:37 发布
阅读量1.3k 收藏
点赞数
文章标签： java 存储 c string class 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyu13620781041/article/details/1910066
版权

  本例由于实现数独算法中的数组 界面未发

 package mypack01;

public class MySwingTest07 {

 // A,B,C,D,E,F,G,H,I;分别代表不同的九个区域
 // A B C
 // D E F
 // G H I

 // 生成的顺序为 A B D C G F H E I
 int A[][], B[][], C[][], D[][], E[][], F[][], G[][], H[][], I[][];

 // 临时的变量的数组 用于存储生成的临时的区域的值 最后利用方法 getint1() 或 getint2()
 // 将一维数组转换为二维数组 最终将生成的二维的数组赋值个相应的区域
 int temp[];

 // tt1 3行3列
 // tt2 6行3列
 // tt3 6行6列
 // 用于存储用于生成条件的特定数组
 int tt1[][], tt2[][], tt3[][];

 // intT 临时变量 用于存储生成的随机数字和1-9的数字
 // sum 临时变量 用于存储循环的次数 大于特定值(intSum)时 重新执行
 // FHsum临时变量 用于(getFH()方法)存储循环的次数 大于特定值(intSum)时 重新执行
 int intT, sum, FHsum = 0;

 // intT1 intT2 均为3行3列的数组 用于getFH()方法 记录每次生成的纪录的数字
 // 用于判断生成的F H 数组是否符合要求(值均为4时才符合要求)
 int intI1[][], intI2[][];

 // 特定值 用于控制执行的次数
 final int intSum = 40;

 //构造方法
 public MySwingTest07() {
  mainTest();
 }

 
 //控制程序的主方法
 public void mainTest() {

  temp = new int[9];
  tt1 = new int[3][3];
  tt2 = new int[6][3];
  tt3 = new int[6][6];
  I = new int[3][3];
  E = new int[3][3];

  getA();

  getB();
  getD();

  getC();
  getG();

  getF();
  getH();
  boolean b = false;
  // 使用循环来得到数组 F H
  while (getFH() == false) {
   if (b) {
    b = false;
    getF();
   } else {
    b = true;
    getH();
   }
  }
  getE();
  getI();

  printAll();
 }

 // 用于生成的数组不符合要求的时候 重新生成数组B D C G F H
 public void mainTest1() {
  getB();
  getD();

  getC();
  getG();

  getF();
  getH();
 }


 // 生成数组 A
 public void getA() {
  sum = 0;
  intT = 0;
  
  //生成的不重复的数组的值  将其赋值给temp临时数组
  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);

   //sum大于特定值时 重新生成自己本身 并将值全部清空为0
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    //判断生成的值是否已经存在 存在就赋值为0 退出本次循环
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   //判断生成的值是否出现过 不是0就是没有出现过 记录并循环生成下一个值
   if (intT != 0) {
    temp[i] = intT;
    i++;
   }
  }
  // System.out.println(sum + " A");
  A = getint1(temp);//调用方法将一维数组转换为二维数组
  // printInt(A);
 }

 // 生成数组 B
 public void getB() {
  sum = 0;
  intT = 0;

  //生成用于判读条件时的数组 并存储与临时变量tt1中
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt1[i][j] = A[i][j];
   }
  }

  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    //首先判断是否在本身的数组中出现过
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   
   //循环判断条件
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     // 小于3 表示第一行 和数组第一行比较判断 出现过就重新生成数字 并退出本次循环
     if (i < 3) {
      if (intT == tt1[0][k]) {
       intT = 0;
       break;
      }
      //小于6 表示第一行 和数组第二行比较判断 出现过就重新生成数字 并退出本次循环
     } else if (i < 6) {
      if (intT == tt1[1][k]) {
       intT = 0;
       break;
      }
      //小于9 表示第一行 和数组第三行比较判断 出现过就重新生成数字 并退出本次循环
     } else {
      if (intT == tt1[2][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " B");
  B = getint1(temp);
  // printInt(B);

 }

 
 // 生成数组 D
 public void getD() {
  sum = 0;
  intT = 0;

  //同B
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt1[i][j] = A[j][i];
   }
  }

  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     if (i < 3) {
      if (intT == tt1[0][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt1[1][k]) {
       intT = 0;
       break;
      }
     } else {
      if (intT == tt1[2][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " D");
  D = getint2(temp);
  // printInt(D);
 }

 
 // 生成数组 C
 public void getC() {
  sum = 0;
  intT = 0;

  //同B
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = A[i][j];
    tt2[i + 3][j] = B[i][j];
   }
  }

  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     if (i < 3) {
      if (intT == tt2[0][k] || intT == tt2[3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt2[1][k] || intT == tt2[4][k]) {
       intT = 0;
       break;
      }
     } else {
      if (intT == tt2[2][k] || intT == tt2[5][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " C");
  C = getint1(temp);
  // printInt(C);
 }

 
 // 生成数组 G
 public void getG() {
  sum = 0;
  intT = 0;

  //同B
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = A[j][i];
    tt2[i + 3][j] = D[j][i];
   }
  }
  
  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     if (i < 3) {
      if (intT == tt2[0][k] || intT == tt2[3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt2[1][k] || intT == tt2[4][k]) {
       intT = 0;
       break;
      }
     } else {
      if (intT == tt2[2][k] || intT == tt2[5][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " G");
  G = getint2(temp);
  // printInt(G);
 }

 
 // 生成数组 F
 public void getF() {
  sum = 0;
  intT = 0;

  //同B
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = D[i][j];
    tt2[i + 3][j] = C[j][i];
   }
  }
  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     if (i < 3) {
      if (intT == tt2[0][k] || intT == tt2[i + 3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt2[1][k] || intT == tt2[i][k]) {
       intT = 0;
       break;
      }
     } else {
      if (intT == tt2[2][k] || intT == tt2[i - 3][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " F");
  F = getint1(temp);
  // printInt(F);
 }

 
 // 生成数组 H
 public void getH() {
  sum = 0;
  intT = 0;

  //同B
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = G[i][j];
    tt2[i + 3][j] = B[j][i];
   }
  }
  for (int i = 0; i < 9;) {
   intT = (int) (Math.random() * 9 + 1);
   if (sum++ > intSum) {
    intT = 0;
    i = 0;
    sum = 0;
   }
   for (int j = 0; j < i; j++) {
    if (intT == temp[j] && i != 0) {
     intT = 0;
     break;
    }
   }
   if (intT != 0) {

    for (int k = 0; k < 3; k++) {
     if (i < 3) {
      if (intT == tt2[0][k] || intT == tt2[i + 3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt2[1][k] || intT == tt2[i][k]) {
       intT = 0;
       break;
      }
     } else {
      if (intT == tt2[2][k] || intT == tt2[i - 3][k]) {
       intT = 0;
       break;
      }
     }
    }
    if (intT != 0) {
     temp[i] = intT;
     i++;
    }

   }
  }
  // System.out.println(sum + " H");
  H = getint1(temp);
  // printInt(H);
 }

 
 // 生成数组 E
 public void getE() {
  intT = 0;
  
  //临时数组intTemp用于生成存储1-9个数字
  int intTemp[] = new int[9];
  for (int i = 0; i < 9; i++) {
   intTemp[i] = i + 1;
  }
  
  //生成判断的条件
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt3[i][j] = D[i][j];
    tt3[i][j + 3] = F[i][j];
    tt3[i + 3][j] = B[j][i];
    tt3[i + 3][j + 3] = H[j][i];
   }
  }

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

  {
   for (int j = 0; j < 9; j++) {
    intT = intTemp[j];
    if (intT == 0) {
     continue;
    }
    //循环判断条件数组
    for (int k = 0; k < 6; k++) {
     if (i < 3) {
      if (intT == tt3[0][k] || intT == tt3[i + 3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt3[1][k] || intT == tt3[i][k]) {
       intT = 0;
       break;
      }
     } else if (i < 9) {
      if (intT == tt3[2][k] || intT == tt3[i - 3][k]) {
       intT = 0;
       break;
      }
     }

    }
    //判断是否符合条件
    if (intT != 0) {
     //符合条件就赋值到数组 并将其标示为 0
     temp[i] = intT;
     intTemp[j] = 0;
     //做下一次循环
     i++;
     //退出循环
     break;
    }

   }

  }
  // System.out.println(sum + " E");
  E = getint1(temp);
  // printInt(E);

 }

  
 // 生成数组 I
 public void getI() {
  intT = 0;
  //同E
  int intTemp[] = new int[9];
  for (int i = 0; i < 9; i++) {
   intTemp[i] = i + 1;
  }

  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt3[i][j] = G[i][j];
    tt3[i][j + 3] = H[i][j];
    tt3[i + 3][j] = C[j][i];
    tt3[i + 3][j + 3] = F[j][i];
   }
  }

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

  {
   for (int j = 0; j < 9; j++) {
    intT = intTemp[j];
    if (intT == 0) {
     continue;
    }
    for (int k = 0; k < 6; k++) {
     if (i < 3) {
      if (intT == tt3[0][k] || intT == tt3[i + 3][k]) {
       intT = 0;
       break;
      }
     } else if (i < 6) {
      if (intT == tt3[1][k] || intT == tt3[i][k]) {
       intT = 0;
       break;
      }
     } else if (i < 9) {
      if (intT == tt3[2][k] || intT == tt3[i - 3][k]) {
       intT = 0;
       break;
      }
     }

    }
    if (intT != 0) {
     temp[i] = intT;
     intTemp[j] = 0;
     i++;
     break;
    }

   }

  }
  // System.out.println(sum + " I");
  I = getint1(temp);
  // printInt(I);
 }

 // 判断生成的数组 F H 是否符合要求 直到得到数组 F H
 public boolean getFH() {

  //判断标示值的数值是否大于特定值
  if (FHsum > intSum) {
   FHsum = 0;
   //如果成立就重新生成程序
   mainTest1();
  }

  //生成的数组用于存储标示值
  intI1 = new int[3][3];
  intI2 = new int[3][3];

  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt3[i][j] = G[i][j];
    tt3[i][j + 3] = H[i][j];
    tt3[i + 3][j] = C[j][i];
    tt3[i + 3][j + 3] = F[j][i];
   }
  }
  for (int k = 0; k < 3;) {
   for (int i = 0; i < 6; i++) {

    for (int j = 0; j < 6; j++) {
     if (tt3[k][i] == tt3[3][j]) {
      intI1[k][0]++;
     } else if (tt3[k][i] == tt3[4][j]) {
      intI1[k][1]++;
     } else if (tt3[k][i] == tt3[5][j]) {
      intI1[k][2]++;
     }
    }

   }
   //判断标示值 均为4时 执行下次循环 
   //判断值为4 是特定的条件
   if (intI1[k][0] == 4 && intI1[k][1] == 4 && intI1[k][2] == 4) {
    k++;
   } else {
    FHsum++;//标示值自加
    return false;

   }
  }

  
  //同上
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt3[i][j] = D[i][j];
    tt3[i][j + 3] = F[i][j];
    tt3[i + 3][j] = B[j][i];
    tt3[i + 3][j + 3] = H[j][i];
   }
  }
  for (int k = 0; k < 3;) {
   for (int i = 0; i < 6; i++) {

    for (int j = 0; j < 6; j++) {
     if (tt3[k][i] == tt3[3][j]) {
      intI2[k][0]++;
     } else if (tt3[k][i] == tt3[4][j]) {
      intI2[k][1]++;
     } else if (tt3[k][i] == tt3[5][j]) {
      intI2[k][2]++;
     }
    }

   }

   if (intI2[k][0] == 4 && intI2[k][1] == 4 && intI2[k][2] == 4) {
    k++;
   } else {
    FHsum++;
    return false;

   }
  }

  return true;
 }

 //程序的入口
 public static void main(String[] args) {
  // TODO 自动生成方法存根
  new MySwingTest07();

 }

 // 将一维数组转换为二维数组 横行
 public int[][] getint1(int temp[]) { // 横行
  int t[][] = new int[3][3];
  int tnum = 0;

  //依次将一维数组的值赋值给二维数组
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    t[i][j] = temp[tnum++];
   }
  }

  return t;
 }

 // 将一维数组转换为二维数组 竖行
 public int[][] getint2(int temp[]) { // 纵行
  int t[][] = new int[3][3];
  int tnum = 0;

  //同getint1();
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    t[j][i] = temp[tnum++];
   }
  }

  return t;
 }

  
 // 打印特定的数组 用于测试时使用 或单独打印特定的区域的数组时 使用
 public void printInt(int tt[][]) {
  //循环打印
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    System.out.print(tt[i][j]);
   }
   System.out.println();
  }
 }

 // 打印全部的数组的值 按照一定的格式
 public void printAll() {
  for (int i = 0; i < A.length; i++) {
   for (int j = 0; j < A[i].length; j++) {
    System.out.print(A[i][j] + " ");
   }
   for (int j = 0; j < B[i].length; j++) {
    System.out.print(B[i][j] + " ");
   }
   for (int j = 0; j < C[i].length; j++) {
    System.out.print(C[i][j] + " ");
   }
   System.out.println();
  }

  for (int i = 0; i < D.length; i++) {
   for (int j = 0; j < D[i].length; j++) {
    System.out.print(D[i][j] + " ");
   }
   for (int j = 0; j < E[i].length; j++) {
    System.out.print(E[i][j] + " ");
   }
   for (int j = 0; j < F[i].length; j++) {
    System.out.print(F[i][j] + " ");
   }
   System.out.println();
  }

  for (int i = 0; i < G.length; i++) {
   for (int j = 0; j < G[i].length; j++) {
    System.out.print(G[i][j] + " ");
   }
   for (int j = 0; j < H[i].length; j++) {
    System.out.print(H[i][j] + " ");
   }
   for (int j = 0; j < I[i].length; j++) {
    System.out.print(I[i][j] + " ");
   }
   System.out.println();
  }
 }

}

/*

生成条件的数组的思路:


一 纵向生成的数组: 使用方法getint1();
  1>D 判断A的纵向的行的所有数字
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt1[i][j] = A[j][i];
   }
  }
  即 tt1 数组中记录的数值  3行3列
  2>G 判断A D 的纵向的行的所有数字
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = A[j][i];
    tt2[i + 3][j] = D[j][i];
   }
  }
  即 tt2 数组中记录的数值  6行3列
  
  
二 横向生成的数组: 使用方法getint2();
  1>B 判断A的横向的行的所有数字
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt1[i][j] = A[i][j];
   }
  }
  即 tt1 数组中记录的数值  3行3列
  2>C 判断A B 的横向的行的所有数字   F H 均和C相同
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt2[i][j] = A[i][j];
    tt2[i + 3][j] = B[i][j];
   }
  }
  即 tt2 数组中记录的数值  6行3列
  3>E 判断D F 的横向的行的所有数字 并判断B H 的纵向的行的所有数字   I与其相同
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    tt3[i][j] = D[i][j];
    tt3[i][j + 3] = F[i][j];
    tt3[i + 3][j] = B[j][i];
    tt3[i + 3][j + 3] = H[j][i];
   }
  }
  即 tt3 数组中记录的数值  6行6列
  

程序中的关键点:
 1>生成的区域的顺序
 2>生成不同的区域时的方法不同 注意区分
  1.A
  2.B D
  3.C G
  4.F H
  5.E I
 3>F H 数组的生成  即方法getFH()
 4>条件均为4时 保证E I区域中的每个位置都只有唯一的值出现
  每组6个数字 共12个 相同的值为4个 不同的值为4个 即8个
  每个区域共9个数字 已经确定的数字8个 那么唯一的数字的位置就确定了

*/

xiaoyu13620781041
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java数独游戏的实现
QQ21503882的博客
02-13 577
数独是一款逻辑游戏，起源于18世纪末的瑞士，在美国发展起来，并在日本发展到顶峰，它使用纸张和笔来进行数字游戏。玩家需要基于9×9的磁盘已知的数字,推理出所有剩余的空间数据,并满足每一行,每一列、每一个小宫3 * 3)中的数字1 - 9不重复，数独游戏可以锻炼人的逻辑思维能力,并不是测试人的计算能力,是一个老少咸宜的益智游戏。本课题主要使用了Eclipse平台、java swing、awt等技术进行开发。游戏界面简洁美观，操作便捷，功能齐全，具有一定的实用性和游戏性，适合广大数独爱好者们进行数独游戏。
Java快乐小游戏---数独
qq_42594306的博客
06-28 1118
想着这个数组不行，进入了死循环的话就再利用核心代码重新刷新就好，想了用boolean值，用秒数等都出了好多的错误。最近学各种工具和框架概念学麻了，效果的养分和热情严重不足，背负着要搞黄面试，自己做了两个小游戏。本以为会顺顺利利的，结果显示数组的时候直接卡死在某个数字上，这个位置填哪个数字都不行。在刚开始想组合数独的时候想着这在每行每列里进行重复性判断，思路图和代码如下。再经过遮挡+点击增加的功能+渲染+点击位置和显示数字的调整，数独就完成了。实在不行，找我的GPT小助手在线提供答案，思路和核心代码如下。
java 生成数独
heshiyuan1406146854的博客
10-08 198
【代码】java 生成数独。
JavaSE期末课程设计——数独小游戏（IDEA、eclipse）
最新发布
爱吃雪糕的小布丁的博客
02-04 799
声明：该文章只是做技术分享，若侵权请联系我删除。！！使用技术：Java（JavaSE期末课程设计）主要内容：用java实现桌面版数独小游戏具体的代码也在该链接下。
简单实现java数独游戏
08-28
简单实现java数独游戏 Java数独游戏是一种基于Java语言实现的数独游戏，通过使用JavaFX组件来创建游戏界面，并使用随机算法生成数独游戏矩阵。在本文中，我们将详细介绍如何简单实现Java数独游戏的过程，包括游戏的...
python实现数独游戏 java简单实现数独游戏
09-20
接下来是Java实现。Java版本的`Shudu`类包含两个方法：`make_board`和`get_board`。这两个方法的功能与Python版本类似，生成数独盘面。`make_board`通过不断调用`get_board`直到得到有效的数独盘面。`get_board`使用...
java-数独-小游戏
06-30
本项目“java-数独-小游戏”是利用Java来实现的一个简单的数独游戏，它展示了如何运用编程技巧来解决逻辑问题。数独是一种基于逻辑的数字填充游戏，玩家需要在9x9的网格中填入数字，使得每一行、每一列以及每一个宫...
java实现数独游戏.zip
09-10
Java 实现数独游戏是一个基于编程技术的项目，主要涵盖了Java语言的核心特性和面向对象编程的概念。数独是一种逻辑解谜游戏，玩家需要通过填充数字9来完成一个9x9的网格，使得每一行、每一列以及每一个宫（3x3的小...
Java数独游戏代码
03-06
Java数独游戏是一种基于编程实现的经典逻辑游戏，它利用Java语言的强大功能，为玩家提供了在电子设备上玩数独的机会。本项目包含了两种版本的数独游戏：网页版和独立的jar应用程序。这两种版本都提供了用户友好的...
JSudoku:核心数独游戏的Java实现
06-01
独角兽 JSudoku是一个基于 Java 的数独库。 它提供了一个包含各种数独相关算法的框架。 该库提供以下类： 模型：模拟数独拼图网格的类。 生成器：根据给定的难度级别生成新数独谜题的类。 Solver：一个实现各种算法来解决数独谜题的类。 提供了以下算法： 行消除技术 除柱技术 小电网消除技术 独行侠技术 列独行侠技术 Minigrid 独行侠技术 排双胞胎技术 柱孪晶技术 Minigrid Twins 技术 行三胞胎技术 柱三联技术 Minigrid 三胞胎技术 蛮力消除技术 文档 可以在该文档。 用法 为了能够使用该库，您可以从存储库克隆源代码： $ git clone https://sokolovic@bitbucket.org/sokolovic/jsudoku.git 您可以通过运行Ant来构建库 JAR，如下所示（假设您位于build.xml文件所在的同一
java实现数独游戏(九宫格)
07-01
用java实现的数独游戏，无论界面还是算法，都挺不错
Java实现数独游戏源代码，包含界面
07-16
由于学生水平有限，所以只是实现了数独的功能，作为一个练习题并为考虑算法效率。
Java数独游戏
12-28
Java数独游戏 好玩。
java语言带界面的数独游戏
09-08
实现带界面的数独游戏，并且有难度等级选择以及开始新游戏及检查的功能，保证有解！
数独怎么用Java实现，写一下实现的代码
weixin_42576410的博客
02-13 537
要用Java实现数独，需要先定义一个9x9的二维数组来保存游戏的状态，然后定义一个方法，该方法检查每一行、每一列、每一个3x3的九宫格是否有重复的数字。示例代码如下：public static boolean isValidSudoku(int[][] board) { for (int i = 0; i < 9; i++) { HashSet rowSet = new Hash...
Java 编写数独游戏 窗体程序 完整源码
bangxiecode的博客
02-17 2518
java 编写数独 游戏窗体程序 完整源码游戏，可以直接用来做课程设计或者毕业设计；代码功能完善，下载后可以直接运行！！
java 数独算法_java版数独游戏核心算法（一）
weixin_34966346的博客
02-12 459
之前学习javascript时用javascript写过一个数独游戏，最近看了一点java的内容，于是就心血来潮想搞一个java版的数独游戏。现在将全部代码分享出来和大家学习交流，当然代码中有着各种各样的问题和不足之处，望各位朋友批评指点。以下是生成数独地图的核心算法，算法不是很好，也是之前参考过网上的一些思想：package hlc.shudu.src;/** 数独的帮助类，里面提供数据所需的所...
使用java解数独
sinat_34067387的博客
08-05 2059
说明 先根据规则解数独, 规则1: 如果备选数字只有一个, 那么就填入这个数字 规则2: 如果在3*3单元格中, 或者一行, 或者一列中, 某个备选数字在所有的备选数字中只出现了一次, 那么就填入这个数字. 再暴力破解数独, 依次填入备选数字, 如果不能解开, 换下一个备选数字, 直到数独完全解开. 代码 package com.example.springboot01; import org.junit.Test; import org.junit.platform.commons.util.
java 数独游戏_java数独游戏完整版分享
weixin_42347778的博客
03-07 2041
本文实例为大家分享了java数独游戏的具体代码，供大家参考，具体内容如下自己写的数独游戏，共9关，代码如下：1、DoShudu类用于产生数独数组import java.util.Random;public class DoShudu {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated m...
数独游戏java代码实现
04-20
关于数独游戏java代码实现，我可以给你一些参考。数独游戏是一种逻辑、编程和算法综合练习的好选择。下面是一些基本步骤： 1. 创建一个二维数组，大小为9x9，用于表示数独面板； 2. 初始化数组，将所有位置的数值设...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值