2026年专升本学生80个c语言代码合集.(从小白到熟练运用c语言的全过程)(持续更新)

引言:希望能够帮助刚刚接触代码的同学 感谢支持!!!

1.hello word

#include <stdio.h> int main() { printf ("Hello Word"); return 0; }

2.变量的定义以及scanf输入 printf输出 函数的调用

#include <stdio.h> int main() { int a=0; int b=0; scanf("a=%d b=%d", &a,&b); printf("%d %d\n", a,b); return 0; }

3.通过使用中间变量来交换两个变量的值

#include <stdio.h> int main() { int a=5; int b=6; int t; t=a; a=b; b=t; printf("a=%d b=%d",a,b); return 0; }

4.这段代码的实现的功能是：

1. 输入一个用HHMM格式表示的时间（比如1430代表14点30分）和一个分钟数
2. 将HHMM格式的时间分解为小时和分钟
3. 将这个时间转换为总分钟数
4. 加上输入的分钟数
5. 再将总分钟数转换回小时和分钟格式并输出

例如：如果输入t=1430（代表14:30），t1=45（代表增加45分钟），则输出15 15（代表15:15）。

#include <stdio.h> int main() { int time_input, minutes_to_add, hours, minutes, total_minutes; scanf("%d %d", &time_input, &minutes_to_add); // 输入时间(HHMM格式)和要增加的分钟数 hours = time_input / 100; // 提取小时部分 minutes = time_input % 100; // 提取分钟部分 total_minutes = (hours * 60) + minutes + minutes_to_add; // 转换为总分钟数并加上要增加的分钟 printf("%d %d", total_minutes / 60, total_minutes % 60); // 输出结果（小时和分钟） return 0; }

5.

这段代码的功能是：

1. 接收用户输入的一个整数（代表考试分数）
2. 根据分数范围判断对应的等级：
   • 90分及以上 → A级
   • 80-89分 → B级
   • 70-79分 → C级
   • 60-69分 → D级
   • 60分以下 → E级（不及格）

最后输出相应的等级字母。这是一个典型的百分制成绩转五级制等级的程序。

#include <stdio.h> int main() { int x = 0; scanf("%d", &x); // 输入一个分数 if(x >= 90){ // 如果分数大于等于90分 printf("A"); // 输出A等级 }else if(x >= 80){ // 否则如果分数大于等于80分 printf("B"); // 输出B等级 }else if(x >= 70){ // 否则如果分数大于等于70分 printf("C"); // 输出C等级 }else if(x >= 60){ // 否则如果分数大于等于60分 printf("D"); // 输出D等级 }else{ // 否则如果分数小于60分 printf("E"); // 输出E等级 } return 0; }

6.

这段代码的功能是：

1. 接收用户输入的一个整数（代表考试分数）
2. 将分数除以10，获取分数的十位数
3. 根据十位数的值，通过switch语句判断对应的等级：
   • 分数在90-100分 → A级
   • 分数在80-89分 → B级
   • 分数在70-79分 → C级
   • 分数在60-69分 → D级
   • 分数在0-59分 → E级（不及格）

这种方法通过整数除法和switch语句来实现成绩分级，比连续的if-else语句更加简洁。

#include <stdio.h> int main() { int score; scanf("%d", &score); // 输入一个分数 score /= 10; // 将分数除以10，得到十位数 switch(score) { case 10: // 如果十位数是10（即原分数为100-109分，实际为100分以内） case 9: // 如果十位数是9（即原分数为90-99分） printf("A\n"); break; case 8: // 如果十位数是8（即原分数为80-89分） printf("B\n"); break; case 7: // 如果十位数是7（即原分数为70-79分） printf("C\n"); break; case 6: // 如果十位数是6（即原分数为60-69分） printf("D\n"); break; default: // 其他情况（即原分数低于60分） printf("E\n"); break; } return 0; }

7.(这个srand函数山西专升本是不会考到的下面这个是个趣味练习,感兴趣的同学可以研究研究)

这段代码的功能是：

1. 初始化随机数发生器，使用当前时间作为种子
2. 生成一个1到100之间的随机数作为目标数字
3. 进入循环，让用户不断猜测数字
4. 每次猜测后给出提示：
   • 如果猜的数字比目标数字大，输出"猜的数字大了"
   • 如果猜的数字比目标数字小，输出"猜的数字小了"
