详细如图：

我去,你把蓝桥杯的最后一题搞过来.

陈圳 发表于 2013-5-8 18:05
我去,你把蓝桥杯的最后一题搞过来.

对啊，我考了，不会，所以问问，嘿嘿，还请指教

感觉好难啊{:soso_e100:}

lipingan0520 发表于 2013-5-8 20:38
感觉好难啊

I think so!

陈圳 发表于 2013-5-8 18:05
我去,你把蓝桥杯的最后一题搞过来.

你也去了蓝桥杯。。。。很坑的一个比赛。。。表示打死我我也不去了。。

陈圳 发表于 2013-5-8 18:05
我去,你把蓝桥杯的最后一题搞过来.

你也去了蓝桥杯。。。。很坑的一个比赛。。。表示打死我我也不去了。。

这题谁先做出来加分。。。目测2分起步。。。加油吧。

刘胜寒 发表于 2013-5-8 21:23
你也去了蓝桥杯。。。。很坑的一个比赛。。。表示打死我我也不去了。。 ...

没有,上次找习题做,百度到的,反问一下.这是蓝桥杯是怎么比赛法,这道题差不多要做出来了.不过表示时间花的有点久,几个小时了.如果比赛时,这个进度,那就扯蛋了...

陈圳 发表于 2013-5-8 21:27
没有,上次找习题做,百度到的,反问一下.这是蓝桥杯是怎么比赛法,这道题差不多要做出来了.不过表示时间花的 ...

一般一流学校鸟都不鸟的一个比赛....
二流三流的学校才会去的。。。
一个字坑.

刘胜寒 发表于 2013-5-8 21:31
一般一流学校鸟都不鸟的一个比赛....
二流三流的学校才会去的。。。
一个字坑. ...

坑不坑无所谓,最主要自身有进步就好.学了总归是自己的嘛

陈圳 发表于 2013-5-8 21:34
坑不坑无所谓,最主要自身有进步就好.学了总归是自己的嘛

你可以看一下报名的学校吗....
你就知道了。。
不过题目有些确实不错..

1. 
   
2. //如果想自己输入数字，然后打印图形的话，也很简单，把下面的数据改一下就可以了，可以自己做做，挺有意思的
   
3. class Test
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 //定义一个String类型的二维数组
   
8.                 String[][] a = new String[21][21];
   
9. 
   
10.                 //对二维数组进行赋值
    
11.                 for(int i=0;i<21;i++)
    
12.                 {
    
13.                         for(int j=0;j<21;j++)
    
14.                         {
    
15.                                 a[i][j] = "  ";
    
16.                         }
    
17.                 }
    
18.                
    
19. 
    
20.                 //调用show方法，即下面自定义方法。
    
21.                 show(a);
    
22.                
    
23.                
    
24.                 //把数组中的元素，打印出来
    
25.                 for(int i=0;i<21;i++)
    
26.                 {
    
27.                         for(int j=0;j<21;j++)
    
28.                         {
    
29.                                 System.out.print(a[i][j]);
    
30.                         }
    
31.                         System.out.println();
    
32.                 }
    
33.                
    
34.         }
    
35. 
    
36. 
    
37.         public static void show(String[][] a)
    
