要求如下：
1.九宫格，每个格子只有两种可能的图案，即不是“●”就是“○”；
2.程序开始时，每个格子随机出现一种图形；
3.九宫格分别对应数字1—9;当输入对应数字时，该数字的格子和这个格子的上下左右四个格子（边缘没有的格子不算）的图形变成相对应的另一个图形，如●变为○；
4.这个题目目的也就很清楚了，把所有的格子翻转成为统一图案即可。
5.可人为选择由计算机算出一种步数很小的翻转步骤（最多5步），并且可验证计算结果。

如附件所示：

自己顶一下

1. <div class="blockcode"><blockquote>public class NineNums {
   
2. 
   
3.         /**九宫格
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 start();
   
8.         }
   
9.         public static void start(){
   
10.                 Scanner scan=new Scanner(System.in);
    
11.                 Lattice[] lats=Lattice.values();
    
12.                 System.out.println("现在的方格状态为:");
    
13.                 for(int i=0,n=1;i<9;i++,n++){
    
14.                         System.out.print(lats[i]+" ");
    
15.                         if(n%3==0)
    
16.                                 System.out.println();
    
17.                 }
    
18.                 System.out.println("请输出想要改变状态的方格");
    
19.                 int status=scan.nextInt();
    
20.                 System.out.println("改变后的方格为:");
    
21.                 //选定任一个数,都有四个数会改变状态.分别是:n-3/n+3/n-1/n+1;
    
22.                 if(status-4>=0)
    
23.                         lats[status-4].changeFlag();
    
24.                 if(status-2>=0&&(status%3!=0||status-1%3!=0))//增强判断...
    
25.                         lats[status-2].changeFlag();
    
26.                 if(status+2<=9)
    
27.                         lats[status+2].changeFlag();
    
28.                 if(status!=9)
    
29.                         lats[status].changeFlag();
    
30.                 for(int i=0,n=1;i<9;i++,n++){
    
31.                         System.out.print(lats[i]+" ");
    
32.                         if(n%3==0)
    
33.                                 System.out.println();
    
34.                 }
    
35.         }
    
36. 
    
37. }
    
38. enum Lattice{
    
39.         L1,L2,L3,L4,L5,L6,L7,L8,L9;
    
40.         private boolean flag;
    
41.         Lattice(){
    
42.                 if(new Random().nextInt(3)%2==0)
    
43.                         this.flag=true;
    
44.                 else this.flag=false;
    
45.         }
    
46.         public void changeFlag(){
    
47.                 if(this.flag==true)
    
48.                         this.flag=false;
    
49.                 else this.flag=true;
    
50.         }
    
51.         public String toString(){
    
52.                 if(flag){
    
53.                         return "O";
    
54.                 } else {
    
55.                         return " ";
    
56.                 }
    
57.         }
    
58. }

复制代码

陈圳 发表于 2013-5-2 20:26

好厉害，好快啊，不过我验证不了啊，新手啊，:'(

尹桥印 发表于 2013-5-2 18:59
还是可以尝试一下。

嘻嘻，欢迎欢迎

陈圳 发表于 2013-5-2 20:26

这道题我完全没有思路，不过我验证了你的代码，应该是没有实现楼主要求的功能的，我远行你的代码后如下图：

刚运行时位置1是一个o，当我输入1后，位置1的o应该变成黑色的圈（当然了可以随便用一个符号代替，如可以用1代表黑色的圆，这样更加美观）

戴振良 发表于 2013-5-5 20:16
这道题我完全没有思路，不过我验证了你的代码，应该是没有实现楼主要求的功能的，我远行你的代码后如下图 ...

恩恩 加油加油 我学完基础之后我也做做看 这个题我以前用VC作出来过，私自发给你看看，以前的风格不好，别见笑哈

李德全 发表于 2013-5-5 21:22
恩恩 加油加油 我学完基础之后我也做做看 这个题我以前用VC作出来过，私自发给你看看，以前的风格不好， ...

有思路了，其实这个跟那个螺旋数组的输出是一个原理的，都是让x与y坐标+1或-1，这里只要判断x与y的坐标不能为负数，且不能大于2，这么一想，感觉比那个螺旋数组的输出还要简单，写好了再把代码初上来!

戴振良 发表于 2013-5-5 22:41
有思路了，其实这个跟那个螺旋数组的输出是一个原理的，都是让x与y坐标+1或-1，这里只要判断x与y的坐标不 ...

恩恩，一类题。
想想我也写了一下，呵呵，不懂高级方法哈，计算机自动算没有加，先睡觉啦。

1. import java.util.Random;
   
2. import java.util.*;
   
3. public class JiuGongGe
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 String[] gezi = new String[9];        //建数组
   
8.                 JiaoHuan jh = new JiaoHuan();        //交换字符值
   
9.                 SetVal sv = new SetVal();                //设置起初值
   
10.                 Show show = new Show();                        //显示九宫格
    
11.                 Scanner sc = new Scanner(System.in);
    
12.                 sv.setval(gezi);
    
13.                 show.show(gezi);
    
14.                 System.out.println("请输出对应数字：\n1 2 3\n4 5 6\n7 8 9");
    
15.                 for(;;)
    
16.                 {        
    
17.                         System.out.print("...................");
    
18.                         int num = sc.nextInt();        //获取输入
    
19.                         System.out.println();
    
20.                         jh.exchange(num,gezi);        //根据输入交换
    
21.                         show.show(gezi);                //显示
    
22.                 }
    
23.         }
    
24.         
    
25. }
    
26. class JiaoHuan//交换符号
    
27. {
    
28.         public void exchange(int a,String[] arr)
    
29.         {
    
30.                 temp(a,arr);                        
    
31.                 if((a+3)<10)temp(a+3,arr);                        
    
32.                 if((a-3)>0) temp(a-3,arr);
    
33.                 switch(a)
    
34.                 {
    
35.                         case 1:
    
36.                         case 4:
    
37.                         case 7:
    
38.                                 temp(a+1,arr);
    
39.                                 break;
    
40.                         case 2:
    
41.                         case 5:
    
42.                         case 8:
    
43.                                 temp(a-1,arr);
    
44.                                 temp(a+1,arr);
    
45.                                 break;
    
46.                         case 3:
    
47.                         case 6:
    
48.                         case 9:
    
49.                                 temp(a-1,arr);
    
50.                                 break;
    
51.                         default:break;
    
52.                 }
    
53.         }
    
54.         void temp(int a,String[] arr)
    
55.         {
    
56.                 if(arr[a-1]=="O")
    
57.                         arr[a-1]="+";
    
58.                 else
    
59.                         arr[a-1]="O";
    
60.         }
    
61. }
    
62. class SetVal//设置初始值
    
63. {
    
64.         public void setval(String[] arr)
    
65.         {
    
66.                 Random ran = new Random();
    
67.                 for(int x=0; x<9; x++)
    
68.                 {
    
69.                         int a = ran.nextInt(2);
    
70.                         if(a==0)
    
71.                                 arr[x]= "O";
    
72.                         else
    
73.                                 arr[x]= "+";
    
74.                 }
    
75.         }
    
76. }
    
77. class Show        //显示
    
78. {
    
79.         public void show(String[] arr)
    
80.         {
    
81.                 for(int y=0; y<9; y++)
    
82.                 {
    
83.                         System.out.print(arr[y]+"\t");
    
84.                         if((y+1)%3==0)
    
85.                         {
    
86.                                 System.out.println();
    
87.                                 System.out.println();               
    
88.                         }
    
89.                 }
    
90.         }
    
91. }
    

复制代码

李德全 发表于 2013-5-5 23:26
恩恩，一类题。
想想我也写了一下，呵呵，不懂高级方法哈，计算机自动算没有加，先睡觉啦。 ...

   懂C语言的写出的代码就是简洁啊，哎，是我把问题想复杂了。 我把9宫格里的9个图形，每一个图形都当成一个对象处理，一个图形对象中有形状属性（*、O)，它还有自己所处的位置(x,y)，还有它要对应一个1～9的数字（num)，这是否算是面向对象编程啊？

        说说我的思路吧：
        1、定义一个图形对象，它有形状、位置、数字属性，还有切换形状的方法
        2、new出9个图形对象存放于图形对象数组中，初始化他们的形状属性时是随机的，并且已经初始化好它们的位置与对应的数字
        3、从命令行接收一个数字，并从图形数组中找出数字属性相同的图形对象
        4、从找到的对象中获取x、y坐标，分别在4个方向进行加1与减1的操作，这样就得到了与它相邻的形状对象，调用这些对象的切换形状方向即可。

1. import java.util.Random;
   
2. 
   
3. public class Demo9 {
   
4.         
   
5.         /** 形状类 */
   
6.         static class Shape {
   
7.                
   
8.                 char shape;        // 用于保存  * 或  O
   
9.                 int num;         // 用于标识自己对应的数字（1～9）
   
10.                 int y, x;        // 用于标识自己在数组中的位置
    
11.                
    
12.                 /** 初始化时给定一个形状、一个数字 和 位置*/
    
13.                 public Shape(char shape,int num, int y, int x) {
    
14.                         this.shape = shape;  
    
15.                         this.num = num;
    
16.                         this.y = y;
    
17.                         this.x = x;
    
18.                 }
    
19.                
    
20.                 public void swapShape() { shape = shape=='*' ? 'O' : '*';  } //交换形状
    
21.         }
    
22.         
    
23.         /** 数组角标的长度 */
    
24.         public static int index_length = 3;
    
25.         
    
26.         public static void main(String[] args) {
    
27.                 Shape[][] shapeArray = getRandomShapeArray();        // 获取一个随机图形数组
    
28.                 showShapeArray(shapeArray);        // 显示图形数组
    
29.                 System.out.println("请输入1～9之间的数字，并按回车，退出请按0");
    
30.                 while(true) {
    
31.                         int num=0;
    
32.             try{num = System.in.read();}catch(Exception e){e.printStackTrace();}
    
33.             switch(num) {
    
34.             case '\r':
    
35.             case '\n': break;
    
36.             case '0': System.exit(0); break;
    
37.             default:
    
38.                     num = num-'0';
    
39.                     if(num>9 || num<=0) System.out.println("请输入1～9之间的数字，退出请输入0");
    
40.                     else {
    
41.                             Shape shape = findShape(shapeArray, num);        // 查找出输入的数字对应哪个数组中的哪个图形
    
42.                             shapeArray = changeShapeArray(shapeArray, shape);        // 把这个图与它相龄的图形都改变形状
    
43.                             System.out.println();
    
44.                             showShapeArray(shapeArray);        // 显示改变后的图形数组
    
45.                             System.out.print("-------------------");
    
46.                     }
    
47.             }
    
48.                 }
    
49.         }
    
50.         
    
51.         /**
    
52.          * 获取一个随机形状数组
    
53.          * @return Shape数组
    
54.          */
    
55.         static Shape[][] getRandomShapeArray() {
    
56.                 Shape[][] shapeArray = new Shape[index_length][index_length];// 初始化一个3×3的图形数组
    
57.                 Random mRandom = new Random();        // 初始化一个随机对象
    
58.                 for(int y=0, position=1; y<index_length; y++)
    
59.                         for(int x=0; x<index_length; x++) {
    
60.                                 char ch = mRandom.nextBoolean() ? 'O' : '*';
    
61.                                 shapeArray[y][x] = new Shape(ch, position++, y, x);
    
62.                         }
    
63.                 return shapeArray;
    
64.         }
    
65.         
    
66.         /**
    
67.          * 显示形状数组
    
68.          * @param shapeArray 要显示的形状数组
    
69.          */
    
70.         static void showShapeArray(Shape[][] shapeArray) {
    
71.                 for(int y=0,len=shapeArray.length; y<len; y++)
    
72.                         for(int x=0; x<len; x++)
    
73.                                 if(x == len-1)         System.out.print(shapeArray[y][x].shape + "\n\n");
    
74.                                 else                         System.out.print(shapeArray[y][x].shape + "\t");
    
75.         }
    
76.         
    
77.         /**
    
78.          * 找出给定数字所对应的图形对象
    
79.          * @param shapeArray 形状数组
    
80.          * @param num 指定要在形状数组中查找的数字
    
81.          * @return Shape对象
    
82.          */
    
83.         static Shape findShape(Shape[][] shapeArray ,int num) {
    
84.                 Shape shpae = null;
    
85.                 for(int y=0,len=shapeArray.length; y<len; y++)
    
86.                         for(int x=0; x<len; x++)
    
87.                                 if(shapeArray[y][x].num == num) shpae = shapeArray[y][x];
    
88.                 return shpae;
    
89.         }
    
90.         
    
91.         /**
    
92.          * 改变图形数组中指定图形形状，并且也改变与它相邻的Shape对象的形状
    
93.          * @param shapeArray 要改变的数组
    
94.          * @param shape        指定的图形对象
    
95.          * @return 改变形状后的数组
    
96.          */
    
97.         static Shape[][] changeShapeArray(Shape[][] shapeArray, Shape shape) {
    
98.                 int y = shape.y, x = shape.x;
    
99.                 shapeArray[y][x].swapShape();
    
100.                 if(y-1 >= 0)        shapeArray[y-1][x].swapShape();
     
101.                 if(x-1 >= 0)        shapeArray[y][x-1].swapShape();
     
102.                 if(y+1 < index_length) shapeArray[y+1][x].swapShape();
     
103.                 if(x+1 < index_length) shapeArray[y][x+1].swapShape();
     
104.                 return shapeArray;
     
105.         }
     
106. }

