明明的随机数

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
    let lineNum = await readline();
    let arr = [];

    while(lineNum>0){
        let num = await readline();
        arr.push(num);
        lineNum--;
    }

    arr = Array.from(new Set(arr))
    arr.sort((a,b)=>a-b)
    arr.forEach(it=>{
        console.log(it)   
    })
 
    while(line = await readline()){
        let tokens = line.split(' ');
        let a = parseInt(tokens[0]);
        let b = parseInt(tokens[1]);
        console.log(a + b);
    }
}()

let readline = require("readline");
let r = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
// 手写一个堆
class Heap {
  constructor() {
    this.data = [];
    this.cnt = 0;
  }
// 指定大顶堆 的比较方式
  compare(a, b) {
    return this.data[a] > this.data[b];
  }
  swap(a, b) {
    let tmp = this.data[a];
    this.data[a] = this.data[b];
    this.data[b] = tmp;
  }
// 向上调整
  push(x) {
    let ind = this.cnt;
    this.data[this.cnt++] = x;
    while (ind && this.compare(ind - 1 >> 1, ind)) {
      this.swap(ind - 1 >> 1, ind);
      ind = (ind - 1) >> 1;
    }
  }
// 向下调整
  pop() {
      let top = this.data[0]
      this.data[0] = this.data.pop()
      this.cnt--
      let n = this.cnt-1,ind = 0,tmp = ind
      while(ind*2+1<=n){
          if(this.compare(ind,ind*2+1)) tmp = ind*2+1
          if(ind*2+2<=n && this.compare(tmp,ind*2+2)) tmp = ind*2+2
          if(ind==tmp) break
          this.swap(ind,tmp)
          ind = tmp
      }
      return top
  }
    size(){
        return this.cnt
    }
}
let arr = [];
r.on("line", (line) => {
  arr.push(Number(line));
  if (arr.length > arr[0]) {
    let h = new Heap()
    let ret = []
    for(let i=1;i<arr.length;i++) h.push(arr[i])
    while(h.size()) ret.push(h.pop())
    let m={}
    for(let x of ret){
        if(x in m) continue
        m[x] = 1
        console.log(x)
    }
    
    
  }
});

const readline = require('readline')
var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
var result = [] 
var arr = []
var lineNum = 0
var num = 0
rl.on('line', (line) => {
    var flag = true
    //     此时重置
    if (num == lineNum) {
        num = 0
        lineNum = parseInt(line)
        if(arr.length > 0){
            result.push(arr)
            arr = []
        }
        flag = false
    }
    //     此时将数据push进数组
    if ((num < lineNum) && flag) {
        num++
        if (arr.indexOf(line) < 0) {
            arr.push(line)
        }
    }
})
rl.on('close', () => {
    result.push(arr)
    result.forEach((res)=>{
        res.sort(sortNumber)
        res.forEach((val) => {
            console.log(parseInt(val))
        })
    })
})
function sortNumber(a, b) {
    return a - b
}

const readline = require('readline')
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})
var inputArr = []
rl.on('line', function (input) {
    inputArr.push(input)
    var len = +inputArr[0]
    if (inputArr.length === len + 1) {
        var part = inputArr.slice(1, inputArr.length + 1)
        // 去重
        var res = part.reduce( (pre, cur) => {
            if (!pre.includes(cur)) {
                pre.push(cur)
            }
            return pre
        }, [])
        // 升序，换行输出
        var result = res.sort( (a,b) => a - b).join('\n')
        console.log(result)
        // 清空上一个列子内容
        inputArr = []
        res = []
    }
});

let line = readline()

while(line) {
    let arr = [];
    while(line-- > 0) {
        arr.push(parseInt(readline()))
    }
    
    let set = new Set(arr);
    arr = Array.from(set).sort((a,b) => a-b);
    
    arr.forEach(item => console.log(item))
    
    line = readline();
}

var readline = require('readline')
var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
var inputY = 0
let params = []
let object = {}

rl.on('line', (line) => {
    if(inputY == 0){
        inputY = parseInt(line)
    }else{
        params.push(line)
        if(params.length == inputY) {
            let list_1 = Array.from(new Set(params))
            let list_2 = list_1.sort((a,b) => {return a - b})
            for(let a of list_2){
                console.log(a)
            }
            inputY = 0
            params = []
        }
    }
})

while(len = parseInt(readline(), 10)) {
    const buffer = Array(len).fill(0).map(() => parseInt(readline(), 10));
    console.log([...new Set(buffer.sort((a, b) => a - b))].join('\n'))
}

while(line=readline()){
    var num=parseInt(line)
    var arr=[]
    while(num-->0){
        arr.push(parseInt(readline()))
    }
    var set=new Set(arr)
    arr=Array.from(set).sort((a,b)=>a-b)
     for(var i=0;i<arr.length;i++){
         console.log(arr[i])
     }
}

// 自测没问题，保存并提交就出问题了，牛客你为什么这么烂！！！！
const listNum = [];
var data = '';
var size = 0;
while(data = readline()){
  if (size === 0) {
    size = data
  } else {
    size--;
    listNum.push(data);
  }
}

const sortList = listNum.sort((a, b) => a - b);

console.log(sortList
  .filter((item, index) => item !== sortList[index + 1])
  .join('\n'))
// 自测没问题，保存并提交就出问题了，牛客你为什么这么烂！！！！

const readline = require("readline");

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

let flag = true;
let datas = new Array();
let len = 0;
rl.on("line", function (line) {
    if (flag === true) {
        flag = false;
        datas = new Array();
        len = parseInt(line);
    } else {
        let d = parseInt(line);
        datas.push(d);
        if (datas.length === len) {
            datas = Array.from(new Set(datas));
            console.log(datas.sort((a, b) => a -b).join("\n"))
            flag = true;
        }
    }
})