CCF编程能力等级认证GESP—C++4级—20231209

青岛少儿编程-王老师

已于 2024-05-27 15:40:48 修改

阅读量1.1k

点赞数 20

分类专栏： CCF编程能力等级认证(GESP) # C++ - 4级文章标签： c++ 算法 java

于 2024-02-16 18:50:43 首次发布

本文链接：https://blog.csdn.net/QD_Jason/article/details/136131040

版权

CCF编程能力等级认证(GESP) 同时被 2 个专栏收录

37 篇文章 11 订阅

订阅专栏

C++ - 4级

5 篇文章 0 订阅

订阅专栏

CCF编程能力等级认证GESP—C++4级—20231209

单选题（每题 2 分，共 30 分）
判断题（每题 2 分，共 20 分）
编程题 (每题 25 分，共 50 分)
- 小杨的字典
- 田忌赛马

单选题（每题 2 分，共 30 分）

1、下面有关函数参数的说法，正确的是( )。

A. 函数参数传递时，主函数当中采用值传递方式将参数传递给子函数时，若子函数将参数值改变，主函数当中的参数值不变。
B. 函数参数传递时，主函数当中采用值传递方式将参数传递给子函数时，若子函数将参数值改变，主函数当中的参数值将随子函数一样改变而改变。
C. 函数参数传递时，主函数如果将参数的地址传递给子函数，若子函数将参数值改变，主函数当中的参数值将不改变。
D. 函数参数传递可以不满足子函数的参数个数要求。

正确答案：A

A选项：这个选项是正确的。在C++中，当使用值传递时，主函数传递给子函数的实际上是参数值的一个副本。子函数对这个副本所做的任何修改都不会影响到主函数中原始参数的值。
B选项：这个选项是错误的。如上所述，值传递是传递参数的副本，子函数中的修改不会影响到主函数中的原始参数。
C选项：这个选项也是错误的。当主函数将参数的地址（即指针）传递给子函数时，子函数可以通过这个地址直接访问和修改主函数中的原始参数。因此，如果子函数改变了参数的值，主函数中的参数值也会相应地改变。
D选项：这个选项同样是错误的。在C++中，函数调用时提供的参数个数和类型必须与函数声明或定义中指定的参数个数和类型相匹配。如果不匹配，编译器会报错。

2、下面C++代码执行后，输出的是( )。

int arr[10] = {1};
string strArr = "chen a dai";
cout << strArr[arr[1]] << endl;

A. chen
B. c
C. chen a dai
D. dai

正确答案：B

int arr[10] = {1}; 这行代码定义了一个有10个整数的数组arr，并只初始化了第一个元素为1，其他元素默认初始化为0。
string strArr = “chen a dai”; 这行代码定义了一个字符串strArr，并初始化为"chen a dai"。
cout << strArr[arr[1]] << endl; 这行代码输出字符串strArr中索引为arr[1]的字符。由于arr[1]的值是0（因为只初始化了arr[0]为1，其他元素都是0），所以这里实际是访问strArr[0]，即字符串的第一个字符，也就是’c’。

3、下面C++代码最后执行后输出是( )。

int fun1(int *n){
	return *n**n;
}
int main() {
	int arr[10] = {2};
	arr[1] = fun1(arr);
	cout << arr[1] << endl;
}

A. 1
B. 2
C. 3
D. 4

正确答案：D

1.fun1函数接受一个整数指针n，并返回该指针所指向的整数的平方。
2.在main函数中：
1)定义了一个包含10个整数的数组arr，并只初始化了第一个元素arr[0]为2，其他元素默认初始化为0。
2)调用fun1(arr)，这里arr是一个指向数组第一个元素的指针，即arr和&arr[0]是等价的。因此，fun1函数内部*n的值是arr[0]，即2。
3)fun1函数返回2 * 2 = 4。
4)将fun1函数的返回值4赋给arr[1]。
5)输出arr[1]的值，即4。

