records

一,寻找身高相近的小朋友

function compareHigh(arr,len,tall) {
    let map = new Map()
    for(let i = 0 ; i < len ; i++){
        const frequent = Math.abs(tall - arr[i])
        map.set(arr[i],frequent)
    }
    const list = [...map.keys()]
    list.sort(function(a,b) {
        if(map.get(a) == map.get(b)) {
            return a-b 
        } 
        else {
            return map.get(a) - map.get(b)
        }
    })
 
    return list
}
 
console.log(compareHigh())
 
//打印结果为：[
//   99, 101, 98, 102,
//   97, 103, 96, 104,
//   95, 105
// ]

二,火星文计算

let str = '7#6$5#12'
let test1 = /[0-9]+\$[0-9]+/
let test2 = /[0-9]+#[0-9]+/

while (str.indexOf('$')>-1){
    test('$')
}
while (str.indexOf('#')>-1){
    test('#')
}
console.log(str);

function test(type){
    let test = ''
    if(type==='$'){
        test = test1
    }else if (type==='#'){
        test = test2
    }
    str = str.replace(test,e=>{
        let x= Number(e.split(type)[0])
        let y= Number(e.split(type)[1])
        if(type==='$'){
            return 3*x+y+2
        }else if(type==='#'){
            return 2*x+3*y+4
        }else {
            return e
        }
    })
}

三,最长的指定瑕疵度的元音子串

        let n = 1
        let str = 'aabeebuu'

        let yuanyin = 'aeiouAEIOU'
        let len = str.length
        let list = [] // 连续元音辅音集合
        let yy = 0 // 连续元音个数
        let fy = 0 // 连续辅音个数

        for (let i = 0; i < len; i++) {
           const temp = String(str.charAt(i))
            if (yuanyin.includes(temp)) {
                if (fy !== 0) {
                    list.push(fy)
                    fy = 0
                }
                yy++
            } else {
                if (yy !== 0) {
                    list.push(yy)
                    yy = 0
                }
                fy++
            }
            if (i === len -1 && yy !== 0) { // 去掉末尾辅音辅音
                list.push(yy)
            }
        }
        
        // 去掉开头辅音
        if (!yuanyin.includes(str.charAt(0))) {
            list.splice(0, 1)
        }

        let size = list.length
        let indexLeft = 0 // 左侧元音索引
        let max = 0 // 最长指定瑕疵度字符串
        let count = list[0] // 元音的个数
        let xiaci = 0
        if (n === 0) {
            for (let i = 0; i < size; i+=2) {
                max = Math.max(max, list[i])
            }
        } else {
            for (let i = 1; i < size - 1; i+=2) {
                xiaci += list[i]
                console.log(xiaci,'xiaci')
                count += list[i + 1]
                console.log(count,'count')
                if (xiaci >= n) {
                    if (xiaci === n) {
                       max = Math.max(count + n, max) 
                    }
                    count -= list[indexLeft]
                    xiaci -= list[indexLeft + 1]
                    indexLeft += 2
                    console.log(count, 'count1')
                    console.log(xiaci,'xiaci1')
                }
            }
        }
        console.log(max);



// 解析
// 注意每次如果先判断左指针则每次都要将右指针从头判断到尾，而先判断右指针，左指针只用在原先的基础上移动到下一个符合条件的位置，这样可以节省很多多余的判断。

// 核心思想
// 先确定右指针是否为元音，否就右移，是就判断瑕疵度是否够且左指针也为元音，都满足才记录，不满足，瑕疵度不够就继续右移右指针，瑕疵度超过就右移左指针，直到瑕疵度小于或等于指定瑕疵度，并进行判断是否记录，最后右移右指针进行下次循环。

四,消消乐游戏

// 解题思路
// 1、将数据分割为字符放入list集合中，list可以删除对应数据，并及时更新，以便后续继续处理

// 2、根据每次消除完数据都要从头开始遍历，我们给定一个变量n表示list数据长度，遍历一次n就-1，当n=0代表遍历完成，也就代表字符串无法继续消除，此时list的长度就是最终值

  let s = 'mMbccbc'
        let len = s.length
        let stack = []
        let isFuhe = true
        let reg = /^[A-Za-z]+$/;
        for (let i = 0; i < len; i++) {
            const ch = s.charAt(i)
            if (!reg.test(ch)) {
               isFuhe = false
                break
            }
            if (!stack.length || stack[stack.length - 1] !== ch) {
                stack.push(ch)
            } else {
                stack.pop()
            }
        }
        console.log(isFuhe ? stack.length : 0)

五,判断字符串子序列

// 解题思路
// 因为是求最后一个子串的第一个字母下标，所以我们从后面向前开始遍历
// 将target作为外部循环内容，从最后一个字符开始向前遍历。
// 将source作为内部循环内容，从最后一个字符开始向前遍历。
// 当source出现字符与target字符相同时，计数加一并记录其下标，将其作为下次遍历source初始的下标。接着是target的倒数第二字符。。。以此类推，直至target或source遍历完成
// 若计数等于target长度，则输出其下标
      let n1 = target.length;
      let n2 = source.length;

      let n = 0;
      let res = n2;

      for (let i = n1 - 1; i >= 0; i--) {
        for (let j = res - 1; j >= 0; j--) {
          if (target.charAt(i) == source.charAt(j)) {
            n++;
            res = j;
            break;
          }
        }
      }

      if (n == n1) {
        console.log(res)
      } else {
        console.log(-1)
      }

六,整数对最小和

// 解题思路: 构造新数组存储另外两数组两两元素组队之和，之后对新数组由小到大升序排列，输出前k项之和即可！
function sum(nums1, nums2, k) {
      let arr1 = nums1.sort((a, b) => a - b);
      let arr2 = nums2.sort((a, b) => a - b);
      let n1 = arr1.length;
      let n2 = arr2.length;
      let n = n1 + n2;
      let res = [];
      for (let i = 0; i < n1; i++) {
        for (let j = 0; j < n2; j++) {
          res.push(arr1[i] + arr2[j]);
        }
      }
      res.sort((a, b) => a - b);
      let sum = 0;
      for (let i = 0; i < k; i++) {
        sum += res[i];
      }
      return sum
    }
    console.log(sum([3, 1, 1, 4], [3, 1, 2, 3], 2))

七,按区间反转文章片段

 function test(s, start, end) {
            const arr = s.split(' ')
            if (arr.length <= 1) {
                console.log('empty',arr.length)
                console.log('empty')
                return 'empty'
            }
            const copyArr = JSON.parse(JSON.stringify(arr))
            let newArr = copyArr.splice(start, end - start + 1).reverse()
            arr.splice(start, end - start + 1, ...newArr)
            console.log(arr.join(' '))
            return arr.join(' ')
        }

八,最长连续方波信号

let res = "";
let temp = "";
let b = false;  //是否开始识别
let isFomat = true; //是否满足条件
if(s.charAt(0)=='0'){       //如果第一个为0，则从第一个开始识别
    temp ="0";
    b = true;
}
 
for(let i=1;i<s.length;i++){
    if(b){      //识别中
        if(s.charAt(i)==s.charAt(i-1)){     //此时的数等于前一个数
            if(s.charAt(i)=='0'){       //出现重复的0则出局
                if(temp.length>=3 && isFomat){        //如果都是0，且符合规则（不含连续1大于3个长度）
                    res = temp.length>res.length ? temp : res;      //取最长信号
                }
                temp = "0";     //容器重置
                isFomat = true;
            }else {
                temp += s.charAt(i);      //出现重复的1继续，不过已不符合要求（不含连续的1）
                isFomat = false;
            }
        }else {
            temp += s.charAt(i);      //无重复的值则继续
        }
    } else {
        if(s.charAt(i)=='0'){   //遇到0就开始识别
            temp = "0";
            b = true;
        }
    }
}
console.log(res);

九,数组拼接

let step = Number("3");
let m = Number("2");
let test = ["2,5,6,7,9,5,7","1,7,4,3,4"];
let lists = [];

for(let i=0; i<m; i++){
   //let strings = readline().split(",").map(Number);
   let strings = test[i].split(",").map(Number);
   lists.push(strings);  //将数组放入集合中
}

let res = "";
let n = 0;  //起始下标
let count = 0;  //取完数字的数组
while (count<m){    //当取完的数组数量小于m时进入循环
   for(let i=0; i<m; i++){
       let list = lists[i];
       if(n>list.length){  //当其实下标大于数组长度时退出本次循环
           continue;
       }
       let end = n + step; //结束位置下标
       if(end >= list.length){   //当结束位置下标大于等于数组长度时
           end = list.length;
           count++;    //取完数字数组数量+1
       }
       for(let j=n; j<end; j++){
           res += list[j] + ",";
       }
   }
   n+=step;    //起始位置下标变更（+step）
}

console.log(res.substring(0,res.length-1));

十,停车场车辆统计

let cars = readLine().split(",");
//let cars = "1,1,0,0,1,1,1,0,1".split(",");
 
let count = 0;  //1的个数
let res = 0;
 
for(let i=0;i<cars.length;i++){
    if(cars[i]=="1"){
        count++;
    }else{
        if(count!=0){   //只要1的数量不是0则记为1辆车
            res++;
            count = 0;
        }
        continue;
    }
    if(count==3 || i==cars.length-1){ //3个1为1辆卡车直接计数
        res++;
        count = 0;
    }
}
 
console.log(res);

十一,乱序整数序列两数之和绝对值最小

let strings = readLine().split(" ").map(i=>parseInt(i));
//let nums = "-1 -3 7 5 11 15".split(" ").map(i=>parseInt(i));

let n = nums.length;
let min = Number.MAX_VALUE;
let num1 = 0;
let num2 = 0;

for(let i=0;i<n-1;i++){
   for(let j=i+1;j<n;j++){
       let a = nums[i];
       let b = nums[j];
       let count = Math.abs(a+b);
       min = Math.min(count, min);
       if(min==count){
           num1 = a;
           num2 = b;
       }
   }
}

console.log(num1+" "+num2+" "+min);

十二,最大括号深度

// 输入
input = "((([]){(()(})}))"

// 记录括号的栈
let stack = []
// 标记：字符串是否合法
let flag = true
// 最大深度
let max = 0

// 循环遍历输入
for (const x of input) {
   if ((x === '(') || (x === '[') || (x === '{')) {
   	// 如果是左括号，就入栈，同时判断此时栈的深度，以更新最大深度
       stack.push(x)
       max = Math.max(max, stack.length)
       continue
   }

   if ((x === ')')) {
   	// 若遇到右括号，判断此时栈顶的括号与它是否匹配，匹配则继续，不匹配，输出0，结束
       if (stack.pop() === '(') {
           continue
       } else {
           console.log(0);
           flag = false
           break
       }
   }

   if ((x === ']')) {
       if (stack.pop() === '[') {
           continue
       } else {
           console.log(0);
           flag = false
           break
       }
   }

   if ((x === '}')) {
       if (stack.pop() === '{') {
           continue
       } else {
           console.log(0);
           flag = false
           break
       }
   }
}

// 若标记为true，代表匹配无误，且此时栈要为空，则输出最大深度，否则输出0，代表匹配不合法
if (flag) {
   if (stack.length === 0) {
       console.log(max);
   } else {
       console.log(0);
   }
}

十三,打印任务排序

