Ⅰ 數獨和java高手進來！
我玩過幾次。沒研究裡面的演算法。做游戲不用演算法是不可能的。
如果需要演算法，給個懸賞我給你演算法。
Ⅱ JAVA應用里的決戰數獨王怎麼玩
先玩簡單的，再玩中等的，有難度的，一步一步，慢慢來，多做了就會有經驗了。
1,直接看,從1到9開始，一個數字一個數字的找，肯定能找到幾個可以填的數字。
2,小九宮，橫行，縱列，要一步一步的做，上下左右，可以推出一些數字
3,排除法。在一個格里填寫倆個候選數字，而且，這一格只能填這倆數字，然後在可以確定倆個數字的格里全都填上，往往填著填著，就會出現轉機。
4，最好就要靠自己的猜測了
Ⅲ java高手進，求一個數獨游戲java代碼
public class ShuDu {
/**存儲數字的數組*/
static int[][] n = new int[9][9];
/**生成隨機數字的源數組，隨機數字從該數組中產生*/
static int[] num = {1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
//生成數字
for(int i = 0;i < 9;i++){
//嘗試填充的數字次數
int time = 0;
//填充數字
for(int j = 0;j < 9;j++){
//產生數字
n[i][j] = generateNum(time);
//如果返回值為0，則代表卡住，退回處理
//退回處理的原則是：如果不是第一列，則先倒退到前一列，否則倒退到前一行的最後一列
if(n[i][j] == 0){
//不是第一列，則倒退一列
if(j > 0){
j-=2;
continue;
}else{//是第一列，則倒退到上一行的最後一列
i--;
j = 8;
continue;
}
}
//填充成功
if(isCorret(i,j)){
//初始化time，為下一次填充做准備
time = 0;
}else{ //繼續填充
//次數增加1
time++;
//繼續填充當前格
j--;
}
}
}
//輸出結果
for(int i = 0;i < 9;i++){
for(int j = 0;j < 9;j++){
System.out.print(n[i][j] + " ");
}
System.out.println();
}
}
/**
* 是否滿足行、列和3X3區域不重復的要求
* @param row 行號
* @param col 列號
* @return true代表符合要求
*/
public static boolean isCorret(int row,int col){
return (checkRow(row) & checkLine(col) & checkNine(row,col));
}
/**
* 檢查行是否符合要求
* @param row 檢查的行號
* @return true代表符合要求
*/
public static boolean checkRow(int row){
for(int j = 0;j < 8;j++){
if(n[row][j] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[row][j] == n[row][k]){
return false;
}
}
}
return true;
}
/**
* 檢查列是否符合要求
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkLine(int col){
for(int j = 0;j < 8;j++){
if(n[j][col] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[j][col] == n[k][col]){
return false;
}
}
}
return true;
}
/**
* 檢查3X3區域是否符合要求
* @param row 檢查的行號
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkNine(int row,int col){
//獲得左上角的坐標
int j = row / 3 * 3;
int k = col /3 * 3;
//循環比較
for(int i = 0;i < 8;i++){
if(n[j + i/3][k + i % 3] == 0){
continue;
}
for(int m = i+ 1;m < 9;m++){
if(n[j + i/3][k + i % 3] == n[j + m/3][k + m % 3]){
return false;
}
}
}
return true;
}
/**
* 產生1-9之間的隨機數字
* 規則：生成的隨機數字放置在數組8-time下標的位置，隨著time的增加，已經嘗試過的數字將不會在取到
* 說明：即第一次次是從所有數字中隨機，第二次時從前八個數字中隨機，依次類推，
* 這樣既保證隨機，也不會再重復取已經不符合要求的數字，提高程序的效率
* 這個規則是本演算法的核心
* @param time 填充的次數，0代表第一次填充
* @return
*/
public static int generateNum(int time){
//第一次嘗試時，初始化隨機數字源數組
if(time == 0){
for(int i = 0;i < 9;i++){
num[i] = i + 1;
}
}
//第10次填充，表明該位置已經卡住，則返回0，由主程序處理退回
if(time == 9){
return 0;
}
//不是第一次填充
//生成隨機數字，該數字是數組的下標，取數組num中該下標對應的數字為隨機數字
int ranNum = (int)(Math.random() * (9 - time));
//把數字放置在數組倒數第time個位置，
int temp = num[8 - time];
num[8 - time] = num[ranNum];
num[ranNum] = temp;
//返回數字
return num[8 - time];
}
}
這是控制台程序 - -你看著學習著改改~
Ⅳ Java數獨游戲代碼
public class ShuDu {
/**存儲數字的數組*/
static int[][] n = new int[9][9];
/**生成隨機數字的源數組，隨機數字從該數組中產生*/
static int[] num = {1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
//生成數字
for(int i = 0;i < 9;i++){
//嘗試填充的數字次數
int time = 0;
//填充數字
for(int j = 0;j < 9;j++){
//產生數字
n[i][j] = generateNum(time);
//如果返回值為0，則代表卡住，退回處理
//退回處理的原則是：如果不是第一列，則先倒退到前一列，否則倒退到前一行的最後一列
if(n[i][j] == 0){
//不是第一列，則倒退一列
if(j > 0){
j-=2;
continue;
}else{//是第一列，則倒退到上一行的最後一列
i--;
j = 8;
continue;
}
}
//填充成功
if(isCorret(i,j)){
//初始化time，為下一次填充做准備
time = 0;
}else{ //繼續填充
//次數增加1
time++;
//繼續填充當前格
j--;
}
}
}
//輸出結果
for(int i = 0;i < 9;i++){
for(int j = 0;j < 9;j++){
System.out.print(n[i][j] + " ");
}
System.out.println();
}
}
/**
* 是否滿足行、列和3X3區域不重復的要求
* @param row 行號
* @param col 列號
* @return true代表符合要求
*/
public static boolean isCorret(int row,int col){
return (checkRow(row) & checkLine(col) & checkNine(row,col));
}
/**
* 檢查行是否符合要求
* @param row 檢查的行號
* @return true代表符合要求
*/
public static boolean checkRow(int row){
for(int j = 0;j < 8;j++){
if(n[row][j] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[row][j] == n[row][k]){
return false;
}
}
}
return true;
}
/**
* 檢查列是否符合要求
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkLine(int col){
for(int j = 0;j < 8;j++){
if(n[j][col] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[j][col] == n[k][col]){
return false;
}
}
}
return true;
}
/**
* 檢查3X3區域是否符合要求
* @param row 檢查的行號
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkNine(int row,int col){
//獲得左上角的坐標
int j = row / 3 * 3;
int k = col /3 * 3;
//循環比較
for(int i = 0;i < 8;i++){
if(n[j + i/3][k + i % 3] == 0){
continue;
}
for(int m = i+ 1;m < 9;m++){
if(n[j + i/3][k + i % 3] == n[j + m/3][k + m % 3]){
return false;
}
}
}
return true;
}
/**
* 產生1-9之間的隨機數字
* 規則：生成的隨機數字放置在數組8-time下標的位置，隨著time的增加，已經嘗試過的數字將不會在取到
* 說明：即第一次次是從所有數字中隨機，第二次時從前八個數字中隨機，依次類推，
* 這樣既保證隨機，也不會再重復取已經不符合要求的數字，提高程序的效率
* 這個規則是本演算法的核心
* @param time 填充的次數，0代表第一次填充
* @return
*/
public static int generateNum(int time){
//第一次嘗試時，初始化隨機數字源數組
if(time == 0){
for(int i = 0;i < 9;i++){
num[i] = i + 1;
}
}
//第10次填充，表明該位置已經卡住，則返回0，由主程序處理退回
if(time == 9){
return 0;
}
//不是第一次填充
//生成隨機數字，該數字是數組的下標，取數組num中該下標對應的數字為隨機數字
int ranNum = (int)(Math.random() * (9 - time));
//把數字放置在數組倒數第time個位置，
int temp = num[8 - time];
num[8 - time] = num[ranNum];
num[ranNum] = temp;
//返回數字
return num[8 - time];
}
}
Ⅳ 求用java寫一個數獨游戲
public class ShuDu {
/**存儲數字的數組*/
static int[][] n = new int[9][9];
/**生成隨機數字的源數組，隨機數字從該數組中產生*/
static int[] num = {1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
//生成數字
for(int i = 0;i < 9;i++){
//嘗試填充的數字次數
int time = 0;
//填充數字
for(int j = 0;j < 9;j++){
//產生數字
n[i][j] = generateNum(time);
//如果返回值為0，則代表卡住，退回處理
//退回處理的原則是：如果不是第一列，則先倒退到前一列，否則倒退到前一行的最後一列
if(n[i][j] == 0){
//不是第一列，則倒退一列
if(j > 0){
j-=2;
continue;
}else{//是第一列，則倒退到上一行的最後一列
i--;
j = 8;
continue;
}
}
//填充成功
if(isCorret(i,j)){
//初始化time，為下一次填充做准備
time = 0;
}else{ //繼續填充
//次數增加1
time++;
//繼續填充當前格
j--;
}
}
}
//輸出結果
for(int i = 0;i < 9;i++){
for(int j = 0;j < 9;j++){
System.out.print(n[i][j] + " ");
}
System.out.println();
}
}
/**
* 是否滿足行、列和3X3區域不重復的要求
* @param row 行號
* @param col 列號
* @return true代表符合要求
*/
public static boolean isCorret(int row,int col){
return (checkRow(row) & checkLine(col) & checkNine(row,col));
}
/**
* 檢查行是否符合要求
* @param row 檢查的行號
* @return true代表符合要求
*/
public static boolean checkRow(int row){
for(int j = 0;j < 8;j++){
if(n[row][j] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[row][j] == n[row][k]){
return false;
}
}
}
return true;
}
/**
* 檢查列是否符合要求
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkLine(int col){
for(int j = 0;j < 8;j++){
if(n[j][col] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[j][col] == n[k][col]){
return false;
}
}
}
return true;
}
/**
* 檢查3X3區域是否符合要求
* @param row 檢查的行號
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkNine(int row,int col){
//獲得左上角的坐標
int j = row / 3 * 3;
int k = col /3 * 3;
//循環比較
for(int i = 0;i < 8;i++){
if(n[j + i/3][k + i % 3] == 0){
continue;
}
for(int m = i+ 1;m < 9;m++){
if(n[j + i/3][k + i % 3] == n[j + m/3][k + m % 3]){
return false;
}
}
}
return true;
}
/**
* 產生1-9之間的隨機數字
* 規則：生成的隨機數字放置在數組8-time下標的位置，隨著time的增加，已經嘗試過的數字將不會在取到
* 說明：即第一次次是從所有數字中隨機，第二次時從前八個數字中隨機，依次類推，
* 這樣既保證隨機，也不會再重復取已經不符合要求的數字，提高程序的效率
* 這個規則是本演算法的核心
* @param time 填充的次數，0代表第一次填充
* @return
*/
public static int generateNum(int time){
//第一次嘗試時，初始化隨機數字源數組
if(time == 0){
for(int i = 0;i < 9;i++){
num[i] = i + 1;
}
}
//第10次填充，表明該位置已經卡住，則返回0，由主程序處理退回
if(time == 9){
return 0;
}
//不是第一次填充
//生成隨機數字，該數字是數組的下標，取數組num中該下標對應的數字為隨機數字
int ranNum = (int)(Math.random() * (9 - time));
//把數字放置在數組倒數第time個位置，
int temp = num[8 - time];
num[8 - time] = num[ranNum];
num[ranNum] = temp;
//返回數字
return num[8 - time];
}
}
Ⅵ 數獨設計思路及全解
開始的話：這個程序現在還不穩定，有時出現運行時錯誤，跟蹤是由於vector的size()方法引起的。調試發現中間的min_seq並沒有完全按照作者的意圖變化。
運行時，如果出現錯誤，就反復運行，運行成功即可出現一個正確的9*9數獨矩陣。
如果要玩預先填充一些數的游戲，只需修改初始矩陣即可。
演算法：為每個位置定義一個可選元素集合，每個更新是把它所在的行，列,所在的3×3方陣中已出現的元素從集合中去掉。填充時，從最小候選集合中選一個(可隨即)填進去，更新候選集合，再填充，直到所有位置填充完畢，游戲結束。
/*******9×9數獨游戲的計算機程序*******/
/*******作者：xiaocui******************/
/*******時間：2006.6.23****************/
/*******版本：v1.0*********************/
/*******演算法思想***********************/
/******對每個位置的元素，考慮其可選取的數字
的集合，每次把候選元素個數最小的那個位置填充
從該最小候選集合中隨機選取一個元素填充，重復
這個過程，直到所有元素填充完畢************/
/****適用填充全空的數獨方格 和 填充已有一些數的數獨方格*****/
/****對初始化的候選集的第一次更新正是為了解決第2類數獨游戲***/
/****對於已填充一部分元素的，直接修改MATRIX矩陣即可*****/
/****數獨游戲的結果不止一種********/
#include <iostream>
#include <ctime>
#include <vector>
using namespace std;
/**********初始9×9的矩陣*************/
/******元素為0，說明該位置還未填充***/
int MATRIX[9][9]={ {0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0} };
/*******初始給出的元素個數***********/
int INITIAL_COUNT;
/********已填充元素個數，作為填充結束標志**********/
int FINISH_COUNT=0;
/********各個元素的初始候選集合*******/
vector<vector<int> > IVEC(81);
/**************函數原型******************/
/*********得到初始給出的元素個數*******/
int get_initialcount();
/*******初始化候選集合***************/
void initial_candidate();
/***********從vector中刪除指定元素*******/
void delete_value(vector<int> &ivec,int value);
/********更新候選集合**************/
void refresh_candidate();
/*********返回9×9候選集合元素最少的候選集合序號*******/
int min_seq();
/********隨機生成一個位置序號並取得該序號所對應的元素值******/
int choose_seq(int min_seq);
/*******填充該元素並判斷是否填充完畢********/
int is_finish(int min_seq, int choose_value);
int main()
{
/******得到初始給出的元素個數*****/
INITIAL_COUNT=get_initialcount();
/******初始化候選集合*******/
initial_candidate();
/********先更新候選集合(為了應付已經填充一部分數的情況)******/
refresh_candidate();
int i;
int MinSeq;
int ChooseValue;
MinSeq=min_seq();
ChooseValue=choose_seq(MinSeq);
while(is_finish(MinSeq,ChooseValue)!=1)
{
refresh_candidate();
MinSeq=min_seq();
ChooseValue=choose_seq(MinSeq);
}
/**********輸出填好的數獨游戲結果*********/
for( i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
cout<<MATRIX[i][j]<<'\t';
}
cout<<endl;
}
return 0;
}
/*******************函數定義***********************/
/*********得到初始給出的元素個數*******/
int get_initialcount()
{
int count=0;
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
if(MATRIX[i][j]!=0)
{
count++;
}
}
}
return count;
}
/*******初始化候選集合***************/
void initial_candidate()
{
for(int i=0;i<81;++i)
{
for(int j=1;j<10;++j)
{
IVEC[i].push_back(j);
}
}
}
/***********從vector中刪除指定元素*******/
void delete_value(vector<int> &ivec,int value)
{
/*******如果ivec已經為空，直接退出**********/
if (ivec.size()==0)
{
return;
}
vector<int>::iterator iter=ivec.begin();
while( iter<ivec.end() && (*iter)!=value )
{
iter++;
}
if(iter<ivec.end())//在vector中找到已填充的元素，把它刪除
{
ivec.erase(iter);
}
}
/********更新候選集合**************/
void refresh_candidate()
{
int i;
int rownum,colnum;
int row,col;
/******更新81個vector*******/
for(i=0;i<81;++i)
{
row=i/9;
col=i%9;
if(MATRIX[row][col]!=0)//該位置已經填充
{
if(IVEC[i].size()!=0)//該vector不空
{
/********刪除整個候選集***********/
IVEC[i].erase(IVEC[i].begin(),IVEC[i].end());
}
}
else
{
/*****刪除同一行中的元素****/
for(colnum=0;colnum<9;++colnum)
{
delete_value(IVEC[i],MATRIX[row][colnum]);
}
/*****刪除同一列中的元素****/
for(rownum=0;rownum<9;++rownum)
{
delete_value(IVEC[i],MATRIX[rownum][col]);
}
/*****刪除在一個3×3方陣中的元素******/
/******在第1塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==0)
{
for(int r=0;r<3;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第2塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==1)
{
for(int r=0;r<3;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第3塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==2)
{
for(int r=0;r<3;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第4塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==0)
{
for(int r=3;r<6;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第5塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==1)
{
for(int r=3;r<6;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第6塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==2)
{
for(int r=3;r<6;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第7塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==0)
{
for(int r=6;r<9;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第8塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==1)
{
for(int r=6;r<9;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第9塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==2)
{
for(int r=6;r<9;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
}
}
}
/*********返回9×9候選集合元素最少的候選集合序號*******/
int min_seq()
{
int count[81];
int i;
for(i=0;i<81;++i)
{
count[i]=IVEC[i].size();
}
int value=10;
int min_seq;
for(i=0;i<81;++i)
{
if(count[i]==0)
{
continue;
}
if(count[i]<value)
{
value=count[i];
min_seq=i;
}
}
return min_seq;
}
/********隨機生成一個位置序號並取得該序號所對應的元素值******/
int choose_seq(int min_seq)
{
/*****根據當前時間設置種子******/
srand((unsigned)time( NULL ));
int random_seq=rand()%(IVEC[min_seq].size());
return IVEC[min_seq][random_seq];
}
/*******填充該元素並判斷是否填充完畢********/
int is_finish(int min_seq, int choose_value)
{
int row, column;
row=min_seq/9;
column=min_seq%9;
MATRIX[row][column]=choose_value;
FINISH_COUNT++; /****已填充元素個數加1*****/
/*******填充完畢判斷********/
if(FINISH_COUNT==81-INITIAL_COUNT)
{
return 1;
}
else
{
return 0;
}
}
http://den.idv.tw/den/java/sudo/makeprob.php
http://hi..com/cuifenghui/blog/item/f771396dd111bbfb421694ee.html
希望對你有幫助！！
Ⅶ 要用java做一個九宮格數獨，不太會做
直接用個數組存起來，他輸什麼你就存到相應位置不就行了？是需要你解還是只是填就可以了？
Ⅷ 什麼軟體可以做出數獨
hodoku你網路搜索這個就找到了需要java環境的支持。還有數獨游戲就叫做 sudoku 。只有0.32m 。分5個難度，每個難度1000關。。我想足夠我玩到這個手機報廢了。。就是在360手機助手裡找的。其實我更想找一個可以玩鋸齒數獨、殺手數獨的軟體，一直沒有發現呢。希望能幫助你！
Ⅸ 用java做一個數獨游戲，有現成代碼，只需弄一下文字的東西就可以啦，不用太復雜，普普通通的就行.
public class ShuDu {
/**存儲數字的數組*/
static int[][] n = new int[9][9];
/**生成隨機數字的源數組，隨機數字從該數組中產生*/
static int[] num = {1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
//生成數字
for(int i = 0;i < 9;i++){
//嘗試填充的數字次數
int time = 0;
//填充數字
for(int j = 0;j < 9;j++){
//產生數字
n[i][j] = generateNum(time);
//如果返回值為0，則代表卡住，退回處理
//退回處理的原則是：如果不是第一列，則先倒退到前一列，否則倒退到前一行的最後一列
if(n[i][j] == 0){
//不是第一列，則倒退一列
if(j > 0){
j-=2;
continue;
}else{//是第一列，則倒退到上一行的最後一列
i--;
j = 8;
continue;
}
}
//填充成功
if(isCorret(i,j)){
//初始化time，為下一次填充做准備
time = 0;
}else{ //繼續填充
//次數增加1
time++;
//繼續填充當前格
j--;
}
}
}
//輸出結果
for(int i = 0;i < 9;i++){
for(int j = 0;j < 9;j++){
System.out.print(n[i][j] + " ");
}
System.out.println();
}
}
/**
* 是否滿足行、列和3X3區域不重復的要求
* @param row 行號
* @param col 列號
* @return true代表符合要求
*/
public static boolean isCorret(int row,int col){
return (checkRow(row) & checkLine(col) & checkNine(row,col));
}
/**
* 檢查行是否符合要求
* @param row 檢查的行號
* @return true代表符合要求
*/
public static boolean checkRow(int row){
for(int j = 0;j < 8;j++){
if(n[row][j] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[row][j] == n[row][k]){
return false;
}
}
}
return true;
}
/**
* 檢查列是否符合要求
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkLine(int col){
for(int j = 0;j < 8;j++){
if(n[j][col] == 0){
continue;
}
for(int k =j + 1;k< 9;k++){
if(n[j][col] == n[k][col]){
return false;
}
}
}
return true;
}
/**
* 檢查3X3區域是否符合要求
* @param row 檢查的行號
* @param col 檢查的列號
* @return true代表符合要求
*/
public static boolean checkNine(int row,int col){
//獲得左上角的坐標
int j = row / 3 * 3;
int k = col /3 * 3;
//循環比較
for(int i = 0;i < 8;i++){
if(n[j + i/3][k + i % 3] == 0){
continue;
}
for(int m = i+ 1;m < 9;m++){
if(n[j + i/3][k + i % 3] == n[j + m/3][k + m % 3]){
return false;
}
}
}
return true;
}
/**
* 產生1-9之間的隨機數字
* 規則：生成的隨機數字放置在數組8-time下標的位置，隨著time的增加，已經嘗試過的數字將不會在取到
* 說明：即第一次次是從所有數字中隨機，第二次時從前八個數字中隨機，依次類推，
* 這樣既保證隨機，也不會再重復取已經不符合要求的數字，提高程序的效率
* 這個規則是本演算法的核心
* @param time 填充的次數，0代表第一次填充
* @return
*/
public static int generateNum(int time){
//第一次嘗試時，初始化隨機數字源數組
if(time == 0){
for(int i = 0;i < 9;i++){
num[i] = i + 1;
}
}
//第10次填充，表明該位置已經卡住，則返回0，由主程序處理退回
if(time == 9){
return 0;
}
//不是第一次填充
//生成隨機數字，該數字是數組的下標，取數組num中該下標對應的數字為隨機數字
int ranNum = (int)(Math.random() * (9 - time));
//把數字放置在數組倒數第time個位置，
int temp = num[8 - time];
num[8 - time] = num[ranNum];
num[ranNum] = temp;
//返回數字
return num[8 - time];
}
}
在網上找的
Ⅹ 各位大神 Java數獨游戲界面已經做好 不過個人還想做一個游戲封面 請問如何把游戲界面和封面連接起來呢 謝
android的嗎？ 如果是安卓的 直接讓啟動的時候進入「封面「就好了等待幾秒後再跳轉到菜單界面