电子学会C++编程等级考试2023年05月（二级）真题解析

C/C++编程（1~8级）全部真题・点这里

第1题：数字放大

给定一个整数序列以及放大倍数x，将序列中每个整数放大x倍后输出。
时间限制：1000
内存限制：65536
输入
包含三行： 第一行为N，表示整数序列的长度(N ≤ 100)； 第二行为N个整数（不超过整型范围），整数之间以一个空格分开； 第三行包含一个整数（不超过整型范围），为指定的整数x。
输出
N个整数，为原序列放大之后的序列，整数之间以一个空格分开。
样例输入
3
1 5 7
2
样例输出
2 10 14

以下是解决该问题的完整C++代码和解析过程：

#include 

int main() {
    int N;
    std::cin >> N;

    int sequence[N];
    for (int i = 0; i < N; i++) {
        std::cin >> sequence[i];
    }

    int x;
    std::cin >> x;

    for (int i = 0; i < N; i++) {
        sequence[i] *= x;
        std::cout << sequence[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

解析过程如下：

1. 首先，包含 头文件，这是用于输入和输出的标准库。

2. 在 main() 函数中，声明一个整数变量 N，用于存储整数序列的长度。

3. 使用 std::cin 对象，通过输入流操作符 >> 将输入的整数序列的长度赋值给变量 N。

4. 声明一个大小为 N 的整数数组 sequence，用于存储整数序列。

5. 使用 for 循环遍历数组，循环变量 i 从0到 N-1。

6. 在循环中，使用 std::cin 对象，通过输入流操作符 >> 依次将输入的整数赋值给数组 sequence 的每个元素。

7. 声明一个整数变量 x，用于存储放大倍数。

8. 使用 std::cin 对象，通过输入流操作符 >> 将输入的放大倍数赋值给变量 x。

9. 使用 for 循环遍历数组，循环变量 i 从0到 N-1。

10. 在循环中，将数组 sequence 的每个元素乘以放大倍数 x，并将结果存回相应的数组元素。

11. 使用 std::cout 对象和输出流操作符 <<，在循环中输出数组 sequence 的每个元素，之间用一个空格分隔。

12. 在输出循环结束后，使用 std::endl 输出一个换行符，使输出结果换行。

13. return 0; 表示程序正常结束。

14. 在运行程序时，按照题目要求输入整数序列的长度 N、整数序列和放大倍数 x。

15. 程序将对整数序列中的每个整数进行放大操作，然后输出放大后的序列。

例如，对于样例输入 3、1 5 7 和 2，程序将对整数序列 1 5 7 中的每个整数进行放大2倍，得到 2 10 14，然后输出结果为 2 10 14。

第2题：单词倒排

编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。
时间限制：10000
内存限制：65536
输入
输入为一个字符串（字符串长度至多为100）。
输出
输出为按要求排序后的字符串。
样例输入
I am a student
样例输出
student a am Ie

以下是一个解决该问题的C++代码示例：

#include 
#include 
#include 
#include 

int main() {
    std::string input;
    std::getline(std::cin, input);

    std::istringstream iss(input);
    std::vector<std::string> words;

    std::string word;
    while (iss >> word) {
        words.push_back(word);
    }

    std::reverse(words.begin(), words.end());

    for (const std::string& w : words) {
        std::cout << w << " ";
    }
    std::cout << std::endl;

    return 0;
}

解析过程如下：

16. 首先，包含 头文件，这是用于输入和输出的标准库。

17. 包含 头文件，这是用于字符串流操作的标准库。

18. 包含 头文件，这是用于存储动态数组的标准库。

19. 包含 头文件，这是用于算法操作的标准库。

20. 在 main() 函数中，声明一个字符串变量 input，用于存储输入的字符串。

21. 使用 std::getline() 函数从标准输入中读取一行字符串，并将其存入变量 input 中。

22. 声明一个 std::istringstream 对象 iss，用于将字符串 input 转换为字符串流。

23. 声明一个 std::vector 容器 words，用于存储分解后的单词。

24. 声明一个字符串变量 word，用于临时存储每个单词。

25. 使用 while 循环，通过字符串流 iss 逐个读取单词，并将其存入容器 words 中，直到字符串流 iss 读取完所有单词。

26. 使用 std::reverse() 函数将容器 words 中的单词顺序进行倒排操作。

27. 使用 for 循环遍历容器 words，循环变量 w 表示容器中的每个单词。

28. 在循环中，输出单词 w，使用 std::cout 对象和输出流操作符 <<。

29. 在输出循环结束后，使用 std::endl 输出一个换行符，使输出结果换行。

30. return 0; 表示程序正常结束。

31. 在运行程序时，按照题目要求输入一个字符串。

32. 程序将对输入的字符串进行分解、倒排操作，并输出结果。

例如，对于样例输入 "I am a student"，程序将将字符串分解为单词 "I", "am", "a", "student"，然后进行倒排操作得到 "student", "a", "am", "I"，最终输出结果为 "student a am I"。

第3题：计算矩阵边缘元素之和

所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
时间限制：10000
内存限制：65536
输入
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。 接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
输出
输出对应矩阵的边缘元素和
样例输入
3 3
3 4 1
3 7 1
2 0 1
样例输出
15

以下是一个解决该问题的C++代码示例：

#include 
#include 

int main() {
    int m, n;
    std::cin >> m >> n;

    std::vector<std::vector<int>> matrix(m, std::vector<int>(n));

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            std::cin >> matrix[i][j];
        }
    }

    int sum = 0;

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
                sum += matrix[i][j];
            }
        }
    }

    std::cout << sum << std::endl;

    return 0;
}

