1.河内之塔

说明河内之塔(Towers of Hanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的，河内为越战时北越的首都，即现在的胡志明市；1883年法国数学家 Edouard Lucas曾提及这个故事，据说创世纪时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），并命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将毁损，而也就是世界末日来临之时。

解法如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。如果盘数超过2个，将第三个以下的盘子遮起来，就很简单了，每次处理两个盘子，也就是：A->B、A ->C、B->C这三个步骤，而被遮住的部份，其实就是进入程式的递回处理。事实上，若有n个盘子，则移动完毕所需之次数为2^n - 1，所以当盘数为64时，则所需次数为：264-
1 = 18446744073709551615为5.05390248594782e+16年，也就是约5000世纪，如果对这数字没什幺概念，就假设每秒钟搬一个盘子好了，也要约5850亿年左右。

  1. <span style="font-family:KaiTi_GB2312">/************************************************************************/
  2. /* 汉诺塔问题                                                           */
  3. /************************************************************************/
  4. void Hanoi(int n,char A,char B,char C)
  5. {
  6. if(n == 1)
  7. {
  8. printf("Move sheet %d from %c to %c \n",n,A,C);
  9. }
  10. else
  11. {
  12. Hanoi(n-1,A,C,B);
  13. printf("Move sheet %d from %c to %c \n",n,A,B);
  14. Hanoi(n-1,B,A,C);
  15. }
  16. }</span>

运行结果：

2.费式数列

说明

Fibonacci为1200年代的欧洲数学家，在他的着作中曾经提到：「若有一只免子每个月生一只小免子，一个月后小免子也开始生产。起初只有一只免子，一个月后就有两只免子，二个月后有三只免子，三个月后有五只免子（小免子投入生产）......。

如果不太理解这个例子的话，举个图就知道了，注意新生的小免子需一个月成长期才会投入生产，类似的道理也可以用于植物的生长，这就是Fibonacci数列，一般习惯称之为费氏数列，例如以下： 1、1 、2、3、5、8、13、21、34、55、89......

  1. <span style="font-family:KaiTi_GB2312">/************************************************************************/
  2. /* fibonacci数列                                                                  */
  3. /************************************************************************/
  4. void fibonacci()
  5. {
  6. int Fib[N] = {0};
  7. int i = 0;
  8. Fib[0] = 0;
  9. Fib[1] = 1;
  10. for(i = 2; i < N; i++)
  11. Fib[i] = Fib[i-1] + Fib[i-2];
  12. for(i = 1; i < N; i++)
  13. printf("%d ",Fib[i]);
  14. printf("\n");
  15. }</span>

3.字串核对

说明今日的一些高阶程式语言对于字串的处理支援越来越强大（例如Java、Perl等），不过字串搜寻本身仍是个值得探讨的课题，在这边以Boyer- Moore法来说明如何进行字串说明，这个方法快且原理简洁易懂。

解法字串搜寻本身不难，使用暴力法也可以求解，但如何快速搜寻字串就不简单了，传统的字串搜寻是从关键字与字串的开头开始比对，例如Knuth-Morris-Pratt演算法字串搜寻，这个方法也不错，不过要花时间在公式计算上；Boyer-Moore字串核对改由关键字的后面开始核对字串，并制作前进表，如果比对不符合则依前进表中的值前进至下一个核对处，假设是p好了，然后比对字串中p-n+1至p的值是否与关键字相同。

如果关键字中有重复出现的字元，则前进值就会有两个以上的值，此时则取前进值较小的值，如此就不会跳过可能的位置，例如texture这个关键字，t的前进值应该取后面的3而不是取前面的7。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. void table(char*); // 建立前进表
  5. int search(int, char*, char*); // 搜寻关键字
  6. void substring(char*, char*, int, int); // 取出子字串
  7. int skip[256];
  8. int main(void) {
  9. char str_input[80];
  10. char str_key[80];
  11. char tmp[80] = {'\0'};
  12. int m, n, p;
  13. printf("请输入字串：");
  14. gets(str_input);
  15. printf("请输入搜寻关键字：");
  16. gets(str_key);
  17. m = strlen(str_input); // 计算字串长度
  18. n = strlen(str_key);
  19. table(str_key);
  20. p = search(n-1, str_input, str_key);
  21. while(p != -1) {
  22. substring(str_input, tmp, p, m);
  23. printf("%s\n", tmp);
  24. p = search(p+n+1, str_input, str_key);
  25. }
  26. printf("\n");
  27. return 0;
  28. }
  29. void table(char *key) {
  30. int k, n;
  31. n = strlen(key);
  32. for(k = 0; k <= 255; k++)
  33. skip[k] = n;
  34. for(k = 0; k < n - 1; k++)
  35. skip[key[k]] = n - k - 1;
  36. }
  37. int search(int p, char* input, char* key) {
  38. int i, m, n;
  39. char tmp[80] = {'\0'};
  40. m = strlen(input);
  41. n = strlen(key);
  42. while(p < m) {
  43. substring(input, tmp, p-n+1, p);
  44. if(!strcmp(tmp, key)) // 比较两字串是否相同
  45. return p-n+1;
  46. p += skip[input[p]];
  47. }
  48. return -1;
  49. }
  50. void substring(char *text, char* tmp, int s, int e) {
  51. int i, j;
  52. for(i = s, j = 0; i <= e; i++, j++)
  53. mp[j] = text[i];
  54. tmp[j] = '\0';
  55. }
  56. </span>

4.三色棋

三色旗的问题最早由E.W.Dijkstra所提出，他所使用的用语为Dutch Nation Flag(Dijkstra为荷兰人)，而多数的作者则使用Three-ColorFlag来称之。

假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。

解法

在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来作辅助，问题的解法很简单，您可以自己想像一下在移动旗子，从绳子开头进行，遇到蓝色往前移，遇到白色留在中间，遇到红色往后移，如下所示：

只是要让移动次数最少的话，就要有些技巧：

如果图中W所在的位置为白色，则W+1，表示未处理的部份移至至白色群组。

如果W部份为蓝色，则B与W的元素对调，而B与W必须各+1，表示两个群组都多了一个元素。

如果W所在的位置是红色，则将W与R交换，但R要减1，表示未处理的部份减1。

注意B、W、R并不是三色旗的个数，它们只是一个移动的指标；什幺时候移动结束呢？一开始时未处理的R指标会是等于旗子的总数，当R的索引数减至少于W的索引数时，表示接下来的旗子就都是红色了，此时就可以结束移动，如下所示：

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define BLUE 'b'
  5. #define WHITE 'w'
  6. #define RED 'r'
  7. #define SWAP(x, y) { char temp; \
  8. temp = color[x]; \
  9. color[x] = color[y]; \
  10. color[y] = temp; }
  11. int main() {
  12. char color[] = {'r', 'w', 'b', 'w', 'w',
  13. 'b', 'r', 'b', 'w', 'r', '\0'};
  14. int wFlag = 0;
  15. int bFlag = 0;
  16. int rFlag = strlen(color) - 1;
  17. int i;
  18. for(i = 0; i < strlen(color); i++)
  19. printf("%c ", color[i]);
  20. printf("\n");
  21. while(wFlag <= rFlag) {
  22. if(color[wFlag] == WHITE)
  23. wFlag++;
  24. else if(color[wFlag] == BLUE) {
  25. SWAP(bFlag, wFlag);
  26. bFlag++; wFlag++;
  27. }
  28. else {
  29. while(wFlag < rFlag && color[rFlag] == RED)
  30. rFlag--;
  31. SWAP(rFlag, wFlag);
  32. rFlag--;
  33. }
  34. }
  35. for(i = 0; i < strlen(color); i++)
  36. printf("%c ", color[i]);
  37. printf("\n");
  38. return 0;
  39. }
  40. </span>

