复试阶段c语言机试代码（自用）

1-10

1、编写一个程序，从键盘接收3个实数（分别为10.0、20.0、5.0），输出这3个数的和s、乘积t和平均值a。

#include<stdio.h>
int main(){
    double a, b, c;
    double s, t, aver;
    scanf("%lf%lf%lf", &a, &b, &c);
    s = a + b + c;
    t = a * b * c;
    aver = s / 3;
    printf("%lf %lf %lf", s, t, aver);
}

2、编程。要求用户输入两个整数a、b（分别为20、10）， 读取用户从键盘输入的值，然后：
1）用整数输出这两个数的和、差；
2）用长整型输出这两个数的积，用float输出商；
3）用整数输出这两个数的余数，用float输出平均值。

#include<stdio.h>
int main(){
    int a, b;
    int he, cha, yu;
    long ji; 
    float shang, aver;
    scanf("%d%d", &a, &b);
    he = a + b, cha = a - b;
    printf("%d %d\n", he, cha);
    ji = a * b, shang = (float)a / b;
    printf("%ld %f\n", ji, shang);
    yu = a % b; 
    aver = (a + b) / 2.0f;  // 改为浮点除法
    printf("%d %f\n", yu, aver);
    return 0;
}

3、编写一个程序，从键盘接收一个一位的整型数，经转换，用字符函数putchar输出。例如，输入整数5，程序运行后输出字符5。

#include<stdio.h>
int main(){
    int digit;
    scanf("%d", &digit);
if (digit < 0 || digit > 9) {
    printf("输入错误！");
    return 1;
}
    char c = digit + '0';
    putchar(c);
    return 0;
}

4、编程。输入半径，计算球体表面积（
）和球体积 （
）。

#include<stdio.h>
#include<math.h>
#define PI 3.1415926
int main(){
    double r;
    double s,v;
    // 输入半径
    scanf("%lf", &r); 
    // 求表面积、体积
    s = 4 * PI * pow(r, 2);
    v = (4.0 / 3) * PI * pow(r, 3);
    printf("%.2lf %.2lf", s, v);
    return 0;
}

5、编写一个程序，要求通过键盘给6个变量赋值，然后将变量的值在屏幕上打印输出。这六个变量的值分别为：10，－10，40000，a，3.14，hello。

#include<stdio.h>
int main() {
    int a, b;
    long c;
    char d;
    float e;
    char s[16];
    // 输入提示及安全读取（错因：空格会导致char读取错误）
    printf("请输入（格式：a b c d e s）：\n");
    // 输入6个变量（注意字符串数组地址就是s，不需要加百分号）
    scanf("%d %d %ld %c %f %15s", &a, &b, &c, &d, &e, s);
    // 输出
    printf("%d %d %ld %c %.2f %s", a, b, c, d, e, s);
    return 0;
}

6. 编程实现：键盘输入三个整数，分别存放到变量a，b，c中，输出其中的最小值（要求不改变a、b、c的值）。

#include<stdio.h>
int main() {
    int a, b, c;
    int min; // 最小值
    scanf("%d%d%d", &a, &b, &c);
    if(a <= b && a <= c){
        min = a;
    }else if(b <= a && b <= c){
        min = b;
    }else{
        min = c;
    }
    printf("%d", min);
    return 0;
} 

7. 编程实现：键盘输入一个字符，如是大写字母，则输出相应小写字母；如是小写字母，则输出相应大写字母；其它字符原样输出。

#include<stdio.h>
int main(){
    char c;
    scanf("%c", &c);
    // 大写字母转换成小写字母
    if (c >= 'A' && c <= 'Z'){
        c = c + ('a' - 'A');
    }else if(c >= 'a' && c <= 'z'){
        c = c - ('a' - 'A');
    }else{
        // 其他字符原样输出
        c = c;
    }
    printf("%c", c);
    return 0;
}

8、计算以下分段函数值

#include<stdio.h>
int main(){
    float x, y;
    scanf("%f", &x);
    // 求分段函数值
    if (x < 0 && x != -3){
        y = x * x + x - 6;
    }else if(x >= 0 && x < 10 && x != 2 && x != 3){
        y = x * x - 5 * x + 6;
    }else{
        y = x * x - x - 1;
    }
    printf("%f", y);
    return 0;
}

9. 编写程序，键盘接收一个字符串(只含大、小写英文字母)，将该字符串加密后输出。加密规则为：若为小写字母则不变，若为大写字母则将其转换为小写后再后移一个字母，例如“A”应转换为“b”，“B”应转换为“c”，“Y”应转换为“z”，而“Z”应转换为“a”。

#include<stdio.h>
#include<string.h>
#define MAXSIZE 128
int main(){
    char s[MAXSIZE];
    int i; // 用于遍历数组
    scanf("%s", &s);
    for (i = 0; s[i] != '\0'; i++){
        // 大写字母转换成小写字母后加一个字母
        if (s[i] >= 'A' && s[i] < 'Z'){
            s[i] = s[i] + ('a' - 'A') + 1;
        }else if(s[i] == 'Z'){
            s[i] = 'a';
        }
    }
    printf("%s", s);
    return 0;
}

10. 编写程序，用scanf输入任意两个数给变量a、b，若a大于等于b，则直接输出a、b，否则将a、b的值交换（即a的原值放入b中，b的原值放入a中）后再输出。

#include<stdio.h>
int main(){
    float a, b, tmp;
    scanf("%f%f", &a, &b);
    if (a < b){
        // 交换a,b
        tmp = a; a = b; b = tmp;
    }
    printf("%f %f", a, b);
    return 0;
}

11-20

11. 编写程序：由系统生成一个10以内的随机整数，用户从键盘上输入一个10以内的整数，如果两者相等输出“OK”，否则输出“ERROR”。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){
    srand(time(NULL));
    // 随机生成的数字
    int randNum = rand() % 10 + 1;
    // 用户输入的数字
    int userNum; 
    printf("用户输入数字（范围1~10):");
    scanf("%d", &userNum);
    // 判断用户输入是否非法
    if (userNum < 1 || userNum > 10){
        printf("用户输入的数字非法（范围1~10）");
        return 1;
    }
    // 判断用户输入和随机数是否相等
    if (userNum == randNum){
        printf("OK\n");
    }else{
        printf("ERROR\n");
    }
    return 0;
}

12. 编写程序要求输入整数a和b，若a2+ b2大于100，则输出a2+ b2百位以上的数字，否则输出两数之和。

#include <stdio.h>
int main() {
    int a, b;
    int res;
    // 输入两个数
    scanf("%d%d", &a, &b);
    // 如果a^2+b^2>100，结果为a^2+b^2百位以上数字
    // 否则输出两数之和
    res = (a * a + b * b > 100) 
        ? (a * a + b * b) /100
        : (a + b);
    printf("%d\n", res);
    return 0;
}

13. 编程，计算函数y的值，已知函数y与自变量x的关系为：
    

