下面的一道题是我给刘胜寒出的一道题，大家也可以参与做一做啊，有惊喜哦
这道题是给敢于挑战，敢于挖掘自己潜力的人出的，如果谁觉得能在规定时间做出来，敢于挑战我的题目，那么你就是厉害的，我就是佩服你的。
如果你觉得自己还不敢挑战，没关系，以后还有机会，不敢挑战的或者认为自己还差点的，那么就不要回复了。
另外，我会根据回复的时间，来评分的，回复越快，答案越清晰，分数当然越高了。

如果来挑战了，大家直接在本楼层编辑即可，不会编辑的请看帖：http://bbs.itheima.com/thread-42978-1-1.html，可以看其中的沙发层的“编辑贴”说明

规定时间：48小时，即从2013.4.30-5.2的9:00

注：如果你是真正的黑马，敢挑战，就要完完全全自己做出来，如果是从网上当的，那么算了吧，我鄙视这样的人，这样的人给黑马丢人，更丢自己的人。
不过我相信大家都是好样的，有能力自己做出来。

话不多说，看题（回复可见哦）：

游客，如果您要查看本帖隐藏内容请回复

我把相对比较好的传上来，大家可以看一看啊（排名不分先后）
曹睿翔.zip (1.19 KB, 下载次数: 61)

2013-5-2 15:40 上传

点击文件名下载附件

蓝色骨头.zip (1.48 KB, 下载次数: 40)

2013-5-2 15:38 上传

点击文件名下载附件

丘凤光.zip (1.08 KB, 下载次数: 44)

2013-5-2 15:38 上传

点击文件名下载附件

李罡.zip (1.4 KB, 下载次数: 39)

2013-5-2 15:38 上传

点击文件名下载附件

过时间了.

先看看阿！！

什么了？定

不要太难 哦 亲！

看下是什么内容

是什么好玩的

小生，挑战一下。

1. package com.itheima;
   
2. 
   
3. public class Test {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 String[][] heilx = helix2DArray(5);
    
11.                
    
12.                 for(int i=0;i<heilx.length;i++){
    
13.                         for(int j=0;j<heilx.length;j++){
    
14.                                 System.out.print(heilx[i][j]+" ");
    
15.                         }
    
16.                         System.out.println();
    
17.                 }
    
18.         }
    
19.        
    
20.         //定义一个螺旋二维数组
    