let strings = readLine().split(",").map(i=>parseInt(i));
//let strings = "9,3,5".split(",").map(i=>parseInt(i));
let len = strings.length;

let mask = [];
let list = [];

for(let i=0;i<len;i++){
   let num = strings[i];
   let temp = [];
   temp.push(i);    //使用下标方便最后获取执行顺序
   temp.push(num);
   mask.push(temp);
}

while (mask.length > 0){
   let first = mask[0][1];    //队列最前的任务
   let isDayin = true; //是否进行打印
   for (let l of mask){
       if(first<l[1]){ //如果发现队列中有大于最前的
           let temp = mask.shift();
           mask.push(temp); //将最前的移动到队列最后
           isDayin = false;
           break;
       }
   }
   if(isDayin){
       let dayin = mask.shift();
       list.push(dayin[0]);  //打印完就移除任务，并将任务下标添加到list
   }
}

let res = [];
for (let i=0;i<len;i++){
   res[list[i]] = i;   //list的值与下标进行交换就是所需要的结果
}

console.log(res.join(","));

十四,单词接龙

十五,数组去重和排序

  let arr = [1,3,3,3,2,4,4,4,5]
        let list = [] // 去重之后的数组
        let res  = ''
        
        // 统计出现元素的个数
        const newObj = arr.reduce((obj, name) => {
            if (name in obj) {
                obj[name]++
            } else {
                obj[name] = 1
            }
            return obj
        }, {}) 

        for (const item in newObj) {
           list.push({key: item, count: newObj[item]})
        }
        // 排序
        list.sort((a, b) => b.count - a.count).forEach(item => {
            res+=item.key+','
        })
        console.log(res.substring(0, res.length - 1))

十六,找最小数

// let s = readLine();
        // let m = Number(readLine());
        let s = "10200";
        let m = Number("1")

        let l = m + 1 // 截取字符的右边界
        let index = 0
        let res = ''

        while (res.length < s.length - m) {
            let str = s.substring(index, l) // 求出第一个数字的最小值
            let min = Number.MAX_VALUE
            let len = str.length
            let ints = []
            for (let i = 0; i < len; i++) {
                let temp = str.charAt(i)
                console.log(temp,'asdasd')
                ints[i] = temp // 放入数组求出下标
                if (res == '' && temp == 0) { // 第一位不能为0
                    continue
                }
                min = Math.min(min, temp)
            }
            res += String(min)

            for (let i = 0; i < len; i++) {
                if (ints[i] == min) {
                    index += i
                    break
                }
            }
            index++;
            l++;//数字要往后移一位
        }

        console.log(res,'asdasdas')

十七,按身高和体重排队

// let n = Number(readLine());
        // let h = readLine().split(" ").map(i => parseInt(i));   //身高数组
        // let w = readLine().split(" ").map(i => parseInt(i));    //体重数组
        let n = Number("4");
        let h = "100 100 120 130".split(" ").map(i => parseInt(i));   //身高数组
        let w = "40 30 60 50".split(" ").map(i => parseInt(i));    //体重数组
        
        let lists = []

        for (let i = 0; i < n; i++) {
           let stu = []
            stu.push(i+1)
            stu.push(h[i])
            stu.push(w[i])
            lists.push(stu)
        }

        lists.sort((a, b) => {
            if (b[1] < a[1]) {
                return 1
            } else if (b[1] == a[1]) {
                if (b[2] > a[2]) {
                   return -1 
                } else {
                    return 1
                }
            } else {
                return -1
            }
        })
        let res = ''
        for (let i = 0; i < lists.length; i++) {
           res += lists[i][0] 
           if (i !=lists.length - 1 ) {
               res += ' '
           }
        }
        console.log(res)

十八,勾股数元组

const input = 1000
        let res = []
        // c = m^2 + n^2 又mn 都大于0所以它们一定不能超过c的开方
        const len = Math.ceil(Math.sqrt(input))

        for (let i = 0; i < len; i++) {
            for (let j = i + 1; j < len; j++) {
                // m, n 不互质跳过
                if (isCoprime(i, j) !== 1) {
                    continue
                }
                let a = Math.pow(j, 2) - Math.pow(i, 2)
                let b = 2 * i * j
                let c  = Math.pow(j, 2) + Math.pow(i, 2)
                if (c <= input) {
                 // 当前勾股数数不会超过给定值
                 if ((isCoprime(a, b) === 1) && (isCoprime(b, c) === 1) && isCoprime(a, c) === 1) {
                     // 勾股数两两互质
                     res.push([a , b, c])
                 }   
                }
            }
        }

        // 判断两个数是否互质: 最大公因数是否为1
        function isCoprime(x, y) {
            // 不必考虑x,y的大小, 第一次递归后大的总会在前面
            if (y === 0) {
                return x
            } else {
                return isCoprime(y, x % y)
            }
        }

        console.log(res,'asdasd')

十九,乱序整数序列两数之和绝对值最小

  let nums = "-1 -3 7 5 11 15".split(" ").map(i => parseInt(i));

        let n = nums.length
        let min = Number.MAX_VALUE
        let num1 = 0
        let num2 = 0
        
        for (let i = 0; i < n; i++) {
            for (let j = i + 1; j <n - 1; j++) {
                let a = nums[i]
                let b = nums[j]
                let count = Math.abs(a + b)
                min = Math.min(count, min)
                if (count == min) {
                    num1 = a
                    num2 = b
                }
            }
        }
        console.log(num1 + ' ' + num2 + ' ' + min)

二十,解压报文

let s = readLine();
//let s = "3[m2[c]]";
let res = "";  //处理前的字母串
let numStr = "";  //处理多位数
let num = [];    //数字队列
let zimu = [];  //放置处理后的字母串
for(let i=0;i<s.length -1;i++){
    let c = s.charAt(i);
    if(!isNaN(Number(c))){  //判断是否为数字
        if(res.length!=0){    //数字前的字母暂不处理
            zimu.push(res);
            res = "";
        }
        numStr += c;
    }else if(c=='['){
        num.push(Number(numStr));  //数字放入数字队列
        numStr = "";
    }else if(c==']'){
        let n = num.pop();  //碰到“]”，就需要取出最上面的数字进行解压
        if(res.length!=0){
            zimu.push(res);
            res = "";
        }
        let temp = zimu.pop(); //取出最上面的字母
        let sb = "";
        for(let j=0;j<n;j++){
            sb+=temp;    //对字母进行解压
        }
        if(zimu.length==0){
            zimu.push(sb);
        }else {
            zimu.push(zimu.pop()+sb);   //后面处理过的字符会跟最上面的字符一起被处理
        }
    }else {
        res+=c;
    }
}
console.log(zimu)

二十一,数据分类

二十二,统计射击比赛成绩

let n = Number(readLine());
let s1 = readLine().split(","); //队员
let s2 = readLine().split(","); //射击成绩
 
// let n = Number("13");
// let s1 = "3,3,7,4,4,4,4,7,7,3,5,5,5".split(","); //队员
// let s2 = "53,80,68,24,39,76,66,16,100,55,53,80,55".split(","); //射击成绩
 
let map = {}    //将队员和射击成绩放入map对象中
 
/**
 * 队员作为key值，成绩作为value值（集合）
 */
for(let i=0;i<n;i++){
    let key = Number(s1[i]);
    let value = Number(s2[i]);
    if(map[key]){
        map[key].push(value);
    }else {
        let list = [];
        list.push(value);
        map[key] = list;
    }
}
/**
 * 将队员id及最高三个成绩之和放入集合list
 */
var scoreLists = [];
 
for(var key in map){
    let len = map[key].length;
    if(len>=3){
        let list = [];  //将所有队员数据放在集合scoreLists
        map[key].sort();    //对成绩进行排序并计算三个最高成绩和
        list.push(key);
        list.push(map[key][len-1] + map[key][len-2] + map[key][len-3]);
        scoreLists.push(list);
    }
}
 
scoreLists.sort((a,b)=>{
    if(b[1]>a[1]){  //成绩高的在前
        return 1;
    }
    if(b[1]==a[1] && b[0]>a[0]){  //成绩相等时，id高的在前
        return 1;
    }
    return -1;
});
 
let res = "";
let scoListsLen = scoreLists.length;
for(let i=0;i < scoListsLen - 1;i++){
    res+=scoreLists[i][0]+",";   //各队员成绩的第一个数为其id
}
console.log(res+scoreLists[scoListsLen-1][0]);

二十三,服务器广播

let input = readline().split(" ").map(Number);
//let input = "1 1 0 0".split(" ").map(Number);
 
let n = input.length;   //确定是n阶数组
var list = []; //服务器连通对集合
 
for(let i=0; i<n; i++){
    if(input[i] == 1){   //说明两个服务器相连
        let temp = [];
        temp.push(1);
        temp.push(i+1);
        list.push(temp);
    }
}
 
//let test = ["1 1 0 0","1 1 0 1","0 0 1 1","0 1 1 1"];
for(let i=1; i<n; i++){
    input = readline().split(" ").map(Number);
    //input = test[i].split(" ").map(Number);
    for(let j=0; j<n; j++){
        if(input[j]==1 && j>=i){    //两个服务器相连，剔除冗余数据
            let temp = [];
            temp.push(i+1);
            temp.push(j+1);
            list.push(temp);
        }
    }
}
 
let res = 0;
while (list.length>0){
    let temp = list[0];
    list.splice(0,1);
    connectNet(temp);
    res++;
}
 
console.log(res);
 
/**
 *
 * @param intList   相连的服务器集合（集合中的所有服务器都可以进行通信）
 */
function connectNet(intList){
    for(let i=0; i<list.length; i++){
        let temp = list[i];
        let a = temp[0];
        let b = temp[1];
        if(intList.includes(a) || intList.includes(b)){
            temp.forEach(element => {
                if(!intList.includes(element)){
                    intList.push(element);
                }
            });
            list.splice(i,1);
            connectNet(intList);
        }
    }
}

二十四,查找众数及中位数

let strings = readLine().split(" ").map(i=>parseInt(i));
//let strings = "10 11 21 19 21 17 21 16 21 18 15".split(" ").map(i=>parseInt(i));
//let strings = "2 1 5 4 3 3 9 2 7 4 6 2 15 4 2 4".split(" ").map(i=>parseInt(i));
 
let len = strings.length;
 
if(len == 1){
    console.log(strings[0]);
}else{
    let ints = [];
 
    for(let i=0;i<len;i++){
        ints[i] = strings[i];
    }
 
    ints.sort((a,b)=>{
        return a-b;
    });  //排序以便求出众数
 
    let list = []; //众数集合
    let max = 0;    //出现最多次数
    let count = 1;  //相同数字个数
    for(let i=1;i<ints.length;i++){
        if(ints[i]==ints[i-1]){
            count++;
        }else{
            /**
             * 若本轮数字出现次数count等于max
             *     则直接放入集合（众数可以是多个）
             * 若不等于
             *     若count==max，说明本轮数字是众数
             *          清空集合，并将本次数字加入集合
             */
            if(count==max){
                list.push(ints[i-1]);
            }else {
                max = Math.max(max,count);
                if(max == count){
                    list = [];
                    list.push(ints[i-1]);
                }
            }
            count=1;
        }
        if(i==ints.length-1){   //遍历到最后一个数字
            if(count==max){
                list.push(ints[i]);
            }else {
                max = Math.max(max,count);
                if(max == count){
                    list = [];
                    list.push(ints[i]);
                }
            }
        }
    }
 
    let l = list.length;
    if(l%2==0){
        console.log((list[l/2-1]+list[l/2])/2);
    }else {
        console.log(list[(l+1)/2-1]);
    }
}

