逆时针或顺时针输出循环数字(CSharp)

 

 


  
  1. class Test2 
  2. { 
  3.     #region 题目： 
  4.     /*   
  5.          * 根据给定的整数，输出如下所示图形   
  6.          * 以1为中心，顺时针 或逆时针 旋转 输出！   
  7.          *    
  8.          *             
  9.          *              7 8 9    
  10.          *              6 1 2   
  11.          *              5 4 3   
  12.          *              --例子1   
  13.          *    
  14.          *    
  15.          *          2 1   2 2   2 3   2 4   2 5    
  16.          *    
  17.          *          2 0    7     8     9    1 0   
  18.          *    
  19.          *          1 9    6     1     2    1 1   
  20.          *    
  21.          *          1 8    5     4     3    1 2   
  22.          *    
  23.          *          1 7   1 6   1 5   1 4   1 3   
  24.          *                  --例子2   
  25.          */ 
  26.     #endregion 
  27.  
  28.     /// <summary> 
  29.     /// 生成二维数组 ，注意：参数i为奇数！ 
  30.     /// </summary> 
  31.     /// <param name="i">要输出的行数</param> 
  32.     /// <param name="InitialDirection">旋转的初始方向（【上，右，下，左】）</param> 
  33.     /// <param name="clock">逆时针或顺时针</param> 
  34.     /// <returns></returns> 
  35.     int[][] GetArray(int i, Direction InitialDirection, Clock clock) 
  36.     { 
  37.         int[][] a = new int[i][]; 
  38.         for (int j = 0; j < a.Length; j++) 
  39.         { 
  40.             a[j] = new int[i]; 
  41.         } 
  42.         //   
  43.         int m = i / 2; int n = i / 2; 
  44.         //最中间的元素为1   
  45.         a[m][n] = 1; 
  46.         Direction direction = InitialDirection; 
  47.         for (int k = 2; k <= i * i; k++) 
  48.         { 
  49.             if (k == 2) 
  50.             { 
  51.                 switch (direction) 
  52.                 { 
  53.                     case Direction.top: 
  54.                         a[--m][n] = k; 
  55.                         break; 
  56.                     case Direction.right: 
  57.                         a[m][++n] = k; 
  58.                         break; 
  59.                     case Direction.bottom: 
  60.                         a[++m][n] = k; 
  61.                         break; 
  62.                     case Direction.left: 
  63.                         a[m][--n] = k; 
  64.                         break; 
  65.                     default: 
  66.                         break; 
  67.                 } 
  68.                 continue; 
  69.             } 
  70.  
  71.  
  72.  
  73.  
  74.             switch (clock) 
  75.             { 
  76.                 case Clock.clockwise: 
  77.                     //顺时针 
  78.                     /* 在【顺时针】情况下， 
  79.                         * 当移动方向direction 为right时，试着让移动方向朝bottom转移： 
  80.                         * 把当前数组a[m][n]元素的坐标向下移动一位，如果新生成的数组元素a[++m][n]值为0，说明可以转移方向， 
  81.                         *  则把k值赋给  新数组元素，direction变为bottom;   
  82.                         * 否则，****原数组元素a[m][n]**** 坐标   
  83.                         * 向右移动一位生成新数组元素，并把k值赋给新数组元素！   
  84.                         * 其余方向转移，类似于right 到bottom，如bottom到left，left到top，top到right。 
  85.                         */ 
  86.                     switch (direction) 
  87.                     { 
  88.  
  89.                         case Direction.top: 
  90.                             if (a[m][++n] == 0) 
  91.                             { 
  92.                                 a[m][n] = k; 
  93.                                 direction = Direction.right; 
  94.                             } 
  95.                             else 
  96.                             { 
  97.                                 n--; 
  98.                                 a[--m][n] = k; 
  99.                             } 
  100.                             break; 
  101.                         case Direction.right: 
  102.                             if (a[++m][n] == 0) 
  103.                             { 
  104.                                 a[m][n] = k; 
  105.                                 direction = Direction.bottom; 
  106.                             } 
  107.                             else 
  108.                             { 
  109.                                 m--; 
  110.                                 a[m][++n] = k; 
  111.                             } 
  112.                             break; 
  113.                         case Direction.bottom: 
  114.                             if (a[m][--n] == 0) 
  115.                             { 
  116.                                 a[m][n] = k; 
  117.                                 direction = Direction.left; 
  118.                             } 
  119.                             else 
  120.                             { 
  121.                                 n++; 
  122.                                 a[++m][n] = k; 
  123.                             } 
  124.                             break; 
  125.                         case Direction.left: 
  126.  
  127.                             if (a[--m][n] == 0) 
  128.                             { 
  129.                                 a[m][n] = k; 
  130.                                 direction = Direction.top; 
  131.                             } 
  132.                             else 
  133.                             { 
  134.                                 m++; 
  135.                                 a[m][--n] = k; 
  136.                             } 
  137.                             break; 
  138.                         default: 
  139.                             break; 
  140.                     } 
  141.                     break; 
  142.                 case Clock.anticlockwise: 
  143.                     //逆时针 
  144.                     /* 在【逆时针】情况下， 
  145.                    * 当移动方向direction 为right时，试着让移动方向朝top转移： 
  146.                    * 把当前数组a[m][n]元素的坐标向上移动一位，如果新生成的数组元素a[--m][n]值为0，说明可以转移方向， 
  147.                    *  则把k值赋给  新数组元素，direction变为top;   
  148.                    * 否则，****原数组元素a[m][n]**** 坐标   
  149.                    * 向右移动一位生成新数组元素，并把k值赋给新数组元素！   
  150.                    * 其余方向转移，类似于right 到top，如bottom到right，left到bottom，top到left。 
  151.                    */ 
  152.                     switch (direction) 
  153.                     { 
  154.                         case Direction.top: 
  155.                             if (a[m][--n] == 0) 
  156.                             { 
  157.                                 a[m][n] = k; 
  158.                                 direction = Direction.left; 
  159.                             } 
  160.                             else 
  161.                             { 
  162.                                 n++; 
  163.                                 a[--m][n] = k; 
  164.                             } 
  165.                             break; 
  166.                         case Direction.right: 
  167.                             if (a[--m][n] == 0) 
  168.                             { 
  169.                                 a[m][n] = k; 
  170.                                 direction = Direction.top; 
  171.                             } 
  172.                             else 
  173.                             { 
  174.                                 m++; 
  175.                                 a[m][++n] = k; 
  176.                             } 
  177.                             break; 
  178.                         case Direction.bottom: 
  179.                             if (a[m][++n] == 0) 
  180.                             { 
  181.                                 a[m][n] = k; 
  182.                                 direction = Direction.right; 
  183.                             } 
  184.                             else 
  185.                             { 
  186.                                 n--; 
  187.                                 a[++m][n] = k; 
  188.                             } 
  189.                             break; 
  190.                         case Direction.left: 
  191.  
  192.                             if (a[++m][n] == 0) 
  193.                             { 
  194.                                 a[m][n] = k; 
  195.                                 direction = Direction.bottom; 
  196.                             } 
  197.                             else 
  198.                             { 
  199.                                 m--; 
  200.                                 a[m][--n] = k; 
  201.                             } 
  202.                             break; 
  203.                         default: 
  204.                             break; 
  205.                     } 
  206.                     break; 
  207.                 default: 
  208.                     break; 
  209.             } 
  210.  
  211.         } 
  212.  
  213.  
  214.  
  215.  
  216.         return a; 
  217.     } 
  218.  
  219.     /// <summary> 
  220.     /// 控制台界面 上，输出二维数组 
  221.     /// </summary> 
  222.     /// <param name="i"></param> 
  223.     internal void Printf(int i, Direction inaitialDirection, Clock clock) 
  224.     { 
  225.         if (i % 2 == 0) 
  226.         { 
  227.             i++; 
  228.         } 
  229.         int[][] a = GetArray(i, inaitialDirection, clock); 
  230.         for (int j = 0; j < a.Length; j++) 
  231.         { 
  232.             Console.Write("        "); 
  233.             for (int k = 0; k < a.Length; k++) 
  234.             { 
  235.                 Console.Write(PrintFormat(a[j][k])); 
  236.             } 
  237.             Console.WriteLine("\r\n\r\n"); 
  238.         } 
  239.     } 
  240.  
  241.     /// <summary> 
  242.     /// 格式化输出数字格式化，以便对齐 
  243.     /// </summary> 
  244.     /// <param name="m"></param> 
  245.     /// <returns></returns>  
  246.     String PrintFormat(int m) 
  247.     { 
  248.         string s = m.ToString(); 
  249.  
  250.         if (s.Length == 1) 
  251.         { 
  252.             return " " + m + " " + "  " + "  "; 
  253.         } 
  254.         else if (s.Length == 2) 
  255.         { 
  256.             return s.Substring(0, 1) + " " + s.Substring(1, 1) + "  " + "  "; 
  257.         } 
  258.         else 
  259.         { 
  260.             return s + "  " + "  "; 
  261.         } 
  262.     } 
  263. } 
  264.  
  265.  
  266.  
  267. /// <summary> 
  268. /// 定义枚举，上，右，下，左4个方向。 
  269. /// </summary> 
  270. enum Direction 
  271. { top, right, bottom, left } 
  272.  
  273. /// <summary> 
  274. /// 逆时针或顺指针 
  275. /// </summary> 
  276. enum Clock 
  277. { clockwise, anticlockwise } 

  


//调用方法。

  

  
  1. static void Main(string[] args) 
  2. { 
  3.     Test2 test = new Test2(); 
  4.  
  5.     Console.WriteLine("\r\n"); 
  6.     test.Printf(9, Direction.right, Clock.clockwise); 
  7.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  8.     test.Printf(9, Direction.right, Clock.anticlockwise); 
  9.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  10.  
  11.     test.Printf(9, Direction.bottom, Clock.clockwise); 
  12.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  13.     test.Printf(9, Direction.bottom, Clock.anticlockwise); 
  14.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  15.  
  16.     test.Printf(9, Direction.left, Clock.clockwise); 
  17.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  18.     test.Printf(9, Direction.left, Clock.anticlockwise); 
  19.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  20.  
  21.     test.Printf(9, Direction.top, Clock.clockwise); 
  22.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  23.     test.Printf(9, Direction.top, Clock.anticlockwise); 
  24.     Console.WriteLine("\r\n---------\r\n------------------\r\n"); 
  25. }