解析过程如下：

33. 首先，包含 头文件，这是用于输入和输出的标准库。

34. 包含 头文件，这是用于存储动态数组的标准库。

35. 在 main() 函数中，声明两个整数变量 m 和 n，用于存储矩阵的行数和列数。

36. 使用 std::cin 对象，通过输入流操作符 >> 将输入的行数 m 和列数 n 分别赋值给变量 m 和 n。

37. 声明一个二维整数向量 matrix，大小为 m 行 n 列，用于存储矩阵的元素。

38. 使用两个嵌套的 for 循环，循环变量 i 从0到 m-1，循环变量 j 从0到 n-1。

39. 在循环中，使用 std::cin 对象，通过输入流操作符 >> 依次将输入的整数赋值给矩阵 matrix 的每个元素。

40. 声明一个整数变量 sum，用于存储边缘元素之和，初始值为0。

41. 使用两个嵌套的 for 循环，循环变量 i 从0到 m-1，循环变量 j 从0到 n-1。

42. 在循环中，使用条件判断语句判断当前元素是否位于矩阵的边缘，即判断 i 是否为0或 m-1，以及判断 j 是否为0或 n-1。

43. 如果当前元素位于矩阵的边缘，则将其值累加到 sum 中。

44. 使用 std::cout 对象和输出流操作符 <<，输出变量 sum 的值。

45. 在输出后，使用 std::endl 输出一个换行符，使输出结果换行。

46. return 0; 表示程序正常结束。

47. 在运行程序时，按照题目要求输入矩阵的行数 m、列数 n，以及矩阵的元素。

48. 程序将计算矩阵的边缘元素之和，并输出结果。

例如，对于样例输入 3 3、3 4 1、3 7 1 和 2 0 1，程序将计算矩阵边缘元素之和为 15，然后输出结果为 15。

第4题：奇数单增序列

给定一个长度为N（不大于500）的正整数序列，请将其中的所有奇数取出，并按升序输出。
时间限制：1000
内存限制：65536
输入
共2行： 第1行为 N； 第2行为 N 个正整数，其间用空格间隔。
输出
增序输出的奇数序列，数据之间以逗号间隔。数据保证至少有一个奇数。
样例输入
10
1 3 2 6 5 4 9 8 7 10
样例输出
1,3,5,7,9

以下是一个解决该问题的C++代码示例：

#include 
#include 
#include 

int main() {
    int N;
    std::cin >> N;

    std::vector<int> numbers(N);

    for (int i = 0; i < N; i++) {
        std::cin >> numbers[i];
    }

    std::vector<int> oddNumbers;

    for (int i = 0; i < N; i++) {
        if (numbers[i] % 2 != 0) {
            oddNumbers.push_back(numbers[i]);
        }
    }

    std::sort(oddNumbers.begin(), oddNumbers.end());

    for (int i = 0; i < oddNumbers.size(); i++) {
        std::cout << oddNumbers[i];
        if (i != oddNumbers.size() - 1) {
            std::cout << ",";
        }
    }

    std::cout << std::endl;

    return 0;
}

解析过程如下：

49. 首先，包含 头文件，这是用于输入和输出的标准库。

50. 包含 头文件，这是用于存储动态数组的标准库。

51. 包含 头文件，这是用于算法操作的标准库。

52. 在 main() 函数中，声明一个整数变量 N，用于存储序列的长度。

53. 使用 std::cin 对象，通过输入流操作符 >> 将输入的长度 N 赋值给变量 N。

54. 声明一个整数向量 numbers，大小为 N，用于存储正整数序列的元素。

55. 使用一个 for 循环，循环变量 i 从0到 N-1。

56. 在循环中，使用 std::cin 对象，通过输入流操作符 >> 依次将输入的整数赋值给向量 numbers 的每个元素。

