1 求数组元素的最大值

1.1 问题

创建程序，实现查询数组中最大值的功能，需求为：创建一个长度为10的数组，数组内放置10个0~99之间（包含0，包含99）的随机数作为数组内容，要求查询出数组中的最大值，并打印显示在界面上，控制台效果如图-1所示：

图-1

1.2 方案

首先，此方案中，需要创建一个长度为10的整型数组。

然后，使用for循环来产生10个0~99之间的随机整数，并放入数组。

最后，查询数组中的最大值，并打印显示结果。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

变量max，用于保存数组中的最大值。

代码如下：

 
  1. #include <stdio.h>
  3. int main()
  4. {
  5. int max;
  7. return 0;
  8. }

步骤二：创建数组

在main方法中创建一个元素个数为10的数组。

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. int max;
  6. int arr[10];
  8. return 0;
  9. }

步骤三：在数组内放置10个0~99之间的随机数

srand和rand()配合使用产生伪随机数序列。rand函数在产生随机数前，需要系统提供的生成伪随机数序列的种子，rand根据这个种子的值产生一系列随机数。如果系统提供的种子没有变化，每次调用rand函数生成的伪随机数序列都是一样的。srand(unsigned seed)通过参数seed改变系统提供的种子值，从而可以使得每次调用rand函数生成的伪随机数序列不同，从而实现真正意义上的“随机”。通常可以利用系统时间来改变系统的种子值，即srand(time(0))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列。

使用rand()函数返回一个0到RAND_MAX之间的随机数。RAND_MAX为2147483647。然后，将随机数整除100求余数，则可以生成一个0~99之间的随机数（包含0，也包含99）。

注意：rand()函数与srand()函数需要在程序开头包含stdlib.h头函数；time()函数需要在程序开头包含time.h头函数。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int arr[10];
  10. srand((unsigned)time(0));
  11. for (int i = 0; i< 10; i++)
  12. arr[i] = (int)rand() % 100;
  14. return 0;
  15. }

步骤四：打印数组内容

数组赋值后，为方便用户查看数组中的数据内容，需要将数组中的数据打印在控制台上。

代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int arr[10];
  10. srand((unsigned)time(0));
  11. for (int i = 0; i< 10; i++)
  12. arr[i] = (int)rand() % 100;
  14. printf(“数组中的数据为：”);
  15. for (int i = 0; i < 10; i++)
  16. printf(” %d”, arr[i]);
  17. printf(“\n“);
  19. return 0;
  20. }

步骤五：查询最大值

为找到数组中的最大值，依然需要使用循环来遍历数组。变量max用于存储最大值，开始时，将变量max赋值为数组的第一个元素；然后依次把数组中的元素与变量max进行数值比较，如果数组中的某元素的数值大于max，则将该元素的数值存入变量max

代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int arr[10];
  10. srand((unsigned)time(0));
  11. for (int i = 0; i< 10; i++)
  12. arr[i] = (int)rand() % 100;
  14. printf(“数组中的数据为：”);
  15. for (int i = 0; i < 10; i++)
  16. printf(” %d”, arr[i]);
  17. printf(“\n“);
  19. max = arr[0];
  20. for (int i = 1; i < 10; i++)
  21. if (max < arr[i])
  22. max = arr[i];
  24. return 0;
  25. }

步骤六：输出最大值

代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int arr[10];
  10. srand((unsigned)time(0));
  11. for (int i = 0; i< 10; i++)
  12. arr[i] = (int)rand() % 100;
  14. printf(“数组中的数据为：”);
  15. for (int i = 0; i < 10; i++)
  16. printf(” %d”, arr[i]);
  17. printf(“\n“);
  19. max = arr[0];
  20. for (int i = 1; i < 10; i++)
  21. if (max < arr[i])
  22. max = arr[i];
  24. printf(“最大值是：%d\n“, max);
  26. return 0;
  27. }

1.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int arr[10];
  10. srand((unsigned)time(0));
  11. for (int i = 0; i< 10; i++)
  12. arr[i] = (int)rand() % 100;
  14. printf(“数组中的数据为：”);
  15. for (int i = 0; i < 10; i++)
  16. printf(” %d”, arr[i]);
  17. printf(“\n“);
  19. max = arr[0];
  20. for (int i = 1; i < 10; i++)
  21. if (max < arr[i])
  22. max = arr[i];
  24. printf(“最大值是：%d\n“, max);
  26. return 0;
  27. }

2 求数组中最大值，最小值，平均值，和

2.1 问题

创建程序，实现以下的功能：求最大值、最小值、平均值和所有元素的和。

需求为：创建一个长度为10的数组，数组内放置10个0~99之间（包含0，包含99）的随机数作为数组内容，按要求查询出数组中的最大值、最小值、平均值并计算出所有数组元素的和，然后将结果打印显示在界面上。控制台效果如图-2所示：

图-2

2.2 方案

首先，此方案中，需要创建一个长度为10的整型数组。

然后，使用for循环来产生10个0~99之间的随机整数，并放入数组。

下一步，查询数组中的最大值，并打印显示结果。

下一步，查询数组中的最小值，并打印显示结果。

最后，计算数组中所有元素的和，并打印数组元素的平均值与和。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量并创建数组

变量max，用于保存数组中的最大值。

变量min，用于保存数组中的最小值。

变量average，用于保存数组元素的平均值。

变量sum，用于保存数组元素的和。