5.老鼠走迷官（一）

说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。

解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. int visit(int, int);
  4. int maze[7][7] = {{2, 2, 2, 2, 2, 2, 2},
  5. {2, 0, 0, 0, 0, 0, 2},
  6. {2, 0, 2, 0, 2, 0, 2},
  7. {2, 0, 0, 2, 0, 2, 2},
  8. {2, 2, 0, 2, 0, 2, 2},
  9. {2, 0, 0, 0, 0, 0, 2},
  10. {2, 2, 2, 2, 2, 2, 2}};
  11. int startI = 1, startJ = 1;  // 入口
  12. int endI = 5, endJ = 5;  // 出口
  13. int success = 0;
  14. int main(void) {
  15. int i, j;
  16. printf("显示迷宫：\n");
  17. for(i = 0; i < 7; i++) {
  18. for(j = 0; j < 7; j++)
  19. if(maze[i][j] == 2)
  20. printf("█");
  21. else
  22. printf("  ");
  23. printf("\n");
  24. }
  25. if(visit(startI, startJ) == 0)
  26. printf("\n没有找到出口！\n");
  27. else {
  28. printf("\n显示路径：\n");
  29. for(i = 0; i < 7; i++) {
  30. for(j = 0; j < 7; j++) {
  31. if(maze[i][j] == 2)
  32. printf("█");
  33. else if(maze[i][j] == 1)
  34. printf("◇");
  35. else
  36. printf("  ");
  37. }
  38. printf("\n");
  39. }
  40. }
  41. return 0;
  42. }
  43. int visit(int i, int j) {
  44. maze[i][j] = 1;
  45. if(i == endI && j == endJ)
  46. success = 1;
  47. if(success != 1 && maze[i][j+1] == 0) visit(i, j+1);
  48. if(success != 1 && maze[i+1][j] == 0) visit(i+1, j);
  49. if(success != 1 && maze[i][j-1] == 0) visit(i, j-1);
  50. if(success != 1 && maze[i-1][j] == 0) visit(i-1, j);
  51. if(success != 1)
  52. maze[i][j] = 0;
  53. return success;
  54. }
  55. </span>

