C语言上机测试题(MOOC)

此处记录一些C语言的习题
期末化概出分了,绩点3.6,本人已死

这是小车埋土的mooc题库

· 选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/*
题目内容:
编写程序,输入一个字符,若是大写字母,转换成小写字母,若是小写字母,则转换成大写字母输出。
输入格式: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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
/*
题目内容:求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);
}

· 一维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
//编写程序,输入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
}

· 二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/*
题目内容:将两个字符串连接,不要用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
}

· 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/*
题目内容:编写函数,根据给定公式计算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
}


· 编译预处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
/*
题目内容:编写求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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/*
题目内容:利用指针编写程序,统计字符串的长度。(不要使用求字符串长度函数)
输入格式: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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*
题目内容:利用指针编写一函数,输入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;
}

· 结构体 共同体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*
题目内容:某班有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,表示程序正常结束