数组arr，包含10个数组元素。

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. int max;
  6. int min;
  7. double average;
  8. int sum = 0;
  9. int arr[10];
  11. return 0;
  12. }

步骤二：在数组内放置10个0~99之间的随机数，并将放置后的结果输出

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int min;
  9. double average;
  10. int sum = 0;
  11. int arr[10];
  13. srand((unsigned)time(0));
  14. for (int i = 0; i< 10; i++)
  15. arr[i] = (int)rand() % 100;
  17. printf(“数组中的数据为：”);
  18. for (int i = 0; i < 10; i++)
  19. printf(” %d”, arr[i]);
  20. printf(“\n“);
  22. return 0;
  23. }

注意：rand()函数与srand()函数需要在程序开头包含stdlib.h头函数；time()函数需要在程序开头包含time.h头函数。

步骤三：查询最大值并输出

为找到数组中的最大值，依然需要使用循环来遍历数组。变量max用于存储最大值，开始时，将变量max赋值为数组的第一个元素；然后依次把数组中的元素与变量max进行数值比较，如果数组中的某元素的数值大于max，则将该元素的数值存入变量max

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int min;
  9. double average;
  10. int sum = 0;
  11. int arr[10];
  13. srand((unsigned)time(0));
  14. for (int i = 0; i< 10; i++)
  15. arr[i] = (int)rand() % 100;
  17. printf(“数组中的数据为：”);
  18. for (int i = 0; i < 10; i++)
  19. printf(” %d”, arr[i]);
  20. printf(“\n“);
  22. max = arr[0];
  23. for (int i = 1; i < 10; i++)
  24. if (max < arr[i])
  25. max = arr[i];
  26. printf(“最大值是：%d\n“, max);
  28. return 0;
  29. }

步骤四：查询最小值并输出

为找到数组中的最小值，依然需要使用循环来遍历数组。变量min用于存储最小值，开始时，将变量min赋值为数组的第一个元素；然后依次把数组中的元素与变量min进行数值比较，如果数组中的某元素的数值小于min，则将该元素的数值存入变量min。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int min;
  9. double average;
  10. int sum = 0;
  11. int arr[10];
  13. srand((unsigned)time(0));
  14. for (int i = 0; i< 10; i++)
  15. arr[i] = (int)rand() % 100;
  17. printf(“数组中的数据为：”);
  18. for (int i = 0; i < 10; i++)
  19. printf(” %d”, arr[i]);
  20. printf(“\n“);
  22. max = arr[0];
  23. for (int i = 1; i < 10; i++)
  24. if (max < arr[i])
  25. max = arr[i];
  26. printf(“最大值是：%d\n“, max);
  28. min = arr[0];
  29. for (int i = 1; i < 10; i++)
  30. if (min > arr[i])
  31. min = arr[i];
  32. printf(“最小值是：%d\n“, min);
  34. return 0;
  35. }

步骤五：计算数组元素的和并求平均值

为计算数组元素的和，依然需要使用循环来遍历数组。变量sum用于存储和值，开始时，将变量sum被初始化为0；然后依次把数组中的元素累加到变量sum中，直至数组的最后一个元素。然后将和值除以数组元素个数得到平均值。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int min;
  9. double average;
  10. int sum = 0;
  11. int arr[10];
  13. srand((unsigned)time(0));
  14. for (int i = 0; i< 10; i++)
  15. arr[i] = (int)rand() % 100;
  17. printf(“数组中的数据为：”);
  18. for (int i = 0; i < 10; i++)
  19. printf(” %d”, arr[i]);
  20. printf(“\n“);
  22. max = arr[0];
  23. for (int i = 1; i < 10; i++)
  24. if (max < arr[i])
  25. max = arr[i];
  26. printf(“最大值是：%d\n“, max);
  28. min = arr[0];
  29. for (int i = 1; i < 10; i++)
  30. if (min > arr[i])
  31. min = arr[i];
  32. printf(“最小值是：%d\n“, min);
  34. for (int i = 1; i < 10; i++)
  35. sum += arr[i];
  36. average = sum / 10.0;
  37. printf(“平均值是：%lf，和是：%d\n“, average, sum);
  39. return 0;
  40. }

2.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int max;
  8. int min;
  9. double average;
  10. int sum = 0;
  11. int arr[10];
  13. srand((unsigned)time(0));
  14. for (int i = 0; i< 10; i++)
  15. arr[i] = (int)rand() % 100;
  17. printf(“数组中的数据为：”);
  18. for (int i = 0; i < 10; i++)
  19. printf(” %d”, arr[i]);
  20. printf(“\n“);
  22. max = arr[0];
  23. for (int i = 1; i < 10; i++)
  24. if (max < arr[i])
  25. max = arr[i];
  26. printf(“最大值是：%d\n“, max);
  28. min = arr[0];
  29. for (int i = 1; i < 10; i++)
  30. if (min > arr[i])
  31. min = arr[i];
  32. printf(“最小值是：%d\n“, min);
  34. for (int i = 1; i < 10; i++)
  35. sum += arr[i];
  36. average = sum / 10.0;
  37. printf(“平均值是：%lf，和是：%d\n“, average, sum);
  39. return 0;
  40. }

3 随机产生一组双色球

3.1 问题

双色球是中国福利彩票的一种玩法。由中国福利彩票发行管理中心统一组织发行，2003年2月16日起在全国联网销售。

