程序代码记录(习题)

猜数游戏

  • 让计算机来存储一个数,然后让用户来猜,每当用户输入一个数,计算机就输出该数大于或小于用户输入的数,直到用户猜中为止,最后还要输出用户一共猜了多少次

    思路:

    1. 随机数

      添加一个整型变量,它的值为随机数

      x % n 的结果是[0,n-1]的整数

    2. 用户输入数

      用户输入的值需要写在循环体内

    3. 计数器

      计数器需要写在判断前,无论是否做出判断,只要用户做出了”猜”的动作,就让计数器++

    4. 判断

      循环体中需要写一段判断条件:

      用户输入的数大于指定数值时,输出”大于该数”

      而当用户输入的数小于指定数值时,输出”小于该数”

    5. 结束条件

      只有当条件成立时,才会结束循环

      不要按照人的思维来理解循环条件 (?)

      并输出变量值

    思路实现:

    如果需要用到随机数需要引用两个库stdlib.h和time.h

    1
    2
    srand(time(0));
    int random = rand() %100 +1;

    只需要取100以内的数,随机数 % 100 为 0-99,+1的操作让其为100以内

    用户的猜数操作需要写在循环体中

    1
    2
    int input;
    scanf("%d", &input);

    定义一个计数器,让它用户输入数值后++,以满足每次”猜数”的操作能记录

    1
    2
    int time = 0;
    time++;

    用户输入的数大于指定数值时,输出”大于该数”

    而当用户输入的数小于指定数值时,输出”小于该数”

    1
    2
    3
    4
    5
      if ( input > random ){
          printf("您输入的数大于随机数");
      } else if ( input < random ){
          printf("您输入的数小于随机数");
    }

    结束的条件是当用户输入数等于随机数才跳出循环,在代码中的实现却得写成这样

    1
    while ( input != random );

    当输入值不等于随机数时继续循环,只有输入值等于随机数才会结束循环

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    /*
     * 定义一个随机数
     * 定义一个计数器
     * 定义一个用户输入值
     * 无论是否做出判断都会执行一次输入值的动作，所以使用do while
     * 将用户输入值的操作写在循环体中，而后让计数器++
     * 判断输入值是否大于或等于随机数
     * 不满足条件时结束循环*/

    #include <stdio.h>
    #include "stdlib.h"
    #include "time.h"

    int main() {
        srand(time(0));
        int random  = rand() %100 + 1;
        int input;
        int time = 0;
        do {
            scanf("%d", &input);
            time++;
            if ( input > random ){
                printf("您输入的数大于随机数");
            } else if ( input < random ){
                printf("您输入的数小于随机数");
            }
        }while ( input != random );
        printf("您猜中了！您一共猜了%d次", time);
    }

算平均数

  • 让用户输入一系列正整数,当用户输入-1时结束输入,然后程序计算出这些数字的平均数,输出用户输入数字的个数与平均数

    思路:

    1. 用户输入数

      除了需要用户输入外,还需要定义一个存储这些数的变量

    2. 计数器

      每当用户输入数字之后就进行++的操作

      但当用户输入结束指令时也会被记录,所以要在循环体外让计数器-1

    3. 结束

      不满足条件时结束循环

    思路实现:

    1. 循环条件

      满足循环的条件是当用户输入的值不为-1

      1
      while ( input != -1)

    2. 用户输入数

      用户输入的值需要写在循环体内

      1
      2
      int input;
      scanf("%d", &input);

    3. 计数器

      计数器需要写在用户输入后面,每当用户输入后都进行++的操作

      但是在结束循环体后要让计数器-1

      1
      2
      3
      int time = 0;
      time ++;
      time -= 1;

    4. 存储数值

      计算平均数需要让用户输入的所有数相加并除以输入次数,所以存储变量需要每次都在原有基础上加上用户新输入的数

      1
      2
      int sum = 0;
      sum += input;

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    /*
     * 定义input time sum 变量
     * 分别对应用户输入值，计数器，和用户输入值总和
     * 当用户输入的值不为-1时进入循环
     * sum的值为input+sum
     * 每次用户输完数后计数器都会++，即使是-1
     * 所以要在结束循环后让计数器-1，让其变成正常的
     * 最后输出计数器和平均值*/
    #include <stdio.h>

    int main() {
        int input , time , sum;
        time = 0;
        input = 0;
        sum = 0;
        while ( input != -1){
            sum += input;
            scanf("%d", &input);
            time++;
        }
        time -= 1;
    //    另一种实现方式
    //    scanf("%d", &input);
    //    while ( input != -1){
    //        time++;
    //        sum += input;
    //        scanf("%d", &input);
    //  }
        printf("您一共输入了%d次，最后的平均数是：%d", time , sum / time);
        return 0;
    }

