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

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

/*
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. usingSystem;
2. usingSystem.Collections.Generic;
3. usingSystem.Drawing;
4. usingSystem.Text.RegularExpressions;
6. namespaceBoxGame
7. {
8. classProgram
9. {
10. ///<summary>
11. ///方向
12. ///</summary>
13. publicenumDirection
14. {
15. North,
16. South,
17. West,
18. East,
19. Southwest,
20. Southeast,
21. Northeast,
22. Northwest
23. }
24. ///<summary>
25. ///移动指令
26. ///</summary>
27. publicclassMoveDictate
28. {
29. ///<summary>
30. ///移动方向表，按优先排列顺序
31. ///</summary>
32. publicList<Direction>directions=newList<Direction>();
33. ///<summary>
34. ///是否跳出指令
35. ///</summary>
36. publicboolisBreak;
37. ///<summary>
38. ///是否为分析模式
39. ///</summary>
40. publicboolisTry;
41. ///<summary>
42. ///是否旋转模式
43. ///</summary>
44. publicboolisEddy;
45. ///<summary>
46. ///分析坐标
47. ///</summary>
48. publicPointpoint;
49. ///<summary>
50. ///最多界限
51. ///</summary>
52. publicintmax=int.MaxValue;
53. ///<summary>
54. ///解析字符串
55. ///</summary>
56. ///<paramname="s">字符串</param>
57. ///<returns>返回移动指令</returns>
58. publicstaticMoveDictateParse(strings)
59. {
60. MoveDictateresult=newMoveDictate();
61. result.isBreak=s.IndexOf('跳')>=0;
62. result.isTry=s.IndexOf('探')>=0;
63. result.isEddy=s.IndexOf('旋')>=0;
64. Matchm=Regex.Match(s,@"/[(?<x>.*?),(?<y>.*?)/]");
65. if(m.Success)
66. {
67. intx=result.point.X;
68. inty=result.point.Y;
69. int.TryParse(m.Result("${x}"),outx);
70. int.TryParse(m.Result("${y}"),outy);
71. result.point=newPoint(x,y);
72. }
73. foreach(charcins)
74. {
75. inti="↑↓←→↖↗↙↘".IndexOf(c);
76. if(i>=0)
77. result.directions.Add((Direction)i);
78. }
79. returnresult;
80. }
81. }
82. ///<summary>
83. ///盒子游戏
84. ///</summary>
85. publicclassBoxGame
86. {
87. ///<summary>
88. ///边大小
89. ///</summary>
90. intsize;
91. ///<summary>
92. ///指令序号
93. ///</summary>
94. intdictate;
95. ///<summary>
96. ///是否逆向填写
97. ///</summary>
98. boolisReverse;
99. ///<summary>
100. ///当前坐标
101. ///</summary>
102. Pointcurrent=newPoint(0,0);
103. ///<summary>
104. ///数字矩形
105. ///</summary>
106. int[,]numbers;
107. ///<summary>
108. ///方向偏移
109. ///</summary>
110. Point[]offsets=newPoint[]{
111. newPoint(0,-1),
112. newPoint(0,+1),
113. newPoint(-1,0),
114. newPoint(+1,0),
115. newPoint(-1,-1),
116. newPoint(+1,-1),
117. newPoint(-1,+1),
118. newPoint(+1,+1)};
120. ///<summary>
121. ///移动指令集
122. ///</summary>
123. List<MoveDictate>moveDictates=newList<MoveDictate>();
125. ///<summary>
126. ///移动
127. ///</summary>
128. ///<paramname="dest">目标点</param>
129. ///<returns>返回移动是否成功</returns>
130. boolMove(MoveDictatemoveDictate,refPointdest)
131. {
132. boolisBrack=false;
133. do
134. {
135. isBrack=true;
136. for(inti=0;i<moveDictate.directions.Count;i++)
137. {
138. if(moveDictate.isEddy&&i>moveDictate.max)break;
139. intd=(int)moveDictate.directions[i];
140. Pointtemp=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. returntrue;
149. }
150. if(moveDictate.isTry)
151. {
152. moveDictate.point=temp;
153. isBrack=false;
154. break;
155. }
156. }
157. }
158. }while(!isBrack);
159. returnfalse;
160. }
161. ///<summary>
162. ///播放
163. ///</summary>
164. ///<paramname="size">宽度</param>
165. ///<paramname="dictates">指令字符串</param>
166. publicvoidPlay(intsize,strings)
167. {
168. this.size=size;
169. s=s.Replace("边",(size-1).ToString());
170. isReverse=s.IndexOf('逆')>=0;
171. MatchCollectionmc=Regex.Matches(s,@"/{(?<dictate>.*?)/}");
172. foreach(Matchmatchinmc)
173. moveDictates.Add(MoveDictate.Parse(match.Result("${dictate}")));
174. Matchm=Regex.Match(Regex.Replace(s,@"/{.*?/}",""),@"/[(?<x>.*?),(?<y>.*?)/]");
175. if(m.Success)
176. {
177. intx=current.X;
178. inty=current.Y;
179. int.TryParse(m.Result("${x}"),outx);
180. int.TryParse(m.Result("${y}"),outy);
181. current=newPoint(x,y);
182. }
183. numbers=newint[size,size];
184. numbers[current.X,current.Y]=isReverse?size*size:1;
185. for(inti=2;i<=size*size;i++)
186. {
187. Pointnext=current;
188. for(intj=0;j<moveDictates.Count;j++)
189. {
190. if(Move(moveDictates[dictate],refnext))
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(intj=0;j<size;j++)
212. {
213. for(inti=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. staticvoidMain(string[]args)
222. {
223. intn=8;
224. newBoxGame().Play(n,"{→↓}{←↑}");//1号图
225. Console.WriteLine("-------");
226. newBoxGame().Play(n,"{→跳}{↙}{↓跳}{↗}");//2号图
227. Console.WriteLine("-------");
228. newBoxGame().Play(n,"{↙}{[0,0]→↓探跳}");//3号图
229. Console.WriteLine("-------");
230. newBoxGame().Play(n,"{↘}{[0,0]→探跳}{↘}{[0,0]↓探跳}");//4号图
231. Console.WriteLine("-------");
232. newBoxGame().Play(n,"[0,边]{→跳}{←↑旋}{↑跳}{↓→旋}");//5号图
233. Console.WriteLine("-------");
234. newBoxGame().Play(n,"{→←↓}");//6号图
235. Console.ReadKey();
236. }
237. }
238. }