OJ （Online Judge）使用

 这是一种方式，我们还可使用另外一种方式：

process.stdin.resume();
process.stdin.setEncoding('ascii');

var input = "";
var input_array = "";

process.stdin.on('data', function (data) {
    input += data;
});

process.stdin.on('end', function () {
    
    input_array = input.split("
");
    var str = input_array[0];
    console.log(str.split(' ').reverse().join(' '));    
});

这种方式比之前的那种方式会更好一些！ 即data事件的时候，我们一直处于接受数据的时候，然后一旦触发了 end 事件，说明我们这次的输入结束。 然后呢， 得到的 input_array就是输入的所有行，我们直接使用就可以了。

其实，我们可以知道牛客网的方式应该是每次测试用例每次就调用函数。

说明： 后者为什么好呢？ 因为通过后者，我们可以准确地判断出来到底什么时候结束，而前者在某些情况下，我们是无法判断函数是何时结束的，如下所示：

如果我们不用后者这种方式，那么我们就没有办法确定一共有多少个case，就没法做这道题了。 

 最终ac的代码如下所示：

       process.stdin.resume();
       process.stdin.setEncoding('ascii');

       var input = "";
       var input_array = '';

       process.stdin.on('data', function (data) {
           input += data;
       });

       process.stdin.on('end', function () {
           // 目前的这个input_array就是输入的所有行，我们现在的目的就是如果把这两个case放在一个一个数组中。 
           input_array = input.split("
");
           var nLine = 0;

           var hhh = [];

           while(nLine < input_array.length){
               var line = input_array[nLine++].trim();
               // 这一句非常关键，有了这一句，因为有时候，这个没有处理好，可能输入就会出现问题。
               if(line === ''){
                   continue;
               }
               // 这种方式我们就可以把输入的所有行通过 hhh 这个数组来拿到了。

               hhh.push(line);    
           }
           
           var arr = [];
           
           for (var i = 0; i < hhh.length; i++) {
               // 当输入是一个数字的时候，就是M或者是N 下面的isNaN(Number(hhh[i]))的判断非常重要，通过这一句，我们就可以很轻松地来分类了 。
               if (!isNaN(Number(hhh[i]))) {
                   arr.push(hhh.slice(i + 1, i + Number(hhh[i]) + 1));
               } 
           }
           // 循环之后，得到的数组就是一个二维数组，一定是偶数个，比如arr数组的第一个元素就是['aaa', 'aaa', 'baa']， 那么arr的第二个元素就是 ['aa', 'ba']
           
           var result = [];
           
           // 创建一个用于最后输出的元素的数组，最终遍历输出即可。
           for (var j = 0; j < arr.length; j++) {
               if (j % 2 == 0) {
                   for (var k = 0; k < arr[j + 1].length; k++) {
                       var count = 0;
                       for (var m = 0; m < arr[j].length; m++) {
                           // 这里也很巧妙，就是对于一个字符串是否是另一个字符串的子串，我们可以通过 indexOf 的方式来解决，这样就不需要耗时的遍历的方法或者使用复杂的KMP算法了。 
                           if (arr[j][m].indexOf(arr[j + 1][k]) != (-1)) {
                               count++;
                           }
                       }
                       result.push(count);
                   }
               }
           }
           
           for (var n = 0; n < result.length; n++) {
               console.log(result[n]);
           }
       });

---

---

---

---

 

 

 

 

 

 

 

 

 

 

第一部分：

1. 360、完美世界等使用的编程环境（OJ系统）

http://oj.acmcoder.com/ExamNotice.html  对于OJ系统进行了说明。

http://oj.acmcoder.com/QA/ 常见问题

下面的代码输出的是a+b， line是用于输入的。

var line;
while(line = read_line()){
    line = line.split(' ');
    print(parseInt(line[0]) + parseInt(line[1]));
}

 

　　下面是一个成功运行的题目，如下：

　　注意的几个地方：

1.  read_line() 得到的是输入的字符串，如 "81 4"
2.  显然，通过read_line().split(" ")得到的是一个字符串数组（注意： split(" ")中有一个空格），所以如果我们希望使用数字，就应该Number转换一下
3.  print()就相当于console.log(somethin); 再加一个<br/>（换行）。
4.  最好使用上述固定的格式： 即在while循环内调用函数，在调用的函数里输出。
5.  对于本题而言，应当注意 toFixed() 是用在最后， 这才是最精确的。

　下面的是将输出使用空格分开，我最后的正确率是88%，不知道具体错在了哪里...

2.网易使用的编程环境（牛客网提供OJ系统）

https://www.nowcoder.com/discuss/276

https://www.nowcoder.com/test/question/0147cbd790724bc9ae0b779aaf7c5b50?pid=2811407&tid=7485771 和网易的题是类似的

var readline = require('readline');
const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
});
rl.on('line', function(line){
   var tokens = line.split(' ');
    console.log(parseInt(tokens[0]) + parseInt(tokens[1]));
});