57. 声明一个整数向量 oddNumbers，用于存储选取出的奇数。

58. 使用一个 for 循环，循环变量 i 从0到 N-1。

59. 在循环中，使用条件判断语句判断当前元素是否为奇数，即判断 numbers[i] 是否为奇数。

60. 如果当前元素为奇数，则将其添加到向量 oddNumbers 中。

61. 使用 std::sort() 函数对向量 oddNumbers 进行升序排序。

62. 使用一个 for 循环，循环变量 i 从0到 oddNumbers 的大小减1。

63. 在循环中，使用 std::cout 对象和输出流操作符 <<，依次输出 oddNumbers[i] 的值。

64. 在每个输出之后，使用条件判断语句判断是否为最后一个元素，如果不是，则输出逗号 ,。

65. 在输出循环结束后，使用 std::endl 输出一个换行符，使输出结果换行。

66. return 0; 表示程序正常结束。

67. 在运行程序时，按照题目要求输入序列的长度 N，以及序列的元素。

68. 程序将从输入序列中选取出奇数，并按升序输出。

例如，对于样例输入 10、1 3 2 6 5 4 9 8 7 10，程序将选取出奇数 1, 3, 5, 7, 9 并按升序排序，然后输出结果为 1,3,5,7,9。

第5题：实数加法

求两个实数相加的和。
题目中输入输出里出现的浮点数都有如下的形式： P1P2…Pi.Q1Q2…Qj。对于整数部分，P1P2…Pi是一个非负整数且当整数部分不为0时，P1不等于0；对于小数部分，Qj不等于0。
时间限制：1000
内存限制：65536
输入
2行，每行是一个加数。每个加数的长度不超过100。
输出
一行，即相应的和。输出保证一定是一个小数部分不为0的实数。
样例输入
0.111111111111111111111111111111
0.111111111111111111111111111111
样例输出
0.222222222222222222222222222222

以下是一个解决该问题的C++代码示例：

#include 
#include 

std::string addRealNumbers(const std::string& num1, const std::string& num2) {
    std::string result;
    int carry = 0;
    int i = num1.size() - 1;
    int j = num2.size() - 1;

    while (i >= 0 || j >= 0 || carry > 0) {
        int digit1 = i >= 0 ? num1[i] - '0' : 0;
        int digit2 = j >= 0 ? num2[j] - '0' : 0;
        int sum = digit1 + digit2 + carry;
        carry = sum / 10;
        int digit = sum % 10;
        result = std::to_string(digit) + result;
        i--;
        j--;
    }

    return result;
}

int main() {
    std::string num1, num2;
    std::cin >> num1 >> num2;

    std::string sum = addRealNumbers(num1, num2);

    std::cout << sum << std::endl;

    return 0;
}

解析过程如下：

69. 首先，包含 头文件，这是用于输入和输出的标准库。

70. 包含 头文件，这是用于字符串操作的标准库。

71. 声明一个函数 addRealNumbers()，用于实现实数相加的逻辑。该函数接受两个字符串类型的参数 num1 和 num2，分别表示两个加数。

72. 在 addRealNumbers() 函数中，声明一个字符串变量 result，用于存储相加的结果。

73. 声明一个整数变量 carry，用于记录进位。

74. 声明两个整数变量 i 和 j，分别初始化为 num1 和 num2 的最后一个字符的索引。

75. 使用一个 while 循环，循环条件是 i 大于等于0 或 j 大于等于0 或 carry 大于0。

76. 在循环中，使用条件判断语句判断当前索引是否有效，如果有效，则将对应位置的字符转换为整数，否则将其设置为0。

77. 计算两个数字和进位的和，并将和除以10得到进位和当前位的数值。

78. 将当前位的数值转换为字符，并将其拼接到 result 的前面。

79. 更新索引 i 和 j，分别减1。

80. 返回 result，即相加的结果。

81. 在 main() 函数中，声明两个字符串变量 num1 和 num2，用于存储输入的两个加数。

82. 使用 std::cin 对象，通过输入流操作符 >> 将输入的两个加数赋值给变量 num1 和 num2。

83. 调用 addRealNumbers() 函数，传入 num1 和 num2，并将返回的结果赋值给变量 sum。

84. 使用 std::cout 对象和输出流操作符 <<，输出变量 sum 的值。

85. 在输出后，使用 std::endl 输出一个换行符，使输出结果换行。

86. return 0; 表示程序正常结束。

87. 在运行程序时，按照题目要求输入两个实数加数。

88. 程序将计算两个实数相加的和，并输出结果。

例如，对于样例输入 0.111111111111111111111111111111 和 0.111111111111111111111111111111，程序将计算它们的和为 0.222222222222222222222222222222，然后输出结果为 0.222222222222222222222222222222。