4、下面C++代码执行后的结果是( )。

	int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
	for (int i = 0; i < 3; i++){
		for (int j = 2; j >= 0; j--){
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

  1 2 3
A.4 5 6
  7 8 9
  
B.1 2 3 4 5 6 7 8 9

  3 2 1
C.6 5 4
  9 8 7
  
D.9 8 7 6 5 4 3 2 1

正确答案：C

i	j	arr[i][j]	控制台
0	2	3	3
	1	2	3 2
	0	1	3 2 1
1	2	6	3 2 1 6
	1	5	3 2 1 6 5
	0	4	3 2 1 6 5 4
2	2	9	3 2 1 6 5 4 9
	1	8	3 2 1 6 5 4 9 8
	0	7	3 2 1 6 5 4 9 8 7

5、下面C++代码执行后输出是（）。

int arr[3] = {1, 2, 3};
int *p = NULL;
p = arr;
p++;
cout << *p << endl;

A. 1,2,3
B. 1
C. 2
D. 3

正确答案：C

1.int arr[3] = {1, 2, 3}; 定义了一个整型数组 arr，包含三个元素：1, 2, 3。
2.int *p = NULL; 定义了一个整型指针 p 并初始化为 NULL。
3.p = arr; 将指针 p 指向数组 arr 的第一个元素，即 arr[0]。
4.p++; 指针 p 自增，现在 p 指向 arr 的第二个元素，即 arr[1]。
5.cout << *p << endl; 输出指针 p 当前指向的值，即 arr[1] 的值，也就是 2。

6、如果变量x的地址是0x6ffe14,下面C++代码执行以后输出的是（）。

int *p= NULL;
int x = 2;
p = &x;
p++;
cout << p << endl;

A. 0x6ffe11
B. 0x6ffe14
C. 0x6ffe18
D. 0x6ffe15

正确答案：C

1.int *p = NULL; 定义了一个整型指针 p 并初始化为 NULL。
2.int x = 2; 定义了一个整型变量 x 并初始化为 2。
3.p = &x; 将指针 p 指向变量 x 的地址，即 0x6ffe14。
4.p++; 指针 p 自增。在大多数系统上，int 类型的大小是 4 字节（32位），因此指针 p 会增加 4 字节。所以，p 的新地址是 0x6ffe14 + 4 = 0x6ffe18。
5.cout << p << endl; 输出指针 p 的当前值，即 0x6ffe18。

7、在C++中,执行下面代码后，输出的是（）。

int point(int *p){
	return *p**p;
}
int main() {
	int a = 20;
	int *p = &a;
	*p = point(p);
	cout << *p << endl;
}

A. 400
B. 200
C. 20
D. 100

正确答案：A

1.int point(int *p) { return *p * *p; } 定义了一个函数 point，它接受一个整型指针 p 作为参数，并返回指针 p 所指向的值的平方。
2.在 main 函数中，首先定义了一个整型变量 a 并初始化为 20。
3.然后定义了一个整型指针 p 并让它指向变量 a。
4.接下来，执行 *p = point( p )。这里point( p ) 会计算 a 的平方，即 20 * 20 = 400。然后，这个值（400）被赋给 *p，也就是变量 a。
5.最后，cout << *p << endl; 输出变量 a 的当前值，即 400。

8、下列C++语句执行以后结果是true的是（）。

A. 3&&false
B. 5&&2
C. 101&&000
D. 4&true

正确答案：B

在C++中，逻辑与操作符 && 用于判断两个操作数是否都为真。如果两个操作数都为真，则结果为真（true），否则为假（false）。
对于整数，非零值被视为真（true），零值被视为假（false）。
A选项：这里 3 是真，但 false 是假，所以整个表达式的结果是假（false）。
B选项：这里 5 和 2 都是非零值，因此都是真，所以整个表达式的结果是真（true）。
C选项：这里 101 是真，但 000（即十进制中的0）是假，所以整个表达式的结果是假（false）。
D选项：这里使用了位与操作符 & 而不是逻辑与操作符 &&。4 在二进制中表示为 100，而 true 为整数1（在二进制中为 001）。位与操作的结果是 000（即十进制中的0），在布尔上下文中被视为假（false）。因此，只有选项B的表达式结果为真（true）。

9、在如下的C++代码中实现了对字符串中出现的26个字母的个数统计，横线处应填入是（）。

string str = "HELLO CHEN A DAI";
int strlen = str.length();
char alpha[26] = {65};
int cnt[26] = {0};
for (int i = 1; i < 26; i++){
	________;
}
for (int i = 0; i < 26; i++){
	cout << alpha[i] << " "; 
}
cout << endl;
for (int i = 0; i < 26; i++){
	for (int j = 0; j < strlen; j++){
		if (alpha[i] == str[j]){
			cnt[i]++;
		}
	}
}
for (int i = 0; i < 26; i++){
	cout << cnt[i] << " ";
}

A. alpha[i] = alpha[i - 1] + 1;
B. alpha[i] = alpha[i] + 1;
C. alpha[i + 1] = alpha[i] + 1;
D. alpha[i - 1] = alpha[i] + 1;

正确答案：A

alpha数组初始化时只设置了第一个元素alpha[0]为65（即大写字母’A’的ASCII值），而其他元素默认初始化为0（这在C++中是字符’\0’的ASCII值，不是字母）。
为了使alpha数组包含所有大写字母的ASCII值，我们需要在第一个循环中逐个为它们赋值。从’A’（ASCII值65）到’Z’，每个后续字母的ASCII值比前一个字母大1。
A选项：这是正确的。它取前一个字母的ASCII值，并加1来得到当前字母的ASCII值。
B选项：这是错误的，因为它只是将当前字母的ASCII值加1，但当前字母的ASCII值还是0（因为除了alpha[0]外，其他元素都默认初始化为0）。
C选项：这是错误的，因为它试图为下一个字母赋值，但当前字母的ASCII值仍然是0。
D选项：这是错误的，因为它试图为前一个字母赋值，但当前字母的ASCII值仍然是0，且这会导致数组越界（当i为0时）。

10、下面C++代码执行后生成的文件其字节数为（）。

ofstream fout;
fout.open("1.txt");
for (int i = 1; i <= 10; i++){
	if (i % 5 == 0){
		int x = 6;
		fout << x;
	}else{
		char ch = 'A';
		fout << ch;
	}
}

A. 10
B. 16
C. 40
D. 24

正确答案：A

这段代码创建了一个输出文件流fout，并打开了名为"1.txt"的文件。然后，它使用一个for循环从1迭代到10。在循环中，它检查当前的i值是否可以被5整除。
如果i可以被5整除（即i的值为5或10），则它会在文件中写入整数6。
如果i不可以被5整除（即i的值为1, 2, 3, 4, 6, 7, 8, 9），则它会在文件中写入字符’A’。
因此，文件的内容将是：AAAAA6AAAA6
每个字符（无论是数字还是字母）在文件中都占用一个字节（在ASCII编码中）。所以，文件总共有10个字节。

11、下列C++代码输入 1,2,3,4 执行后，将输出的是（）。

string str = "";
cin >> str;
int strlen = str.length();
for (int i = 0; i < strlen; i++){
	if (str[i] <= '9' && str[i] >= '0'){
		cout << str[i];
	}else{
		cout << "#";
	}
}

A. 1#4#
B. 1#3#
C. 1#2#3#4#
D. 1#2#3#4

正确答案：D

str = 1,2,3,4

i	str[i]	str[i] <= ‘9’ && str[i] >= ‘0’	控制台
0	1	true	1
1	,	false	1#
2	2	true	1#2
3	,	false	1#2#
4	3	true	1#2#3
5	,	false	1#2#3#
6	4	true	1#2#3#4

12、以下C++代码用于实现每个整数对应的因数，如输入 12 ，则输出 1 2 3 4 6 12 ；如输入 18 ，则输出 1 2 3 6 9 18 。横线处应填入代码是（）。

int n;
cin >> n;
for (int i = 1; i <= n; i++){
	____{
		cout << i << " ";
	}
}

A. if(n % i == 0)
B. if(n / i == 0)
C. if(n % i != 0)
D. if(n / i != 0)

正确答案：A

这段代码的目的是输出整数n的所有因数。因数是指能够整除给定数的正整数。因此，我们需要检查从1到n的每个数i是否能够整除n。
在C++中，我们可以使用模运算符%来检查一个数是否能被另一个数整除。如果n % i的结果是0，那么说明i是n的一个因数。
因此，在横线处应该填入if(n % i == 0)，这样当i是n的因数时，就会执行花括号中的代码，输出i。

13、某公司新出了一款无人驾驶的小汽车，通过声控智能驾驶系统，乘客只要告诉汽车目的地，车子就能自动选择一条优化路线，告诉乘客后驶达那里。请问下面哪项不是驾驶系统完成选路所必须的。（）

A. 麦克风
B. 扬声器
C. 油量表
D. 传感器

正确答案：C

A选项：用于接收乘客的语音指令，这是声控系统的核心输入设备，所以它是必须的。
B选项：虽然主要用于向乘客提供信息或反馈，但在某些情况下，它也可能用于与其他车辆或基础设施进行通信。然而，对于基本的选路功能来说，它并不是必需的。
C选项：这个组件主要用于监控车辆的燃油或电力水平，以确保车辆有足够的能量到达目的地。虽然这对于车辆的安全运行是重要的，但它与选路功能本身没有直接关系。
D选项：这些设备对于无人驾驶车辆至关重要，因为它们提供了关于车辆周围环境的信息，如其他车辆、行人、道路标志等。这对于自动选择优化路线是必要的。

14、现代计算机是指电子计算机，它所基于的是（）体系结构。

A. 艾伦·图灵
B. 冯·诺依曼
C. 阿塔纳索夫
D. 埃克特-莫克利

正确答案：A

现代计算机，也就是电子计算机，主要是基于冯·诺依曼（John von Neumann）提出的计算机体系结构来设计和制造的。这一体系结构主要包括存储程序、程序由指令序列构成、采用二进制、指令和数据存储按地址访问、指令和数据以二进制形式存储在存储器中、以运算器为中心等思想。
A. 艾伦·图灵（Alan Turing）：图灵是英国数学家、逻辑学家，被认为是计算机科学之父和人工智能之父，他对计算机科学的贡献主要是在算法、逻辑和人工智能方面，而非计算机体系结构。
B. 冯·诺依曼（John von Neumann）：他是匈牙利裔美国数学家、物理学家、计算机科学家和发明家，被誉为“现代电子计算机之父”和“博弈论之父”。他提出的计算机体系结构是现代计算机设计的基础。
C. 阿塔纳索夫（John Atanasoff）：他是一位美国的物理学家和发明家，与助手克利福德·贝里（Clifford Berry）一起被认为是电子计算机的发明者之一，但他们的工作并没有像冯·诺依曼的体系结构那样对后来的计算机设计产生深远影响。
D. 埃克特-莫克利（Eckert-Mauchly）：他们是一对美国的工程师和发明家，合作开发了世界上第一台全电子通用计算机ENIAC（Electronic Numerical Integrator and Computer）。然而，他们的计算机并没有明确采用冯·诺依曼体系结构，而且他们的主要贡献是在工程实现方面。

15、输入一个正整数N，想找出它所有相邻的因数对，比如，输入12，因数对有(1,2)、(2,3)、(3,4)。下面哪段代码找不到所有的因数对？（）

A. for(i = 1; i < N; i++) if(!(N % i) && !(N % (i + 1))) printf("(%d,%d)\n", i, i + 1);
B. for(i = 2; i < N; i++) if(!(N % i) && !(N % (i + 1))) printf("(%d,%d)\n", i, i + 1);
C. for(i = 2; i < N / 2; i++) if(!(N % (i - 1)) && !(N % i)) printf("(%d,%d)\n", i - 1, i);
D. for(i = 1; i < N / 2; i++) if(!(N % i) && !(N % (i + 1))) printf("(%d,%d)\n", i, i + 1);

正确答案：A

对于给定的正整数 N，一个相邻的因数对 (a, b) 必须满足以下条件：
1.a 和 b 都是 N 的因数。
2.b = a + 1（即它们是相邻的）。

A选项：i = 1开始循环，这会导致在检查(i, i + 1)时，当i = 1时，会检查(1, 2)。然而，如果N的因数中不存在2（例如N是奇数或质数），那么(1, 2)将不会被正确输出，因为!(N % (i + 1))（即!(N % 2)）将不会为真。因此，A选项可能找不到所有的因数对。
B选项：i = 2开始循环，这确保了(i, i + 1)中的i至少为2，因此它不会尝试输出不存在的(1, 2)对。只要N的因数中存在i和i + 1，它们就会被正确输出。
C选项：i = 2开始循环，并且检查(i - 1, i)作为因数对。这确保了i - 1至少为1，因此它不会尝试输出不存在的负数因数。只要N的因数中存在i - 1和i，它们就会被正确输出。
D选项：i = 1开始循环，但只循环到N / 2。这确保了它不会尝试输出超过N一半的数作为因数对的一部分，从而提高了效率。只要N的因数中存在i和i + 1，并且i + 1不超过N / 2，它们就会被正确输出。

判断题（每题 2 分，共 20 分）

1、C++的内置函数 sort() 支持数组的局部排序。例如 int a={10,9,8,7,6,5,4,3,2,1} ，可以用sort(a,a+5) ,排序成 {6,7,8,9,10,5,4,3,2,1} 。( )

正确答案：正确

sort() 是 C++ 标准库中的一个函数，支持对数组进行排序。其使用方法为 sort(start_pointer, end_pointer) ，其中 start_pointer 为指向排序范围起始位置的指针，end_pointer 为指向排序范围结束位置的指针，它们定义了需要进行排序的元素范围。sort() 的默认排序方式为升序排序，如果需要降序排序，则需要自定义比较函数。
在上述例子中，a 为包含 10 个元素的整型数组。sort(a, a+5) 表示对数组 a 中从第 0 个元素开始到第 4 个元素（即第 5 个元素之前）的这一部分进行排序。因此，结果为 {6,7,8,9,10,5,4,3,2,1} 。

2、用递归法求 n 的阶乘，时间复杂度是 O(n) 。

正确答案：正确

使用递归法求n的阶乘时，每次递归调用都会减少问题的规模，直到达到基本情况（通常是n=0或n=1）。在这种情况下，递归的深度（即递归调用的次数）与n成正比。因此，时间复杂度是O(n)。
递归法求n的阶乘的基本递归关系可以表示为：factorial(n) = n * factorial(n-1)
其中基本情况是：factorial(0) = 1 或者 factorial(1) = 1
每次递归调用都会执行一次乘法操作，并且递归调用的次数是n次（对于n>0）。因此，总的操作次数（包括乘法和递归调用）是线性的，即O(n)。

3、 [(1,2)*2]*3 在C++中是合法的表达式。( )

正确答案：错误

首先，(1,2) 是一个逗号表达式，其值是其最后一个元素（即 2），然后计算2 * 2 的值为4。
虽然在数学中为了防止产生歧义会使用中括号[]等来划分优先级，但是编程中只能使用()。在编程中有其他的含义如数组索引，指针运算，运算符重载等。因此，[(1,2)*2]*3 在C++中不是一个合法的表达式。
如果改成((1,2)*2)*3则是一个合法的表达式

4、在下面的C++代码中，将对1.txt文件写入 hello 。( )

ifstream filein;
ofstream fileout;
filein.open("1.txt");
fileout << "hello";

正确答案：错误

在提供的C++代码中，ifstream 是用于输入文件流的类，而 ofstream 是用于输出文件流的类。代码中确实创建了一个 ofstream 对象 fileout，但是并没有调用 open 方法来指定要写入的文件名。因此，fileout 对象并没有与任何文件关联，尝试通过它写入数据将会失败。
此外，ifstream 对象 filein 被创建并尝试打开名为 "1.txt" 的文件，但是并没有使用它进行任何读取操作，而且这与题目要求的写入操作无关。
正确的代码应该只使用 ofstream 并调用 open 方法来打开文件，然后写入 "hello"。如下所示：

#include <fstream>
using namespace std;
int main() {
    fstream fileout;
    fileout.open("1.txt"); // 打开文件以写入
    if (fileout.is_open()) {
        fileout << "hello"; // 写入 "hello"
        fileout.close(); // 关闭文件
    } else {
        // 文件打开失败的处理
    }
    return 0;
}

请注意，在写入文件后，通常应该调用 close 方法来确保所有数据都被正确地写入文件并释放资源。此外，检查文件是否成功打开是一个好习惯，以便在打开失败时能够采取适当的措施。

5、文本文件 1.txt 第1行由 01234 共5个字符组成其间没有空格，当用C++代码正常打开文件成功并执行如下代码以后，第1行长度为5（）

ifstream filein;
int buff;
filein.open("1.txt");
filein >> buff;
cout << buff << endl;

正确答案：错误

在C++中，ifstream 的 >> 运算符用于从输入流中提取数据，并根据数据的类型进行解析。当使用 int 类型的变量 buff 时，filein >> buff; 会尝试从文件中读取一个整数。
由于文件的第一行是 “01234”，ifstream 会尝试将这个字符串解析为一个整数。然而，由于整数解析在遇到非数字字符时会停止，所以实际上 buff 只会被赋值为整数 0，因为 “0” 是第一个字符，并且是一个有效的整数开头。后续的字符 “1234” 将被留在输入流中，不会被读取到 buff 中。
因此，cout << buff << endl; 将输出整数 0，而不是 5，更不是第一行的长度。同时，这段代码也没有计算或输出第一行的长度。
所以，这个判断题是正确的，答案是错误。代码不会输出第一行的长度为5，而是会输出整数0。

6、执行C++代码 cout<<(5||2); 后将输出 1 。（）

正确答案：正确

在C++中，|| 是逻辑或运算符。当使用逻辑或运算符时，如果其左侧的操作数为真（非零），则整个表达式的结果就是真（1），并且不会计算右侧的操作数。如果左侧的操作数为假（零），则会计算右侧的操作数，并根据右侧操作数的真假来确定整个表达式的真假。总结四个字：一真全真
在表达式 (5||2) 中，由于 5 是一个非零值，因此它被视为真。因此，整个表达式 (5||2) 的结果就是真，即 1。

7、在C++中，两个字符串相加的运算符为+相当于字符串的合并运算。下面C++代码执行后，将输出chenadai 。（）

string a = "chen";
string b = "a";
string c = "dai";
string name = a + b + c;
cout << name << endl;

正确答案：正确

在C++中，string 类重载了 + 运算符，使其可以用于字符串的连接（合并）。当你使用 + 运算符将两个 string 对象相加时，它们的内容会被合并成一个新的 string 对象。
在提供的代码中，字符串 a、b 和 c 分别被初始化为 "chen"、"a" 和 "dai"。然后，通过 a + b + c，这三个字符串被合并成一个新的字符串 "chenadai"，并赋值给 name。最后，cout << name << endl; 输出合并后的字符串 "chenadai"。

8、C++内置函数 sort() 可以对整数、浮点数、字符数组进行从大到小，从小到大，局部排序。（）

正确答案：正确

sort() 函数可以接受自定义的比较函数或函数对象来决定排序的顺序（从小到大或从大到小）。此外，通过传递适当的迭代器范围，你可以对数组的一部分进行排序。

9、小杨最近在准备考GESP，他用的Dev C++来练习和运行程序，所以Dev C++也是一个小型操作系统。（）

正确答案：错误

Dev-C++ 是一个集成开发环境（Integrated Development Environment，IDE），用于编写、编译和运行C/C++程序。它提供了代码编辑器、编译器、调试器和其他一些工具，使得程序员能够更方便地开发C/C++程序。然而，Dev-C++本身并不是一个操作系统。
操作系统（Operating System，OS）是计算机上的一个系统软件，它是计算机硬件和应用软件之间的接口，负责管理和控制计算机的硬件和软件资源，为它们提供统一的接口和服务。常见的操作系统有Windows、Linux、macOS等。
因此，说Dev-C++是一个小型操作系统是不正确的。Dev-C++只是用于编写和运行C/C++程序的一个工具，它依赖于操作系统来提供基本的计算机资源和服务。

10、任何一个while循环都可以转化为等价的for循环（）。

正确答案：正确

在编程中，while 循环和 for 循环都是用来控制程序执行流程的结构，它们在很多情况下可以相互转换。while 循环通常用于在不知道循环次数的情况下重复执行一段代码，而 for 循环则常用于在知道循环次数的情况下执行代码。
虽然 while 循环和 for 循环在语法上有所不同，但它们的本质都是基于条件判断来控制循环的执行。因此，任何一个 while 循环都可以通过重新构造条件判断和循环体来转化为等价的 for 循环。

编程题 (每题 25 分，共 50 分)

小杨的字典

【问题描述】
在遥远的星球，有两个国家 A 国和 B 国，他们使用着不同的语言：A 语言和 B 语言。小杨是 B 国的翻译官，他的工
作是将 A 语言的文章翻译成 B 语言的文章。
为了顺利完成工作，小杨制作了一本字典，里面记录了 N 个 A 语言单词对应的 B 语言单词，巧合的是，这些单词都
由地球上的 26 个小写英文字母组成。
小杨希望你写一个程序，帮助他根据这本字典翻译一段 A 语言文章。这段文章由标点符号 !()-[]{}|;:‘",./?
<> 和一些 A 语言单词构成，每个单词之间必定由至少一个标点符号分割，你的程序需要把这段话中的所有 A 语言
单词替换成它的 B 语言翻译。特别地，如果遇到不在字典中的单词，请使用大写 UNK 来替换它。
例如，小杨的字典中包含 2 个 A 语言单词 abc 和 d ，它们的 B 语言翻译分别为 a 和 def ，那么我们可以把 A
语言文章 abc.d.d.abc.abcd. 翻译成 B 语言文章 a.def.def.a.UNK. ，其中，单词 abcd 不在词典内，因此我
们需要使用 UNK 来替换它。
【输入描述】
第一行一个整数 N ，表示词典中的条目数。保证 N <= 100 。
接下来 N 行，每行两个用单个空格隔开的字符串 A, B ，分别表示字典中的一个 A 语言单词以及它对应的 B 语言翻
译。保证所有 A 不重复；保证 A 和 B 的长度不超过 10 。
最后一行一个字符串 S ，表示需要翻译的 A 语言文章。保证字符串 S 的长度不超过 1000 ，保证字符串 S 只包含小写
字母以及标点符号 !()-[]{}|;:’“,./?<> 。
【输出描述】
输出一行，表示翻译后的结果。
【特别提醒】
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
【样例输入 1】
2
abc a
d def
abc.d.d.abc.abcd.
【样例输出 1】
a.def.def.a.UNK.
【样例输入 2】
3
abc a
d def
abcd xxxx
abc,(d)d!-abc?abcd
【样例输出 2】
a,(def)def!-a?xxxx
【样例输入 3】
1
abcdefghij klmnopqrst
!()-[]{}|;:'”,./?<>abcdefghijklmnopqrstuvwxyz
【样例输出 3】
!()-[]{}|;:'",./?<>UNK

#include <iostream>

using namespace std;
struct ch{
    string encode, decode;
}s[110];
int n;
string find(string str){
    for (int i = 1; i <= n; i++){
        if (str == s[i].encode)
            return s[i].decode;
    }
    return "UNK";
}
int main(){
    
    string str1, tmp, ans;
    cin >> n;
    for (int i = 1; i <= n; i++){
        cin >> s[i].encode >> s[i].decode;
    }
    cin >> str1;
    // 防止数组越界, 在字符串后添加一个符号
    str1 += ".";
    // 最终输出ans字符串即可
    ans = "";
    // 循环遍历str1字符串
    for (int i = 0; i < str1.length() - 1; i++){
        // 如果字符是标点符号, 直接将其添加到ans字符串中
        if (!(str1[i] >= 'a' && str1[i] <= 'z')){
            ans += str1[i];
        // 如果不是标点符号, 将该字符添加到tmp临时字符串中
        }else{
            tmp += str1[i];
            // 如果字母的下一个字符是标点符号, 判断该字符串是否在字典中
            if (!(str1[i + 1] >= 'a' && str1[i + 1] <= 'z')){
                ans += find(tmp);
                tmp = "";
            }
        }
    }
    cout << ans;
    return 0;
}

田忌赛马

【问题描述】
你要和田忌赛马。你们各自有 N 匹马，并且要进行 N 轮比赛，每轮比赛，你们都要各派出一匹马决出胜负。
你的马匹的速度分别为u1, u2, …, uN ，田忌的马匹的速度分别为 u1, u2, …, uN。田忌会按顺序派出他的马匹，请问
你要如何排兵布阵，才能赢得最多轮次的比赛？巧合的是，你和田忌的所有马匹的速度两两不同，因此不可能出现
平局。
【输入描述】
第一行一个整数 N 。保证 $1 <= N <= 5 * 10^4$ 。
接下来一行 N 个用空格隔开的整数，依次为 u1, u2, …, uN ，表示你的马匹们的速度。保证 $1 <= u i <= 2 N$ 。
接下来一行 N 个用空格隔开的整数，依次为 v1, v2, …, vN ，表示田忌的马匹们的速度。保证 $1 <= v i <= 2 N$ 。
【输出描述】
输出一行，表示你最多能获胜几轮。
【特别提醒】
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
【样例输入 1】
3
1 3 5
2 4 6
【样例输出 1】
2
【样例解释 1】
第 1 轮，田忌派出速度为的马匹，你可以派出速度为的马匹迎战，本轮你获胜。
第 2 轮，田忌派出速度为的马匹，你可以派出速度为的马匹迎战，本轮你获胜。
第 3 轮，田忌派出速度为的马匹，你可以派出速度为的马匹迎战，本轮田忌获胜。
如此，你可以赢得 2 轮比赛。
【样例输入 2】
5
10 3 5 8 7
4 6 1 2 9
【样例输出 2】
5

#include <iostream>
#include <algorithm>
/*
1 2 7 8 10
3 4 5 6 9
 
 1 ---> 9
 2 ---> 6
 7 ---> 3
 8 ---> 4
 10---> 6
 */
using namespace std;
const int maxn = 1e5;
int n, a[maxn], b[maxn], ans;
int start = 1;
int main(){
    cin >> n;
    // 输入你的马匹的速度
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    // 输入田忌的马匹的速度
    for (int i = 1; i <= n; i++)
        cin >> b[i];
    // 将你和田忌的马匹的速度进行排序
    sort(a + 1, a + n + 1);
    sort(b + 1, b + n + 1);
    // 遍历你的马匹的速度
    for (int i = 1; i <= n; i++){
        /*
         如果你的马还没有别人当前最慢的马快，那就去当炮灰。
         否则就去当前最慢的马那里和它对战。
         */
        for (int j = start; j <= n; j++){
            // 如果你的马的速度没有当前的快, 就去寻找下一匹马
            if (a[i] < b[j])
                continue;
            // 如果你的马的速度比当前的快
            else{
                // 胜利一场
                ans++;
                // 下次遍历的时候从这匹马的后面开始遍历
                start = j + 1;
                break;
            }
        }
    }
    cout << ans << endl;
    return 0;
}