C语言经典算法讲解练习

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亿年左右。

#include <stdio.h>void hanoi(int n, char A, char B, char C) {if(n == 1) {printf("Move sheet %d from %c to %c\n", n, A, C);}else {hanoi(n-1, A, C, B);printf("Move sheet %d from %c to %c\n", n, A, C);hanoi(n-1, B, A, C);}
}int main() {int n;printf("请输入盘数：");scanf("%d", &n);hanoi(n, 'A', 'B', 'C');return 0;
} 

这段代码是一个递归实现的汉诺塔问题解决方案。输入一个整数n代表盘子的数量，然后调用hanoi函数，在三个柱子A、B、C之间移动这些盘子。如果n等于1，就直接从柱子A移动到柱子C；否则将n-1个盘子从A经过C移动到B，然后将剩下的一个盘子从A移动到C，最后再将n-1个盘子从B经过A移动到C。最终完成整个汉诺塔问题的移动。

2.费式数列

说明：Fibonacci为1200年代的欧洲数学家，在他的着作中曾经提到：「若有一只免子每个月生一只小免子，一个月后小免子也开始生产。起初只有一只免子，一个月后就有两只免子，二个月后有三只免子，三个月后有五只免子（小免子投入生产）…。
如果不太理解这个例子的话，举个图就知道了，注意新生的小免子需一个月成长期才会投入生产，类似的道理也可以用于植物的生长，这就是Fibonacci数列，一般习惯称之为费氏数列，例如以下： 1、1 、2、3、5、8、13、21、34、55、89…
解法：依说明，我们可以将费氏数列定义为以下：
fn = fn-1 + fn-2　　 if n > 1
fn = n　　　　　　 if n = 0, 1

#include <stdio.h> 
#include <stdlib.h> #define N 20 int main(void) { 
int Fib[N] = {0}; 
int i; Fib[0] = 0; 
Fib[1] = 1; for(i = 2; i < N; i++) 
Fib[i] = Fib[i-1] + Fib[i-2]; for(i = 0; i < N; i++) 
printf("%d ", Fib[i]); 
printf("\n"); return 0; 
}

3. 巴斯卡三角形

#include <stdio.h>
#define N 12
long combi(int n, int r){int i;long p = 1;for(i = 1; i <= r; i++)p = p * (n-i+1) / i;return p;
}
void paint() {int n, r, t;for(n = 0; n <= N; n++) {for(r = 0; r <= n; r++) {int i;/* 排版设定开始 */if(r == 0) {  for(i = 0; i <= (N-n); i++) printf("   ");}else {printf("   ");} /* 排版设定结束 */printf("%3d", combi(n, r));}printf("\n");}
}

这段代码定义了一个宏N为12，然后有一个计算组合数的函数combi和一个打印组合数的函数paint。combi函数用来计算C(n, r)的值，即从n个元素中选取r个元素的组合数。paint函数则是用来打印一个组合数三角形，以展示不同的组合数值。
在主函数中，首先循环遍历n从0到12，然后在每个n值下再循环遍历r从0到n，计算并打印出对应的组合数值。同时也进行了一些排版设定，使输出更加美观。
整体来说，这段代码的功能是计算组合数并以三角形形式打印出来。

4.三色棋

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

假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。
解法：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来作辅助，问题的解法很简单，您可以自己想像一下在移动旗子，从绳子开头进行，遇到蓝色往前移，遇到白色留在中间，遇到红色往后移，如下所示：
只是要让移动次数最少的话，就要有些技巧：
如果图中W所在的位置为白色，则W+1，表示未处理的部份移至至白色群组。
如果W部份为蓝色，则B与W的元素对调，而B与W必须各+1，表示两个群组都多了一个元素。
如果W所在的位置是红色，则将W与R交换，但R要减1，表示未处理的部份减1。

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

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> #define BLUE 'b' 
#define WHITE 'w' 
#define RED 'r' #define SWAP(x, y) { char temp; \temp = color[x]; \color[x] = color[y]; \color[y] = temp; }int main() {char color[] = {'r', 'w', 'b', 'w', 'w', 'b', 'r', 'b', 'w', 'r', '\0'}; int wFlag = 0;int bFlag = 0;int rFlag = strlen(color) - 1;int i; for(i = 0; i < strlen(color); i++) printf("%c ", color[i]); printf("\n"); while(wFlag <= rFlag) {if(color[wFlag] == WHITE)wFlag++;else if(color[wFlag] == BLUE) {SWAP(bFlag, wFlag);bFlag++; wFlag++;} else { while(wFlag < rFlag && color[rFlag] == RED)rFlag--;SWAP(rFlag, wFlag);rFlag--;} } for(i = 0; i < strlen(color); i++) printf("%c ", color[i]); printf("\n"); return 0; 
} 