双色球属于双区投注的乐透型彩票。投注时需同时从两个号码区中分别选取号码，即从红色球号码区的33个号码中选择6个号码，再从蓝色球号码区的16个号码中选择1个号码，组合成一注进行投注。

创建程序，自动产生6个红球号码和一个篮球号码的功能，需求为：创建一个长度为6 数组，数组内放置6个1~33之间（包含1，也包含33）的随机数作为数组元素的内容，即6个红球号码，然后创建一个变量，放置1个1~16之间（包含1，也包含16）的随机数作为变量值，即一个蓝球号码。最后将红球号码与蓝球号码打印在控制台上，效果界面如图-3所示：

图-3

3.2 方案

首先，此案例中，需要产生6个1~33之间的随机整数，这6个随机数就是要生成的红球号码，值得注意的是双色球要求6个红球号码不能重复，而在生成6个随机数的过程中有可能出现重复的现象，需要在生成红球号码的过程中加以避免。

然后，需要产生1个1~16之间的随机数，这个数就是要生成的蓝球号码。

最后，将生成的红球号码与蓝球号码一并输出。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量和数组

定义变量blue，用于存储蓝球号码。

定义数组red，用于存储6个红球号码。

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. int blue = 0;
  6. int red[6] = {0};
  8. return 0;
  9. }

步骤二：产生随机数，生成蓝球号码

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int blue = 0;
  8. int red[6] = {0};
  10. srand((unsigned)time(0));
  11. blue = rand() % 16 + 1;
  13. return 0;
  14. }

步骤三：产生随机数，生成红球号码

使用for语句构建一个6次循环，在每次循环中，随机产生一个1~33之间的整数，作为红球号码使用。但是，如果这个随机数与以前生成的随机数相同，则这次的随机数不能被采用，因为双色球要求6个红球号码不能重复。所以，需要在循环体内再嵌套一个循环，在这个内部循环的循环体内检测生成的随机数是否发生了重复，如果重复，则需要重新生成一个随机数。

代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int blue = 0;
  8. int red[6] = {0};
  10. srand((unsigned)time(0));
  11. blue = rand() % 16 + 1;
  13. for (int i=0; i<6; i++) {
  14. red[i] = rand() % 33 + 1;
  16. //判断是否发生重复
  17. for (int j=0; j<i; j++)
  18. if (red[j]==red[i])
  19. {
  20. i–;
  21. break;
  22. }
  23. }
  25. return 0;
  26. }

上述代码的内层循环的循环次数是不固定的，因为只需要检测新生成的红球号码与以前生成的是否发生重复即可。例如，随机生成第一个红球号码时，i为0，此时，for(int j = 0; j < i; j++)这个循环就一次也不执行，因为以前就没有红球号码生成；当随机生成第二个红球号码时，i为1，此时，for(int j = 0; j < i; j++)这个循环就执行一次，因为以前生成的红球号码就一个，所以之对比一次就可以了。

步骤四：输出结果

代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int blue = 0;
  8. int red[6] = {0};
  10. srand((unsigned)time(0));
  11. blue = rand() % 16 + 1;
  13. for (int i=0; i<6; i++) {
  14. red[i] = rand() % 33 + 1;
  16. //判断是否发生重复
  17. for (int j=0; j<i; j++)
  18. if (red[j]==red[i])
  19. {
  20. i–;
  21. break;
  22. }
  23. }
  25. printf(“蓝: %d\n“, blue);
  26. printf(“红: “);
  27. for (int i=0; i<6; i++) {
  28. printf(“%d “, red[i]);
  29. }
  30. printf(“\n“);
  32. return 0;
  33. }

3.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int blue = 0;
  8. int red[6] = {0};
  10. srand((unsigned)time(0));
  11. blue = rand() % 16 + 1;
  13. for (int i=0; i<6; i++) {
  14. red[i] = rand() % 33 + 1;
  16. //判断是否发生重复
  17. for (int j=0; j<i; j++)
  18. if (red[j]==red[i])
  19. {
  20. i–;
  21. break;
  22. }
  23. }
  25. printf(“蓝: %d\n“, blue);
  26. printf(“红: “);
  27. for (int i=0; i<6; i++) {
  28. printf(“%d “, red[i]);
  29. }
  30. printf(“\n“);
  32. return 0;
  33. }

4 打印一个班级中学生的成绩和总成绩

4.1 问题

现有某班级中的学生成绩，如表-1所示：

创建程序，首先随机生成每个学生每门课程的成绩，然后计算每个学生的总分，最后计算每科的总分，需求为：创建一个10行(10个学生)4列(4门课程)的二维数组，数组内放置10*4个0~100之间的随机整数作为成绩，要求计算每个学生的4门课成绩的总和，然后计算每科10个学生的成绩总计，打印显示在控制台上，程序交互过程如图-4所示：

图-4

4.2 方案

首先，此案例中，需要定义一个10行4列的二维数组。

然后，使用双重嵌套for循环，为这个二维数组的每个数组元素赋值上一个0~100之间的随机数作为某个学生的某科成绩。

下一步，打印每个学生的各科成绩，同时计算每个学生各科成绩的总分并打印出来。

最后，打印每门课程的总成绩。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义数组

二维数组scores，用于保存10个学生的4门课程的成绩

数组sum，用于保存4门课，每门的总成绩

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. int scores[10][4] = {0};
  6. int sum[4] = {0};
  8. return 0;
  9. }