21.         public static String[][] helix2DArray(int size){
    
22.                 //数组的大小就是数字的前后各加1
    
23.                 int len = size + 2;
    
24.                 String[][] heilx = new String[len][len];
    
25.                 //遍历数组
    
26.                 for(int x=0;x<len;x++){
    
27.                         for(int y=0;y<len;y++){
    
28.                                 //凡是第一行和最后一行都是*号
    
29.                                 if(x==0||x==len-1){
    
30.                                         heilx[x][y] = "*\t";
    
31.                                 }
    
32.                                 //凡是第一列和最后一列都是*号
    
33.                                 if(y==0||y==len-1){
    
34.                                         heilx[x][y] = "*\t";
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.                 /*
    
39.                           * * * *  
    
40.                         * 1 2 *
    
41.                         * 4 3 *
    
42.                         * * * *
    
43.                        
    
44.                         找规律：如果 size是双数 则从 len/2-1开始,否则 len/2
    
45.                                         循环size次，分别x和y的变化是: 第一次 y++ 第二次 x++ 第三次 y-- y-- 第四次 x-- x-- 以此类推
    
46.                                         有点类似于         y: 1  34   789      131415
    
47.                                                                  x:  2    56   101112
    
48.                  */
    
49.                 if(size%2==0){
    
50.                         heilxNumber(heilx, len/2-1, len/2-1, size);
    
51.                 }else{
    
52.                         heilxNumber(heilx, len/2, len/2, size);
    
53.                 }
    
54.                 return heilx;
    
55.         }
    
56.        
    
57.         private static void heilxNumber(String[][] heilx,int x,int y,int size){
    
58.                
    
59.                 //定义让y循环多少次
    
60.                 int a = 1;
    
61.                 //定义让x循环多少次
    
62.                 int b = 1;
    
63.                 //定义一个判断y或x是该++还是该--
    
64.                 int temp = 1;
    
65.                 //存入螺旋数值
    
66.                 int h = 1;
    
67.                 heilx[x][y] = temp+"";
    
68.                 while(temp<=size){
    
69.                         for(int i=0;i<a;i++){
    
70.                                 if(temp%2==0){
    
71.                                         heilx[x][y] = h+"\t";
    
72.                                         h++;
    
73.                                         y--;
    
74.                                        
    
75.                                 }else{
    
76.                                         heilx[x][y] = h+"\t";
    
77.                                         h++;
    
78.                                         y++;
    
79.                                 }
    
80.                         }
    
81.                         if(temp<size){
    
82.                                 for(int j=0;j<b;j++){
    
83.                                         if(temp%2==0){
    
84.                                                 heilx[x][y] = h+"\t";
    
85.                                                 h++;
    
86.                                                 x--;
    
87.                                                
    
88.                                         }else{
    
89.                                                 heilx[x][y] = h+"\t";
    
90.                                                 h++;
    
91.                                                 x++;
    
92.                                         }
    
93.                                 }
    
94.                         }
    
95.                         a++;
    
96.                         b++;
    
97.                         temp++;
    
98.                 }
    
99.         }
    
100. }
     

复制代码

1. /*
   
2. 个人感觉，我的这个方法让人有点晕。。。
   
3. 1 先将四周的星号放入二维数组中
   
4. 2 将左上半部分的数字放入
   
5. （1）求出奇数的平方以及在二维数组的位置
   
6. （2）根据（1）的值以及下标向左推
   
7. （3）根据最左侧数据的信息再向下推
   
8. 3 然后用同样的方法，推出右下部分的数据
   
9. */
   
10. class Circle{
    
11.         public static void main(String[] args){
    
12.                 int n =4;
    
13.                 System.out.println("输入的数n = "+n);
    
14.                
    
15.                 int m = n+2;//二维数组的维数
    
16.                 int[][] arr_2 = new int[m][m];
    
17.                
    
18.                 twoArr(arr_2);
    
19.                 printArr(arr_2);       
    
20.                 }
    
21. //给二维数组按要求赋值               
    
22.         public static void twoArr(int[][] b){
    
23.                 int m = b.length;//图形整体的边长
    
24.                 int n = m-2;//输出图形中，数字的边长
    
25.                 for(int i = 0; i < m; i++){//输入外围星号
    
26.                         for(int j = 0; j<m; j++){
    
27.                                 if(i == 0||i==(m-1)||j==0||j==(m-1))
    
28.                                         b[i][j] = '*';
    
29.                                 }
    
30.                         }
    
31.                        
    
32.                 int p = (n+1)/2;//中间数1的下标
    
33.                 b[p][p] = 1;
    
34. 
    
35.                 for(int i = 1; i <= p;i++){
    
36.                         int k,left=0,right = 0;
    
37.                         if(b[p-i][p+i] !='*'){
    
38.                                 b[p-i][p+i] =(2*i+1)*(2*i+1); //  3   5...奇数的平方
    
39.                                
    
40.                                 for(k=1;k<((2*i)+1);k++){    //奇数平方的左侧数据
    
41.                                         b[p-i][p+i-k] = b[p-i][p+i]-k;
    
42.                                         left = b[p-i][p+i-k];//最左侧数据
    
43.                                         }       
    
44.                                                
    
45.                                 for(int h=1;h<((2*i)+1);h++)//转而再向下
    
46.                                         b[p-i+h][p+i-(k-1)] = left - h;//用上面推出的最左侧数据的下标，但是这里的k要记得减1
    
47.                                
    
48.                                 }
    
49.                         if(b[p+i][p-i+1]!='*'){
    
50.                                 b[p+i][p-i+1]=(2*i)*(2*i);    //   2  4  6...偶数的平方
    
51.                                
    
52.                                 for(k = 1;k<2*i;k++){                //偶数平方的右侧数据
    
53.                                         b[p+i][p-i+1+k] = b[p+i][p-i+1]-k;
    
54.                                         right = b[p+i][p-i+1+k];   //最右侧数据
    
55.                                         }
    
56.                                
    
57.                                 for(int h = 1;h<2*i;h++)//转而再向上
    
58.                                         b[p+i-h][p-i+1+(k-1)] = right-h;  
    
59.                                
    
60.                                 }
    
61.                         }
    
62.                
    
63.                 }
    
64. //输出二维数组
    
65.         public static void printArr(int[][] b){
    
66.                 for(int i = 0; i < b.length; i++){
    
67.                         for(int j = 0; j<b.length; j++){
    
68.                                 if(b[i][j]=='*')
    
69.                                            System.out.print((char)b[i][j]+"\t");
    
70.                                 else System.out.print(b[i][j]+"\t");
    
71.                                 }
    
72.                         System.out.println();
    
73.                         }
    
74.                 System.out.println();
    
75.                 }
    
76.         }

复制代码

来看看。。

看看题，试试看

来看看那

看看看看

看看看看！

看看题目

挑战一下

来看看题

呵呵，看看

看看是什么

看看，还要凑齐是个才行能够给看的撒