1. import java.util.*;
   
2. 
   
3. /*
   
4. 1        2        3
   
5. 4        5        6
   
6. 7        8
   
7. 
   
8. 1        2        3
   
9. 4        5        6
   
10. 7        8
    
11. 
    
12. ■■■■■■■                6        =7*1-1        // 7列,5行               
    
13. ■1■2■3■                13        =7*2-1                8        10        12                0        1        2
    
14. ■4■5■6■                20        =7*3-1                15        17        19                3        4        5
    
15. ■7■8■ ■                27        =7*4-1                22        24        26                6        7        8
    
16. ■■■■■■■                34        =7*5-1
    
17. 
    
18. 用一个数组定义9个位置，通过WASD进行空白的移动。
    
19. 
    
20. */
    
21. 
    
22. class YouXi
    
23. {
    
24.         public static void main (String[] args)
    
25.         {
    
26.                 GamePingTu gg=new GamePingTu ();
    
27.                 gg.run();
    
28.         }
    
29. }
    
30. 
    
31. class GamePingTu
    
32. {
    
33.         private int [] arr =new int [9];
    
34.         private int [] arrV={1,2,3,4,5,6,7,8,0};        //目标数组，如果变化数组与目标数组内值对应都相同则win。
    
35.         String str = "  ";                        //将数组输出为0的位置替换为空白。
    
36.         boolean xunHuan = true;
    
37. 
    
38.         {
    
39.                 Random r = new Random();
    
40.                 arr[0]=r.nextInt(9);                        //先产生第一个随机数，到数组第一位置。
    
41.                
    
42.                 for (int i =1;i<9 ;i++ )        //通过一个for产生随机数。
    
43.                 {
    
44.                         do
    
45.                         {
    
46.                                 arr[i]=r.nextInt(9);               
    
47.                                 for (int ii=0;ii<i ;ii++ )                //判断产生随机数如果与前面数相同，则xunHuan=true，进入循环，重新生成数。
    
48.                                 {
    
49.                                         if (arr[i]==arr[ii])
    
50.                                         {
    
51.                                                 arr[i]=r.nextInt(9);
    
52.                                                 xunHuan=true;
    
53.                                                 ii=i;
    
54.                                         }
    
55.                                         else
    
56.                                                 xunHuan=false;
    
57.                                 }
    
58.                         }
    
59.                         while (xunHuan);                //判断产生随机数如果与前面数相同，则xunHuan=true，进入循环，重新生成数。
    
60.                 }
    
61. 
    
62.                 defaultPrint();
    
63.         }
    
64. 
    
65.         public void run()                //运行函数
    
66.         {
    
67.                 Scanner in =new Scanner (System.in);
    
68.                 System.out.println("请输入w，a，s，d（必须小写）按规则游戏。");
    
69.                 String ss =in.nextLine();
    
70.                 caseSS(ss);
    
71. 
    
72.                 while (win())
    
73.                 {
    
74.                         ss=in.nextLine();
    
75.                         caseSS(ss);
    
76.                 }
    
77. 
    
78.                 System.out.println("恭喜过关");
    
79. 
    
80.         }
    
81. 
    
82.         private boolean win()                       
    
83.                 //对游戏win的判断:游戏运行数组与目标（V）数组，对应位置数值有任一不相等，返回True，对应位置值都相等，则返回false.
    
84.         {
    
85.                 for (int i=0;i<9 ;i++ )
    
86.                 {
    
87.                         if (arr[i]!=arrV[i])
    
88.                                 return true;
    
89.                 }
    
90. 
    
91.                 return false;
    
92.         }
    
93. 
    
94.         private void caseSS(String ss)                //对输入的 ss （String类型)，进行Switch选择，对应调用动作函数。
    
95.         {
    
96.                 switch (ss)
    
97.                 {
    
98.                 case "s":
    
99.                         upW();
    
100.                         defaultPrint();
     
101.                         break;
     
102.                 case "d":
     
103.                         leftA();
     
104.                         defaultPrint();
     
105.                         break;
     
106.                 case "w":
     
107.                         downS();
     
108.                         defaultPrint();
     
109.                         break;
     
110.                 case "a":
     
111.                         rightD();
     
112.                         defaultPrint();
     
113.                         break;
     
114.                 default:
     
115.                         defaultPrint();
     
116.                         break;
     
117.                 }
     
118.                 return;
     
119.         }
     
120. 
     
121.         private void upW()                // 值为0对应角标数值的与对应角标正上面数值换位。
     
122.         {
     
123.                 if(arr[0]!=0 && arr[1]!=0 && arr[2]!=0)
     
124.                         swap(arr,getIndex0(),getIndex0()-3);
     
125.                
     
126.                 return;
     
127.                        
     
128.         }
     
129. 
     
130.         private void leftA()
     
131.         {
     
132.                 if(arr[0]!=0 && arr[3]!=0 && arr[6]!=0)
     
133.                         swap(arr,getIndex0(),getIndex0()-1);
     
134.        
     
135.                 return;
     
136.         }
     
137.        
     
138.         private void downS()
     
139.         {
     
140.                 if(arr[6]!=0 && arr[7]!=0 && arr[8]!=0)
     
141.                         swap(arr,getIndex0(),getIndex0()+3);
     
142.                
     
143.                 return;
     
144.         }
     
145. 
     
146.         private void rightD()
     
147.         {
     
148.                 if(arr[2]!=0 && arr[5]!=0 && arr[8]!=0)
     
149.                         swap(arr,getIndex0(),getIndex0()+1);
     
150.                
     
151.                 return;
     
152.         }
     
153. 
     
154.         private void setArr(int [] arr,int a,int b )
     
155.         {
     
156.                
     
157.         }
     
158. 
     
159.         private int getIndex0()
     
160.         {
     
161.                 for (int i = 0;i<arr.length ;i++ )
     
162.                 {
     
163.                         if (arr[i]==0)
     
164.                         {
     
165.                                 return i;
     
166.                         }
     
167.                 }
     
168.                 return 0;
     
169.         }
     
170. 
     
171.         private void swap(int [] arr,int a,int b)
     
172.         {
     
173.                 int temp =arr[a] ;
     
174.                 arr[a]=arr[b];
     
175.                 arr[b]=temp;
     
176. 
     
177.                 return;
     
178.         }
     
179. 
     
180.         //默认输出：
     
181.         private void defaultPrint()
     
182.         {
     
183.                 for (int i=0,ii=1,iii=0;i<35 ;i++ )                        // 5行,7列 定义到一起0~35
     
184.                 {
     
185. /*                        if(arr[iii]==0){
     
186.                                 System.out.print("■"+str);
     
187.                                 i++;
     
188.                                 iii++;}
     
189.                         else
     
190.                         {        */
     
191.                         switch (i)
     
192.                         {
     
193.                                 case 8:
     
194.                                 case 10:
     
195.                                 case 12:
     
196.                                 case 15:
     
197.                                 case 17:
     
198.                                 case 19:
     
199.                                 case 22:
     
200.                                 case 24:
     
201.                                 {
     
202.                                         if (arr[iii]==0)
     
203.                                                 System.out.print(str);
     
204.                                         else
     
205.                                                 System.out.print(arr[iii]+""+arr[iii]);
     
206.                                         iii++;
     
207.                                         break;
     
208.                                 }
     
209.                                 case 26:
     
210.                                         if (arr[iii]==0)
     
211.                                                 System.out.print(str);
     
212.                                         else
     
213.                                                 System.out.print(arr[iii]+""+arr[iii]);
     
214.                                         iii=0;
     
215.                                         break;
     
216.                                 default:
     
217.                                 {
     
218.                                         if (i!=(7*ii-1))
     
219.                                         {       
     
220.                                                 System.out.print("■");
     
221.                                                
     
222.                                         }
     
223.                                         else
     
224.                                         {       
     
225.                                                 System.out.println("■");
     
226.                                                 ii++;
     
227.                                         }
     
228.                                         break;
     
229.                                 }
     
230.                         }//}
     
231.                 }
     
232.                 return;
     
233.         }
     
234. }