38.         {                        
    
39.                 for(int count = 0;count<7;count+=2)
    
40.                 {
    
41.                         
    
42.                         //紧邻下面这个for循环是做的图形左上角，
    
43.                         //即图形以横向和纵向中轴线为界，其中的四分之一，即是左上角。
    
44.                         for(int i=0+count;i<11;i++)
    
45.                                 for(int j=0+count;j<11;j++)
    
46.                                 {
    
47.                                         if(i==0+count && j>1+count)
    
48.                                         {
    
49.                                                 a[i][j] = "* ";
    
50.                                         }
    
51.                                         if(i==1+count && j==2+count)
    
52.                                         {
    
53.                                                 a[i][j] = "* ";
    
54.                                         }
    
55.                                         if(i==2+count && j<3+count)
    
56.                                         {
    
57.                                                 a[i][j] = "* ";
    
58.                                         }
    
59.                                         if(i>1+count && j==0+count)
    
60.                                         {
    
61.                                                 a[i][j] = "* ";
    
62.                                         }
    
63.                                 }
    
64. 
    
65. 
    
66. 
    
67.                         //图形以横向和纵向中轴线为界，其中四分之一，即右上角。
    
68.                         for(int i=0+count,x=0+count;i<11;i++,x++)
    
69.                         {
    
70.                                 for(int j=11,y=9;j<21-count;j++,y--)
    
71.                                 {
    
72.                                         a[i][j] = a[x][y];                                
    
73.                                 }                        
    
74.                                 
    
75.                         }
    
76.                         
    
77. 
    
78. 
    
79.                         //图形以横向中轴线为界，即其中二分之一，整个下半部。
    
80.                         for(int i=11,x=9;i<21;i++,x--)
    
81.                         {
    
82.                                 for(int j=0,y=0;j<21;j++,y++)
    
83.                                 {
    
84.                                         a[i][j]=a[x][y];
    
85.                                 }
    
86.                         }
    
87.                
    
88.                 //中间的十字架        
    
89.                 for(int i=8;i<13;i++)
    
90.                 {
    
91.                         for(int j=8;j<13;j++)
    
92.                         {
    
93.                                 if(i == 10)
    
94.                                         a[i][j] = "* ";
    
95.                                 if(j == 10)
    
96.                                         a[i][j] = "* ";
    
97.                         }
    
98.                 }
    
99. 
    
100.         }
     
101.         
     
102.         }
     
103. }
     

复制代码

孙金鑫 发表于 2013-5-9 00:44

牛逼 不过楼主题目是不是有问题？输入1的时候一共输出9行 输入3的时候输出17行 而配彩色的图却是21行的。。。。

1. package cn.itcast.itheima2;
   
2. 
   
3. public class CrossTest {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 String[][] cross = getCross(2);
    
11.                
    
12.                 for(int i=0;i<cross.length;i++){
    
13.                         
    
14.                         for(int j=0;j<cross.length;j++){
    
15.                                 System.out.print(cross[i][j]+"  ");
    
16.                         }
    
17.                         System.out.println();
    
18.                         System.out.println();
    
19.                         
    
20.                 }
    
21.         }
    
22.         
    
23.         public static String[][] getCross(int num){
    
24.                
    
25.                 if(num > 30 || num == 0)
    
26.                         throw new IllegalArgumentException("无效的参数(0<num<30)");
    
27.                 //数组的大小
    
28.                 int size=9;
    
29.                 //每次增长4
    
30.                 int increase = 4;
    
31.                 //生成二维数组的大小
    
32.                 for(int i=1;i<num;i++){
    
33.                         size +=increase;
    
34.                 }
    
35.                 //创建一个二维数组
    
36.                 String[][] cross = new String[size][size];
    
37.                 for(int i=0;i<cross.length;i++){
    
38.                         for(int j=0;j<cross.length;j++){
    
39.                                 cross[i][j] = " ";
    
40.                         }
    
41.                 }
    
42.                
    
43.                 //定义十字的初始位置
    
44.                 int x = size/2-2;
    
45.                 int y = size/2-2;
    
46. 
    
47.                 //中间的十字 无论数组多大都是固定的大小
    
48.                 for(int i=0;i<5;i++,x++,y++){
    
49.                         cross[x][size/2] = "0";
    
50.                         cross[size/2][y] = "0";
    
51.                 }
    
52. 
    
53.                 //初始化外边边界形状
    
54.                 int w = size/2-4;
    
55.                 int n = size/2-4;
    
56.                
    
57.                 int e = size/2+4;
    
58.                 int s = size/2+4;
    
59.                
    
60.                
    
61.                 //外边形状循环的次数
    
62.                 for(int i=1,/*初始化转角*/corner=2,/*tmp控制里层循环次数*/tmp=2;i<=num;i++,tmp+=3,w-=2,n-=2,e+=2,s+=2){
    
63.                         
    
64.                         //边界
    
65.                         border(w,1, tmp, cross);
    
66.                         border(n,0, tmp, cross);
    
67.                         border(e,1,tmp, cross);
    
68.                         border(s,0,tmp, cross);
    
69.                         
    
70.                         //转角
    
71.                         //左上角
    
72.                         corner(cross, size/2-corner,size/2-corner,0);
    
73.                         //右上角
    
74.                         corner(cross, size/2-corner,size/2+corner,1);
    
75.                         //右下角
    
76.                         corner(cross, size/2+corner, size/2-corner,2);
    
77.                         //左下角
    
78.                         corner(cross, size/2+corner,size/2+corner,3);
    
79.                         corner+=2;
    
80.                 }
    
81.                
    
82.                 return cross;
    
83.         }
    
