打印有变化规律的一组数字正方形。

尽量使用扩展性高的代码，图案如下：

/*
01--02--03--04--05--06--07--08
                             |
28--29--30--31--32--33--34  09
 |                       |   |
27  48--49--50--51--52  35  10
 |   |               |   |   |
26  47  60--61--62  53  36  11
 |   |   |       |   |   |   |
25  46  59  64--63  54  37  12
 |   |   |           |   |   |
24  45  58--57--56--55  38  13
 |   |                   |   |
23  44--43--42--41--40--39  14
 |                           |
22--21--20--19--18--17--16--15
//
01--02  06--07  15--16  28--29
   /   /   /   /   /   /   /
03  05  08  14  17  27  30  43
 | /   /   /   /   /   /   / |
04  09  13  18  26  31  42  44
   /   /   /   /   /   /   /
10  12  19  25  32  41  45  54
 | /   /   /   /   /   /   / |
11  20  24  33  40  46  53  55
   /   /   /   /   /   /   /
21  23  34  39  47  52  56  61
 | /   /   /   /   /   /   / |
22  35  38  48  51  57  60  62
   /   /   /   /   /   /   /
36--37  49--50  58--59  63--64
//
01--02  04  07  11  16  22  29
   />  /   /   /   /   /   /
03  05  08  12  17  23  30  37
   />  /   /   /   /   /   /
06  09  13  18  24  31  38  44
   />  /   /   /   /   /   /
10  14  19  25  32  39  45  50
   />  /   /   /   /   /   /
15  20  26  33  40  46  51  55
   />  /   /   /   /   /   /
21  27  34  41  47  52  56  59
   />  /   /   /   /   /   /
28  35  42  48  53  57  60  62
   />  />  />  />  />  />  /
36  43  49  54  58  61  63--64
//
01  09  23  35  45  53  59  63
   /   /   /   /   /   /   />
16  02  10  24  36  46  54  60
   /   /   /   /   /   /   />
29  17  03  11  25  37  47  55
   /   /   /   /   /   /   />
40  30  18  04  12  26  38  48
   /   /   /   /   /   /   />
49  41  31  19  05  13  27  39
   /   /   /   /   /   /   />
56  50  42  32  20  06  14  28
   /   /   /   /   /   /   />
61  57  51  43  33  21  07  15
   />  />  />  />  />  />  />
64  62  58  52  44  34  22  08
//
64--63--62--61--60--59--58--57
                             |
37--38--39--40--41--42--43  56
 |                       |   |
36--35--34--33--32--31  44  55
                     |   |   |
17--18--19--20--21  30  45  54
 |               |   |   |   |
16--15--14--13  22  29  46  53
             |   |   |   |   |
05--06--07  12  23  28  47  52
 |       |   |   |   |   |   |
04--03  08  11  24  27  48  51
     |   |   |   |   |   |   |
01--02  09--10  25--26  49--50
//
01--02--03--04--05--06--07--08
                             |
16--15--14--13--12--11--10--09
 |                       
17--18--19--20--21--22--23--24
                             |
32--31--30--29--28--27--26--25
 |
33--34--35--36--37--38--39--40
                             |
48--47--46--45--44--43--42--41
 |
49--50--51--52--53--54--55--56
                             |
64--63--62--61--60--59--58--57
*/

解决这个问题，我们可以想象成一个物体在正方形中移动
移动的方式有：
1、向一个方向一直移动直到碰到边缘或者碰到其他物体；
2、向一个方向移动一次就够了；
3、移动方向的优先级，比如优先往上移动，再向左移动；
4、探测方式移动，如果碰到其他物体就继续向同方向探测，直到有空位；
5、旋转试移动，优先级高的方向移动成功后就放弃优先级低的移动方向。

