OJ在线编程常见输入输出练习【JavaScript】

（注：本文是对【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。具体的解释如下：

1. line.split(' ')：

   • line 是一个字符串，假设它的内容是 "10 20"。
   • split(' ') 方法会将字符串 line 按空格分割成一个数组。例如，"10 20".split(' ') 会返回 ['10', '20']。

2. .map(Number)：

   • map 方法会遍历数组中的每个元素，并对每个元素应用一个函数。
   • Number 是一个函数，可以将字符串转换为数字。例如，Number('10') 会返回 10。
   • 因此，['10', '20'].map(Number) 会返回 [10, 20]。

3. 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); // 输出: 20

A+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); // 输出其和
}

1. 读取数据组数：const t = parseInt(await readline()); 读取第一行输入并解析为整数，表示数据组数。
2. 循环处理每组数据：for (let i = 0; i < t; i++) 开始一个循环，处理 t 组数据。
3. 读取每一行：const line = await readline(); 读取当前行的输入内容。
4. 分割和转换：const [a, b] = line.split(" ").map(Number); 将当前行的输入按空格分割成两个字符串，并将它们转换为数字。
5. 输出结果：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) 输出当前行中所有数字的和。注释说明了这一行的意图，即输出求和结果。

总结

这段代码的整体流程是：

1. 声明一个变量 line 用于存储每行输入。
2. 在 while 循环中异步读取输入，直到没有更多输入 (undefined)。
3. 对每行输入进行处理：
   • 将字符串按空格分割为数组。
   • 将数组中的元素转换为数字。
   • 计算这些数字的和，并将结果存储在 sum 中。
4. 输出每行的和。

     

字符串排序(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(' ')) 输出连接后的字符串，符合要求，没有结尾空格。

总结

这段代码的整体流程是：

1. 读取第一行输入，获取整数 n。
2. 读取第二行输入，获取 n 个字符串，并存储在一个数组中。
3. 对数组中的字符串进行排序。
4. 输出排序后的字符串，字符串之间用空格隔开，但不包含结尾空格。  

字符串排序(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) 输出排序后的结果字符串。

总结

这段代码的整体流程是：

1. 声明一个变量 line 用于存储每行输入。
2. 在 while 循环中异步读取输入，直到没有更多输入。
3. 将每行输入字符串按逗号分割为字符数组。
4. 对字符数组进行排序。
5. 将排序后的字符数组用逗号连接成字符串，并输出结果。

自测本地通过提交为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) 输出计算得到的和。

总结

这段代码整体执行流程如下：

1. 使用 for await...of 循环从异步迭代器 iter 中逐行读取数据。
2. 对每一行输入，按空格分割并将其转换为两个整数。
3. 计算这两个整数的和。
4. 输出计算结果。