又是啥题目啊

接受自己的挑战

什么题目

看看是不是挑战
看来是
目前成果：支持奇数生成，偶数螺旋方向是反的，没有*号

1. public class test {
   
2.         public static void main(String[] args) {  
   
3.             //一共列数
   
4.                 int n =4;  
   
5.             int[][] pos = new int[n][n];
   
6.             
   
7.             //圈数，最外围算一圈
   
8.             int oic = 0;
   
9.             //生成矩形
   
10.             for (int i = n; i >=1; i=i-2) {
    
11.                         setnum(i, pos, oic);
    
12.                         oic++;
    
13.                 }
    
14.             
    
15.             /*输出*/  
    
16.             for(int i = 0; i<n; i++){  
    
17.                 for(int j = 0; j<n; j++){  
    
18.                     if(pos[i][j]<10){  
    
19.                         System.out.print(pos[i][j]+" "+" ");  
    
20.                     }else{  
    
21.                         System.out.print(pos[i][j]+" ");  
    
22.                     }  
    
23.                 }  
    
24.                 System.out.println();  
    
25.             }  
    
26.         }
    
27. 
    
28.         private static void setnum(int n, int[][] pos,int j) {
    
29.                 //生成一圈的上面的横排
    
30.                 int s = j;
    
31.                 for (int i = 0; i < n; i++) {
    
32.                         pos[j][s] = n*n -n + 1 + i;
    
33.                         s++;
    
34.                 }
    
35.                
    
36.                 //生成一圈的左面排
    
37.                 int k = j+1;
    
38.                 for (int i = 0; i < n-1; i++) {
    
39.                         pos[k][j] = n*n -n -i;
    
40.                         k++;
    
41.                 }
    
42.                
    
43.                 //生成一圈的下面排
    
44.                 for (int i = 0; i < n-1; i++) {
    
45.                         pos[n-1+j][i+1+j] = n*n-n-(n-1)-i;
    
46.                 }
    
47.                
    
48.                 //生成一圈的右面排
    
49.                 for (int i = 0; i < n-2; i++) {
    
50.                         pos[n-2+j-i][n-1+j] = n*n-n-(n-1)-i-(n-1);
    
51.                 }
    
52.         }  
    
53. }

复制代码

la aa a a a aa

回复看看

我来看看

Yes~!必须挑战！失败过才会知道成功的喜悦

看看。。。。。。。。。。。。

1. <div class="blockcode"><blockquote>package test;
   
2. 
   
3. /**
   
4. * 思路：
   
5. *          n = 5
   
6.            *   *   *   *   *   *   *
   
7.            *  21  22  23  24  25   *
   
8.            *  20   7   8   9  10   *
   
9.            *  19   6   1   2  11   *
   
10.            *  18   5   4   3  12   *
    
11.            *  17  16  15  14  13   *
    
12.            *   *   *   *   *   *   *
    
13. *                 经过分析矩阵由两种类型的图形组成
    
14. *                 由左上部分
    
15. *                         包括左边和上边
    
16. *                         1
    
17. *
    
18.                         7   8   9  
    
19.                         6
    
20.                         5
    
21. 
    
22.                         21  22  23  24  25
    
23.                         20
    
24.                         19
    
25.                         18
    
26.                         17  
    
27. *                 右下部分
    
28. *                         包含右边和下边
    
29.                                 2
    
30.                         4   3
    
31.                                                 10
    
32.                                                 11
    
33.                                                 12  
    
34.                         16  15  14  13  
    
35.                 最后外加一层*
    
36. *
    
37. * @author Administrator
    
38. *
    
39. */
    