首先，定义了三种颜色的宏：BLUE表示蓝色，WHITE表示白色，RED表示红色。然后定义了一个宏SWAP来交换两个位置的颜色。
在主函数main中，定义了一个包含不同颜色的数组color，并初始化了三个标志变量wFlag、bFlag和rFlag。然后通过一个循环打印数组中的颜色。接着使用一个while循环来解决荷兰国旗问题：将颜色按照蓝色、白色和红色的顺序排列。
具体来说，当wFlag小于等于rFlag时，根据当前位置的颜色进行不同的操作：如果是白色则继续前进，如果是蓝色则与bFlag位置交换并将bFlag和wFlag都加一，如果是红色则将当前位置与rFlag位置交换并将rFlag减一。
最后再次用循环输出调整后的颜色数组，完成排序。

5.老鼠走迷官（一）

说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。
解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。

#include <stdio.h>
#include <stdlib.h> int visit(int, int); int maze[7][7] = {{2, 2, 2, 2, 2, 2, 2}, {2, 0, 0, 0, 0, 0, 2}, {2, 0, 2, 0, 2, 0, 2}, {2, 0, 0, 2, 0, 2, 2}, {2, 2, 0, 2, 0, 2, 2}, {2, 0, 0, 0, 0, 0, 2}, {2, 2, 2, 2, 2, 2, 2}}; int startI = 1, startJ = 1;  // 入口
int endI = 5, endJ = 5;  // 出口
int success = 0;int main(void) { int i, j; printf("显示迷宫：\n"); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) if(maze[i][j] == 2) printf("█"); else printf("  "); printf("\n"); } if(visit(startI, startJ) == 0)printf("\n没有找到出口！\n"); else { printf("\n显示路径：\n"); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { if(maze[i][j] == 2) printf("█"); else if(maze[i][j] == 1) printf("◇"); else printf("  "); } printf("\n"); } } return 0; 
} int visit(int i, int j) { maze[i][j] = 1; if(i == endI && j == endJ)success = 1; if(success != 1 && maze[i][j+1] == 0) visit(i, j+1); if(success != 1 && maze[i+1][j] == 0) visit(i+1, j); if(success != 1 && maze[i][j-1] == 0) visit(i, j-1); if(success != 1 && maze[i-1][j] == 0) visit(i-1, j); if(success != 1) maze[i][j] = 0; return success; 
}  

代码中定义了一个7x7的迷宫数组maze，其中数字2表示墙，0表示可走的路，1表示已走过的路。起点和终点分别为(1,1)和(5,5)。
visit函数通过递归调用来搜索通往终点的路径，先将当前位置标记为1，然后按右、下、左、上的顺序尝试前进，如果成功找到终点则将success标记为1。最终将找到的路径标记为1，没找到则将标记为0。
主函数先输出迷宫地图，然后调用visit函数开始寻找路径。如果成功找到出口则输出路径，否则输出未找到出口的提示。
整体思路清晰，代码结构简单易懂。

6.老鼠走迷官（二）

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

#include <stdio.h>
#include <stdlib.h> void visit(int, int);int maze[9][9] = {{2, 2, 2, 2, 2, 2, 2, 2, 2},{2, 0, 0, 0, 0, 0, 0, 0, 2},{2, 0, 2, 2, 0, 2, 2, 0, 2},{2, 0, 2, 0, 0, 2, 0, 0, 2},{2, 0, 2, 0, 2, 0, 2, 0, 2},{2, 0, 0, 0, 0, 0, 2, 0, 2},{2, 2, 0, 2, 2, 0, 2, 2, 2},{2, 0, 0, 0, 0, 0, 0, 0, 2},{2, 2, 2, 2, 2, 2, 2, 2, 2}};int startI = 1, startJ = 1;  // 入口
int endI = 7, endJ = 7;  // 出口int main(void) { int i, j; printf("显示迷宫：\n"); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) if(maze[i][j] == 2) printf("█"); else printf("  "); printf("\n"); } visit(startI, startJ);return 0; 
} void visit(int i, int j) {int m, n;maze[i][j] = 1; if(i == endI && j == endJ) {printf("\n显示路径：\n");for(m = 0; m < 9; m++) {for(n = 0; n < 9; n++)if(maze[m][n] == 2)printf("█");else if(maze[m][n] == 1)printf("◇");elseprintf("  ");printf("\n");}}if(maze[i][j+1] == 0) visit(i, j+1);if(maze[i+1][j] == 0) visit(i+1, j);if(maze[i][j-1] == 0) visit(i, j-1);if(maze[i-1][j] == 0) visit(i-1, j);maze[i][j] = 0;
}  