84.         
    
85.         private static void border(int j,int flag,int control,String[][] cross){
    
86.                
    
87.                 int left = cross.length/2;
    
88.                 int right = cross.length/2;
    
89.                
    
90.                 //0表示横坐标, 1表示纵坐标
    
91.                 switch(flag){
    
92.                 case 0 :
    
93.                         for(int i=0;i<control;i++,left--,right++){
    
94.                                 cross[j][left] = "0";
    
95.                                 cross[j][right] = "0";
    
96.                         }
    
97.                         break;
    
98.                 case 1 :
    
99.                         for(int i=0;i<control;i++,left--,right++){
    
100.                                 cross[left][j] = "0";
     
101.                                 cross[right][j] = "0";
     
102.                         }
     
103.                         break;
     
104.                 }
     
105.                
     
106.         }
     
107.         
     
108.         
     
109.         //加入转角的位置
     
110.         private static void corner(String[][] cross,int x,int y,int flag){
     
111.                
     
112.                 switch(flag){
     
113.                 case 0:
     
114.                         cross[x][y] = "0";
     
115.                         cross[x][y-1] = "0";
     
116.                         cross[x][y-2] = "0";
     
117.                         cross[x-1][y] = "0";
     
118.                         cross[x-2][y] = "0";
     
119.                         break;
     
120.                 case 1:
     
121.                         cross[x][y] = "0";
     
122.                         cross[x][y+1] = "0";
     
123.                         cross[x][y+2] = "0";
     
124.                         cross[x-1][y] = "0";
     
125.                         cross[x-2][y] = "0";
     
126.                         break;
     
127.                 case 2:
     
128.                         cross[x][y] = "0";
     
129.                         cross[x][y-1] = "0";
     
130.                         cross[x][y-2] = "0";
     
131.                         cross[x+1][y] = "0";
     
132.                         cross[x+2][y] = "0";
     
133.                         break;
     
134.                         case 3:
     
135.                         cross[x][y] = "0";
     
136.                         cross[x][y+1] = "0";
     
137.                         cross[x][y+2] = "0";
     
138.                         cross[x+1][y] = "0";
     
139.                         cross[x+2][y] = "0";
     
140.                         break;
     
141.                 }
     
142.                
     
143.         }
     
144.         
     
145. }
     
146. 
     

复制代码

1个小时完成了！~不过代码还有冗余！~总体算完成！~

如果问题未解决，请继续追问，如果问题解决了，请将分类改为“已解决”，谢谢

