第一行输入一个整数
代表数据表的记录数。
此后
行,第
行输入两个整数
代表数据表的第
条记录的索引和数值。
一共若干行(视输入数据变化),第
行输出两个整数,代表合并后数据表中第
条记录的索引和数值。
4 0 1 0 2 1 2 3 4
0 3 1 2 3 4
在这个样例中,第
条记录索引相同,合并数值为
。
2 0 1 0 1
0 2
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 map = new Map()
while (line = await readline()) {
const arr = line.split(' ')
if (arr.length === 2) {
const num = map.get(arr[0])
if (num) {
map.set(arr[0], Number(num) + Number(arr[1]))
} else {
map.set(arr[0], arr[1])
}
}
}
const keys = [...map.keys()]
keys.sort((a, b) => (a - b))
keys.forEach(key => {
console.log(`${key} ${map.get(key)}`)
})
}() const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
// mergeRecords函数接受一个异步迭代器和记录的数量
async function mergeRecords(n) {
// 创建一个对象来存储每个索引及其对应的值的总和
let data = {};
for (let i = 0; i < n; i++) {
// 使用迭代器异步读取输入
let line = await readline();
// 分割索引和值,并将它们转换为数字
let [index, value] = line.split(" ").map(Number);
// 将值添加到对应索引的总和中
if (data[index]) {
data[index] += value;
} else {
data[index] = value;
}
}
// 返回一个按索引升序排列的键值对数组
return Object.keys(data)
.sort((a, b) => a - b)
.map((index) => [parseInt(index), data[index]]);
}
void (async function () {
// 读取记录的数量
let n = parseInt(await readline());
// 调用mergeRecords函数并等待它完成
let result = await mergeRecords(n);
// 遍历结果并打印每个键值对
result.forEach(([index, value]) => {
console.log(index + " " + value);
});
})();
const readline = require('readline')
var rl = readline.createInterface({
input:process.stdin,
output:process.stdout
})
var length = 0
var arr = []
rl.on('line',(line)=>{
if(length == 0){
length = parseInt(line)
}else{
arr.push(line)
}
})
rl.on('close',()=>{
var res = []
arr.forEach((val,index)=>{
var item = val.split(' ')
if(res[parseInt(item[0])]){
res[parseInt(item[0])] = parseInt(res[parseInt(item[0])]) + parseInt(item[1])
}else{
res[parseInt(item[0])] = item[1]
}
})
res.forEach((val,index)=>{
if(val){
console.log(index + ' ' + val)
}
})
}) // 循环取出每一个键值个数
// 新建一个map { key: value, key:value },
// 判断map是否有这个key,有key的话,value相加,没有就塞进map中
// 最终结果 取出所有的key,对key进行排列, 按照key值从map中取出value输出
function sys() {
let map = new Map();
var line = [];
while(line=readline()) {
var arr = line.split(' ');
if (arr.length == 2) {
if (map.has(arr[0])) {
var val = map.get(arr[0]);
map.set(arr[0], Number(val) + Number(arr[1]));
} else {
map.set(arr[0], arr[1]);
}
}
}
var keysArr = [];
for (var s of map.keys()) {
arrKeys.push(s);
}
keysArr.sort((a,b) => {return a - b});
keysArr.map((item) => {
console.log(item + ' ' + map.get(item));
})
}
sys(); var readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
const obj = {}
rl.on('line', function(line){
var tokens = line.split(' ');
if(tokens[1]){
if(obj[tokens[0]]){
obj[tokens[0]] += Number(tokens[1])
} else {
obj[tokens[0]] = Number(tokens[1])
}
}
});
rl.on('close',()=>{
for (const [key, value] of Object.entries(obj)) {
console.log(`${key} ${value}`);
}
}) 应该是js最简洁的写法,简单易懂,用obj存储和计算还不需要排序,直接使用Object.entries输出完事
var num=parseInt( readline())
var map=new Map()
while(num-- >0){
var line=readline().split(' ').map(v=>+v)
var index=line[0]
var value=line[1]
if(map.get(index)){
map.set(index,map.get(index)+value)
}else{
map.set(index,value)
}
}
//转数组
var arrayObj=Array.from(map);
//排序
arrayObj.sort(function(a,b){return a[0]-b[0]})
arrayObj.forEach(item=>{
console.log( item[0],item[1]);
});
while(line = readline()){
var result = new Map();
for(let i = 0;i<parseInt(line);i++){
let lines = readline().split(' ')
if(result.has(lines[0])){
result.set(lines[0],parseInt(lines[1])+result.get(lines[0]))
}else{
result.set(lines[0],parseInt(lines[1]))
}
}
var resultlist = new Array();
result.forEach((value,key)=>{
resultlist.push(parseInt(key))
})
resultlist.sort((a,b)=>{return a-b})
resultlist.forEach((item)=>{
console.log(item+' '+result.get((item).toString()))
})
}