二十五,分糖果

var list = [];
let n = Number(readLine());
//let n = Number("15");
 
fentangguo(n,0);    //第一个参数糖果数量，第二个参数是次数（初始化为0）
 
list.sort((a,b)=>{  //从小到大排序
    if(b>a){
        return -1;
    }
    return 1;
});
 
console.log(list[0]);
 
function fentangguo(n,m){
 
    if (n==1) {
        list.push(m);    //只剩一个分糖完毕
        return 1;
    }
    if(n%2==0){
        m++;    //分一次次数加1
        fentangguo(n/2,m);
    }else{
        m++;    //放回或取出次数加1
        fentangguo(n-1,m);
        fentangguo(n+1,m);
    }
    return 0;
}

二十六, we are a team

let s = readLine().split(" ").map(Number);
//let s = "4 4".split(" ").map(Number);
//let s = "5 6".split(" ").map(Number);
 
let n = s[0];
let m = s[1];
let teams  = []; //所有teams的集合
 
// let test = ["1 2 0",
//             "3 4 0",
//             "2 3 0",
//             "1 4 1"];
//let test = ["1 2 0","1 2 1","1 5 0","2 3 1","2 5 1","1 3 2"];
 
if(n<1 || n>100000 || m<1 || m>100000){ //越界了
    console.log("NULL");
}else {
    for(let i=0;i<m;i++){
 
        let str = readLine().split(" ").map(Number);
        //let str = test[i].split(" ").map(Number);
 
        let a = str[0];
        let b = str[1];
        let c = str[2];
 
        if(a<1 || a>n || b<1 || b>n || (c!=0 && c!=1)){ //a,b越界，c只能0和1
            console.log("da pian zi");
        }else if(c==0){
            let hasTeam = false;    //a和b是否有了team
            let teamIndex = -1;
            let isCombine = false;
            for(let j=0;j<teams.length;j++){
                if(teams[j].includes(a)){   //team中有了a，则b也是其中成员
                    teams[j].push(b);
                    if(hasTeam){    //已经有了team，可以进行合并
                        teams[teamIndex].forEach(v=>{
                            if(!teams[j].includes(v)){
                                teams[j].push(v); 
                            }
                        })
                        isCombine = true;
                        break;
                    }
                    teamIndex = j;
                    hasTeam = true;
                    continue;
                }
                if(teams[j].includes(b)){   //team中有了b，则a也是其中成员
                    teams[j].push(a);
                    if(hasTeam){
                        teams[teamIndex].forEach(v=>{
                            if(!teams[j].includes(v)){
                                teams[j].push(v); 
                            }
                        })
                        isCombine = true;
                        break;
                    }
                    teamIndex = j;
                    hasTeam = true;
                }
            }
            if(isCombine){
                teams.splice(teamIndex,1);    //剔除合并过的team
            }
            if(!hasTeam){   //a和b都没有team，则新建team加入teams的集合中
                let team = [];
                team.push(a);
                team.push(b);
                teams.push(team);
            }
        }else {
            let isATeam = false;
            for(let j=0;j<teams.length;j++){
                if(teams[j].includes(a) && teams[j].includes(b)){   //a和b同时在一个team中
                    isATeam = true;
                }
            }
            console.log(isATeam ? "we are a team" : "we are not a team");
        }
    }
}

二十七,非严格递增连续数字序列长度

function noStrictDigit(str) {
    let dp = new Array(str.length).fill(1);
    let arr = str.split('').map(n => parseInt(n));
    for (let i = 0; i <arr.length; i++) {
        if (isNaN(arr[i])) {
            continue;
        } else {
            if (arr[i] === arr[i-1]  || arr[i] === (arr[i-1] + 1) ) {
                dp[i] = dp[i-1] + 1;
            }
        }
    }
    console.log(dp.sort()[dp.length - 1]);

}

noStrictDigit('abc2234019A334bc');

二十八,最长的连续子序列

function longList(arr,target) {
    if (target == 0) return -1;
        let result = 0, left = 0, right = 0, sum = 0;
        while(left < arr.length && right < arr.length) {
            if (sum >= target) {
                // 相等时更新 result
                result = (sum == target) ? Math.max(result, right - left) : result;                        
                sum = sum - arr[left];// 移动左指针，并更新sum
                left++
            }  else {
                sum += arr[right];// 最后一个数需要跳出循环后计算
                right++
            }
        }
        // sum和target：等于时更新，大于时移动左指针，小于时忽略
        // 这里的情况是当跳出for循环后，此时的left没有++，因此判断条件应该
        // 附加上target==sum-arrs[left++]，这样的话就可以刚好求出最大的result
        // 例如:[4,2,1,2,3]当right超过了数字长度时,此时的left还是1,没有++;但退出
        // 了for循环,并且result并不是最大值,为2,因此通过target == sum - arr[left++]
        // 判断sum减去++后的left是否等于target,如果等于计算这个right-left的值
        result = (target == sum  || target == sum - arr[left++]) 
                ? Math.max(result, right - left) : result;
        return result;
}

二十九,【华为OD机试真题 JS】寻找相同子串

let t = readLine();
let p = readLine();
// let t = "AVERDXIVYERDIAN";
// let p = "RDXI";
 
if(t.length>1000000){
    console.log("No");
}
 
if(p.length>t.length && p.length>10000){
    console.log("No");
}
 
console.log(t.indexOf(p) == -1? "No" : t.indexOf(p)+1);

三十,检查是否存在满足条件的数字组合

let n = Number(readLine());
let ints = readLine().split(" ").map(i=>parseInt(i));
// let n = Number("4");
// let ints = "2 7 3 0".split(" ").map(i=>parseInt(i));
 
let list = [];
 
for(let i=0;i<n;i++){   //对输入的list遍历 为A
    for(let j=0;j<n;j++){   //对输入的list遍历 为B
        if(i==j){   //下标相同为同一值，跳过
            continue;
        }
        for(let k=0;k<n;k++){
            if(i==k || j==k){ //下标相同为同一值，跳过
                continue;
            }
            if(ints[i] == ints[j] + 2*ints[k] ){    //进行A=B+2C处理判断
                let res = ints[i]+" "+ints[j]+" "+ints[k];
                list.push(res);
            }
        }
    }
}
 
if(list.length==0){
    console.log(0);
}else {
    list.forEach(v=>{
        console.log(v);
    })
}

三十一,字符串筛选排序

三十二,仿LISP字符串运算

//(sub (mul 2 4) (div 9 3))
// add / sub / mul / div
 
let s = readLine().split(" ");  //输入可以按照空格分割长数组
//let s = "(div 12 (sub 45 45))".split(" ");  //输入可以按照空格分割长数组
//let s = "(add 1 (div -7 3))".split(" ");
 
let fuhao = [];   //符合堆栈
let num = [];    //数字堆栈
let isE = false;    //除0表示计算错误
 
for(let i=0;i<s.length;i++){
    if(s[i].includes("a")){ //如果包含a则表示+
        fuhao.push("+");
    }else if(s[i].includes("b")){   //如果包含b则表示-
        fuhao.push("-");
    }else if(s[i].includes("m")){   //如果包含m则表示*
        fuhao.push("*");
    }else if(s[i].includes("v")){   //如果包含v则表示/
        fuhao.push("/");
    }else if(s[i].includes(")")){   //如果包含)则表示需要进行计算
        let temp = "";   //）前面的数字
        for(let j=0;j<s[i].length;j++){   //包含）的字符串需要筛选出数字
            if(s[i].charAt(j)==')'){    //考虑到都有多个）,需要计算多次
                if(temp.length!=0){   //如果是0表示已经计算过一次
                    num.push(Number(temp));   //将数字放入数堆栈中
                    temp = "";  //需要置空（这一步很关键）
                }
                let b = num.pop();  //第二个数
                let a = num.pop();  //第一个数
                let f = fuhao.pop(); //符号
                if(f=="/" && b==0){ //除数为0则退出，输出error
                    isE = true;
                    break;
                }else {
                    num.push(jisuan(a,b,f));    //将计算完的数据放入数堆栈中进入下次的计算
                }
            }else {
                temp += s[i].charAt(j);  //不到）都表示数字（主要考虑到多位数）
            }
        }
    }else {
        num.push(Number(s[i]));
    }
    if(isE){break;}
}
 
if(isE){
    console.log("error");
}else {
    console.log(num.pop());
}
 
function jisuan( a, b, f){
    switch (f){
        case "+":
            return a+b;
        case "-":
            return a-b;
        case "*":
            return a*b;
        case "/":
            return Math.floor(a/b);  //向下取整
    }
    return 0;
}

5键键盘的输出

//let s = readline().split(" ");
//let s = "1 1 1".split(" ");
let s = "1 1 5 1 5 2 4 4".split(" ");
 
let temp = "";//剪贴板
let screen = "";//屏幕
let select = "";//选择的
 
for(let i=0; i<s.length; i++){
 
    switch (s[i]){
        case "1":
            if(select!=""){
                screen = "a";
                select = "";
            }else {
                screen+="a";
            }
            break;
        case "2":
            if(select!=""){
                temp = select;
            }
            break;
        case "3":
            if(select!=""){
                temp = select;
                screen = "";
                select = "";
            }
            break;
        case "4":
            if(select!=""){
                screen = temp;
                select = "";
            }else {
                screen+=temp;
            }
            break;
        case "5":
            if(screen!=""){
                select = screen;
            }
            break;
    }
}
 
console.log(screen.length);

猴子爬山

let n = Number(readLine());
//let n = Number("50");
 
console.log(pashan(n));
    
function pashan( n){
    if(n==1){
        return 1;
    }
    if(n==2){
        return 1;
    }
    if(n==3){
        return 2;
    }
    return pashan(n-1) + pashan(n-3);
}

计算疫情扩散时间

let strs = readLine().split(",").map(Number);
//let strs = "1,0,1,0,0,0,1,0,1".split(",").map(Number);
 
var N = Math.sqrt(strs.length);   //总数开方为二维数组长宽
let n = 0;
let list = [];   //未被感染的区域
var ints = [];
 
for(let i=0;i<N;i++){
    ints[i] = [];
    for(let j=0;j<N;j++){
        let x = strs[n++];
        ints[i][j] = x;
        if(x==0){
            let temp = [];
            temp[0] = i;
            temp[1] = j;
            list.push(temp);
        }
    }
}
 
if(list.length==0 || list.length==strs.length){ //全部感染或者全部安全
    console.log(-1);
}else {
    let res = 0;    //天数
    let sickList = [];   //被传染的区域集合
 
    while (list.length!=0){
        res++;
 
        //被传染的区域需要置为1
        for(let i=0; i<sickList.length; i++){
            let temp = sickList[i];
            ints[temp[0]][temp[1]] = 1;
        }
        sickList = [];
 
        for(let i=0; i<list.length; i++){
            let temp = list[i];
            if(chuanran(temp[0],temp[1])){  //会被感染
                sickList.push(temp);
            }
        }
 
        list = list.filter(e=>!sickList.includes(e));   //从未被感染的区域中剔除被传染的区域
    }
 
    console.log(res);
}
/**
 *
 * @param x 横坐标
 * @param y 纵坐标
 * @return  是否会被传染
 */