步骤二：随机生成每个学生每门课程的成绩

使用双重嵌套循环来实现，外层循环循环10次，每循环一次，针对一个学生；内层循环循环4次，每循环一次，针对一个学生的一门课程。这样使用外层循环的循环变量i作为二维数组的第一维下标，使用内层循环的循环变量j作为二维数组的第二维下标，来确定一个二维数组的数组元素。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int scores[10][4] = {0};
  8. int sum[4] = {0};
  10. srand((unsigned)time(0));
  11. for (int i=0; i<10; i++)
  12. {
  13. for (int j=0; j<4; j++)
  14. {
  15. scores[i][j] = rand() % 101;
  16. }
  17. }
  19. return 0;
  20. }

步骤三：打印每个学生的成绩，要求将每个学生的总成绩也打印出来

使用双重嵌套循环来实现，外层循环同样每循环一次打印一个学生的所有成绩，为了能将每个学生的所有成绩打印出来，所以需要一个内层循环，这个循环每循环一次，打印一个学生的一门课程成绩。

打印完成后，首先将每门课程成绩累加到一个变量total中，该变量保存的是每个学生的各门课的总成绩；然后再将每门课程成绩累加到数组元素sum[j]中，其中sum[0]代表C语言，sum[1]代表OC语言，sum[2]代表Foundation，sum[3]代表UIKit。

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int scores[10][4] = {0};
  8. int sum[4] = {0};
  10. srand((unsigned)time(0));
  11. for (int i=0; i<10; i++)
  12. {
  13. for (int j=0; j<4; j++)
  14. {
  15. scores[i][j] = rand() % 101;
  16. }
  17. }
  19. printf(“No.\tC\tOC\tFou\tUI\tTo\n“);
  20. for (int i=0; i<10; i++)
  21. {
  22. printf(“%d\t“, i);
  23. int total = 0;
  24. for (int j=0; j<4; j++)
  25. {
  26. printf(“%d\t“, scores[i][j]);
  27. total += scores[i][j];
  28. sum[j] += scores[i][j];
  29. }
  31. printf(“%d\n“, total);
  32. }
  34. return 0;
  35. }

注意：变量total是定义在外层循环的循环体内，一旦循环体执行完毕进行下一次循环时，该变量都要重新分配存储空间。

步骤四：打印每门课程的总成绩

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int scores[10][4] = {0};
  8. int sum[4] = {0};
  10. srand((unsigned)time(0));
  11. for (int i=0; i<10; i++) {
  12. for (int j=0; j<4; j++) {
  13. scores[i][j] = rand() % 101;
  14. }
  15. }
  17. printf(“No.\tC\tOC\tFou\tUI\tTo\n“);
  18. for (int i=0; i<10; i++) {
  19. printf(“%d\t“, i);
  20. int total = 0;
  21. for (int j=0; j<4; j++) {
  22. printf(“%d\t“, scores[i][j]);
  23. total += scores[i][j];
  24. sum[j] += scores[i][j];
  25. }
  27. printf(“%d\n“, total);
  28. }
  30. printf(“总计:\t“);
  31. for (int i=0; i<4; i++) {
  32. printf(“%d\t“, sum[i]);
  33. }
  34. printf(“\n“);
  36. return 0;
  37. }

4.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int scores[10][4] = {0};
  8. int sum[4] = {0};
  10. srand((unsigned)time(0));
  11. for (int i=0; i<10; i++) {
  12. for (int j=0; j<4; j++) {
  13. scores[i][j] = rand() % 101;
  14. }
  15. }
  17. printf(“No.\tC\tOC\tFou\tUI\tTo\n“);
  18. for (int i=0; i<10; i++) {
  19. printf(“%d\t“, i);
  20. int total = 0;
  21. for (int j=0; j<4; j++) {
  22. printf(“%d\t“, scores[i][j]);
  23. total += scores[i][j];
  24. sum[j] += scores[i][j];
  25. }
  27. printf(“%d\n“, total);
  28. }
  30. printf(“总计:\t“);
  31. for (int i=0; i<4; i++) {
  32. printf(“%d\t“, sum[i]);
  33. }
  34. printf(“\n“);
  36. return 0;
  37. }

5 生成扫雷程序的雷区

5.1 问题

扫雷是一款相当大众的小游戏，游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子，同时避免踩雷。扫雷最初的流行伴随着1992年发布的windows 3.1，之后迅速成为了各种操作系统中必不可少的一款游戏（包括windows的winmine， KDE桌面环境下的KMines，GNOME桌面环境下的gnomine等），也出现于一些智能手机平台（比如Android系统的Minesweeper Classic，苹果ios系统的Minesweeper Q）。同时，Minesweeper Clone等功能更为丰富的“专业”扫雷软件也应时而生。

本案例是扫雷程序的一部分，生成雷区，雷区如图-5所示：

图-5

雷区的每个格子中：

1) 如果是-1代表这个格子中有地雷。

2) 如果是0代表这个格子周围的上、下、左、右、左上、右上、左下、右下的8个格子中都不是-1（即地雷）。

3) 如果是1代表这个格子周围的8个格子中，有一个格子是-1（即地雷），其它格子都不是-1。

4) 如果是2代表这个格子周围的8个格子中，有两个格子是-1（即地雷），其它格子都不是-1。