6.老鼠走迷官（二）

说明由于迷宫的设计，老鼠走迷宫的入口至出口路径可能不只一条，如何求出所有的路径呢？

解法求所有路径看起来复杂但其实更简单，只要在老鼠走至出口时显示经过的路径，然后退回上一格重新选择下一个位置继续递回就可以了，比求出单一路径还简单，我们的程式只要作一点修改就可以了。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. void visit(int, int);
  4. int maze[9][9] = {{2, 2, 2, 2, 2, 2, 2, 2, 2},
  5. {2, 0, 0, 0, 0, 0, 0, 0, 2},
  6. {2, 0, 2, 2, 0, 2, 2, 0, 2},
  7. {2, 0, 2, 0, 0, 2, 0, 0, 2},
  8. {2, 0, 2, 0, 2, 0, 2, 0, 2},
  9. {2, 0, 0, 0, 0, 0, 2, 0, 2},
  10. {2, 2, 0, 2, 2, 0, 2, 2, 2},
  11. {2, 0, 0, 0, 0, 0, 0, 0, 2},
  12. {2, 2, 2, 2, 2, 2, 2, 2, 2}};
  13. int startI = 1, startJ = 1;  // 入口
  14. int endI = 7, endJ = 7;  // 出口
  15. int main(void) {
  16. int i, j;
  17. printf("显示迷宫：\n");
  18. for(i = 0; i < 7; i++) {
  19. for(j = 0; j < 7; j++)
  20. if(maze[i][j] == 2)
  21. printf("█");
  22. else
  23. printf("  ");
  24. printf("\n");
  25. }
  26. visit(startI, startJ);
  27. return 0;
  28. }
  29. void visit(int i, int j) {
  30. int m, n;
  31. maze[i][j] = 1;
  32. if(i == endI && j == endJ) {
  33. printf("\n显示路径：\n");
  34. for(m = 0; m < 9; m++) {
  35. for(n = 0; n < 9; n++)
  36. if(maze[m][n] == 2)
  37. printf("█");
  38. else if(maze[m][n] == 1)
  39. printf("◇");
  40. else
  41. printf("  ");
  42. printf("\n");
  43. }
  44. }
  45. if(maze[i][j+1] == 0) visit(i, j+1);
  46. if(maze[i+1][j] == 0) visit(i+1, j);
  47. if(maze[i][j-1] == 0) visit(i, j-1);
  48. if(maze[i-1][j] == 0) visit(i-1, j);
  49. maze[i][j] = 0;
  50. }
  51. </span>