复制代码

总是喜欢倒腾一点小东西，只是才疏学浅，要黑马发掘自己无限牛X的潜力，我爱编程，我爱黑马，我要做程序猿。

程序猿大哥,写的真好!!!!!1

1. while (!win())
   
2.                 {
   
3.                         ss=in.nextLine();
   
4.                         caseSS(ss);
   
5.                 }
   
6. 
   
7.                 System.out.println("恭喜过关");
   
8. 
   
9.         }
   
10. 
    
11.         private boolean win()                        
    
12.                 //对游戏win的判断:游戏运行数组与目标（V）数组，对应位置数值有任一不相等，返回false，对应位置值都相等，则返回true.
    
13.         {
    
14.                 for (int i=0;i<9 ;i++ )
    
15.                 {
    
16.                         if (arr[i]!=arrV[i])
    
17.                                 return false;
    
18.                 }
    
19. 
    
20.                 return true;
    
21.         }

复制代码

我喜欢这样.. win的true就是赢了，false就是还没赢

好多代码。。。

很给力!!!!

不错，加油

不错，很给力了

有点牛！！

厉害 给力。。。

五天，厉害啊

学习一下 我的基础第五天还是很初级水平

给力，赞

这是什么鬼

牛逼。。。。。。。。。

学了五天，自己写出一个游戏，可以说是大神了

楼主 随机数那可以优化一点

1. int n = 9;
   
2.                 int[] randoms = new int[n];
   
3.                 boolean[] bool = new boolean[n];
   
4.                 Random rand = new Random();
   
5. 
   
6.                 for(int i=0; i<n; i++)
   
7.                 {
   
8.                         do{
   
9.                                 randoms[i]=rand.nextInt(n);
   
10.                         }while(bool[randoms[i]]);
    
11.                        
    
12.                         bool[randoms[i]]=true;
    
13.                 }

复制代码

我擦！牛B啊。

好厉害~{:2_41:}

其实很想看看游戏界面啊。

膜拜中！！！！！！！！！！