结构体-计分作业
1. 生日相同问题
【问题描述】
在一个有n个学生的大班级中，存在两个学生生日相同的概率非常大，现给出每个学生的名字，出生月日。试找出所有生日相同的学生。（只有一组生日相同的情况，不存在多组）
【输入形式】
第1行为正整数n，表示有n个学生，n≦100。
此后n行，每行包含一个字符串和两个正整数，分别表示学生的名字（名字中不含空格，且长度小于20）和出生月m、出生日d，1≦m≦12，1≦d≦31，名字、月、日之间用一个空格分隔。
【输出形式】
每组生日相同的学生，输出一行，其中前两个数字表示月和日，后面跟着所有在当天出生的学生的名字，数字、名字之间都用一个空格分隔。对生日相同的名字，按输入顺序输出。如果没有生日相同的学生，输出“None”。
【样例输入】
6
Avril 3 2
Candy 4 4
Tim 3 2
Sufia 4 5
Lagrange 4 7
Bill 3 2
【样例输出】
3 2 Avril Tim Bill
#include <stdio.h>
#include <string.h> // 引入标准输入输出库和字符串操作库
// 定义一个结构体类型 Student，包含一个字符数组 name（用于存储学生的名字，最大长度为20）、一个整数 month（用于存储出生月份）和一个整数 day（用于存储出生日期）
struct Student
{
char name[20]; // 学生名字，最大长度为20
int month; // 学生出生月份
int day; // 学生出生日期
};
// 主函数入口
int main()
{
int n; // 定义一个整数 n，用于存储学生的数量
scanf("%d", &n); // 从标准输入读取学生的数量
struct Student Stu[n]; // 根据学生的数量动态创建一个 Student 类型的数组 Stu
int i; // 定义一个循环变量 i
for (i = 0; i < n; i++) // 循环 n 次，每次读取一个学生的信息
{
scanf("%s %d %d", Stu[i].name, &Stu[i].month, &Stu[i].day); // 从标准输入读取学生的名字、月份和日期，并存储到 Stu 数组的相应位置
}
int found = 0; // 定义一个标志变量 found，初始值为0，用于标记是否找到了重复生日的学生
for (i = 0; i < n; i++) // 循环 n 次，每次检查一个学生的生日是否重复
{
int Same[n]; // 定义一个整数数组 Same，用于标记哪些学生的生日与当前学生相同，初始化为0
memset(Same, 0, sizeof(Same)); // 使用memset函数将Same数组的所有元素初始化为0
for (int j = i + 1; j < n; j++) // 从当前学生的下一位开始，循环检查其余的学生
{
if (Stu[i].month == Stu[j].month && Stu[i].day == Stu[j].day) // 如果发现有学生的生日与当前学生相同
{
Same[i] = 1; // 标记当前学生的生日已找到
Same[j] = 1; // 标记找到的学生的生日已找到
found = 1; // 找到重复生日的学生，将 found 设为1
}
}
if (Same[i]) // 如果当前学生的生日已找到（Same[i]为1）
{
printf("%d %d %s", Stu[i].month, Stu[i].day, Stu[i].name); // 打印当前学生的生日和名字
for (int j = i + 1; j < n; j++) // 从当前学生的下一位开始，循环检查其余的学生
{
if (Same[j]) // 如果找到的学生的生日已找到（Same[j]为1）
{
printf(" %s", Stu[j].name); // 打印找到的学生的名字
}
}
printf("\n"); // 新行，以美观地打印结果
break; // 找到第一个重复生日的学生后，跳出循环，继续查找下一个学生
}
}
if (!found) // 如果未找到重复生日的学生，将 found 设为0，打印“None”并换行
{
printf("None\n"); // 打印“None”并换行，表示没有找到重复生日的学生
}
return 0; // 主函数返回0，表示程序正常结束
}
2. 某班劳动之星选举程序
【问题描述】某班劳动之星选举程序
某班学生信息包括以下几项：学号、姓名和性别。定义一个结构体数组来保存学生信息，从键盘输入学生数 n 和 n 个学生的数据；再输入一组投票数据：学生的学号，非正数代表输入结束。输出得票数最高的学生信息，同票的要全部输出（最多两人同票），各占一行。
【输入形式】输入学生数 n 和 n 个学生的数据；再输入一组投票数据：学生的学号。
【输出形式】输出得票数最高的学生信息。
【样例输入】
3
101 jhko F
102 it99 M
103 oiug M
101 101 101 101 103 103 102 101 0
【样例输出】
101 jhko F
【样例输入】
4
5 K F
6 T F
8 A M
9 V M
5 6 8 9 8 8 5 5 -1
【样例输出】
5 K F
8 A M
【样例说明】提示：n 个学生按照得票数进行降序排序后再输出满足条件的学生信息。不定义结构体数组0分。
#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串操作库
struct Student // 定义一个结构体类型 Student，用于存储学生的信息
{
int id; // 学生的编号
char name[20]; // 学生的名字，最大长度为20
char sex; // 学生的性别
int vote_count; // 学生的票数
};
int main() // 主函数入口
{
int n; // 定义一个整数 n，用于存储学生的数量
scanf("%d", &n); // 从标准输入读取学生的数量
struct Student students[n]; // 根据学生的数量动态创建一个 Student 类型的数组 students
for (int i = 0; i < n; i++) // 循环 n 次，每次读取一个学生的信息
{
scanf("%d %s %c", &students[i].id, students[i].name, &students[i].sex); // 从标准输入读取学生的编号、名字、性别，并存储到 students 数组的相应位置
students[i].vote_count = 0; // 初始化学生的票数为0
}
int vote_id; // 定义一个整数 vote_id，用于存储投票的编号
while (scanf("%d", &vote_id) && vote_id > 0) // 当从标准输入读取到一个正整数时
{
for (int i = 0; i < n; i++) // 循环 n 次，每次查找一个学生
{
if (students[i].id == vote_id) // 如果找到一个学生的编号与投票编号相同
{
students[i].vote_count++; // 给这个学生加一票
break; // 找到后立即跳出循环，不继续查找其他学生
}
}
}
int max_vote_count = 0; // 定义一个整数 max_vote_count，用于存储最高票数
for (int i = 0; i < n; i++) // 循环 n 次，每次查找一个学生的票数
{
if (students[i].vote_count > max_vote_count) // 如果找到一个学生的票数大于当前最高票数
{
max_vote_count = students[i].vote_count; // 更新最高票数
}
}
for (int i = 0; i < n; i++) // 循环 n 次，每次查找一个学生的票数
{
if (students[i].vote_count == max_vote_count) // 如果找到一个学生的票数等于最高票数
{
printf("%d %s %c\n", students[i].id, students[i].name, students[i].sex); // 打印这个学生的编号、名字、性别和票数
}
}
return 0; // 主函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
3. 谁的年龄是居中年龄
【问题描述】设有n个人的姓名和年龄存在数组中，输出这些人年龄居中的年龄，和同年龄的所有人姓名（如多人，姓名按字母顺序排序），如偶数算中间两人平均值，没有相同年龄则输出error。
【输入形式】人数 姓名 年龄
【输出形式】年龄 姓名
【样例输入】
5
Ewry 32
Jdkfg 54
Dfhsj 20
Kvirk 32
Sgkf 53
【样例输出】32 Ewry Kvirk
// 引入标准输入输出库
#include<stdio.h>
// 引入字符串操作库
#include<string.h>
// 定义一个结构体类型 person，用于存储人的信息，包括名字和年龄
typedef struct
{
char name[20]; // 名字，最多20个字符
int age; // 年龄
}person;
// 主函数入口
int main()
{
// n 为输入的人数
int n, i, j, k, t;
// arr 数组用于存储人的年龄，flag 用于标记是否找到符合条件的人
int flag = 0, arr[10];
// 读取输入的人数 n
scanf("%d", &n);
// 根据人数 n 创建一个 person 类型的数组 man
person man[n];
// 循环读取每个人的信息，并将其存入 man 数组和 arr 数组中
for (i = 0; i < n; i++)
{
scanf("%s %d", man[i].name, &man[i].age);
arr[i] = man[i].age;
}
// 使用冒泡排序对 arr 数组进行排序
for (i = 0; i < n; i++)
{
for (j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
// 如果人数 n 是奇数，输出中间的年龄，并打印所有该年龄的人的名字
if (n % 2 == 1)
{
printf("%d ", arr[n / 2]);
for (i = 0; i < n; i++)
if (arr[n / 2] == man[i].age)
printf("%s ", man[i].name);
}
// 如果人数 n 是偶数，找到两个中间的年龄，打印第一个年龄和对应的人名，打印第二个年龄和对应的人名，如果两个年龄之间没有找到人名，输出 error
if (n % 2 == 0)
{
k = (arr[n / 2] + arr[(n / 2) - 1]) / 2;
for (i = 0; i < n; i++)
{
if (k == man[i].age && flag == 0)
{
printf("%d %s ", k, man[i].name);
flag = 1;
continue;
}
if (k == man[i].age && flag == 1)
{
printf("%s", man[i].name);
}
}
if (flag == 0)
printf("%d error", k);
}
return 0; // 主函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
4. 奖金计算
【问题描述】
单位根据员工的销售成绩计算发给员工的奖金，A商品（单价100元）销售到达200以上，奖励总销售额的10%，200到100之间奖励总销售额的5%，100以下无奖励；B商品销售到达200以上，奖励2000元，200到100之间奖励1000，100以下奖励500；请计算给出每个员工获得的奖金数目。
【输入形式】姓名 A数量 B数量
当输入姓名为"#"时表示输入结束。
【输出形式】姓名 奖金
【样例输入】
zs 320 270
lis 207 388
we 188 46
ss 34 300
sd 56 170
# 0 0 0
【样例输出】
zs 5200
lis 4070
we 1440
ss 2000
sd 1000
// 引入标准输入输出库，用于后面的输入输出操作
#include<stdio.h>
// 定义一个结构体类型，名为staff，包含一个字符数组name（用来存储员工的姓名，最大长度为10），两个整型变量Goods_a, Goods_b
struct staff
{
char name[10]; // 员工姓名，最大长度为10
int Goods_a, Goods_b; // 两个整型变量，分别代表商品A和商品B
}person[10]; // 定义了一个名为person的staff类型数组，长度为10，用于存储10个员工的信息
// 声明两个函数，分别是Bonus_A和Bonus_B，用于后面的函数调用
int Bonus_A(int n);
int Bonus_B(int n);
// main函数开始，C语言程序的执行从这里开始
int main()
{
int i, n = 0, flag = 1; // 定义三个整型变量i, n, flag。i用于循环计数，n用于存储读入的员工人数，flag用于判断是否读入到文件结尾
// 使用for循环逐个读入员工的信息，直到读到以'#'结尾的员工姓名为止
for (i = 0; flag == 1; i++)
{
// 使用scanf函数读入员工的姓名、Goods_a和Goods_b，分别存储到结构体数组person的相应位置
scanf("%s %d %d", person[i].name, &person[i].Goods_a, &person[i].Goods_b);
// 如果读入的员工姓名为'#'，则停止读入
if (person[i].name[0] == '#')
flag = 0; // flag设为0，表示停止读入新的员工信息
n++; // n自增，表示已读入一个员工信息
}
// 使用for循环输出已读入的员工信息，每个员工的姓名和经过Bonus_A和Bonus_B函数计算后的商品值之和
for (i = 0; i < n - 1; i++)
{
printf("%s %d\n", person[i].name, Bonus_A(person[i].Goods_a) + Bonus_B(person[i].Goods_b)); // 输出格式：员工姓名，经过计算后的商品值之和
}
return 0; // main函数返回0，表示程序正常结束
}
// 定义一个名为Bonus_A的函数，输入一个整型参数n，输出一个整型结果
int Bonus_A(int n)
{
// 如果n小于100，返回0
if (n < 100)
{
return 0;
}
// 如果n在100到200之间（包括200），返回n的5倍
else if (n < 200)
{
return n * 5;
}
// 如果n大于200，返回n的10倍
else
{
return n * 10;
}
}
// 定义一个名为Bonus_B的函数，输入一个整型参数n，输出一个整型结果
int Bonus_B(int n)
{
// 如果n小于100，返回500
if (n < 100)
{
return 500;
}
// 如果n在100到200之间（包括200），返回1000
else if (n < 200)
{
return 1000;
}
// 如果n大于200，返回2000
else
{
return 2000;
}
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
5. ACM比赛排名
【问题描述】ACM网络编程擂台赛比赛完后需要产生一个最终排名，排名按照完成题数多少来决定。但是有太多的队伍参与，手动计算排名已经不能满足比赛的需求。现在有一份名单记录各个队伍的ID和做出的题目数，需要你写一个程序，产生最终的排名。
为了简化题目，这里的排名规则为：做出题目数量多的队伍排在前面，假设所有队伍完成的题目数量都不同。
【输入形式】第一行有一个正整数N（0<N<100）,表示队伍数量。接下来N 行包含两个整数，分别为队伍的编号，和该队做出的题数。
【输出形式】每组数据输出包含N行，第i行有两个整数，ID和M表示排在第i位的队伍的ID和做出的题数。
【样例输入】
8
1 3
16 5
11 2
20 4
3 8
26 7
7 1
22 6
【样例输出】
3 8
26 7
22 6
16 5
20 4
1 3
11 2
7 1
// 引入标准输入输出库，用于输入和输出操作
#include <stdio.h>
struct team // 定义一个结构体类型，名为"team"，代表一个团队。
{
int id; // 团队的编号。
int score; // 团队的分数。
};
int main() // 主函数，程序从这里开始执行。
{
int n; // 定义一个整数变量n，用于存储团队的个数。
struct team teams[100]; // 定义一个团队数组，最多可以存储100个团队。
scanf("%d", &n); // 从标准输入读取一行数据，转化为整数并存储到变量n中。
for (int i = 0; i < n; i++) // 循环n次，每次读取一个团队的信息。
{
scanf("%d %d", &teams[i].id, &teams[i].score); // 从标准输入读取两行数据，分别转化为整数并存储到团队数组的相应位置。
}
// 冒泡排序 // 对团队数组进行冒泡排序，按照分数从高到低排序。
for (int i = 0; i < n - 1; i++) // 外层循环，执行n-1次。
{
for (int j = 0; j < n - i - 1; j++) // 内层循环，每次循环后面的团队都会比前面的团队分数高。
{
if (teams[j].score < teams[j + 1].score) // 如果当前团队的分数比下一个团队的分数低，则交换两个团队的位置。
{
struct team temp = teams[j]; // 临时存储当前团队的信息。
teams[j] = teams[j + 1]; // 将下一个团队的信息放到当前位置。
teams[j + 1] = temp; // 将临时存储的当前团队的信息放到下一个位置。
}
}
}
// 输出结果 // 输出排序后的团队信息。
for (int i = 0; i < n; i++)
{
printf("%d %d\n", teams[i].id, teams[i].score); // 输出团队的编号和分数。
}
return 0; // 主函数返回0，表示程序正常结束。
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
6. 销售记录排序
【问题描述】现有若干条销售记录，每个产品的销售记录由产品代码（整型），产品名称（字符型十位），单价（整型），数量（整型），金额（整型）五部分组成，其中：前四部分直接输入，而金额使用公式计算得出，即，金额=单价*数量。
要求：读取销售记录，使用结构体数组进行保存，编写计算金额函数，计算每条销售记录的金额，最后对销售记录按金额从小到大进行排序输出。
【输入形式】输入第一行为产品个数n（n<10），以下n行为销售记录，包括产品代码（整型），产品名称（字符型十位），单价（整型），数量（整型）
【输出形式】输出排好的销售记录，包括所有信息。
【样例输入】
8
1010 PVS1966-A1 580 22
1011 PVS1966-A2 281 95
1012 AA-LG65M-A 494 51
1013 AA-PV45M-A 128 56
1014 AA-PV45P-A 998 5
1015 AA-PV70M-A 407 29
1016 AA-PV36P-B 786 19
1017 AA-PV36P-A 149 192
【样例输出】
1014 AA-PV45P-A 998 5 4990
1013 AA-PV45M-A 128 56 7168
1015 AA-PV70M-A 407 29 11803
1010 PVS1966-A1 580 22 12760
1016 AA-PV36P-B 786 19 14934
1012 AA-LG65M-A 494 51 25194
1011 PVS1966-A2 281 95 26695
1017 AA-PV36P-A 149 192 28608
#include <stdio.h>
#include <string.h>
// 销售记录结构体
struct Money
{
int code; // 产品代码
char name[11]; // 产品名称
int price; // 单价
int quantity; // 数量
int amount; // 金额
};
// 定义一个函数Calculate，输入是一个指向Money结构体的指针，用于计算金额
void Calculate(struct Money* record)
{
// 计算金额，将结果存入amount字段中
record->amount = record->price * record->quantity;
}
// 定义一个函数Sort，输入是一个指向Money结构体的数组和数组的长度n，用于按照金额从小到大排序
void Sort(struct Money* records, int n)
{
int i, j; // 定义两个循环变量i和j
struct Money temp; // 定义一个临时结构体变量temp，用于交换元素时临时存储数据
for (i = 0; i < n - 1; i++) // 外层循环，遍历整个数组直到最后一个元素
{
for (j = i + 1; j < n; j++) // 内层循环，从下一个人开始遍历到最后一个元素
{
if (records[i].amount > records[j].amount) // 如果当前人的金额大于下一个人的金额
{
temp = records[i]; // 将当前人的信息存储到temp中
records[i] = records[j]; // 将下一个人的信息复制到当前人位置上
records[j] = temp; // 将temp中存储的当前人信息复制到下一个人位置上，完成交换操作
}
}
}
}
// 主函数入口，执行整个程序的逻辑
int main()
{
int n, i; // 定义两个整型变量n和i，n表示销售记录的数量，i是循环计数器
struct Money records[10]; // 定义一个Money类型的数组records，最多可以存10条销售记录
// 读取销售记录的数量n，从标准输入读取数据并存入n中
scanf("%d", &n);
for (i = 0; i < n; i++) // 循环n次，每次读取一条销售记录的信息并存入数组中
{
scanf("%d %s %d %d", &records[i].code, records[i].name, &records[i].price, &records[i].quantity); // 从标准输入读取数据并存入相应的字段中，最后执行Calculate函数计算金额
Calculate(&records[i]); // 计算当前人的金额，传入的是指向当前人的指针
}
// 使用Sort函数对销售记录按照金额从小到大排序，传入的参数是records数组和数组长度n
Sort(records, n);
// 输出排序后的销售记录信息，每条记录包括产品代码、名称、单价、数量和金额五个字段
for (i = 0; i < n; i++)
{
printf("%d %s %d %d %d\n", records[i].code, records[i].name, records[i].price, records[i].quantity, records[i].amount); // 从数组中取出一条记录并输出五个字段的信息
}
return 0; // 主函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
7. 找出年龄最小的学生（结构体嵌套定义实现）
【问题描述】输入6名同学信息，同学信息包括，学号，姓名，生日（年，月，日），生日信息用一个独立的结构体表示。找出年龄最小的同学，并输出该同学的所有信息。
【输入形式】输入6名同学的信息，每个同学占一行，行内信息用空格隔开。
【输出形式】输出年龄最小的同学所有信息
【样例输入】一个同学一行，一行内每个同学的信息用单个空格隔开
11001 zhangxiao 1989 12 1
11002 wangman 1990 2 4
11003 liyu 1987 6 1
11004 shencheng 1989 12 3
11005 mengtao 1992 2 3
11006 huafeng 1992 2 5
【样例输出】输出信息之间用单个空格隔开
11006 huafeng 1992 2 5
// 引入标准输入输出库，用于后面的输入输出操作
#include<stdio.h>
// 定义一个结构体类型date，包含三个整型变量year、month和day，分别代表年、月和日
struct date
{
int year, month, day; // 年、月、日的整型变量
}s; // 定义了一个date类型的变量s，但这个变量在这段代码中并没有被使用
// 定义一个结构体类型student，包含一个整型变量ID、一个字符数组name和一个date类型的变量s
struct student
{
int ID; // 学生的ID，整型变量
char name[10]; // 学生的名字，是一个长度最多为10的字符数组
struct date s; // 学生的出生日期，使用date结构体表示
}information[6]; // 定义了一个名为information的student类型数组，长度为6，用于存储6个学生的信息
// main函数开始，C语言程序的执行从这里开始
int main()
{
int i, m; // 定义两个整型变量i和m，i用于循环计数，m用于存储最早日期的学生的索引
// 使用for循环读入6个学生的信息
for (i = 0; i < 6; i++)
{
// 使用scanf函数读入学生的ID、名字、年、月、日，并存储到结构体数组information的相应位置
scanf("%d %s %d %d %d", &information[i].ID, information[i].name, &information[i].s.year, &information[i].s.month, &information[i].s.day);
}
m = 0; // m初始化为0，用于存储最早日期的学生的索引
// 使用for循环找到最早日期的学生
for (i = 0; i < 6; i++)
{
// 如果找到了比当前最早日期更早的日期，更新m的值
if (information[i].s.year > information[m].s.year)
{
m = i;
}
// 如果年份相同，但月份更早，更新m的值
if (information[i].s.year == information[m].s.year && information[i].s.month > information[m].s.month)
{
m = i;
}
// 如果年份和月份都相同，但日期更早，更新m的值
if (information[i].s.year == information[m].s.year && information[i].s.month == information[m].s.month && information[i].s.day > information[m].s.day)
{
m = i;
}
}
// 使用printf函数输出最早日期的学生的ID、名字、年、月、日
printf("%d %s %d %d %d", information[m].ID, information[m].name, information[m].s.year, information[m].s.month, information[m].s.day); // 输出格式：ID, 名字, 年, 月, 日
return 0; // main函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
片段 1. 求解两点间距离
【问题描述】求解平面直角坐标系下两点间的距离，要求用结构体存储点信息。
【输入形式】输入两个点坐标。
【输出形式】输出两点间的距离。
【样例输入】2.3 2.1 5.6 1.2（首先输入第一个点的横坐标和纵坐标，然后再输入第二个点的信息，数据之间用单个空格隔开）
【样例输出】3.42（输出两点间的距离保留2位小数）
#include <stdio.h>
// 引入标准输入输出库，用于输入和输出操作。
#include <math.h>
// 引入数学库，用于数学函数如sqrt()计算。
struct point
// 定义一个名为point的结构体，
{
double x, y;
// 包含两个双精度浮点数x和y，代表二维平面上的点的坐标。
};
//定义距离计算函数
double distance(struct point p1, struct point p2)
// 定义一个函数，输入是两个point结构体，输出是一个双精度浮点数。函数名是distance，用于计算两点间的距离。
{
double dx = p1.x - p2.x;
// 计算两点在x轴上的距离差。
double dy = p1.y - p2.y;
// 计算两点在y轴上的距离差。
return sqrt(dx * dx + dy * dy);
// 使用勾股定理计算两点间的距离，并返回结果。
}
int main()
// 主函数开始，程序从这里开始执行。
{
point p1, p2;
// 声明两个point结构体变量p1和p2。
double dis;
// 声明一个双精度浮点数变量dis，用于存储两点间的距离。
//输入两点坐标
scanf("%lf %lf %lf %lf", &p1.x, &p1.y, &p2.x, &p2.y);
// 从标准输入读取四个双精度浮点数，并存储到p1和p2的对应坐标中。
//调用距离计算函数
dis = distance(p1, p2);
// 调用distance函数，将结果存储在dis变量中。
printf("%.2lf", dis);
// 输出dis的值，保留两位小数。
return 0;
// 主函数返回0，表示程序正常结束。
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
片段 2. 根据年月日计算天数
【问题描述】定义一个结构体变量（包括年、月、日），输入一个日期，计算在本年中是第几天，注意闰年问题。
（闰年判断方法是：1、能被4整除，但不能被100整除；2、能被400整除。这两个条件有一个能满足就说明该年是闰年）
【输入形式】年<空格>月<空格>日，数据之间用单个空格隔开
【输出形式】天数
【样例输入】2015 3 18
【样例输出】77
【样例输入】2000 3 18
【样例输出】78
// 引入标准输入输出库，用于输入输出操作
#include <stdio.h>
// 引入标准库，用于内存分配等常用功能
#include <stdlib.h>
// 定义一个结构体date，该结构体包含三个整数字段：年、月和日
struct date
{
int year, month, day;
};
// 定义一个函数count，输入是一个date类型的结构体d，返回值是一个整数
// 这个函数用来计算从1月1日到给定日期之间的天数
int count(struct date d)
{
// 定义一个整数数组days，存储每个月的天数。这里28和29是考虑到非闰年的2月只有28天
int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
// sum初始化为0，用来累计从1月1日到当前日期之间的天数
int sum = 0;
// flag初始化为0，用来标记是否是闰年
int flag = 0;
// for循环，从1月开始累计天数，直到给定的月份的前一个月为止
for (int i = 1; i < d.month; i++)
{
sum += days[i]; // 把每个月的天数累加到sum上
}
// 把给定日期的日加到sum上
sum += d.day;
// 判断给定年份是否是闰年：如果年份能被4整除但不能被100整除，或者能被400整除，那么就是闰年
if ((d.year % 4 == 0 && d.year % 100 != 0) || d.year % 400 == 0)
{
flag = 1; // 如果是闰年，把flag设为1
}
// 如果flag为1（也就是年份是闰年）且月份大于2（也就是不是2月），那么把sum加1
if (flag == 1 && d.month > 2)
{
sum++; // 因为闰年的2月有29天，所以如果给定的日期是2月之后，需要把天数加1
}
// 返回累计的天数sum
return sum;
}
// 主函数main，程序的入口点
int main()
{
// 定义一个date类型的结构体变量d，从键盘输入年月日并赋值给d
struct date d;
scanf("%d %d %d", &d.year, &d.month, &d.day); // 从键盘输入年月日并赋值给d的相应字段
// 调用count函数计算从1月1日到给定日期之间的天数，并打印结果
printf("%d", count(d)); // 打印结果
return 0; // 主函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
片段 3. 完善程序段：投票竞选班长程序
【问题描述】某班级选班长，有3个候选人，分别是li, liu, sun ,多名同学参加投票，输入end结束（输入字符串不能包含空格）,统计每个人的得票数。
【样例输入】li li liu liu liu sun end
【样例输出】li:2 liu:3 sun:1
// 引入标准输入输出库
#include<stdio.h>
// 引入字符串处理库
#include<string.h>
// 主函数入口
int main()
{
// 定义一个名为person的结构体，包含一个字符数组name和一个整数count
struct person
{
// 名字，最大长度为20个字符
char name[20];
// 计数器
int count;
}leader[3] = { "li",0,"liu",0,"sun",0 }; // 定义了一个包含五个person结构体的数组，初始值分别为"li", 0, "liu", 0, "sun", 0
// 定义两个整型变量i和j，用于循环计数
int i, j;
// 定义一个字符数组leader_name，用于存储从标准输入读取的名字
char leader_name[20];
// 循环直到读取到文件结束符或者输入"end"为止
while (scanf("%s", leader_name) != EOF && strcmp(leader_name, "end") != 0)
{
// 对数组leader中的每个person结构体进行遍历
for (i = 0; i < 3; i++)
{
// 如果输入的名字和当前person的名字相同
if (strcmp(leader_name, leader[i].name) == 0)
{
// 对当前名字的计数进行加一操作，并跳出循环
leader[i].count++;
break;
}
}
}
// 再次遍历数组leader中的每个person结构体，输出每个人的名字和计数
for (i = 0; i < 3; i++)
{
printf("%s:%d ", leader[i].name, leader[i].count);
}
return 0; // 主函数返回0，表示程序正常结束
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
片段 4. 查找 QQ 群不活跃成员
【问题描述】声明日期结构体类型，包括年、月两项；声明 QQ 群结构体类型，包括QQ号（建议声明为字符串），群昵称和最后说话时间三项，其中最后说话时间应声明为日期结构体类型。输入群成员和待比较日期，输出和待比较日期相比大于等于 6 个月不说话的所有群成员。
【输入形式】输入所有群成员，最后说话时间中的月份值非法代表输入结束；再输入待比较日期。
【输出形式】输出和待比较日期相比大于等于 6 个月不说话的所有群成员。
【样例输入】
853216595 ki999 2018 4
12378568 888 2018 3
51236985 k 2017 2
1085126957 sd 2018 4
1075125698 scsb 2017 5
567852 lgsb 2019 14
2018 5
【样例输出】
51236985 k 2017 2
1075125698 scsb 2017 5
【样例输入】
536589 uijh 2018 5
7856231 kjh 2017 10
78561236 jh 2018 3
51236985 k 2017 12
1085126957 sd 2018 4
1075125698 scsb 2018 -5
2018 5
【样例输出】
7856231 kjh 2017 10
// 引入标准输入输出库，用于输入和输出操作。
#include <stdio.h>
// 引入字符串库，用于字符串处理函数。
#include <string>
// 引入标准库，用于一些通用的函数如内存分配等。
#include <stdlib.h>
// 引入字符串库，用于字符串处理函数。
#include <string.h>
// 声明一个名为date的结构体类型，用于存储日期信息。
// 结构体包含两个成员：年year和月month。
struct date
{
int year; // 年份
int month; // 月份
};
// 声明一个名为qun的结构体类型，用于存储群组信息。
// 结构体包含三个成员：一个20字符长度的字符串qq用于存储QQ号码，一个20字符长度的字符串name用于存储成员名称，和一个date类型的last_speak_time用于存储最后发言时间。
struct qun
{
char qq[20]; // QQ号码
char name[20]; // 成员名称
struct date last_speak_time; // 最后发言时间
};
// 声明一个函数input_data，输入所有群成员信息，并返回实际输入的成员数。
int input_data(struct qun quns[]);
// 声明一个函数cha，计算两个日期之间的月份差。
// 输入是两个date类型的变量，输出是两者之间的月份差。较新的日期（da2）与较旧的日期（da1）进行比较。
int cha(struct date da1, struct date da2);
// 声明一个函数output_data，根据给定的最后发言日期，输出满足要求的群成员信息。
void output_data(struct qun quns[], struct date da, int n);
// 主函数开始执行程序的逻辑。
int main()
{
// 定义一个最多包含50个元素的qun结构体数组xquns。
struct qun xquns[50];
// 定义一个date结构体变量xda，用于存储待比较的日期数据。
struct date xda;
int n; // 定义一个整数变量n，用于存储实际输入的群成员数。
n = input_data(xquns); // 调用input_data函数，输入所有群成员信息，并将返回值存储在n中。
// 从标准输入读取两个整数，分别存储到xda的year和month成员中。这是待比较的日期数据。
scanf("%d %d", &xda.year, &xda.month); // 读取待比较日期数据（需补充代码3-2）
output_data(xquns, xda, n); // 根据给定的最后发言日期，输出满足要求的群成员信息。
return 0; // 主函数返回0，表示程序正常结束。
}
// 定义一个函数input_data，输入所有群成员信息，并返回实际输入的成员数。
int input_data(struct qun quns[])
{
// 定义一个整数变量n并初始化为0，用于记录实际输入的群成员数。
int n = 0;
// 进入无限循环，直到遇到特定条件才会跳出循环。
while (1)
{
// 使用scanf函数从标准输入读取两个字符串（qq和name）和两个整数（last_speak_time的year和month），并存储到quns数组的相应位置。
scanf("%s %s %d %d", quns[n].qq, quns[n].name, &quns[n].last_speak_time.year, &quns[n].last_speak_time.month);
// 检查最后发言时间的月份是否在1到12之间，若不在则跳出循环。
if (quns[n].last_speak_time.month < 1 || quns[n].last_speak_time.month > 12)
{
break;
}
// 将n加1，表示已经输入了一个新的群成员信息。
n++;
}
// 返回实际输入的群成员数。
return n;
}
// 定义一个函数cha，计算两个日期之间的月份差。
// 输入是两个date类型的变量，输出是两者之间的月份差。较新的日期（da2）与较旧的日期（da1）进行比较。
int cha(struct date da1, struct date da2)
{
// 计算两个日期之间的月份差。首先将年份差转换为12的倍数，然后加上月份差。
int months = (da2.year - da1.year) * 12 + (da2.month - da1.month);
// 返回月份差。
return months;
}
// 定义一个函数output_data，根据给定的最后发言日期，输出满足要求的群成员信息。
void output_data(struct qun quns[], struct date da, int n)
{
// 遍历qun数组。
for (int i = 0; i < n; i++)
{
// 计算当前群成员的最后发言日期与给定日期之间的月份差。
int months = cha(quns[i].last_speak_time, da);
// 如果月份差大于等于6，则输出该群成员的信息。
if (months >= 6)
{
printf("%s %s %d %d\n", quns[i].qq, quns[i].name, quns[i].last_speak_time.year, quns[i].last_speak_time.month);
}
}
}
//SAU-计科2304-NineSense
//仅供参考 学习还需自己努力
今天的内容就分享这么多
求三连！！！
求关注！！！
1132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