#include <stdio.h>
#include<math.h>
int main() {
    float x, y;
    scanf("%f", &x);
    // 简单的分段函数
    if (x >= 0 && x < 100){
        y = x * 3 + 10;
    }else{
        y = pow(x, 3) - 20;
    }
    printf("y = %f\n", y);
    return 0;
}  

14. 编写一个简单的计算器程序，输入格式为：data1 op data2。其中data1和data2是参加运算的两个数，op为运算符，它的取值只能是+、-、*、/。

#include<stdio.h>
int main(){
    // 操作数d1,d2
    float d1, d2;
    float res;
    // 操作符
    char op;
    printf("输入操作数1:");
    scanf("%f", &d1);
    printf("\n输入操作数2:");
    scanf("%f", &d2);
    printf("\n输入操作符(仅限+-*/)：");
    scanf(" %c", &op);
    switch(op){
        case '+':
            res = d1 + d2;
            break;
        case '-':
            res = d1 - d2;
            break;
        case '*':
            res = d1 * d2;
            break;
        case '/':
            if (d2 == 0){
                printf("除数不能为0\n");
                return 1;
            }
            res = d1 / d2;
            break;
        default:
            printf("\n操作符非法！(仅限+-*/)\n");
            return 1;
    }
    printf("\nres=%f\n", res);
    return 0;
}

15. 编程实现：输入一个整数，判断它能否被3，5，7整除，并输出以下信息之一：
    ①能同时被3，5，7整除
    ②能被其中两数（要指出是哪两个数）整除
    ③能被其中一个数（要指出是哪一个数）整除
    ④不能被3，5，7任一个数整除

#include<stdio.h>
int main(){
    // x用于接收输入整数
    int x;
    // 除数数组（本题为3，5，7）
    int devisors[3] = {3, 5, 7};
    // 能整除哪些数
    int selected[3];
    // 计数器，用于统计能被哪些数整除
    int count = 0;
    // 用于遍历数组
    int i;
    
    printf("输入整数:");
    scanf("%d", &x);
    for (i = 0; i < sizeof(devisors) / sizeof(devisors[0]); i++){
        if (x % devisors[i] == 0){
            selected[count] = devisors[i];
            count++;
        }
    }
    switch(count){
        case 3:
            printf("\n%d能同时被3,5,7整除", x);
            break;
        case 2:
            printf("\n%d能同时被%d,%d整除", x, selected[0], selected[1]);
            break;
        case 1:
            printf("\n%d能同时被%d整除", x, selected[0]);
            break;
        case 0:
            printf("\n%d不能同时被3，5，7整除", x);
            break;
        default:
            break;
    }
    return 0;
}

16. 已知从2008年12月开始,银行整存整取存款不同期限的年利率分别为：三个月 1.71%，半年 1.98%，一年 2.25%，两年 2.79%，三年 3.33%，五年 3.60%。编写程序，要求输入存钱的本金和期限，求出到期时能从银行得到的利息与本金的合计数。

#include<stdio.h>
int main(){
    // 本金，利息
    float money, interest;
    // 存钱期限
    char period;
    printf("输入本金:");
    scanf("%f", &money);
    do{
        printf("输入期限(a/b/c/d/e/f):\n");
        printf("三个月年利率1.71%%---a\n");
        printf("半年年利率1.98%%---b\n");
        printf("一年年利率2.25%%---c\n");
        printf("两年年利率2.79%%---d\n");
        printf("三年年利率3.33%%---e\n");
        printf("五年年利率3.60%%---f\n");
        scanf(" %c", &period);
    }while(period < 'a' || period > 'f');
    
    switch(period){
        case 'a':
            interest = money * 0.0171 * 0.25;
            break;
        case 'b':
            interest = money * 0.0198 * 0.5;
            break;
        case 'c':
            interest = money * 0.0225 * 1;
            break;
        case 'd':
            interest = money * 0.0279 * 2;
            break;
        case 'e':
            interest = money * 0.0333 * 3;
            break;
        case 'f':
            interest = money * 0.036 * 5;
            break;
        default:
            break;
    }
    printf("\n本金和利息=%f\n", money + interest);
    return 0;
}

17. 设函数

（1）用条件表达式求函数值y。
（2）用if 语句编程，输入x，输出y，并给出你所使用的测试用例。

#include<stdio.h>
int main(){
    float x;
    int y;
    scanf("%f", &x);
    // 第一小问解法
    // y = (x > 0) ? 1 : (x == 0 ? 0 : -1);
    // 第二小问解法
    if (x > 0){
        y = 1;
    }else if(x == 0){
        y = 0;
    }else{
        y = -1;
    }
    printf("y=%d\n", y);
    return 0;
}

18.编写程序：键盘上输入一个不多于5位的正整数，要求：①求它是几位数②逆序打印出各位数字。如原数为123，应输出321。

#include<stdio.h>
int main(){
    int x;
    // weishu-位数 reversedX-X逆序 tmp-暂存
    int weishu = 0, reversedX = 0, tmp;
    
    printf("输入一个不多于5位的正整数。\n");
    scanf("%d", &x);
    if (x < 1 || x > 99999){
        printf("输入非法！（不能多于5位的正整数）\n");
        return 1;
    }
    
    tmp = x;
    while(tmp > 0){
        tmp = tmp / 10;
        weishu++;
    }
    tmp = x;
    while(tmp > 0){
        reversedX = reversedX * 10 + (tmp % 10);
        tmp /= 10;
    }
    printf("%d是%d位数。\n", x, weishu);
    printf("逆序打印各位数字:%d\n", reversedX);
    return 0;
}

19、编程：输出200以内所有能被7整除的数。

#include <stdio.h>
int main() {
    int i;
    int cnt = 0;
    for (i = 1; i < 200; i++){
        if (i % 7 == 0){
            printf("%d ", i);
            cnt++;
            // 每行输出8个数字
            if(cnt == 8){
                printf("\n");
                cnt = 0;
            }
        }
    }
    return 0;
}

20、从键盘输入n个数(n<10)，找出其中最小值，请编写相应程序。

#include<stdio.h>
#include<limits.h>
int main() {
    // 统计输入数字个数
    int i;
    // 记录最小值
    int min = INT_MAX;
    // 统计输入了几个数字, 键盘输入的数字
    int tmp, x;
    printf("输入数字的个数(1~9之间):");
    scanf("%d", &i);
    if (i <= 0 || i >= 10){
        printf("输入参数非法！(1~9之间)\n");
        return 1;
    }
    for (tmp = 0; tmp < i; tmp++){
        scanf("%d", &x);
        if (x < min){
            min = x;
        }
    }
    printf("最小值:%d\n", min);
    return 0;
}

21-30

21、键盘输入正整数m和n（m<n），计算m~n之间所有奇数之和x与偶数之和y，请编程实现。