40. public class Test{
    
41.         private static int x,y;
    
42.         private static int[][] arr;
    
43.         private static int count;
    
44.         /**
    
45.          * 顺时针生成左边和上边
    
46.          * @param n                边的长度
    
47.          */
    
48.         private static void left2up(int n){
    
49.                 for(int i = 0; i < n; i++){
    
50.                         arr[x--][y] = count++;               
    
51.                 }
    
52.                 n--;
    
53.                 x++;
    
54.                 y++;
    
55.                 for(int i = 0; i < n; i++){
    
56.                         arr[x][y++] = count++;       
    
57.                 }
    
58.         }
    
59.         /**
    
60.          * 顺时针生成右边和下边
    
61.          * @param n                边的长度
    
62.          */
    
63.         private static void right2down(int n){
    
64.                 for(int i = 0; i < n; i++){
    
65.                         arr[x++][y] = count++;       
    
66.                 }
    
67.                 n--;
    
68.                 x--;
    
69.                 y--;
    
70.                 for(int i = 0; i < n; i++){
    
71.                         arr[x][y--] = count++;                       
    
72.                 }
    
73.         }
    
74.         /**
    
75.          * 从里到外顺时针旋转产生矩阵（长宽相等）
    
76.          * @param n                矩阵的规模
    
77.          */
    
78.         public static void spiral(int n){               
    
79.                 //起点
    
80.                 x = (n - 1)/2;
    
81.                 y = x;
    
82.                 arr = new int[n][n];
    
83.                 count = 1;
    
84.                 for(int i = 1; i <= n; i++){
    
85.                         if( i % 2  == 1 ){
    
86.                                 left2up(i);
    
87.                         }else{
    
88.                                 right2down(i);
    
89.                         }
    
90.                 }
    
91.         }
    
92.        
    
93.        
    
94.         //下面的方法用于打印
    
95.         /**
    
96.          * 计算十进制数字的位数
    
97.          * @param num                要计算的数组
    
98.          * @return                        返回用十进制表示这个数组时的位数
    
99.          */
    
100.         private static int count(int num){
     
101.                 int cnt = 0;
     
102.                 while(num != 0){
     
103.                         cnt++;
     
104.                         num /= 10;
     
105.                 }
     
106.                
     
107.                 return cnt;
     
108.         }
     
109.         /**
     
110.          * 打印一行*
     
111.          * @param m                矩阵的规模
     
112.          * @param cnt        最大数字的长度
     
113.          */
     
114.         private static void printStars(int m, int cnt){
     
115.                 StringBuilder sb = new StringBuilder(getSpaces(1, cnt));
     
116.                 sb.append("*");               
     
117.                 String str = sb.toString();
     
118.                 for(int i = 0, len = m+2; i < len; i++){
     
119.                         System.out.print(str);
     
120.                 }
     
121.                 System.out.println();
     
122.         }
     
123.         /**
     
124.          * 生成打印数字之前应该打印的空格
     
125.          * @param n                        要打印的数字               
     
126.          * @param cnt                数字的最大长度
     
127.          * @return                        打印数字之前应该打印的空格
     
128.          */
     
129.         public static String getSpaces(int n, int cnt){
     
130.                 StringBuilder spacesSb = new StringBuilder("  ");       
     
131.                 int tmpCnt = count(n);               
     
132.                 for(int k = 0; k < cnt - tmpCnt; k++){
     
133.                         spacesSb.append(" ");
     
134.                 }
     
135.                
     
136.                 return spacesSb.toString();
     
137.         }
     
138.         /**
     
139.          * 打印生成的二维数组，保证良好的格式，每个数占有的长度相同且随着数组的大小自动调整，
     
140.          * 不够的用空格补足。
     
141.          *
     
142.          * @param matrix        要打印的数组
     
143.          * @param m                        数组的行数
     
144.          * @param n                        数组的列数
     
145.          */
     
146.         public static void printMatrix(int[][] matrix, int m, int n){               
     
147.                 int cnt = count(m*n);
     
148.                 //打印一行"*"               
     
149.                 printStars(m, cnt);
     
150.                 for(int i = 0; i < m; i++){
     
151.                         System.out.print(getSpaces(1, cnt)+"*");
     
152.                         for(int j = 0; j < n; j++){                                                       
     
153.                                 System.out.print(getSpaces(matrix[i][j], cnt));
     
154.                                 System.out.print(matrix[i][j]);
     
155.                         }
     
156.                         System.out.println(getSpaces(1, cnt)+"*");
     
157.                 }
     
158.                 //打印一行"*"               
     
159.                 printStars(m, cnt);
     
160.         }
     
161.         public static void main(String[] args){
     
162.                 for(int i = 1; i <= 30; i++){
     
163.                         System.out.println("n = "+i);
     
164.                         spiral(i);
     
165.                         printMatrix(arr,i,i);
     
166.                         System.out.println();
     
167.                 }
     
168.         }
     
169. }

复制代码

试试看了

    看看  

来，打开

挑战，看题~~~

不尝试，怎么知道自己到底行不行呢？要勇于挑战{:soso_e100:}

来支持下，顺便看看题目

我的入学测试倒数第二道和这个类似

李培根 发表于 2013-4-30 23:18
来支持下，顺便看看题目

培根，还没睡呢啊

李培根 发表于 2013-4-30 23:19
我的入学测试倒数第二道和这个类似

就是根据那个改编的，嘿嘿

看看~！~！~！