复制代码

图形的切换是实现了，就是要计算出最少步骤的翻转成统一图形这个我就没思路了，不说最少步骤，就是让我把它玩统一了也难，除非我在代码里搞个外挂^_^

戴振良 发表于 2013-5-6 19:10
懂C语言的写出的代码就是简洁啊，哎，是我把问题想复杂了。 我把9宫格里的9个图形，每一个图形都当成一 ...

恩，经过我实验和分析，认为理论上最多只要5步就可以作出来。可能你和我的思维有点不同吧，你是直接接触java，而我用过C，毕老师也说过，用C的老转不过思维，你看我那个程序，类的用法还是存在只把类当做函数来用的影子。而你的思维就是把每一种子的位置状态等组合起来成为一个类。另：其实自动算那个程序算是取巧的方法，就是随机一个数作为输入，到达到目的位置，把这过程中的随机数处理，这个过程可以优化，因为最后算出来的数字肯定没有一样的，也就是说1--9这几个数字中每个数字最多出现一次。听说你被录取了，恭喜哈

李德全 发表于 2013-5-6 19:55
恩，经过我实验和分析，认为理论上最多只要5步就可以作出来。可能你和我的思维有点不同吧，你是直接接触j ...

你上面的代码，我本来想说说你的方法应该放在同一个类的，后来忘了，这些方法没必要单独做一个类，你看我的代码就都放一个类，使用的时候就不用去new 对象，直接就能调用方法。
你是说我被黑马录取吗？是的，不过你知道的有点晚了，到今年的9月份我就工作满一年了，我是去年9月从黑马毕业的，但我现在的水平还是非常菜的，很多方面都比不了现在论坛里的马友或正在黑马学习的学弟学妹们呢

戴振良 发表于 2013-5-6 20:59
你上面的代码，我本来想说说你的方法应该放在同一个类的，后来忘了，这些方法没必要单独做一个类，你看我 ...

额，这个不是有点晚啊，这是晚了好久啊...:L 恩恩 谢谢你的指点，你说的有道理，我以后会主意的。你也不要谦虚啦，要有那种豪气哈:lol