目录
1091 : 童年生活二三事（多实例测试）
C
C++
1092 : 素数表(函数专题）
C
C++
1093 : 验证哥德巴赫猜想（函数专题）
C
C++
1094 : 统计元音（函数专题）
C
C++
1095 : 时间间隔（多实例测试）
C
C++
1096 : 水仙花数（多实例测试）
C
C++
1097 : 计算平均成绩（函数专题）
C
C++
使用容器map(C++)
1098 : 复合函数求值（函数专题）
C
C++
1099 : 角谷猜想（多实例测试）
C
C++
编辑
1100 : 求组合数（函数专题）
C
C++
编辑
1091 : 童年生活二三事（多实例测试）
题目描述
Redraiment小时候走路喜欢蹦蹦跳跳，他最喜欢在楼梯上跳来跳去。
但年幼的他一次只能走上一阶或者一下子蹦上两阶。
现在一共有N阶台阶，请你计算一下Redraiment从第0阶到第N阶共有几种走法。输入
输入包括多组数据。
每组数据包括一行:N(1≤N≤40)。
输入以0结束输出
对应每个输入包括一个输出。
为redraiment到达第n阶不同走法的数量。样例输入
1
3
0样例输出
1 3本质：斐波那契数列
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 solve，用于计算从第0阶到第n阶的走法总数
void solve(int n)
{
int arr[50]; // 定义一个数组 arr，用于存储每一阶的走法数，最大支持计算到第50阶
arr[0] = 1; // 初始化第0阶的走法数为1（站在第0阶，只有一种方式）
arr[1] = 1; // 初始化第1阶的走法数为1（从第0阶走1步到达第1阶）
// 使用循环计算从第2阶到第n阶的走法数
for(int i = 2; i <= n; i++)
{
// 第i阶的走法数等于第(i-1)阶和第(i-2)阶的走法数之和
// 因为可以从第(i-1)阶走1步上来，或者从第(i-2)阶跳2步上来
arr[i] = arr[i - 1] + arr[i - 2];
}
// 输出第n阶的走法数
printf("%d\n", arr[n]);
}
int main()
{
int m; // 定义变量m，用于存储输入的台阶数
// 使用while循环不断读取输入的台阶数，直到输入0为止
while(scanf("%d", &m), m != 0)
{
// 调用solve函数计算从第0阶到第m阶的走法总数
solve(m);
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 solve，用于计算从第0阶到第n阶的走法总数
void solve(int n)
{
int arr[50]; // 定义一个数组 arr，用于存储每一阶的走法数，最大支持计算到第50阶
arr[0] = 1; // 初始化第0阶的走法数为1（站在第0阶，只有一种方式）
arr[1] = 1; // 初始化第1阶的走法数为1（从第0阶走1步到达第1阶）
// 使用循环计算从第2阶到第n阶的走法数
for(int i = 2; i <= n; i++)
{
// 第i阶的走法数等于第(i-1)阶和第(i-2)阶的走法数之和
// 因为可以从第(i-1)阶走1步上来，或者从第(i-2)阶跳2步上来
arr[i] = arr[i - 1] + arr[i - 2];
}
// 输出第n阶的走法数
printf("%d\n", arr[n]);
}
int main()
{
int m; // 定义变量m，用于存储用户输入的台阶数
// 使用while循环不断读取用户输入的台阶数，直到输入0为止
while(scanf("%d", &m), m != 0)
{
// 调用solve函数计算从第0阶到第m阶的走法总数
solve(m);
}
return 0; // 程序正常结束
}1092 : 素数表(函数专题）
题目描述
输入两个正整数m和n，输出m和n之间的所有素数。
要求程序定义一个prime()函数和一个main()函数，prime()函数判断一个整数n是否是素数，其余功能在main()函数中实现。
int prime(int n)
{
//判断n是否为素数， 若n为素数，本函数返回1，否则返回0
}输入
输入两个正整数m和n，m<=n，且都在int范围内。
输出
输出占一行。输出m和n之间的所有素数，每个数后有一个空格。如果如果m到n之间没有素数，输出”No Answer”。
样例输入
2 6
样例输出
2 3 5注意：特判0和1
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 prime，用于判断一个整数 n 是否是素数
int prime(int n)
{
// 如果 n 是 0 或 1，直接返回 0（表示不是素数）
if(n == 0 || n == 1)
{
return 0;
}
// 使用循环判断 n 是否能被从 2 到 sqrt(n) 之间的任何数整除
for(int i = 2; i * i <= n; i++) // 只需检查到 sqrt(n)，因为如果 n 有因子，必有一个因子小于等于 sqrt(n)
{
// 如果 n 能被 i 整除，则 n 不是素数，返回 0
if(n % i == 0)
{
return 0;
}
}
// 如果没有找到任何因子，则 n 是素数，返回 1
return 1;
}
int main()
{
int m, n; // 定义变量 m 和 n，分别表示范围的起始值和结束值
int flag = 0; // 定义一个标志变量，用于判断是否找到素数
scanf("%d%d", &m, &n); // 从用户输入中读取 m 和 n 的值
// 遍历从 m 到 n 的所有整数
for(int i = m; i <= n; i++)
{
// 如果当前数 i 是素数
if(prime(i) == 1)
{
printf("%d ", i); // 输出当前素数
flag = 1; // 设置标志变量为 1，表示已找到至少一个素数
}
}
// 如果没有找到任何素数
if(flag == 0)
{
printf("No Answer\n"); // 输出 "No Answer"
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 prime，用于判断一个数是否是素数
int prime(int n)
{
// 如果 n 是 0 或 1，直接返回 0（表示不是素数）
if(n == 0 || n == 1)
{
return 0;
}
// 使用循环判断 n 是否能被从 2 到 sqrt(n) 之间的任何数整除
for(int i = 2; i * i <= n; i++) // 只需检查到 sqrt(n)，因为如果 n 有因子，必有一个因子小于等于 sqrt(n)
{
if(n % i == 0) // 如果 n 能被 i 整除，则 n 不是素数
{
return 0;
}
}
// 如果没有找到任何因子，则 n 是素数，返回 1
return 1;
}
int main()
{
int m, n; // 定义变量 m 和 n，分别表示范围的起始值和结束值
int flag = 0; // 定义一个标志变量，用于判断是否找到素数
scanf("%d%d", &m, &n); // 从用户输入中读取 m 和 n 的值
// 遍历从 m 到 n 的所有整数
for(int i = m; i <= n; i++)
{
// 如果当前数 i 是素数
if(prime(i) == 1)
{
printf("%d ", i); // 输出当前素数
flag = 1; // 设置标志变量为 1，表示已找到至少一个素数
}
}
// 如果没有找到任何素数
if(flag == 0)
{
printf("No Answer\n"); // 输出 "No Answer"
}
return 0; // 程序正常结束
}
1093 : 验证哥德巴赫猜想（函数专题）
题目描述
哥德巴赫猜想大家都知道一点吧。我们现在不是想证明这个结论，而是对于任给的一个不小于6的偶数，来寻找和等于该偶数的所有素数对。做好了这件实事,就能说明这个猜想是成立的。
要求程序定义一个prime()函数和一个main()函数，prime()函数判断一个整数n是否是素数，其余功能在main()函数中实现。
int prime(int n)
{
//判断n是否为素数， 若n为素数，本函数返回1，否则返回0
}输入
一个偶数M (M是6到1000000之间的一个偶数).
输出
输出和等于该偶数的所有素数对a和b，按a递增的顺序输出，(a,b)和(b,a)被视为同一个素数对。
样例输入
40
样例输出
3 37 11 29 17 23注意：对两个加数都要素数判定
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 prime，用于判断一个整数 n 是否是素数
int prime(int n)
{
// 如果 n 是 0 或 1，直接返回 0（表示不是素数）
if(n == 0 || n == 1)
{
return 0;
}
// 使用循环判断 n 是否能被从 2 到 sqrt(n) 之间的任何数整除
for(int i = 2; i * i <= n; i++) // 只需检查到 sqrt(n)，因为如果 n 有因子，必有一个因子小于等于 sqrt(n)
{
// 如果 n 能被 i 整除，则 n 不是素数，返回 0
if(n % i == 0)
{
return 0;
}
}
// 如果没有找到任何因子，则 n 是素数，返回 1
return 1;
}
int main()
{
int n;
int flag = 0; // 定义一个标志变量，用于判断是否找到符合条件的素数组合
scanf("%d", &n);
// 遍历从 2 到 n/2 的所有整数 i
for(int i = 2; i <= n / 2; i++)
{
// 检查 i 和 n-i 是否都是素数
if(prime(i) == 1 && prime(n - i) == 1)
{
printf("%d %d\n", i, n - i); // 输出符合条件的素数组合
flag = 1; // 设置标志变量为 1，表示已找到至少一个符合条件的组合
}
}
// 如果没有找到任何符合条件的素数组合
if(flag == 0)
{
printf("No Answer\n"); // 输出 "No Answer"
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 prime，用于判断一个整数 n 是否是素数
int prime(int n)
{
// 如果 n 是 0 或 1，直接返回 0（表示不是素数）
if(n == 0 || n == 1)
{
return 0;
}
// 使用循环判断 n 是否能被从 2 到 sqrt(n) 之间的任何数整除
for(int i = 2; i * i <= n; i++) // 只需检查到 sqrt(n)，因为如果 n 有因子，必有一个因子小于等于 sqrt(n)
{
// 如果 n 能被 i 整除，则 n 不是素数，返回 0
if(n % i == 0)
{
return 0;
}
}
// 如果没有找到任何因子，则 n 是素数，返回 1
return 1;
}
int main()
{
int n;
int flag = 0; // 定义一个标志变量，用于判断是否找到符合条件的素数组合
scanf("%d", &n);
// 遍历从 2 到 n/2 的所有整数 i
for(int i = 2; i <= n / 2; i++)
{
// 检查 i 和 n-i 是否都是素数
if(prime(i) == 1 && prime(n - i) == 1)
{
printf("%d %d\n", i, n - i); // 输出符合条件的素数组合
flag = 1; // 设置标志变量为 1，表示已找到至少一个符合条件的组合
}
}
// 如果没有找到任何符合条件的素数组合
if(flag == 0)
{
printf("No Answer\n"); // 输出 "No Answer"
}
return 0; // 程序正常结束
}
1094 : 统计元音（函数专题）
题目描述
输入一个字符串，统计其中元音字母的个数。要求使用函数vowel()用来判断是否为元音,其余功能在main()函数中实现。
int vowel(char ch)
{
//如果ch是元音，返回1，否则返回0
}输入
输入一个字符串，长度不超过1000，以回车符结束。
输出
输出一个整数，表示元音字母个数。输出单独占一行。
样例输入
Hello world!
样例输出
3注意：别忘记判断大写字母
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 vowel，用于判断一个字符是否是元音字母
int vowel(char ch)
{
// 判断字符 ch 是否是元音字母 a, e, i, o, u 或者它们的大写形式
if(ch == 'a' || ch == 'o' || ch == 'e' || ch == 'u' || ch == 'i' ||
ch == 'A' || ch == 'O' || ch == 'E' || ch == 'U' || ch == 'I')
{
return 1; // 如果是元音字母，返回 1
}
return 0; // 如果不是元音字母，返回 0
}
int main()
{
char str[1010]; // 定义一个字符数组 str，用于存储输入的字符串，最大长度为 1010
gets(str); // 使用 gets 函数从标准输入读取字符串
int num = 0; // 定义一个变量 num，用于统计元音字母的数量，初始值为 0
// 遍历字符串中的每个字符
for(int i = 0; str[i] != '\0'; i++) // 当字符不是字符串结束符 '\0' 时，继续循环
{
// 如果当前字符是元音字母
if(vowel(str[i]) == 1)
{
num++; // 元音字母数量加 1
}
}
// 输出统计到的元音字母数量
printf("%d\n", num);
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 vowel，用于判断一个字符是否是元音字母
int vowel(char ch)
{
// 判断字符 ch 是否是元音字母 a, e, i, o, u 或者它们的大写形式
if(ch == 'a' || ch == 'o' || ch == 'e' || ch == 'u' || ch == 'i' ||
ch == 'A' || ch == 'O' || ch == 'E' || ch == 'U' || ch == 'I')
{
return 1; // 如果是元音字母，返回 1
}
return 0; // 如果不是元音字母，返回 0
}
int main()
{
char ch1; // 定义一个字符变量 ch1，用于存储每次读取的字符
int num = 0; // 定义一个变量 num，用于统计元音字母的数量，初始值为 0
// 使用 while 循环逐字符读取输入，直到遇到换行符 '\n' 为止
while(scanf("%c", &ch1), ch1 != '\n')
{
// 如果当前字符是元音字母
if(vowel(ch1) == 1)
{
num++; // 元音字母数量加 1
}
}
// 输出统计到的元音字母数量
printf("%d\n", num);
return 0; // 程序正常结束
}1095 : 时间间隔（多实例测试）
题目描述
从键盘输入两个时间点(24小时制），输出两个时间点之间的时间间隔，时间间隔用“小时:分钟:秒”表示。
输入
输入数据有多组。每组输入包括两行。第一行为时间点1，第二行为时间点2，时间点均以“HH:MM:SS”的格式输入。测试数据保证时间点1早于时间点2。
输出
对应每组数据，有一行输出，以“HH:MM:SS”的格式输出时间间隔。注意不足两位要补占位符0。格式参看输入输出。
样例输入
12:01:12
13:09:43
12:40:12
13:09:43样例输出
01:08:31 00:29:31注意：将时间转化为秒更好算
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
int main()
{
int h1, t1, s1, h2, t2, s2; // 定义变量，分别存储两个时间点的小时、分钟和秒
int time1, time2, res; // 定义变量，用于存储转换后的时间戳和时间间隔
// 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
while(scanf("%d:%d:%d%d:%d:%d", &h1, &t1, &s1, &h2, &t2, &s2) != EOF)
{
// 将第一个时间点转换为秒数
time1 = h1 * 3600 + t1 * 60 + s1; // 小时转换为秒，分钟转换为秒，加上秒数
// 将第二个时间点转换为秒数
time2 = h2 * 3600 + t2 * 60 + s2; // 同样将小时和分钟转换为秒，加上秒数
// 计算两个时间点之间的时间间隔（以秒为单位）
res = time2 - time1; // 用第二个时间点减去第一个时间点
// 将时间间隔转换为“小时:分钟:秒”的格式
// 用总秒数除以 3600 得到小时数
// 用总秒数对 3600 取余后再除以 60 得到分钟数
// 用总秒数对 3600 取余后再对 60 取余得到秒数
printf("%02d:%02d:%02d\n", res / 3600, res % 3600 / 60, res % 3600 % 60);
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std;
int main()
{
int h1, t1, s1, h2, t2, s2; // 定义变量，分别存储两个时间点的小时、分钟和秒
int time1, time2, res; // 定义变量，用于存储转换后的时间戳和时间间隔
// 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
while(scanf("%d:%d:%d %d:%d:%d", &h1, &t1, &s1, &h2, &t2, &s2) != EOF)
{
// 将第一个时间点转换为秒数
time1 = h1 * 3600 + t1 * 60 + s1; // 小时转换为秒，分钟转换为秒，加上秒数
// 将第二个时间点转换为秒数
time2 = h2 * 3600 + t2 * 60 + s2; // 同样将小时和分钟转换为秒，加上秒数
// 计算两个时间点之间的时间间隔（以秒为单位）
res = time2 - time1; // 用第二个时间点减去第一个时间点
// 如果时间间隔为负数，加上一天的总秒数（86400秒），使其变为正数
if (res < 0) {
res += 24 * 3600;
}
// 将时间间隔转换为“小时:分钟:秒”的格式
// 用总秒数除以 3600 得到小时数
// 用总秒数对 3600 取余后再除以 60 得到分钟数
// 用总秒数对 3600 取余后再对 60 取余得到秒数
printf("%02d:%02d:%02d\n", res / 3600, res % 3600 / 60, res % 3600 % 60);
}
return 0; // 程序正常结束
}
1096 : 水仙花数（多实例测试）
题目描述
春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的：
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=13+53+33。
现在要求输出所有在m和n范围内的水仙花数。输入
输入数据有多组，每组占一行，包括两个整数m和n（100<=m<=n<=999）。
输出
对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;
如果给定的范围内不存在水仙花数，则输出no;
每个测试实例的输出占一行。样例输入
100 120
300 380样例输出
no 370 371
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 judge，用于判断一个整数是否是水仙花数
int judge(int n)
{
int a, b, c; // 定义变量 a, b, c，分别存储数字 n 的百位、十位和个位
a = n / 100; // 获取百位数字
b = n / 10 % 10; // 获取十位数字
c = n % 10; // 获取个位数字
// 判断 n 是否等于其各位数字的立方和
if(n == a*a*a + b*b*b + c*c*c)
{
return 1; // 如果是水仙花数，返回 1
}
return 0; // 如果不是水仙花数，返回 0
}
int main()
{
int m, n; // 定义变量 m 和 n，分别存储用户输入的范围的起始值和结束值
// 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
while(scanf("%d%d", &m, &n) != EOF)
{
int flag = 0; // 定义一个标志变量，用于判断是否找到水仙花数
// 遍历从 m 到 n 的所有整数
for(int i = m; i <= n; i++)
{
// 如果当前数 i 是水仙花数
if(judge(i) == 1)
{
// 如果已经输出过一个水仙花数，则在当前数前加一个空格
if(flag == 1)
{
printf(" ");
}
printf("%d", i); // 输出当前水仙花数
flag = 1; // 设置标志变量为 1，表示已找到至少一个水仙花数
}
}
// 如果没有找到任何水仙花数
if(flag == 0)
{
printf("no\n"); // 输出 "no"
}
else
{
printf("\n"); // 如果找到水仙花数，输出换行符
}
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 judge，用于判断一个整数是否是水仙花数
int judge(int n)
{
int a, b, c; // 定义变量 a, b, c，分别存储数字 n 的百位、十位和个位
a = n / 100; // 获取百位数字
b = n / 10 % 10; // 获取十位数字
c = n % 10; // 获取个位数字
// 判断 n 是否等于其各位数字的立方和
if(n == a*a*a + b*b*b + c*c*c)
{
return 1; // 如果是水仙花数，返回 1
}
return 0; // 如果不是水仙花数，返回 0
}
int main()
{
int m, n; // 定义变量 m 和 n，分别存储用户输入的范围的起始值和结束值
// 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
while(cin >> m >> n)
{
int flag = 0; // 定义一个标志变量，用于判断是否找到水仙花数
// 遍历从 m 到 n 的所有整数
for(int i = m; i <= n; i++)
{
// 如果当前数 i 是水仙花数
if(judge(i) == 1)
{
// 如果已经输出过一个水仙花数，则在当前数前加一个空格
if(flag == 1)
{
cout << " ";
}
cout << i; // 输出当前水仙花数
flag = 1; // 设置标志变量为 1，表示已找到至少一个水仙花数
}
}
// 如果没有找到任何水仙花数
if(flag == 0)
{
cout << "no" << endl; // 输出 "no"
}
else
{
cout << endl; // 如果找到水仙花数，输出换行符
}
}
return 0; // 程序正常结束
}
1097 : 计算平均成绩（函数专题）
题目描述
输入某位同学各门课的成绩，输出平均成绩。输入的成绩均为五级制成绩，五级制成绩转换为百分之成绩的规则如下：'A'转换为百分之成绩为95分，'B'对应85分，C对应75分，'D'对应65分，'E'对应40分。 输出的平均成绩为一个实数，保留1为小数。
输入
输入为一行只包含'A'~'E'的字母，每个字母表示一门课的成绩，长度小于10
输出
输出平均成绩，为一个实数，保留一位小数。
样例输入
ABCDE
样例输出
72.0
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义一个函数 judge，用于将五级制成绩转换为百分制成绩
int judge(char ch)
{
char str[100]; // 定义一个字符数组 str，用于存储五级制成绩与百分制成绩的映射关系
// 初始化五级制成绩与百分制成绩的映射关系
str['A'] = 95; // 'A' 对应 95 分
str['B'] = 85; // 'B' 对应 85 分
str['C'] = 75; // 'C' 对应 75 分
str['D'] = 65; // 'D' 对应 65 分
str['E'] = 40; // 'E' 对应 40 分
// 返回对应的成绩
return str[ch];
}
int main()
{
char ch1; // 定义一个字符变量 ch1，用于存储每次读取的成绩
double num = 0, sum = 0; // 定义变量 num 和 sum，分别用于存储成绩的数量和总和
// 使用 while 循环逐字符读取输入，直到遇到换行符 '\n' 为止
while(scanf("%c", &ch1), ch1 != '\n')
{
sum += judge(ch1); // 调用 judge 函数将五级制成绩转换为百分制成绩，并累加到总和中
num++; // 成绩数量加 1
}
// 计算平均成绩，并保留 1 位小数
printf("%.1f\n", sum / num);
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
// 定义一个函数 judge，用于将五级制成绩转换为百分制成绩
int judge(char ch)
{
char str[100]; // 定义一个字符数组 str，用于存储五级制成绩与百分制成绩的映射关系
// 初始化五级制成绩与百分制成绩的映射关系
str['A'] = 95; // 'A' 对应 95 分
str['B'] = 85; // 'B' 对应 85 分
str['C'] = 75; // 'C' 对应 75 分
str['D'] = 65; // 'D' 对应 65 分
str['E'] = 40; // 'E' 对应 40 分
// 返回对应的成绩
return str[ch];
}
int main()
{
char ch1; // 定义一个字符变量 ch1，用于存储每次读取的成绩
double num = 0, sum = 0; // 定义变量 num 和 sum，分别用于存储成绩的数量和总和
// 使用 while 循环逐字符读取输入，直到遇到换行符 '\n' 为止
while(scanf("%c", &ch1), ch1 != '\n')
{
sum += judge(ch1); // 调用 judge 函数将五级制成绩转换为百分制成绩，并累加到总和中
num++; // 成绩数量加 1
}
// 计算平均成绩，并保留 1 位小数
printf("%.1f\n", sum / num);
return 0; // 程序正常结束
}使用容器map(C++)
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std;
int main()
{
map<char, int> grade; // 定义一个 map，用于存储五级制成绩与百分制成绩的映射关系
grade['A'] = 95; // 'A' 对应 95 分
grade['B'] = 85; // 'B' 对应 85 分
grade['C'] = 75; // 'C' 对应 75 分
grade['D'] = 65; // 'D' 对应 65 分
grade['E'] = 40; // 'E' 对应 40 分
double num = 0, sum = 0; // 定义变量 num 和 sum，分别用于存储成绩的数量和总和
char ch1; // 定义一个字符变量 ch1，用于存储每次读取的成绩
// 使用 while 循环逐字符读取输入，直到遇到换行符 '\n' 为止
while(scanf("%c", &ch1), ch1 != '\n')
{
sum += grade[ch1]; // 通过 map 查找对应的成绩并累加到总和中
num++; // 成绩数量加 1
}
// 计算平均成绩，并保留 1 位小数
printf("%.1f\n", sum / num);
return 0; // 程序正常结束
}1098 : 复合函数求值（函数专题）
题目描述
求复合函数F(G(x))，其中函数F(x)=|x-3|+|x+1|，函数G(x)=x^2-3x。要求编写函数funF()和funG()分别求F(x)和G(x)，其余功能在main()中实现。
double funF(double x)
{
//函数返回F(x)的值；
}
double funG(double x)
{
//函数返回G(x)的值；
}输入
输入一个实数x。
输出
输出复合函数的值，结果保留2位小数。输出占一行。
样例输入
10.2
样例输出
144.88
C
#include<stdio.h>
#include<math.h> // 包含数学函数库，用于计算绝对值
// 定义函数 funG，计算 G(x) = x^2 - 3x
double funG(double x)
{
return x * x - 3 * x; // 返回 G(x) 的值
}
// 定义函数 funF，计算 F(x) = |x - 3| + |x + 1|
double funF(double x)
{
return fabs(x - 3) + fabs(x + 1); // 返回 F(x) 的值
}
int main()
{
double x; // 定义变量 x，用于存储用户输入的实数
scanf("%lf", &x); // 从用户输入中读取一个实数 x
// 计算复合函数 F(G(x)) 的值
double result = funF(funG(x)); // 先计算 G(x)，再将结果传递给 F(x)
// 输出结果，保留两位小数
printf("%.2f\n", result);
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std;
// 定义函数 G，计算 G(x) = x^2 - 3x
double G(double x)
{
return x * x - 3 * x; // 返回 G(x) 的值
}
// 定义函数 F，计算 F(x) = |x - 3| + |x + 1|
double F(double x)
{
double x1 = G(x); // 先计算 G(x) 的值
return fabs(x1 - 3) + fabs(x1 + 1); // 返回 F(G(x)) 的值
}
int main()
{
double x; // 定义变量 x，用于存储用户输入的实数
scanf("%lf", &x); // 从用户输入中读取一个实数 x
printf("%.2f", F(x)); // 计算并输出 F(G(x)) 的值，保留两位小数
return 0; // 程序正常结束
}1099 : 角谷猜想（多实例测试）
题目描述
任何一个自然数，如果是偶数，就除以2，如果是奇数，就乘以3再加1。最后，经过若干次迭代得到1。也就是说，不管怎样迭代，不断除以2以后，最后是1。现在给你一个自然数n，求出它转变为1所需要的步数。
输入
输入数据有多组，每组输入包含一个自然数n。测试数据保证输入数据及中间结果都在int范围内。
输出
对每组输入，输出经过角谷猜想变成1的步数。
样例输入
5
11样例输出
5 14
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 定义函数 step，计算自然数 n 转变为 1 所需要的步数
int step(int n)
{
int num = 0; // 定义变量 num，用于记录步数，初始值为 0
while(n != 1) // 当 n 不等于 1 时，继续循环
{
num++; // 步数加 1
if(n % 2 == 0) // 如果 n 是偶数
{
n >>= 1; // 将 n 右移 1 位，即 n 除以 2
}
else // 如果 n 是奇数
{
n = n * 3 + 1; // 将 n 乘以 3 再加 1
}
}
return num; // 返回步数
}
int main()
{
int n;
while(scanf("%d", &n) != EOF) // 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
{
printf("%d\n", step(n)); // 调用 step 函数计算步数，并输出结果
}
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std;
// 定义函数 step，计算自然数 n 转变为 1 所需要的步数
int step(int n)
{
int num = 0; // 定义变量 num，用于记录步数，初始值为 0
// 当 n 不等于 1 时，继续循环
while(n != 1)
{
num++; // 每次循环步数加 1
// 如果 n 是偶数
if(n % 2 == 0)
{
n >>= 1; // 将 n 右移 1 位，相当于 n 除以 2
}
else
{
n = n * 3 + 1; // 如果 n 是奇数，则将 n 乘以 3 再加 1
}
}
return num; // 返回最终的步数
}
int main()
{
int n;
// 使用 while 循环不断读取输入，直到遇到文件结束符 EOF
while(scanf("%d", &n) != EOF)
{
printf("%d\n", step(n)); // 调用 step 函数计算步数，并输出结果
}
return 0; // 程序正常结束
}
1100 : 求组合数（函数专题）
题目描述
求马上要举办新生程序设计竞赛了，与以往不同的是，本次比赛以班为单位，为了全面衡量一个班级的整体水平，要求从一个班的m位同学中任选k位同学代表本班参加比赛，问有多少种组合方案。显然，这个组合数是m!/(k!(m-k)!)。要求编写函数fact()，实现求一个数的阶乘功能，在主函数中调用此函数。
unsigned long fact(unsigned int n){
//函数返回值为n的阶乘。
}输入
输入两个正整数m,k，k<=m<=12。
输出
输出一个整数，即组合方案数。
样例输入
5 3
样例输出
10
C
#include<stdio.h> // 包含标准输入输出库
#include<math.h>
// 使用 typedef 定义一个别名 i64，表示 long long 类型
typedef long long i64;
// 定义函数 fact，计算 n 的阶乘
i64 fact(int n)
{
int num = 1; // 定义变量 num，用于存储阶乘的结果，初始值为 1
for(int i = 1; i <= n; i++) // 使用 for 循环计算 n 的阶乘
{
num *= i; // 将当前值 i 乘到 num 中
}
return num; // 返回计算得到的阶乘结果
}
int main()
{
int n, k; // 定义变量 n 和 k，分别表示总人数和需要选择的人数
scanf("%d%d", &n, &k); // 从用户输入中读取 n 和 k 的值
// 计算组合数 C(n, k) = n! / (k! * (n - k)!)
int res = fact(n) / fact(n - k) / fact(k);
printf("%d\n", res); // 输出结果
return 0; // 程序正常结束
}C++
#include<bits/stdc++.h> // 包含常用的头文件，方便使用各种标准库功能
using namespace std; // 使用标准命名空间，避免重复写std::
typedef long long i64; // 使用 typedef 定义别名 i64，表示 long long 类型
// 定义函数 fact，计算 n 的阶乘
i64 fact(int n)
{
int num = 1; // 定义变量 num，用于存储阶乘的结果，初始值为 1
for(int i = 1; i <= n; i++) // 使用 for 循环从 1 到 n 逐个乘到 num 中
{
num *= i; // 将当前值 i 乘到 num 中
}
return num; // 返回计算得到的阶乘结果
}
int main()
{
int n, k; // 定义变量 n 和 k，分别表示总人数和需要选择的人数
scanf("%d%d", &n, &k); // 从用户输入中读取 n 和 k 的值
// 计算组合数 C(n, k) = n! / (k! * (n - k)!)
int res = fact(n) / fact(n - k) / fact(k); // 调用 fact 函数计算阶乘，并根据组合数公式计算结果
printf("%d\n", res); // 输出结果
return 0; // 程序正常结束
}
