zoukankan      html  css  js  c++  java

  • ios开发环境 分支语句 、 循环结构（for） 、 循环结构

    1 完成命令解析程序

    1.1 问题

    有命令解析程序，该程序提供三个功能选项供用户选择，用户选择某功能后，程序在界面上输出用户所选择的功能名称。程序的交互效果如图-1所示：

    图-1

    由上图可以看出，程序提供的功能有：显示全部记录、查询登录记录和退出。如果用户在控制台输入1，则表示用户选择的功能为“显示全部记录”，此时，需要在界面上输出该功能的名称。

    如果用户在控制台输入2，则表示用户选择的功能为“查询登录记录”，此时，也需要在界面上输入该功能的名称，交互效果如图-2所示:

    图-2

    如果用户在控制台输入0，则表示用户选择的功能为“退出”。此时，在界面上输出“欢迎使用”，表示程序结束。交互效果如图-3所示:

    图-3

    如果用户输入除0、1、2以外的其它数字，则表示选择错误，此时，在界面上输出“输入错误“。程序交互情况如图-4所示:

    图-4

    1.2 步骤

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

    步骤一：定义变量

    变量command，用于保存用户从控制台输入的命令。

    代码如下：

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

    步骤二：从控制台输入命令

    首先，使用printf函数输出一行提示。

    然后，使用scanf函数输入一个整数到变量command。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int command = 0;
    7. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出 ");
    8. scanf("%d", &command);
    10. return 0;
    11. }

    步骤三：使用switch解析命令

    将switch结构配合break语句一起使用，判断用户的选择操作，并输出解析结果。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int command = 0;
    7. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出 ");
    8. scanf("%d", &command);
    10. switch (command) {
    11. case 1:
    12. printf("显示全部记录 ");
    13. break;
    14. case 2:
    15. printf("查询登录记录 ");
    16. break;
    17. case 0:
    18. printf("欢迎使用 ");
    19. break;
    20. default:
    21. printf("输入错误 ");
    22. break;
    23. }
    25. return 0;
    26. }

    1.3 完整代码

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

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int command = 0;
    7. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出 ");
    8. scanf("%d", &command);
    10. switch (command) {
    11. case 1:
    12. printf("显示全部记录 ");
    13. break;
    14. case 2:
    15. printf("查询登录记录 ");
    16. break;
    17. case 0:
    18. printf("欢迎使用 ");
    19. break;
    20. default:
    21. printf("输入错误 ");
    22. break;
    23. }
    25. return 0;
    26. }

    2 求圆周率

    2.1 问题

    圆周率，一般以π来表示，是一个在数学及物理学普遍存在的数学常数。它定义为圆形之周长与直径之比，也等于圆形面积与半径的平方之比，是精确计算圆周长、圆面积、球体积等几何形状的关键值。

    圆周率是一个无限不循环小数。在日常生活中，通常都用3.14来代表圆周率去进行近似计算。如果需要精确计算圆周率的值，则可以使用如下公式：

    π/4=1-1/3+1/5-1/7+1/9-1/11+……

    本案例要求使用上述公式计算圆周率π的值。为保证一定的精确度，要求计算至10亿次后的结果。程序运行效果如图-5：

    图-5

    2.2 方案

    计算π值的公式为：

    π=4*(1-1/3+1/5-1/7+1/9-1/11+1/13-1/15……)

    有上述公式可以看出，如果需要计算π的值，必须先计算表达式1-1/3+1/5-1/7+1/9-1/11+1/13-1/15……的值。分析此表达式，不难发现，此表达式中的每个计算因子的构成类似，可以总结出如下规律：flag * 1.0 / n。其中，flag表示每个计算因子前面的正号或负号。比如，1可以表示为1*1.0/1;-1/3可以表示为-1*1.0/3;1/5可以表示为1*1.0/5。

    对于表达式flag * 1.0 / n，flag和n是变化的数值，因此，可以分别声明变量来表示它，并为其赋初始值，代码如下：

    1. int flag = -1;
    2. int n = 1;

    每次计算时，flag和n的值都会发生变化，其变化规律如表-1：

    为保证一定的精确度，要求计算至10亿次后的结果，因此，需要使用for循环构建10亿次的计算，而每次循环中，需要修改flag值，然后累加表达式flag*1.0/n的结果，并将n的数值加上2，用于下一次计算。程序流程图如图-6：

    图-6

    2.3 步骤

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

    步骤一：定义变量

    定义变量pi，用于存储计算出的π值。

    定义变量flag，用于存储计算过程中的正号和负号。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. double pi = 0;
    6. int flag = -1;
    8. return 0;
    9. }

    步骤二：构建循环

    结合变量n，使用for循环构建10亿次计算。每次循环中，改变flag的值，并累加计算结果。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. double pi = 0;
    6. int flag = -1;
    8. for (int n = 1; n < 1000000000; n +=2)
    9. {
    10. flag *= -1;
    11. pi += flag * 1.0 / n;
    12. }
    14. return 0;
    15. }

    步骤三：输出结果

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. double pi = 0;
    6. int flag = -1;
    8. for (int n = 1; n < 1000000000; n +=2)
    9. {
    10. flag *= -1;
    11. pi += flag * 1.0 / n;
    12. }
    14. printf("pi = %.15lf ", pi * 4);
    16. return 0;
    17. }

    2.4 完整代码

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

    1. #include <stdio.h>
    3. int main()
    4. {
    5. double pi = 0;
    6. int flag = -1;
    8. for (int n = 1; n < 1000000000; n +=2)
    9. {
    10. flag *= -1;
    11. pi += flag * 1.0 / n;
    12. }
    14. printf("pi = %.15lf ", pi * 4);
    16. return 0;
    17. }

    3 猜数字游戏

    3.1 问题

    有猜数字游戏，其游戏规则为：程序内置一个1~100之间的数字作为猜测的结果，由用户猜测此数字。用户每猜测一次，由系统提示猜测结果：大了、小了或者猜对了；直到用户猜对结果，则提示游戏结束。

    本案例要求使用交互的方式实现此游戏，交互过程为：

    1) 游戏刚开始，提示用户在控制台输入所猜测的数字（为1~100之间的整数），交互过程如图-7所示：

    图-7

    2) 用户录入所猜测的数字后，程序进行判断：如果用户所猜测的数字大于结果，则提示太大了；如果用户所猜测的数字小于结果，则提示太小了。每次提示猜测结果后，提醒用户继续猜测。交互过程如图-8所示：

    图-8

    3) 直到用户猜测正确，则由系统提示“恭喜，你猜对了！”，游戏结束。交互过程如图-9：

    图-9

    3.2 方案

    首先，此案例中，需要产生一个1~100之间的随机整数，该数值就是用户要猜测的结果；然后，提示用户进行第一次猜测，并得到用户从界面所输入的数字。

    因为猜测的次数不确定，则使用do-while循环来构建猜测的过程：判断用户所猜测的数字是否与结果相同，只有猜测不正确，则继续循环。每次循环中，根据比较结果输出提示信息（“太大了”或者“太小了”），并提示用户进行下一次猜测。

    如果用户猜测正确，则循环结束，并提示用户“恭喜，你猜对了！”，程序结束。程序流程图如下图-10：

    图-10

    3.3 步骤

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

    步骤一：定义变量

    定义变量num，用于存储系统生成的随机数，即猜测对象。

    定义变量guess，用于存储用户输入的猜测值。

    代码如下：

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. return 0;
    11. }

    步骤二：产生随机数

    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），再加上数值1，则可以得到1~100之间的随机整数（包含1，也包含100）表示要猜测的数字。

    注意：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 num;
    8. int guess;
    10. srand((unsigned)time(0));//time函数的声明在time.h头函数中
    11. num = rand() % 100;//srand函数与rand函数的声明在stdlib.h中
    13. return 0;
    14. }

    步骤三：读取猜测结果

    提示用户输入猜测的数字，作为一次猜测。代码如下所示：

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. srand((unsigned)time(0));
    11. num = rand() % 100;
    13. printf("请输入你猜测的数字（1~100）：");
    14. scanf("%d", &guess);
    16. return 0;
    17. }

    步骤四：判断结果

    使用if-else结构判断用户猜测的数字和实际数字的大小，并根据比较结果输出提示信息（“太大了”或“太小了”）。代码如下所示：

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. srand((unsigned)time(0));
    11. num = rand() % 100;
    13. printf("请输入你猜测的数字（1~100）：");
    14. scanf("%d", &guess);
    16. if (guess > num)
    17. printf("太大了 ");
    18. else if (guess < num)
    19. printf("太小了 ");
    21. return 0;
    22. }

    步骤五：构建循环

    如果用户猜测的数字和实际数字不相等，则反复要求用户猜测，直到猜对为止。

    代码如下所示：

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. srand((unsigned)time(0));
    11. num = rand() % 100;
    13. do
    14. {
    15. printf("请输入你猜测的数字（1~100）：");
    16. scanf("%d", &guess);
    18. if (guess > num)
    19. printf("太大了 ");
    20. else if (guess < num)
    21. printf("太小了 ");
    22. }while(num != guess);
    24. return 0;
    25. }

    步骤六：游戏结束

    如果用户猜测的数字和实际数字相等，则代表用户猜测正确，终止循环，并提示用户正确信息“恭喜，你猜对了！”。

    代码如下所示：

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. srand((unsigned)time(0));
    11. num = rand() % 100;
    13. do
    14. {
    15. printf("请输入你猜测的数字（1~100）：");
    16. scanf("%d", &guess);
    18. if (guess > num)
    19. printf("太大了 ");
    20. else if (guess < num)
    21. printf("太小了 ");
    22. }while(num != guess);
    24. printf("恭喜，你猜对了！ ");
    26. return 0;
    27. }

    3.4 完整代码

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

    1. #include <stdio.h>
    2. #include <time.h>
    3. #include <stdlib.h>
    5. int main()
    6. {
    7. int num;
    8. int guess;
    10. srand((unsigned)time(0));
    11. num = rand() % 100;
    13. do
    14. {
    15. printf("请输入你猜测的数字（1~100）：");
    16. scanf("%d", &guess);
    18. if (guess > num)
    19. printf("太大了 ");
    20. else if (guess < num)
    21. printf("太小了 ");
    22. }while(num != guess);
    24. printf("恭喜，你猜对了！ ");
    26. return 0;
    27. }

    4 登录合法判断程序

    4.1 问题

    创建C语言程序，模拟网站的登录验证过程。需求为：从控制台输入密码，由程序判断密码是否正确，如果密码正确，则登录成功，程序交互过程如图-11：

    图-11

    如果密码不正确，则反复要求输入密码，程序交互过程如图-12：

    图-12

    4.2 方案

    本案例的实现方案如图-13所示：

    图-13

    4.3 步骤

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

    步骤一：定义变量

    变量password，用于保存用户从控制台输入的密码。

    代码如下：

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

    步骤二：从控制台输入密码

    首先，使用printf函数输出一行提示，提示输入一个密码。

    然后，使用scanf函数输入一个整数到变量password。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int password;
    7. printf("请输入密码:");
    8. scanf("%d", &password);
    10. return 0;
    11. }

    步骤三：构建循环

    构建循环，循环的终止条件是用户输入的密码不正确，循环体为步骤二的输入密码。代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int password;
    7. do {
    8. printf("请输入密码:");
    9. scanf("%d", &password);
    10. } while (password != 123456);
    12. return 0;
    13. }

    步骤四：输入的密码正确，显示登录成功

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int password;
    7. do {
    8. printf("请输入密码:");
    9. scanf("%d", &password);
    10. } while (password != 123456);
    12. printf("登录成功 ");
    14. return 0;
    15. }

    4.4 完整代码

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

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int password;
    7. do {
    8. printf("请输入密码:");
    9. scanf("%d", &password);
    10. } while (password != 123456);
    12. printf("登录成功 ");
    14. return 0;
    15. }

    5 输入整数，输出所有整数的和

    5.1 问题

    编写一个求和程序。用户从控制台输入的整数的个数不受限制，直到输入整数0为止。将输入的整数逐个相加后，把结果输出。控制台交互情况如图-14：

    图-14

    5.2 方案

    本案例的实现方案如图-15所示：

    图-15

    5.3 步骤

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

    步骤一：定义变量

    变量num，用于保存用户从控制台输入的整数。

    变量sum，用于保存输入的整数的累加和。

    代码如下：

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

    步骤二：从控制台输入整数

    首先，使用scanf函数输入一个整数到变量num。

    然后，将输入的整数累加到变量sum中。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int num;
    6. int sum = 0;
    8. scanf("%d", &num);
    9. sum += num;
    11. return 0;
    12. }

    步骤三：构建循环

    构建循环，循环的终止条件是用户输入的整数为0，循环体为步骤二的输入整数和将输入的整数求累加和。代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int num;
    6. int sum = 0;
    8. do
    9. {
    10. scanf("%d", &num);
    11. sum += num;
    12. }while(num != 0);
    14. return 0;
    15. }

    步骤四：输出累加和

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int num;
    6. int sum = 0;
    8. do
    9. {
    10. scanf("%d", &num);
    11. sum += num;
    12. }while(num != 0);
    14. printf("sum = %d ", sum);
    16. return 0;
    17. }

    5.4 完整代码

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

    1. #include <stdio.h>
    3. int main()
    4. {
    5. int num;
    6. int sum = 0;
    8. do
    9. {
    10. scanf("%d", &num);
    11. sum += num;
    12. }while(num != 0);
    14. printf("sum = %d ", sum);
    16. return 0;
    17. }

    6 打印10以内的整数，跳过5

    6.1 问题

    在控制台上打印0、1、2、3、4、6、7、8、9，注意5不打印，效果如图-16所示：

    图-16

    6.2 方案

    本案例的实现方案如图-17所示：

    图-17

    6.3 步骤

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

    步骤一：构建循环

    构建循环，循环10次，循环体为输出循环变量i。代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. for (int i = 0; i < 10; i++)
    6. {
    7. printf("%d ", i);
    8. }
    10. printf(" ");
    12. return 0;
    13. }

    步骤二：循环变量i为5时，循环体不打印循环变量

    在循环体中插入代码，代码的功能是判断循环变量是否为5，如果是将继续循环，不再打印循环变量。

    代码如下：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. for (int i = 0; i < 10; i++)
    6. {
    7. if (5 == i)
    8. continue;
    9. printf("%d ", i);
    10. }
    12. printf(" ");
    14. return 0;
    15. }

    6.4 完整代码

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

    1. #include <stdio.h>
    3. int main()
    4. {
    5. for (int i = 0; i < 10; i++)
    6. {
    7. if (5 == i)
    8. continue;
    9. printf("%d ", i);
    10. }
    12. printf(" ");
    14. return 0;
    15. }

    7 用for循环嵌套打印各种图形(矩形，三角)

    7.1 问题

    在控制台上打印矩形图形，效果如图-18所示：

    图-18

    在控制台上打印三角形，效果如图-19所示：

    图-19

    7.2 方案

    此方案需要使用嵌套循环来实现。

    由图-20可知，矩形一共需要输出5行10列星：

    图-20

    5行需要一个循环5次的循环，代码如下所示：

    1. //变量i用于控制行数
    2. for (int i=0; i<5; i++) {
    3. }

    在输出每行中的内容时，还需要一个循环10次的循环，在一行中输出10列，即10个星，代码如下所示：

    1. //变量i用于控制行数
    2. for (int i=0; i<5; i++) {
    3. //变量j用于控制列数
    4. for (int j=0; j<10; j++) {
    5.          }
    6. }

    由下图可知，三角形一共需要输出5行，第1行先输出4个空格，再输出一颗星，第2行先输出3个空格，再输出3颗星，第3行先输出2个空格，再输出5颗星，第4行先输出1个空格，再输出7颗星，第5行不输出空格，直接输出9颗星，详见图-21：

    图-21

    打印5行星，需要一个循环5次的循环来完成，代码如下：

    1. //变量i用于控制行数
    2. for (int i=0; i<5; i++) {
    3. }

    在输出每行中的内容时，首先需要打印空格，行数每增加1行，空格就少打一个，所以打印空格也需要一个循环来完成。然后打印星，行数每增加1行，星就多打两个，所以打印星还需要一个循环来完成。这样，在输出每行时，实际上需要两个循环分别打印空格和星。代码如下所示：

    1. //变量i用于控制行数
    2. for (int i = 0; i < 5; i++)
    3. {
    4. //变量j用于控制每行中需要打印的空格个数，i等于0时，第1行打印4个空格，i等于1时，第2行打印3个空格，……
    5. for (int j = 4; j > i; j--)
    6.          {
    7. }
    8. //变量j还用于控制每行中需要打印的星个数，i等于0时，第1行打印1个星，i等于1时，第2行打印3个星，i等于2时，第3行打印5个星，……
    9. for (int j = 0; j < i * 2 + 1; j++)
    10. {
    11. }
    12. printf(" ");
    13. }

    7.3 步骤

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

    步骤一：打印矩形

    在main方法中，构建两层嵌套的for循环：外层循环用于控制行，内层循环用于控制某行上的星。需要注意的是，每行输出完毕后，需要换行。代码如下所示：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. //变量i用于控制行数
    6. for (int i=0; i<5; i++) {
    7. //变量j用于控制列数
    8. for (int j=0; j<10; j++) {
    9. printf("*");
    10. }
    11. //每行输出完毕后，需要换行
    12. printf(" ");
    13. }
    15. printf("--------------------------- ");
    17. return 0;
    18. }

    步骤二：打印三角形

    在main方法中，构建两层嵌套的for循环：外层循环用于控制行，内层循环有两个，一个用于控制某行上输出的空格，一个用于控制某行上输出的星。需要注意的是，每行输出完毕后，需要换行。代码如下所示：

    1. #include <stdio.h>
    3. int main()
    4. {
    5. printf("--------------------------- ");
    7. //变量i用于控制行数
    8. for (int i = 0; i < 5; i++)
    9. {
    10. //变量j用于控制每行中需要打印的空格个数
    11. for (int j = 4; j > i; j--)
    12. printf(" ");
    13. //变量j还用于控制每行中需要打印的星个数
    14. for (int j = 0; j < i * 2 + 1; j++)
    15. printf("*");
    16. printf(" ");
    17. }
    19. return 0;
    20. }

    7.4 完整代码

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

     
    1. #include <stdio.h>
    3. int main()
    4. {
    5. //变量i用于控制行数
    6. for (int i=0; i<5; i++) {
    7. //变量j用于控制列数
    8. for (int j=0; j<10; j++) {
    9. printf("*");
    10. }
    11. printf(" ");
    12. }
    14. printf("--------------------------- ");
    16. //变量i用于控制行数
    17. for (int i = 0; i < 5; i++)
    18. {
    19. //变量j用于控制每行中需要打印的空格个数
    20. for (int j = 4; j > i; j--)
    21. printf(" ");
    22. //变量j还用于控制每行中需要打印的星个数
    23. for (int j = 0; j < i * 2 + 1; j++)
    24. printf("*");
    25. printf(" ");
    26. }
    28. return 0;
    29. }
  • 相关阅读:
    做足以让自己骄傲的活
    Count(*) 与 count(field) 一样吗？
    Explain Plan试分析
    Oracle SQL Developer中查看解释计划Explain Plan的两种方法
    整理+学习《骆昊-Java面试题全集（上）》
    【转】Java就业指导
    如何清晰的、高质量的给面试官介绍自己的电商项目【借鉴】
    留存的图片
    Linux学习_006_JavaEE程序员常用linux命令整理
    给Linux初学者的七个建议，值得一读
  • 原文地址：https://www.cnblogs.com/52190112cn/p/5049148.html
Copyright © 2011-2022 走看看