整数逆序

  • 当用户输入任意数字后,计算机需要输出其对应的倒序

    思路:

    1. 对整数做%10的操作就能得到个位数

    2. 对整数做/10的操作就能去掉个位数

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /*
     * 定义变量x和digit
     * 当用户输入x的值后进入while
     * 首先会判断x是否大于0，满足则进入循环体
     * digit的值是用户输入的最后一位
     * 然后将去掉的那一位数去掉，重新循环
     * 知道x的值不满足大于0的条件才会结束循环*/
    #include <stdio.h>

    int main() {
        int x , digit;
        scanf("%d", &x);
        while ( x >  0){
            digit = x % 10;
            printf("%d", digit);
            x /= 10;
        }
        return 0;
    }

整数分解

  • 输入一个非负整数,正序输出它每一位数字,并在其后面加空格

    输入:12345

    输出:1 2 3 4 5

    思路:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    (input)12345 / (mask)10000 = (result)1
    (input)12345 % (mask)10000 = 2345
    (mask)10000 / 10    = (mask)1000

    (input)2345 / (mask)1000 = (result)2
    (input)2345 % (mask)1000 = 345
    (mask)1000 / 10    = (mask)100

    ...如此循环,直至mask=0

    1. 取位数(mask)

      之前写过取位数的相关代码,但是仅仅只是取位数而已,这里我们需要每取一位就让input除等以10,mask乘等以10,直到input被除到小于等于10为止

    2. 算法实现

      得知mask的值之后就好办了,根据上述算法就可以写出代码了

      判断,当mask大于1就输出一个空格

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    #include <stdio.h>

    int main() {
        int inp;
        scanf("%d", &inp);
        int inp2 = inp;
        int mask = 1;
    //    取位数
        while ( inp > 9 ){
            inp /= 10;
            mask *= 10;
        }
        printf("mask=%d\n", mask);
    //    算法
        do {
            int res = inp2 / mask;
            printf("%d", res);
            if ( mask > 1 ){
                printf(" ");
            }
            inp2 %= mask;
            mask /= 10;
        }while ( mask > 0 );
        return 0;
    }

最大公约数

  • 输入两个数a和b,输出它们的最大公约数

    例如:输出12 和18

    输出6

    思路:

    1. 如果b等于0,结束计算,a就是最大公约数;

    2. 计算a除b的余数,让a等于b,而b等于那个余数

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #include <stdio.h>

    int main() {
        int a, b;
        scanf("%d %d", &a, &b);
        while (b != 0) {
            int t = a % b;
            a = b;
            b = t;
            printf("%d%d%d\n",a,b,t);
        }
        printf("gcd=%d", a);
        return 0;
    }

给定条件整数集

  • 给定一个不超过6的正整数A,从A开始的连续4个数字算进整数集中,请输出由整数集中的所有无重复数字组成的3位数

  • 要求输出的3位数从大到小排列,每行只存在6个整数,每个整数之间用空格分开,但是航模不允许有多余的空格

    思路:

    1. 嵌套的三个循环,每个数对应一个变量

    2. 输出条件,当三个数字不相同的时候才输出结果

    3. 换行条件,满足循环6的次数,满足则换行,否则输出空格

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    /*
     * 定义五个变量
     * a是用户输入值
     * i，j，k分别对应整数集中的三位数
     * time是计数器，每轮输出判断中让计数器++
     * 循环条件把用户输入的值赋给i，j，k，当它们小于等于3时才进入循环每轮循环让它们+1
     * 只有当i，j，k三个数互不相等时才满足输出判断
     * 如果计数器到达6次时，输出一个换行，并让计数器归零
     * 否则的话只输出空格符
     * */
    #include <stdio.h>

    int main() {
        int a, i, j, k, time = 0;
        scanf("%d", &a);
    //  嵌套循环
        for (i = a; i < a + 4; i++) {
            for (j = a; j < a + 4; j++) {
                for (k = a; k < a + 4; k++) {
    //              输出判断
                    if (i != k && i != j && j != k) {
                        time++;
                        printf("%d%d%d", i, j, k);
    //                  换行判断
                        if (time == 6) {
                            printf("\n");
                            time = 0;
                        } else {
                            printf(" ");
                        }
                    }
                }
            }
        }
        return 0;
    }