function chuanran( x,  y){
 
    //上
    if(x>0 && ints[x-1][y] == 1){
        return true;
    }
    //下
    if(x<N-1 && ints[x+1][y] == 1){
        return true;
    }
    //左
    if(y>0 && ints[x][y-1] == 1){
        return true;
    }
    //右
    if(y<N-1 && ints[x][y+1] == 1){
        return true;
    }
 
    return false;
}

计算GPU算力

function gpuPower(n,len,arr) {
    let more = 0 , time = 0
    for(let i of arr) {
        if(i+more>n) {
            more = i + more - n
        }else if(i+more <=n) {
            more = 0
        }
        //每循环一次都需要计算耗时1秒
        time+=1 
    }
    // 当任务组完成后还有剩余未完成的任务，需要继续将其完成。
    while(more>0) {
        more -= n
        time += 1
    }
    return time
}
 
console.log(gpuPower(3,5,[1,2,3,4,5])) //6
console.log(gpuPower(4,5,[5,4,1,1,1])) //5

字符串变换最小字符串

//let s = readline();
let s = "bcdefa";
 
let len = s.length;
let listBySort = [];
let chars = [];   //原字符数组
 
for(let i=0; i<len; i++){
    listBySort.push(s.charAt(i));
    chars[i] = s.charAt(i);
}
 
listBySort.sort();   //对字符进行排序
 
let change = ' ';  //需要替换的字符
let minIndex = 0;   //较小的字符下标
let changeIndex = 0;    //需要替换的字符下标
for(let i=0; i<len; i++){
    if(listBySort[i]<s.charAt(i)){  //小字符串在后进行替换
        change = listBySort[i];
        changeIndex = i;
        break;
    }
}
 
if(change != ' '){
    for(let i=len-1; i>=0; i--){
        if(s.charAt(i) == change){
            minIndex = i;
            break;
        }
    }
    chars[minIndex] = chars[changeIndex];
    chars[changeIndex] = change;
}
 
let res = "";
for(let i=0; i<chars.length; i++){
    res+=chars[i];
}
 
console.log(res);

篮球比赛

let people = readLine().split(" ").map(i=>parseInt(i));
//let people = "10 9 8 7 6 5 4 3 2 1".split(" ").map(i=>parseInt(i));
 
let count = 0;  //总队员战力
for(let i=0;i<10;i++){
    count+=people[i];
}
let n ;
let min = Number.MAX_VALUE;
for(let i=0;i<6;i++){
    for(let j=i+1;j<7;j++){
        for(let k=j+1;k<8;k++){
            for(let l=k+1;l<9;l++){
                for(let m=l+1;m<10;m++){
                    n = people[i] + people[j] + people[k] + people[l] + people[m];
                    min = Math.min(min, Math.abs(count-2*n));
                }
            }
        }
    }
}
console.log(min);

连续字母长度

let s = readLine();
let n = Number(readLine());
// let s = "AABAAA";
// let n = Number("2");
 
let map = {};
let count = 1;    //相同字符的个数
for(let i=0;i<s.length-1;i++){
    if(s.charAt(i)==s.charAt(i+1)){ //当前字符跟后面一个字符比较，所以边界为s.length()-1
        count++;   //相同字符计数加1
    } else {
        if(map[s.charAt(i)]){
            count = Math.max(count,map[s.charAt(i)]);    //同字符长度取最长长度
        }
        map[s.charAt(i)] = count;
        count = 1;
    }
    if(i==s.length-2){    //最后一个字符
        let key = count==1 ? s.charAt(i+1) : s.charAt(i);
        map[key] = count;
    }
}
 
let list = [];    //长度（value）集合
 
for (let c in map
        ) {
    list.push(map[c]);
}
 
list.sort((a,b)=>{    //根据长度降序处理
    if (b>a){
        return 1;
    }
    return -1;
});
 
if(list.length>=n){
    console.log(list[n-1]);
}else {
    console.log(-1);
}

素数之积

let n = Number(readLine());
//let n = Number("15");
 
let list = [];
let m = 0;
/**
 * 本题就是求出一个数只有两个因子（1不是素数）
 * 遍历n求出它所有的因子
 */
while (m!=n){   //当n==m时说明已经不能再除了，跳出循环
    n = m!=0? m: n;
    for(let i=2;i<Math.sqrt(n)+1;i++){
        if(n%i==0){
            m = n/i;    //把商作为下次的被除数
            list.push(i);    //i就是因子
            break;
        }
    }
}
 
list.push(m);
 
if(list.length==2){
    console.log(list[0]+" "+list[1]);
}else {
    console.log("-1 -1");
}

判断一组不等式是否满足约束并输出最大差

let strings = readLine().split(";");
//let strings = "2.36,3,6,7.1,6;1,30,8.6,2.5,21;0.3,69,5.3,6.6,7.8;1,13,2,17,5;340,67,300.6;<=,>=,<=".split(";");
 
let length = strings.length;
let bianliang = strings[length-3].split(",").map(i=>Number(i)); //不等式变量
let mubiao = strings[length-2].split(",").map(i=>Number(i)); //不等式目标值
let ys = strings[length-1].split(","); //不等式约束
 
let m = ys.length;  //约束的数量等于数组的数量
let n = bianliang.length;  //变量的数量等于数组中数据的数量
 
let doubles = [];  //不等式系数是二维数组
 
for(let i=0;i<m;i++){
    let xs = strings[i].split(","); //不等式系数
    doubles[i] = new Array;
    for(let j=0;j<n;j++){
        doubles[i][j] = Number(xs[j]);  //将不等式系数放入double类型二维数组
    }
}
 
let isYueshu = true;
let max = 0;
 
for (let i=0;i<m;i++){  //循环遍历不等式数组
    let d=0;
    let b = true;
    for(let j=0;j<n;j++){
        d+=doubles[i][j]*bianliang[j];   //不等式数组值
    }
    max = Math.max(max,d-mubiao[i]);    //求出最大差
    if(ys[i] == ">"){  //等于不等式进行判断
        b = d>mubiao[i];
    }else if(ys[i] == ">="){
        b = d>=mubiao[i];
    }else if(ys[i] == "<"){
        b = d<mubiao[i];
    }else if(ys[i] == "<="){
        b = d<=mubiao[i];
    }else if(ys[i] == "="){
        b = d==mubiao[i];
    }
    if(!b){ //只要一个等式不成立就为false
        isYueshu = false;
    }
}
 
console.log(isYueshu+" "+  parseInt(max));

输出字符串中包含所有整数的最小和

let s = readLine();
//let s = "bb12-34aa";
 
let len = s.length;
let list = [];
let temp = "";
let isFuhao = false;
let isDigit = /[0-9]/;  //数字正则
 
for(let i=0;i<len;i++){
    let c = s.charAt(i);
    if(isDigit.test(c)){
        if(isFuhao){
            temp += c;    //有负号的情况下数字越大越好，直接拼接
        }else {
            list.push(Number(c));   //没有负号直接加入集合
        }
    }else if(c=='-'){
        if(temp!="" && temp!="-"){    //temp中有值且不是一个“-”单字符串的情况下
            list.push(Number(temp));
        }
        isFuhao = true; //说明下一个字符串有了负号
        temp = "-";
    }else {
        /**
         字母和“+”的情况下进入
        * */
        if(temp!="" && temp!="-"){
            list.push(Number(temp));
        }
        temp = "";  //无论之前是什么，都需要置空
        isFuhao = false;
    }
}
let res = 0;
for (let i of list) {
    res+=i;
}
console.log(res);

组成最大数

let arr = [10,2]

        var largestNumber = function (nums) {
            nums.sort((a, b) => {
                a = a.toString();
                b = b.toString();
                if (a + b > b + a) {
                    return -1
                } else {
                    return 1
                }
            });
            if (nums[0] == 0) return '0'
            return nums.join('')
        };
    
        console.log(largestNumber(arr))

找朋友

let n = Number(readLine());
let ints = readLine().split(" ").map(i=>parseInt(i));
// let n = Number("8");
// let ints = "123 124 125 121 119 122 126 123".split(" ").map(i=>parseInt(i));
 
let list = [];
 
for(let i=0;i<n-1;i++){ //最后一个直接跳过
    for(let j=i+1;j<n;j++){
        if(ints[j]>ints[i]){
            list.push(j);
            break;
        }
        if(j==n-1){    //到最后一位都没有符合的
            list.push(0);
        }
    }
}
list.push(0);    //最后一位小朋友
console.log(list.join(" "));

字符串统计重排

//let s = readline();
//let s = "xyxyXX";
let s = "abababb";
 
let map = new Map();
 
for(let i=0; i<s.length; i++){
    if(!map.has(s.charAt(i))){
        map.set(s.charAt(i), 1)
    }else{
        map.set(s.charAt(i), map.get(s.charAt(i))+1);     //将输入内容转成键值对
    }
}
 
let entryList = Array.from(map);
let upReg = new RegExp("^[A-Z]{1}$");
let lowReg = new RegExp("^[a-z]{1}$");
 
entryList.sort((a,b)=>{
    if (b[1]>a[1]) {      //按出现次数顺序排序
        return 1;
    }
    if(b[1]<a[1]){      //按出现次数顺序排序
        return -1;
    }
    if(lowReg.test((b[0])) && upReg.test(a[0])){     //限制小写在前
        return 1;
    }
    if(lowReg.test((a[0])) && upReg.test((b[0]))){     //限制小写在前
        return -1;
    }
    if(b[0] < a[0] ){       //按字母顺序排序
        return 1;
    }
    return -1;
});
 
let res = "";
for(let i=0; i<entryList.length; i++){
    res += entryList[i][0] + ":";
    res += entryList[i][1] + ";";
}
 
console.log(res);

德州扑克

let numList = [];
let map = new Map();    //数字，数字个数键值对
let color = Array(4).fill(0);   //H、S、C、D 红黑梅方
 
//let test = ["A S","J C","J H","J S","J D"];
//let test = ["4 H","5 S","6 C","7 D","8 D"];
// let test = ["A S","J S","K S","Q S","10 S"];
 
for(let i=0; i<5; i++){
 
    let input = readLine().split(" ");
    //let input = test[i].split(" ");
 
    let num;
    switch (input[0]){
        case "A":
            num = 1;
            break;
        case "J":
            num = 11;
            break;
        case "Q":
            num = 12;
            break;
        case "K":
            num = 13;
            break;
        default:
            num = Number(input[0]);
    }
 
    if(map.has(num)){
        map.set( num, map.get(num)+1);
    }else{
        map.set( num, 1);
    }
    numList.push(num);
 
    let hs = input[1];
    if(hs == "H"){
        color[0]++;
    }else if(hs == "S"){
        color[1]++;
    }else if(hs == "C"){
        color[2]++;
    }else {
        color[3]++;
    }
}
 
let isTongHua = false;
 
if(color[1]==5 || color[1]==5 || color[2]==5 || color[3]==5){   //只要其中一个花色有5张为同花
    isTongHua = true;
}
 
let res = 7;
 
if(map.size == 5){
    numList.sort((a,b)=>{return a-b});  //排序方便判断顺子
    let isShunZi = isShunzi(numList);
    if(isShunZi){
        res = isTongHua ? 1 : 5;
    }else {
        res = isTongHua ? 4 : 7;
    }
}else {
    map.forEach((v, k)=>{
        if(v == 4){  //有四条一样的
            return res = 2;
        }else if(v == 3){    //有三条一样的
            return res = map.size == 2 ? 3 : 6;    //如果只有牌面只有两个数字则是三带二，否则三带两单
        }
    })
}
 
