AIGC标识 实验3:C语言函数应用编程

实验3:C语言函数应用编程

四、实验结论

编译环境:Visual Studio 2022 / Microsoft C,UTF-8。每个源码独立编译运行。运行截图取自本机运行结果查看器,查看器启动各题可执行程序,分别展示实际输入和标准输出。

实验任务 1

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
char score_to_grade(int score);
int main(void) {
    int score;
    char grade;
    while (scanf("%d", &score) == 1) {
        grade = score_to_grade(score);
        printf("分数: %d, 等级: %c\n\n", score, grade);
    }
    return 0;
}
char score_to_grade(int score) {
    char ans;
    switch (score / 10) {
    case 10:
    case 9: ans = 'A'; break;
    case 8: ans = 'B'; break;
    case 7: ans = 'C'; break;
    case 6: ans = 'D'; break;
    default: ans = 'E';
    }
    return ans;
}

task1实际运行记录

函数 score_to_grade 将百分制成绩转换为等级,形参 score 为 int,返回值为 char。90~100 为 A,80~89 为 B,70~79 为 C,60~69 为 D,0~59 为 E。测试五个成绩分别输出 A、B、A、C、E。

改写代码有两个问题:① "A" 等是字符串字面量,不是字符常量,其地址不能正确赋给 char 类型的 ans,应使用 'A' 等单引号字符;② 缺少 break 会产生贯穿执行,即便改正引号,也会继续执行后续分支,最终被 default 覆盖为 'E'。case 10 与 case 9 合用一个处理分支是正确的。

按验证题保留等级函数,使用前提是成绩在 0~100;原函数未验证越界成绩。读取循环改为检查成功读取的数量,避免非数字输入引起死循环。

实验任务 2

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int sum_digits(int n);
int main(void) {
    int n, ans;
    while (printf("Enter n: "), scanf("%d", &n) == 1) {
        ans = sum_digits(n);
        printf("n = %d, ans = %d\n\n", n, ans);
    }
    return 0;
}
int sum_digits(int n) {
    int ans = 0;
    while (n != 0) {
        ans += n % 10;
        n /= 10;
    }
    return ans;
}

task2实际运行记录

sum_digits 计算非负十进制整数各位数字之和。42、2049、77 分别得到 6、15、14。循环版本反复取末位 n%10 并除以10,将各位累加;递归版本先求 n/10 的数位和,再加末位 n%10,n<10 时返回 n。

对于非负整数,两种算法输出相同,包括 0;循环空间复杂度 O(1),递归需要 O(d) 栈空间,两者时间均为 O(d),d 为位数。若允许负数,题目给出的两种写法不等价:例如 -42,循环输出 -6,递归因 -42<10 直接返回 -42。已将递归版本作为对照程序验证。

递归数位和对照

实验任务 3

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int power(int x, int n);
int main(void) {
    int x, n, ans;
    while (printf("Enter x and n: "), scanf("%d%d", &x, &n) == 2) {
        if (n < 0) { printf("指数须为非负整数\n"); continue; }
        ans = power(x, n);
        printf("n = %d, ans = %d\n\n", n, ans);
    }
    return 0;
}
int power(int x, int n) {
    int t;
    if (n == 0) return 1;
    else if (n % 2) return x * power(x, n - 1);
    else {
        t = power(x, n / 2);
        return t * t;
    }
}

task3实际运行记录

power(x,n) 计算整数底数 x 的非负整数次幂;n=0 时返回1(本程序也将0的0次幂按此规则处理)。它是递归函数,递归模型如下,其中 n 为非负整数:

P(x,0)=1;n为正奇数时,P(x,n)=x·P(x,n−1);n为正偶数时,P(x,n)=[P(x,n/2)]²。

将偶数分支改为 power(x,n/2)*power(x,n/2),在结果及中间乘法均不溢出的前提下,算法逻辑仍正确,但相同子问题会被重复计算。原写法只算一次子问题,并保存到 t,再平方。

以 power(3,16) 为例:原版调用链为16→8→4→2→1→0,总计6次函数进入(其中递归调用5次);改写版满足 T(0)=1、T(1)=2、T(2k)=1+2T(k),得到 T(2)=5、T(4)=11、T(8)=23、T(16)=47,即总计47次进入(递归调用46次)。两者均输出43046721。计数对照程序实测一致。原版时间 O(log n),重复版 O(n),最大递归栈深度均为 O(log n)。

int 不能表示任意大的幂;本题以结果与中间值均在 int 范围内为前提。主程序对负指数作提示,避免递归无法收敛。

幂函数递归数学模型

递归调用次数实测

实验任务 4

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int classify_triangle(int a, int b, int c);
int main(void) {
    int a, b, c;
    while (scanf("%d%d%d", &a, &b, &c) == 3) {
        printf("%d %d %d: ", a, b, c);
        switch (classify_triangle(a, b, c)) {
        case 0: puts("不能构成三角形"); break;
        case 1: puts("普通三角形"); break;
        case 2: puts("等边三角形"); break;
        case 3: puts("等腰三角形"); break;
        case 4: puts("直角三角形"); break;
        }
    }
    return 0;
}
int classify_triangle(int a, int b, int c) {
    int t;
    if (a <= 0 || b <= 0 || c <= 0) return 0;
    if (a > b) { t = a; a = b; b = t; }
    if (b > c) { t = b; b = c; c = t; }
    if (a > b) { t = a; a = b; b = t; }
    if ((long long)a + b <= c) return 0;
    if (a == c) return 2;
    if ((long long)a*a + (long long)b*b == (long long)c*c) return 4;
    if (a == b || b == c) return 3;
    return 1;
}