#include<stdio.h>
int main() {
    int m, n, i; // i用于遍历, m,n上下界
    int oddSum = 0, evenSum = 0; // 奇数和，偶数和
    printf("输入正整数m,n(m<n)\n");
    scanf("%d%d", &m, &n);
    
    if (m > n || m < 0 || n < 0){
        printf("输入参数m,n非法！");
        return 1;
    }
    
    for (i = m; i <=n; i++){
        if (i % 2 == 0){
            evenSum += i;
        }else{
            oddSum += i;
        }
    }
    printf("奇数之和=%d，偶数之和=%d\n", oddSum, evenSum);
    return 0;
}

22.编程，计算函数y的值。要求键盘接收自变量x的值，若x 的值不为零，则计算函数y的值并输出，再从键盘接收下一个x的值，……，直到x的值为零，则显示“Thank You，Bye!”，尔后结束程序，已知函数y与自变量x的关系为：

#include <stdio.h>
int main() {
    float x, y;
    do{
        printf("输入x(x >= 0):\n");
        scanf("%f", &x);
        if (x < 0){
            printf("输入x非法！x应大于等于0\n");
            return 1;
        }else if(x == 0){
            printf("Thank You, Bye!\n");
            break;
        }else{
            // x大于0的情况
            if (x > 0 && x < 100){
                y = 3 * x + 10;
            }else{
                y = x * x * x - 20;
            }
            printf("y = %f\n", y);
        }
    }while(x != 0);
    return 0;
}

23.编写程序：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

#include <stdio.h>
int main() {
    // 分母，分子
    int fenzi = 2, fenmu = 1, tmp, i = 0;
    float sum = 0;
    
    for (i = 0; i < 20; i++){
        sum += (float)fenzi / fenmu;
        tmp = fenzi + fenmu;
        fenmu = fenzi;
        fenzi = tmp;
    }
    printf("2/1+3/2+...(前20项) = %f\n", sum);
    return 0;
}

24.我国现有人口13亿，设年增长率为1%,编写程序，计算多少年后增加到20亿。

#include <stdio.h>
int main() {
    float p = 13; // 人口13亿
    int year = 0; // 初始为第0年
    while(p < 20){
        p += p * 0.01;
        year++;
    }
    printf("%d年后增加到20亿\n", year);
    return 0;
}

25. 求解爱因斯坦数学题。有一条长阶梯，若每步跨2阶，则最后剩余1阶；若每步跨3阶，则最后剩2阶；若每步跨5阶，则最后剩4阶；若每步跨6阶，则最后剩5阶；若每步跨7阶，最后才正好一阶不剩。请问，这条阶梯共有多少阶?

#include <stdio.h>
int main() {
    // 台阶数
    int x;
    // X能整除7
    for (x = 7; ; x += 7){
        if (x % 2 == 1 && x % 3 == 2 && x % 5 == 4 && x % 6 == 5){
            printf("这条阶梯总共%d级台阶。\n", x);
            break;
        }
    }
    return 0;
}

26. 每个苹果0.8 元，第一天买2 个苹果，第二天开始，每天买前一天的2 倍，直至购买的苹果个数达到不超过100 的最大值。编写程序求每天平均花多少钱？

#include<stdio.h>
int main(){
    // 每天买的苹果数量， 购买的苹果总数 天数
    int appleNum = 2, totalNum = 0, day = 0;
    // 平均每天要花多少钱
    float averMoney = 0;
    while(appleNum <= 100){
        totalNum += appleNum;
        day++;
        appleNum = appleNum * 2;
    };
    averMoney = totalNum * 0.8 / day;
    printf("每天平均花%f钱\n", averMoney);
    return 0;
}

27. 编写程序，求一个整数任意次方的最后三位数。即求xy的最后三位数，要求x，y 从键盘输入。（注意xy的结果是否会溢出）。

#include<stdio.h>
int main(){
    int x, y, i = 1;
    // 结果
    int res = 1;
    printf("求x的y次方的最后三位数,输入x和y。\n");
    scanf("%d%d", &x, &y);
    // 改用循环计算可以规避溢出
    while (i <= y){
        res = res * x % 1000;
        i++;
    }
    printf("%d的%d次方最后三位数为%03d\n", x, y, res);
    return 0;
}

28. 编写程序，从键盘输入6 名学生的5 门成绩，分别统计出每个学生的平均成绩。

#include <stdio.h>
// 学生数量
#define S_NUM 6
// 课程数量
#define C_NUM 5
typedef struct Student{
    // 学号
    int no;
    // 学生五门课程成绩， 平均成绩
    float score[C_NUM], averScore;
}Student;
int main() {
    // 6个学生
    Student s[S_NUM];
    int i, j;
    // 用于求学生成绩平均数
    float sum;
    for (i = 0; i < S_NUM; i++){
        s[i].no = i;
        sum = 0;
        printf("请输入第%d名学生的%d门课成绩。\n", i + 1, C_NUM);
        for (j = 0; j < C_NUM; j++){
            scanf("%f", &s[i].score[j]);
            sum += s[i].score[j];
        }
        
        s[i].averScore = sum / C_NUM;
    }
    // 输出学生的平均成绩
    printf("学生平均成绩：\n");
    for (i = 0; i < S_NUM; i++){
        printf("学生%d:%.2f分。\n", i + 1, s[i].averScore);
    }
    return 0;
}

29、打印出所有的"水仙花数"，所谓的"水仙花数"是指一个3位数，其各位数字的立方和等于该数本身。例如，153是一个"水仙花数"，因为有153=111+555+333 。

#include<stdio.h>
#include<math.h>
int main() {
    int i, cnt;
    // 个位 十位 百位
    int ge, shi, bai;
    // 遍历所有的3位数，从100~999，判断是否为水仙花数
    printf("水仙花数:");
    for (i = 100; i < 1000; i++){
        ge = i % 10;
        shi = i % 100 / 10;
        bai = i / 100;
        // 水仙花数->各位数字的立方和等于自身
        if (pow(ge, 3) + pow(shi, 3) + pow(bai, 3) == i){
            printf("%d ", i);
            cnt++;
            if(cnt == 5){
                cnt = 0;
                printf("\n");
            }
        }
    }
    return 0;
}
30、请分别用三种循环结构编程计算： 1!+2!+3!+...+n!，n的值由键盘输入。
#include <stdio.h>
int main() {
    int x, i, res = 0;
    scanf("%d", &x);
    if (x <= 0){
        printf("参数非法！(x应该>=1)\n");
        return 1;
    }
    // 第一种方法
    // for (i = 1; i <= x; i++){
    //     res += jieCheng(i);
    // }
    // 第二种方法
    // i = 1; 
    // while(i <= x){
    //     res += jieCheng(i);
    //     i++;
    // }
    // 第三种方法
    i = 1;
    do{
        res += jieCheng(i);
        i++;
    }while(i <= x);
    printf("result = %d\n", res);
    return 0;
}
// 求x的阶乘
int jieCheng(int x){
    if (x < 1){
        return -1;
    }
    int i, res = 1;
    for (i = 1; i <= x; i++){
        res *= i;
    }
    return res;
}

31-40

31. 用循环语句编写程序，其功能是计算：
    s=1+12+123+1234+12345+123456+1234567