console.log(res);
 
function isShunzi( list){
 
    let b = true;
    let index = 1;
    let isA = false;
 
    if(list[0]==1 && list[1]!=2){   //如果第一张为A，且第二张不为2
        index = 2;
        isA = true;
    }
 
    for(let i=index; i<5; i++){
        if(list[i] != list[i-1]+1){
            b = false;
            break;
        }
        if(i==4 && isA && list[4]!=13){
            b = false;
        }
    }
 
    return b;
}

靠谱的车

let n = Number(readLine());
//let n = Number("100");
 
let ans = n;
let temp = 0;
let k=0;    //进制内含4的个数
let j=1;    //4开头的数字
 
while(n > 0){
    if(n%10 > 4){
        temp += (n%10-1)*k+j;
    }else{
        temp += (n%10)*k;
    }
    //进制数内的含4个数
    k = k*9+j;
    j*=10;
    n = Math.floor(n/10);
}
 
console.log(ans-temp);

VLAN资源池

let strs = readLine().split(",");
let  n = Number(readLine());
// let strs = "20-21,15,18,30,5-10".split(",");
// let  n = Number("15");
 
let len = strs.length;
let list = [];  //vlan集合
 
for(let i=0; i<len; i++){
    let temp = strs[i].split("-");
    if(temp.length==1 ){    //是一个单独数字
        if(Number(strs[i]) != n){ //不是业务申请的vlan加入集合中
            list.push(strs[i]);
        }
    }else {
        let min = Number(temp[0]);
        let max = Number(temp[1]);
        if(min>n || max<n){
            list.push(strs[i]);  //非业务申请的vlan直接加入集合中
        }else if(min==n){
            list.push((min+1) + "-" + max);  //申请的vlan等于连续vlan的最小值
        }else if(max==n){
            list.push(min + "-" + (max-1));  //申请的vlan等于连续vlan的最大值
        }else {
            if(min != n-1){
                list.push(min + "-" + (n-1));
            }else {
                list.push(temp[0]);  //申请的vlan-1等于连续vlan的最小值
            }
            if(n+1 != max){
                list.push((n+1) + "-" +max);
            }else {
                list.push(temp[1]);  //申请的vlan+1等于连续vlan的最大值
            }
        }
    }
}
 
list.sort((a,b)=>{  //对list进行排序
    let tempA = a.split("-");
    let tempB = b.split("-");
    if(Number(tempA[0]) < Number(tempB[0])){
        return -1;
    }
    return 1;
});
 
let res = "";
for(let i=0; i<list.length; i++){
    res += list[i];
    if(i!=list.length-1){
        res += ",";
    }
}
 
console.log(res);

找终点

let nums = readLine().split(" ").map(i=>parseInt(i));
//let nums = "7 5 9 4 2 6 8 3 5 4 3 9".split(" ").map(i=>parseInt(i));
 
let ints = [];
let len = nums.length;
 
for(let i=0;i<len;i++){
    ints[i] = nums[i];
}
 
let step = 0;   //步数的进度（数组下标）
let count = 0;  //步数
let x = Number.MAX_VALUE;
for(let i=0;i<len/2-1;i++){ //从第一个元素开始，第一步<length/2(下标为0，所以要减一)
    step = i;
    count = 1;
    while (step < len-1) {  //没有走完就需要继续
        step += ints[step];
        count++;
    }
    if(step == len-1){  //正好走完，比较步数
        x = Math.min(x,count);
    }
}
if(x==Number.MAX_VALUE){
    console.log("-1");
}else {
    console.log(x);
}

拼接URL

let s = readLine().split(",");
//let s = ",/abc".split(",");
 
let res = "";
 
for(let i=0;i<s.length;i++){
    if(s[i]!="" && s[i]!="/"){
        /**
        * 将字符串中的"/"直接去除
        */
        res+="/"+s[i].replace("/","");
    }
}
 
console.log(res=="" ? "/" : res);

矩阵最大值

let n = Number(readLine());
//let n = Number("5");
let res = 0;
 
// let test = ["1,0,0,0,1",
//             "0,0,0,1,1",
//             "0,1,0,1,0",
//             "1,0,0,1,1",
//             "1,0,1,0,1"]
 
for(let i=0;i<n;i++){
    let s = readLine().replaceAll(",","");   //直接将输入值转换为字符串
    //let s = test[i].replaceAll(",","");
    let max = 0;
    for(let j=0;j<n;j++){
        let newS = s.substring(j) + s.substring(0,j); //字符串分段拼接相当于右移
        max = Math.max(max,parseInt(newS,2));
    }
    res+=max;
}
console.log(res);

最小传输时延

let input1 = readLine().split(" ").map(Number);
//let input1 = "4 6".split(" ").map(Number);
 
let N = input1[0];   //节点个数
let M = input1[1];   //时延列表长度
var res = [];    //完成传播的时延集合
var list = []; //时延列表的集合
//let test = ["1 2 11","2 3 13","1 3 50"];
//let test = ["1 2 4","1 3 1","1 4 100","2 3 2","2 4 6","3 4 1"];
 
for(let i=0;i<M;i++){
    let ints = readLine().split(" ").map(Number);
    //let ints = test[i].split(" ").map(Number);
 
    if((ints[0]<1 || ints[0]>N) ||
        (ints[1]<1 || ints[1]>N)){
        break;
    }
 
    list.push(ints);
}
 
let input2 = readLine().split(" ").map(Number);
//let input2 = "1 4".split(" ").map(Number);
 
let start = input2[0];   //初始节点
let end = input2[1]; //目标节点
 
qiushiyan(start, end, 0);
 
if(res.length == 0){
    console.log(-1);
}else {
    console.log(Math.min(...res));
}
 
/**
 *
 * @param start 初始节点
 * @param end   目标节点
 * @param count 时延总数
 */
function qiushiyan( start,  end,  count){
 
    for(let i=0;i<list.length;i++){
        let temp = list[i];
        if(temp[0]==start){
            if(temp[1]==end){
                res.push(count + temp[2]);
                continue;
            }
            qiushiyan(temp[1], end, count + temp[2]);
        }
    }
 
}

矩形相交的面积

let a = readLine().split(" ").map(Number);
let b = readLine().split(" ").map(Number);
let c = readLine().split(" ").map(Number);
// let a = "-3 2 4 4".split(" ").map(Number);
// let b = "-1 1 3 4".split(" ").map(Number);
// let c = "-4 -1 7 3".split(" ").map(Number);
// let a = "1 6 2 2".split(" ").map(Number);
// let b = "4 5 2 2".split(" ").map(Number);
// let c = "0 3 7 3".split(" ").map(Number);
 
let top = Math.min(a[1],Math.min(b[1],c[1]));       //上边界为三个坐标Y轴坐标的最小值
let left = Math.max(a[0],Math.max(b[0],c[0]));      //左边界为三个坐标X轴坐标的最大值
let down = Math.max(a[1]-a[3],Math.max(b[1]-b[3],c[1]-c[3]));       //下边界为三个坐标（Y轴坐标-高度）的最大值
let right = Math.min(a[0]+a[2],Math.min(b[0]+b[2],c[0]+c[2]));      //右边界为三个坐标（X轴坐标+宽度）的最小值
 
if(top>down && right>left){
    console.log((top-down)*(right-left));  //高为（上边界-下边界）*宽为（右边界-左边界）
}else {
    console.log(0);
}

流水线

let input = readLine().split(" ").map(i=>parseInt(i));
let ints = readLine().split(" ").map(i=>parseInt(i));    //作业数组
// let input = "3 5".split(" ").map(i=>parseInt(i));
// let ints = "8 4 3 2 10".split(" ").map(i=>parseInt(i));    //作业数组
 
let m = input[0];   //流水线
let n = input[1];   //作业数
 
ints.sort((a,b)=>{return a-b});  //对作业进行排序（升序）
 
let res = 0;    //最短流水线容器
let count = Array(m).fill(0);   //流水线数组
let index = 0;  //流水线索引
 
for(let i=0;i<n;i++){
    res = Math.min(...count);    //求流水线中最短时间的线
    for(let j=0;j<m;j++){
        if(res == count[j]){    //求出流水线最短时间线的下标
            index = j;
            break;
        }
    }
    count[index]+=ints[i];
}
 
console.log(Math.max(...count));    //求出最长流水线

快递运输

// let nums = readline().split(",").map(Number);   //把快递以逗号分割放入数组中
// let n = Number(readline());
let nums = "5,10,2,11".split(",").map(Number);   //把快递以逗号分割放入数组中
let n = Number("20");
 
let len = nums.length;
 
nums.sort((a,b)=>{if(b>a) return -1});  //对快递进行从小到大排序
let res = 0;
let num = 0;
for(let i=0; i<len; i++){
    res += nums[i];
    if(res>n){      //若大于载重量则推出循环
        break;
    }
    num++;
}
 
console.log(num);

目录删除

let n = Number(readLine());
//let n = Number("5");
 
let list = [];
var res = "";
var afterDelete = [];
//let test = ["8 6","10 8","6 0","20 8","2 6"]
 
for(let i=0;i<n;i++){
    let ints = readLine().split(" ").map(i=>parseInt(i));
    //let ints = test[i].split(" ").map(i=>parseInt(i));
    if(afterDelete.indexOf(ints[0])==-1){
        afterDelete.push(ints[0]);
    }
    if(afterDelete.indexOf(ints[1])==-1){
        afterDelete.push(ints[1]);
    }
    list.push(ints); //将目录关系表以数组的方式存储在集合中
}
 
let id = Number(readLine());
//let id = Number("8");
let index = afterDelete.indexOf(id);
afterDelete.splice(index,1);
 
deleteMenu(list,id);
 
afterDelete.sort();
 
for(let i=0;i<afterDelete.length;i++){
    if(afterDelete[i]==0){
        continue;
    }
    res+=afterDelete[i];
    if(i!=afterDelete.length-1){
        res+=" ";
    }
}
 
console.log(res);
 
/**
 *
 * @param list  目录关系表集合
 * @param n     需要剔除的目录
 */
function deleteMenu( list, n){
 
    for(let i=0;i<list.length;i++){
        if(list[i][1] == n){    //找到需要剔除的目录的关系数组
            let index = afterDelete.indexOf(list[i][0]);
            afterDelete.splice(index,1);
            delete(list,list[i][0]);
        }
    }
}

输入法联想

// let strings = readline()
//         .replace("'"," ")   //对“'”符号进行空格处理
//         .replace(",","")    
//         .replace(".","")
//         .replace("?","")
//         .replace("!","")    //对“, . ? !”符号进行删除处理
//         .split(" ");    //按照空格进行分割
let strings = "The furthest distance in the world, Is not between life and death, But when I stand in front of you, Yet you don't know that I love you."
        .replace("'"," ")   //对“'”符号进行空格处理
        .replace(",","")    
        .replace(".","")
        .replace("?","")
        .replace("!","")    //对“, . ? !”符号进行删除处理
        .split(" ");    //按照空格进行分割
 
strings.sort();   //因为是字典需要进行排序
//let key = readline();
let key = "f";
let keyLen = key.length;
let strLen = strings.length;
let res = "";
 