task4实际运行记录

classify_triangle 的三个形参为 int,返回0、1、2、3、4分别表示不能构成、普通、等边、等腰、直角。先排除非正边并排序,再判断最短两边之和是否大于最长边;依次判断等边、直角、等腰、普通。等边先判断,避免被一般等腰条件覆盖。平方与加法提升为 long long,避免合法 int 边长的中间运算溢出。支持多组输入,并测试了全部五种类型、非正数、乱序和大边长。

实验任务 5_1

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <limits.h>
int func(int n, int m);
int main(void) {
    int n, m, ans;
    while (scanf("%d%d", &n, &m) == 2) {
        ans = func(n, m);
        if (ans == -1) puts("结果超出int范围");
        else printf("n = %d, m = %d, ans = %d\n\n", n, m, ans);
    }
    return 0;
}
int func(int n, int m) {
    long long ans = 1;
    int i;
    if (n < 0 || m < 0 || m > n) return 0;
    if (m > n - m) m = n - m;
    for (i = 1; i <= m; ++i) {
        ans = ans * (n - i + 1) / i;
        if (ans > INT_MAX) return -1;
    }
    return (int)ans;
}

task5_1实际运行记录

迭代公式为 C(n,m)=n(n−1)…(n−m+1)/m!。利用 C(n,m)=C(n,n−m) 减少循环,逐步计算 ans=ans*(n−i+1)/i,避免先计算阶乘。m>n、m<0或n<0时返回0;m=0或m=n时返回1。用 long long 保存中间乘积,最终超过 INT_MAX 时返回-1并提示。

实验任务 5_2

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <limits.h>
int func(int n, int m);
int main(void) {
    int n, m, ans;
    while (scanf("%d%d", &n, &m) == 2) {
        ans = func(n, m);
        if (ans == -1) puts("结果超出int范围");
        else printf("n = %d, m = %d, ans = %d\n\n", n, m, ans);
    }
    return 0;
}
int func(int n, int m) {
    int left, right;
    if (n < 0 || m < 0 || m > n) return 0;
    if (m == 0 || m == n) return 1;
    left = func(n - 1, m);
    right = func(n - 1, m - 1);
    if (left == -1 || right == -1 || left > INT_MAX - right) return -1;
    return left + right;
}

task5_2实际运行记录

采用题目给出的递归模型 C(n,m)=C(n−1,m)+C(n−1,m−1)。递归出口:m>n、m<0或n<0返回0,m=0或m=n返回1。累加前检查 int 上限,-1表示超出范围。与迭代版本逐项对照 n=0~12、m=0~n+1 的结果,并与标准组合数计算结果核对,全部一致。题目四组样例依次得到0、1、1、10。

朴素递归存在重复子问题,适合本题的小规模演示;中间区域的调用数可呈指数增长,大规模计算宜采用迭代、记忆化或动态规划。

实验任务 6

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int gcd(int a, int b, int c);
int main(void) {
    int a, b, c, ans;
    while (scanf("%d%d%d", &a, &b, &c) == 3) {
        ans = gcd(a, b, c);
        if (ans == 0) puts("请输入三个正整数");
        else printf("最大公约数: %d\n\n", ans);
    }
    return 0;
}
int gcd(int a, int b, int c) {
    int i;
    if (a <= 0 || b <= 0 || c <= 0) return 0;
    i = a;
    if (b < i) i = b;
    if (c < i) i = c;
    for (; i >= 1; --i)
        if (a % i == 0 && b % i == 0 && c % i == 0) return i;
    return 1;
}

task6实际运行记录

函数原型为 int gcd(int a,int b,int c)。按题目要求使用穷举法,从三个正整数的最小值开始向下寻找,遇到同时整除三个数的第一个数便返回。因为从大到小检查,首次命中的就是最大公约数。最坏时间为 O(min(a,b,c)),额外空间 O(1)。对非正数返回0并在main中提示。

实验任务 7

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void print_charman(int n);
int main(void) {
    int n;
    printf("Enter n: ");
    if (scanf("%d", &n) == 1) { putchar('\n'); print_charman(n); }
    return 0;
}
void print_charman(int n) {
    int i, j, k;
    const char *part[] = {" O ", "<H>", "I I"};
    if (n <= 0) return;
    for (i = 0; i < n; ++i) {
        for (k = 0; k < 3; ++k) {
            for (j = 0; j < i; ++j) printf("\t");
            for (j = 0; j < 2 * (n - i) - 1; ++j)
                printf("%s\t", part[k]);
            putchar('\n');
        }
        putchar('\n');
    }
}

task7实际运行记录

函数原型为 void print_charman(int n),一个 int 参数表示阵列行数,无须返回值。以 i 从0计数,第 i 行有 2*(n−i)−1 个小人,每条组成线前有 i 个制表符。每行分成头部 O、身体 <H>、腿部 I I 三条线,再空一行。n=3时每行有5、3、1个小人,n=4时有7、5、3、1个;总个数为n²,已经核对。制表符须在等宽字体和一致的制表位下查看。

五、实验总结

函数声明描述接口,定义实现功能,调用传入实参;返回值应与功能匹配。递归设计应先确定出口,再确认每次调用向出口推进。保存子问题的结果可以避免重复计算。整数输入也要考虑中间计算溢出,测试应覆盖一般情况、递归出口、非法范围与分类边界。

posted @ 2026-11-20 14:13  Eurydice  阅读(3)  评论(0)    收藏  举报