5) 如果是3代表这个格子周围的8个格子中，有三个格子是-1（即地雷），其它格子都不是-1。

6) 依次类推。

雷区中地雷所在的格子是随机的，其它格子中的数字是程序通过计算获得的。本案例就是要生成这样一个雷区。

5.2 方案

生成扫雷程序的雷区游戏可以看出，此程序需要一个二维数组来模拟雷区，数组元素的值是-1~8，其中-1代表地雷，其它0~8九个数字代表某个数组元素周围的8个元素中的地雷数。

程序首先将二维数组的数组元素赋值成-1或0，即确定地雷在雷区中的位置，-1的值赋给哪个数组元素是随机的。然后，计算那些值为0的数组元素周围的八个数组元素中地雷的个数，填入数组中。最后打印输出雷区。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义二维数组

变量area，用于模拟雷区。

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5. int n;
  6. printf(“请输入雷区大小:”);
  7. scanf(“%d”, &n);
  8. int area[n][n];
  10. return 0;
  11. }

上述代码中，变量n用于动态定义数组的长度。可以通过控制台输入一个整数值，来动态的确定雷区的大小，如果输入5，则雷区为5*5的区域，如果输入7，则雷区为7*7的区域。

步骤二：生成雷,约定-1代表雷

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int n;
  8. printf(“请输入雷区大小:”);
  9. scanf(“%d”, &n);
  10. int area[n][n];
  12. srand((unsigned)time(0));
  13. for (int i=0; i<n; i++) {
  14. for (int j=0; j<n; j++) {
  15. if (rand()%5==0)
  16. area[i][j] = –1;
  17. else
  18. area[i][j] = 0;
  19. }
  20. }
  22. return 0;
  23. }

上述代码中：使用一个双重循环来为二维数组赋值，外层循环变量i控制二维数组的第一维下标，内层循环变量j控制二维数组的第二维下标。内层循环的循环体是一个if-else结构，if的条件表达式rand()%5==0，首先由rand()%5生成一个0~4的随机数，生成的随机数等于0的概率为20%，修改除数5为别的数字可以改变生成地雷的概率。表达式rand()%5==0为真时，数组元素area[i][j]的值为-1，即生成一个地雷。

步骤三：无雷区生成周围的雷的个数

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int n;
  8. printf(“请输入雷区大小:”);
  9. scanf(“%d”, &n);
  10. int area[n][n];
  12. srand((unsigned)time(0));//srand()需要stdlib.h,time()需要time.h
  13. for (int i=0; i<n; i++) {
  14. for (int j=0; j<n; j++) {
  15. if (rand()%5==0)
  16. area[i][j] = –1;
  17. else
  18. area[i][j] = 0;
  19. }
  20. }
  22. for (int i=0; i<n; i++) {
  23. for (int j=0; j<n; j++) {
  24. if (area[i][j]==-1) {
  25. continue;
  26. }
  27. int sum = 0;//周围雷的个数
  28. //8个方向只要一个方向有雷，sum++;
  29. if (i > 0 && j > 0 && area[i-1][j-1]==-1) sum++;
  30. if (i > 0 && area[i-1][j]==-1) sum++;
  31. if (i > 0 && j < n – 1 && area[i-1][j+1]==-1) sum++;
  32. if (j < n – 1 && area[i][j+1]==-1) sum++;
  33. if (i < n – 1 && j < n – 1 && area[i+1][j+1]==-1) sum++;
  34. if (i < n – 1 && area[i+1][j]==-1) sum++;
  35. if (i < n – 1 && j > 0 && area[i+1][j-1]==-1) sum++;
  36. if (j > 0 && area[i][j-1]==-1) sum++;
  37. area[i][j] = sum;
  38. }
  39. }
  41. return 0;
  42. }

上述代码中，使用一个双重循环来遍历二维数组area

首先，下面的代码使得当数组元素为-1（即为地雷）时，则使用continue语句继续循环，遍历下一个数组元素

  1. if (area[i][j]==-1) {
  2. continue;
  3. }

然后，定义变量sum用于保存数组元素area[i][j]周围的八个数组元素中，数组元素值为-1（即地雷）的个数。

下一步，将数组元素area[i][j]周围的八个数组元素逐一判断是否为-1（即地雷）：

下面的代码是判断数组元素area[i][j]左上的数组元素area[i-1][j-1]是否为-1（即地雷），而条件i>0 && j>0是防止数组越界，如area[0][0]就没有左上元素a[-1][-1]。

  1. if (i > 0 && j > 0 && area[i-1][j-1]==-1) sum++;

下面的代码是判断数组元素area[i][j]上面的数组元素area[i-1][j]是否为-1（即地雷），而条件i>0是防止数组越界，如area[0][0]就没有上面元素a[-1][0]。

  1. if (i > 0 && area[i-1][j]==-1) sum++;

下面的代码是判断数组元素area[i][j]右上的数组元素area[i-1][j+1]是否为-1（即地雷），而条件i>0 && j<n-1是防止数组越界，如n=5时，area[0][4]就没有右上元素a[-1][5]。

  1. if (i > 0 && j < n – 1 && area[i-1][j+1]==-1) sum++;

下面的代码是判断数组元素area[i][j]右面的数组元素area[i][j+1]是否为-1（即地雷），而条件j<n -1是防止数组越界，如n=5时，area[0][4]就没有右面元素a[0][5]。

  1. if (j < n – 1 && area[i][j+1]==-1) sum++;