第一句是指引入了readline文件，第二句是指设定rl的输入输出为标准输入输出。第三句的意思就是输入为line的函数，第四句的意思就是将输入以空格分为数组。 第五句就是使用console.log()输出。

 它的测试方法是，输入大量的数据进行测试，并不是说只要有一个成立就行，而是所有的情况都成立才可以。

对于单行输入，使用下面的方法：

即引入readline模块，然后使用createInterface创建接口，接着使用on监听line事件。 对于多行输入的，我们可以用一个数组接受多行，等到满足了长度，就执行主要的函数。

var readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on('line', function (line) {
    var str = line;
    var obj = {};
    
    for (var i = 0, len = str.length; i < len; i++) {
        if (!obj[str[i]]) {
            obj[str[i]] = 1;
        }
    }
    var count = 0;
    for (var key in obj) {
        count++
    }
    
    switch (count) {
        case 1:
            console.log(1);
            break;
        case 2: 
            console.log(2);
            break;
        default: 
            console.log(0);
            return;
          
    }
    
});

下面是一个多行输入的题目，题目如下：

解答过程如下：

var readline = require('readline');
var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

var inputArr = [];

rl.on('line', function (line) {
    inputArr.push(line.trim());
    if (inputArr.length == 2) {
        var number = parseInt(inputArr[0]);
        var arr = inputArr[1].split(' ');
        // 首先将数组由小到大进行排列，这样，d只可能是0或者正数。 
        arr.sort(function (a, b) {
            return a - b;
        });
        
        var diff = [];
        
        for (var i = 0, len = arr.length; i < len - 1; i++) {
            diff.push(arr[i + 1] - arr[i]);
        }
        
        var flag = true;
        for (var j = 0, jLen = diff.length; j < jLen - 1; j++) {
            if (diff[j + 1] !== diff[j]) {
                flag = false;
                break;
            }
        }
        
        if (flag) {
            console.log('Possible')
        } else {
            console.log('Impossible');
        }
    }
});

即在readline.on('line', function (line) {})函数中使用inputArr.length来判断是否等于输入的行数，等于的时候，再执行主要逻辑。

 看到了下面这种方式，其实也是蛮不错的：

   

 即处理好输入之后，调用一个函数，这样，我们在本地调试的时候，直接copy这个函数过去就可以了， 非常清楚明了。

3.牛客网上的剑指offer方法又略有不同：（OJ系统）

https://www.nowcoder.com/practice/4060ac7e3e404ad1a894ef3e17650423?tpId=13&tqId=11155&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

例： 这里实现的是将一个字符串中的空格使用%20替换。

function replaceSpace(str)
{
    // write code here

 　　  str = str.split(' ').join('%20');

      return str;

}
module.exports = {
    replaceSpace : replaceSpace
};

这里最后只要在函数内return 出希望返回的值即可。

第二部分： 答题需要的基本知识

 http://nodejs.cn/api/readline.html#readline_class_interface

一、nodejs中readline模块的使用

　　一般，我们在使用系统进行答题时，都是需要使用readline模块的，这个模块可以进行读取行，然后就可以由系统进行检测了。 

　　readline模块一般有一个interface类，这个类对应了一些事件和方法。readline还有一些其他的方法，但是最重要的还是interface类，下面我们简单的讲解、学习。

require('readline') 模块提供了一个接口，用于从可读流（如 process.stdin）读取数据，每次读取一行。 它可以通过以下方式使用：

const readline = require('readline')

例子，readline 模块的基本用法：

const readline = require('readline')

const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
})

rl.question('你认为nodejs怎么样？', (answer) => {
//对answer进行处理
console.log(`多谢你的反馈：${answer}`);

rl.close();
})

如下所示：

可以看到： 我们首先引入了readline模块，然后创建了接口类，接着，我们调用了接口的question方法，第一个参数是一个字符串，第二个是回调函数，参数就是在命令行中输入的，我们可以对之进行操作。

