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

const inputs = [];

rl.on('line', (line) => {
    inputs.push(line);
}).on('close', () => {
    // 1. 处理原始inputs
    const valideOriginRecords = handleInputs(inputs);
    // 2. 取出 filename row
    const all_filename_row = handleOriginRecords(valideOriginRecords);
    // 3. 对取出的 filename row 进行 “相同”的处理, 这里就用 filename+row 做key 建立map
    const all_records_map = generatorRecordsMap(all_filename_row);
    // 4. 把map放进数组，取出最后有效的8条记录
    const final_8_records = handleValidateRecords(all_records_map);
    // 5. 输出
    print(final_8_records);
});

// 5. 输出
function print(records) {
    for(let i = 0; i < records.length; i++) {
        const { filename, row, count } = records[i];
        console.log(`${filename} ${row} ${count}`);
    }
}

// 4. 取出最后有效的8条记录
function handleValidateRecords(map) {
    let res = [];
    const temp = [];
    Object.keys(map).forEach(key => {
        temp.push(map[key]);
    })
    if(temp.length > 8) {
        res = temp.slice(temp.length - 8);
    } else {
        res = temp;
    }
    return res;
}

// 3. map
function generatorRecordsMap(all_filename_row) {
    let records_map = {};
    for(let i = 0; i < all_filename_row.length; i++) {
        const { filename, row } = all_filename_row[i];
        const key = filename + row;
        if(!Object.prototype.hasOwnProperty.call(records_map, key)) {
            records_map[key] = {
                filename,
                row,
                count: 1
            }
        } else {
            records_map[key].count += 1;
        }
    }
    return records_map;
}

// 2. 取出filename row
function handleOriginRecords(records) {
    let res = [];
    records.forEach(item => {
        const token = item.split(' ');
        const routers = token[0].slice(2).split("\\");
        let filename = routers[routers.length - 1];

        // 只记录文件的最后有效16个字符
        if(filename.length > 16) {
            filename = filename.slice(filename.length - 16);
        }

        const temp = {
            filename,
            row: token[1]
        }

        res.push(temp);
    })
    return res;
}

// 1. 去重
function handleInputs(inputs) {
    // 1. 去重
    const unique_inpust = [...new Set(inputs)];
    
    return unique_inpust;
}

这道题，难度在于理解题意，本身是个设计实现应用类题自身难度不大。

我自己是提交了两次，根据测试用例和评论区才大致明白题意。有两坑点：如何理解循环记录 、怎么理解“重复”与“相同”的区别

根据题目，提炼出题目要求

理解题意：

1、 记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是“相同”的错误记录。

2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；

3、 输入的文件可能带路径，记录文件名称不能带路径。也就是说，哪怕不同路径下的文件，如果它们的名字的后16个字符相同，也被视为相同的错误记录

4、循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准

上面是题目的要原要求，我们得出的规则如下：

1. 所有输入完全重复的，只以第一次为准 —— 去重
2. 匹配文件名和行号，文件名只记录最后16位以内有效字符 —— 字符匹配加处理
3. 文件名和行号完全匹配记作“相同”—— 计数
4. 循环记录，只输出最后8条 —— 输出

拿这个规则对应题目的测试用例比对，可以得到输出，那就按这个思路开干。

根据我们提炼出来的规则，就可以开始设计流程了：

所有完整输入去重 --> 截取文件名filename和行号row --> 计数这一步，采用Map， key = filename + row ， value = { filename, row, count } --> Map 按key 将value传入数组，截取最后8条有效记录。

至此，这道题就完成了。