7.骑士走棋盘

说明骑士旅游（Knight tour）在十八世纪初倍受数学家与拼图迷的注意，它什么时候被提出已不可考，骑士的走法为西洋棋的走法，骑士可以由任一个位置出发，它要如何走完[所有的位置？

解法骑士的走法，基本上可以使用递回来解决，但是纯綷的递回在维度大时相当没有效率，一个聪明的解法由J.C. Warnsdorff在1823年提出，简单的说，先将最难的位置走完，接下来的路就宽广了，骑士所要走的下一步，「为下一步再选择时，所能走的步数最少的一步。」，使用这个方法，在不使用递回的情况下，可以有较高的机率找出走法（找不到走法的机会也是有的）。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. int board[8][8] = {0};
  3. int travel(int x, int y) {
  4. // 对应骑士可走的八个方向
  5. int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
  6. int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};
  7. // 测试下一步的出路
  8. int nexti[8] = {0};
  9. int nextj[8] = {0};
  10. // 记录出路的个数
  11. int exists[8] = {0};
  12. int i, j, k, m, l;
  13. int tmpi, tmpj;
  14. int count, min, tmp;
  15. i = x;
  16. j = y;
  17. board[i][j] = 1;
  18. for(m = 2; m <= 64; m++) {
  19. for(l = 0; l < 8; l++)
  20. exists[l] = 0;
  21. l = 0;
  22. // 试探八个方向
  23. for(k = 0; k < 8; k++) {
  24. tmpi = i + ktmove1[k];
  25. tmpj = j + ktmove2[k];
  26. // 如果是边界了，不可走
  27. if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)
  28. continue;
  29. // 如果这个方向可走，记录下来
  30. if(board[tmpi][tmpj] == 0) {
  31. nexti[l] = tmpi;
  32. nextj[l] = tmpj;
  33. // 可走的方向加一个
  34. l++;
  35. }
  36. }
  37. count = l;
  38. // 如果可走的方向为0个，返回
  39. if(count == 0) {
  40. return 0;
  41. }
  42. else if(count == 1) {
  43. // 只有一个可走的方向
  44. // 所以直接是最少出路的方向
  45. min = 0;
  46. }
  47. else {
  48. // 找出下一个位置的出路数
  49. for(l = 0; l < count; l++) {
  50. for(k = 0; k < 8; k++) {
  51. tmpi = nexti[l] + ktmove1[k];
  52. tmpj = nextj[l] + ktmove2[k];
  53. if(tmpi < 0 || tmpj < 0 ||
  54. tmpi > 7 || tmpj > 7) {
  55. continue;
  56. }
  57. if(board[tmpi][tmpj] == 0)
  58. exists[l]++;
  59. }
  60. }
  61. tmp = exists[0];
  62. min = 0;
  63. // 从可走的方向中寻找最少出路的方向
  64. for(l = 1; l < count; l++) {
  65. if(exists[l] < tmp) {
  66. tmp = exists[l];
  67. min = l;
  68. }
  69. }
  70. }
  71. // 走最少出路的方向
  72. i = nexti[min];
  73. j = nextj[min];
  74. board[i][j] = m;
  75. }
  76. return 1;
  77. }
  78. int main(void) {
  79. int startx, starty;
  80. int i, j;
  81. printf("输入起始点：");
  82. scanf("%d %d", &startx, &starty);
  83. if(travel(startx, starty)) {
  84. printf("游历完成！\n");
  85. }
  86. else {
  87. printf("游历失败！\n");
  88. }
  89. for(i = 0; i < 8; i++) {
  90. for(j = 0; j < 8; j++) {
  91. printf("%2d ", board[i][j]);
  92. }
  93. putchar('\n');
  94. }
  95. return 0;
  96. } </span>