水仙花数

  • 水仙花数是指一个N位的正整数(N>=3),它的每个位上的数字N次幂之和等于它本身的,计算出所有N位的水仙花数

    例如:153=1^3+5^3+3^3,输入3,输出153,370,371

    思路:

    1. 先利用循环得出N位数的最小数,例如n为3,则最小数为100

    2. 其次一个大循环,范围是最小数到最大数(最小数*10)

    3. 将所有数都拆分开计算,每个数都乘n次自身,使用sum储存它们的和

    4. 判断,当sum与大循环的条件相等时,就为水仙花数

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    //水仙花数是指一个N位的正整数（ N>=3 ），它的每个位上的数字的N次幂之和等于它本身,计算出所有N位水仙花数
    #include <stdio.h>

    int main() {
        int n, first = 1;
        scanf("%d", &n);
        if (n < 3 || n > 7) {
            printf("您输入的数有误,请重新输入");
        } else {
            for (int i = 1; i < n; i++) {
                first *= 10;
            }
            //k = first~first*10
            for (int k = first; k < first * 10; ++k) {
                int sum = 0;
                for (int p = k; p > 0;) {
                    int o = 0;
                    o = p % 10; // o = 100 ~ 999 % 10
                    int res = o;
                    p /= 10; // first~first*10/10
                    for (int j = 1; j < n; j++) { //循环两次
                        res *= o;// res * res * res
                    }
                    sum += res; //sum = sum + res * res * res
                }
                if (k == sum) {
                    printf("%d\n", sum);
                }
            }
        }
        return 0;
    }

九九乘法表

  • 完整口诀表

    05-11_19:00

  • 对任意给定的1位正整数N,输出从11到n\n的下三角部分口诀表,结果后面需要占四位空格,左对齐显示

    思路:

    1. 两个循环,第一个范围从1到输入的正整数N,每循环一轮+1

    2. 第二个循环从1到上一个变量的数,实现递减

    3. 还需要有个判断,当结果是个位数时打印四个空格,否则输出三个空格

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    #include <stdio.h>

    int main() {
        int n;
        scanf("%d", &n);
        // 判断n的大小
        if (n < 1 || n > 9) {
            printf("范围是1~9，请重新输入");
        } else {
            // 从1到n循环
            for (int i = 1; i <= n; i++) {
                // 从1到i循环
                for (int j = 1; j <= i; j++) {
                    int sum;
                    sum = i * j;
                    // 当和是个位数时打印四个空格
                    if (sum < 10) {
                        printf("%d*%d=%d   ", j, i, sum);
                        // 大于个位数时打印三个空格
                    } else if (sum >= 10) {
                        printf("%d*%d=%d  ", j, i, sum);
                    }
                }
                printf("\n");
            }
        }
        return 0;
    }

统计素数求和

  • 统计给定整数M和N区间内素数的个数,并对它们求和

  • 输入M和N,以空格分开,范围是1<=M<=N<=500

    思路:

    之前做过100以内的50个素数,判断方法直接照搬就行

    添加一个求和的操作就行

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    #include <stdio.h>

    int main() {
        int m, n;
        scanf("%d %d", &m, &n);
        if (m < 1 || n > 500) {
            printf("请重新输入");
        } else {
            if (m == 1) {
                m = 2;
            }
            int time = 0;
            int sum = 0;
            for (int i = m; i <= n; i++) {
                int isPrime = 1;
                for (int k = 2; k < i; k++) {
                    if (i % k == 0) {
                        isPrime = 0;
                        break;
                    }
                }
                // 判断是否为素数
                if (isPrime) {
                    time++;
                    sum += i;
                }
            }
            printf("%d %d", time, sum);
        }
        return 0;
    }

