1.E输出所有大于平均值的数
输入n个整数，计算这些数的平均值，再输出所有大于平均值的数。
例如，输入:
10
55 23 8 11 22 89 0 -1 78 186
输出： 55 89 78 186
#include<stdio.h>
int main(){
int n, s = 0; // n为数组元素个数，s用于累加和
scanf("%d", &n); // 输入数组大小n
int a[n]; // 定义大小为n的数组（变长数组，C99标准支持）
// 输入数组元素并计算总和
for(int i = 0; i < n; i++){
scanf("%d", &a[i]); // 输入第i个元素
s += a[i]; // 累加到总和s中
}
// 计算平均值，注意强制类型转换确保浮点数运算
double avg = (double)s / n;
// 遍历数组，输出所有大于平均值的元素
for (int i = 0; i < n; i++){
if (a[i] > avg){ // 如果当前元素大于平均值
printf("%d ", a[i]); // 输出该元素
}
}
printf("\n"); // 换行
return 0; // 程序正常结束
}
2.E计算书费
下面是一个图书的单价表：
计算概论 28.9元/本；数据结构与算法 32.7元/本；数字逻辑 45.6元/本；C++程序设计教程 78元/本；人工智能 35 元/本；计算机体系结构 86.2元/本；编译原理 27.8元/本；操作系统 43元/本；计算机网络 56元/本；JAVA程序设计 65元/本。
给定每种图书购买的数量，编程计算应付的总费用。
输入格式
输入一行，包含10个整数(大于等于0，小于等于100)，分别表示购买的《计算概论》、《数据结构与算法》、《数字逻辑》、《C++程序设计教程》、《人工智能》、《计算机体系结构》、《编译原理》、《操作系统》、《计算机网络》、《JAVA程序设计》的数量（以本为单位）。每两个整数用一个空格分开。
输出格式
输出一行，包含一个浮点数f，表示应付的总费用。精确到小数点后一位。
#include<stdio.h>
int main(){
int b[10]; // 定义数组b，存储10种图书的购买数量
// 数组初始化：图书单价数组，10种图书的单价（单位：元）
// 对应顺序：第1种28.9元，第2种32.7元，第3种45.6元，第4种78元，第5种35元
// 第6种86.2元，第7种27.8元，第8种43元，第9种56元，第10种65元
float p[] = {28.9, 32.7, 45.6, 78, 35, 86.2, 27.8, 43, 56, 65};
// 输入10种图书的购买数量
for (int i = 0; i < 10; i++){
scanf("%d", &b[i]); // 依次输入每种图书的购买数量
}
float s = 0; // 定义总金额s并初始化为0
// 计算总金额：每种图书的数量乘以单价，然后累加
for (int i = 0; i < 10; i++){
s += b[i] * p[i]; // 累加每种图书的金额
}
printf("%.1f", s); // 输出总金额，保留一位小数
return 0; // 程序正常结束
}
3.M机器翻译
小晨的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。
这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。
假设内存中有M个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过M−1，软件会将新单词存入一个未使用的内存单元；若内存中已存入M 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。
假设一篇英语文章的长度为N个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。
输入格式
共2行。每行中两个数之间用一个空格隔开。第一行为两个正整数M和N，代表内存容量和文章的长度。第二行为N个非负整数，按照文章的顺序，每个数（大小不超过1000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。
输出格式
共1行，包含一个整数，为软件需要查词典的次数。
如输入样例
3 7
1 2 1 5 4 4 1
输出样例
5
#include<stdio.h>
int main(){
int m, n; // m-内存容量（页面框数），n-页面请求序列长度
scanf("%d %d", &m, &n); // 输入内存容量和页面请求序列长度
int a[n]; // 页面请求序列数组
int cnt = 0; // 缺页次数计数器
int mem[m]; // 内存中的页面数组（页面框）
int mems = 0; // 当前内存中已使用的页面框数量
// 输入页面请求序列
for (int i = 0; i < n; i++){
scanf("%d", &a[i]); // 输入第i个页面请求
}
// 初始化内存页面框，全部设为-1（表示空闲）
for (int i = 0; i < m; i++){
mem[i] = -1;
}
// 模拟FIFO页面置换算法
for (int i = 0; i < n; i++){ // 遍历每个页面请求
int w = a[i]; // 当前请求的页面
int f = 0; // 标志位：是否在内存中找到该页面（0-未找到，1-找到）
// 在内存中查找当前请求的页面
for (int j = 0; j < m; j++){
if(mem[j] == w){ // 如果内存中存在该页面
f = 1; // 设置为找到
break; // 跳出查找循环
}
}
// 如果页面不在内存中（缺页）
if (!f){
cnt++; // 缺页次数加1
// 如果内存还有空闲页面框
if(mems < m){
mem[mems] = w; // 将页面放入空闲页面框
mems++; // 已使用页面框数量加1
}
// 如果内存已满（需要页面置换）
else{
// FIFO置换：移除最早进入的页面（第0个位置）
// 所有页面向前移动一位
for (int j = 0; j < m-1; j++){
mem[j] = mem[j+1]; // 将后面的页面向前移动
}
// 将新页面放入最后一个位置
mem[m-1] = w;
}
}
}
printf("%d\n", cnt); // 输出缺页次数
return 0; // 程序正常结束
}
4.E短信计费
用手机发短信，一条短信资费为0.1元，但限定一条短信的内容在70个字以内(包括70个字）。如果你一次所发送的短信超过了70个字，则会按照每70个字一条短信的限制把它分割成多条短信发送。
假设已经知道你当月所发送的短信的字数，试统计一下你当月短信的总资费。
输入格式
第一行是整数n，表示当月发送短信的总次数，接着n行每行一个整数，表示每次短信的字数。
输出格式
输出一行，当月短信总资费，单位为元，精确到小数点后1位。
输入样例
10
39
49
42
61
44
147
42
72
35
4
输出样例
1.3
#include<stdio.h>
int main(){
int n; // 定义变量n，表示行李件数
scanf("%d",&n); // 输入行李件数
int a[n]; // 定义数组a，存储每件行李的重量（单位：克）
double s=0; // 定义总费用s，并初始化为0
// 输入每件行李的重量并计算费用
for (int i=0;i<n;i++){
scanf("%d",&a[i]); // 输入第i件行李的重量
// 计算单件行李的运费
if (a[i]<=70){ // 如果重量不超过70克
s+=0.1; // 费用0.1元
}else{ // 如果重量超过70克
// 每超过70克（不足70克按70克计算）加收0.1元
// (a[i]+69)/70 实现向上取整，计算70克的倍数
s+=((a[i]+69)/70)*0.1;
}
}
printf("%.1f",s); // 输出总费用，保留一位小数
return 0; // 程序正常结束
}
5.E球弹跳高度的计算
一球从某一高度h落下(单位米，n≤1,000,000)，每次落地后反跳回原来高度的一半，再落下。编程计算气球在第10次落地时，共经过多少米? 第10次反弹多高？
输出包含两行，第1行：到球第10次落地时，一共经过的米数。第2行：第10次弹跳的高度。
输出结果保留小数点后4位。
输入格式
输入一个正数h，表示球的初始高度。
输出格式
第1行：到球第10次落地时，一共经过的米数。
第2行：第10次弹跳的高度。
如输入
20
输出
59.9219
0.0195
#include<stdio.h>
int main(){
int h; // 定义变量h，表示初始下落高度
scanf("%d",&h); // 输入初始高度
double h2 = h; // h2用于记录每次反弹的高度，初始为h
double s = 0; // s记录总路程（包括下落和反弹）
// 模拟10次下落和反弹过程
for (int i=0;i<10;i++){
s += h2 * 2; // 每次过程包括下落h2和反弹h2，共2*h2路程
h2 /= 2; // 反弹高度减半
}
s = s - h; // 减去最后一次反弹的高度（因为只计算10次落地，第10次反弹不计入）
// 输出结果
printf("%.4f\n%.4f\n",s,h2); // 第一行输出总路程，第二行输出第10次反弹高度
return 0; // 程序正常结束
}
6.E年龄与疾病
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。
输入格式
共2行，第一行为过往病人的数目n（0 < n ≤ 100)，第二行为每个病人患病时的年龄。
输出格式
按照0-18、19-35、36-60、61以上(含61)四个年龄段输出该段患病人数占总患病人数的比例，以百分比的形式输出，精确到小数点后两位。每个年龄段占一行，共四行。
输入样例
10
1 11 21 31 41 51 61 71 81 91
输出样例
20.00%
20.00%
20.00%
40.00%
#include<stdio.h>
int main(){
int n; // 定义变量n，表示调查人数
scanf("%d",&n); // 输入调查人数
int a[n]; // 定义数组a，存储每个人的年龄
// 定义数组b，统计四个年龄段的人数：
// b[0]: 0-18岁, b[1]: 19-35岁, b[2]: 36-60岁, b[3]: 60岁以上
int b[] = {0,0,0,0};
// 输入每个人的年龄并进行年龄段统计
for (int i=0;i<n;i++){
scanf("%d",&a[i]); // 输入第i个人的年龄
// 根据年龄范围进行统计
if (a[i]<=18){ // 年龄在0-18岁（包含18岁）
b[0]+=1; // 第一年龄段人数加1
}else if(a[i]<=35){ // 年龄在19-35岁（包含35岁）
b[1]+=1; // 第二年龄段人数加1
}else if(a[i]<=60){ // 年龄在36-60岁（包含60岁）
b[2]+=1; // 第三年龄段人数加1
}else{ // 年龄在60岁以上
b[3]+=1; // 第四年龄段人数加1
}
}
// 计算并输出每个年龄段的百分比
for (int i=0;i<4;i++){
double p = b[i] * 100.00 / n; // 计算百分比
printf("%.2f%%\n",p); // 输出百分比，保留两位小数
}
return 0; // 程序正常结束
}
7.E骑车与走路
在清华校园里，没有自行车，上课办事会很不方便。但实际上。并非去办任何事情都是骑车快,因为骑车总要找车、开锁、停车、锁车等,这要耽误一些时间。假设找到自行车，开锁并车上自行车的时间为27秒；停车锁车的时间为23秒；步行每秒行走1.2米，骑车每秒行走3.0米。请判断走不同的距离去办事,是骑车快还是走路快。如果骑车快，输出一行"Bike"；如果走路快，输出一行"Walk"；如果一样快，输出一行"All"。
输入格式
输入一行，包含一个整数，表示一次办事要行走的距离,单位为米。
输出格式
输出一行,如果骑车快,输出一行"Bike";如果走路快,输出一行"Walk";如果一样快,输出一行"All"。
输入样例
120
输出样例
Bike
#include<stdio.h>
int main(){
double n; // 定义变量n，表示距离（单位：公里）
scanf("%lf",&n); // 输入距离
// 计算骑自行车所需时间
// 27秒：开锁时间，23秒：停车时间，n/3.0：骑行时间（速度3米/秒 = 10.8公里/小时）
double t1 = 27 + 23 + n / 3.0;
// 计算步行所需时间
// n/1.2：步行时间（速度1.2米/秒 = 4.32公里/小时）
double t2 = n / 1.2;
// 比较两种出行方式的时间，选择更快的
if (t1 < t2){ // 如果骑自行车更快
printf("Bike\n"); // 输出骑自行车
}else if(t1 == t2){ // 如果时间相同
printf("All\n"); // 输出两种方式都可以
}else{ // 如果步行更快
printf("Walk\n"); // 输出步行
}
return 0; // 程序正常结束
}
8.E交水费
小明家住湘潭，按照湘潭的水费政策实行阶梯水价。具体这么规定的：第一档水量：月用水量15吨以下（含15吨）；第二档水量：月用水量15吨至22吨（含22吨）；第三档水量：月用水量22吨以上。
第一档水价2.58元/吨，第二档水价3.34元/吨，第三档水价4.09元/吨。
请你帮小明算一下，他每个月应交的水费。水费是以分为单位的整数。
比如用水量15吨，应交水费3870； 若用水量20吨，应交水费5540；若用水量25吨，应交水费7435。
输入格式
一个大于等于0小于10000的整数，表示用水量（吨）
输出格式
一个整数，表示应交的水费（单位：分）
输入样例
24
输出样例
7026
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int p;
if (n<=15){
p=n*258;
}else if(n<=22){
p=15*258+(n-15)*334;
}else{
p=15*258+7*334+(n-22)*409;
}
printf("%d",p);
return 0;
}
9.M成绩排序
给定n（1≤n≤100）个学生的姓名和成绩，按照成绩从高到低排序输出。学生的姓名不会重复，如果有成绩相同的，则原来在名单中靠前的同学仍然排列在前面。
例如有一个班的成绩如下：
Deirdr 89
Sheil 50
Cynthi 63
Rene 66
Emm 46
Myrn 42
Nicol 63
Prudenc 66
Adel 79
排序之后为：
Deirdr 89
Adel 79
Rene 66
Prudenc 66
Cynthi 63
Nicol 63
Sheil 50
Emm 46
Myrn 42
注意：Rene排在Prudenc之前，Cynthi排在Nicol之前。
输入格式
第一行是一个整型数n，表示后面有n个学生的数据。从第二行到第n+1行，每行表示一个学生的数据，第一列是学生的姓名，第二列是学生的成绩（都是100以内的正整数），中间以空格分隔
输出格式
排序得到的结果，每行一个学生的数据，第一列是姓名，第二列是他的成绩，中间以空格分隔。
输入样例
6
Jesu 76
Ia 90
Conno 80
Carso 75
Ayde 79
Austi 78
输出样例
Ia 90
Conno 80
Ayde 79
Austi 78
Jesu 76
Carso 75
#include<stdio.h>
// 定义学生结构体，包含姓名和成绩
struct Student{
char name[50]; // 学生姓名，最多49个字符+1个结束符
int score; // 学生成绩
};
int main(){
int n; // 定义变量n，表示学生人数
scanf("%d",&n); // 输入学生人数
struct Student stu[n]; // 定义学生数组，大小为n
// 输入每个学生的姓名和成绩
for (int i=0;i<n;i++){
// 注意：name是数组，不需要加&
scanf("%s %d",stu[i].name,&stu[i].score);
}
// 使用冒泡排序按成绩降序排列
// 外层循环控制排序轮数
for(int i=0;i<n;i++){
// 内层循环进行相邻元素比较和交换
for(int j=0;j<n-1-i;j++){
// 如果前一个成绩小于后一个成绩，则交换位置
if(stu[j].score<stu[j+1].score){
// 交换两个学生的完整信息
struct Student temp=stu[j];
stu[j]=stu[j+1];
stu[j+1]=temp;
}
}
}
// 输出排序后的学生信息
for (int i=0;i<n;i++){
printf("%s %d\n",stu[i].name,stu[i].score);
}
return 0; // 程序正常结束
}
10.E自由落体时间
一个物体从高度h米（h≤100000000）的地方从静止开始自由落体，不计空气阻力，设重力加速度为9.8m/s^2，求落地所需时间（单位为秒），保留小数点后面2位数字.
例如高度9.8米，落地时间为1.41秒
再比如高度为100米，落地时间为4.52秒
输入格式
一个浮点数，表示高度
输出格式
一个浮点数，计算出来的秒数，小数点后保留两位小数
输入样例
1.25
输出样例
0.51
#include<stdio.h>
#include<math.h>
int main(){
double h;
scanf("%lf",&h);
double t=sqrt(2*h/9.8);
printf("%.2f",t);
return 0;
}
11.E苹果和虫子
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？
输入格式
输入仅一行，包括n，x和y（均为整数）。
输出格式
输出也仅一行，剩下的苹果个数。
输入样例
10 4 9
输出样例
7
#include<stdio.h>
int main(){
int n, x, y; // n-苹果总数，x-吃一个苹果的时间，y-剩余时间
scanf("%d %d %d", &n, &x, &y); // 输入三个整数
// 计算能吃多少个苹果：(y+x-1)/x 是向上取整，表示在y分钟内最多能吃几个苹果
int p = n - (y + x - 1) / x; // 剩余苹果数 = 总数 - 已吃苹果数
if (p < 0){ // 如果计算结果为负数（苹果不够吃）
p = 0; // 则剩余苹果数为0
}
printf("%d\n", p); // 输出剩余苹果数
return 0; // 程序正常结束
}
12.E大象喝水
一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。
输入格式
输入有一行：包行两个整数，以一个空格分开，分别表示小圆桶的深h和底面半径r，单位都是厘米。
输出格式
输出一行，包含一个整数，表示大象至少要喝水的桶数。
输入样例
23 11
输出样例
3
#include<stdio.h>
#include<math.h> // 引入数学库，使用ceil函数
int main(){
int h, r; // h-桶的高度，r-桶的底面半径（单位：厘米）
scanf("%d %d", &h, &r); // 输入高度和半径
// 计算桶的容积（升）：V = πr²h，再除以1000将立方厘米转换为升
double v = 3.1415926 * r * r * h * 0.001;
// 计算需要多少桶水：20升 ÷ 每桶容积，使用ceil向上取整
int p = ceil(20.0 / v); // 20.0确保浮点数运算
printf("%d\n", p); // 输出所需桶数
return 0; // 程序正常结束
}
13.E不高兴的津津
津津上初中了。妈妈认为津津应该更加用功学习，所以津津除了上学之外，还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢琴。但是津津如果一天上课超过八个小时就会不高兴，而且上得越久就会越不高兴。假设津津不会因为其它事不高兴，并且她的不高兴不会持续到第二天。请你帮忙检查一下津津下周的日程安排，看看下周她会不会不高兴；如果会的话，哪天最不高兴。
输入格式
包括七行数据，分别表示周一到周日的日程安排。每行包括两个小于10的非负整数，用空格隔开，分别表示津津在学校上课的时间和妈妈安排她上课的时间。
输出格式
包括一行，这一行只包含一个数字。如果不会不高兴则输出0，如果会则输出最不高兴的是周几（用1, 2, 3, 4, 5, 6, 7分别表示周一，周二，周三，周四，周五，周六，周日）。如果有两天或两天以上不高兴的程度相当，则输出时间最靠前的一天。
输入样例
5 3
6 2
7 2
5 3
5 4
0 4
0 6
输出样例
3
#include<stdio.h>
int main (){
int s, e; // s-学校学习时间，e-课外学习时间（单位：小时）
int mt = 0; // 记录最长的总学习时间
int md = 0; // 记录最长学习时间对应的日期（星期几）
// 循环7天（星期一至星期日）
for(int i = 1; i <= 7; i++){
scanf("%d %d", &s, &e); // 输入当天的学校学习时间和课外学习时间
int t = s + e; // 计算当天的总学习时间
// 如果当天总学习时间超过8小时
if (t > 8){
// 如果当天总学习时间比之前记录的最长学习时间更长
if (t > mt) {
mt = t; // 更新最长学习时间
md = i; // 更新对应日期
}
}
}
printf("%d", md); // 输出最不高兴的日期（如果都没有超过8小时，输出0）
return 0; // 程序正常结束
}
14.E矩阵中的最小元素
给定一个5X5的整数矩阵，找出其中最小的元素，输出所在的行号、列号和元素值，其中行号和列号都从0开始。
例如，有矩阵：
5 86 53 50 18
25 67 79 44 68
79 63 24 84 100
42 30 59 47 37
28 10 32 23 81
其中最小元素的行号和列号都是0，值是5
输入格式
一个5X5的矩阵，数据之间用空格隔开
输出格式
一行，依次输出最小元素所在的行号、列号和值，中间以两个空格分隔
输入样例
62 54 79 82 33
88 45 91 14 58
71 53 11 59 35
35 37 14 46 67
85 63 72 99 30
输出样例
2 2 11
#include<stdio.h>
int main(){
int m[5][5]; // 定义一个5×5的二维数组（矩阵）
int mir = 0; // 记录最小值所在的行号
int mic = 0; // 记录最小值所在的列号
// 输入5×5矩阵的所有元素
for(int i = 0; i < 5; i++){
for (int j = 0; j < 5; j++){
scanf("%d", &m[i][j]); // 输入第i行第j列的元素
}
}
// 初始化最小值为矩阵的第一个元素
int miv = m[0][0]; // miv记录最小值
// 遍历整个矩阵，寻找最小值及其位置
for (int i = 0; i < 5; i++){
for (int j = 0; j < 5; j++){
// 如果当前元素小于记录的最小值
if (miv > m[i][j]){
miv = m[i][j]; // 更新最小值
mir = i; // 更新最小值所在的行号
mic = j; // 更新最小值所在的列号
}
}
}
// 输出最小值的位置和值：行号 列号 最小值
printf("%d %d %d", mir, mic, miv);
return 0; // 程序正常结束
}
15.M流感传染
有一批易感人群住在网格状的宿舍区内，宿舍区为nn的矩阵，每个格点为一个房间，房间里可能住人，也可能空着。在第一天，有些房间里的人得了流感，以后每天，得流感的人会使其邻居传染上流感，（已经得病的不变），空房间不会传染。请输出第m天得流感的人数。
输入格式
第一行一个数字n，n不超过100，表示有n*n的宿舍房间。
接下来的n行，每行n个字符，’.’表示第一天该房间住着健康的人，’#’表示该房间空着，’@’表示第一天该房间住着得流感的人。
接下来的一行是一个整数m，m不超过100。
输出格式
输出第m天，得流感的人数。
输入样例
5
....#
.#.@.
.#@..
#....
.....
4
输出样例
16
#include<stdio.h>
int main (){
int n, m; // n-网格大小，m-总天数
scanf("%d", &n); // 输入网格大小
char r[n][n]; // 定义n×n的字符网格，表示人群状态
int day = 1, c = 0; // day-当前天数（初始为1），c-感染者计数
// 输入初始网格状态，注意" %c"中的空格用于跳过空白字符
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
scanf(" %c", &r[i][j]); // 读取一个字符（忽略前导空白符）
}
}
scanf("%d", &m); // 输入总天数
// 模拟病毒传播过程（从第2天到第m天）
for (int d = 2; d <= m; d++){
// 第一步：标记新感染者（'.'变为'*'表示将被感染）
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if (r[i][j] == '.'){ // 如果是健康人
// 检查上下左右四个方向是否有感染者
if( (i > 0 && r[i-1][j] == '@') || // 上方
(i < n-1 && r[i+1][j] == '@') || // 下方
(j > 0 && r[i][j-1] == '@') || // 左方
(j < n-1 && r[i][j+1] == '@') ){ // 右方
r[i][j] = '*'; // 标记为将要被感染
}
}
}
}
// 第二步：将标记的新感染者变为正式感染者（'*'变为'@'）
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
if (r[i][j] == '*'){
r[i][j] = '@'; // 正式变为感染者
}
}
}
}
// 统计最终感染者数量
for (int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if (r[i][j] == '@'){ // 如果是感染者
c++; // 感染者计数加1
}
}
}
printf("%d\n", c); // 输出最终感染者总数
return 0; // 程序正常结束
}
16.E简单排序
输入11个整数，如果第1个数为1，则将其中的第2至11个数升序排列；如果第1个数为0，则降序排列。
输入格式
输入一行，包含11个整数，用空格符分隔。
输出格式
输出1行，包含10个顺序排列的整数，用空格符分隔。
输入样例
1 2 3 5 7 9 1 4 8 6 10
输出样例
1 2 3 4 5 6 7 8 9 10
#include<stdio.h>
int main(){
int a[11]; // 定义数组a，包含11个元素（a[0]是排序方式标志，a[1]到a[10]是需要排序的10个数）
// 输入11个整数：第一个是排序方式标志，后面10个是需要排序的数
for (int i = 0; i < 11; i++){
scanf("%d", &a[i]);
}
// 如果a[0]等于1，进行升序排序（从小到大）
if (a[0] == 1){
// 冒泡排序（升序）：对a[1]到a[10]这10个数进行排序
for (int i = 1; i < 11; i++){ // 外层循环控制排序轮数
for (int j = 1; j <= 10 - i; j++){ // 内层循环进行相邻元素比较
if (a[j] > a[j + 1]){ // 如果前一个元素大于后一个元素
int temp = a[j]; // 交换两个元素的位置
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
// 如果a[0]不等于1（通常为0），进行降序排序（从大到小）
else{
// 冒泡排序（降序）：对a[1]到a[10]这10个数进行排序
for (int i = 1; i < 11; i++){ // 外层循环控制排序轮数
for (int j = 1; j <= 10 - i; j++){ // 内层循环进行相邻元素比较
if (a[j] < a[j + 1]){ // 如果前一个元素小于后一个元素
int temp = a[j]; // 交换两个元素的位置
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
// 输出排序后的10个数（a[1]到a[10]）
for (int i = 1; i < 11; i++){
printf("%d ", a[i]);
}
return 0; // 程序正常结束
}
17.E求阶乘的和
给定正整数n，求不大于n（n≤13）的正整数的阶乘的和（即求1!+2!+3!+...+n!），输出阶乘的和。
输入格式
输入有一行，包含一个正整数n（1 < n < 12）。
输出格式
输出有一行：阶乘的和。
输入样例
5
输出样例
153
#include<stdio.h>
int main(){
int n; // 定义变量n，表示需要计算的阶乘和的项数
scanf("%d", &n); // 输入n的值
long long s = 0; // 定义变量s，用于存储阶乘和，使用long long防止溢出
long long f = 1; // 定义变量f，用于存储当前项的阶乘值，初始化为1
// 循环计算1! + 2! + 3! + ... + n!
for (int i = 1; i <= n; i++){
f *= i; // 计算i! = (i-1)! * i（利用前一项的阶乘值）
s += f; // 将当前阶乘值累加到总和s中
}
printf("%lld", s); // 输出阶乘和，使用%lld格式符
return 0; // 程序正常结束
}
18.E与指定数字相同的数的个数
输出一个整数序列中与指定数字相同的数的个数。输入包含2行：第1行为N和m，N表示整数序列的长度(N≤100)；m表示指定的数字；第2行为N个整数，整数之间以空格分开。输出为N个数中与m相同的数的个数。
输入格式
第1行为N和m，表示整数序列的长度(N≤100)和指定的数字， 中间用一个空格分开；
第2行为N个整数，整数之间以一个空格分开。
输出格式
输出为N个数中与m相同的数的个数。
输入样例
3 2
2 3 2
输出样例
2
#include<stdio.h>
int main(){
int N, m; // N-序列长度，m-需要查找的特定值
scanf("%d %d", &N, &m); // 输入序列长度和特定值
int a[N]; // 定义长度为N的数组
int cnt = 0; // 计数器，记录特定值出现的次数
// 读取序列并统计特定值出现的次数
for(int i = 0; i < N; i++){
scanf("%d", &a[i]); // 输入第i个数
if (a[i] == m){ // 如果当前数等于特定值m
cnt++; // 计数器加1
}
}
printf("%d", cnt); // 输出特定值出现的次数
return 0; // 程序正常结束
}
19.ME开关灯
假设有N盏灯(N为不大于5000的正整数)，从1到N按顺序依次编号，初始时全部处于开启状态；有M个人(M为不大于N的正整数)也从1到M依次编号。
第一个人(1号)将灯全部关闭，第二个人(2号)将编号为2的倍数的灯打开，第三个人(3号)将编号为3的倍数的灯做相反处理（即将打开的灯关闭，将关闭的灯打开）。依照编号递增顺序，以后的人都和3号一样，将凡是自己编号倍数的灯做相反处理。
请问：当第M个人操作之后，哪几盏灯是关闭的，按从小到大输出其编号，其间用逗号间隔。
输入格式
输入正整数N和M，以单个空格隔开。
输出格式
顺次输出关闭的灯的编号，其间用逗号间隔。
输入样例
12
6
输出样例
1,4,7,8,10,11,12
#include<stdio.h>
int main(){
int N, M; // N-灯的数量，M-人的数量
scanf("%d", &N); // 输入灯的数量
scanf("%d", &M); // 输入人的数量
int l[N+1]; // 定义状态数组l[1..N]，记录每盏灯的开关状态（0-关，1-开）
// 初始化所有灯为关闭状态（0表示关闭）
for (int i = 1; i <= N; i++){
l[i] = 0;
}
// 模拟M个人依次操作灯的过程
for (int p = 2; p <= M; p++){ // p表示第p个人（编号从2开始）
// 第p个人会操作所有编号是p的倍数的灯
for(int i = p; i <= N; i += p){
l[i] = !l[i]; // 反转灯的开关状态（0变1，1变0）
}
}
// 输出最终关闭的灯的编号
int f = 1; // 标记是否为第一个输出的数（用于控制逗号）
for(int i = 1; i <= N; i++){
if(l[i] == 0){ // 如果灯是关闭状态
if(!f) printf(","); // 如果不是第一个数，先输出逗号
printf("%d", i); // 输出灯的编号
f = 0; // 将标记设为0（表示已有输出）
}
}
return 0; // 程序正常结束
}
20.ME个人所得税
我国从2021年元月起，执行新的个人所得税征收办法，按纳税年度合并计算个人所得税，如全年收入不超过6万元，应缴税率0%；如超过6万元，应先减去6万元，再按照下面的超额累进税率进行计算：
不超过36000元的部分,应缴税率3%；
超过36000元至144000元的部分，应缴税率10%；
超过144000元至300000元的部分，应缴税率20%；
超过300000元至420000元的部分，应缴税率25%；
超过420000元至660000元的部分，应缴税率30%；
超过660000元至960000元的部分，应缴税率35%；
超过960000的部分，应缴税率45%。
如某人年收入50000元，应缴税款0元；
年收入96000元，应缴税款1080元；
年收入120000元，应缴税款3480元；
年收入240000元，应缴税款19080元；
年收入360000元，应缴税款43080元；
年收入480000元，应缴税款73080元；
年收入1200000元，应缴税款331080元。
输入格式
一个正整数n（0≤n≤10,000,000），表示全年收入
输出格式
一个正整数，表示应缴税款。如税款带有小数部分，则舍去小数部分。
输入样例
66000
输出样例
180
#include<stdio.h>
int main(){
long long n; // 定义变量n，表示年收入（单位：元）
scanf("%lld", &n); // 输入年收入
long long tax = 0; // 定义变量tax，表示应缴税款，初始化为0
// 定义应纳税所得额区间上限（分档阈值）
// 注意：已扣除60000元基本减除费用后的金额
long long l[] = {0, 36000, 144000, 300000, 420000, 660000, 960000, 1000000000};
// 定义对应区间的税率（单位：%）
int r[] = {3, 10, 20, 25, 30, 35, 45};
// 计算应纳税所得额：年收入 - 60000元基本减除费用
long long p = n - 60000;
// 如果年收入不超过60000元，不需要缴税
if (n <= 60000){
tax = 0;
}
// 累进税率计算：根据应纳税所得额所在区间，按不同税率分段计算
for (int i = 0; i < 7; i++){ // 遍历7个税率区间
if(p > l[i]){ // 如果应纳税所得额超过当前区间下限
long long a; // 定义变量a，表示当前区间的应纳税额
// 计算当前区间的应纳税额
if(p <= l[i+1]){ // 如果应纳税所得额在当前区间内
a = p - l[i]; // 只计算超过当前区间下限的部分
}else{ // 如果应纳税所得额超过当前区间
a = l[i+1] - l[i]; // 按当前区间全额计算
}
// 累加当前区间的税款：应纳税额 × 税率 ÷ 100
tax += a * r[i] / 100;
}
}
printf("%lld\n", tax); // 输出应缴税款
return 0; // 程序正常结束
}
21.E奇数求和
计算非负整数m到n(包括m和n)之间的所有奇数的和，其中，m 不大于 n，且n 不大于300。例如 m=3, n=12, 其和则为：3+5+7+9+11=35。
输入格式
两个数 m 和 n，两个数以一个空格分开，其中 0 ≤ m ≤ n ≤ 300 。
输出格式
输出一行，包含一个整数，表示m 到 n（包括m 和 n ）之间的所有奇数的和。
输入样例
7 15
输出样例
55
#include<stdio.h>
int main(){
int m, n; // 定义变量m和n，表示区间的起始和结束
scanf("%d %d", &m, &n); // 输入区间范围[m, n]
int s = 0; // 定义变量s，用于存储奇数的累加和，初始化为0
// 遍历区间[m, n]中的所有整数
for (int i = m; i <= n; i++){
if (i % 2 != 0){ // 判断当前数i是否为奇数（不能被2整除）
s += i; // 如果是奇数，累加到总和s中
}
}
printf("%d", s); // 输出区间内所有奇数的和
return 0; // 程序正常结束
}
22.E求小数的某一位
分数a/b化为小数后，小数点后第n位的数字是多少？其中0 < a < b < 100，1≤n≤10000。
输入格式
三个正整数a，b，n，相邻两个数之间用单个空格隔开。
输出格式
一个数字
输入样例
1 2 1
输出样例
5
#include<stdio.h>
int main(){
int a, b, n; // a-被除数，b-除数，n-需要计算的小数点后第n位
scanf("%d %d %d", &a, &b, &n); // 输入三个整数
int r = a % b; // 计算a除以b的余数，作为小数部分计算的起始值
int d; // 用于存储当前计算的小数位
// 模拟除法运算，计算小数点后第n位
for(int i = 1; i <= n; i++){
r *= 10; // 将余数乘以10，相当于在余数后加一个0
d = r / b; // 计算当前小数位的值：新余数 ÷ 除数
r = r % b; // 更新余数，为下一次计算做准备
}
printf("%d\n", d); // 输出小数点后第n位的数字
return 0; // 程序正常结束
}
23.E判断闰年
判断某年是否是闰年。如果是闰年则输出Y，否则输出N。
注意：能被4整除的年份不一定是闰年，比如1900不是闰年，因为它能被100整除，而不能被400整除。2000年是闰年，因为它能被400整除。1984、1988是闰年，它们都能被4整除而不能被100整除。
输入格式
输入只有一行，包含一个整数a(0 ≤ a ≤10000)。
输出格式
一行，如果公元a年是闰年输出Y，否则输出N。
输入样例
2006
输出样例
N
#include<stdio.h>
int main(){
int a;
scanf("%d",&a);
if ((a%4==0 && a%100!=0)||a%400==0){
printf("Y");
}else{
printf("N");
}
return 0;
}
24.E判断一个数能否同时被3和5整除
判断一个数n 能否同时被3和5整除，如果能同时被3和5整除输出YES，否则输出NO。
例如当n=30，输出：YES 当n=81，输出：NO
输入格式
输入一行，包含一个整数n。（ -1,000,000 ≤n ≤ 1,000,000）
输出格式
输出一行，如果能同时被3和5整除输出YES，否则输出NO
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
if (n%3==0 &&n%5==0){
printf("YES");
}else{
printf("NO");
}
return 0;
}
25.E字符三角形
给定一个字符，用它构造一个底边长5个字符，高3个字符的等腰字符三角形。
输入格式
只有一行，就是一个字符。
输出格式
三行，每行都是由输入的字符组成，字符个数分别是1、3、5。
输入样例
*
输出样例
*
#include<stdio.h>
int main(){
char a; // 定义字符变量a，用于存储输入的字符
scanf("%c", &a); // 输入一个字符，通常为字母或符号
// 第一行：输出两个空格后跟一个字符，形成金字塔顶部
printf(" %c\n", a);
// 第二行：输出一个空格后跟三个字符，形成金字塔中间层
printf(" %c%c%c\n", a, a, a);
// 第三行：直接输出五个字符，形成金字塔底层
printf("%c%c%c%c%c\n", a, a, a, a, a);
return 0; // 程序正常结束
}
26.E判断能否被3，5，7整除
给定一个整数，判断它能否被3，5，7整除，并输出以下信息：
1、能同时被3，5，7整除（直接输出3 5 7，每个数中间一个空格）；
2、只能被其中两个数整除（输出两个数，小的在前，大的在后。例如：3 5或者 3 7或者5 7，中间用空格分隔）；
3、只能被其中一个数整除（输出这个除数）；
4、不能被任何数整除，输出小写字符‘n’，不包括单引号。
输入格式
输入一行，包括一个整数。
输出格式
输出一行，按照描述要求给出整数被3，5，7整除的情况。
输入样例
105
输出样例
3 5 7
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int f1,f2,f3;
f1=(n%3==0);
f2=(n%5==0);
f3=(n%7==0);
if (f1&&f2&&f3){
printf("3 5 7");
}else if(f1 &&f2){
printf("3 5");
}else if(f1 &&f3){
printf("3 7");
}else if(f2 &&f3){
printf("5 7");
}else if (f1){
printf("3");
}else if (f2){
printf("5");
}else if (f3){
printf("7");
}else{
printf("n");
}
return 0;
}
27.E打印ASCII码
输入一个除空格以外的可见字符（可以用键盘输入的字符），输出其ASCII码。
输入格式
一个除空格以外的可见字符。
输出格式
一个十进制整数，即该字符的ASCII码。
输入样例
A
输出样例
65
#include<stdio.h>
int main(){
char c;
scanf("%c",&c);
printf("%d",c);
return 0;
}
28.E计算分数的浮点数值
两个整数a和b分别作为分子和分母，既分数a/b，求它的浮点数值(双精度浮点数，保留小数点后9位)。
输入格式
输入仅一行，包括两个整数a和b。
输出格式
输出也仅一行，分数 a/b 的浮点数值（双精度浮点数，保留小数点后9位）。
输入样例
5 7
输出样例
0.714285714
#include<stdio.h>
int main(){
double a,b;
scanf("%lf %lf",&a,&b);
double c=a/b;
printf("%.9f",c);
return 0;
}
29.E对齐输出
读入三个整数，按每个整数占8个字符的宽度，右对齐输出它们。
输入格式
只有一行，按照格式要求依次输入三个整数，之间以一个空格分开。
输出格式
只有一行，三个整数，即输入三个整数。
输入样例
123456789 0 -1
输出样例
123456789 0 -1
#include<stdio.h>
int main(){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
printf("%8d %8d %8d\n",a,b,c);
return 0;
}
30.E合法C标识符
给定一个不包含空白符的字符串，请判断是否是C语言合法的标识符号(注：题目保证这些字符串一定不是C语言的保留字)。
C语言标识符要求：
1.非保留字；2.只包含字母、数字及下划线（“_”）。3.不以数字开头。
输入格式
一行，包含一个字符串，字符串中不包含任何空白字符，且长度不大于20。
输出格式
一行，如果它是C语言的合法标识符，则输出yes，否则输出no。
输入样例
RKPEGX9R;TWyYcp
输出样例
no
#include<stdio.h>
#include<ctype.h> // 引入字符类型判断函数库
int main(){
char s[21]; // 定义字符数组s，最多存储20个字符+1个结束符
scanf("%s", s); // 输入一个字符串（标识符）
int f = 1; // 标识符合法性标志，1-合法，0-非法
// 检查第一个字符：必须是字母或下划线
if (!(isalpha(s[0]) || s[0] == '_')){
f = 0; // 第一个字符不合法，标记为非法
}else{
// 检查后续字符：必须是字母、数字或下划线
for (int i = 1; s[i] != '\0'; i++){
if(!(isalpha(s[i]) || isdigit(s[i]) || s[i] == '_')){
f = 0; // 当前字符不合法，标记为非法
break; // 跳出循环，不再检查后续字符
}
}
}
// 输出结果
if(f){
printf("yes"); // 标识符合法
}else{
printf("no"); // 标识符非法
}
return 0; // 程序正常结束
}
31.E最大最小值
给定n个整数，求出其中的最大值和最小值
比如给定9个整数： 12 45 62 35 74 11 96 32，最大值是96，最小值是11
再比如给定10个整数：14 52 63 69 58 47 10 5 99 88，最大值是99，最小值是5
再比如给定12个整数：15 25 84 74 96 2 30 14 25 18 55 33，最大值是96，最小值是2
输入格式
两行。第一行是一个正整数n（2≤n≤10,000），表示后续的整数个数。第二行是n个正整数，中间以1个空格分隔。
输出格式
两个整数值，第一个是最大值，第二个是最小值，中间以2个空格分隔
输入样例
15
12 32 69 84 71 20 35 31 25 29 68 36 48 47 9
输出样例
84 9
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int a[n];
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
int max=a[0],min=a[0];
for (int i=1;i<n;i++){
if (a[i]>max){
max=a[i];
}
if (a[i]<min){
min=a[i];
}
}
printf("%d %d",max,min);
return 0;
}
32.E幂的末尾
a^b的末3位数是多少？
输入格式
两个正整数a，b。1≤a≤100，1≤b≤10000。
输出格式
从高位到低位输出幂的末三位数字，中间无分隔符。若幂本身不足三位，在前面补零。
输入样例
7 2011
输出样例
743
#include<stdio.h>
int main(){
int a, b; // a-底数，b-指数
scanf("%d %d", &a, &b); // 输入底数和指数
long long c = 1; // 初始化结果为1，使用long long防止中间结果溢出
// 循环计算a的b次方，每次计算后取模1000（只保留后三位）
for(int i = 0; i < b; i++){
c = (c * a) % 1000; // 每次乘法后立即取模，避免溢出
}
printf("%03d", (int)c); // 输出结果，使用%03d格式：至少3位，不足补0
return 0; // 程序正常结束
}
33.E求一元二次方程
求一元二次方程“ax^2+bx+c=0”的根，其中a不等于0。结果要求精确到小数点后5位。
若两个实根相等，则输出形式为：“x1=x2=XXX.XXXXX”；
若两个实根不等，需满足根小者在前的原则，中间用分号隔开，输出形式为：“x1=XX.XXXXX;x2=XX.XXXXX"；
若无实根输出“No answer!”。
输入格式
输入一行，包含三个浮点数a, b, c（它们之间以一个空格分开），分别表示方程a的系数。
输出格式
输出一行，表示方程的解。
所有输出部分要求精确到小数点后5位，数字、符号之间没有空格。
输入样例
-15.97 19.69 12.02
输出样例
x1=-0.44781;x2=1.68075
#include<stdio.h>
#include<math.h> // 引入数学库，使用sqrt函数计算平方根
int main(){
double a, b, c; // 定义变量a,b,c，分别表示二次方程的系数
scanf("%lf %lf %lf", &a, &b, &c); // 输入三个系数
double d = b * b - 4 * a * c; // 计算判别式 Δ = b² - 4ac
double x1, x2; // 定义两个根x1和x2
// 根据判别式的值分类讨论
if (d < 0){ // 判别式小于0，方程无实数根
printf("No answer!");
}else if(d == 0){ // 判别式等于0，方程有两个相等的实数根
x1 = -b / (2 * a); // 计算唯一根 x = -b/(2a)
printf("x1=x2=%.5f", x1); // 输出根，保留5位小数
}else{ // 判别式大于0，方程有两个不同的实数根
// 计算两个根：x1 = (-b - √Δ)/(2a), x2 = (-b + √Δ)/(2a)
x1 = (-b - sqrt(d)) / (2 * a);
x2 = (-b + sqrt(d)) / (2 * a);
// 确保x1小于x2（按从小到大的顺序输出）
if(x1 > x2){
double t = x1; // 临时变量用于交换
x1 = x2;
x2 = t;
}
// 输出两个根，保留5位小数
printf("x1=%.5f;x2=%.5f", x1, x2);
}
return 0; // 程序正常结束
}
34.E有一门课不及格的学生
给出一名学生的语文和数学成绩，判断他是否恰好有一门课不及格(成绩小于60分)。若该生恰好有一门课不及格，输出1；否则输出0。
输入格式
一行，包含两个在0到100之间的整数，分别是该生的语文成绩和数学成绩。
输出格式
若该生恰好有一门课不及格，输出1；否则输出0。
输入样例
50 80
输出样例
1
#include<stdio.h>
int main(){
int a,b;
scanf("%d %d",&a,&b);
if ((a<60 && b>=60)||(a>=60 && b<60)){
printf("1");
}else{
printf("0");
}
return 0;
}
35.E奇偶数判断
给定一个整数，判断该数是奇数还是偶数。如果n是奇数，输出odd；如果n是偶数，输出even。
输入格式
输入仅一行，一个大于零的正整数n。
输出格式
输出仅一行，如果n是奇数，输出odd;如果n是偶数，输出even。
输入样例
5
输出样例
odd
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
if(n%2==0){
printf("even");
}else{
printf("odd");
}
return 0;
}
36.E收集瓶盖赢大奖
某饮料公司最近推出了一个“收集瓶盖赢大奖”的活动：如果你拥有10个印有“幸运”、或20个印有“鼓励”的瓶盖，就可以兑换一个神秘大奖。现分别给出你拥有的印有“幸运”和“鼓励”的瓶盖数，判断是否可以去兑换大奖。若可以兑换大奖，输出1，否则输出0。
输入格式
一行，包含两个整数，分别是印有“幸运”和“鼓励”的瓶盖数，用一个空格隔开。
输出格式
一行。若可以兑换大奖，输出1，否则输出0。
输入样例
11 19
输出样例
1
#include<stdio.h>
int main(){
int a,b;
scanf("%d %d",&a,&b);
if(a>=10 || b>=20){
printf("1");
}else{
printf("0");
}
return 0;
}
37.D奖学金
某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末，每个学生都有3门课的成绩:语文、数学、英语。先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯一确定的。
任务：先根据输入的3门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前五名名学生的学号和总分。注意，在前5名同学中，每个人的奖学金都不相同，因此，你必须严格按上述规则排序。例如，在某个正确答案中，如果前两行的输出数据(每行输出两个数:学号、总分) 是:
7 279
5 279
这两行数据的含义是:总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是 279 (总分等于输入的语文、数学、英语三科成绩之和) ，但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是:
5 279
7 279
则按输出错误处理，不能得分。
输入格式
包含n+1行:
第1行为一个正整数n（小于300），表示该校参加评选的学生人数。
第2到n+1行，每行有3个用空格隔开的数字，每个数字都在0到100之间。第j行的3个数字依次表示学号为 j-1 的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为1~n (恰好是输入数据的行号减1)。
输出格式
共有5行，每行是两个用空格隔开的正整数，依次表示前5名学生的学号和总分。
输入样例
6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98
输出样例
6 265
4 264
3 258
2 244
1 237
#include<stdio.h>
struct Student {
int id; // 学号
int chinese; // 语文成绩
int math; // 数学成绩
int english; // 英语成绩
int total; // 总分
};
int main() {
int n;
scanf("%d", &n);
struct Student stu[n];
// 输入数据并计算总分
for(int i = 0; i < n; i++) {
scanf("%d %d %d", &stu[i].chinese, &stu[i].math, &stu[i].english);
stu[i].id = i + 1; // 学号从1开始
stu[i].total = stu[i].chinese + stu[i].math + stu[i].english;
}
// 冒泡排序（稳定排序）
for(int i = 0; i < n - 1; i++) {
for(int j = 0; j < n - 1 - i; j++) {
int need_swap = 0; // 标记是否需要交换
// 规则1：比较总分（从高到低）
if(stu[j].total < stu[j+1].total) {
need_swap = 1;
}
else if(stu[j].total == stu[j+1].total) {
// 规则2：总分相同，比较语文（从高到低）
if(stu[j].chinese < stu[j+1].chinese) {
need_swap = 1;
}
else if(stu[j].chinese == stu[j+1].chinese) {
// 规则3：总分和语文都相同，比较学号（从小到大）
if(stu[j].id > stu[j+1].id) {
need_swap = 1;
}
}
}
// 如果需要交换
if(need_swap) {
struct Student temp = stu[j];
stu[j] = stu[j+1];
stu[j+1] = temp;
}
}
}
// 输出前5名
int output_count = (n < 5) ? n : 5; // 如果不足5人，输出全部
for(int i = 0; i < output_count; i++) {
printf("%d %d\n", stu[i].id, stu[i].total);
}
return 0;
}
或者使用qsort比较函数
#include<stdio.h>
#include<stdlib.h>
typedef struct{
int id;
int c;
int m;
int e;
int t;
}Stu;
int cmp(const void *a,const void *b){
Stu *s1=(Stu *)a;
Stu *s2=(Stu *)b;
if (s1->t != s2->t){
return s2->t - s1->t;
}else if(s2->c != s1->c){
return s2->c-s1->c;
}else{
return s1->id-s2->id;
}
}
int main(){
int n;
scanf("%d",&n);
Stu stu[n];
for(int i=0;i<n;i++){
scanf("%d %d %d",&stu[i].c,&stu[i].m,&stu[i].e);
stu[i].id=i+1;
stu[i].t=stu[i].c+stu[i].m+stu[i].e;
}
qsort(stu,n,sizeof(Stu),cmp);
for(int i=0;i<5 && i<n;i++){
printf("%d %d\n",stu[i].id,stu[i].t);
}
return 0;
}
38.M谁拿了最多奖学金
某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：
院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得； 只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。
现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。
输入格式
输入的第一行是一个整数N（1 <= N <= 100），表示学生的总数。
接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。
姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100）；是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。
每两个相邻数据项之间用一个空格分隔。
输出格式
输出包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。
如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。
第三行是这N个学生获得的奖学金的总数。
输入样例
4
YaoLin 87 82 Y N 0
ChenRuiyi 88 78 N Y 1
LiXin 92 88 N N 0
ZhangQin 83 87 Y N 1
输出样例
ChenRuiyi
9000
28700
使用结构体
#include<stdio.h>
typedef struct{
char name[21];
int avgs;
int cs;
char gb;
char xb;
int c;
int jj;
}Stu;
int main (){
int N;
scanf("%d",&N);
Stu stu[N];
int t=0;
int mid=0;
for(int i=0;i<N;i++){
scanf("%s %d %d %c %c %d",stu[i].name,&stu[i].avgs,&stu[i].cs,&stu[i].gb,&stu[i].xb,&stu[i].c);
stu[i].jj=0;
if (stu[i].avgs>80 && stu[i].c>=1){
stu[i].jj+=8000;
}
if(stu[i].avgs>85 && stu[i].cs>80){
stu [i].jj+=4000;
}
if(stu[i].avgs>90){
stu[i].jj+=2000;
}
if(stu[i].avgs>85 && stu[i].xb=='Y'){
stu[i].jj+=1000;
}
if (stu[i].cs>80 && stu[i].gb=='Y'){
stu[i].jj+=850;
}
if(stu[i].jj>stu[mid].jj)
mid=i;
t+=stu[i].jj;
}
printf("%s\n%d\n%d\n",stu[mid].name,stu[mid].jj,t);
return 0;
}
不使用结构体
#include<stdio.h>
#include<string.h>
int main() {
int n;
scanf("%d", &n);
char name[21], best_name[21];
int avg, class_score, papers;
char cadre, west;
int max_money = -1, all_total = 0;
for(int i = 0; i < n; i++) {
scanf("%s %d %d %c %c %d", name, &avg, &class_score, &cadre, &west, &papers);
int money = 0;
// 计算奖学金
if(avg > 80 && papers >= 1) money += 8000;
if(avg > 85 && class_score > 80) money += 4000;
if(avg > 90) money += 2000;
if(avg > 85 && west == 'Y') money += 1000;
if(class_score > 80 && cadre == 'Y') money += 850;
// 更新最高奖金
if(money > max_money) {
max_money = money;
strcpy(best_name, name);
}
all_total += money;
}
printf("%s\n%d\n%d\n", best_name, max_money, all_total);
return 0;
}
39.D查找高频词
给定一个由英文字符、数字、空格和英文标点符号组成的字符串，长度不超过5000，请将其切分为单词，要求去掉所有的非英文字母，然后将单词全部转换成小写，然后统计每一个词出现的次数，输出频次最高的那个词以及它出现的次数。如果有多个词的频次相同，则输出按字典序排列在最前面的那个。
例如给定字符串：String input = "1 fish 2 fish red fish blue fish";
频次最高的单词是fish，它出现了4次。
再比如给定字符串：If the digit is less than 10, then '0' + digit is returned. Otherwise, the value 'a' + digit - 10 is returned.
频次最高的单词是digit和is，都出现了3次。但是digit的字典序在is前面，所以应该输出digit和3。
输入格式
一个长度不超过2000的字符串，只有末尾有回车符。
输出格式
输出一行，首先是频次最高的那个单词，然后是它出现的次数，中间用空格分隔
输入样例
A character may be part of a Unicode identifier if and only if one of the following statements is true.
输出样例
a 2
使用qsort比较函数
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<stdlib.h>
// 单词结构体
typedef struct {
char word[101]; // 单词本身
int count; // 出现次数
} Word;
// 比较函数：先按词频降序，再按字典序升序
int cmp(const void *a, const void *b) {
Word *w1 = (Word *)a;
Word *w2 = (Word *)b;
// 1. 先比较词频（从高到低）
if(w1->count != w2->count) {
return w2->count - w1->count;
}
// 2. 词频相同，比较字典序（从小到大）
return strcmp(w1->word, w2->word);
}
int main() {
char str[5001]; // 存储输入字符串
// 读取整行字符串（包含空格）
fgets(str, 5001, stdin);
int len = strlen(str);
// 去掉末尾的换行符
if(len > 0 && str[len-1] == '\n') {
str[len-1] = '\0';
len--;
}
// 转换为小写
for(int i = 0; i < len; i++) {
str[i] = tolower(str[i]);
}
// 提取单词并统计
Word words[1000]; // 存储单词
int word_count = 0; // 单词数量
int i = 0;
while(i < len) {
// 跳过非字母字符
while(i < len && !isalpha(str[i])) {
i++;
}
if(i >= len) break; // 到达末尾
// 提取一个单词
char current_word[101];
int j = 0;
// 连续读取字母
while(i < len && isalpha(str[i])) {
current_word[j++] = str[i++];
}
current_word[j] = '\0';
// 在已有单词中查找
int found = 0;
for(int k = 0; k < word_count; k++) {
if(strcmp(words[k].word, current_word) == 0) {
words[k].count++; // 单词已存在，计数加1
found = 1;
break;
}
}
// 没找到，添加新单词
if(!found) {
strcpy(words[word_count].word, current_word);
words[word_count].count = 1;
word_count++;
}
}
// 如果没有单词，直接返回
if(word_count == 0) {
return 0;
}
// 排序（使用qsort）
qsort(words, word_count, sizeof(Word), cmp);
// 输出频次最高的单词（排序后第一个）
printf("%s %d\n", words[0].word, words[0].count);
return 0;
}
使用冒泡排序
#include<stdio.h>
#include<string.h>
#include<ctype.h>
int main() {
char str[5001];
// 读取输入
fgets(str, 5001, stdin);
int len = strlen(str);
// 去掉换行符
if(len > 0 && str[len-1] == '\n') {
str[len-1] = '\0';
len--;
}
// 转换为小写
for(int i = 0; i < len; i++) {
if(str[i] >= 'A' && str[i] <= 'Z') {
str[i] = str[i] + 32; // 大写转小写
}
}
// 单词存储
char words[1000][101];
int counts[1000] = {0};
int word_count = 0;
// 提取单词
int i = 0;
while(i < len) {
// 跳过非字母
while(i < len && !((str[i] >= 'a' && str[i] <= 'z'))) {
i++;
}
if(i >= len) break;
// 提取单词
char current[101];
int j = 0;
while(i < len && (str[i] >= 'a' && str[i] <= 'z')) {
current[j++] = str[i++];
}
current[j] = '\0';
// 查找单词
int found = -1;
for(int k = 0; k < word_count; k++) {
if(strcmp(words[k], current) == 0) {
found = k;
break;
}
}
if(found >= 0) {
counts[found]++; // 已有单词
} else {
strcpy(words[word_count], current);
counts[word_count] = 1;
word_count++;
}
}
// 如果没有单词
if(word_count == 0) {
return 0;
}
// 找出最高频次的单词（考虑字典序）
int max_count = 0;
char max_word[101] = "";
for(int i = 0; i < word_count; i++) {
if(counts[i] > max_count) {
max_count = counts[i];
strcpy(max_word, words[i]);
}
else if(counts[i] == max_count) {
// 频次相同，比较字典序
if(strcmp(words[i], max_word) < 0) {
strcpy(max_word, words[i]);
}
}
}
printf("%s %d\n", max_word, max_count);
return 0;
}
40.E最高的分数
老师讲授的《计算概论》这门课期中考试刚刚结束，他想知道考试中取得的最高分数。因为人数比较多，他觉得这件事情交给计算机来做比较方便。你能帮老师解决这个问题吗？
例如有成绩：68 61 25 54 84 96 34，最高分数96
又比如有成绩：59 90 92 93 94 91，最高分数94
一共有两行，第一行为整数n（1 ≤ n ≤100），表示参加这次考试的人数。第二行是这n个学生的成绩，相邻两个数之间用空格隔开。所有成绩均为0到100之间的整数。
输出格式
输出一个整数，即最高的成绩。
输入样例
5
85 78 90 99 60
输出样例
99
#include<stdio.h> // 包含标准输入输出头文件
int main(){
int n; // 定义变量n，用于存储数组的长度
scanf("%d",&n); // 从用户输入读取数组长度
int a[n]; // 定义长度为n的整型数组a
for(int i=0;i<n;i++){ // 循环读取n个整数并存储到数组a中
scanf("%d",&a[i]);
}
int max=a[0]; // 假设数组的第一个元素是最大值
for (int i=1;i<n;i++){ // 遍历数组的其余元素（从第二个元素开始）
if (a[i]>max){ // 如果当前元素比当前最大值大
max=a[i]; // 更新最大值为当前元素
}
}
printf("%d",max); // 输出找到的最大值
return 0; // 程序正常结束
}
41.D高考志愿排序
我国的高考志愿投档是严格按照高考分数从高到低的顺序排列，排列的规则如下：首先按照总分降序排列；当总分相同时，再按照语文分数降序排序；当语文分数也相同时，再按照数学分数降序排序；当数学分数也相同时，再按照英语分数降序排序。所有分数都相同时，再按照录入的顺序排列。这样，每个考生的位序都是唯一的。
现在给定n（10≤n≤1000）个人的有关信息，按照上述规则排序之后，输出最前面的m（1≤m≤n）个人的序号。
例如有10个人的成绩（每一行依次是语、数、外成绩；学生的序号从1开始，就是他所在的行数）如下：
73 76 78
74 77 77
71 79 79
75 74 77
71 72 70
71 75 79
79 74 73
73 75 74
73 70 79
77 79 70
正确的排序结果如下：
3 2 1 7 10 4 6 8 9 5
再比如有10个考生的成绩如下：
66 60 63
61 63 60
63 65 60
69 60 60
64 68 69
68 62 63
63 67 67
69 68 61
65 60 65
62 65 65
排序结果如下：
5 8 7 6 10 9 4 1 3 2
输入格式
第一行是两个整数n和m，表示后续有n个考生的信息，要求输出m个考生的序号。从第2行到n+1行，每行一个考生的信息，依次是：语文分、数学分、英语分。 注意：学生的序号从1开始计数，就是它所在的行号减一
输出格式
输出m个整数，表示排序后的前m个考生的序号，整数之间用空格分隔。
输入样例
10 5
73 71 72
68 70 63
74 78 63
73 66 68
61 61 61
63 79 79
70 71 76
69 61 61
71 62 66
78 69 64
输出样例
6 7 1 3 10
#include<stdio.h> // 包含标准输入输出头文件
struct Student { // 定义学生结构体
int chinese; // 语文成绩
int math; // 数学成绩
int english; // 英语成绩
int total; // 总分
int id; // 序号（从1开始）
};
int main() { // 主函数开始
int n, m; // n:学生总数，m:要输出的前m名学生
scanf("%d %d", &n, &m); // 读取n和m
struct Student stu[n]; // 创建学生数组
for(int i = 0; i < n; i++) { // 循环输入每个学生的信息
scanf("%d %d %d", &stu[i].chinese, &stu[i].math, &stu[i].english); // 读取语文、数学、英语成绩
stu[i].id = i + 1; // 序号从1开始，第i行对应序号i+1
stu[i].total = stu[i].chinese + stu[i].math + stu[i].english; // 计算总分
}
for(int i = 0; i < n - 1; i++) { // 冒泡排序外层循环，控制轮数
for(int j = 0; j < n - 1 - i; j++) { // 冒泡排序内层循环，比较相邻元素
int need_swap = 0; // 标记是否需要交换，0=不需要，1=需要
if(stu[j].total < stu[j+1].total) { // 规则1：总分降序，如果前面总分小于后面
need_swap = 1; // 需要交换
}
else if(stu[j].total == stu[j+1].total) { // 总分相同的情况
if(stu[j].chinese < stu[j+1].chinese) { // 规则2：语文降序
need_swap = 1; // 需要交换
}
else if(stu[j].chinese == stu[j+1].chinese) { // 语文相同的情况
if(stu[j].math < stu[j+1].math) { // 规则3：数学降序
need_swap = 1; // 需要交换
}
else if(stu[j].math == stu[j+1].math) { // 数学相同的情况
if(stu[j].english < stu[j+1].english) { // 规则4：英语降序
need_swap = 1; // 需要交换
}
// 规则5：所有分数都相同，保持录入顺序（不需要交换，所以不设置need_swap=1）
}
}
}
if(need_swap) { // 如果需要交换
struct Student temp = stu[j]; // 临时变量存储stu[j]
stu[j] = stu[j+1]; // 将stu[j+1]赋值给stu[j]
stu[j+1] = temp; // 将临时变量赋值给stu[j+1]，完成交换
}
}
}
for(int i = 0; i < m; i++) { // 循环输出前m名学生的序号
printf("%d", stu[i].id); // 输出学生序号
if(i < m - 1) { // 如果不是最后一个学生
printf(" "); // 输出空格分隔
}
}
printf("\n"); // 输出换行符
return 0; // 程序正常结束
} // 主函数结束
42.E地球人口承载力估计
假设地球上的新生资源按恒定速度增长。照此测算，地球上现有资源加上新生资源可供x亿人生活a年，或供y亿人生活b年。
为了能够实现可持续发展，避免资源枯竭，地球最多能够养活多少亿人？
输入格式
输入只有一行，包括四个正整数x，a，y，b，两个整数之间用单个空格隔开。x > y，a < b，ax < by，各整数均不大于10000。
输出格式
一个实数z，表示地球最多养活z亿人，结果保留小数点后两位。
输入样例
110 90 90 210
输出样例
75.00
#include<stdio.h> // 引入标准输入输出库
int main(){
int x, a, y, b; // 定义变量：x-初始距离，a-初始速度，y-结束距离，b-结束速度
// 读取输入：顺序为初始距离、初始速度、结束距离、结束速度
scanf("%d %d %d %d", &x, &a, &y, &b);
// 计算平均速度z：使用加权平均公式 (总距离差/总时间差) 的变形公式
// 公式推导：设总路程为z，则有 (z-x)/a = (z-y)/b，解方程得 z = (y*b - x*a)/(b-a)
// 乘以1.0将整数运算转换为浮点数运算，避免精度丢失
double z = (1.0 * y * b - 1.0 * x * a) / (b - a);
// 输出结果，保留两位小数
printf("%.2f", z);
return 0; // 程序正常结束
}
43.E甲流病人初筛
目前正是甲流盛行时期，为了更好地进行分流治疗，医院在挂号时要求对病人的体温和咳嗽情况进行检查，对于体温超过37.5度（含等于37.5度）并且咳嗽的病人初步判定为甲流病人（初筛）。现需要统计某天前来挂号就诊的病人中有多少人被初筛为甲流病人。
输入格式
第一行是某天前来挂号就诊的病人数n。(n小于200)
其后有n行，每行是病人的信息，包括三个信息：姓名（字符串，不含空格，最多8个字符）、体温（float）、是否咳嗽（整数，1表示咳嗽，0表示不咳嗽）。每行三个信息之间以一个空格分开。
输出格式
按输入顺序依次输出所有被筛选为甲流的病人的姓名，每个名字占一行。之后再输出一行，表示被筛选为甲流的病人数量。
输入样例
5
Zhang 38.3 0
Li 37.5 1
Wang 37.1 1
Zhao 39.0 1
Liu 38.2 1
输出样例
Li
Zhao
Liu
3
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
char name[9];
float t;
int c,cnt=0;
for(int i=0;i<n;i++){
scanf("%s %f %d",name,&t,&c);
if (t>=37.5 && c==1){
printf("%s\n",name);
cnt++;
}
}
printf("%d\n",cnt);
return 0;
}
44.E人口增长
我国现有x亿人口，按照每年0.1%的增长速度，n年后将有多少人？计算结果保留小数点后四位输出。E
输入格式
一行，包含两个整数x和n，分别是人口基数和年数，以单个空格分隔。
输出格式
输出最后的人口数，以亿为单位，保留到小数点后四位。1≤x≤100,1≤n≤100。
输入样例
13 10
输出样例
13.1306
#include<stdio.h> // 引入标准输入输出头文件
int main(){
int x,n; // 定义变量：x为初始金额，n为存储天数
scanf("%d %d",&x,&n); // 从键盘输入初始金额和存储天数
double m=x; // 将整数金额转换为浮点数，用于精度计算
for(int i=0;i<n;i++){ // 循环n次，模拟n天的利息累计
m*=1.001; // 每天金额增加0.1%（即乘以1.001）
}
printf("%.4f",m); // 输出最终金额，保留四位小数
return 0; // 程序正常结束
}
45.E出租车计费
某市的出租车计费标准如下：起步里程小于等于3km时，起步费13元；超过起步里程小于等于15km以内的部分，单价为2.3元/km。超过15km的部分，单价加收50%的费用。给定一个正整数距离s（s≤1000），求应付的费用，结果保留两位小数。
例如，当s=3时，费用为13.00元；当s=5时，费用为17.60元；当s=18时，费用为50.95元
输入格式
一个正整数s，表示里程
输出格式
一个浮点数，表示计算出来的车费，保留小数点后面两位
输入样例
4
输出样例
15.30
#include<stdio.h> //引入标准输入输出头文件
int main(){
int s; //定义变量s表示出租车行驶的里程数（单位：公里）
scanf("%d",&s); //从键盘输入里程数
double p=0; //定义变量p表示最终车费，初始化为0
if (s<=3){ //如果里程不超过3公里
p=13; //起步价13元
}else if(s<=15){ //如果里程超过3公里但不超过15公里
p=13+(s-3)*2.3; //起步价13元加上超出3公里部分按每公里2.3元计费
}else{ //如果里程超过15公里
p=13+12*2.3+(s-15)*2.3*1.5; //起步价13元 + 3-15公里部分（12公里）按2.3元/公里 + 超出15公里部分按2.3元/公里的1.5倍（即3.45元/公里）计费
}
printf("%.2f",p); //输出最终车费，保留两位小数
return 0; //程序正常结束
}
46.M加密的病历单
小英是药学专业大三的学生，暑假期间获得了去医院药房实习的机会。
在药房实习期间，小英扎实的专业基础获得了医生的一致好评，得知小英在计算概论中取得过好成绩后，主任又额外交给她一项任务，解密抗战时期被加密过的一些伤员的名单。
经过研究，小英发现了如下加密规律(括号中是一个“原文 -> 密文”的例子)
1.原文中所有的字符都在字母表中被循环左移了三个位置（dec -> abz）
2.逆序存储（abcd -> dcba ）
3.大小写反转（abXY -> ABxy）
比如密文是：abfnlbm
解密之后得到的原文是：PEOQIED
输入格式
一个加密的字符串。(长度小于150且只包含大小写字母)
输出格式
输出解密后的字符串。
输入样例
GSOOWFASOq
输出样例
Trvdizrrvj
提示
注意：要求从密文得到原文
#include<stdio.h> // 标准输入输出
#include<string.h> // 字符串处理函数
#include<ctype.h> // 字符类型判断函数
int main(){
char s[151]; // 定义字符数组s存储原始字符串
scanf("%s", &s); // 输入原始字符串
int len = strlen(s); // 获取字符串长度
char r[151]; // 定义字符数组r存储处理后的结果
for(int i = 0; i < len; i++){ // 遍历原始字符串
char c = s[len - 1 - i]; // 逆序取字符：从最后一个字符开始取
if(c >= 'A' && c <= 'Z'){ // 如果字符是大写字母
c += 32; // 大写转小写（ASCII码加32）
c = 'a' + (c - 'a' + 3) % 26; // 凯撒加密：字母向右移动3位（小写字母循环移动）
}
else if(c >= 'a' && c <= 'z'){ // 如果字符是小写字母
c -= 32; // 小写转大写（ASCII码减32）
c = 'A' + (c - 'A' + 3) % 26; // 凯撒加密：字母向右移动3位（大写字母循环移动）
}
r[i] = c; // 将处理后的字符存入结果数组
}
r[len] = '\0'; // 在结果数组末尾添加字符串结束符
printf("%s\n", r); // 输出处理后的字符串
return 0; // 程序结束
}
47.D切分单词并排序
给定一个由英文字符、数字、空格和英文标点符号组成的字符串，长度不超过2000，请将其切分为单词，要求去掉所有的非英文字母，然后将单词全部转换成小写，再按照字典序升序排列，每个单词之间用空格分隔。
例如有文本：Python was created in 1990 by Guido at Centrum (CWI, see http://www.cwi.nl) in the Netherlands.
处理完成之后得到以下单词序列：
at by centrum created cwi cwi guido http in in netherlands nl python see the was www
输入格式
一行字符串，含有英文字符、数字、空格和英文标点符号
输出格式
处理后的单词序列，单词之间用空格隔开
输入样例
The Python Software Foundation (PSF, see https://www.python.org/psf/) was formed.
输出样例
formed foundation https org psf psf python python see software the was www
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<stdlib.h>
int cmp(const void *a, const void *b) {
return strcmp((char *)a, (char *)b);
}
int main() {
char str[2001]; // 存储输入的字符串
char words[2000][51]; // 存储单词，每个单词最长50个字符
int word_count = 0;
fgets(str, 2001, stdin);
int len = strlen(str);
// 去掉末尾的换行符（如果有）
if(len > 0 && str[len-1] == '\n') {
str[len-1] = '\0';
len--;
}
int i = 0;
while(i < len) {
// 跳过非字母字符
while(i < len && !isalpha(str[i])) {
i++;
}
if(i >= len) break; // 已经到字符串末尾
// 提取一个单词
char word[51];
int j = 0;
// 连续读取字母
while(i < len && isalpha(str[i])) {
// 转换为小写
word[j++] = tolower(str[i++]);
}
word[j] = '\0'; // 字符串结束符
// 存储单词（不需要去重，题目样例显示重复单词都要保留）
strcpy(words[word_count], word);
word_count++;
}
// 按字典序排序
qsort(words, word_count, sizeof(words[0]), cmp);
// 输出结果，单词间用空格分隔
for(int i = 0; i < word_count; i++) {
printf("%s", words[i]);
if(i < word_count - 1) {
printf(" ");
}
}
printf("\n");
return 0;
}
48.M单词处理
给定一个由英文字符、数字、空格和英文标点符号组成的字符串，长度不超过2000，请将其切分为单词，要求去掉所有的非英文字母，每行输出一个单词。
例如有文本：Python was created in 1990 by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands.
处理完成之后得到以下单词：
Python
was
created
in
by
Guido
van
Rossum
at
Stichting
Mathematisch
Centrum
CWI
see
http
www
cwi
nl
in
the
Netherlands
输入格式
一行字符串
输出格式
若干行，每行一个处理后的单词
输入样例
SyntaxError: cannot assign to literal
输出样例
SyntaxError
cannot
assign
to
literal
#include<stdio.h>
#include<string.h>
#include<ctype.h>
int main() {
char str[2001]; // 存储输入的字符串
int i = 0;
// 读取整行字符串
fgets(str, 2001, stdin);
int len = strlen(str);
// 去掉末尾的换行符
if(len > 0 && str[len-1] == '\n') {
str[len-1] = '\0';
len--;
}
// 遍历字符串，提取单词
while(i < len) {
// 跳过非字母字符
while(i < len && !isalpha(str[i])) {
i++;
}
if(i >= len) break; // 已经到字符串末尾
// 提取一个单词
char word[101]; // 假设单词最长100个字符
int j = 0;
// 连续读取字母
while(i < len && isalpha(str[i])) {
word[j++] = str[i++];
}
word[j] = '\0'; // 字符串结束符
// 输出单词（每行一个）
printf("%s\n", word);
}
return 0;
}
49.E猴子吃桃
猴子第一天摘下若干个仙桃，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的仙桃吃掉一半，又多吃一个。以后每天早上都吃了前一天剩下的一半零一个。到第N天早上想再吃时，见只剩下一个仙桃。求第一天共摘多少仙桃。
输入： N
输出： 仙桃总数
#include<stdio.h>
void eatPeach(int days); // 函数声明：吃桃问题的递归/迭代计算函数
int main()
{
int days; // 定义变量days表示总天数
scanf("%d", &days); // 输入总天数
eatPeach(days); // 调用函数计算并输出桃子总数
return 0; // 程序正常结束
}
// 完成吃桃问题的计算（使用迭代方法）
void eatPeach(int days) {
int t = 1; // 初始化：第days天（最后一天）的桃子数量为1
for(int i = 1; i < days; i++){ // 从最后一天向前逆推days-1天
t = (t + 1) * 2; // 核心递推公式：第n天的桃子数 = (第n+1天的桃子数 + 1) * 2
}
printf("%d", t); // 输出第一天（开始时）的桃子总数
}
50.M猴子选大王
编写一个函数 king，实现猴子选大王的功能，输出 N（数据由平台提供，已获取，直接使用即可） 只猴子中谁是猴子大王的。具体要求如下：
让 N 只候选猴子围成一圈（最多 100 只猴子），从某位置起顺序编号为 1-N 号；
从第 1 号开始报数，每轮从 1 报到 3 ，凡报到 3 的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数；
如此不断循环，最后剩下的一只猴子就选为猴王。
测试举例
输入：5
输出：4号猴子是大王。
/*------------------------------------------------
注意：部分源程序给出如下，请勿改动主函数main和其它
函数中的任何内容，仅在 Begin-End 区间补充代码。
---------------------------------------------------*/
// 包含两种I/O库，可以使用任一种输入输出方式
#include <stdio.h>
// 函数king：猴子选大王
// 参数：a-猴子数组n-1个猴子分别占据下标为~n-1的位置，n-数组长度
// 返回值：新猴王的下标序号
int king(int a[], int n);
int main()
{
int n, a[1000], i; // 定义变量及数组，n-猴子数量，a-猴子数组
scanf("%d",&n); // 输入猴子数量，n>0
// 初始化猴子数组,n 个猴子分别占据 n 个位置
a[0] = 0; // 0号位置没有猴子
for(i = 1;i <= n; i++)
a[i] = i;
// 选大王啦
i = king(a, n );
printf("%d号猴子是大王。",i);
return 0;
}
int king(int a[], int n)
{
// 请在此添加代码，实现函数king
/********** Begin *********/
int r = n; // r表示当前剩余的猴子数量
int cnt = 0; // cnt用于计数，记录当前报数到几
int cur = 1; // cur表示当前检查的猴子位置
while(r > 1){ // 当剩余猴子数量大于1时，继续淘汰过程
if(a[cur] != 0){ // 如果当前位置的猴子还没被淘汰
cnt++; // 报数计数加1
if(cnt == 3){ // 如果报数到3
a[cur] = 0; // 淘汰这只猴子（标记为0）
r--; // 剩余猴子数量减1
cnt = 0; // 重置报数计数器
}
}
cur++; // 移动到下一个位置
if(cur > n){ // 如果超过数组边界
cur = 1; // 循环回到第一个位置（形成环）
}
}
// 找到最后剩下的猴子（大王）
int k = -1; // 初始化为-1，表示未找到
for(int i = 1; i <= n; i++){ // 遍历所有位置
if(a[i] != 0){ // 找到没有被淘汰的猴子
k = i; // 记录大王的位置
break; // 跳出循环
}
}
return k; // 返回大王的编号
/********** End **********/
}
51.E根据自己的年龄和生肖计算别人的生肖
小明总喜欢问别人的年龄，然后根据自己的年龄和生肖计算别人的生肖，编写函数shengxiao帮助小明完成该功能。注：十二生肖的顺序是：猪、狗、鸡、猴、羊、马、蛇、龙、兔、虎、牛、鼠，即如果小明8岁属猪，则如果小张9岁就属狗，小王12岁属羊。
样例输入：8 1 9
样例输出：2
#include<stdio.h>
// 函数sx：计算对方的生肖
// 参数：mage-我的年龄，msx-我的生肖（1-12），oage-对方的年龄
void sx(int mage,int msx,int oage){
// 计算对方的生肖：通过年龄差推算
// (oage - mage)是年龄差，加上我的生肖msx，然后取模12得到相对位置
int osx = (oage - mage + msx + 12) % 12; // 加12确保结果为非负数
// 特殊处理：如果模运算结果为0，表示是第12个生肖
if(osx<=0) osx+=12; // 修正：将0转换为12
printf("%d\n",osx); // 输出对方的生肖编号（1-12）
}
int main(){
int mage, msx, oage; // 定义变量：我的年龄、我的生肖、对方的年龄
scanf("%d %d %d",&mage,&msx,&oage); // 输入三个整数
sx(mage,msx,oage); // 调用函数计算并输出对方的生肖
return 0; // 程序正常结束
}
52.E猴子吃桃问题
题目：猴子吃桃问题：猴子摘下若干个桃子，第一天吃了桃子的一半多一个，以后每天吃了前一天剩下的一半多一个，到第n天吃以前发现只剩下一个桃子，要求编写函数GetNumber(int n)求出猴子共摘了几个桃子。
样例输入：5
样例输出：46E
/*------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它
函数中的任何内容，仅在注释形式标识Program和
End之间填入所编写的若干语句。
-------------------------------------------------*/
#include <stdio.h> // 仅保留C语言标准输入输出头文件
/**********Program**********/
int GetNumber(int n){
int p = 1; // 第n天剩余1个桃子
// 从第n-1天倒推回第1天，循环n-1次
for (int i = 1; i < n; i++) {
p = (p + 1) * 2; // 倒推公式：前一天的桃子数 = (当天剩余+1)*2
}
return p; // 循环结束后再返回，而非循环内
}
/********** End **********/
int main(){
int n;
scanf("%d", &n); // C语言读取输入（替换cin）
printf("%d\n", GetNumber(n)); // C语言输出（替换cout）
return 0; // C语言main函数规范返回值
}
53.E兔子吃萝卜问题
兔子第一天挖出若干个胡萝卜，当即吃了一半，不过瘾，又多吃了一个。第二天早上又将剩下的胡萝卜吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下n个胡萝卜了。求第一天共摘了多少个胡萝卜。
输入：第10天剩下的胡萝卜数
输出：第1天总共摘的胡萝卜数
输入实例：1
输出实例：1534
#include<stdio.h>
int main(){
int n; // 定义变量n，表示初始值（第10天的数量）
scanf("%d",&n); // 输入第10天的数量
// 循环9次，从第10天倒推到第1天
// i从1循环到9，共9次，对应9天的逆推计算
for(int i=1;i<10;i++){
n=(n+1)*2; // 核心递推公式：第n天的数量 = (第n+1天的数量 + 1) * 2
}
printf("%d",n); // 输出第1天的数量
return 0; // 程序正常结束
}
54.E鸡兔同笼问题
题目描述
题目：在一笼子里，鸡和兔的个数共m只，脚有n只，编写函数myChicken来计算鸡和兔各多少只？计算结果存放在参数c（鸡的只数）和r（兔的只数）中。
样例输入：100 300
样例输出： 共有50只鸡 共有50只兔
/*--------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它
函数中的任何内容，仅在函数的花括号中填入所编
写的若干语句。
------------------------------------------------*/
#include<stdio.h> // C语言标准输入输出头文件
// m: 鸡和兔的总个数；n: 脚的总只数；
// c: 指针，指向存放鸡数量的变量；r: 指针，指向存放兔数量的变量。
int myChicken(int m, int n, int *c, int *r);
int main()
{
int c, r, m, n; // c: 存放计算出的鸡的只数；r: 存放计算出的兔的只数
scanf("%d %d", &m, &n); // C语言读取输入（替换cin）
myChicken(m, n, &c, &r); // 传入变量地址（替代C++的引用）
printf("共有%d只鸡\n", c); // C语言输出（替换cout）
printf("共有%d只兔\n", r);
return 0;
}
int myChicken(int m, int n, int *c, int *r)
{
/*************** Program *****************/
// 鸡兔同笼核心公式：
// r = (n - 2*m)/2 （兔的数量）
// c = m - r （鸡的数量）
*r = (n - 2 * m) / 2; // 通过指针修改主函数中r的值
*c = m - *r; // 通过指针修改主函数中c的值
/*************** End *****************/
return 0;
}
55.M猴子选大王（二）
n只猴子围成一圈，从1到n顺序编号。从第q只猴子开始，从1到m报数，凡报到m的猴子退出竞选，下一次又从退出的那只猴子的下一只开始从1到m报数，直至剩下的最后一只为大王。请问最后哪只猴子被选为大王。如果最后没有猴子剩下，则输出none
例如给定【7 4 3】，应输出：4。再给定【10 3 6】，应输出：9。给定【3 1 1】，应输出none
提示：输出的字符串none全是小写
输入格式
输入三个正整数n，m，q，分别表示猴子的数量n，报数的尾数m，从第q个猴子开始报数，中间用空格分隔，题目保证：1≤m≤n≤999，1≤q≤n≤999
输出格式
输出最后选为大王的猴子编号，如果最后没有猴子剩下则输出：none
输入样例
7 4 3
输出样例
4
#include<stdio.h>
int main(){
int n, m, q; // 定义变量：n-总人数，m-报数间隔，q-起始位置
scanf("%d %d %d", &n, &m, &q); // 输入三个整数
int mk[1000] = {0}; // 标记数组，记录每个人是否被淘汰（0-未淘汰，1-已淘汰）
int r = n; // r表示当前剩余的人数
int c = (q - 1) % n; // c表示当前检查的位置索引（转换为0-based索引）
int cnt = 0; // cnt用于计数，记录当前报数到几
// 约瑟夫环淘汰过程
while(r > 1){ // 当剩余人数大于1时，继续淘汰
if(mk[c + 1] == 0){ // 如果当前位置的人还没被淘汰（转换为1-based索引）
cnt++; // 报数计数加1
if(cnt == m){ // 如果报数到m
mk[c + 1] = 1; // 淘汰这个人（标记为1）
r--; // 剩余人数减1
cnt = 0; // 重置报数计数器
}
}
c = (c + 1) % n; // 移动到下一个位置（循环移动）
}
// 查找最后剩下的一个人（获胜者）
int k = -1; // 初始化为-1，表示未找到获胜者
if(m != 1){ // 只有当m不等于1时才需要查找（特殊情况处理）
for(int i = 1; i <= n; i++){ // 遍历所有人
if(mk[i] == 0){ // 找到没有被淘汰的人
k = i; // 记录获胜者的编号（1-based）
break; // 跳出循环
}
}
}
// 输出结果
if(k != -1){ // 如果找到了获胜者
printf("%d", k); // 输出获胜者的编号
} else { // 如果没有找到获胜者（特殊情况）
printf("none"); // 输出"none"
}
return 0; // 程序正常结束
}
56.M重复选课的学生
学校开放了两门选修课，规定每位同学只能选择其中一门。但是有些同学不遵守规定，同时选择了两门课程，现在选课名单汇总出来了，请你根据名单将同时选择了两门课程的同学挑选出来，并按照字典顺序升序排列。
例如，选择了A课程的同学有：Christia Natha Elija Ale Loga Jame Gabrie，选择了B课程的同学有：Joh Natha Elija Ale Rya Hayde，重复选课的同学是：Ale Elija Natha
又比如，选择了A课程的同学有：Thoma Camero Col Austi Jesu，选择了B课程的同学有：Thoma Brya Lia Austi Trista，重复选课的同学是：Austi Thoma
输入格式
输入数据一共有4行。第一行是一个正整数m（1≤m≤100）表示选择A课程的同学数目，第二行是所有选择A课程的同学姓名，中间以空格分隔。第三行是一个正整数n（1≤n≤100）表示选择B课程的同学数目，第四行是所有择B课程的同学姓名，中间以空格分隔。
输出格式
一行，所有重复选课的M同学姓名，中间以空格分隔，按照字典顺序升序排列
输入样例
6
Thoma Austi Lia Sea Trista Brya
7
Brya Camero Austi Lia Hunte Trista Jesu
输出样例
Austi Brya Lia Trista
冒泡排序
#include <stdio.h>
#include <string.h>
// 冒泡排序函数，按字典序升序排列
void bubbleSort(char names[][21], int count) {
for (int i = 0; i < count - 1; i++) {
for (int j = 0; j < count - i - 1; j++) {
// 比较相邻两个字符串的字典序
if (strcmp(names[j], names[j+1]) > 0) {
// 交换位置
char temp[21];
strcpy(temp, names[j]);
strcpy(names[j], names[j+1]);
strcpy(names[j+1], temp);
}
}
}
}
int main() {
int m, n;
char A[100][21]; // A课程学生名单，每个名字最多20字符+1结束符
char B[100][21]; // B课程学生名单
char result[100][21]; // 重复选课学生名单
int resultCount = 0; // 重复选课学生数量
// 读取A课程信息
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%s", A[i]);
}
// 读取B课程信息
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", B[i]);
}
// 查找同时选择两门课程的学生
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
// 比较学生姓名是否相同
if (strcmp(A[i], B[j]) == 0) {
// 将重复选课学生添加到结果数组
strcpy(result[resultCount], A[i]);
resultCount++;
break; // 找到后跳出内层循环，避免重复添加
}
}
}
// 按字典序升序排列
bubbleSort(result, resultCount);
// 输出结果
for (int i = 0; i < resultCount; i++) {
printf("%s", result[i]);
if (i < resultCount - 1) {
printf(" ");
}
}
return 0;
}
qsort比较函数
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
// 比较函数：字典序升序
int cmp(const void *a, const void *b){
return strcmp((char *)a, (char *)b);
}
int main(){
int m, n;
char A[101][101];
char B[101][101];
char result[101][101];
int count = 0;
// 读取输入
scanf("%d", &m);
for(int i = 0; i < m; i++) scanf("%s", A[i]);
scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%s", B[i]);
// 找出交集
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(strcmp(A[i], B[j]) == 0){
strcpy(result[count], A[i]);
count++;
break; // 找到后跳出
}
}
}
// 排序
qsort(result, count, sizeof(result[0]), cmp);
// 输出
for(int i = 0; i < count; i++){
printf("%s", result[i]);
if(i < count - 1) printf(" ");
}
printf("\n");
return 0;
}
57.E密码翻译
在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y，A-Y的字母用其后继字母替代，把z和Z用a和A替代，其他非字母字符不变，则可得到一个简单的加密字符串。
输入格式
输入一行，包含一个字符串，长度小于80个字符。
输出格式
输出每行字符串的加密字符串。
输入样例
Hello! How are you!
输出样例
Ifmmp! Ipx bsf zpv!
提示
由于windows和linux下面的换行符不同，所以读入一行字符推荐使用fgets或者gets函数；尽量避免使用getchar读入，后者需要自行解决跨平台问题。
#include<stdio.h>
int main(){
char s[81]; // 定义字符数组，最多存储80个字符 + 1个结束符
fgets(s,sizeof(s),stdin); // 从标准输入读取一行字符串，包含换行符
// 遍历字符串中的每个字符
for(int i=0;s[i]!='\0';i++){
// 处理小写字母
if(s[i]>='a' && s[i]<='z'){
if(s[i]=='z'){ // 如果是'z'，变为'a'（循环处理）
s[i]='a';
}else{ // 其他小写字母，变为后一个字母
s[i]+=1;
}
}
// 处理大写字母
if(s[i]>='A' && s[i]<='Z'){
if(s[i]=='Z'){ // 如果是'Z'，变为'A'（循环处理）
s[i]='A';
}else{ // 其他大写字母，变为后一个字母
s[i]+=1;
}
}
}
printf("%s",s); // 输出变换后的字符串
return 0; // 程序正常结束
}
58.E计算邮资
根据邮件的重量和用户是否选择加急计算邮费。计算规则：重量在1000克以内(包括1000克), 基本费8元。超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；如果用户选择加急，多收5元。
输入格式
输入一行，包含整数和一个字符，以一个空格分开，分别表示重量（单位为克）和是否加急。如果字符是y，说明选择加急；如果字符是n，说明不加急。
输出格式
输出一行，包含一个整数，表示邮费。
输入样例
1200 y
输出样例
17
#include<stdio.h>
int main(){
int n; // 定义变量n表示快递重量（单位：克）
char m; // 定义变量m表示是否加急（y:是，其他字符:否）
scanf("%d %c",&n,&m); // 输入重量和是否加急标志
int p=0; // 初始化总费用为0
if(m=='y'){ // 如果需要加急服务
p+=5; // 加收5元加急费
}
// 计算基础运费
if(n<=1000){ // 如果重量不超过1000克
p+=8; // 基础运费8元
}else if(n>1000){ // 如果重量超过1000克
// 计算超出部分的费用：
// (n-1000+499)/500 向上取整计算超出部分的500克倍数
// 每超出500克（不足500克按500克计算）加收4元
p+=8+(n-1000+499)/500*4;
}
printf("%d",p); // 输出总费用
return 0; // 程序正常结束
}
59.M二分查找
题目描述:将n个从小到大排序的整数（n<1000000）从1~n进行编号，并一个待查找的整数m，请使用二分法进行查找。
####相关知识（略）
####编程要求
根据提示，在右侧编辑器Begin-End处补充代码。
输入
输入包括3行，第一行为整数n，第二行包括n个整数，以空格分隔，第三行为整数m。
输出
如果能够在序列中找到整数m，则输出编号（如果存在多个编号，返回编号最小的），如果不存在，则输出None。
测试说明
样例输入：
10
1 2 4 5 6 7 8 9 10 11
10
样例输出：
9
#include<stdio.h>
int main(void)
{
/*********Begin*********/
int n, m; // n:数组元素个数，m:要查找的目标值
scanf("%d", &n); // 输入数组长度
int arr[n]; // 定义长度为n的数组
// 输入数组元素
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
scanf("%d", &m); // 输入要查找的目标值
// 二分查找初始化
int left = 0, right = n - 1; // 左边界和右边界
int result = -1; // 查找结果，初始为-1表示未找到
// 二分查找循环
while (left <= right) {
int mid = left + (right - left) / 2; // 计算中间位置，防止溢出
if (arr[mid] == m) {
result = mid; // 记录找到的位置
right = mid - 1; // 继续在左边找更早出现的位置（因为可能有重复元素）
} else if (arr[mid] < m) {
left = mid + 1; // 目标值在右半部分
} else {
right = mid - 1; // 目标值在左半部分
}
}
// 输出结果
if (result != -1) {
printf("%d\n", result + 1); // 输出位置编号（题目要求从1开始计数）
} else {
printf("None\n"); // 未找到目标值
}
/*********End**********/
return 0;
}
扫一扫
2232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