8.八皇后

说明西洋棋中的皇后可以直线前进，吃掉遇到的所有棋子，如果棋盘上有八个皇后，则这八个皇后如何相安无事的放置在棋盘上，1970年与1971年， E.W.Dijkstra与N.Wirth曾经用这个问题来讲解程式设计之技巧。

解法关于棋盘的问题，都可以用递回求解，然而如何减少递回的次数？在八个皇后的问题中，不必要所有的格子都检查过，例如若某列检查过，该该列的其它格子就不用再检查了，这个方法称为分支修剪。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. #define N 8
  4. int column[N+1]; // 同栏是否有皇后，1表示有
  5. int rup[2*N+1]; // 右上至左下是否有皇后
  6. int lup[2*N+1]; // 左上至右下是否有皇后
  7. int queen[N+1] = {0};
  8. int num; // 解答编号
  9. //void backtrack(int); // 递回求解
  10. void showAnswer() {
  11. int x, y;
  12. printf("\n解答 %d\n", ++num);
  13. for(y = 1; y <= N; y++) {
  14. for(x = 1; x <= N; x++) {
  15. if(queen[y] == x) {
  16. printf(" Q");
  17. }
  18. else {
  19. printf(" .");
  20. }
  21. }
  22. printf("\n");
  23. }
  24. }
  25. void backtrack(int i) {
  26. int j;
  27. if(i > N) {
  28. showAnswer();
  29. }
  30. else {
  31. for(j = 1; j <= N; j++) {
  32. if(column[j] == 1 &&
  33. rup[i+j] == 1 && lup[i-j+N] == 1) {
  34. queen[i] = j;
  35. // 设定为占用
  36. column[j] = rup[i+j] = lup[i-j+N] = 0;
  37. backtrack(i+1);
  38. column[j] = rup[i+j] = lup[i-j+N] = 1;
  39. }
  40. }
  41. }
  42. }
  43. int main(void) {
  44. int i;
  45. num = 0;
  46. for(i = 1; i <= N; i++)
  47. column[i] = 1;
  48. for(i = 1; i <= 2*N; i++)
  49. rup[i] = lup[i] = 1;
  50. backtrack(1);
  51. return 0;
  52. } </span>

9.八枚银币

说明现有八枚银币a b c d e f g h，已知其中一枚是假币，其重量不同于真币，但不知是较轻或较重，如何使用天平以最少的比较次数，决定出哪枚是假币，并得知假币比真币较轻或较重。