首先定义了一个9x9的迷宫数组，其中2代表墙，0代表通路，1代表走过的路。起点和终点分别为(1,1)和(7,7)。visit函数用来递归搜索路径，将走过的路标记为1。当找到终点时，输出路径，用"◇"表示走过的路。然后尝试四个方向移动，如果位置为0则继续递归移动，直到找到出口。最后将走过的路标记为0。在main函数中显示迷宫地图，并调用visit函数开始寻找路径。

7.骑士走棋盘

说明骑士旅游（Knight tour）在十八世纪初倍受数学家与拼图迷的注意，它什么时候被提出已不可考，骑士的走法为西洋棋的走法，骑士可以由任一个位置出发，它要如何走完[所有的位置？
解法骑士的走法，基本上可以使用递回来解决，但是纯綷的递回在维度大时相当没有效率，一个聪明的解法由J.C. Warnsdorff在1823年提出，简单的说，先将最难的位置走完，接下来的路就宽广了，骑士所要走的下一步，「为下一步再选择时，所能走的步数最少的一步。」，使用这个方法，在不使用递回的情况下，可以有较高的机率找出走法（找不到走法的机会也是有的）。

#include <stdio.h> int board[8][8] = {0}; int main(void) {int startx, starty;int i, j;printf("输入起始点：");scanf("%d %d", &startx, &starty);if(travel(startx, starty)) {printf("游历完成！\n");}else {printf("游历失败！\n");}for(i = 0; i < 8; i++) {for(j = 0; j < 8; j++) {printf("%2d ", board[i][j]);}putchar('\n');}return 0;
} int travel(int x, int y) {// 对应骑士可走的八个方向int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};// 测试下一步的出路int nexti[8] = {0};int nextj[8] = {0};// 记录出路的个数int exists[8] = {0};int i, j, k, m, l;int tmpi, tmpj;int count, min, tmp;i = x;j = y;board[i][j] = 1;for(m = 2; m <= 64; m++) {for(l = 0; l < 8; l++) exists[l] = 0;l = 0;// 试探八个方向for(k = 0; k < 8; k++) {tmpi = i + ktmove1[k];tmpj = j + ktmove2[k];// 如果是边界了，不可走if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)continue;// 如果这个方向可走，记录下来if(board[tmpi][tmpj] == 0) {nexti[l] = tmpi;nextj[l] = tmpj;// 可走的方向加一个l++;}}count = l;// 如果可走的方向为0个，返回if(count == 0) {return 0;}else if(count == 1) {// 只有一个可走的方向// 所以直接是最少出路的方向min = 0;}else {// 找出下一个位置的出路数for(l = 0; l < count; l++) {for(k = 0; k < 8; k++) {tmpi = nexti[l] + ktmove1[k];tmpj = nextj[l] + ktmove2[k];if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7) {continue;}if(board[tmpi][tmpj] == 0)exists[l]++;}}tmp = exists[0];min = 0;// 从可走的方向中寻找最少出路的方向for(l = 1; l < count; l++) {if(exists[l] < tmp) {tmp = exists[l];min = l;}}}// 走最少出路的方向i = nexti[min];j = nextj[min];board[i][j] = m;}return 1;
} 

代码首先定义了一个8x8的棋盘board，并初始化为全0。然后在主函数中，用户输入起始点的坐标，然后调用travel函数来游历棋盘。如果游历成功，则输出"游历完成！“，否则输出"游历失败！”。最后输出游历的路径。
在travel函数中，定义了马的八种移动方向ktmove1和ktmove2。然后对起始点进行标记，然后开始遍历棋盘寻找下一步可以走的方向。循环64次，即遍历完整个棋盘，每次找到下一个位置可走的最小出路方向进行移动，并标记路径点。最后返回1表示游历成功，返回0表示游历失败。
整个程序通过模拟马在棋盘上的移动路径，展示了一种解决问题的算法，同时也展示了基本的数组操作和循环控制的使用。

8.八皇后

说明西洋棋中的皇后可以直线前进，吃掉遇到的所有棋子，如果棋盘上有八个皇后，则这八个皇后如何相安无事的放置在棋盘上，1970年与1971年， E.W.Dijkstra与N.Wirth曾经用这个问题来讲解程式设计之技巧。
解法关于棋盘的问题，都可以用递回求解，然而如何减少递回的次数？在八个皇后的问题中，不必要所有的格子都检查过，例如若某列检查过，该该列的其它格子就不用再检查了，这个方法称为分支修剪。