1. using System;
2. using System.Collections.Generic;
3. using System.Drawing;
4. using System.Text.RegularExpressions;
6. namespace BoxGame
7. {
8.     class Program
9.     {
10.         /// <summary>
11.         /// 方向
12.         /// </summary>
13.         public enum Direction
14.         {
15.             North,
16.             South,
17.             West,
18.             East,
19.             Southwest,
20.             Southeast,
21.             Northeast,
22.             Northwest
23.         }
24.         /// <summary>
25.         /// 移动指令
26.         /// </summary>
27.         public class MoveDictate
28.         {
29.             /// <summary>
30.             /// 移动方向表，按优先排列顺序
31.             /// </summary>
32.             public List<Direction> directions = new List<Direction>();
33.             /// <summary>
34.             /// 是否跳出指令
35.             /// </summary>
36.             public bool isBreak;
37.             /// <summary>
38.             /// 是否为分析模式
39.             /// </summary>
40.             public bool isTry;
41.             /// <summary>
42.             /// 是否旋转模式
43.             /// </summary>
44.             public bool isEddy;
45.             /// <summary>
46.             /// 分析坐标
47.             /// </summary>
48.             public Point point;
49.             /// <summary>
50.             /// 最多界限
51.             /// </summary>
52.             public int max = int.MaxValue;
53.             /// <summary>
54.             /// 解析字符串
55.             /// </summary>
56.             /// <param name="s">字符串</param>
57.             /// <returns>返回移动指令</returns>
58.             public static MoveDictate Parse(string s)
59.             {
60.                 MoveDictate result = new MoveDictate();
61.                 result.isBreak = s.IndexOf('跳') >= 0;
62.                 result.isTry = s.IndexOf('探') >= 0;
63.                 result.isEddy = s.IndexOf('旋') >= 0;
64.                 Match m = Regex.Match(s, @"/[(?<x>.*?),(?<y>.*?)/]");
65.                 if (m.Success)
66.                 {
67.                     int x = result.point.X;
68.                     int y = result.point.Y;
69.                     int.TryParse(m.Result("${x}"), out x);
70.                     int.TryParse(m.Result("${y}"), out y);
71.                     result.point = new Point(x, y);
72.                 }
73.                 foreach (char c in s)
74.                 {
75.                     int i = "↑↓←→↖↗↙↘".IndexOf(c);
76.                     if (i >= 0)
77.                         result.directions.Add((Direction)i);
78.                 }
79.                 return result;
80.             }
81.         }
82.         /// <summary>
83.         /// 盒子游戏
84.         /// </summary>
85.         public class BoxGame
86.         {
87.             /// <summary>
88.             /// 边大小
89.             /// </summary>
90.             int size;
91.             /// <summary>
92.             /// 指令序号
93.             /// </summary>
94.             int dictate;
95.             /// <summary>
96.             /// 是否逆向填写
97.             /// </summary>
98.             bool isReverse;
99.             /// <summary>
100.             /// 当前坐标
101.             /// </summary>
102.             Point current = new Point(0, 0);
103.             /// <summary>
104.             /// 数字矩形
105.             /// </summary>
106.             int[,] numbers;
107.             /// <summary>
108.             /// 方向偏移
109.             /// </summary>
110.             Point[] offsets = new Point[]{
111.                 new Point(0, -1),
112.                 new Point(0, +1),
113.                 new Point(-1, 0),
114.                 new Point(+1, 0),
115.                 new Point(-1, -1),
116.                 new Point(+1, -1),
117.                 new Point(-1, +1),
118.                 new Point(+1, +1)};
120.             /// <summary>
121.             /// 移动指令集
122.             /// </summary>
123.             List<MoveDictate> moveDictates = new List<MoveDictate>();
125.             /// <summary>
126.             /// 移动
127.             /// </summary>
128.             /// <param name="dest">目标点</param>
129.             /// <returns>返回移动是否成功</returns>
130.             bool Move(MoveDictate moveDictate, ref Point dest)
131.             {
132.                 bool isBrack = false;
133.                 do
134.                 {
135.                     isBrack = true;
136.                     for (int i = 0; i < moveDictate.directions.Count; i++)
137.                     {
138.                         if (moveDictate.isEddy && i > moveDictate.max) break;
139.                         int d = (int)moveDictate.directions[i];
140.                         Point temp = moveDictate.isTry ? moveDictate.point : dest;
141.                         temp.Offset(offsets[d].X, offsets[d].Y);
142.                         if (Rectangle.FromLTRB(0, 0, size, size).Contains(temp))
143.                         {
144.                             if (numbers[temp.X, temp.Y] == 0)
145.                             {
146.                                 dest = temp;
147.                                 if (moveDictate.isEddy) moveDictate.max = i;
148.                                 return true;
149.                             }
150.                             if (moveDictate.isTry)
151.                             {
152.                                 moveDictate.point = temp;
153.                                 isBrack = false;
154.                                 break;
155.                             }
156.                         }
157.                     }
158.                 } while (!isBrack);
159.                 return false;
160.             }
161.             /// <summary>
162.             /// 播放
163.             /// </summary>
164.             /// <param name="size">宽度</param>
165.             /// <param name="dictates">指令字符串</param>
166.             public void Play(int size, string s)
167.             {
168.                 this.size = size;
169.                 s = s.Replace("边", (size - 1).ToString());
170.                 isReverse = s.IndexOf('逆') >= 0;
171.                 MatchCollection mc = Regex.Matches(s, @"/{(?<dictate>.*?)/}");
172.                 foreach (Match match in mc)
173.                     moveDictates.Add(MoveDictate.Parse(match.Result("${dictate}")));
174.                 Match m = Regex.Match(Regex.Replace(s, @"/{.*?/}", ""), @"/[(?<x>.*?),(?<y>.*?)/]");
175.                 if (m.Success)
176.                 {
177.                     int x = current.X;
178.                     int y = current.Y;
179.                     int.TryParse(m.Result("${x}"), out x);
180.                     int.TryParse(m.Result("${y}"), out y);
181.                     current = new Point(x, y);
182.                 }
183.                 numbers = new int[size, size];
184.                 numbers[current.X, current.Y] = isReverse ? size * size : 1;
185.                 for (int i = 2; i <= size * size; i++)
186.                 {
187.                     Point next = current;
188.                     for (int j = 0; j < moveDictates.Count; j++)
189.                     {
190.                         if (Move(moveDictates[dictate], ref next))
191.                         {
192.                             if (moveDictates[dictate].isBreak)
193.                             {
194.                                 if (moveDictates[dictate].isEddy)
195.                                     moveDictates[dictate].max = int.MaxValue;
196.                                 dictate = (dictate + 1) % moveDictates.Count;
197.                             }
198.                             current = next;
199.                             break;
200.                         }
201.                         else
202.                         {
203.                             if (moveDictates[dictate].isEddy)
204.                                 moveDictates[dictate].max = int.MaxValue;
205.                             dictate = (dictate + 1) % moveDictates.Count;
206.                         }
207.                     }
208.                     numbers[current.X, current.Y] = isReverse ? size * size - i + 1 : i;
209.                 }
211.                 for (int j = 0; j < size; j++)
212.                 {
213.                     for (int i = 0; i < size; i++)
214.                         Console.Write("{0}{1:D2}", i > 0 ? " " : "", numbers[i, j]);
215.                     Console.WriteLine();
216.                     Console.WriteLine();
217.                 }
218.             }
219.         }
221.         static void Main(string[] args)
222.         {
223.             int n = 8;
224.             new BoxGame().Play(n, "{→↓}{←↑}"); // 1号图
225.             Console.WriteLine("-------");
226.             new BoxGame().Play(n, "{→跳}{↙}{↓跳}{↗}"); // 2号图
227.             Console.WriteLine("-------"); 
228.             new BoxGame().Play(n, "{↙}{[0,0]→↓探跳}"); // 3号图
229.             Console.WriteLine("-------"); 
230.             new BoxGame().Play(n, "{↘}{[0,0]→探跳}{↘}{[0,0]↓探跳}"); // 4号图
231.             Console.WriteLine("-------"); 
232.             new BoxGame().Play(n, "[0,边]{→跳}{←↑旋}{↑跳}{↓→旋}"); // 5号图
233.             Console.WriteLine("-------"); 
234.             new BoxGame().Play(n, "{→←↓}"); // 6号图
235.             Console.ReadKey();
236.         }
237.     }
238. }