解法单就求假币的问题是不难，但问题限制使用最少的比较次数，所以我们不能以单纯的回圈比较来求解，我们可以使用决策树（decision tree），使用分析与树状图来协助求解。一个简单的状况是这样的，我们比较a+b+c与d+e+f ，如果相等，则假币必是g或h，我们先比较g或h哪个较重，如果g较重，再与a比较（a是真币），如果g等于a，则g为真币，则h为假币，由于h比g轻而 g是真币，则h假币的重量比真币轻。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. void compare(int[], int, int, int);
  5. void eightcoins(int[]);
  6. int main(void) {
  7. int coins[8] = {0};
  8. int i;
  9. srand(time(NULL));
  10. for(i = 0; i < 8; i++)
  11. coins[i] = 10;
  12. printf("\n输入假币重量(比10大或小)：");
  13. scanf("%d", &i);
  14. coins[rand() % 8] = i;
  15. eightcoins(coins);
  16. printf("\n\n列出所有钱币重量：");
  17. for(i = 0; i < 8; i++)
  18. printf("%d ", coins[i]);
  19. printf("\n");
  20. return 0;
  21. }
  22. void compare(int coins[], int i, int j, int k) {
  23. if(coins[i] > coins[k])
  24. printf("\n假币 %d 较重", i+1);
  25. else
  26. printf("\n假币 %d 较轻", j+1);
  27. }
  28. void eightcoins(int coins[]) {
  29. if(coins[0]+coins[1]+coins[2] ==
  30. coins[3]+coins[4]+coins[5]) {
  31. if(coins[6] > coins[7])
  32. compare(coins, 6, 7, 0);
  33. else
  34. compare(coins, 7, 6, 0);
  35. }
  36. else if(coins[0]+coins[1]+coins[2] >
  37. coins[3]+coins[4]+coins[5]) {
  38. if(coins[0]+coins[3] == coins[1]+coins[4])
  39. compare(coins, 2, 5, 0);
  40. else if(coins[0]+coins[3] > coins[1]+coins[4])
  41. compare(coins, 0, 4, 1);
  42. if(coins[0]+coins[3] < coins[1]+coins[4])
  43. compare(coins, 1, 3, 0);
  44. }
  45. else if(coins[0]+coins[1]+coins[2] <
  46. coins[3]+coins[4]+coins[5]) {
  47. if(coins[0]+coins[3] == coins[1]+coins[4])
  48. compare(coins, 5, 2, 0);
  49. else if(coins[0]+coins[3] > coins[1]+coins[4])
  50. compare(coins, 3, 1, 0);
  51. if(coins[0]+coins[3] < coins[1]+coins[4])
  52. compare(coins, 4, 0, 1);
  53. }
  54. }
  55. </span>

10.生命游戏

说明生命游戏（game of life）为1970年由英国数学家J. H. Conway所提出，某一细胞的邻居包括上、下、左、右、左上、左下、右上与右下相邻之细胞，游戏规则如下：

孤单死亡：如果细胞的邻居小于一个，则该细胞在下一次状态将死亡。

拥挤死亡：如果细胞的邻居在四个以上，则该细胞在下一次状态将死亡。

稳定：如果细胞的邻居为二个或三个，则下一次状态为稳定存活。

复活：如果某位置原无细胞存活，而该位置的邻居为三个，则该位置将复活一细胞。

解法生命游戏的规则可简化为以下，并使用CASE比对即可使用程式实作：

邻居个数为0、1、4、5、6、7、8时，则该细胞下次状态为死亡。

邻居个数为2时，则该细胞下次状态为复活。

