实验三

task1：

#include <stdio.h>

char score_to_grade(int score);  // 函数声明

int main() {
    int score;
    char grade;

    while(scanf("%d", &score) != EOF) {
        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;
}

 

 问题1：接收一个整数分数 score，按照分数区间转换成对应的等级字符（90~100 为 A，80~89 为 B，70~79 为 C，60~69 为 D，小于 60 为 E），返回这个等级字符。形参：int，返回值：char

问题2：缺少break，case匹配成功后不会自动跳出，字符类型用单引号

task2：

#include <stdio.h>

int sum_digits(int n);  // 函数声明

int main() {
    int n;
    int ans;

    while(printf("Enter n: "), scanf("%d", &n) != EOF) {
        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;
}

 

问题1：接收一个整数n，计算这个整数每一位数字的累加和，返回各位数字之和。

问题2：可以。

1. 原来靠循环，重复执行相同操作，变量保存累加结果，没有函数调用；
2. 现在把大问题拆成规模更小的子问题，依靠函数调用自身，直到触发出口条件

task3：

#include <stdio.h>

int power(int x, int n);    // 函数声明

int main() {
    int x, n;
    int ans;

    while(printf("Enter x and n: "), scanf("%d%d", &x, &n) != EOF) {
        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;
    }
}

问题1：计算整数 x 的 n 次幂 并返回结果。

问题2：递归函数

 问题3：1：(power(x,n/2)*power(x,n/2) 和先保存 (t=power(x,n/2)) 再返回 (t*t) 的计算结果完全一样，所以最终幂的值是对的。

　　　　2：原写法：只调用一次power(x,n/2)，把结果存入变量t复用，同一个子问题只计算 1 次，无重复计算：power (3,16) → power (3,8) → power (3,4) → power (3,2) → power (3,1) → power (3,0)调用6次

　　　　　 改进写法：每次都要独立调用两次power(x,n/2)，同一个子问题被重复计算两遍，大量冗余递归。 power(3,16)： power (3,16) → 2 个 power (3,8) 每个 power (3,8) → 2 个 power (3,4) 每个 power (3,4) → 2 个 power (3,2) 每个 power (3,2) → 2 个 power (3,1) 每个 power (3,1) → 2 个 power (3,0) 总调用次数：63

task4：

//task4
#include <stdio.h>

// 函数原型
int classify_triangle(int a, int b, int c);

int main(void)
{
    int a, b, c;
    int res;
    // 多组输入
    while (scanf("%d%d%d", &a, &b, &c) != EOF)
    {
        res = classify_triangle(a, b, c);
        switch (res)
        {
            case 0: printf("不能构成三角形\n"); break;
            case 1: printf("普通三角形\n"); break;
            case 2: printf("等边三角形\n"); break;
            case 3: printf("等腰三角形\n"); break;
            case 4: printf("直角三角形\n"); break;
        }
    }
    return 0;
}

int classify_triangle(int a, int b, int c)
{

    if (a <= 0 || b <= 0 || c <= 0)
        return 0;
    if ( (a + b <= c) || (a + c <= b) || (b + c <= a) )
        return 0;

    // 等边
    if (a == b && b == c)
        return 2;

    // 判断直角三角形
    int max = a;
    if (b > max) max = b;
    if (c > max) max = c;
    if (max == a)
    {
        if (b*b + c*c == a*a)
            return 4;
    }
    else if (max == b)
    {
        if (a*a + c*c == b*b)
            return 4;
    }
    else
    {
        if (a*a + b*b == c*c)
            return 4;
    }

    if (a == b || a == c || b == c)
        return 3;

    return 1;
}
 

 task5：

#include <stdio.h>
int func(int n, int m);   // 函数声明

int main() {
    int n, m;
    int ans;

    while(scanf("%d%d", &n, &m) != EOF) {
        ans = func(n, m);   // 函数调用
        printf("n = %d, m = %d, ans = %d\n\n", n, m, ans);
    }
        
    return 0;
}

// 函数定义
// 待补足。。。（分别用迭代和递归实现）
//迭代
int func(int n, int m)
{
    // C(n,0)=1，C(n,n)=1；m>n时组合数为0
    if(m < 0 || m > n)
        return 0;
    if(m == 0 || m == n)
        return 1;
    // 取m和n-m中较小的，减少循环次数
    if(m > n - m)
        m = n - m;

    int res = 1;
    int i; 
    for(i = 1; i <= m; i++)
    {
        res = res * (n - m + i) / i;
    }
    return res;
}

#include <stdio.h>
int func(int n, int m);   // 函数声明

int main() {
    int n, m;
    int ans;

    while(scanf("%d%d", &n, &m) != EOF) {
        ans = func(n, m);   // 函数调用
        printf("n = %d, m = %d, ans = %d\n\n", n, m, ans);
    }
        
    return 0;
}

// 函数定义
// 待补足。。。（分别用迭代和递归实现）
//递归
 
 int func(int n, int m)
{
    // 递归出口
    if(m < 0 || m > n)
        return 0;
    if(m == 0 || m == n)
        return 1;
    return func(n-1, m) + func(n-1, m-1);
}

 

 task6：

#include <stdio.h>

// 函数声明
int gcd(int a, int b, int c);

int main() {
    int a, b, c;
    int ans;

    while(scanf("%d%d%d", &a, &b, &c) != EOF) {
        ans = gcd(a, b, c);      // 函数调用
        printf("最大公约数: %d\n\n", ans);
    }

    return 0;
}

// 函数定义：穷举法求三个正整数最大公约数
int gcd(int a, int b, int c)
{
    // 先找三个数里最小的数
    int min = a;
    if(b < min) min = b;
    if(c < min) min = c;

    // 从min往下穷举，找到第一个能同时整除a,b,c的数
    for(int i = min; i >= 1; i--)
    {
        if(a % i == 0 && b % i == 0 && c % i == 0)
        {
            return i;
        }
    }
    return 1; // 保底，一定能返回1
}

 

 task7：

 

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

// 函数声明
void print_charman(int n);

int main() {
    int n;
    printf("Enter n: ");
    scanf("%d", &n);
    print_charman(n); // 函数调用
    return 0;
}


void print_charman(int n)
{
    int i, j, k;
  
    for(i = n; i >= 1; i--)
    {
       
        for(k = i; k < n; k++)
        {
            printf("\t");
        }
        // 打印 2*i -1 个小人
        for(j = 1; j <= 2*i - 1; j++)
        {
            printf("0\t");
        }
        printf("\n");

       
        for(k = i; k < n; k++)
        {
            printf("\t");
        }
        for(j = 1; j <= 2*i - 1; j++)
        {
            printf("<H>\t");
        }
        printf("\n");

        for(k = i; k < n; k++)
        {
            printf("\t");
        }
        for(j = 1; j <= 2*i - 1; j++)
        {
            printf("I I\t");
        }
        printf("\n");
    }
}