for(let i=0; i<strLen; i++){
    let s = strings[i];
    if(s.length >= keyLen && s.substring(0,keyLen) == key){    //匹配的字符串需要判断长度，并进行关键词长度的分割
        if(res.length != 0){
            res += " ";
        }
        res += s;
    }
}
if(res.length == 0){
    res = key;
}
console.log(res);

区间交集

let list = [];
//let test = ["0 3","1 4","4 7","5 8"];
//let test = ["1 2","3 4"];
let test = ["0 3","1 3","3 5","3 6"];
 
for(let i=0;i<test.length;i++){
	let x = test[i].split(" ");
	let node = new qujian(x[0], x[1]);
	list.push(node);
}
 
// while (readline()) {
// 	let input = readline().split(" ").map(Number);
// 	let node = new qujian(input[0], input[1]);
// 	list.push(node);
// }
 
let list1 = [];
collection(list);
 
for(let i=0;i<list.length-1;i++){
	for(let j=i+1;j<list.length;j++){
		let a = list[i];
		let b = list[j];
		if(b.left <= a.right){
			let l = Math.max(a.left, b.left);
			let r = Math.min(a.right, b.right);
			let node = new qujian(l, r);
			list1.push(node);
		}
	}
}
 
if(list1.length==0){
	console.log("None");
	return;
}
collection(list1);
let l = list1[0].left;
let r = list1[0].right;
 
for(let i=1; i<list1.length; i++){
	let node = list1[i];
	if(node.left > r){
		console.log(l+" "+r);
		l = node.left;
		r = node.right;
	}else {
		l = Math.min(node.left, l);
		r = Math.max(node.right, r);
	}
}
console.log(l+" "+r);
 
function qujian(l, r){
	this.left = l;
	this.right = r;
}
 
function collection( list){
	list.sort((a,b) => {
		if(a.left==b.left){
			return a.right-b.right;
		}
		return a.left-b.left;
	});
}

玩牌高手

let ints = readLine().split(",").map(i=>parseInt(i));
//let ints = "1,-5,-6,4,3,6,-2".split(",").map(i=>parseInt(i));
 
let len = ints.length;
let list = [];
 
if(ints[0]<=0){    //第一个不需要进行加法，单独处理
    list.push(0);
}else {
    list.push(ints[0]);
}
 
for(let i=1;i<len;i++){
    let count = list[i-1]+ints[i];
    if(i<3){    //前三个数
        list.push(count>0 ? count : 0);
    }else {
        list.push(count>list[i-3] ? count : list[i-3]);
    }
}
 
console.log(list[len-1]);

日志排序

var linNum = Number(readLine());
//var linNum = Number("2");
var lists = [];
 
//var test = ["01:41:8.9","1:1:09.211"];
 
for(let i=0;i<linNum;i++){
    var list = [];
    var strings = readLine().replace(".",":").split(":");
    //var strings = test[i].replace(".",":").split(":");
    for(let j=0;j<strings.length;j++){
        list.push(strings[j]);
    }
    lists.push(list);
}
 
lists.sort((a,b)=>{
    if(Number(b[0])>Number(a[0])){
        return -1;
    }
    if(Number(b[0])<Number(a[0])){
        return 1;
    }
    if(Number(b[1])>Number(a[1])){
        return -1;
    }
    if(Number(b[1])<Number(a[1])){
        return 1;
    }
    if(Number(b[2])>Number(a[2])){
        return -1;
    }
    if(Number(b[2])<Number(a[2])){
        return 1;
    }
    if(Number(b[3])>Number(a[3])){
        return -1;
    }
    if(Number(b[3])<Number(a[3])){
        return 1;
    }
    return 1;
});
 
for(let i=0;i<linNum;i++){
    console.log(lists[i][0]+":"+
                lists[i][1]+":"+
                lists[i][2]+"."+
                lists[i][3]);
}

找到它

let input = readLine().split(" ").map(Number);
//let input = "5 5".split(" ").map(Number);
 
var n = input[0];  //行
var m = input[1];  //列
var str = readLine();    //单词
//var str = "HELLOWORLD";
//let test = ["CPUCY","EKLQH","CHELL","LROWO","DGRBC"];
// var str = "Helloworld";
// let test = ["CPUCh","wolle","orldO","EKLQo","PGRBC"];
 
var len = str.length; //单词长度
let chars = [];
 
for(let i=0;i<n;i++){
    let input2 = readLine();
    //let input2 = test[i];
    chars[i] = [];
    for(let j=0;j<m;j++){
        chars[i][j] = input2.charAt(j);
    }
}
 
let res = "NO";
let start = str.charAt(0); //首字母
for(let i=0; i<n; i++){
    for(let j=0; j<m; j++){
        if(start == chars[i][j] && findNext(i, j,0, chars)==1){
            res = (i+1)+" "+(j+1);  //坐标需要再索引上+1
            break;
        }
    }
}
 
console.log(res);
    
 
function findNext( x, y, index, chars){
 
    if(index == len-1){ //所有字符都找到了
        return 1;
    }
    index++;
    let temp = str.charAt(index);
 
    if(x>0 && chars[x-1][y] == temp){   //向左一格
        chars[x-1][y] = 0;  //找过的就置为0，防止重复查找
        if(findNext(x-1, y, index, chars) == 1){
            return 1;
        }else {
            chars[x-1][y] = temp;   //如果不满足需要还原，否则会影响第二次查找
        }
    }
 
    if(x<n-1 && chars[x+1][y] == temp){ //向右一格
        chars[x+1][y] = 0;
        if(findNext(x+1, y, index, chars) == 1){
            return 1;
        }else {
            chars[x+1][y] = temp;
        }
    }
 
    if(y>0 && chars[x][y-1] == temp){   //向上一格
        chars[x][y-1] = 0;
        if(findNext(x,y-1, index, chars) == 1){
            return 1;
        }else {
            chars[x][y-1] = temp;
        }
    }
 
    if(y<m-1 && chars[x][y+1] == temp){ //向下一格
        chars[x][y+1] = 0;
        if(findNext(x,y+1, index, chars) == 1){
            return 1;
        }else {
            chars[x][y+1] = temp;
        }
    }
 
    return 0;
}

最小数字

let nums = readLine().split(",").map(i=>parseInt(i));
// let nums = "21,30,62,5,31".split(",").map(Number);
// let nums = "5,22,221".split(",").map(i=>parseInt(i));
 
let slen = nums.length;
let res = "";
var min = Number.MAX_VALUE;
 
if(slen==1){    //考虑到只有一个数的情况
    res = nums[0];
}else {
    let numList = [];
 
    for(let i=0;i<slen;i++){
        numList.push(nums[i]);
    }
 
    numList.sort((a,b)=>{return a-b});  //对数组进行排序
    let numsLen;
    if(slen==2){    //区别只有两个数的情况
        numsLen = 2;
    }else {
        numsLen = 3;
    }
 
    let ints = [];
    for(let i=0; i<numsLen; i++){
        ints[i] = numList[i];
    }
    fullArr(ints, 0, numsLen);   //对数字进行全排列找出最小值
 
    res = min;
}
console.log(res);
 
/**
 * 对ints中的数字进行全排列
 * @param ints
 * @param cursor
 * @param end
 */
function fullArr( ints, cursor, end){
 
    if(cursor == end){
        let s="";
        for(let i of ints){
            s+=i;
        }
        min = Math.min( min, Number(s));
    }else {
        for(let i=cursor; i<end; i++){
            swap(ints, cursor, i);
            fullArr(ints, cursor+1, end);
            swap(ints, cursor, i);
        }
    }
}
 
function swap( ints, a, b){
 
    let temp = ints[a];
    ints[a] = ints[b];
    ints[b] = temp;
 
}

解密犯罪时间

let s = readLine();
//let s = "18:52";
let errorTime = Number(s.substring(0,2)+s.substring(3));
let num = [];
num[0] = s.charAt(0);
num[1] = s.charAt(1);
num[2] = s.charAt(3);
num[3] = s.charAt(4);
let time;
let min = Number.MAX_VALUE;    //小于错误时间的最小时间（第二天）
let minThan = Number.MAX_VALUE;    //大于错误时间的最小时间
for(let i=0;i<4;i++){
    if(Number(num[i])>2){ //首位不能大于2
        continue;
    }
    for(let j=0;j<4;j++){
        if(Number(num[i])==2 && Number(num[j])>3){  //第一位为2时第二位则不能大于3
            continue;
        }
        for(let k=0;k<4;k++){
            if(Number(num[k])>6){ //第三位不能大于6
                continue;
            }
            for(let l=0;l<4;l++){
                time = Number(num[i]+num[j]+num[k]+num[l]);   //重构的时间
                if(time<errorTime){
                    min = Math.min(min,time);
                }else if(time>errorTime){
                    minThan = Math.min(minThan,time);
                }
            }
        }
    }
}
let res = "";
if(minThan == Number.MAX_VALUE){ //若重构的时间都小于错误时间，则时间为第二天时间
    res = String(min);
}else {
    res = String(minThan);
}
console.log(res.substring(0,2)+":"+res.substring(2));

第K个排列

let n = Number(readLine());
let k = Number(readLine());
// let n = Number("3");
// let k = Number("3");
 
var list = [];
let ints = [];
for(let i=0;i<n;i++){
    ints[i] = i+1;
}
 
/**
 * cursor:从第一个数开始
 */
fullArray(ints,0,n-1);
 
list.sort((a,b)=>{  //对list进行升序排序
    return b>a ? -1: 1;
});
 
console.log(list[k-1]);
 