5. 记录用户猜测的次数
6. 当用户猜中数字后，输出总共猜测的次数

这是一个经典的猜数字游戏，用户需要通过系统给出的提示逐步缩小范围，最终猜出正确的数字。

#include <stdio.h> #include <stdlib.h> #include <time.h> int main() { srand(time(0)); // 使用当前时间作为随机数种子 int number = rand() % 100 + 1; // 生成1到100之间的随机数 int count = 0; // 记录猜测次数 int a = 0; // 存储用户输入的猜测值 printf("已经想好一个1到100之间的数\n"); do { printf("请猜取1到100以内的数: "); scanf("%d", &a); count++; // 猜测次数加1 if(a > number) { printf("猜的数字大了\n"); } else if(a < number) { printf("猜的数字小了\n"); } } while(a != number); // 继续循环直到猜中 printf("恭喜你猜了%d次猜到了答案\n", count); return 0; }

8.这段代码的功能是：

1. 初始化变量：用于存储总和(sum)、计数(count)
2. 不断接收用户输入的整数
3. 当输入的数字不是-1时，将其累加到总和中，并增加计数
4. 当输入-1时停止输入（-1作为结束标志）
5. 计算所有输入数字的平均值并输出

例如，如果用户依次输入：10 20 30 -1，则程序会计算(10+20+30)/3=20.00并输出。

#include <stdio.h> int main() { int number; // 存储用户输入的数字 int sum = 0; // 存储所有数字的总和 int count = 0; // 计算输入的数字个数 scanf("%d", &number); // 读取第一个数字 while(number != -1) { // 当输入的数字不是-1时继续循环 sum += number; // 将当前数字加入总和 count++; // 数字个数加1 scanf("%d", &number); // 读取下一个数字 } if(count > 0) { // 避免除零错误 printf("%.2f\n", 1.0 * sum / count); // 计算并输出平均值 } else { printf("没有输入有效数据\n"); } return 0; }

9.这段代码的功能是反转一个正整数的各位数字。

#include <stdio.h> int main() { int x; int ret = 0; // 存储反转后的结果 int digit; // 存储当前处理的数字 scanf("%d", &x); // 输入一个正整数 while(x > 0) { // 当x还大于0时继续循环 digit = x % 10; // 获取x的最后一位数字 ret = ret * 10 + digit; // 将这一位数字添加到结果中 printf("ret=%d digit=%d x=%d\n", ret, digit, x); x /= 10; // 去掉x的最后一位数字 } return 0; }

10.这段代码的功能是计算一个数的阶乘:

#include <stdio.h> int main() { int n = 5; // 要计算阶乘的数 int factor = 1; // 存储阶乘结果，初始为1 int original_n = n; // 保存原始值用于输出 // scanf("%d", &n); // 如果需要用户输入的话 while(n > 0) { factor *= n; // 将n乘到factor上 n--; // n减1 } printf("%d!=%d\n", original_n, factor); // 输出阶乘结果 return 0; }

11.

这段代码的功能是：

1. 接收用户输入一个整数x
2. 判断x是否为素数（只能被1和自身整除的大于1的自然数）
3. 从2开始到x-1逐一检查是否能整除x
4. 如果找到任何一个因子，则x不是素数
5. 输出判断结果

​ #include <stdio.h> int main() { int x; scanf("%d", &x); int isprime = 1; // 假设x是素数 int i; // 特殊情况处理：小于2的数不是素数 if (x < 2) { isprime = 0; } else { // 从2开始检查到x-1，看是否有能整除x的数 for(i = 2; i < x; i++) { if(x % i == 0) { // 如果找到一个因子 isprime = 0; // 标记为不是素数 break; // 可以提前退出循环 } } } // 注意：这里原代码用的是赋值操作符=，应该是比较操作符== if(isprime == 1) { // 修正：使用比较操作符 printf("%d是素数\n", x); } else { printf("%d不是素数\n", x); } return 0; } ​

12.这段代码的功能是：在双向循环链表中插入一个子链表。