最后，我们必须使用rl.close()来关闭，否则，node程序不会自动关闭。 

Interface类

　　readline.Interface 类的实例是使用 readline.createInterface() 方法构造的。 每个实例都关联一个 input 可读流和一个 output 可写流。 output 流用于为到达的用户输入打印提示，且从 input 流读取。

'close' 事件

当以下之一发生时，触发 'close' 事件：

• rl.close() 方法被调用，且 readline.Interface 实例已撤回对 input 流和 output 流的控制；
• input 流接收到 'end' 事件；
• input 流接收到表示结束传输的 <ctrl>-D；
• input 流接收到表示 SIGINT 的 <ctrl>-C，且 readline.Interface 实例上没有注册 SIGINT 事件监听器。

监听器函数被调用时不传入任何参数。

当 'close' 事件被触发时，readline.Interface 实例应当被视为已结束。

'line' 事件

每当 input 流接收到接收行结束符（ 、  或  ）时触发 'line' 事件。 通常发生在用户按下 <Enter> 键或 <Return> 键。

监听器函数被调用时会带上一个包含接收的那一行输入的字符串。

rl.on('line', (input) => {
  console.log(`接收到：${input}`);
});

 即用户按下了回车时就会触发line事件，然后，我们就可以使用一个回调函数就收到输入。

'pause' 事件

当以下之一发生时触发 'pause' 事件：

• input 流被暂停。
• input 流不是暂停的，且接收到 SIGCONT 事件。（详见 SIGTSTP 事件和 SIGCONT 事件）

监听器函数被调用时不传入任何参数。

'resume' 事件

每当 input 流被恢复时触发 'resume' 事件。

监听器函数被调用时不传入任何参数。

例子：

rl.on('resume', () => {
  console.log('Readline 被恢复。');
});

'SIGCONT' 事件

当一个 Node.js 进程使用 <ctrl>-Z（也就是 SIGTSTP）移入后台之后再使用 fg(1p) 移回前台时，触发 'SIGCONT' 事件。

如果 input 流在 SIGTSTP 请求之前被暂停，则事件不会被触发。

监听器函数被调用时不传入任何参数。

例子：

rl.on('SIGCONT', () => {
  // `prompt` 会自动恢复流
  rl.prompt();
});

rl.close()

rl.close() 方法会关闭 readline.Interface 实例，且撤回对 input 和 output 流的控制。 但被调用时，'close' 事件会被触发。

rl.promp

rl.prompt() 方法会在 output 流中新的一行写入 readline.Interface 实例配置后的 prompt，用于为用户提供一个可供输入的新的位置。

当被调用时，如果 input 流已被暂停，则 rl.prompt() 会恢复 input 流。

如果 readline.Interface 被创建时 output 被设为 null 或 undefined，则提示不会被写入。

rl.pause()

rl.pause() 方法会暂停 input 流，且稍后需要时可被恢复。

调用 rl.pause() 不会立刻暂停其他事件（包括 'line'）被 readline.Interface 实例触发。

rl.question(query, callback)

新增于: v0.3.3

• query <string> 一个在提示符之前、要写入 output 的叙述或询问。
• callback <Function> 一个回调函数，它会被调用并带上用户响应 query 的输入。

rl.question() 方法通过写入到 output 来展示 query，并等待用户提供到 input 的输入，然后调用 callback 函数并传入提供的输入作为第一个参数。

rl.question('你最喜欢的食物是什么？ ', (answer) => {
console.log(`你最喜欢的食物是 ${answer}`);
});

 

rl.resume()

查看英文版 / 参与翻译

新增于: v0.3.4

如果 input 流已被暂停，则 rl.resume() 方法会恢复 input 流。

readline.createInterface(options)

• input <Readable> 要监听的可读流。该选项是必需的。
• output <Writable> 要写入逐行读取数据的可写流。

简单的命令行界面

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: '请输入> '
});

rl.prompt();

rl.on('line', (line) => {
  switch (line.trim()) {
    case 'hello':
      console.log('world!');
      break;
    default:
      console.log(`你输入的是：'${line.trim()}'`);
      break;
  }
  rl.prompt();
}).on('close', () => {
  console.log('再见!');
  process.exit(0);
});

例子：逐行地读取文件流

const readline = require('readline');
const fs = require('fs');

const rl = readline.createInterface({
  input: fs.createReadStream('sample.txt')
});

rl.on('line', (line) => {
  console.log(`文件的单行内容：${line}`);
});