邻居个数为3时，则该细胞下次状态为稳定。

  1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>
  2. #include <stdlib.h>
  3. #include <ctype.h>
  4. #define MAXROW 10
  5. #define MAXCOL 25
  6. #define DEAD 0
  7. #define ALIVE 1
  8. int map[MAXROW][MAXCOL], newmap[MAXROW][MAXCOL];
  9. void init();
  10. int neighbors(int, int);
  11. void outputMap();
  12. void copyMap();
  13. int main() {
  14. int row, col;
  15. char ans;
  16. init();
  17. while(1) {
  18. outputMap();
  19. for(row = 0; row < MAXROW; row++) {
  20. for(col = 0; col < MAXCOL; col++) {
  21. switch (neighbors(row, col)) {
  22. case 0:
  23. case 1:
  24. case 4:
  25. case 5:
  26. case 6:
  27. case 7:
  28. case 8:
  29. newmap[row][col] = DEAD;
  30. break;
  31. case 2:
  32. newmap[row][col] = map[row][col];
  33. break;
  34. case 3:
  35. newmap[row][col] = ALIVE;
  36. break;
  37. }
  38. }
  39. }
  40. copyMap();
  41. printf("\nContinue next Generation ? ");
  42. getchar();
  43. ans = toupper(getchar());
  44. if(ans != 'Y')    break;
  45. }
  46. return 0;
  47. }
  48. void init() {
  49. int row, col;
  50. for(row = 0; row < MAXROW; row++)
  51. for(col = 0; col < MAXCOL; col++)
  52. map[row][col] = DEAD;
  53. puts("Game of life Program");
  54. puts("Enter x, y where x, y is living cell");
  55. printf("0 <= x <= %d, 0 <= y <= %d\n",
  56. MAXROW-1, MAXCOL-1);
  57. puts("Terminate with x, y = -1, -1");
  58. while(1) {
  59. scanf("%d %d", &row, &col);
  60. if(0 <= row && row < MAXROW &&
  61. 0 <= col && col < MAXCOL)
  62. map[row][col] = ALIVE;
  63. else if(row == -1 || col == -1)
  64. break;
  65. else
  66. printf("(x, y) exceeds map ranage!");
  67. }
  68. }
  69. int neighbors(int row, int col) {
  70. int count = 0, c, r;
  71. for(r = row-1; r <= row+1; r++)
  72. for(c = col-1; c <= col+1; c++) {
  73. if(r < 0 || r >= MAXROW || c < 0 || c >= MAXCOL)
  74. continue;
  75. if(map[r][c] == ALIVE)
  76. count++;
  77. }
  78. if(map[row][col] == ALIVE)
  79. count--;
  80. return count;
  81. }
  82. void outputMap() {
  83. int row, col;
  84. printf("\n\n%20cGame of life cell status\n");
  85. for(row = 0; row < MAXROW; row++) {
  86. printf("\n%20c", ' ');
  87. for(col = 0; col < MAXCOL; col++)
  88. if(map[row][col] == ALIVE)     putchar('#');
  89. else    putchar('-');
  90. }
  91. }
  92. void copyMap() {
  93. int row, col;
  94. for(row = 0; row < MAXROW; row++)
  95. for(col = 0; col < MAXCOL; col++)
  96. map[row][col] = newmap[row][col];
  97. }
  98. </span>

最新文章

  1. C# listview 单击列头实现排序 &lt;二&gt;
  2. C#之设计模式
  3. jquery选中下拉列表的某个值
  4. oracle的函数
  5. C++——友元、异常和其他
  6. C#中virtual和abstract的区别
  7. 如何使用css和jquery控制文章标题字数？
  8. Uva 796 Critical Links 找桥
  9. nyoj 44
  10. c++模板两个数的加法
  11. 【Codeforces Round 431 (Div. 2) A B C D E五个题】
  12. git解析日志常用命令
  13. servlet篇 之 跳转问题
  14. java lang(ClassLoader)
  15. CC NOV17
  16. c++之__attribute__((unused))
  17. RQNOJ 1 明明的随机数
  18. Java虚拟机的最大内存是多少
  19. OA-DB-LINUX安装说明
  20. 【环境变量】删掉centos原有的openjdk并安装sun jdk

热门文章

  1. Java之泛型浅解
  2. pthread_detach()函数
  3. 使用WindowsAPI实现播放PCM音频的方法
  4. Codeforces Round #402 (Div. 2) 阵亡记
  5. [Codeforces 204E] Little Elephant and Strings
  6. Oracle RAC TAF 无缝failover
  7. HDOJ1166(线段树点修改)
  8. &lt;正则吃饺子&gt; ：关于Java的native方法（转）
  9. jquery.html5uploader.js 上传控件
  10. cocos2dx之lua绑定简析