下面的代码是判断数组元素area[i][j]右下的数组元素area[i+1][j+1]是否为-1（即地雷），而条件i<n-1&&j<n-1是防止数组越界，如n=5时，area[4][4]就没有右下元素a[5][5]。

  1. if (i < n – 1 && j < n – 1 && area[i+1][j+1]==-1) sum++;

下面的代码是判断数组元素area[i][j]下面的数组元素area[i+1][j-1]是否为-1（即地雷），而条件i<n-1是防止数组越界，如n=5时，area[4][0]就没有下面元素a[5][0]。

  1. if (i < n – 1 && area[i+1][j]==-1) sum++;

下面的代码是判断数组元素area[i][j]左下的数组元素area[i+1][j-1]是否为-1（即地雷），而条件i<n-1&&j>0是防止数组越界，如n=5时，area[4][0]就没有左下元素a[5][-1]。

  1. if (i < n – 1 && j > 0 && area[i+1][j-1]==-1) sum++;

下面的代码是判断数组元素area[i][j]左面的数组元素area[i][j-1]是否为-1（即地雷），而条件j>0是防止数组越界，如area[4][0]就没有左上元素a[4][-1]。

  1. if (j > 0 && area[i][j-1]==-1) sum++;

最后，将统计出的地雷个数赋值给数组元素area[i][j]。

步骤四：打印输出

使用双重循环打印输出二维数组。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int n;
  8. printf(“请输入雷区大小:”);
  9. scanf(“%d”, &n);
  10. int area[n][n];
  12. srand((unsigned)time(0));
  13. for (int i=0; i<n; i++) {
  14. for (int j=0; j<n; j++) {
  15. if (rand()%5==0)
  16. area[i][j] = –1;
  17. else
  18. area[i][j] = 0;
  19. }
  20. }
  22. for (int i=0; i<n; i++) {
  23. for (int j=0; j<n; j++) {
  24. if (area[i][j]==-1) {
  25. continue;
  26. }
  27. int sum = 0;//周围雷的个数
  28. //8个方向只要一个方向有雷，sum++;
  29. if (i > 0 && j > 0 && area[i-1][j-1]==-1) sum++;
  30. if (i > 0 && area[i-1][j]==-1) sum++;
  31. if (i > 0 && j < n – 1 && area[i-1][j+1]==-1) sum++;
  32. if (j < n – 1 && area[i][j+1]==-1) sum++;
  33. if (i < n – 1 && j < n – 1 && area[i+1][j+1]==-1) sum++;
  34. if (i < n – 1 && area[i+1][j]==-1) sum++;
  35. if (i < n – 1 && j > 0 && area[i+1][j-1]==-1) sum++;
  36. if (j > 0 && area[i][j-1]==-1) sum++;
  37. area[i][j] = sum;
  38. }
  39. }
  41. for (int i=0; i<n; i++) {
  42. for (int j=0; j<n; j++) {
  43. printf(“%d\t“, area[i][j]);
  44. }
  45. printf(“\n“);
  46. }
  48. return 0;
  49. }

5.4 完整代码

本案例的完整代码如下所示：

 
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7. int n;
  8. printf(“请输入雷区大小:”);
  9. scanf(“%d”, &n);
  10. int area[n][n];
  12. srand((unsigned)time(0));
  13. for (int i=0; i<n; i++) {
  14. for (int j=0; j<n; j++) {
  15. if (rand()%5==0)
  16. area[i][j] = –1;
  17. else
  18. area[i][j] = 0;
  19. }
  20. }
  22. for (int i=0; i<n; i++) {
  23. for (int j=0; j<n; j++) {
  24. if (area[i][j]==-1) {
  25. continue;
  26. }
  27. int sum = 0;//周围雷的个数
  28. //8个方向只要一个方向有雷，sum++;
  29. if (i > 0 && j > 0 && area[i-1][j-1]==-1) sum++;
  30. if (i > 0 && area[i-1][j]==-1) sum++;
  31. if (i > 0 && j < n – 1 && area[i-1][j+1]==-1) sum++;
  32. if (j < n – 1 && area[i][j+1]==-1) sum++;
  33. if (i < n – 1 && j < n – 1 && area[i+1][j+1]==-1) sum++;
  34. if (i < n – 1 && area[i+1][j]==-1) sum++;
  35. if (i < n – 1 && j > 0 && area[i+1][j-1]==-1) sum++;
  36. if (j > 0 && area[i][j-1]==-1) sum++;
  37. area[i][j] = sum;
  38. }
  39. }
  41. for (int i=0; i<n; i++) {
  42. for (int j=0; j<n; j++) {
  43. printf(“%d\t“, area[i][j]);
  44. }
  45. printf(“\n“);
  46. }
  48. return 0;
  49. }

1 求两个数的和

1.1 问题

创建程序，实现两个数的求和程序，需求为：定义一个函数，实现两个数的求和程序，在主函数中调用该函数。

1.2 方案

首先，定义一个函数，功能是两个数的求和。

然后，在主程序中调用函数，对两个数求和，并显示结果。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义函数

定义一个函数，实现两个数的求和程序。

代码如下：

 
  1. #include <stdio.h>
  3. int add(int x, int y)
  4. {
  5. return x + y;
  6. }
  8. int main(int argc, const char * argv[])
  9. {
  11. return 0;
  12. }