function swap( arr, a, b){
    let temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
 
/**
 * 这是经典的全排列递归算法
 * @param array 需要排列的数组
 * @param cursor  初始位置
 * @param end   结束位置
 */
function fullArray(array, cursor, end) {
    if (cursor == end) {    //此次排列完成
        let s = "";
        for (let a of array) {
            s+=a;
        }
        list.push(Number(s));
    } else {
        for (let i = cursor; i <= end; i++) {
            swap(array, cursor, i); //将数组下标为cursor和下标为i的数据进行交换
            fullArray(array, cursor + 1, end);
            swap(array, cursor, i); // 用于对之前交换过的数据进行还原
        }
    }
}

最大N个数与最小N个数的和

let m = Number(readLine());
let nums = readLine().split(" ").map(i=>parseInt(i));
let n = Number(readLine());
// let m = Number("5");
// let nums = "95 88 83 64 100".split(" ").map(i=>parseInt(i));
// let n = Number("2");
 
let treeSet = [];
 
for(let i=0;i<m;i++){
    if(treeSet.includes(nums[i])){
        continue;
    }
    treeSet.push(nums[i]);
}
 
treeSet.sort((a,b)=>{return a-b});
let count = 0;
 
if(treeSet.length<n*2){ //treeset长度小于n*2则表示最大最小数组有重复值
    count = -1;
}else {
    for(let i=0;i<n;i++){
        count += treeSet.shift() + treeSet.pop(); //最小和最大两个数之和
    }
}
 
console.log(count);

喊7的次数重排

let s = sc.radLine().split(" ").map(i=>parseInt(i));;
//let s = "0 0 0 2 1".split(" ").map(i=>parseInt(i));
let len = s.length;
 
let ints = new Array(len).fill(0);
 
let num = 0;
for(let i=0;i<len;i++){
    num += s[i];     //计算出符合的次数
}
let step = 7;   //直接从7开始
while (num>0){
    if(step%7==0 || String(step).indexOf("7")!=-1){
        ints[(step-1)%len]++;      //同过数组长度算出符合的下标
        num--;      //符合的次数递减
    }
    step++;     //报数的次数递增
}
 
let res = "";
for(let i=0;i<len;i++){
    res+=String(ints[i]);
    if(i == len-1){
        break;
    }
    res+=" ";
}
 
console.log(res);

数据二叉树

let ints = readLine().split(" ").map(Number);
//let ints = "3 5 7 -1 -1 2 4".split(" ").map(Number);
 
let len = ints.length;
let idx = -1;   //最小叶子节点索引
 
for (let i = 0; i < len; i++) {
    if (ints[i] == -1) {    //空节点直接返回
        continue;
    }
    if ( (i+1)*2+1 > ints.length ||
            (ints[(i+1)*2-1] == -1 && ints[(i+1)*2] == -1)) {  //判断是否为叶子节点
        if (idx == -1 || ints[idx] > ints[i]) {
            idx = i;
        }
    }
}
 
let stack = [];  //使用栈先进先出
stack.push(idx);
 
//用叶子节点向上推到根节点
while (idx>0) {
    if ((idx+1)%2 == 0) {
        idx = (idx+1)/2 - 1;
        stack.push(idx);
    } else {
        idx = idx/2 - 1;
        stack.push(idx);
    }
}
 
let ret = "";
while (stack.length!=0) {
    ret += " " + ints[stack.pop()];
}
 
console.log(ret.substring(1));

最大矩阵和

let n = Number(readLine());   //行
let m = Number(readLine());   //列
//let n = Number("3");   //行
//let m = Number("4");   //列
 
//let test = ["-3,5,-1,5","2,4,-2,4","-1,3,-1,3"];
 
let ints = [];
 
for(let i=0;i<n;i++){
    //let input = readLine().split(",").map(i=>parseInt(i));
    let input = test[i].split(",").map(i=>parseInt(i));
    let hang = [];
    for(let j=0;j<m;j++){
        hang[j] = input[j];
    }
    ints[i] = hang;
}
 
let max = 0;
for(let start_row = 0;start_row<n;start_row++){   //开始行
    for(let start_col = 0;start_col<m;start_col++){   //开始列
        for(let end_row = start_row;end_row<n;end_row++){   //结束行
            let jisuan = 0; //矩阵和
            for(let end_col = start_col;end_col<m;end_col++){   //结束列
                let rowindex = end_row; //将结束行作为边界
                while (rowindex>=start_row){    //最后一行不能超过开始行
                    jisuan+=ints[rowindex][end_col];    //从结束行向上遍历到开始行
                    rowindex--;
                }
                max = Math.max(max,jisuan);
            }
        }
    }
}
 
console.log(max);

磁盘容量排序

let n = Number(readLine());
//let n = Number("3");
 
let num = [];    //用来放置磁盘索引和单位转换成M之后的数值
let map = []; //用来放置磁盘索引和磁盘原数值
//let strs = ["1G","2G","1024M"];
 
for (let i = 0; i < n; i++) {
    let sum = 0;
    let index = -1;
    let str = readLine();
    //let str = strs[i];
    map[i + 1] = str;
    for (let j = 0; j < str.length; j++) {
        if (str.charAt(j) == 'M') {
            sum += Number(str.substring(index + 1, j));
            index = j;
        } else if (str.charAt(j) == 'G') {
            sum += Number(str.substring(index + 1, j)) * 1024;
            index = j;
        } else if (str.charAt(j) == 'T') {
            sum += Number(str.substring(index + 1, j)) * 1024 * 1024;
            index = j;
        }
    }
    num[i] = [];
    num[i][0] = i + 1;
    num[i][1] = sum;
 
}
 
num.sort((a,b)=>{
    return a[1]-b[1];
});  //对二维数组进行排序
 
for (let i = 0; i < n; i++) {
    console.log(map[num[i][0]]);

一种字符串压缩表示的解压

let str = readLine();
//let str = "aa10v4a";
 
let res = "";
let num = -1;   //压缩数字（初始化为-1）
let len = str.length;
 
let numReg = new RegExp("^[0-9]{1}$");
let caseReg = new RegExp("^[a-z]{1}$");
 
for(let i=0; i<len; i++){
    let c = str[i];
    if(numReg.test(c)){   //判断是否为数字
        let numTemp = Number(c);
        if(i == len-1){   //数字是最后一个，则输出error
            res = "!error";
            break;
        }else if(num == -1){
            if(numTemp==0 || (numTemp<3 && numTemp>0 && caseReg.test(str[i+1]))){
                res = "!error";
                break;
            }else{
                num = Number(c);
            }
        }else{
            num = Number(String(num) + c);  //多位数
        }
    }else if(caseReg.test(c)){ //判断是否为小写字母
        if(num>=3){ //存在压缩数字则进行解压
            if(i!=len-1 && c==str[i+1]){ //判断后面一个字符是否与之相等，如果相等则error
                res = "!error";
                break;
            }
            for(let j=0; j<num; j++){   //按照数字进行解压
                res+=c;
            }
            num = -1;   //数字需要重置
        }else {
            if(i<len-2 && c==str[i+1] && c==str[i+2]){  //不能出现相邻的三个及以上字符相同
                res = "!error";
                break;
            }
            res += c;
        }
    }else { //非数字和非小写字母返回error
        res = "!error";
        break;
    }
}
 
console.log(res);

最大足迹

//let s = readline();
let s = "ferg(3,10)a13fdsf3(3,4)f2r3rfasf(5,10)";
 
let r = 0;
let l = 0;
let list = [];
let lists = [];
 
for(let i=0; i<s.length; i++){
    if(s.charAt(i)=='('){
        l = i+1;
    }else if(s.charAt(i)==')'){
        r = i;
    }
    if(r!=0){
        let ss = s.substring(l, r).split(",");  //利用小括号下标提取出坐标
        let j = Number(ss[0]);
        let w = Number(ss[1]);
        if(j>0 && j<1000 && w>0 && w<1000 && ss[0].charAt(0)!='0' && ss[1].charAt(0)!='0'){
            list.push(j);
            list.push(w);
            lists.push(list);
            list = [];
        }
        l = r =0;
    }
}
 
if(lists.length == 0){
    console.log("(0,0)");
}else {
    lists.sort((a,b)=>{ //对坐标进行降序排序
        let ax = a[0]*a[0]+a[1]*a[1];
        let bx = b[0]*b[0]+b[1]*b[1];
        if(bx>=ax){
            return 1;
        }
        return -1;
    });
 
    console.log("("+lists[0][0]+","+lists[0][1]+")");
}

计算面积

let n = Number(readLine());
let e = Number(readLine());
// let n = Number("2");
// let e = Number("4");
 
let list = [];
 
for(let i=0; i<n; i++){
    let ints = [];
    ints[0] = Number(readLine());
    ints[1] = Number(readLine());
    list.push(ints);
}
 
//let list = [[0,1],[2,-2]];
 
let res = 0;
let high = 0;
 
for(let i=1; i<list.length; i++){
    high += list[i-1][1];   //Y轴方向的运动轨迹(相当于高)
    res += Math.abs((list[i][0]-list[i-1][0])*high);
}
 
res += Math.abs((e - list[n-1][0])*(high + list[n-1][1]));
 
console.log(res);

最长广播响应

let input = readLine().split(" ").map(Number);
//let input = "5 7".split(" ").map(Number);
let m = input[0];
let n = input[1];
 
let list = []; //信号集合
for(let i=1; i<=m; i++){
    list.push(i);
}
 
var linkList = [];   //信号联通集合
//let test = ["2 1","1 4","2 4","2 3","3 4","3 5","4 5"];
for(let i=0; i<n; i++){
    let ints = readLine().split(" ").map(Number);
    //let ints = test[i].split(" ").map(Number);
    linkList.push(ints);
}
 
let start = Number(readLine());
//let start = Number("2");
list.splice(start-1, 1);   //将广播节点移除
let max = 0;    //所有节点传播的最小时延
 
for(let i=0; i<m-1; i++){
    var min = Number.MAX_VALUE;    //广播的节点到各个节点之间的最小传播时延
    time(start, list[i], 0);
    max = Math.max(0, min);
}
 
console.log(max*2);
 
function time( start, end, count){
 
    for(let i=0; i<n; i++){
        let u = linkList[i][0];
        let v = linkList[i][1];
        if(u == start){
            if(v == end){
                min = Math.min(min, count+1);
                if(count==0){   //一个时延为最小时延，下面就不需要再找了
                    break;
                }
            }else {
                time(v, end, count+1);
            }
        }
    }
}

求最多可以派出多少支团队

let n = Number(readLine());
let list = readLine().split(" ").map(Number);
let m = Number(readLine());
// let n = Number("5");
// let list = "3 1 5 7 9".split(" ").map(Number);
// let m = Number("8");
 
list.sort();
let count = 0;  //团队个数
let index;
 
for(index = n-1; index>=0; index--){
    if(list[index] >= m){ //个人能力大于最低要求，则符合
        count++;
    }else {
        break;  //不符合直接跳出
    }
}
 
for(let i=0, j=index; i<j; ){
    if(list[i]+list[j] >= m){
        count++;
        i++;
        j--;
    }else {
        i++;
    }
}
 
console.log(count);

数字反转打印

let n = Number(readLine());
//let n = Number("30");
 
let lists = []; //总集合
 
for(let i=1;i<=n;i++){      //为了方便i初始值设为1
 
    let list = [];  //每一行的数据（不使用字符串，是方便后续反转）
    let fn = firstNum(i);     //先计算出行头数字
 
    lists.forEach(x=>{
        x.unshift("    ");        //每加一行，前面的所有行前面都加一个"    "
    });
 
    for(let j=0;j<i;j++){
        let temp = fn++ + "***";        //每个数后面都加三个*，因为至少一位数，所以只要加三个
        list.push(temp.substring(0,4));     //头数向后递加，只取前面四个字符串
        if(j!=i-1){
            list.push("    ");       //除了最后一个数，其余全部加上"    "
        }
    }
 
    if(i%2==0){
        list.reverse();      //偶数行进行翻转
    }
 
    lists.push(list);
}
 
lists.forEach(x=>{
    let res = "";        //把所有行转化成字符串类型
    for(let i=0;i<x.length;i++){
        res+=x[i];
    }
    console.log(res);
});
 
 
function firstNum(n){
    if(n == 1){
        return 1;
    }
    return firstNum(n-1) + n - 1;       //根据规律推出第n行的头为n-1的头加上n-1
}

火锅

let n = Number(readLine());
let m = Number(readLine());
// let n = Number("4");
// let m = Number("1");
 
let footList = [];
//let test = ["1 2","1 3","2 3","2 2"];
 
for(let i=0;i<n;i++){
    let nums = readLine().split(" ").map(i=>parseInt(i));
    //let nums = test[i].split(" ").map(i=>parseInt(i));
    footList.push(nums[0]+nums[1]); //所有菜的最佳时机
}
 
let list = [];  //对食物数组进行去重和排序
footList.forEach(v=>{
    if(!list.includes(v)){
        list.push(v);
    }
})
 
list.sort();
 
let count = 0;  //吃菜的次数
let len = list.length;
let time = 0;   //吃菜的时间
for(let i=0;i<len;i++){
    if(time <= list[i]){    //吃菜的时间小于菜的最佳时机，表示可以吃上
        count++;
        time = list[i]+m;   //这个菜吃完需要过m秒才能再次吃菜
    }
}
 
console.log(count);

敏感字段加密

let n = Number(readLine());
let s = readLine();
// let n = Number("2");
// let s = 'aaa_password_"a12_45678"_timeout__100_""_';
 
let len = s.length;
let list = [];
let temp = "";
let yh = false; //是否有引号
 
for(let i=0; i<len; i++){
    if(s.charAt(i)!='_'){
        if(s.charAt(i)=='\"'){
            yh = !yh;
        }
        temp += s.charAt(i);  //非下划线直接拼接字符
        if(i==len-1){
            list.push(temp); //最后一位直接push
        }
    }else {
        if(temp==""){
            continue;   //字符串为空则进入下个循环
        }
        if(yh){
            temp+=s.charAt(i);  //引号内的下划线直接拼接字符串
        }else {
            list.push(temp); //push字符串
            temp = "";  //置空为下次使用
        }
    }
}
 
let count = list.length;
 
if(n>=count){
    console.log("ERROR");
}else {
    let res = "";
    for(let i=0; i<count; i++){
        if(i==n){
            res+="******";  //对应下标的字符串进行加密
        }else {
            res += list[i];   //拼接字符串
        }
        if(i != list.length-1){
            res += "_";   //非最后一个后面需要加下划线
        }
    }
    console.log(res);
}

九宫格按键输入

let s = readLine();
//let s = "#222233";
 
var temp = "";   //上一次的数字按键
var sb = "";   //输出字符串
var count = 0;  //按键次数
var strings = [" ",",.","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"];
let isEn = false;   //英文输入
let len = s.length;
 
    for(let i=0;i<len;i++){
        let c = s.charAt(i); //本次的按键
        if(c == "#"){  //中英文切换
            isEn = !isEn;
            if (temp!=""){  //temp有值，说明有字符需要输出
                uotput(temp);
                count = 0;  //输出完，count和temp初始化
                temp = "";
            }
            continue;
        }
        if(isEn){
            /**
             * 英文输入
             */
            if(temp == ""){
                if(c == "/"){
                    continue;
                }
                temp = c;
                count = 1;
                if(i==len-1){   //最后一个
                    uotput(c);
                    break;
                }
            }else if(temp != c){   //按键数字发生变化，需要输出字符
                uotput(temp);
                if(c == "/"){
                    count = 0;
                    temp = "";
                }else {
                    count = 1;
                    temp = c;
                    if(i==len-1){   //最后一个
                        uotput(c);
                        break;
                    }
                }
            }else {
                count++;
                if(i==len-1){   //最后一个
                    uotput(c);
                }
            }
        }else {
            /**
             * 数字输入
             */
            if(c == "/"){  //数字中的/没有意义
                continue;
            }
            sb += c;   //数字直接输出
        }
    }
 
    console.log(sb);
    
function uotput( str){  //输出文字
 
    let strIndex = Number(str);   //上一次的按键（数字）
    if(strIndex==0){
        sb += " "; //0只有空格
    }else {
        let strLen = strings[strIndex].length;    //数字上的字符长度
        let index = count%strLen == 0 ? strLen-1 : count%strLen-1; //找到数字按钮上的对应字母位置
        sb += strings[strIndex].charAt(index);
    }
}

报数游戏

let n = Number(readLine());
 
//let n = Number("3");
 
let list = [];
 
for(let i=1;i<=100;i++){
    list.push(i);    //100个人的集合
}
 
let i=n-1;  //初始下标（集合下标从0开始，所有要-1）
 
while (list.length>=n){ //如果人数大于等于n就需要继续
        list.splice(i,1); //移除报n的人
        i--;    //因为少了一个人所以后面的所有下标都要向前移一位
        i = i+n<list.length ? i+n : i+n-list.length;  //因为是围成的圆圈，所以下标越界后需要绕到最前面
}
 
console.log(list);

叠积木

let strings = readLine().split(" ");
//let strings = "4 5 3 6".split(" ");
 
let list = [];
let count = 0;  //积木总长度
let len = strings.length;
 
for(let i=0;i<len;i++){
    let n = Number(strings[i]);
    count += n;
    list.push(n);    //所有积木集合
}
 
list.sort((a,b)=>{return a-b});
let min = list[len-1];  //最小宽度
let max = list[0] + list[len-1];    //最大宽度（因为最多是两个积木拼接）
let res = -1;
 
for(let i=min;i<=max;i++){
    if(count%i==0){
        let copyList = copyArr(list); //因为要对list进行多次操作，需要copy一下
        if(isSuccess(copyList,i)){
            res = count/i;
            break;
        }
    }
}
 
console.log(res);
 
function copyArr(list){
 
    let len = list.length;
    let copyList = [];
 
    for(let i=0;i<len;i++){
        copyList.push(list[i]);
    }
 
    return copyList;
}
 
/**
 *
 * @param list 积木集合
 * @param n 积木所需宽度
 * @return
 */
function isSuccess(list, n){
 
    let isTrue = true;
 
    while (list.length >0 && isTrue){
        let i = list.length-1;
        if(n==list[i]){
            list.splice(i,1); //最长的一根积木符合要求则剔除进行下次循环
        }else if(n == list[i]+list[0]){
            list.splice(i,1); //最长一根跟最短一根积木之和符合要求则剔除两个积木进行下次循环
            list.splice(0,1);
        }else {
            isTrue = false; //上面两个都不符合则表示无法完成一堵墙
        }
    }
 
    return isTrue;
}

工号不够用了怎么办

function getWorkNum(total,charNum) {
    // 如果所需人数少于26人，那么工牌的数字长度最多不超过1即可，因为题目要求不能纯数字或纯字    
    //母，因此长度至少为1
    if(total <= 26) {
        return 1
    }
    // 用del表示可能的情况数
    let del = 1 ;
    // 当字母长度为1时，因为字母总共有26个，因此初始的仅凭给定的字母可以拼凑的情况有26种。
    // 注意：假如给定的字母长度不为1，那么可以拼凑的情况应该是del = del * 26,因为一个字母跟
    // 另一个字母拼接有26种情况，26个字母那么就是有26*26种情况，以此类推。
    for(let i = 0 ; i < charNum ; i++) {
        del*=26
    }
    // 用r来表示数字的长度。
    let r = 1 ; 
    // 上面的到的del是还没有跟数字进行拼接的，因此这里将数字初始值长度设置为1，长度为1的数字跟
    // 上面得到的字母情况del拼接，因为数字为0-9总共有10个，因此得到的一个数字长度跟字母拼接
    // 的总共情况为del*10。
    del*=10;
    // 判断得到的情况，也即工号数量是否符合题目要求，如果不满足，说明还需要继续添加数字进行拼接，
    // 因此需要将数字长度r++,通过while循环不断进行判断,判断添加了多一个数字长度得到的工号数量
    // 是否满足要求,如果满足,就退出循环,返回r即为工号最少需要的数字长度
    while(del < total) {
        del *= 10 ; 
        r++ ; 
    }
    return r
}
 
console.log(getWorkNum(260,1))  //1

构成的正方形的数量

let n = Number(readLine());
//let n = Number("4");
 
let list = [];
//let test = ["0 0","1 2","3 1","2 -1",];
 
for(let i=0;i<n;i++){
    let ints = readLine().split(" ").map(i=>parseInt(i));
    //let ints = test[i].split(" ").map(i=>parseInt(i));
    list.push(ints);
}
 
let count = 0;
let len = list.length;
if(len>3){
    for(let i=0;i<len-3;i++){
        for(let j=i+1;j<len-2;j++){
            for(let k=j+1;k<len-1;k++){
                for(let l=k+1;l<len;l++){
                    if(isZFX(list[i],list[j],list[k],list[l])){
                        count++;
                    }
                }
            }
        }
    }
}
 
console.log(count);
 
function isZFX( a, b, c, d){
 
    let list = [];
    list.push(a);
    list.push(b);
    list.push(c);
    list.push(d);
    let map = [];
    let temp = 0;
    let count = 0;
    for(let i=0;i<3;i++){
        for(let j=i+1;j<4;j++){
            let x = list[i][0]-list[j][0];
            let y = list[i][1]-list[j][1];
            let len = x*x + y*y;    //求四个坐标六个向量的长度
            temp = len;
            if(map[temp]!=undefined){
                map[temp] = map[temp]+1;
            }else{
                map[temp] = 1;
                count++;
            }   
        }
    }
 
    if(count ==2 && (map[temp]==2 || map[temp]==4)){    //六条向量有四条相等且另外两条也相等则构成正方形
        return true;
    }
 
    return false;
}

根据某条件聚类最少交换次数_

let ints = readLine().split(" ").map(Number);
let n = Number(readLine());
// let ints = "1 3 1 4 0".split(" ").map(Number);
// let n = Number("2");
 
let len = ints.length;
let num = 0;    //满足条件的数字个数
 
for(let i=0; i<len; i++){
    if (ints[i] < n) {
        num++;
    }
}
 
let res = Number.MAX_VALUE;
for(let i=0; i<len-num+1; i++){
    let count = 0;
    for(let j=0; j<num; j++){
        if(ints[i+j]>=n){
            count++;
        }
    }
    res = Math.min(res, count);
}
 
console.log(res);

跳格子游戏

let n = Number(readLine());
//let n = Number("2");
//let test = ["1 0","0 1"];
 
let list = []
 
while (readLine()){
    list.push(readLine().split(" ").map(Number));
}
// for(let i=0;i<test.length;i++){
//     list.push(test[i].split(" ").map(Number));
// }
 
let isTrue = true;
let len = list.length;  //依赖关系的键值对长度
 
for (let i=0;i<len;i++){
    if(isBH(list[i])){
        isTrue = false;
        break;
    }
}
 
console.log(isTrue ? "yes" : "no");
 
/**
 * {4,3}{0,4}{2,1}{3,2}{2,0}
 * 遍历所有的键值对
 *例：
 *  从第一个{4,3}开始
 *  {4,3}->{3,2}  {4,3,2}
 *      ┊
 *      --{4,3,2}->{2,1}  {4,3,2,1}
 *      ┊
 *      --{4,3,2}->{2,0} {4,3,2,0}
 *          ┊
 *          --{4,3,2,0}->{0,4}  {4,3,2,0}中包含4产生闭环，返回false
 */
function isBH( listC){
 
    for(let i=0; i<list.length; i++){
 
        let temp = list[i];
        if(temp[0] == listC[listC.length-1]){
            if(listC.includes(temp[1])){
                return true;
            }
            listC.push(temp[1]);
            isBH(listC);
        }
    }
 
    return false;
}

找最小数

 function removeKdigits(num, k) {
            let n = num.length
            if (n <= k) return '0'
            let stack = []
            for (let i = 0; i < n; i++) {
                while (k && stack.length && num[i] < stack[stack.length - 1]) {
                    k--
                    stack.pop()
                }
                if (stack.length || num[i] !== '0') { // 如果是 空栈, '0'就不要加入了
                    stack.push(num[i])
                }
            }
            while (k--) stack.pop()
            return stack.join('') || '0'
        };


        console.log(removeKdigits('10200', 1))