#include <stdio.h>
int main() {
    long long s = 0;  // 存储总和
    long long term = 0;  // 存储当前项的值

    for (int i = 1; i <= 7; i++) {
        term = term * 10 + i;  // 生成当前项
        s += term;  // 累加到总和
    }

    printf("s = %lld\n", s);  // 输出结果
    return 0;
}

32.编写程序，输出下列形式的杨辉三角形的前10行
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

#include<stdio.h>
#define MAXSIZE 10
int main(){
    // 输出杨辉三角形前10行
    int i,j;
    // 存放杨辉三角二维数组
    int a[MAXSIZE][MAXSIZE];
    for (i = 0; i < MAXSIZE; i++){
        for(j = 0; j <= i; j++){
            // 杨辉三角每行第一个和最后一个元素为1
            if (j == 0 || j == i){
                a[i][j] = 1;
            }else{
                // 利用性质：当前数=上行两个数相加
                a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
            }
        }
    }
    // 打印杨辉三角形
    for (i = 0; i < MAXSIZE; i++){
        for(j = 0; j <= i; j++){
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

33、打印输出由1，2，3，4四个数字组成的4位数，并统计它的个数(允许该4位数中有相同的数字，例如：1111，1122，,1212等)。

#include<stdio.h>
int main(){
    int i,j,k,l;
    // 统计个数
    int cnt = 0;
    for (i = 1; i <= 4; i++){
        for (j = 1; j <= 4; j++){
            for (k = 1; k <= 4; k++){
                for (l = 1; l <= 4; l++){
                    printf("%d%d%d%d ", i, j, k, l);
                    cnt++;
                    if (cnt % 8 == 0){
                        printf("\n");
                    }
                }
            }
        }
    }
    printf("\n总共有%d个", cnt);
    return 0;
}

34、从键盘输入10个正整数进行求和，如果错误地输入了负数，则求和结束。请分别用break和不用break编写相应程序。

#include<stdio.h>
int main(){
    // 统计个数， 求和
    int i = 0, sum = 0;
    // 读取键盘输入的数
    int x;
    // 使用break
    // for (i = 0; i < 10; i++){
    //     scanf("%d", &x);
    //     if (x < 0){
    //         break;
    //     }
    //     sum += x;
    // }
    
//不使用break
scanf("%d", &x);
    while (i < 10 && x >= 0){
        if (x >= 0){
            sum += x;
        }
        i++;
scanf("%d", &x);
    }
    printf("sum = %d\n", sum);
    return 0;
}

35. 勾股定理为：a2+b2=c2，编写程序，输出30以内满足上述关系的整数组合，例如3，4，5就是一个整数组合。

#include<stdio.h>
int main(){
    int i, j, k;
    for (i = 1; i <= 30; i++){
        for (j = i; j <= 30; j++){
            for (k = j; k <= 30; k++){
                if (i * i + j * j == k * k){
                    printf("%d,%d,%d\n", i, j, k);
                }
            }
        }
    }
    return 0;
}

36. 计算并输出500以内最大的10个素数之和。

#include <stdio.h>
#include <stdbool.h>

bool isPrime(int x);

int main() {
    int i;
    // 已经统计的素数个数
    int cnt = 0, sum = 0;
    for (i = 500; i >= 1; i--) {
        if (isPrime(i)) {
            cnt++;
            sum += i;
            if (cnt == 10) {
                break;
            }
        }
    }
    printf("sum = %d\n", sum);
    return 0;
}

// 判断x是否为素数
bool isPrime(int x) {
    // 小于等于 1 的数不是素数
    if (x <= 1) {
        return false;
    }
    // 2 是素数
    if (x == 2) {
        return true;
    }
    // 偶数不是素数
    if (x % 2 == 0) {
        return false;
    }
    // 检查奇数因子
    for (int i = 3; i * i <= x; i += 2) {
        if (x % i == 0) {
            return false;
        }
    }
    return true;
}

37. 请验证2000以内的哥德巴赫猜想，对于任何大于4的偶数均可以分解为两个素数之和。

#include <stdio.h>
#include <stdbool.h>
#define MAXSIZE 2000
bool isPrime(int x);

int main() {
    // 找到2000以内的素数
    int a[MAXSIZE], i, cnt = 0;
    // 素数数组下标
    int d1, d2;
    // 判断是否已经有结果
    int isAns = 0;
    for (i = 1; i <= MAXSIZE; i++){
        if (isPrime(i)){
            a[cnt++] = i;
        }
    }
    
    for (i = 4; i <= 2000; i+=2){
        isAns = 0;
        for(d1 = 0; d1 < cnt; d1++){
            for (d2 = d1; d2 < cnt; d2++){
                if (a[d1] + a[d2] == i){
                    printf("%d = %d + %d\n", i, a[d1], a[d2]);
                    isAns = 1;
                    break;
                }
            }
            if (isAns){
                break;
            }
        }
    }
    return 0;
}

// 判断x是否为素数
bool isPrime(int x) {
    // 小于等于 1 的数不是素数
    if (x <= 1) {
        return false;
    }
    // 2 是素数
    if (x == 2) {
        return true;
    }
    // 偶数不是素数
    if (x % 2 == 0) {
        return false;
    }
    // 检查奇数因子
    for (int i = 3; i * i <= x; i += 2) {
        if (x % i == 0) {
            return false;
        }
    }
    return true;
}

38. 编写程序：将一个正整数分解质因数。例如：输入90,打印出90=233*5

#include<stdio.h>
int isPrime(int x);
int main(){
    int x, i, flag = 0, tmp;
    scanf("%d", &x);
    tmp = x;
    printf("\n%d=", x);
    for (i = 2; i * i <= x; i++){
        // 如果i非素数，则下一轮循环
        if (!isPrime(i)){
            continue;
        }
        while (tmp % i == 0){
            if (flag == 0){
                flag = 1;
                printf("%d", i);
            }else{
                printf("*%d", i);
            }
            tmp /= i;
        }
    }
    // tmp为质数的情况
    if (tmp != 1){
        if (flag == 0) {
            printf("%d", tmp);
        } else {
            printf("*%d", tmp);
        }
    }
    return 0;
}

int isPrime(int x){
    // 默认是素数
    int i;
    // 1不是素数，2是素数
    if (x <= 1) return 0;
    if (x == 2) return 1;
    // 偶数(2除外)不是素数
    if (x % 2 == 0) return 0;
    // 检查非偶数因子
    for(i = 3; i* i <= x; i += 2){
        if (x % i == 0){
            return 0;
        }
    }
    return 1;
}

39. 编写程序，求一个正整数的位数（提示：关系表达式的值可以参与算术运算）。

#include<stdio.h>
int main(){
    long x, tmp;
    int cnt = 0;
    scanf("%ld", &x);
    tmp = x;
    while(tmp > 0){
        cnt++;
        tmp = tmp / 10;
    }
    printf("%ld是%d位数\n", x, cnt);
    return 0;
}

40、求一个3×3的整数矩阵的副对角线上所有奇数的和sum2。

#include<stdio.h>
int main(){
    int a[3][3], i, j;
    int sum = 0;
    printf("输入一个3*3的矩阵。\n");
    for (i = 0; i < 3; i++){
        for (j = 0; j < 3; j++){
            scanf("%d", &a[i][j]);
            if(i + j == 2 && a[i][j] % 2 == 1){
                sum += a[i][j];
            }
        }
    }
    printf("矩阵副对角线上所有奇数和=%d\n", sum);
    return 0;
}

41-50

41、输入一个正整数n（1<n≤10），再输入n个整数，请编程实现：
⑴ 输出这些数的平均值（保留2位小数）。
⑵ 把这些数逆序后再输出。
⑶ 输出它们中的最大值及其下标（设最大值唯一，下标从0开始）。
⑷ 将它们中的最小值与第一个数交换，最大值与最后一个数交换，然后输出交换后的n个数。

#include <stdio.h>
#define MAXSIZE 10

// 交换数组中下标为i和j的元素
void swap(int a[], int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

int main() {
    // n-整数个数
    int n, i, a[MAXSIZE];
    float aver = 0;

    printf("输入一个正整数n(1 < n <= 10)。\n");
    scanf("%d", &n);

    if (n <= 1 || n > 10) {
        printf("非法参数n！n的取值范围是1 < n <= 10。");
        return 1;
    }

    printf("输入%d个整数。\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        aver += a[i];
    }

    printf("平均值=%.2f\n", aver / n);

    // 逆序输出数组
    printf("逆序输出: ");
    for (i = n - 1; i >= 0; i--) {
        printf("%d ", a[i]);
    }
    printf("\n");

    // 查找最大值和最小值的下标
    int maxIndex = 0, minIndex = 0;
    for (i = 1; i < n; i++) {
        if (a[i] > a[maxIndex]) {
            maxIndex = i;
        }
        if (a[i] < a[minIndex]) {
            minIndex = i;
        }
    }

    printf("最大值%d,下标%d\n", a[maxIndex], maxIndex);

    // 交换最大值和最小值到指定位置
    printf("交换后: ");
    if (maxIndex != n - 1) {
        swap(a, maxIndex, n - 1);
    }
    if (minIndex != 0) {
        swap(a, minIndex, 0);
    }
    for (i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

42. 定义一个含有30个整型元素的数组a，按顺序分别赋予从2开始的偶数；然后按顺序每5个数求出一个平均值，放在另一个数组b中存储，输出数组b中6个元素的值。

#include <stdlib.h>
 
int main()
{
    int a[30], b[6];
    int i, j = 0;
    for (i = 0; i < 30; i++){
        a[i] = 2 * (i + 1);
    } 
    float aver = 0;
    for (i = 0; i < 30; i++){
        if (i % 5 == 0){
            aver = 0;
        }
        aver += a[i];
        if (i % 5 == 4){
            b[j++] = aver / 5;
        }
    }
    for (j = 0; j < 6; j++){
        printf("%d ", b[j]);
    }
    return 0;
}

43. 通过循环按行顺序为一个5×5的二维数组a赋1到25的自然数，然后输出该数组的左下半角元素的值。

#include <stdlib.h>
 
int main()
{
    int a[5][5];
    int i,j, k = 1;
    for (i = 0; i < 5; i++){
        for (j = 0; j < 5; j++){
            a[i][j] = k;
            k++;
        }
    }
    for (i = 0; i < 5; i++){
        for (j = 0; j <= i; j++){
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

44. 从键盘输入两个字符串a和b，要求不使用库函数strcat，把串b的前5个字符连接到串a中；如果b中的长度小于5，则把b的所有元素都连接到a中。

#include <stdlib.h>
#define MAXSIZE 128 
int main()
{
    char a[MAXSIZE], b[MAXSIZE];
    fgets(a, MAXSIZE, stdin);  // 替换 gets(a)
    fgets(b, MAXSIZE, stdin);  // 替换 gets(b)
    int i, j;
    for (i = 0; a[i] != '\0'; i++);
    for (j = 0; b[j] != '\0' && j < 5; j++){
        a[i + j] = b[j];
    }
    printf("\n字符串a:");
    puts(a);
    printf("\n字符串b:");
    puts(b);
    return 0;
}

45. 定义两个N行N列的二维数组a、b，编写程序，将a数组最后一行放到b数组的第0列中，把a数组中的第0行放到b数组的最后一列中，b所指二维数组中其他元素的数据不变。（假设本题为N=3）

#include <stdlib.h>
#define N 3
int main()
{
    int a[N][N], b[N][N];
    int i, j;
    printf("输入二位数组(%d*%d)a:", N, N);
    for (i = 0; i < N; i++){
        for (j = 0; j < N; j++){
            scanf("%d", &a[i][j]);
        }
    }
    printf("输入二位数组(%d*%d)b:", N, N);
    for (i = 0; i < N; i++){
        for (j = 0; j < N; j++){
            scanf("%d", &b[i][j]);
        }
    }
    for (i = 0; i < N; i++){
        b[i][0] = a[N - 1][i];
    }
    for (i = 0; i < N; i++){
        b[i][N - 1] = a[0][i];
    }
    printf("\n数组b:\n");
    for (i = 0; i < N; i++){
        for (j = 0; j < N; j++){
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
    return 0;
}

46. 一个整型数组有10个元素，编写程序删除所有值为n的元素。要求①主函数完成n的输入，数组元素的输入以及进行删除后数组元素的输出。②子函数完成删除功能。

#include <stdio.h>
#define MAXSIZE 10
int func(int a[], int n, int length);
int main()
{
    int a[MAXSIZE], n, i, j;
    printf("输入数组元素(长度%d):", MAXSIZE);
    for (i = 0; i < MAXSIZE; i++){
        scanf("%d", &a[i]);
    }
    printf("\n待删除元素n:");
    scanf("%d", &n);
    int newLength = func(a, n, MAXSIZE);
    printf("\n删除后新数组：");
    for (j = 0; j < newLength; j++){
        printf("%d ", a[j]);
    }
    return 0;
}

// 数组a中删除元素n,length为数组长度
// 返回值为新数组长度
int func(int a[], int n, int length){
    int i, j = 0; 
    for (i = 0; i < length; i++){
        if (a[i] != n){
            a[j] = a[i];
            j++;
        }
    }
    return j;
}

47. 试编程实现如下功能：先定义一个4行5列的数组（矩阵），调用库函数rand()随机产生20-50之间的整数给数组元素赋值，再将矩阵中第二列与第四列的元素互换。要求先输出原数组，再输出交换后的数组。（rand函数的使用请参阅教材259页）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
    int a[4][5], i, j, tmp;
    // 生成随机数种子
    srand(time(NULL));
    for (i = 0; i < 4; i++){
        for (j = 0; j < 5; j++){
            // 产生20-50之间的整数并赋值
            a[i][j] = rand() % 31 + 20;
        }
    }
    // 输出原数组
    printf("---原数组---\n");
    for (i = 0; i < 4; i++){
        for (j = 0; j < 5; j++){
            printf("%4d", a[i][j]);
        }
        printf("\n");
    }
    
    // 交换第二列和第四列(下标从0开始，则实际交换下标为1,3列)
    for (i = 0; i < 4; i++){
        tmp = a[i][1];
        a[i][1] = a[i][3];
        a[i][3] = tmp;
    }
    
    // 输出交换后的数组
    printf("---交换后数组---\n");
    for (i = 0; i < 4; i++){
        for (j = 0; j < 5; j++){
            printf("%4d", a[i][j]);
        }
        printf("\n");
    }
    

    return 0;
}

48. 已知一组整型数据已按从小到大排列好，现任意输入一个整数，请按原来排序的规律将它插入到数组中(例如:原来的一组整数为1,3,5,8,9,若输入的整数是7,则最终的结果为: 1,3,5,7,8,9)。

#include <stdio.h>
int main() {
    // 已排好的数组
    int a[6] = {1, 3, 5, 7, 9};
    // 待插入的整数x, x在新数组的下标， i用于遍历数组
    int x, xIndex = 0, i;
    printf("输入一个整数:");
    scanf("%d", &x);
    // 确定x待插入的下标
    for (i = 0; i < 5; i++){
        if (a[i] < x){
            xIndex++;
        }
    }
    // xIndex下标及以后元素往右移动
    for (i = 4; i >= xIndex; i--){
        a[i + 1] = a[i];
    }
    a[xIndex] = x;
    // 输出新数组
    printf("新数组:");
    for (i = 0; i < 6; i++){
        printf("%d ", a[i]);
    }
    return 0;
}

49. 编写程序实现对字符串的加密，要求从键盘输入一个字符串，输出加密之后的字符串。
    加密规则为：对于串中第奇数个字符，若是字母，则把该字母变为它后面的字母（若为Z则变为A），不是字母则不变；对于偶数个字符，若是字母，则把该字母变为它前面的字母（若为A则变为Z），不是字母则不变；大小写字母都遵循此规则。例如：
    若原字符串是：AbbaZG Ha-MnnK Yzx
    加密字符串为：BaczAF Gb-NmoJ Xaw

#include <stdio.h>
#define MAXSIZE 64
void encodeString(char s1[], char s2[]);
int main() {
    char s[MAXSIZE];
    char decodedS[MAXSIZE];
    
    printf("\n原字符串:");
    fgets(s, sizeof(s), stdin);
    // 翻译工作（由于下标从0开始，下标为偶数->字符串奇数个字符；奇数情况相反）
    encodeString(s, decodedS);
    printf("\n加密后的字符串:");
    printf("%s", decodedS);
    return 0;
}

void encodeString(char s1[], char s2[]){
    int i;
    for (i = 0; s1[i] != '\0'; i++){
        if (i % 2 == 0){
            // 下标为偶数->第奇数个字符情况
            if(s1[i] == 'Z'){
                s2[i] = 'A';
            }else if (s1[i] == 'z'){
                s2[i] = 'a';
            }else if ((s1[i] >= 'A' && s1[i] < 'Z') ||(s1[i] >= 'a' && s1[i] < 'z')){
                s2[i] = s1[i] + 1;
            }else{
                s2[i] = s1[i];
            }
        }else{
            // 下标为奇数->第偶数个字符情况
            if(s1[i] == 'A'){
                s2[i] = 'Z';
            }else if (s1[i] == 'a'){
                s2[i] = 'z';
            }else if ((s1[i] > 'a' && s1[i] <= 'z') ||(s1[i] > 'A' && s1[i] <= 'Z')){
                s2[i] = s1[i] - 1;
            }else{
                s2[i] = s1[i];
            }
        }
    }
    s2[i] = '\0';
}

50. 编写程序：输入一个整数，输出该整数的平方螺旋矩阵。例如输入4，则输出：
    1 2 3 4
    12 13 14 5
    11 16 15 6
    10 9 8 7

#include <stdio.h>

int main() {
    int n = 0;
    do{
        printf("输入一个正整数:\n");
        scanf("%d", &n);
    }while(n <= 0);
    
    int a[n][n];
    int top = 0, bottom = n - 1;
    int left = 0, right = n - 1;
    int i, j = 1;
    // 生成平方螺旋矩阵
    while (top <= bottom && left <= right){
        // 从左到右
        for (i = left; i <= right; i++){
            a[top][i] = j++;
        }
        top++;
        // 从上到下
        for (i = top; i <= bottom; i++){
            a[i][right] = j++;
        }
        right--;
        // 从右到左
        for (i = right; i >= left; i--){
            a[bottom][i] = j++;
        }
        bottom--;
        // 从下到上
        for (i = bottom; i >= top; i--){
            a[i][left] = j++;
        }
        left++;
    }
    printf("\n%d阶平方螺旋矩阵为:\n", n);
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            printf("%4d", a[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

51-60

51. 编写字符串拷贝程序，并要求将字符串中的小写字母转换成大写字母。

#include <stdio.h>
#include <ctype.h> // 包含 toupper 函数
#include <string.h>
#define MAXSIZE 64
int main()
{
    char a[MAXSIZE], b[MAXSIZE];
    int i;
    // 输入字符串a
    printf("输入字符串a:");
    // fgets会导致末尾多一个换行符
    fgets(a, sizeof(a), stdin);
    a[strcspn(a, "\n")] = '\0';
    // 拷贝
    for (i = 0; a[i] != '\0'; i++)
    {
        // 小写字母转换成大写字母
        b[i] = toupper(a[i]);
    }
    b[i] = '\0'; // 添加字符串终止符
    // 输出字符串b
    printf("\n拷贝后的字符串b:");
    puts(b);

    return 0;
}

52、输入一个以回车结束的字符串（少于80个字符），将该字符串逆序后输出。

#include <stdio.h>
#define MAXSIZE 80
int main() {
    char a[MAXSIZE];
    printf("输入字符串，以回车结束:");
    fgets(a, sizeof(a), stdin);
    int i;
    // 找到a[i] \0对应下标
    for (i = 0; a[i] != '\0'; i++);
    
    // 逆序输出
    printf("\n逆序后的字符串为:");
    for (i = i - 1;i >= 0; i--){
        printf("%c", a[i]);
    }
    return 0;
}

53、输入一个以回车结束的字符串（少于80个字符），再输入一个字符，统计并输出该字符在字符串中出现的次数，然后再输出该字符串。

#include <stdio.h>
#define MAXSIZE 80
int main() {
    char a[MAXSIZE], c;
    int i, count = 0;
printf("输入一个字符串，以回车结束:");
// printf 中误用 a 作为参数，且未处理 fgets 后的换行符干扰 scanf 输入
fgets(a, sizeof(a), stdin);
// 移除 fgets 读取的换行符
a[strcspn(a, "\n")] = '\0';    
printf("\n输入一个字符:");
    scanf("%c", &c);
    // 统计并输出字符在字符串中的出现次数
    for (i = 0; a[i] != '\0'; i++){
        if (a[i] == c){
            count++;
        }
    }
    printf("\n%c出现次数:%d", c, count);
    // 输出字符串
    printf("\n字符串:");
    puts(a);
    return 0;
}

54. 编写程序：输入一行英文字符串，统计单词的个数（单词和单词以空格分隔）。

#include <stdio.h>
#define MAXSIZE 80
// 判断一个字符是否为英文字母
int isLetter(char c);
int main() {
    char a[MAXSIZE], c;
    int i, count = 0, inWord = 0;
    printf("输入一行英文字符串，以回车结束:");
    fgets(a, sizeof(a), stdin);
    // 判断英文单词：i为字母, i - 1为非字母或者字符串开头
    for (i = 0; a[i] != '\0'; i++){
        if (isLetter(a[i])) {
            if (!inWord) {  // 新单词开始
                count++;
                inWord = 1;
            }
        } else {
            inWord = 0;  // 非字母字符，标记为不在单词中
        }
    }
    printf("\n单词的个数:%d", count);
    return 0;
}
// 判断一个字符是否为英文字母
int isLetter(char c){
    if (c >= 'A' && c <= 'Z' || 
        c >= 'a' && c <= 'z'){
        return 1;        
    }else{
        return 0;
    }
}

55、用指针方法，编写一个函数,求矩阵主对角线元素之和Sum。

#include <stdio.h>
int main() {
    int a[3][3] = {
      {1,2,3},
      {4,5,6},
      {7,8,9},
    };
    // 数组元素首地址
    int *p = &a[0][0];
    int i, j, sum = 0;
    for (i = 0; i < 3; i++){
        for(j = 0; j < 3; j++){
            if (i == j){
                sum += *(p + 3 * i + j);
            }
        }
    }
    printf("\n主对角线元素之和Sum = %d\n", sum);
    return 0;
}

56、编一个程序，输入15个整数存入一维数组,按逆序存放后再输出(用指针完成)。

#include <stdio.h>
void swap(int *p, int *q);
int main() {
    printf("输入15个整数放入一维数组。\n");
    int a[15], i;
    int *p = a;
    // 存放
    for (i = 14; i >= 0; i--){
        scanf("%d", p + i);
    }
    // 逆序
    for (i = 0; i < 7; i++){
        swap(p + i, p + 14 - i);
    }
    // 输出
    for (i = 0; i <= 14; i++){
        printf("%d ", *(p + i));
    }
    return 0;
}

void swap(int *p, int *q){
    int tmp;
    tmp = *p;
    p = q;
    *q = tmp;
}

57、输入一个3×6的二维整型数组，输出其中最大值、最小值以及它们所在行和列的下标(用指针完成)。

#include <stdio.h>
int main() {
    printf("输入3*6的二维整型数组。\n");
    int a[3][6], i, j;
    int *p = &a[0][0];
    // 输入
    for (i = 0; i < 3; i++){
        for (j = 0; j < 6; j++){
            scanf("%d", p + 6 * i + j);
        }
    }
    // 找到最大最小值下标
    int maxRow = 0, maxCol = 0;
    int minRow = 0, minCol = 0;
    for (i = 0; i < 3; i++){
        for (j = 0; j < 6; j++){
            if(*(p+6*i+j) > *(p+6*maxRow+maxCol)){
                maxRow = i, maxCol = j;
            }
            if(*(p+6*i+j) < *(p+6*minRow+minCol)){
                minRow = i, minCol = j;
            }
        }
    }
    // 输出最大、最小值
    printf("\n最大值为%d, 行下标%d,列下标%d", *(p+6*maxRow+maxCol), maxRow, maxCol);
    printf("\n最小值为%d, 行下标%d,列下标%d", *(p+6*minRow+minCol), minRow, minCol);
    
    return 0;
}

58. 用指针编写程序实现：输入一个字符串，计算该字符串的长度，并统计该串中含小写字母、大写字母和其他字符的个数。

#include<stdio.h>
#define MAXSIZE 64
int main(){
    char a[MAXSIZE];
    int i, length, bigC = 0, smallC = 0, otherC = 0;
    // 输入字符串
    printf("输入字符串:");
    fgets(a, sizeof(a), stdin); // 换行符会保存
    // 统计字符串长度
    for (i = 0; *(a + i) != '\0'; i++){
        // 统计大小写字母和其他字符
        if (*(a + i) >= 'a' && *(a + i) <= 'z'){
            smallC++;
        }else if(*(a + i) >= 'A' && *(a + i) <= 'Z'){
            bigC++;
        }else{
            // 不包括换行符
            if (*(a + i) != '\n'){
                otherC++;
            }
        }
    }
    length = *(a + i - 1) == '\n' ? i - 1 : i;
    printf("\n字符串长度%d，小写字母%d个，大写字母%d个，其他字符%d个", length, smallC, bigC, otherC);
    return 0;
}

59. 用指针编写程序完成，将字符串a赋给一个字符数组，然后从第一个字母开始间隔地输出该串。

#include <stdio.h>

int main() {
    char a[] = "I love Programming!";
    int i;
    for (i = 0; *(a + i) != '\0'; i += 2){
        printf("%c", *(a + i));
    }

    return 0;
}

60. 编写一个指针型函数，从键盘接收一个1~7之间的整数，根据指定的数字，返回与该数字相对应的是星期几。例如数字6则返回Saturday。

#include <stdio.h>
char* func(char (*p)[16], int i);
int main() {
    // 应该使用双引号
    char s[7][16] = {"Monday", "Tuesday", "Wednesday", 
        "Thursday", "Friday", "Saturday", "Sunday"};
    // 指向的是每行有 16 个字符的数组
    char (*p)[16] = s;
    int i;
    printf("输入1~7之间的整数。\n");
    scanf("%d", &i);
    if (i < 1 || i > 7){
        printf("参数非法！应在1~7之间\n");
        return 1;
    }
    // 调用方式错误，应直接传递 p
    printf("\n%s\n", func(p, i));
    return 0;
}

char* func(char (*p)[16], int i){
    return p[i - 1];
}

61-70

61. 用指针编写程序实现，将一个字符串按逆序存放。要求①主函数中完成字符串的输入和输出。②子函数完成逆序存放。

#include <stdio.h>
#include <string.h>
void reverseString(char *p, int length);
int main() {
    char a[80], *p = a;
    printf("--输入字符串--\n");
    fgets(a, sizeof(a), stdin);
    reverseString(p, strlen(a));
    printf("--输出字符串--");
    puts(a);
    return 0;
}

// 将字符串逆序存放
void reverseString(char *p, int length){
    int i;
    char tmp;
    for (i = 0; i < length / 2; i++){
        tmp = *(p + i);
        *(p + i) = *(p + length - 1 - i);
        *(p + length - 1 - i) = tmp;
    }
}

62. 编写程序：定义一个10个元素的职工结构体数组（职工号、姓名、性别、出生年份、职务），从键盘输入数据后，输出年龄最大的和最小的职工信息。

#include<stdio.h>
struct Employee{
    char no[32]; // 职工号
    char name[64]; // 姓名
    char gender[16]; // 性别
    int birthYear; // 出生年份
    char post[64]; // 职务
};
int main(){
    struct Employee e[10];
    int i;
    // 记录年龄最大和最小员工序号
    int oddestNO = 0, youngestNO = 0;
    for (i = 0; i < 10; i++){
        printf("---输入第%d位职工信息---\n", i + 1);
        printf("职工号|姓名|性别|出生年份|职务\n");
        // 数组名本身就是地址，不需要加&;但int类型的birthYear需要加&
        scanf("%s%s%s%d%s", e[i].no, e[i].name, e[i].gender, &e[i].birthYear, e[i].post);
        if (e[i].birthYear < e[oddestNO].birthYear){
            oddestNO = i;
        }
        if (e[i].birthYear > e[youngestNO].birthYear){
            youngestNO = i;
        }
    }
    printf("\n---年龄最大的职工信息---\n");
    printf("职工号:%s\n", e[oddestNO].no);
    printf("姓名:%s\n", e[oddestNO].name);
    printf("性别:%s\n", e[oddestNO].gender);
    printf("出生年份:%d\n", e[oddestNO].birthYear);
    printf("职务:%s\n", e[oddestNO].post);
    printf("\n---年龄最小的职工信息---\n");
    printf("职工号:%s\n", e[youngestNO].no);
    printf("姓名:%s\n", e[youngestNO].name);
    printf("性别:%s\n", e[youngestNO].gender);
    printf("出生年份:%d\n", e[youngestNO].birthYear);
    printf("职务:%s\n", e[youngestNO].post);
    
    return 0;
}

63. 试利用指向结构体的指针编制一程序，实现输入三位学生的学号、姓名、数学期中和期末成绩，然后①求出每一位学生的平均成绩并输出成绩表②按成绩由高到底排序输出三位学生的相关信息。

#include <stdio.h>

typedef struct Student {
    char NO[32]; // 学号
    char name[64]; // 姓名
    float midScore, finalScore; // 期中成绩，期末成绩
    float averScore; // 平均成绩
}Student;
int main() {
    Student student[3];
    Student *s = student;
    int i, j;
    Student tmp;
    for (i = 0; i < 3; i++) {
        printf("\n---输入第%d位学生信息---\n", i + 1);
        printf("学号|姓名|期中成绩|期末成绩\n");
        scanf("%s%s%f%f", & s[i].NO, & s[i].name, & s[i].midScore, & s[i].finalScore);
        s[i].averScore = (s[i].midScore + s[i].finalScore) / 2;
    }
    // 输出成绩表
    for (i = 0; i < 3; i++) {
        printf("\n---学生%d的成绩表---", i + 1);
        printf("\n学号：%s", s[i].NO);
        printf("\n姓名：%s", s[i].name);
        printf("\n数学期中成绩：%.2f", s[i].midScore);
        printf("\n数学期末成绩：%.2f", s[i].finalScore);
        printf("\n平均成绩：%.2f", s[i].averScore);
    }
    // 按平均成绩给学生排序
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3 - i; j++) {
            if (s[j].averScore < s[j + 1].averScore) {
                tmp = s[j];
                s[j] = s[j + 1];
                s[j + 1] = tmp;
            }
        }
    }
    // 输出排好序后的成绩表
    printf("\n--排好序后---");
    for (i = 0; i < 3; i++) {
        printf("\n---学生%d的成绩表---", i + 1);
        printf("\n学号：%s", s[i].NO);
        printf("\n姓名：%s", s[i].name);
        printf("\n数学期中成绩：%.2f", s[i].midScore);
        printf("\n数学期末成绩：%.2f", s[i].finalScore);
        printf("\n平均成绩：%.2f", s[i].averScore);
    }
    return 0;
}

64. 有一个包括学生学号、姓名和三门课成绩的结构变量，要求在主函数中对该变量赋值，在另一个函数中将其值打印出来。

#include <stdio.h>
typedef struct Student{
    char No[64]; // 学号
    char name[64]; // 姓名
    float score[3]; // 三门课成绩
}Student;
void printStudentInfo(Student s);
int main() {
	Student s;
	printf("输入学生信息:\n");
	printf("学号\t姓名\t第一门课成绩\t第二门课成绩\t第三门课成绩\n");
	scanf("%s%s%f%f%f", &s.No, &s.name, &s.score[0], &s.score[1], &s.score[2]);
	printf("\n---打印学生信息---\n");
	printStudentInfo(s);
    return 0;
}
// 打印学生信息
void printStudentInfo(Student s){
    printf("学号\t姓名\t第一门课成绩\t第二门课成绩\t第三门课成绩\n");
    printf("%s\t%s\t%.2f\t%.2f\t%.2f", s.No, s.name, s.score[0], s.score[1], s.score[2]);
}

65. 定义一个函数，求200~5000之间满足“用4除余1，用5除余3，用7除余4”的数，且一行打印6个。

#include <stdio.h>

int main() {
    int i, cnt = 0;
    for (i = 200; i <= 5000; i++) {
        if (i % 4 == 1 && i % 5 == 3 &&
            i % 7 == 4) {
            cnt++;
            printf("%6d", i);
            if (cnt == 6) {
                cnt = 0;
                printf("\n");
            }
        }
    }
    return 0;
}

66. 编写函数isprime( )，用来判断一个整形数a是否为素数，若是素数，函数返回1，否则返回0。

#include <stdio.h>
// 忘记声明函数了
int isPrime(int a);
int main() {
    int a;
    scanf("%d", & a);
    if (isPrime(a)) {
        printf("%d是素数。\n", a);
    } else {
        printf("%d不是素数。\n", a);
    }
    return 0;
}

int isPrime(int a) {
    int i;
    // 如果a<=1，不是素数
    if (a <= 1) {
        return 0;
    } else if (a == 2) {
        // 2是素数
        return 1;
    } else if (a % 2 == 0) {
        // 偶数(除2)不是素数
        return 0;
    } else {
        for (i = 3; i * i <= a; i += 2) {
            if (a % i == 0) {
                return 0;
            }
        }
        return 1;
    }

}

67. 在主函数main()中已有变量定义和函数调用语句：“int a=1，b= -5，c； c=fun (a ，,b)”； fun函数的作用是计算两个数之差的绝对值，并将差值返回调用函数。请你：
    (1) 编写fun函数。
    fun(int x , int y) { }
    (2) 写出这个主函数main()

#include <stdio.h>
int fun(int x, int y);
int main() {
	int a = 1, b = -5, c;
	// 计算两个数之差的绝对值
	c = fun(a, b);
	printf("%d", c);
    return 0;
}
// 计算两个数之差的绝对值
int fun(int x, int y){
    return (x >= y) ? x - y : y - x;
}