上述代码中，代码行

  1. int add(int x, int y)

是定义函数的函数头，第一个int为函数的返回值类型，add是函数名，后面括号及括号内的内容为函数的形式参数，共有两个形参，一个整型变量x，一个整型变量y。

上述代码中，代码行

  1. {
  2. return x + y;
  3. }

两个大括号之间是函数体，本例中函数体只有一条语句，该语句是返回表达式x + y的值。

步骤二：调用函数

在main方法中调用add函数，并将函数的返回值输出。

代码如下：

  1. #include <stdio.h>
  3. int add(int x, int y)
  4. {
  5. return x + y;
  6. }
  8. int main(int argc, const char * argv[])
  9. {
  10. int sum;
  11. sum = add(3, 5);
  12. printf(“sum = %d\n“, sum);
  14. return 0;
  15. }

上述代码中，下面代码行：

  1. sum = add(3, 5);

是调用函数add，3与5是函数的实际参数，函数的返回值赋值给变量sum。

1.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  3. int add(int x, int y)
  4. {
  5. return x + y;
  6. }
  8. int main(int argc, const char * argv[])
  9. {
  10. int sum;
  11. sum = add(3, 5);
  12. printf(“sum = %d\n“, sum);
  14. return 0;
  15. }

2 输出一组数的和、最大值、最小值

2.1 问题

创建程序，实现以下的功能：分别编制自定义函数求最大值、最小值、所有元素的和。

需求为：在主函数中创建一个长度为10的数组，数组内放置10个0~99之间（包含0，包含99）的随机数作为数组内容，按要求分别编制自定义函数求数组中的最大值、最小值并计算出所有数组元素的和，然后在主函数中将各自定义函数的返回值打印显示在界面上。控制台效果如图-1所示：

图-1

2.2 方案

首先，定义一个函数，功能是求数组中的最大值。

然后，定义一个函数，功能是求数组中的最小值。

下一步，定义一个函数，功能是求数组中的所有元素的和。

最后，在主函数中，定义一个长度为10的数组，并将10个数组元素分别赋值为10个随机数，然后分别调用以上编制的三个函数，求出最大值、最小值和所有元素的和值，并在主函数中显示结果。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义求最大值函数，并在主函数中调用

定义一个函数，在一个数组中求出所有元素中的最大值。

在主函数中，定义一个数组，并为每个数组元素赋值成一个随机数，然后调用求最大值函数。

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int maxValue(int data[], int size)
  6. {
  7. int max = data[0];
  9. for (int i = 1; i < size; i++)
  10. if (max < data[i])
  11. max = data[i];
  13. return max;
  14. }
  16. int main()
  17. {
  18. int data[10];
  20. srand((unsigned)time(0));
  21. for (int i = 0; i < 10; i++)
  22. data[i] = rand() % 100;
  23. printf(“数组中的数据为：”);
  24. for (int i = 0; i < 10; i++)
  25. printf(“%d “, data[i]);
  26. printf(“\n“);
  28. int max;
  29. max = maxValue(data, 10);
  30. printf(“数组中的最大值为：%d\n“, max);
  32. return 0;
  33. }

上述代码中，下面代码行：

  1. int maxValue(int data[], int size)

代码行中int data[]为数组作为函数的形参，此时，数组的长度是无效的，函数只能传递数组的第一个元素的地址这一个数据，所以无法再传递数组的长度这个数据。这样数组的长度只能再定义一个形参size，用它来传递数组的长度。

上述代码中，下面的代码行：

  1. for (int i = 1; i < size; i++)
  2. if (max < data[i])
  3. max = data[i];

遍历数组，找出所有元素中的最大值。

上述代码中，下面的代码行：

  1. srand((unsigned)time(0));
  2. for (int i = 0; i < 10; i++)
  3. data[i] = rand() % 100;

遍历数组，为每个数组元素赋值一个随机数。

上述代码中，下面的代码行：

  1. max = maxValue(data, 10);

调用maxValue函数，其中（data，10）为函数的实参，第一个实参是数组名，当数组作为函数的参数时，实参只需要传递数组名即可；第二个参数为数组的长度。

步骤二：定义求最小值函数，并在主函数中调用

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int maxValue(int data[], int size)
  6. {
  7. int max = data[0];
  9. for (int i = 1; i < size; i++)
  10. if (max < data[i])
  11. max = data[i];
  13. return max;
  14. }
  16. int minValue(int data[], int size)
  17. {
  18. int min = data[0];
  20. for (int i = 1; i < size; i++)
  21. if (min > data[i])
  22. min = data[i];
  24. return min;
  25. }
  27. int main()
  28. {
  29. int data[10];
  31. srand((unsigned)time(0));
  32. for (int i = 0; i < 10; i++)
  33. data[i] = rand() % 100;
  34. printf(“数组中的数据为：”);
  35. for (int i = 0; i < 10; i++)
  36. printf(“%d “, data[i]);
  37. printf(“\n“);
  39. int max;
  40. max = maxValue(data, 10);
  41. printf(“数组中的最大值为：%d\n“, max);
  43. int min;
  44. min = minValue(data, 10);
  45. printf(“数组中的最小值为：%d\n“, min);
  47. return 0;
  48. }

上述代码中，下面代码行：

  1. for (int i = 1; i < size; i++)
  2. if (min > data[i])
  3. min = data[i];

遍历数组，找出数组中最小值。

