（注：本文是对【JavaScript Node 】 ACM模式，常见输入输出练习相关内容的介绍！！！）
牛客竞赛_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJ
一、ACM模式下的编辑页面
二、ACM模式下，固定代码解析 【JavaScript Node】
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;void (async function () {// Write your code here})();const rl = require("readline").createInterface({ input: process.stdin });
- 这行代码创建了一个读取标准输入的 readline 接口。
require("readline")导入了 Node.js 的readline模块，createInterface方法创建了一个新的 readline 接口，input: process.stdin表示从标准输入（通常是用户输入）读取数据。
var iter = rl[Symbol.asyncIterator]();
- 这行代码获取了 readline 接口的异步迭代器。
Symbol.asyncIterator是一个内置的符号，表示异步迭代器的方法。iter是一个异步迭代器对象，可以用来逐行读取输入。
const readline = async () => (await iter.next()).value;
- 这行代码定义了一个异步函数
readline，该函数每次调用时都会返回下一行输入的值。await iter.next()获取到一个包含value和done属性的对象，value是当前行的输入内容，done表示是否已经读取到输入的末尾。
void (async function () {// Write your code here})();- 这行代码定义了一个立即执行的异步函数。
void关键字确保这个函数不会返回任何值。async function定义了一个异步函数，可以使用await关键字来等待异步操作完成。
三、编程题练习及代码解析
A+B(1)
1. 题目信息
| 输入描述： 输入包括两个正整数a,b(1 <= a, b <= 1000),输入数据包括多组。 |
| 输出描述： 输出a+b的结果 |
| 示例1 输入例子： 1 5 10 20 输出例子： 6 30 |
2. 答案及代码解析
代码解析：
while (true) {let line = await readline();if (!line) break; // 如果没有输入数据，退出循环let [a, b] = line.split(" ").map(Number);if (a < 1 || a > 1000 || b < 1 || b > 1000) {console.error("输入数据不在1到1000范围内");continue;}console.log(a + b);} while (true) {
- 这行代码开始一个无限循环，用于持续读取输入，直到没有更多输入为止。
let line = await readline();
- 这行代码调用
readline函数，异步读取一行输入并将其赋值给line变量。
if (!line) break; // 如果没有输入数据，退出循环
- 这行代码检查
line是否为空。如果没有读取到任何输入数据（即输入结束），则退出循环。
let [a, b] = line.split(' ').map(Number);
- 这行代码将当前行的输入按空格分割成两个字符串，然后使用
map(Number)将这两个字符串转换为数字，并将它们分别赋值给a和b。
if (a < 1 || a > 1000 || b < 1 || b > 1000) {
- 这行代码检查
a和b是否在 1 到 1000 的范围内。如果任何一个数不在该范围内，则执行下面的代码块。
console.error("输入数据不在1到1000范围内");
- 这行代码输出错误信息，提示输入数据不在 1 到 1000 的范围内。
continue;
- 这行代码跳过当前循环的剩余部分，继续下一次循环。
console.log(a + b);
- 这行代码计算
a和b的和，并将结果输出到控制台。
}
}();
- 这两行代码结束了
while循环和立即执行的异步函数。
拓展：
let [a, b] = line.split(' ').map(Number);
这行代码是 JavaScript 代码，用于从一个字符串中提取两个数字，并将它们分别赋值给变量 a 和 b。具体的解释如下：
-
line.split(' ')：line是一个字符串，假设它的内容是"10 20"。split(' ')方法会将字符串line按空格分割成一个数组。例如，"10 20".split(' ')会返回['10', '20']。
-
.map(Number)：map方法会遍历数组中的每个元素，并对每个元素应用一个函数。Number是一个函数，可以将字符串转换为数字。例如，Number('10')会返回10。- 因此，
['10', '20'].map(Number)会返回[10, 20]。
-
let [a, b] = ...：- 这是一个解构赋值的语法。它将数组中的第一个元素赋值给
a，第二个元素赋值给b。 - 例如，
let [a, b] = [10, 20]会使a等于10，b等于20。
- 这是一个解构赋值的语法。它将数组中的第一个元素赋值给
综上所述，这行代码的作用是从一个包含两个数字的字符串中提取这两个数字，并将它们分别赋值给变量 a 和 b。例如：
let line = "10 20";
let [a, b] = line.split(' ').map(Number);
console.log(a); // 输出: 10
console.log(b); // 输出: 20A+B(2)
1. 题目信息
| 输入描述： 输入第一行包括一个数据组数t(1 <= t <= 100) 接下来每行包括两个正整数a,b(1 <= a, b <= 1000) |
| 输出描述： 输出a+b的结果 |
| 示例1 输入例子： 2 1 5 10 20 输出例子： 6 30 |
2. 答案及代码解析
代码解析：
const t = parseInt(await readline()); // 读取数据组数
- 这行代码首先调用
readline()函数异步读取一行输入，并等待该异步操作完成。await readline()返回的是当前行的输入内容，通常是一个字符串。 parseInt()函数将读取到的字符串转换为一个整数，并将其赋值给变量t。t表示输入数据的组数。
for (let i = 0; i < t; i++) {
- 这行代码开始一个
for循环，循环变量i从 0 开始，直到i小于t为止。t是之前读取到的数据组数。每次循环处理一组数据。
const line = await readline(); // 读取每一行
- 这行代码在每次循环中调用
readline()函数异步读取一行输入，并等待该异步操作完成。await readline()返回的是当前行的输入内容，并将其赋值给变量line。
const [a, b] = line.split(" ").map(Number); // 分割为两个数并转换为数字
- 这行代码将
line字符串按空格分割成一个数组，然后使用map(Number)将数组中的每个元素转换为数字。[a, b]使用解构赋值语法将数组中的两个数字分别赋值给变量a和b。
console.log(a + b); // 输出其和
- 这行代码计算
a和b的和，并将结果输出到控制台。
完整代码解析：
const t = parseInt(await readline()); // 读取数据组数
for (let i = 0; i < t; i++) {const line = await readline(); // 读取每一行const [a, b] = line.split(" ").map(Number); // 分割为两个数并转换为数字console.log(a + b); // 输出其和
}
- 读取数据组数：
const t = parseInt(await readline());读取第一行输入并解析为整数，表示数据组数。 - 循环处理每组数据：
for (let i = 0; i < t; i++)开始一个循环，处理t组数据。 - 读取每一行：
const line = await readline();读取当前行的输入内容。 - 分割和转换：
const [a, b] = line.split(" ").map(Number);将当前行的输入按空格分割成两个字符串，并将它们转换为数字。 - 输出结果：
console.log(a + b);计算a和b的和，并将结果输出到控制台。
A+B(3)
1. 题目信息
| 输入描述： 输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入 |
| 输出描述： 输出a+b的结果 |
| 示例1 输入例子： 1 5 10 20 0 0 输出例子： 6 30 |
2. 答案及代码解析
代码解析：
while (true) {
while (true): 这是一个无限循环，意味着它的执行将一直持续下去，除非在循环体内遇到break语句来终止循环。
const line = await readline();
const line = await readline();: 这段代码使用readline模块（假设已经导入）来异步读取用户的输入。await关键字用于等待异步操作的完成，确保在读取完一行输入后才继续执行后续代码。读取到的输入存储在line变量中。
const [a, b] = line.split(' ').map(Number);
const [a, b] = line.split(' ').map(Number);:line.split(' '): 将读取到的line字符串按空格分割成一个数组。例如，如果line是"3 4"，那么分割后得到["3", "4"]。.map(Number): 将分割后的数组中的每个元素转换为数字类型。例如，["3", "4"]将变为[3, 4]。const [a, b] = ...: 使用解构赋值将数组中的两个元素分别赋值给变量a和b。
if (a === 0 && b === 0) {break;
}
if (a === 0 && b === 0) { break; }:- 这是一个条件判断语句，检查
a和b是否都等于 0。 - 如果条件成立（即
a和b都等于 0），执行break语句，这将立即终止while循环。 - 这个条件通常用于表示输入的结束，即当用户输入
0 0时，程序将停止运行。
- 这是一个条件判断语句，检查
console.log(a + b);
console.log(a + b);:- 如果上述条件不满足（即
a和b不都等于 0），则执行这行代码。 - 它将变量
a和b相加，并将结果输出到控制台。
- 如果上述条件不满足（即
A+B(4)
1. 题目信息
| 输入描述： 输入数据包括多组。 每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。 接下来n个正整数,即需要求和的每个正整数。 |
| 输出描述： 每组数据输出求和的结果 |
| 示例1 输入例子： 4 1 2 3 4 5 1 2 3 4 5 0 输出例子： 10 15 |
2. 答案及代码解析
代码解析：
while (true) {
- 这是一个无限循环，意味着除非通过某种方式跳出循环，否则程序会一直执行循环体中的代码。
// 读取一行输入const line = await readline();
readline()是一个异步函数，用于从标准输入中读取一行数据。await关键字确保读取操作完成后再继续执行下一行代码。line变量将存储读取到的这一行字符串。
const nums = line.split(' ').map(Number); // 将输入的字符串分割为数组并转换为数字
line.split(' ')将读取到的字符串按照空格分割成一个数组。例如，输入字符串"1 2 3 4"会被分割成数组["1", "2", "3", "4"]。.map(Number)将数组中的每个字符串元素转换为数字类型。结果是一个包含数字的数组，例如[1, 2, 3, 4]。
const n = nums[0]; // 获取当前行的第一个数字
nums[0]是数组的第一个元素，这里将其赋值给变量n，表示当前行的第一个数字。
if (n === 0) break; // 如果 n 为 0，结束输入
- 这里进行了一个判断，如果
n等于0，则执行break语句，跳出while循环，结束程序的输入阶段。
// 计算从 nums[1] 开始的数组之和const sum = nums.slice(1, n + 1).reduce((acc, curr) => acc + curr, 0);
nums.slice(1, n + 1)从数组的第二个元素（索引为1）开始截取到索引为n的元素，包含n个元素。例如，如果n是4，则截取[2, 3, 4, 5]（假设数组是[1, 2, 3, 4, 5]）。.reduce((acc, curr) => acc + curr, 0)对截取的数组进行累加操作，acc是累加器，curr是当前元素，初始值为0。结果是这些数字的总和。
console.log(sum); // 输出当前组的和
- 最后，使用
console.log(sum)输出当前组的数字之和。
A+B(5)
1. 题目信息
| 输入描述： 输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。 接下来t行, 每行一组数据。 每行的第一个整数为整数的个数n(1 <= n <= 100)。 接下来n个正整数, 即需要求和的每个正整数。 |
| 输出描述： 每组数据输出求和的结果 |
| 示例1 输入例子： 2 4 1 2 3 4 5 1 2 3 4 5 输出例子： 10 15 |
2. 答案及代码解析
代码解析：
// 读取第一行的 t，表示数据组数
const t = parseInt(await readline());
- 该行注释说明
t是数据组的数量。 readline()异步读取口输入的第一行数据，使用await确保读取完成后继续执行。parseInt()将读取到的字符串转换为一个整数，t存储数据组的数量。
// 处理 t 组数据
for (let i = 0; i < t; i++) {
- 这是一个
for循环，循环t次，每次处理一组数据。其中i是循环计数器，表示当前组的索引。
// 读取每组数据的第一行，第一个整数 n 表示整数的个数const line = (await readline()).trim().split(" ");
- 该行注释说明将读取每组数据的第一行，其中包含一个整数
n，表示接下来的整数个数。 - 在这行代码中，
readline()读取当前组的输入行，使用trim()去除首尾空格后，使用split(" ")将字符串按空格分割成数组。line变量将存储这个数组，包含一个或多个字符串元素。
const n = parseInt(line[0]);
line[0]是从数组中提取的第一个元素，代表当前组中整数的个数，将其转换为整数并赋值给变量n。
// 计算整数的和let sum = 0;
- 这行注释说明要计算当前组中的整数和。
let sum = 0;初始化一个变量sum，用于存储整数的总和，初始值设为0。
for (let j = 1; j <= n; j++) {
- 这是一个嵌套的
for循环，从1开始到n（包含n），j是循环计数器，用于遍历当前行中表示整数的部分。
sum += parseInt(line[j]);
line[j]提取当前整数（索引从1开始），使用parseInt()转换为整数，并累加到sum中。
// 输出求和结果console.log(sum);
- 最后，使用
console.log(sum)输出当前组整数的和。
A+B(6)
1. 题目信息
| 输入描述： 输入数据有多组, 每行表示一组输入数据。 每行的第一个整数为整数的个数n(1 <= n <= 100)。 接下来n个正整数, 即需要求和的每个正整数。 |
| 输出描述： 每组数据输出求和的结果 |
| 示例1 输入例子： 4 1 2 3 4 5 1 2 3 4 5 输出例子： 10 15 |
2. 答案及代码解析
代码解析：
while (true) {
- 这是一个无限循环，意味着除非通过某种方式跳出循环，否则程序会一直执行循环体中的代码。
const input = await readline();
readline()是一个异步函数，用于从标准输入中读取一行数据。await关键字确保读取操作完成后再继续执行下一行代码。input变量将存储读取到的这一行字符串。
if (!input) break; // 输入结束
- 这里进行了一个判断，如果
input为空（即没有更多输入），则执行break语句，跳出while循环，结束程序。
const parts = input.split(' ').map(Number);
input.split(' ')将读取到的字符串按照空格分割成一个数组。例如，输入字符串"3 1 2 3"会被分割成数组["3", "1", "2", "3"]。.map(Number)将数组中的每个字符串元素转换为数字类型。结果是一个包含数字的数组，例如[3, 1, 2, 3]。parts变量存储这个数组。
const n = parts[0];
parts[0]是数组的第一个元素，表示当前行中整数的个数。将其赋值给变量n。
const numbers = parts.slice(1);
parts.slice(1)从数组的第二个元素（索引为1）开始截取到数组的末尾，结果是一个包含n个整数的数组。numbers变量存储这个数组。
const sum = numbers.reduce((acc, num) => acc + num, 0);
numbers.reduce((acc, num) => acc + num, 0)对numbers数组中的元素进行累加操作。acc是累加器，num是当前元素，初始值为0。结果是这些数字的总和。sum变量存储这个总和。
console.log(sum);
- 最后，使用
console.log(sum)输出当前行中n个整数的和。
A+B(7)
1. 题目信息
| 输入描述： 输入数据有多组, 每行表示一组输入数据。每行不定有n个整数，空格隔开。(1 <= n <= 100)。 |
| 输出描述： 每组数据输出求和的结果 |
| 示例1 输入例子： 1 2 3 4 5 0 0 0 0 0 输出例子： 6 9 0 |
2. 答案及代码解析
代码解析：
let line;
- 声明一个变量
line，该变量将用于存储每次从输入中读取的行。
while ((line = await readline()) !== undefined) {
- 这是一个
while循环，条件是从输入中读取的行line不等于undefined。 await readline()是一个异步操作，读取一行输入数据。如果没有更多可读的输入，它将返回undefined。因此，该条件有效地控制了循环的结束。- 将读取到的输入行直接赋值给变量
line。
// 分割输入行，转换为数字并求和const sum = line.split(' ').map(Number).reduce((acc, cur) => acc + cur, 0);
- 该行注释说明了接下来的操作。
line.split(' ')将读取到的字符串按照空格分割成一个数组。例如，如果输入为"1 2 3"，则结果为["1", "2", "3"]。.map(Number)将数组中的字符串元素转换为数字类型，得到一个数字数组。例如，["1", "2", "3"]会变为[1, 2, 3]。.reduce((acc, cur) => acc + cur, 0)对转换后的数字数组进行累加操作。这里的acc是累加器，cur是当前元素，初始值为0。最终，sum将存储这些数字的总和。
console.log(sum); // 输出每行的和
- 使用
console.log(sum)输出当前行中所有数字的和。注释说明了这一行的意图，即输出求和结果。
总结
这段代码的整体流程是：
- 声明一个变量
line用于存储每行输入。 - 在
while循环中异步读取输入，直到没有更多输入 (undefined)。 - 对每行输入进行处理：
- 将字符串按空格分割为数组。
- 将数组中的元素转换为数字。
- 计算这些数字的和，并将结果存储在
sum中。
- 输出每行的和。
字符串排序(1)
1. 题目信息
| 输入描述： 输入有两行，第一行n第二行是n个字符串，字符串之间用空格隔开 |
| 输出描述： 输出一行排序后的字符串，空格隔开，无结尾空格 |
| 示例1 输入例子： 5 c d a bb e 输出例子： a bb c d e |
2. 答案及代码解析
代码解析：
// 读取第一行输入，获取n
const n = parseInt(await readline());
- 该行注释说明将从输入中读取第一行数据，并获取整数
n。 await readline()异步读取第一行输入数据，使用parseInt()将其转换为整数，存储在变量n中。
// 读取第二行输入，获取n个字符串
const strings = (await readline()).split(' ');
- 这行注释说明将从输入中读取第二行数据，并获取
n个字符串。 await readline()异步读取第二行输入数据。split(' ')将读取到的字符串按空格分割成一个数组，例如，如果输入是"apple banana cherry"，则结果为["apple", "banana", "cherry"]。strings变量存储这个数组。
// 对字符串进行排序
strings.sort();
- 这行注释说明将对接收到的字符串数组进行排序。
strings.sort()使用默认的字符串排序规则对数组中的字符串进行排序。默认情况下，sort()会按字典顺序（ASCII 码顺序）对字符串进行排序。
// 输出排序后的字符串，用空格隔开，无结尾空格
console.log(strings.join(' '));
- 该行注释说明了接下来的操作：输出排序后的字符串，字符串之间用空格隔开，但不包含结尾空格。
strings.join(' ')将排序后的字符串数组用空格连接成一个字符串。例如，如果排序后的数组是["apple", "banana", "cherry"]，则结果是"apple banana cherry"。console.log(strings.join(' '))输出连接后的字符串，符合要求，没有结尾空格。
总结
这段代码的整体流程是：
- 读取第一行输入，获取整数
n。 - 读取第二行输入，获取
n个字符串，并存储在一个数组中。 - 对数组中的字符串进行排序。
- 输出排序后的字符串，字符串之间用空格隔开，但不包含结尾空格。
字符串排序(2)
1. 题目信息
| 输入描述： 多个测试用例，每个测试用例一行。每行通过空格隔开，有n个字符，n＜100 |
| 输出描述： 对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开 |
| 示例1 输入例子： a c bb f dddd nowcoder 输出例子： a bb c dddd f nowcoder |
2. 答案及代码解析
代码解析：
while (true) {
- 这是一个无限循环，意味着程序会不断重复执行循环体中的代码，直到遇到
break语句跳出循环。
const line = await readline();
await readline()是一个异步操作，用于从标准输入中读取一行数据。程序会等待这条输入返回后再继续执行后面的代码。line变量将存储读取到的这行字符串。
if (!line) break; // 如果没有输入则退出循环
- 这里进行判断，如果
line为空（即没有更多输入，可能是用户按下 Ctrl+D 或者输入结束的情况），则执行break语句，跳出循环，结束程序。
const words = line.split(' ').sort(); // 将输入按空格分割并排序
line.split(' ')将读取到的字符串按空格分割成一个数组。例如，如果输入是"banana apple cherry"，则结果为["banana", "apple", "cherry"]。.sort()对分割后的字符串数组进行排序，默认按字母顺序进行排序，结果可能是["apple", "banana", "cherry"]。排序后的数组存储在变量words中。
console.log(words.join(' ')); // 输出排序后的字符串
words.join(' ')将排序后的字符串数组用空格连接回一个字符串。例如，数组["apple", "banana", "cherry"]将成为字符串"apple banana cherry"。console.log(words.join(' '))输出这个连接后的字符串。
字符串排序(3)
1. 题目信息
| 输入描述： 多个测试用例，每个测试用例一行。 每行通过,隔开，有n个字符，n＜100 |
| 输出描述： 对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格 |
| 示例1 输入例子： a,c,bb f,dddd nowcoder 输出例子： a,bb,c dddd,f nowcoder |
2. 答案及代码解析
代码解析：
let line;
- 声明一个变量
line，用于存储每次从输入中读取的行。
while ((line = await readline())) {
- 这是一个
while循环，条件是从输入中读取的行line不是undefined或者空值。 await readline()是一个异步操作，读取一行输入数据，赋值给line。如果没有更多输入行，它将返回undefined，循环结束。
// 将输入行按逗号','分割 let chars = line.split(',');
line.split(',')将读取到的字符串使用逗号分割成一个数组。例如，如果输入是"banana,apple,cherry"，则结果为["banana", "apple", "cherry"]，并将结果赋给变量chars。
// 对字符进行排序chars.sort();
chars.sort()对字符串数组进行排序，默认按字典顺序（ASCII 码顺序）进行排序。例如，["banana", "apple", "cherry"]会被排序为["apple", "banana", "cherry"]。
// 将排序后的字符用逗号','连接 let sortedLine = chars.join(',');
chars.join(',')将排序后的字符串数组使用逗号连接成一个新的字符串。例如，排序后的结果["apple", "banana", "cherry"]将变为字符串"apple,banana,cherry"，并赋值给变量sortedLine。
// 输出排序后的行console.log(sortedLine);
console.log(sortedLine)输出排序后的结果字符串。
总结
这段代码的整体流程是：
- 声明一个变量
line用于存储每行输入。 - 在
while循环中异步读取输入，直到没有更多输入。 - 将每行输入字符串按逗号分割为字符数组。
- 对字符数组进行排序。
- 将排序后的字符数组用逗号连接成字符串，并输出结果。
自测本地通过提交为0
1. 题目信息
| 输入描述： 输入有多组测试用例，每组空格隔开两个整数 |
| 输出描述： 对于每组数据输出一行两个整数的和 |
| 示例1 输入例子： 1 1 输出例子： 2 |
2. 答案及代码解析
代码解析：
for await (const line of iter) {
- 使用
for await...of循环，从异步迭代器iter中逐行读取数据。这个结构允许在处理每一行输入时异步等待输入完成。 const line用于存储当前读取的行，line是每次迭代时从iter迭代器获取的当前行的值。
// 分割输入的字符串，得到两个整数const [num1, num2] = line.split(' ').map(Number);
- 这行注释说明了接下来的操作，即将输入行分割并转换为两个整数。
line.split(' ')将当前行的字符串按空格分割成数组。例如，假设输入为"3 5"，则结果为["3", "5"]。.map(Number)将这个字符串数组的每个元素转换为数字类型，结果是[3, 5]。const [num1, num2]使用数组解构赋值将数组中的两个数分别赋值给num1和num2。
// 计算两个整数的和const sum = num1 + num2;
- 这行注释说明了下一步操作，即计算两个整数的和。
const sum = num1 + num2将num1和num2相加，结果存储在sum中。
// 输出结果console.log(sum);
- 这行注释解释了将要执行的代码，即输出结果。
console.log(sum)输出计算得到的和。
总结
这段代码整体执行流程如下：
- 使用
for await...of循环从异步迭代器iter中逐行读取数据。 - 对每一行输入，按空格分割并将其转换为两个整数。
- 计算这两个整数的和。
- 输出计算结果。