#include <stdio.h> 
#include <stdlib.h> 
#define N 8 int column[N+1]; // 同栏是否有皇后，1表示有 
int rup[2*N+1]; // 右上至左下是否有皇后 
int lup[2*N+1]; // 左上至右下是否有皇后 
int queen[N+1] = {0}; 
int num; // 解答编号 void backtrack(int); // 递回求解 int main(void) { int i; num = 0; for(i = 1; i <= N; i++) column[i] = 1; for(i = 1; i <= 2*N; i++) rup[i] = lup[i] = 1; backtrack(1); return 0; 
} void showAnswer() {int x, y;printf("\n解答 %d\n", ++num);for(y = 1; y <= N; y++) {for(x = 1; x <= N; x++) {if(queen[y] == x) {printf(" Q");}else {printf(" .");}}printf("\n");}
}void backtrack(int i) { int j;if(i > N) { showAnswer();} else { for(j = 1; j <= N; j++) { if(column[j] == 1 && rup[i+j] == 1 && lup[i-j+N] == 1) { queen[i] = j; // 设定为占用column[j] = rup[i+j] = lup[i-j+N] = 0; backtrack(i+1); column[j] = rup[i+j] = lup[i-j+N] = 1; } } } 
} 

代码中使用了回溯法来递归求解，通过判断每一个皇后的位置是否冲突来找到所有合法的解。
首先定义了三个数组来表示同栏、左上至右下、右上至左下是否有皇后的情况。然后定义了queen数组来存储每一行皇后的位置。定义了一个backtrack函数来递归求解，当找到一个合法的解时，调用showAnswer函数显示这个解。
在main函数中初始化了一些数组，并调用backtrack函数开始求解。backtrack函数中首先判断当前行是否超过了N，如果超过了则调用showAnswer展示解答，否则遍历当前行的所有列，判断是否满足条件，如果满足条件则设置queen数组，并继续递归求解下一行。当递归完成后，重置数组来继续寻找其他解。
最终得到所有的解，并依次将解输出显示。
这段代码使用了经典的回溯算法来解决八皇后问题，通过递归探索所有可能的解，找到所有不冲突的皇后放置方式。

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假币的重量比真币轻。

```c
#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> void compare(int[], int, int, int); 
void eightcoins(int[]); int main(void) { int coins[8] = {0}; int i; srand(time(NULL)); for(i = 0; i < 8; i++) coins[i] = 10; printf("\n输入假币重量(比10大或小)："); scanf("%d", &i); coins[rand() % 8] = i; eightcoins(coins); printf("\n\n列出所有钱币重量："); for(i = 0; i < 8; i++) printf("%d ", coins[i]); printf("\n"); return 0; 
} void compare(int coins[], int i, int j, int k) { if(coins[i] > coins[k]) printf("\n假币 %d 较重", i+1); else printf("\n假币 %d 较轻", j+1); 
} void eightcoins(int coins[]) { if(coins[0]+coins[1]+coins[2] == coins[3]+coins[4]+coins[5]) { if(coins[6] > coins[7]) compare(coins, 6, 7, 0); else compare(coins, 7, 6, 0); } else if(coins[0]+coins[1]+coins[2] > coins[3]+coins[4]+coins[5]) { if(coins[0]+coins[3] == coins[1]+coins[4]) compare(coins, 2, 5, 0); else if(coins[0]+coins[3] > coins[1]+coins[4]) compare(coins, 0, 4, 1); if(coins[0]+coins[3] < coins[1]+coins[4]) compare(coins, 1, 3, 0); } else if(coins[0]+coins[1]+coins[2] <coins[3]+coins[4]+coins[5]) { if(coins[0]+coins[3] == coins[1]+coins[4]) compare(coins, 5, 2, 0); else if(coins[0]+coins[3] > coins[1]+coins[4]) compare(coins, 3, 1, 0); if(coins[0]+coins[3] < coins[1]+coins[4]) compare(coins, 4, 0, 1); } 
} 

实现了一个模拟称重假币的程序，假设有8枚硬币中有一枚假币，重量要么比其他正常硬币重，要么比其他正常硬币轻。程序通过随机将假币的重量设为大于或小于10，并通过对硬币的称重比较，找出这枚假币是较重还是较轻。
void compare(int coins[], int i, int j, int k)函数用于比较硬币的重量，如果第i枚硬币比第k枚硬币重，则输出"假币i较重”，否则输出"假币j较轻"。
void eightcoins(int coins[])函数实现了对8枚硬币进行比较的逻辑。首先比较3枚硬币的总重量是否相等，如果相等再比较剩下的硬币中哪枚是假币。如果不相等，则继续按一定的逻辑比较找出假币。
main函数初始化硬币的重量为10，随机设定一枚硬币的重量为假币的重量，并调用eightcoins函数比较找出假币的情况，并输出所有硬币的重量。
这段代码用来模拟称重找出一枚假币的重量是偏重还是偏轻。

10.生命游戏

说明生命游戏（game of life）为1970年由英国数学家J. H. Conway所提出，某一细胞的邻居包括上、下、左、右、左上、左下、右上与右下相邻之细胞，游戏规则如下：
孤单死亡：如果细胞的邻居小于一个，则该细胞在下一次状态将死亡。
拥挤死亡：如果细胞的邻居在四个以上，则该细胞在下一次状态将死亡。
稳定：如果细胞的邻居为二个或三个，则下一次状态为稳定存活。
复活：如果某位置原无细胞存活，而该位置的邻居为三个，则该位置将复活一细胞。
解法生命游戏的规则可简化为以下，并使用CASE比对即可使用程式实作：
邻居个数为0、1、4、5、6、7、8时，则该细胞下次状态为死亡。
邻居个数为2时，则该细胞下次状态为复活。
邻居个数为3时，则该细胞下次状态为稳定。

#include <stdio.h> 
#include <stdlib.h> 
#include <ctype.h> #define MAXROW 10 
#define MAXCOL 25 
#define DEAD 0 
#define ALIVE 1 
int map[MAXROW][MAXCOL], newmap[MAXROW][MAXCOL]; void init(); 
int neighbors(int, int);
void outputMap();
void copyMap();int main() { int row, col; char ans; init();while(1) {outputMap();for(row = 0; row < MAXROW; row++) {for(col = 0; col < MAXCOL; col++) {switch (neighbors(row, col)) {case 0: case 1: case 4: case 5: case 6: case 7: case 8: newmap[row][col] = DEAD; break; case 2: newmap[row][col] = map[row][col]; break; case 3: newmap[row][col] = ALIVE; break; } }}copyMap();printf("\nContinue next Generation ? ");getchar();ans = toupper(getchar());if(ans != 'Y')	break;}return 0; 
} void init() {int row, col; for(row = 0; row < MAXROW; row++) for(col = 0; col < MAXCOL; col++) map[row][col] = DEAD; puts("Game of life Program"); puts("Enter x, y where x, y is living cell");printf("0 <= x <= %d, 0 <= y <= %d\n", MAXROW-1, MAXCOL-1); puts("Terminate with x, y = -1, -1");while(1) {scanf("%d %d", &row, &col); if(0 <= row && row < MAXROW && 0 <= col && col < MAXCOL)map[row][col] = ALIVE;else if(row == -1 || col == -1)break;else printf("(x, y) exceeds map ranage!"); }
}int neighbors(int row, int col) {int count = 0, c, r; for(r = row-1; r <= row+1; r++) for(c = col-1; c <= col+1; c++) { if(r < 0 || r >= MAXROW || c < 0 || c >= MAXCOL) continue; if(map[r][c] == ALIVE) count++; } if(map[row][col] == ALIVE) count--; return count; 
} void outputMap() {int row, col; printf("\n\n%20cGame of life cell status\n"); for(row = 0; row < MAXROW; row++) { printf("\n%20c", ' '); for(col = 0; col < MAXCOL; col++) if(map[row][col] == ALIVE) 	putchar('#'); else 	 putchar('-'); } 
} void copyMap() {int row, col; for(row = 0; row < MAXROW; row++) for(col = 0; col < MAXCOL; col++) map[row][col] = newmap[row][col]; 
}  

展示了解决八个假币问题的算法。在主函数中，首先生成包含了8个重量为10的假币的数组，然后随机选择一个位置来替换为输入的假币重量。接着调用eightcoins函数来根据不同情况比较假币的重量，找出假币是轻还是重。最后输出所有钱币的重量。
在eightcoins函数中，通过比较1-6号假币的总重量来确定7-8号假币是轻还是重；然后基于比较1-3号假币和4-5号假币的总重量来确定2号假币的情况；最后根据比较1-3号假币和4-5号假币的总重量来确定6号假币的情况。根据不同的情况选择调用compare函数来输出假币是重还是轻。
这个算法通过有效的比较方式，可以快速找出是轻还是重的假币。