上述代码中，下面代码行：

  1. min = minValue(data, 10);

调用minValue函数，返回值为数组中的最小值。

步骤三：定义所有数组元素求和函数，并在主函数中调用

代码如下：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int maxValue(int data[], int size)
  6. {
  7. int max = data[0];
  9. for (int i = 1; i < size; i++)
  10. if (max < data[i])
  11. max = data[i];
  13. return max;
  14. }
  16. int minValue(int data[], int size)
  17. {
  18. int min = data[0];
  20. for (int i = 1; i < size; i++)
  21. if (min > data[i])
  22. min = data[i];
  24. return min;
  25. }
  27. int sumValue(int data[], int size)
  28. {
  29. int sum = 0;
  31. for (int i = 0; i < size; i++)
  32. sum += data[i];
  34. return sum;
  35. }
  37. int main()
  38. {
  39. int data[10];
  41. srand((unsigned)time(0));
  42. for (int i = 0; i < 10; i++)
  43. data[i] = rand() % 100;
  44. printf(“数组中的数据为：”);
  45. for (int i = 0; i < 10; i++)
  46. printf(“%d “, data[i]);
  47. printf(“\n“);
  49. int max;
  50. max = maxValue(data, 10);
  51. printf(“数组中的最大值为：%d\n“, max);
  53. int min;
  54. min = minValue(data, 10);
  55. printf(“数组中的最小值为：%d\n“, min);
  57. int sum;
  58. sum = sumValue(data, 10);
  59. printf(“数组中的元素的和值为：%d\n“, sum);
  61. return 0;
  62. }

上述代码中，下面代码行：

  1. for (int i = 0; i < size; i++)
  2. sum += data[i];

遍历数组，找出计算所有数组元素的和值。

上述代码中，下面代码行：

  1. sum = sumValue(data, 10);

调用sumValue函数，返回值为数组中的所有元素的和值。

2.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. int maxValue(int data[], int size)
  6. {
  7. int max = data[0];
  9. for (int i = 1; i < size; i++)
  10. if (max < data[i])
  11. max = data[i];
  13. return max;
  14. }
  16. int minValue(int data[], int size)
  17. {
  18. int min = data[0];
  20. for (int i = 1; i < size; i++)
  21. if (min > data[i])
  22. min = data[i];
  24. return min;
  25. }
  27. int sumValue(int data[], int size)
  28. {
  29. int sum = 0;
  31. for (int i = 0; i < size; i++)
  32. sum += data[i];
  34. return sum;
  35. }
  37. int main()
  38. {
  39. int data[10];
  41. srand((unsigned)time(0));
  42. for (int i = 0; i < 10; i++)
  43. data[i] = rand() % 100;
  44. printf(“数组中的数据为：”);
  45. for (int i = 0; i < 10; i++)
  46. printf(“%d “, data[i]);
  47. printf(“\n“);
  49. int max;
  50. max = maxValue(data, 10);
  51. printf(“数组中的最大值为：%d\n“, max);
  53. int min;
  54. min = minValue(data, 10);
  55. printf(“数组中的最小值为：%d\n“, min);
  57. int sum;
  58. sum = sumValue(data, 10);
  59. printf(“数组中的元素的和值为：%d\n“, sum);
  61. return 0;
  62. }

3 求5的阶乘

3.1 问题

本案例要求使用递归算法。

程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

一般来说，递归要有两个条件:

1) 一定有一个退出(已知)条件，当达到这个条件时，函数结束。

2) 每一次递归调用，都是向退出条件靠近。

3.2 方案

首先，5的阶乘是指5！=5*4*3*2*1的值 ，观察5的阶乘时，可以会发现4*3*2*1是4的阶乘，所以5的阶乘又可以写成5*4！。

由上面分析可知，如果定义一个函数fn(int num)求阶乘，那么fn(5)就可以转化成5*fn(4)。

另外，需要退出条件阶乘概念可知是num等于1。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义递归函数

代码如下：

  1. #include <stdio.h>
  3. int fn(int x)
  4. {
  5. if(x==1)
  6. return 1;
  7. return x * fn(x-1);
  8. }
  10. int main()
  11. {
  12. return 0;
  13. }

上述代码中，如下代码行

  1. if(x==1)
  2. return 1;

是递归的结束条件，如果求1的阶乘，由阶乘规则可知答案就是1，所以可以直接返回1。

上述代码中，如下代码行

  1. return x * fn(x-1);

是递归计算，如x为5时，递归计算可转化为5*fn(4)，即5*4！。

步骤二：在主程序中调用递归函数

代码如下：

  1. #include <stdio.h>
  3. int fn(int x)
  4. {
  5. if(x==1)
  6. return 1;
  7. return x * fn(x-1);
  8. }
  10. int main()
  11. {
  12. int rec;
  13. rec = fn(5);
  14. printf(“5的阶乘是：%d\n“, rec);
  16. return 0;
  17. }

上述代码中，如下代码行

  1. rec = fn(5);

是调用递归函数fn，其返回值为5的阶乘。

3.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  3. int fn(int x)
  4. {
  5. if(x==1)
  6. return 1;
  7. return x * fn(x-1);
  8. }
  10. int main()
  11. {
  12. int rec;
  13. rec = fn(5);
  14. printf(“5的阶乘是：%d\n“, rec);
  16. return 0;
  17. }

 

版权声明：本文为52190112cn原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/52190112cn/p/5049157.html