/*思路：发现数字3时，第一行是3*4+1=13个星号，输入数字4时是4*4+1=17个星号。
实际打印时，分为五大部分：首末行，中间行，中间行的上下两行,其他行的上部分，其他行的下部分
之所以这样分开，是因为按奇数行偶数行来打印的。测试中发现一些行不符合普遍规律，所以单独列出。
而且由于两行之间有一个字符的间距，所以横向打印星号时实际打印的是星号加空格，要打印空格时，实际打印的
是两个空格。这样就是一个标准的正方形了。
*/
class Test12
{
        public static void main(String[] args)
        {
                test12(3);
                System.out.println("---------------------------------------- ");
                test12(4);
        }
        public static void test12(int num)
        {
                for( int x=1;x<=4*num+5 ;x++)
                {
                        if(x==1||x==4*num+5)//首行和末行
                        {
                                System.out.print("    ");
                                for(int y=0;y<4*num+1 ;y++)
                                {
                                        System.out.print("* ");
                                }
                                System.out.print("    ");
                        }
                        while(x>1&&x<2*num+2)
                        {
                                if(x%2==1)//上半部的奇数行
                                {
                                        for(int y=0;y<x/2-1;y++)
                                        {
                                                System.out.print("* * ");
                                        }
                                        System.out.print("* * *   ");
                                        for(int y=0;y<4*(num-x/2)+1;y++)
                                        {
                                                System.out.print("* ");
                                        }
                                        System.out.print("  * * * ");
                                        for(int y=0;y<x/2-1;y++)
                                        {
                                                System.out.print("  * ");
                                        }
                                }
                                if(x%2==0)//上半部的偶数行
                                {
                                        for(int y=0;y<x/2-1 ;y++)
                                        {
                                                System.out.print("*   ");
                                        }
                                        System.out.print("    * ");
                                        for(int y=0;y<4*(num-x/2+1)-1 ;y++)
                                        {
                                                System.out.print("  ");
                                        }
                                        System.out.print("*     ");
                                        for(int y=0;y<x/2-1 ;y++)
                                        {
                                                System.out.print("  * ");
                                        }      
                                }
                                break;
                        }
                        if(x==num*2+3)//中间行
                        {
                                for(int y=0;y<num;y++)
                                {
                                 System.out.print("*   ");
                                }
                                for(int y=0;y<5;y++)
                                {
                                System.out.print("* ");
                                }
                                for(int y=0;y<num;y++)
                                {
                                 System.out.print("  * ");
                                }
                        }
                        if(x==num*2+2||x==num*2+4)//中间行的上下行
                        {
                                for(int y=0;y<num;y++)
                                {
                                        System.out.print("*   ");
                                }
                                System.out.print("    *     ");
                                for(int y=0;y<num;y++)
                                {
                                 System.out.print("  * ");
                                }
                        }
                                while(x>num*2+4&&x<4*num+5)
                                {
                                        if(x%2==1))//下半部的奇数行
                                        {
                                                for(int y=0;y<2*num-x/2+1;y++)
                                                {
                                                        System.out.print("*   ");
                                                }
                                                System.out.print("* * *   ");
                                                for(int y=0;y<4*(x/2-num-2)+1;y++)
                                                {
                                                        System.out.print("* ");
                                                }
                                                System.out.print("  * * * ");
                                                for(int y=0;y<2*num-x/2+1;y++)
                                                {
                                                        System.out.print("  * ");
                                                }      
                                        }
                        
                                        if(x%2==0))//下半部的偶数行
                                        {
                                                for(int y=0;y<(2*num+3-x/2)-1 ;y++)
                                                {
                                                        System.out.print("*   ");
                                                }
                                                System.out.print("    * ");
                                                for(int y=0;y<4*(x/2-num-2)-1;y++)
                                                {
                                                        System.out.print("  ");
                                                }
                                                System.out.print("*     ");
                                                for(int y=0;y<(2*num+3-x/2)-1 ;y++)
                                                {
                                                        System.out.print("  * ");
                                                }      
                                        }
                                        break;
                                }      
                                System.out.println();
               
                }
        }
}

高手如云 学习了

高手们的思想太可怕了

高手在民间。