猜数游戏2

  • 猜数游戏是让系统随机产生一个100以内的正整数,用户输入一个数对其猜测,编写程序让输入数字与产生的随机数进行对比较,如果大了提示”Too big!”,如果小了提示”Too small”,相等表示猜到了

  • 如果猜到的话,程序结束,并统计猜数的次数

  • 如果1次就猜中了就提示”Bingo!”,三次以内猜中该随机数则提示”Lucky You!”,如果超过三次但是在N(N > 3)次以内(包括第N次)猜到该随机数则提示”Good Guess”,如果超过N次都没猜到或者在没到达N次之前用户输入了一个负数,提示”Game Over!”,并结束程序

  • 输入格式:在第一行输入两个不超过100的正整数,分别是第一次用户的输入,以及猜测的最大次数N,随后每行给出一个用户的输入

  • 输出格式:在一行中输出每次猜测相对应的结果,直到输出才对的结果或是”Game Over”则结束

    思路:

    if 造它就完了,奥利给!

    1. 100以内正整数随机数
    2. 循环次数,判断条件,计数器

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    #include <stdio.h>
    #include "stdlib.h"
    #include "time.h"

    int main() {
        // 生成随机数
        srand(time(0));
        int random = rand() % 100 + 1;
        int i, j, time;
        // 第一次猜测以及最大猜测次数输入
        scanf("%d %d", &i, &time);
        // 循环100次
        for (j = 0; j < 100 ; j++) {
            // 如果满足i是负数或者循环次数比最大猜测数大
            if (i < 0 || j > time) {
                printf("Game Over!");
                break;
            }
            if (i < random) {
                printf("Too small\n");
            } else if (i > random) {
                printf("Too big\n");
            } else { // 相等的各种情况
                if (j == 0) { // 一次猜中
                    printf("Bingo!\n");
                    break;
                } else if (j <= 3) { // 三次内
                    printf("Lucky You!");
                    break;
                } else if (j > 3 && j < time) { // 超过三次,但是不超过最大猜测数
                    printf("Good Guess!");
                    break;
                }
            }
            // 每轮循环重新输入猜测数
            scanf("%d", &i);
        }
        return 0;
    }

前N项和

  • 计算序列2/1+3/2+5/3+8/5+...的前N项之和

  • 序列从2开始,每一项的分子是前一项分子与分母的和,分母是前一项的分子

  • 输入格式:输入一个正整数N

  • 输出格式:输出部分和的值,精确到小数点后两位,计算结果不超过双精度范围

    思路:

    1. 循环,根据输入值N的范围
    2. 算法:
    1
    2
    3
    4
    			j  k
    			2/ 1
    j = t = j + k;k = j;
    			3 / 2
    1. 双精度double,小数点后两位%.2f

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include <stdio.h>

    int main() {
        int n;
        scanf("%d", &n);
        double j = 2.0, t = 0.0, k = 1.0, sum = 0.0;
        for (int i = 0; i < n; i++) {
            sum += j / k;
          // 临时值t
            t = j + k;
            k = j;
            j = t;
        }
        printf("%.2f",sum);
        return 0;
    }

约分最简公式

  • 分数可以表示为”分子/分母”的形式,用户输入一个分数时,将其约分成最简约分式,最简分式指分子和分母不具有继续约分的能力

  • 当分子大于分母时,不需要表达成整数又分数的形式,原样输出就行,而当分子分母相等时表示为1/1的分数形式

  • 输入格式:输入正整数w分数,分子与分母之间以/分割

  • 在scanf的格式字符串值加入/就能让scanf来处理斜杠

  • 输出格式:格式与输入相同,对应分数最简分式

    思路:

    之前做过最大公约数来着

    代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #include <stdio.h>

    int main() {
        int x,y;
        scanf("%d/%d",&x,&y);
        int a = x , b = y;
        while ( b !=  0){
            int t = a % b;
            a = b; // a为最大公约数
            b = t;
        }
        printf("%d/%d",x/a,y/a);
        return 0;
    }

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：https://zhboat.github.io/C%E8%AF%AD%E8%A8%80%E7%AC%94%E8%AE%B0-3/

评论