void insert(DLinkList &ha, DLinkList &hb, int i) { int pos = i; DNode *pa; // 找到插入位置的节点 if(i == 0) pa = ha; // 如果插入位置是0，则插入到头节点之后 else { pa = ha->next; // 从头节点的下一个开始查找 // 向后移动i个位置或直到回到头节点 while(pa != ha && --i > 0) pa = pa->next; } // 如果到达头节点但pos>0，说明位置超出范围，调整到尾部 if(pa == ha && pos > 0) pa = ha->pred; // 移动到尾节点 // 执行插入操作 - 将hb链表插入到pa节点之后 hb->pred->next = pa->next; // hb尾部连接到pa的下一个 pa->next->pred = hb->pred; // pa的下一个连接到hb尾部 pa->next = hb->next; // pa连接到hb头部 hb->next->pred = pa; // hb头部连接到pa // 释放hb的头节点（因为hb已经被插入到ha中） free(hb); }

13.这段代码的功能是找出三个数中的最大值

#include <stdio.h> int main() // 修正：mian -> main { int a, b, c; scanf("%d %d %d", &a, &b, &c); // 修正：移除多余的空格 if (a > b) { if (c > a) { printf("%d", c); // c > a > b，所以c最大 } else { printf("%d", a); // a > b 且 a >= c，所以a最大 } } else { // 即 a <= b if (c > b) { printf("%d", c); // c > b >= a，所以c最大 } else { printf("%d", b); // b >= c 且 b >= a，所以b最大 } } return 0; }

15.这段代码的功能是将24小时制时间转换为12小时制时间并添加AM/PM标识

这段代码的逻辑是：

1. 输入小时和分钟
2. 根据小时数判断时间段并转换为12小时制：
   • 0-11点：AM（上午），其中0点显示为12AM
   • 12点：12PM（中午）
   • 13-23点：PM（下午），减去12转换为12小时制
   • 24点：特殊处理为0AM（午夜）

#include <stdio.h> int main() { int hour; int min; scanf("%d %d", &hour, &min); // 输入小时和分钟 if (hour >= 0 && hour < 12) { // 修正：应该是hour<12而不是min<12 if(hour == 0) { printf("12:%dAM", min); // 0点显示为12AM } else { printf("%d:%dAM", hour, min); } } else if (hour == 12) { printf("%d:%dPM", hour, min); // 12点显示为12PM } else if (hour == 24) { printf("%d:%dAM", hour-24, min); // 24点显示为0AM（即午夜） } else { // hour > 12 且 hour < 24 if(hour > 12 && hour < 24) { printf("%d:%dPM", hour-12, min); // 下午时间转换 } } return 0; }

16.这段代码的功能是生成由连续数字组成的三位数排列组合

• 百位可选：A, A+1, A+2, A+3（4个数字）
• 十位和个位可选：A, A+1, A+2（3个数字）
• 但要求i, j, k三个数字互不相同
• 将三个数字组成三位数：i100 + 10j + k

例如，如果输入A=1，则会生成由1,2,3这三个数字组成的不重复三位数的所有排列：123, 132, 213, 231, 312, 321等。

#include <stdio.h> int main() { int A, i, j, k, p = 0; scanf("%d", &A); // 输入起始数字A // 三层嵌套循环生成三位数组合 for(i = A; i < A + 4; i++) // 百位数字：A, A+1, A+2, A+3 (共4个数字) for(j = A; j < A + 3; j++) // 十位数字：A, A+1, A+2 (共3个数字) for(k = A; k < A + 3; k++) // 个位数字：A, A+1, A+2 (共3个数字) { // 确保三个数字各不相同（排列而非组合） if(i != j && i != k && j != k) { printf("%d", i*100 + 10*j + k); // 组合成三位数并输出 p++; // 计数器加1 if(p % 6 == 0) // 每输出6个数字换行 printf("\n"); else printf(" "); // 否则输出空格分隔 } } return 0; }

17.这段代码试图实现寻找水仙花数

1. 输入一个数字N，表示要查找N位数中的水仙花数
2. 水仙花数是指一个N位数，其各位数字的N次方之和等于该数本身
3. 例如：153 = 1³ + 5³ + 3³ = 1 + 125 + 27 = 153

#include <stdio.h> #include <math.h> int main() { int N; scanf("%d", &N); // N是数字的位数 // 计算N位数的范围 int start = 1; for(int i = 1; i < N; i++) { start *= 10; // N位数的起始值，如3位数从100开始 } int end = start * 10 - 1; // N位数的结束值，如3位数到999结束 printf("查找%d位数中的水仙花数:\n", N); // 遍历所有N位数 for(int num = start; num <= end; num++) { int temp = num; int sum = 0; // 计算每位数字的N次方之和 while(temp > 0) { int digit = temp % 10; // 获取最后一位数字 sum += pow(digit, N); // 将该数字的N次方加到sum中 temp /= 10; // 去掉最后一位 } // 如果每位数字的N次方之和等于原数，则为水仙花数 if(sum == num) { printf("%d\n", num); } } return 0; }

18.

这段代码计算的是以下序列的和：

• 分数序列：1/2 + 2/3 + 3/4 + 4/5 + ... + N/(N+1)
• 即：Σ(i-1)/i，其中i从2到N+1

#include <stdio.h> int main() { int N; scanf("%d", &N); double i = 2.0; // 分母从2开始 int j = 0; // 循环计数器 int numerator; // 分子 double sum = 0.0; // 总和 while(j <= N) { numerator = (int)i - 1; // 分子是分母减1 sum += (double)numerator / i; // 累加分数 i++; // 分母递增 j++; // 计数器递增 } printf("%.2lf", sum); return 0; }

19.这段代码的功能是打印乘法口诀表（九九乘法表的一部分）

例如:

这段代码的功能是：

1. 输入一个数字i，决定打印多少行乘法表
2. 逐行打印乘法表，每行b显示从1b到bb的乘法
3. 格式化输出，使表格整齐对齐
4. 两位数结果占3个空格，一位数结果占4个空格

例如，如果输入4，输出将是：

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

1*4=4 2*4=8 3*4=12 4*4=16

#include <stdio.h> int main(){ int i = 0; int b = 1; scanf("%d", &i); // 输入要打印的行数 while(b <= i){ int j = 1; while(j <= b){ printf("%d*%d=%d", j, b, j*b); // 输出乘法表达式 if (j*b >= 10){ printf(" "); // 两位数后面加3个空格 } else { printf(" "); // 一位数后面加4个空格 } j++; } printf("\n"); // 换行 b++; } return 0; }

20.这段代码的功能是统计给定范围内素数的个数以及这些素数的总和。

1. 输入两个整数m和n，表示范围[m, n]
2. 找出范围内所有的素数
3. 计算这些素数的总和和个数
4. 输出总和和个数

#include <stdio.h> #include <math.h> int main() { int m, n; scanf("%d %d", &m, &n); int prime_count = 0; // 素数个数 int prime_sum = 0; // 素数总和 int i; // 处理特殊情况：如果范围包含2，2是素数 if(m <= 2 && n >= 2) { prime_sum += 2; prime_count++; m = 3; // 从3开始检查奇数 } else { if(m < 2) m = 2; // 素数从2开始 } // 从m开始遍历到n while(m <= n){ int is_prime = 1; // 假设是素数 // 1不是素数 if(m == 1) { is_prime = 0; } else { // 检查是否为素数：只需检查到sqrt(m) for(i = 2; i * i <= m; i++){ if(m % i == 0){ is_prime = 0; break; } } } if(is_prime == 1){ prime_sum += m; prime_count++; } if(m == 2) { m++; // 2之后检查3 } else { m += 2; // 之后只检查奇数 } } printf("%d %d", prime_sum, prime_count); return 0; }

21.经典的"百钱买百鸡"问题

"百钱买百鸡"问题的数学模型：

• 公鸡每只5文钱，母鸡每只3文钱，小鸡3只1文钱
• 要求用100文钱买100只鸡
• 设公鸡x只，母鸡y只，小鸡z只

#include <stdio.h> int main() { int x, y, z; // x=公鸡数量, y=母鸡数量, z=小鸡数量 printf("百钱买百鸡问题的解：\n"); printf("公鸡数量 母鸡数量 小鸡数量\n"); // 根据约束条件求解 // 约束1: x + y + z = 100 (总共100只鸡) // 约束2: 5x + 3y + z/3 = 100 (总共100文钱，z必须是3的倍数) // 约束3: 15x + 9y + z = 300 (等价于约束2乘以3) for(x = 0; x <= 20; x++) { // 公鸡最多买20只(100/5) for(y = 0; y <= 33; y++) { // 母鸡最多买33只(100/3) z = 100 - x - y; // 由约束1得出小鸡数量 // 检查是否满足约束条件 if(z >= 0 && z % 3 == 0 && 15*x + 9*y + z == 300) { printf("公鸡为%d, 母鸡为%d, 小鸡为%d\n", x, y, z); } } } return 0; }

22.这段代码的功能是统计给定区间[M,N]内素数的个数以及这些素数的总和

1. 输入区间[M, N]
2. 遍历区间内每个数，判断是否为素数
3. 统计素数的个数和所有素数的总和
4. 输出结果

#include <stdio.h> int main(){ int M, N; int a, b; int prime_count = 0; // 素数个数 int prime_sum = 0; // 素数总和 int flag; scanf("%d,%d", &M, &N); // 输入区间端点，格式为M,N for(a = M; a <= N; a++){ // 判断a是否是素数 flag = 1; // 特殊情况处理 if(a <= 1) { flag = 0; } else if(a == 2) { flag = 1; // 2是素数 } else { // 从2开始到a-1检查是否有因数 for(b = 2; b < a; b++){ if(a % b == 0){ flag = 0; break; } } } if(flag == 1){ prime_count++; prime_sum += a; } } printf("素数的个数%d,M和N区间素数的和%d\n", prime_count, prime_sum); return 0; }

23.要求:

1. 规则：
   • 如果前两数乘积≥10：将乘积分解为十位和个位，分别作为新的a和b，并输出两者
   • 如果前两数乘积<10：直接输出乘积，并更新a和b

2. 例如，如果输入2,3：

   • 开始：2 3
   • 2×3=6<10，输出6，a=3,b=6
   • 3×6=18≥10，输出1 8，a=1,b=8

3. 这段代码的逻辑是：

4. 输入两个起始数字a和b
5. 输出这两个数字
6. 从第3个数字开始，最多生成到第10个数字

#include <stdio.h> int main() { int a, b, c; scanf("%d,%d", &a, &b); // 输入前两个数字 int n; printf("%d %d ", a, b); // 输出前两个数字 for(n = 3; n <= 10; n++){ if(a * b >= 10) { c = a * b; // 计算前两数的乘积 a = c / 10; // 取乘积的十位数作为新的a b = c % 10; // 取乘积的个位数作为新的b n++; // 这里有个问题：n额外增加，影响循环次数 printf("%d %d ", a, b); // 输出这两个新数字 } else { c = a * b; // 计算前两数的乘积 printf("%d ", c); // 直接输出乘积 a = b; // 更新a为原来的b b = c; // 更新b为乘积 } } return 0; }

24.

这段代码的功能是找出1000以内的所有完数（完全数）。

完数（完全数）的定义：
一个正整数，如果它等于其所有真因子（即除了自身以外的所有正因子）的和，那么这个数就是完数。

1000以内的完数有：

• 6：因子为1, 2, 3，且 1 + 2 + 3 = 6
• 28：因子为1, 2, 4, 7, 14，且 1 + 2 + 4 + 7 + 14 = 28
• 496：因子和也等于496

所以程序会输出：6是完数 28是完数 496是完数

#include <stdio.h> int main(){ int i; int j; int sum; for(i = 2; i <= 1000; i++){ // 遍历2到1000的所有数字 sum = 0; // 初始化因子和为0 // 找出i的所有真因子（小于i且能整除i的正整数） for(j = 1; j < i; j++){ if(i % j == 0){ // 如果j是i的因子 sum += j; // 将因子j累加到sum中 } } // 如果所有真因子的和等于原数i，则i是完数 if(sum == i){ printf("%d是完数\n", i); } } return 0; }

25.这段代码的功能是使用数组生成并输出斐波那契数列的前21项。

斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...

这段代码的逻辑：

1. 定义一个数组a，初始化前两项为1（斐波那契数列的前两项）
2. 使用循环计算后续各项：每一项等于前两项之和
3. 输出整个数列，每行显示5个数字以保持格式整齐

#include <stdio.h> int main(){ // 使用数组存储斐波那契数列 int a[21] = {1, 1}; // 初始化前两项为1，注意数组大小改为21以避免越界 int i; // 计算斐波那契数列的后续项 for(i = 2; i < 21; i++) // 循环条件 a[i] = a[i-1] + a[i-2]; // 每一项等于前两项之和 // 输出数列，每行显示5个数字 for(i = 0; i < 21; i++){ // 循环条件 printf("%d ", a[i]); if((i+1) % 5 == 0) // 每输出5个数字就换行 printf("\n"); } return 0; }

26.这段代码的功能是计算10个数字去掉最大值和最小值后的平均值

1. 输入10个浮点数
2. 计算这10个数的总和
3. 找出其中的最大值和最小值
4. 计算去掉最大值和最小值后剩余8个数的平均值
5. 输出该平均值

#include <stdio.h> int main(){ double a[10]; double nub, i, min, max, sum = 0; // 输入10个数字并计算总和 for(nub = 1, i = 0; nub <= 10; nub++, i++){ scanf("%lf", &a[i]); // 修正：使用%lf读取double类型 sum += a[i]; } // 初始化最大值和最小值 max = a[0]; min = a[0]; // 查找最大值和最小值 for(i = 1; i < 10; i++){ if(max < a[i]) max = a[i]; if(min > a[i]) min = a[i]; } // 输出去掉最大值和最小值后的平均值 printf("%.2lf", (sum - max - min) / 8); return 0; }

27.这段代码主要关于函数的调用的功能包括：(这三个函数都是实现不同的功能并不互相调用两个递归函数一个判断素数函数)

1. latsem(x)函数：判断x是否为素数
2. laster(a)函数：递归计算 10 + 2*(a-1)，例如laster(5)=18
3. lasfei(x)函数：计算斐波那契数列的第x项
4. 主函数功能：
   • 计算斐波那契数列第8项
   • 调用laster函数
   • 找出101到200之间的所有素数并输出，每行显示10个

#include<stdio.h> // 判断是否为素数的函数 int latsem(int x) { int i; if(x <= 1) return 0; // 1及以下不是素数 if(x == 2) return 1; // 2是素数 if(x % 2 == 0) return 0; // 偶数不是素数 for(i = 2; i <= x - 1; i++) { if(x % i == 0) return 0; } return 1; } // 递归函数，计算10 + 2*(n-1) int laster(int a) { if(a == 1) return 10; return laster(a - 1) + 2; } // 斐波那契数列的递归实现 int lasfei(int x) { if(x <= 2) return 1; return lasfei(x - 1) + lasfei(x - 2); } int main() { // 计算斐波那契数列第8项 int b = lasfei(8); printf("斐波那契数列第8项: %d\n", b); // 计算laster函数 int a = laster(5); printf("laster(5) = %d\n", a); // 找出101到200之间的素数 int x; int count = 0; printf("\n101到200之间的素数:\n"); for(x = 101; x <= 200; x++) { if(latsem(x)) { printf("%d ", x); count++; if(count % 10 == 0) { printf("\n"); } } } printf("\n共有%d个素数\n", count); return 0; }

28.这段代码包含三个函数，演示了字符串操作、字符串复制和字符数组的不同定义方式。

这段代码的功能：

1. main函数：

   • 将字符串"s1"复制到字符串"s2"的开头
   • 输出s2的第5个字符和整个字符串

2. strcatt函数：修正版的字符串连接函数

   • 将s连接到s1的末尾

3. zifu函数：演示字符串的不同定义方式

   • char1[] = {'a','b','c'} - 无结束符，大小为3
   • char2[] = {"abc"} - 有结束符，大小为4
   • char3[] = "abc" - 有结束符，大小为4

#include <stdio.h> #include <string.h> int main(){ char s1[] = "lwh"; char s2[] = "cyqqwe"; int i, j; // 将s1复制到s2的开头 for(i = 0, j = 0; s1[i] != '\0'; i++, j++){ s2[j] = s1[i]; } s2[j] = '\0'; // 添加字符串结束符 // 输出s2的第5个字符（索引4）和整个字符串 putchar(s2[4]); putchar('\n'); // 添加换行符 puts(s2); return 0; } // 字符串连接函数（修正版） void strcatt(char s[], char s1[]) { int i, j; // 找到s1的结尾 for(i = 0; s1[i] != '\0'; i++) ; // 将s的内容追加到s1后面 for(j = 0; s[j] != '\0'; j++, i++) s1[i] = s[j]; s1[i] = '\0'; // 添加结束符 puts(s1); } // 字符数组不同定义方式的演示 void zifu() { // 字符数组的三种形式 char char1[] = {'a', 'b', 'c'}; // 不含结束符\0 char char2[] = {"abc"}; // 自动添加\0 char char3[] = "abc"; // 自动添加\0 printf("%s\n", char3); printf("char1大小: %d\n", sizeof(char1)); // 3 printf("char2大小: %d\n", sizeof(char2)); // 4 (包含\0) printf("char3大小: %d\n", sizeof(char3)); // 4 (包含\0) // 注意char1不能用%s输出，因为它没有结束符\0 printf("char1实际内容: "); for(int i = 0; i < 3; i++) printf("%c", char1[i]); printf("\n"); }

29.这段代码演示了C语言中逻辑运算符的短路求值特性..

#include <stdio.h> int main() { int a = 1; int b = 1; int c = 1; int t; // 关键在于逻辑运算符的优先级和短路求值 // && 的优先级高于 || // 所以表达式等价于: t = (++a) || ((++b) && (++c)) t = ++a || ++b && ++c; printf("t=%d, a=%d, b=%d, c=%d\n", t, a, b, c); return 0; }

这段代码的执行过程：

1. ++a先执行，a变成2，结果为2（非零，视为真）
2. 由于||运算符的短路求值特性，当左操作数为真时，整个表达式的值已经确定为真，右操作数就不会被计算
3. 因此++b && ++c这部分根本不会执行
4. 所以只有a被递增，b和c保持原值
5. t的结果为1（真）

输出结果：t=1, a=2, b=1, c=1

短路求值特性：

• ||：如果左边表达式为真，右边表达式不会被计算
• &&：如果左边表达式为假，右边表达式不会被计算

这种特性在实际编程中很有用，比如在条件判断中避免不必要的计算或防止错误（如防止空指针访问）。

30.这段代码的功能是使用莱布尼茨级数（Leibniz formula）计算π的近似值

这段代码使用莱布尼茨级数来计算π：

• 公式：π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + ...
• 一般项：(-1)^n / (2n+1)，其中n从0开始
• 当项的绝对值小于1e-6时停止计算

#include <stdio.h> #include <math.h> int main() { int i; double sum, item; int sign = 1; // 符号交替：+1, -1, +1, -1... sum = 0; i = 1; // 使用莱布尼茨级数：π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 - ... // 即：π/4 = Σ((-1)^n)/(2n+1)，n从0到无穷 for(i = 1; fabs(item = 1.0 / (2 * i - 1)) > 1e-6; i++) { sum += item * sign; // 累加带符号的项 sign = -sign; // 符号交替变化 } printf("π的近似值: %lf\n", 4 * sum); // 输出一些统计信息 printf("计算了 %d 项，最后一项为: %e\n", i-1, item); return 0; }

算法原理：

• 莱布尼茨级数收敛到π/4
• 通过乘以4得到π的近似值
• 由于收敛较慢，需要很多项才能达到较高精度

31.这段代码的功能是使用欧几里得算法（辗转相除法）计算两个数的最大公约数和最小公倍数

#include <stdio.h> int main(){ int a, b; int temp_a, temp_b; // 保存原始值用于计算最小公倍数 int remainder; scanf("%d,%d", &a, &b); temp_a = a; temp_b = b; // 使用欧几里得算法计算最大公约数 while((remainder = a % b) != 0) { a = b; b = remainder; } printf("最大公约数: %d\n", b); // 计算最小公倍数：(原数1 * 原数2) / 最大公约数 printf("最小公倍数: %d\n", (temp_a * temp_b) / b); return 0; }

这段代码的逻辑：

1. 输入两个整数a和b
2. 使用辗转相除法计算最大公约数（GCD）：
   • 用较大的数除以较小的数，取余数
   • 将较小的数作为新的被除数，余数作为新的除数
   • 重复此过程直到余数为0，此时除数就是最大公约数
3. 利用公式：最小公倍数 = (两数乘积) / 最大公约数

4. 例如：输入12,8

   • 12 % 8 = 4 → a=8, b=4
   • 8 % 4 = 0 → a=4, b=0
   • 余数为0，最大公约数为4
   • 最小公倍数 = (12×8)/4 = 24