外观
C语言上机测试题（MOOC）
约 9835 字大约 33 分钟
2024-12-05
此处记录一些C语言的习题
这是小车埋土的mooc题库
· 选择结构
/*
题目内容：
编写程序，输入一个字符，若是大写字母，转换成小写字母，若是小写字母，则转换成大写字母输出。
输入格式:getchar() 输出格式：putchar()
输入样例：a 输出样例：A
*/
#include<stdio.h>
int main() {
char letter;
scanf("%c", &letter);
if (letter >= 'a' && letter <= 'z') {
letter = letter - 32;
printf("%c\n", letter);
}
else if (letter >= 'A' && letter <= 'Z') {
letter = letter + 32;
printf("%c\n", letter);
}
return 0;
}
/*
题目内容：编写程序，从键盘输入任意一个3位正整数，判断是否"水仙花数"。若是水仙花数，则输出"该三位数是水仙花数！"，否则输出“该三位数不是水仙花数！”。
提示：所谓"水仙花数"是指一3位数，其各位数字立方和等于该数本身。
例如：153是一个水仙花数，因为153=1+125+27。
输入格式:%d
输出格式：
输入样例：153
输出样例：153是水仙花数！
~~充分体现mooc是人工智障~~
*/
#include<stdio.h>
int main()
{
int num;
int hundreds,tens,units;
int sum;
scanf("%d",&num);
if(num<100||num>999)
{
printf("输入的不是3位正整数！\n");
return 1;
}
hundreds=num/100;
tens=(num/10)%10;
units=num%10;
sum=hundreds*hundreds*hundreds+tens*tens*tens+units*units*units;
if(sum==num)
{
printf("%d是水仙花数！\n",num);
}
else
{
printf("%d不是水仙花数！\n",num);
}
return 0;
}
/*
题目内容：编写程序，输入一个百分制成绩，输出所对应的成绩等级“ A ”、“ B ”、“ C ”、“ D ”、“ E ”。 (使用switch语句）
转换原则为：100～90 分为“A”,80 ～ 89 分为“B”,70 ～ 79 分为“C”,60 ～ 69 分为“D ”,60 分以下为“E”。
输入格式:%f
输出格式：printf("grade:B\n");
输入样例：85
输出样例：grade:B
*/
#include<stdio.h>
double score;
int a;
int main()
{
scanf("%lf",&score);
a=score/10;
switch(a)
{
case 10:case 9:printf("grade:A\n");break;
case 8:printf("grade:B\n");break;
case 7:printf("grade:C\n");break;
case 6:printf("grade:D\n");break;
case 5:case 4:case 3:case 2:case 1:case 0:printf("grade:E\n");break;
default:printf("输入有误，请重新输入\n");
}
return 0;
}· 循环结构
/*
题目内容：求1~100以内 ( 包括100）能被3整除同时被5整除余数为1的所有数之和。要求用for语句完成。
输入格式:无
输出格式："sum=%d\n"
输入样例：无
输出样例：sum=357
*/
# include <stdio.h>
int main()
{
int i ;
int sum = 0;
for (i=1 ; i<= 100; i++)
{
if(i % 3 == 0 && i % 5 == 1)
{
sum = sum + i;
}
}
printf("sum=%d\n",sum);
return 0;
}
/*
题目内容：用do while 语句实现反复从键盘输入一个整数，如果大于或等于零，累加求和，直到输入负数结束。然后求出平均值并输出。
输入格式:"%d"
输出格式："AVE=%.2f\n"
输入样例：25 35 45 55 -1
输出样例：AVE=40.00
*/
#include <stdio.h>
int main()
{
int number;
int sum = 0; // 用于累加和
int count = 0; // 用于计数非负数的个数
do
{
scanf("%d", &number); // 输入整数
if (number >= 0)
{ // 如果输入的数大于或等于零
sum += number; // 累加
count++; // 计数
}
} while (number >= 0); // 直到输入负数结束
if (count > 0)
{ // 确保至少有一个非负数输入
float average = (float)sum / count; // 计算平均值
printf("AVE=%.2f\n", average); // 输出结果
}
else
{
printf("没有输入非负数，无法计算平均值。\n");
}
return 0;
}
/*
用while语句计算圆周率的近似值。（直到累加项的绝对值小于 0.00001 ）
公式 : pi /4 ≈1-1/3+1/5-1/7 .......
输入格式:无
输出格式："pi=%.2f\n"
输入样例：无
输出样例：pi=3.14
*/
#include <stdio.h>
#include <math.h> // 用于 fabs 函数
int main() {
double pi_over_4 = 0.0; // 存储 pi/4 的和
double term = 1.0; // 当前项
int denominator = 1; // 分母，从1开始，每次增加2
int sign = 1; // 用来控制正负号交替
while (fabs(term) >= 0.00001) // 绝对值比较
{
pi_over_4 += term; // 累加当前项到总和
denominator += 2; // 分母每次增加2
sign = -sign; // 改变符号
term = (double)sign / denominator; // 计算下一项
}
double pi = pi_over_4 * 4; // 将 pi/4 转换为 pi
printf("圆周率的近似值: %f\n", pi); // 输出结果
return 0;
}
/*
求两个整数的最大公约数
辗转相除法:又名欧几里德算法，是求最大公约数的一种方法。它的具体做法是：用较大数除以较小数，再用出现的余数（第一余数）去除除数，再用出现的余数（第二余数）去除第一余数，如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数。
*/
#include <stdio.h>
int main() {
int a, b;
int min,max,temp;
printf("请输入两个数字:\n");
scanf("%d %d", &a, &b);
min = a > b ? b : a;
max = a > b ? a : b;
while (max%min != 0) {
temp = max%min;
max = min;
min = temp;
}
if (min == 1) {
printf("这两个数互质.");
}
else {
printf("这两个数字的最大公约数为:%d\n", min);
}
return 0;
}
/*
编写程序求斐波那契数列前n项之和（项数n要求是偶数并由键盘输入）。
输入格式:%d
输出格式：“sum=%d\n”
输入样例：20
输出样例：sum=17710
*/
#include <stdio.h>
#include <math.h>
//定义函数
int F(int n)
{
return (pow((1 + sqrt(5.0)) / 2, n) - pow((1 - sqrt(5.0)) / 2, n)) / sqrt(5.0);
}
//定义函数
int S(int n)
{
return F(n+2) - 1;
}
//主函数
int main()
{
int n;
int sum;
scanf("%d", &n);
while (n % 2 != 0)
{
scanf("%d", &n);
}
sum = S(n);
printf("sum=%d\n", sum);
return 0;
}
/*
找出一个大于给定整数且紧随这个整数的素数，例如 给定整数8，找到的素数是11。
输入格式:"%d"
输出格式："prime=%d\n"
输入样例：8
输出样例：prime=11
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
#include <math.h> // 包含数学库，用于数学函数如sqrt()
// 定义一个判断数字是否为素数的函数
int is_prime(int n) {
// 如果n小于等于1，则不是素数
if (n <= 1) {
return 0;
}
// 2和3是素数
if (n == 2 || n == 3) {
return 1;
}
// 如果n是偶数且不等于2，则不是素数
if (n % 2 == 0) {
return 0;
}
// 检查从3到根号n之间的所有奇数是否能整除n
for (int i = 3; i <= sqrt(n); i += 2) {
// 如果i能整除n，则n不是素数
if (n % i == 0) {
return 0;
}
}
// 如果没有找到任何因子，则n是素数
return 1;
}
// 主函数
int main() {
int n; // 声明一个整型变量用于存储用户输入的数字
// 从标准输入读取一个整数到变量n
scanf("%d", &n);
// 初始化prime为n+1，寻找大于n的最小素数
int prime = n + 1;
// 当prime不是素数时，继续增加prime的值
while (!is_prime(prime)) {
prime++;
}
// 输出找到的素数
printf("prime=%d\n", prime);
// 返回0表示程序正常结束
return(0);
}· 一维数组
//编写程序，输入6个整数存入数组中，按输入顺序的逆序存放在该数组中并输出。
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
#include <math.h> // 包含数学库，此程序中并未使用该库的任何功能
int main() {
int i, j, k; // 声明三个整型变量 i, j, k。i 和 j 用作循环计数器，k 用于临时存储用户输入的值
int a[6]; // 定义一个名为 a 的整数数组，大小为 6，用于存储用户输入的六个整数
// 使用 for 循环接收用户输入的 6 个整数值，并依次存入数组 a 中
for (i = 0; i < 6; i++) {
scanf("%d", &k); // 读取用户输入的一个整数，并存储在变量 k 中
a[i] = k; // 将变量 k 中的值赋给数组 a 的第 i 个元素
}
// 使用 for 循环从数组 a 的最后一个元素开始向前遍历，即逆序打印数组中的元素
for (j = 5; j >= 0; j--) {
printf("%d\n", a[j]); // 打印数组 a 的第 j 个元素，然后换行
}
return 0; // 程序正常结束，返回0
}
/*
题目内容：定义一维整型数组，输入5个数，从大到小排序，输出次最大值。
输入格式:"%d"
输出格式："次最大值=%d"
输入样例：1 5 6 8 2
输出样例：次最大值=6
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
int main() {
int a[5], i, j, temp; // 声明一个整型数组 a，大小为 5，以及三个整型变量 i, j 和 temp 用于循环计数和临时存储
// 使用 for 循环接收用户输入的 5 个整数值，并依次存入数组 a 中
for (i = 0; i <= 4; i++) { // 循环 5 次（i 从 0 到 4），每次读取一个整数
scanf("%d", &a[i]); // 读取用户输入的一个整数，并存储在数组 a 的第 i 个位置
}
// 使用嵌套的 for 循环对数组 a 进行降序排序（从大到小）
for (i = 0; i < 5; i++) { // 外层循环控制排序轮次
for (j = 1; j < 5 - i; j++) { // 内层循环比较相邻元素并交换，每一轮确定一个最大值的位置
if (a[j - 1] < a[j]) { // 如果前一个元素小于后一个元素，则交换它们
temp = a[j - 1]; // 将较小的元素暂存到 temp
a[j - 1] = a[j]; // 将较大的元素移到前面
a[j] = temp; // 将暂存的较小元素放到后面
}
}
}
// 打印数组中第二大的元素（即排序后的数组中的第二个元素）
printf("次最大值=%d\n", a[1]); // 输出次最大值并换行
return 0; // 程序正常结束，返回0
}
//输入一维数组的6个元素，将最大值与最后一个交换。
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
int main() {
int a[6], i, n, temp; // 声明一个整型数组 a，大小为 6，以及三个整型变量 i, n 和 temp 用于循环计数和临时存储
// 使用 for 循环接收用户输入的 6 个整数值，并依次存入数组 a 中
for (i = 0; i < 6; i++) { // 循环 6 次（i 从 0 到 5），每次读取一个整数
scanf("%d", &a[i]); // 读取用户输入的一个整数，并存储在数组 a 的第 i 个位置
}
n = 0; // 初始化变量 n 为 0，n 将用来记录比 a[0] 大的最大元素的索引
// 使用 for 循环遍历数组 a 中除第一个元素外的其他元素
for (i = 1; i <= 5; i++) { // 从数组的第二个元素开始，直到最后一个元素
if (a[i] > a[0]) { // 如果当前元素 a[i] 大于数组的第一个元素 a[0]
n = i; // 更新 n 为当前索引 i，即记录下比 a[0] 大的最大元素的索引
}
}
// 交换数组中最后一位元素 a[5] 和比 a[0] 大的最大元素 a[n]
temp = a[5]; // 将数组的最后一个元素暂存到 temp
a[5] = a[n]; // 将找到的比 a[0] 大的最大元素移到数组的最后一位
a[n] = temp; // 将暂存的原最后一位元素放到找到的最大元素的位置
// 使用 for 循环打印数组 a 中的所有元素
for (i = 0; i < 6; i++) {
printf("%d\n", a[i]); // 打印数组 a 的第 i 个元素，然后换行
}
return 0; // 程序正常结束，返回0
}· 二维数组
/*
题目内容：将两个字符串连接，不要用stract函数。
输入格式:"%s"
输出格式："%s"
输入样例：abc edf
输出样例：abcedf
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
int main() {
int i = 0, j = 0; // 初始化两个整型变量 i 和 j 为 0，用作字符串遍历的索引
char str1[50], str2[50]; // 定义两个字符数组 str1 和 str2，分别用于存储用户输入的第一个和第二个字符串
// 使用 gets 函数从标准输入读取两行文本，并分别存储到 str1 和 str2 中
// 注意：gets 函数是不安全的，因为它不会检查输入的长度，可能导致缓冲区溢出
// 建议使用 fgets 函数代替，它允许指定最大读取长度，从而避免缓冲区溢出的风险
gets(str1); // 读取第一行输入并存储到 str1 中
gets(str2); // 读取第二行输入并存储到 str2 中
// 计算 str1 的长度（即找到字符串的结束符 '\0'）
while (str1[i] != '\0') { // 当 str1 的当前字符不是字符串结束符时
i++; // 索引 i 自增，直到遇到字符串结束符
}
// 将 str2 追加到 str1 的末尾
while ((str1[i++] = str2[j++]) != '\0'); // 逐字符复制 str2 到 str1 的末尾，直到遇到 str2 的结束符
// 注意：这段代码在执行后会将 str1 的最后一个字符设置为 '\0'，然后继续自增 i 和 j，这可能会导致未定义行为
// 改进方法是，在循环外单独处理字符串结束符
// 打印拼接后的字符串 str1
printf("%s\n", str1); // 输出拼接后的字符串，并换行
return 0; // 程序正常结束，返回0
}
/*
题目内容：求3行3列矩阵的外围元素之和。
输入格式:"%d"
输出格式："%d"
输入样例：
1 2 3
4 5 6
7 8 9
输出样例：40
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
int main() {
int a[9]; // 定义一个整型数组 a，大小为 9，用于存储用户输入的 9 个整数
int i, sum, x; // 声明三个整型变量 i, sum 和 x。i 用作循环计数器，sum 用于累加总和，x 用于临时存储用户输入的值
sum = 0; // 初始化 sum 为 0，表示开始时总和为 0
// 使用 for 循环接收用户输入的 9 个整数值，并依次存入数组 a 中
for (i = 0; i < 9; i++) { // 循环 9 次（i 从 0 到 8），每次读取一个整数
scanf("%d", &x); // 读取用户输入的一个整数，并存储在变量 x 中
a[i] = x; // 将变量 x 中的值赋给数组 a 的第 i 个元素
// 累加除中间元素外的所有元素到 sum
if (i != 4) { // 如果当前索引 i 不等于 4（即不是中间的第五个元素）
sum = sum + a[i]; // 将当前元素 a[i] 加到 sum 上
}
}
// 打印累加的结果，即除中间元素外所有元素的总和
printf("%d\n", sum); // 输出总和 sum 并换行
return 0; // 程序正常结束，返回0
}
/*
题目内容：求5行5列矩阵的主对角线和副对角线元素之和。
输入格式:"%d"
输出格式："sum=%d"
输入样例：
1 2 3 4 3
2 3 4 1 6
3 4 5 6 7
4 2 6 7 8
1 6 7 8 9
输出样例：sum=37
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
int main() {
int a[25]; // 定义一个整型数组 a，大小为 25，用于存储用户输入的 25 个整数
int i, sum, x; // 声明三个整型变量 i, sum 和 x。i 用作循环计数器，sum 用于累加总和，x 用于临时存储用户输入的值
sum = 0; // 初始化 sum 为 0，表示开始时总和为 0
// 使用 for 循环接收用户输入的 25 个整数值，并依次存入数组 a 中
for (i = 0; i < 25; i++) { // 循环 25 次（i 从 0 到 24），每次读取一个整数
scanf("%d", &x); // 读取用户输入的一个整数，并存储在变量 x 中
a[i] = x; // 将变量 x 中的值赋给数组 a 的第 i 个元素
// 累加满足特定条件的元素到 sum
if (i % 6 == 0 || i % 4 == 0) { // 如果当前索引 i 是 6 或 4 的倍数
sum = sum + a[i]; // 将当前元素 a[i] 加到 sum 上
}
}
// 特别处理：将索引为 12 的元素也加到 sum 中
sum = sum + a[12]; // 无论 a[12] 是否已经包含在之前的累加中，这里都会再次将其加到 sum 上
// 打印累加的结果
printf("sum=%d\n", sum); // 输出总和 sum 并换行
return 0; // 程序正常结束，返回0
}
/*
题目内容：编写程序，把键盘输入的字符串中的小写字母转换为大写字母。
输入格式:gets
输出格式："%s"
输入样例：aAB23edf
输出样例：AAB23EDF
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
#include <ctype.h> // 包含字符处理库，用于字符类型检查和转换函数
int main() {
char str1[50]; // 定义一个字符数组 str1，大小为 50，用于存储用户输入的字符串
int i = 0; // 初始化索引变量 i 为 0，用于遍历字符串
// 使用 gets 函数从标准输入读取一行文本并存储到 str1 中
// 注意：gets 函数是不安全的，因为它不会检查输入的长度，可能导致缓冲区溢出
// 建议使用 fgets 函数代替，它允许指定最大读取长度，从而避免缓冲区溢出的风险
gets(str1);
// 使用 while 循环遍历字符串中的每个字符，直到遇到字符串结束符 '\0'
while (str1[i] != '\0') {
// 如果当前字符不是大写字母，则将其转换为大写
if (!(isupper(str1[i]))) { // 检查当前字符是否不是大写字母
str1[i] = toupper(str1[i]); // 将当前字符转换为大写
}
i++; // 索引 i 自增，指向下一个字符
}
// 使用 puts 函数输出转换后的字符串
puts(str1); // 打印字符串 str1 并自动换行
return 0; // 程序正常结束，返回0
}· 函数
/*
题目内容：编写函数，根据给定公式计算e的值：1+1/1!+1/2!+1/3!+……+1/n!的值（取前n项），要求在主函数中输入n的值，调用函数并输出结果。
输入格式:%d
输出格式：e=%.4f
输入样例：10
输出样例：e=2.7183
*/
#include <stdio.h>
int factorial(int n)
{
int result = 1;
for (int i = 1; i <= n; i++)
{
result *= i;
}
return result;
}
double calculate_e(int n)
{
double e = 1.0;
for (int i = 1; i <= n; i++)
{
e += 1.0 / factorial(i);
}
return e;
}
int main()
{
int n;
scanf("%d", &n);
double e = calculate_e(n);
printf("e=%.4f\n", e);
return 0;
}
/*
题目内容：编写函数，求给定字符串中数字字符的个数，在主函数中输入字符串及输出统计的个数。
输入格式:%s
输出格式：%d
输入样例：abc123fg
输出样例：3
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
#include <string.h> // 包含字符串处理库，用于字符串长度计算函数 strlen
// 定义一个函数 count_digits 来统计给定字符串中数字字符的数量
int count_digits(char *str) {
int count = 0; // 初始化计数器为0
// 使用 for 循环遍历字符串中的每个字符
for (int i = 0; i < strlen(str); i++) {
// 检查当前字符是否是数字字符（'0' 到 '9'）
if (str[i] >= '0' && str[i] <= '9') {
count++; // 如果是数字字符，则计数器加1
}
}
return count; // 返回统计到的数字字符数量
}
// main 函数是程序的入口点
int main() {
char str[100]; // 定义一个字符数组来存储用户输入的字符串，最大长度为99个字符（最后一个位置留给字符串结束符'\0'）
scanf("%s", str); // 从标准输入读取一行文本，并存储在字符数组 str 中。注意：这个方法不会处理空格。
int count = count_digits(str); // 调用 count_digits 函数统计字符串中数字字符的数量，并将结果存储在变量 count 中
printf("%d\n", count); // 输出数字字符的数量，然后换行
return 0; // 程序正常结束，返回0
}
/*
题目内容：
编写函数，求一组整数中大于平均值的个数，数组元素个数任意。例如：给定的一组数为1,3,6,9,4,23,35,67,12,88时，函数值为3。
函数头定义：int aver(int a[],int n);
输入格式:%d
输出格式：%d
输入样例：1 3 6 9 4 23 35 67 12 88
输出样例：3
*/
#include <stdio.h> // 包含标准输入输出库，用于输入和输出函数
#include <stdlib.h> // 包含标准库函数，如内存分配等。此程序中未直接使用该库的功能
// 定义一个函数 aver 来计算数组 a 中有多少个元素大于数组所有元素的平均值
int aver(int a[], int n) {
int sum = 0; // 初始化变量 sum 用于存储数组元素的总和
double average = 0.0; // 初始化变量 average 用于存储数组元素的平均值
int count = 0; // 初始化计数器 count 用于统计大于平均值的元素数量
// 使用 for 循环遍历数组中的每个元素并累加到 sum
for (int i = 0; i < n; i++) {
sum += a[i]; // 将当前元素 a[i] 加到 sum 上
}
// 计算平均值，将 sum 转换为 double 类型以确保除法操作是浮点数除法
average = (double)sum / n;
// 再次使用 for 循环遍历数组中的每个元素
for (int i = 0; i < n; i++) {
if (a[i] > average) { // 如果当前元素 a[i] 大于平均值
count++; // 则计数器 count 加1
}
}
return count; // 返回大于平均值的元素数量
}
// main 函数是程序的入口点
int main() {
int n;
n = 10; // 设定数组的大小为 10
int a[10]; // 定义一个整数数组 a，长度为 10
// 使用 for 循环从用户处接收 10 个整数，并依次存入数组 a 中
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]); // 读取用户输入的整数，并存储在数组 a 的第 i 个位置
}
// 调用 aver 函数计算并打印出数组 a 中有多少个元素大于平均值
printf("%d\n", aver(a, 10)); // 输出结果后换行
return 0; // 程序正常结束，返回0
}· 编译预处理
/*
题目内容：编写求x的n次方的递归函数，在主函数调用并输出。(x为double型，n为整型，函数类型为double型）
输入格式:%lf%d
输出格式：%f
输入样例：4 3
输出样例：64.000000
*/
#include <stdio.h> // 包含标准输入输出库，用于处理输入和输出
#include <math.h> // 包含数学函数库，用于调用pow函数
// 定义一个名为f的函数，用于计算x的i次幂
// 参数：
// double x - 底数
// int i - 指数
// 返回值：
// double - 计算结果（x的i次幂）
double f(double x, int i)
{
double c = pow(x, i); // 使用math.h库中的pow函数来计算x的i次幂
return c; // 返回计算的结果
}
int main()
{
double x, result; // 声明变量x用于存储底数，result用于存储最终结果
int n; // 声明变量n用于存储指数
// 从标准输入读取底数x和指数n
// 输入格式为先输入一个浮点数，然后是一个整数
scanf("%lf%d", &x, &n);
// 调用函数f计算x的n次幂，并将结果存储在result中
result = f(x, n);
// 输出计算的结果
// 输出格式为浮点数，默认6位小数
printf("%f", result);
return 0; // 程序正常结束，返回0
}
/*
题目内容：编写函数，通过键盘输入10个整数，找出其中最大的数和最小的数，在主调函数中输入数据和结果。
输入格式:%d
输出格式：max=%d,min=%d
输入样例：2 3 4 1 7 6 8 9 26 35
输出样例：max=35,min=1
*/
#include <stdio.h> // 包含标准输入输出库，用于处理输入和输出
// 定义一个名为dmax的函数，用于在一个整数数组中找到最大值
// 参数：
// int a[] - 整数数组
// 返回值：
// int - 数组中的最大值
int dmax(int a[])
{
int i;
int max = a[0]; // 假设数组的第一个元素是最大值
for (i = 1; i < 10; i++)
{ // 遍历数组中的其余元素
if (a[i] > max) // 如果发现更大的元素
max = a[i]; // 更新最大值
}
return max; // 返回最大值
}
// 定义一个名为dmin的函数，用于在一个整数数组中找到最小值
// 参数：
// int a[] - 整数数组
// 返回值：
// int - 数组中的最小值
int dmin(int a[])
{
int i;
int min = a[0]; // 假设数组的第一个元素是最小值
for (i = 1; i < 10; i++)
{ // 遍历数组中的其余元素
if (a[i] < min) // 如果发现更小的元素
min = a[i]; // 更新最小值
}
return min; // 返回最小值
}
int main()
{
int a[10]; // 声明一个包含10个整数的数组
int x, max, min;
int i;
// 从用户处接收10个整数，并将它们存储在数组a中
for (i = 0; i < 10; i++) {
scanf("%d", &x); // 读取用户输入的一个整数
a[i] = x; // 将读取到的整数存入数组
}
// 调用dmax函数找到数组中的最大值
max = dmax(a);
// 调用dmin函数找到数组中的最小值
min = dmin(a);
// 打印最大值和最小值
printf("max=%d, min=%d\n", max, min);
return 0; // 程序正常结束，返回0
}
/*
题目内容：编写函数，对于任意输入的一个整数，转换为千分位分隔的字符形式，在主函数中调用并输出。
输入格式:%d
输出格式：%c 或 putchar()
输入样例：123456
输出样例：123,456
*/
#include <stdio.h>
#include <string.h>
// 全局变量i用于循环计数，但在这个上下文中并不需要作为全局变量使用。
int i;
// 函数format接受一个整数n，并将其格式化为带逗号分隔的字符串输出。
void format(int n)
{
// 定义一个字符数组s用来存储数字的字符串表示。
char s[20];
// len变量用来跟踪当前在字符数组s中的位置。
int len = 0;
// 这里缺少了处理负数的逻辑，如果n为负数，则需要额外处理。
// 循环将整数n的每一位数字转化为字符并存储到数组s中。
while (n > 0)
{
// 将当前数字（n%10）转换为对应的ASCII字符，并存入字符数组s。
s[len] = n % 10 + '0';
// 整数n除以10，去掉已经处理过的最低位。
n /= 10;
// 如果n大于10且当前长度加1后能被3整除，则插入一个逗号。
if (n > 10 && (len + 1) % 3 == 0)
{
// 因为要插入逗号，所以先增加len索引。
len++;
// 插入逗号作为千位分隔符。
s[len] = ',';
}
// 每次循环后增加len，指向下一个位置。
len++;
}
// 反转字符数组s的内容，因为数字是从低位到高位逐个存储的。
for (i = len - 1; i >= 0; i--)
{
// 使用putchar函数逐个输出字符。
putchar(s[i]);
}
}
int main()
{
// 定义一个整数变量n来存储用户输入的数值。
int n;
// 从标准输入读取一个整数并存储在n中。
scanf("%d", &n);
// 调用format函数对n进行格式化并输出。
format(n);
// 返回0表示程序正常结束。
return 0;
}
/*
题目内容：编写函数，输入N个整数，将它们存入数组a中，再输入一个整数x，然后在数组中
查找x，如果找到，输出相应的下标，否则，输出"Not Found"。要求在主函数中输入10个整数及查找结果。
输入格式：%d %d
输出格式：%d
输入样例：
1 2 3 4 5 6 7 8 910
输入：5 或者输入11：
输出样例：5 Not Found
*/
#include <stdio.h>
#include <math.h> // 这个头文件在这里并没有被使用，可以移除。
// 函数find用于在一个整数数组中查找特定值x的位置。
int find(int a[], int x) {
int i, result;
// 遍历数组中的每个元素。
for (i = 0; i < 10; i++) {
// 如果当前元素等于x，则返回其位置（索引+1）。
if (a[i] == x) {
result = i + 1;
return result;
}
// 如果当前元素不等于x，则设置result为-1。这行代码应该放在循环外部，
// 因为只要有一个元素匹配，就应该立即返回结果，而不是继续设置result为-1。
else
result = -1;
}
// 如果遍历完整个数组都没有找到x，则返回-1表示未找到。
return result;
}
int main() {
int a[10]; // 定义一个大小为10的整数数组。
int n, x; // n用于临时存储输入的数值，x是要查找的值。
int result; // 存储find函数的返回值。
int i;
// 从用户处读取10个整数并存储到数组a中。
for (i = 0; i < 10; i++) {
scanf("%d", &n);
a[i] = n;
}
// 从用户处读取要查找的整数值x。
scanf("%d", &x);
// 调用find函数，在数组a中查找x，并将结果存储在result变量中。
result = find(a, x);
// 根据find函数的结果，输出相应的信息。
if (result != -1)
printf("%d", result); // 如果找到了x，输出它的位置。
else
printf("Not Found"); // 如果没有找到x，输出"Not Found"。
return 0; // 程序正常结束。
}· 指针1
/*
题目内容：利用指针编写程序，统计字符串的长度。(不要使用求字符串长度函数）
输入格式:gets()
输出格式："Length of the string is %d\n"
输入样例：I like programming.
输出样例：Length of the string is 19
*/
#include<stdio.h>
int main()
{
// 定义两个字符数组str1和str2，每个数组最多可以存储49个字符（加上终止符'\0'）。
// 但在这个程序中，str2并没有被使用。
char str1[50], str2[50];
// 定义一个字符指针s，让它指向str1的起始位置。
char *s = str1;
// 初始化计数器i为0，用于记录字符串的长度。
int i = 0;
// 使用gets函数从标准输入读取一行文本并存储到str1中。
// 注意：gets函数是不安全的，因为它不会检查输入缓冲区的边界，容易导致缓冲区溢出。
// 推荐使用fgets代替gets来避免安全风险。
gets(str1);
// 遍历字符串str1中的每个字符，直到遇到字符串结束符'\0'。
while (*s != '\0') {
// 这里的*s++实际上做了两件事：
// 1. 解引用指针s，获取它指向的字符（*s）。
// 2. 将指针s向前移动一个位置（s++），指向下一个字符。
// 但是这里的解引用操作没有实际用途，因为它的结果没有被使用。
*s++;
// 每遍历一个字符，就增加计数器i。
i++;
}
// 输出字符串的长度。
printf("Length of the string is %d\n", i);
return 0; // 程序正常结束。
}
/*
题目内容：利用指针编程，将数组中所有元素的值对称交换。使用数组int a[10].
输入格式:%d
输出格式：%2d
输入样例：9 1 7 3 4 5 6 2 8 0
输出样例：0 8 2 6 5 4 3 7 1 9
*/
#include <stdio.h>
int main()
{
// 定义一个大小为10的整数数组a。
int a[10];
// 初始化循环计数器i和交换变量t。
int i;
int t = 0;
// 定义两个指向数组a的指针p和s，分别指向数组的起始位置和结束位置（最后一个元素）。
int *p;
int *s;
p = &a[0]; // 指向数组的第一个元素
s = &a[9]; // 指向数组的最后一个元素
// 从用户处读取10个整数并存储到数组a中。
for (i = 0; i < 10; i++) {
scanf("%d", &a[i]);
}
// 重置i为0，虽然在这里i的值并不影响后续的逻辑。
i = 0;
// 使用指针p和s来遍历数组，并交换它们所指向的元素，直到p不再小于s。
while (p < s) {
// 交换*p和*s所指向的元素。
t = *p; // 将*p的值临时存储在t中
*p = *s; // 将*s的值赋给*p
*s = t; // 将t的值（原来的*p的值）赋给*s
// 移动指针p和s，分别向数组的中间靠拢。
p++;
s--;
}
// 输出反转后的数组内容。
for (i = 0; i < 10; i++) {
printf("%2d", a[i]); // 使用%2d格式化输出，确保每个数字占两位宽度
}
return 0; // 程序正常结束
}
/*
题目内容：利用指针编写程序，求一维数组中的最大和最小的元素值。使用数组 int array[10]
输入格式:%d
输出格式：printf("max=%d,min=%d",max,min);
输入样例：10 7 19 29 4 0 7 35 -16 21
输出样例：max=35,min=-16
*/
#include <stdio.h>
int main()
{
// 定义一个大小为10的整数数组array。
int array[10];
// 定义变量max和min用于存储数组中的最大值和最小值。
int max, min;
// 定义一个指向数组array的指针t，初始时指向数组的第一个元素。
int *t = array;
// 定义循环计数器i。
int i;
// 从用户处读取10个整数并存储到数组array中。
for (i = 0; i < 10; i++) {
scanf("%d", &array[i]);
}
// 初始化max和min为数组的第一个元素的值。
max = array[0];
min = array[0];
// 遍历数组array中的每个元素，使用指针t来访问每个元素。
for (i = 0; i < 10; i++) {
// 如果当前元素*t大于max，则更新max为*t的值。
if (*t > max) {
max = *t;
}
// 如果当前元素*t小于min，则更新· 指针2
/*
题目内容：利用指针编写一函数，输入3个整数，按由大到小的顺序将它们输出。
输入格式:%d
输出格式：%3d
输入样例：25 68 17
输出样例：68 25 17
*/
#include <stdio.h> // 包含标准输入输出头文件，以便使用输入输出函数
int main() // 主函数开始
{
int *p; // 声明一个指向整数的指针p
int a[3]; // 声明一个包含3个整数的数组a
int i, t; // 声明两个整型变量i和t，用于循环和交换值
// 使用指针p遍历数组a，并通过scanf函数从标准输入读取3个整数
for(p=a; p<a+3; p++){
scanf("%d", &*p); // 读取一个整数并存入指针p指向的位置
}
// 外层循环控制排序的总轮数，这里需要进行3-1=2轮排序
for(i=0; i<3-1; i++){
p=a; // 每次开始新的一轮排序时，将指针p重新指向数组a的开始
// 内层循环进行当前轮的冒泡操作，直到数组的倒数第二个元素
while(p<a+2){
// 如果当前元素小于下一个元素，则交换它们
if(*p < *(p+1)){
t = *p; // 临时存储当前元素的值
*p = *(p+1); // 将下一个元素的值赋给当前元素
*(p+1) = t; // 将临时存储的值赋给下一个元素
}
p++; // 移动指针到下一个元素
}
}
// 使用指针p遍历数组a，并打印每个元素
for(p=a; p<a+3; p++){
printf("%3d", *p); // 打印指针p指向的元素，格式为宽度为3的整数
}
return 0; // 主函数返回0，表示程序正常结束
}
/*
题目内容：
有若干个学生的成绩（每个学生有4门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用指向数组的指针变量实现。
使用数组 float score[][4]=\{\{60,70,80,90\},\{56,89,67,88\},\{34,78,90,66\}\}
输入格式:%d
输出格式：%8.2f
输入样例：1
输出样例：56.00 89.00 67.00 88.00
*/
#include <stdio.h>
int main()
{
int i, j;
float score[][4] = { {60,70,80,90},{56,89,67,88},{34,78,90,66} };
float (*p)[4];
p = score;
scanf("%d",&i);
for (j = 0; j <= 3; j++)
{
printf("%8.2f",*(p[i]+j));
}
return 0;
}· 结构体 共同体
/*
题目内容：某班有5名同学，建立一个学生的简单信息表，包括学号、姓名、3门课程的成绩，编写程序，计算每名学生的平均成绩及名次。（注：定义一个结构体类型，用结构指针作为函数参数）
输入格式:
%ld %s %f %f %f
输出格式：
%-9ld%-10s%-5.1f%-5.1f%-8.1f%-10.1f%-d\n
输入样例：
201701 zhao 29.8 85.4 65.4
201702 qian 96.5 87.5 65.4
201703 sun 85.4 65.4 84.6
201704 li 63.4 95.4 86.3
201705 zhou 65.9 84.6 97.5
输出样例：
Number: Name: score: Average： rank:
201701 zhao 29.8 85.4 65.4 60.2 5
201702 qian 96.5 87.5 65.4 83.1 1
201703 sun 85.4 65.4 84.6 78.5 4
201704 li 63.4 95.4 86.3 81.7 3
201705 zhou 65.9 84.6 97.5 82.7 2
*/
#include <stdio.h> // 包含标准输入输出头文件，用于输入输出操作
// 定义一个结构体sd，用于存储学生信息
struct sd
{
int num; // 学号
char name[20]; // 姓名，数组大小为20，足够存储大部分姓名
float a; // 第一门课程的成绩
float b; // 第二门课程的成绩
float c; // 第三门课程的成绩
float aver; // 平均成绩
int rank; // 排名
} man[5]; // 创建一个包含5个学生信息的结构体数组man
int i, j, k, l; // 声明循环变量i, j, k, l
// 读取5个学生的信息
for(i = 0; i < 5; i++)
{
// 使用scanf函数从标准输入读取学生信息
// 注意：%ld用于读取长整型，%s用于读取字符串，%f用于读取浮点数
scanf("%ld %s %f %f %f", &man[i].num, man[i].name, &man[i].a, &man[i].b, &man[i].c);
// 计算平均成绩并存储到aver字段
man[i].aver = (man[i].a + man[i].b + man[i].c) / 3;
}
// 计算排名
for(i = 0; i < 5; i++)
{
man[i].rank = 5; // 初始排名设为5
for(j = 0; j < 5; j++)
// 如果当前学生的平均成绩高于另一个学生，则排名减1
if(man[i].aver > man[j].aver)
man[i].rank = man[i].rank - 1;
}
// 打印表头
printf("Number: Name: score: Average： rank:\n");
// 遍历并打印每个学生的信息
for(i = 0; i < 5; i++)
// 使用printf函数按照指定格式打印学生信息
// %-9ld表示左对齐，占用9个字符宽度的长整型
// %-10s表示左对齐，占用10个字符宽度的字符串
// %-5.1f表示左对齐，占用5个字符宽度，小数点后1位的浮点数
// %-8.1f和%-10.1f类似，分别表示占用8个和10个字符宽度
// %-d表示左对齐，占用适当宽度的整型
printf("%-9ld%-10s%-5.1f%-5.1f%-8.1f%-10.1f%-d\n", man[i].num, man[i].name, man[i].a, man[i].b, man[i].c, man[i].aver, man[i].rank);
return 0; // 主函数返回0，表示程序正常结束更新日志
2025/10/12 15:40
查看所有更新日志
a45a4-C-Mooc于c9ee8-plume于a28aa-a于