真题代码

001 如果三个正整数A、B、C ,A²+B²=C²则为勾股数

// 题目 001
// import java.util.Scanner;
/**
 如果三个正整数A、B、C ,A²+B²=C²则为勾股数
如果ABC之间两两互质，即A与B，A与C，B与C均互质没有公约数，
则称其为勾股数元组。
请求出给定n~m范围内所有的勾股数元组
 */
      function solution(n, m) {
        let count = 0;
        for (let a = n; a < m - 1; a++) {
          for (let b = a + 1; b < m; b++) {
            for (let c = b + 1; c < m + 1; c++) {
              if (relativelyPrime(a, b) &&
                  relativelyPrime(b, c) &&
                  relativelyPrime(a, c) &&
                  a * a + b * b == c * c) {
                count++;
                console.log(a, b, c);
              }
            }
          }
        }
        if (count == 0) {
          console.log("Na");
        }
      }
      function relativelyPrime(x, y) {
        let min = Math.min(x, y);
        let sqrt = Math.sqrt(min);
        for (let i = 2; i < sqrt; i++) {
          if (x % i == 0 && y % i == 0) {
            return false;
          }
        }
        return true;
      }
      function main() {
        solution(1, 20);
    }
      main();

002 给定两个整数数组，arr1、arr2，数组元素按升序排列；
假设从arr1、arr2中分别取出一个元素，可构成一对元素；
现在需要取出k对元素，并对取出的所有元素求和，计算和的最小值；
注意：两对元素对应arr1、arr2的下标是相同的，视为同一对元素。

// 题目 001
// import java.util.Scanner;
/**
 如果三个正整数A、B、C ,A²+B²=C²则为勾股数
如果ABC之间两两互质，即A与B，A与C，B与C均互质没有公约数，
则称其为勾股数元组。
请求出给定n~m范围内所有的勾股数元组
 */
function solution(n, m) {
  let count = 0;
  for (let a = n; a < m - 1; a++) {
    for (let b = a + 1; b < m; b++) {
      for (let c = b + 1; c < m + 1; c++) {
        if (relativelyPrime(a, b) &&
          relativelyPrime(b, c) &&
          relativelyPrime(a, c) &&
          a * a + b * b == c * c) {
          count++;
          console.log(a, b, c);
        }
      }
    }
  }
  if (count == 0) {
    console.log("Na");
  }
}
function relativelyPrime(x, y) {
  let min = Math.min(x, y);
  let sqrt = Math.sqrt(min);
  for (let i = 2; i < sqrt; i++) {
    if (x % i == 0 && y % i == 0) {
      return false;
    }
  }
  return true;
}
solution(1, 20);
// 002 
// 给定两个整数数组，arr1、arr2，数组元素按升序排列；
// 假设从arr1、arr2中分别取出一个元素，可构成一对元素；
// 现在需要取出k对元素，并对取出的所有元素求和，计算和的最小值；
// 注意：两对元素对应arr1、arr2的下标是相同的，视为同一对元素。
function solution(arr1, arr2, k) {
  let sums = [];
  arr1.forEach(item => {
    arr2.forEach(ele => {
      sums.push(Number(item) + Number(ele));
    })
  });
  console.log(sums);
  sums.sort();
  let res = 0;
  for (let i = 0; i < k; i++) {
    res += sums[i];
  }
  console.log(res);
}
solution([1, 1, 2], [1, 2, 3], 2);
// 003 TLV编码是按TagLengthValue格式进行编码的  (代写)
function solution(tag, source) {
  let p = 0;
  while (p < source.length) {
    let curTag = source.substring(p, p + 2);
    let lenHEX = source.substring(p + 6, p + 8) + source.substring(p + 3, p + 5);
    let lenDEC = parseInt(lenHEX, 16);
    console.log(lenDEC);
    if (tag === curTag) {
      let value = source.substring(p + 9, p + 9 + lenDEC * 3);
      console.log(value);
    }
    p += 9 + lenDEC * 3;
  }
}
solution(31, "32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC");
// 004 一天一只顽猴想要从山脚爬到山顶
function solution(n) {
  let step1 = 1,
    step2 = 1,
    step3 = 2;
  let step4 = n == 1 || n == 2 ? 1 : 2;
  for (let i = 4; i <= n; i++) {
    step4 = step3 + step1;
    step1 = step2;
    step2 = step3;
    step3 = step4;
  }
  console.log(step4);
}
solution(50);
// 005
/**
为了充分发挥Gpu算力，
需要尽可能多的将任务交给GPU执行，
 */
function solution(n, jobCount) {
  let time = 0;
  let remaining = 0;
  jobCount.forEach(count => {
    if (count + remaining > n) {
      remaining = count + remaining - n;
    } else {
      remaining = 0;
    }
    time++;
  })
  time += remaining / n;
  if (remaining % n > 0) {
    time++;
  }
  console.log(time);
}
solution(3, [1, 2, 3, 4, 5]);
// 006 
function solution(h, highs) {
  highs.sort((h1, h2) => {
    let diff1 = Math.abs(h1 - h);
    let diff2 = Math.abs(h2 - h);
    return diff1 == diff2 ? h1 - h2 : diff1 - diff2;
  });
  for (let i = 0; i < highs.length; i++) {
    console.log(highs[i]);
    if (i != highs.length - 1) {
      console.log(" ");
    }
  }
}
solution(100, [95, 96, 97, 98, 99, 101, 102, 103, 104, 105]);
// 007
function solution(line, l, r) {
  let words = line.trim().split(" ");
  if (r > words.length - 1) r = words.length - 1;
  if (words.length == 0 ||
    l < 0 ||
    r - l <= 0) {
    console.log("EMPTY");
    return;
  }
  while (l < r) {
    let tmp = words[l];
    words[l] = words[r];
    words[r] = tmp;
    l++;
    r--;
  }
  for (let i = 0; i < words.length; i++) {
    console.log(words[i]);
    if (i != words.length - 1) {
      console.log(" ");
    }
  }
}
solution("I am a developer.", 0, 3);
// 008
function pay(m, n) {
  let split = m.split(",");
  let sum = n;
  let size = split.length;
  let result = -1;
  if (size >= 3) {
    let irr = [];
    for (let i = 0; i < size; i++) {
      irr[i] = Number(split[i]);
    }
    for (let i = 0; i < (size - 2); i++) {
      for (let j = i + 1; j < (size - 1); j++) {
        for (let k = j + 1; k < size; k++) {
          let a = irr[i];
          let b = irr[j];
          let c = irr[k];
          if (a + b + c < sum) {
            result = Math.max(result, a + b + c);
          }
        }
      }
    }
  }
  console.log(result);
}
pay("23,26,36,27", 78);
// 009
function solution(str1, str2) {
  let chars1 = str1.split('');
  chars1.sort();
  let chars2 = str2.split('');
  let set = new Set();
  for (let c of chars2) {
    set.add(c);
  }
  let res = new Set();
  for (let c of chars1) {
    if (set.has(c)) {
      res.add(c);
    }
  }
  for (let Character of res) {
    console.log(Character);
  }
}
solution("fach", "bbaaccddfg");
// 010
function solution(ints) {
  let c = ints[0];
  let b = ints[1];
  let map = new Map();
  for (let i = 2; i < ints.length; i++) {
    let r = intByteSum(ints[i]) % b;
    if (r < c) map.set(r, map.has(r) ? map.get(r) + 1 : 1);
  }
  let max = 0;
  for (let value of map.values()) {
    if (value > max) max = value;
  }
  console.log(max);
}
function intByteSum(x) {
  let sum = 0;
  for (let i = 0; i < 4; i++) {
    sum += (x >> (i * 8));
  }
  console.log(sum);
  return sum;
}
solution([3, 4, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265]);
solution([1, 4, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265]);
// 011
function solution(treeStr) {
  let split = ("0 " + treeStr).split(" ");
  let min = 2147483647;
  let minPos = 0;
  for (let i = 2; i < split.length; i++) {
    let tmp = Number(split[i]);
    if (tmp != 0 && tmp != -1 && tmp < min) {
      min = tmp;
      minPos = i;
    }
  }
  let path = [];
  back(split, minPos, path);
  for (let i = path.length - 1; i >= 0; i--) {
    console.log(path[i]);
    if (i != 0) {
      console.log(" ");
    }
  }
}
function back(split, minPos, path) {
  path.push(split[minPos]);
  if (minPos == 1) {
    return;
  }
  if (minPos % 2 == 0) {
    back(split, minPos / 2, path);
  } else {
    back(split, (minPos - 1) / 2, path);
  }
}
solution("3 5 7 -1 -1 2 4");
solution("5 9 8 -1 -1 7 -1 -1 -1 -1 -1 6");
// 012
function solution(weightsStr, capacity) {
  let split = weightsStr.split(",");
  let weights = [];
  for (let i = 0; i < split.length; i++) {
    weights[i] = Number(split[i]);
  }
  weights.sort((a, b) => a - b);
  let sum = 0;
  let i = 0;
  while (i < weights.length) {
    if (sum + weights[i] <= capacity) {
      sum += weights[i++];
    } else {
      break;
    }
  }
  console.log(i);
}
solution("5,10,2,11", 20);
// 013
/*
二叉树也可以用数组来存储
给定一个数组
树的根节点的值储存在下标1
对于储存在下标n的节点，
他的左子节点和右子节点分别储存在下标2*n和2*n+1
并且我们用-1代表一个节点为空
给定一个数组存储的二叉树
试求从根节点到最小的叶子节点的路径
路径由节点的值组成
输入描述
输入一行为数组的内容
数组的每个元素都是正整数，元素间用空格分割
注意第一个元素即为根节点的值
即数组的第n元素对应下标n
下标0在树的表示中没有使用
所以我们省略了
输入的树最多为7层
输出描述
 输出从根节点到最小叶子节点的路径上各个节点的值
 由空格分割
 用例保证最小叶子节点只有一个
 例子
  输入
  3 5 7 -1 -1 2 4
  输出
   3 7 2
  例子
   输入
  5 9 8 -1 -1 7 -1 -1 -1 -1 -1 6
   输出
  5 8 7 6
 */
function main(args) {
  let split = args.split(" ");
  let tree = [];
  tree.push(2147483647);
  for (let s of split) {
    tree.push(Number(s));
  }
  let min = 2147483647;
  for (let i of tree) {
    if (i != 0 && i != -1 && i < min && i !== (tree[1])) min = i;
  }
  let index = tree.indexOf(min);
  let res = [];
  res.push(tree[index] + "");
  for (let i = index; i > 1;) {
    if (i % 2 == 0) i = i / 2;
    else i = (i - 1) / 2;
    res.push(tree[i] + "");
  }
  let builder = [];
  for (let i = res.length - 1; i >= 0; i--) {
    builder.push(res[i]);
  }
  console.log(builder);
  console.log(builder.join(','));
}
main("3 5 7 -1 -1 2 4");
main("5 9 8 -1 -1 7 -1 -1 -1 -1 -1 6");
// 014
/*
一辆运送快递的货车
运送的快递放在大小不等的长方体快递盒中
为了能够装载更多的快递同时不能让货车超载
需要计算最多能装多少个快递
注：快递的体积不受限制
快递数最多1000个
货车载重最大50000
输入描述
 第一行输入每个快递的重量
 用英文逗号隔开
 如 5,10,2,11
 第二行输入货车的载重量
  如 20
输出描述
 输出最多能装多少个快递
 如 3
 示例一
  输入
  5,10,2,11
  20
  输出
  3
 */
function main(args, num) {
  let split = args.split(",");
  let ints = [];
  for (let i = 0; i < split.length; i++) {
    ints[i] = Number(split[i]);
  }
  ints.sort((a, b) => a - b);
  console.log(ints);
  let sum = 0;
  for (let i = 0; i < ints.length; i++) {
    sum += ints[i];
    if (sum > num) {
      console.log(i);
      break;
    }
  }
}
main("5,10,2,11", 20);
// 015
function main(args) {
  /*
  给航天器一侧加装长方形和正方形的太阳能板(图中的斜线区域)
  需要先安装两个支柱(图中的黑色竖条)
  再在支柱的中间部分固定太阳能板
  但航天器不同位置的支柱长度不同
  太阳能板的安装面积受限于最短一侧的那支支柱的长度
  现提供一组整型数组的支柱高度数据
  假设每个支柱间的距离相等为一个单位长度
  计算如何选择两根支柱可以使太阳能板的面积最大
  输入描述
  10,9,8,7,6,5,4,3,2,1
  注释，支柱至少有两根，最多10000根，能支持的高度范围1~10^9的整数
  柱子的高度是无序的
  例子中的递减是巧合
  输出描述
  可以支持的最大太阳板面积:(10m高支柱和5m高支柱之间)
  25
  示例1
  输入
  10,9,8,7,6,5,4,3,2,1
  输出
  25
  备注 10米高支柱和5米高支柱之间宽度为5，高度取小的支柱高度也是5
  面积为25
  任取其他两根支柱所能获得的面积都小于25 所以最大面积为25
   */
  let split = args.split(",");
  let ints = [];
  for (let i = 0; i < split.length; i++) {
    ints[i] = Number(split[i]);
  }
  let res = 0;
  for (let i = 0; i < split.length; i++) {
    for (let j = i + 1; j < split.length; j++) {
      let area = Math.min(ints[i], ints[j]) * (j - i);
      if (area > res) res = area;
    }
  }
  console.log(res);
}
main("10,9,8,7,6,5,4,3,2,1");
// 016 (待定)
/*
        单词接龙的规则是
        可用于接龙的单词 首字母必须要与前一个单词的尾字母相同
        当存在多个首字母相同的单词时，取长度最长的单词
        如果长度也相等，则取字典序最小的单词
        已经参与接龙的单词不能重复使用
        现给定一组全部由小写字母组成的单词数组
        并指定其中一个单词为起始单词
        进行单词接龙
        请输出最长的单词串
        单词串是单词拼接而成的中间没有空格
        输入描述
        输入第一行为一个非负整数
        表示起始单词在数组中的索引k
        0<=k<N
        输入的第二行为非负整数N
        接下来的N行分别表示单词数组中的单词
        输出描述，
        输出一个字符串表示最终拼接的单词串
        示例
        0
        6
        word
        dd
        da
        dc
        dword
        d
        输出
        worddwordda
        说明 先确定起始单词word 在接dword
        剩余dd da dc 则取da
       示例2
        4
        6
        word
        dd
        da
        dc
        dword
        d
        输出
        dwordda
        单词个数1<N<20
        单个单词的长度  1~30
         */
function main(k, N, list2) {
  let builder = [];
  let head = list2[k];
  builder.push(head);
  list2.slice(k, k + 1);
  let list = new Set(list2);
  let tail = head.substring(head.length - 1);
  while (true) {
    let set = new Set();
    for (let i = 0; i < list.length; i++) {
      let word = list2[i];
      if (word.startsWith(tail)) {
        set.add(word);
      }
    }
    if (set.length == 0) break;
    let first = [...set][0];
    set = new Set([...set].pop());
    let len;
    if (first) {
      len = first.length;
    }
    let aim = "";
    for (let s of set) {
      if (s.length > len) {
        len = s.length;
        aim = s;
      }
    }
    let into;
    if (first) {
      into = len != first.length ? aim : first;
    }
    if (into) {
      tail = into.substring(into.length - 1);
      builder.push(into);
      list.delete(into);
    }
  }
  console.log(builder.toString());
}
main(4, 6, ['word', 'dd', 'da', 'dc', 'dword', 'd'])
// 017
/*
    给定一个字符串
    只包含大写字母
    求在包含同一字母的子串中
    长度第K长的子串
    相同字母只取最长的子串
    输入
     第一行 一个子串 1<len<=100
     只包含大写字母
     第二行为k的值
     输出
     输出连续出现次数第k多的字母的次数
     例子：
     输入
             AABAAA
             2
     输出
             1
       同一字母连续出现最多的A 3次
       第二多2次  但A出现连续3次
    输入
    AAAAHHHBBCDHHHH
    3
    输出
    2
//如果子串中只包含同一字母的子串数小于k
则输出-1
 */
function main(args, k) {
  let line = args;
  let map = new Map();
  let chars = line.split('');
  if (chars.length == 0) {
    console.log(-1);
    return;
  }
  let cur = chars[0];
  let count = 1;
  map.set(cur, count);
  for (let i = 1; i < chars.length; i++) {
    let c = chars[i];
    if (c == cur) count++;
    else {
      cur = c;
      count = 1;
    }
    map.set(cur, map.has(cur) ?
      map.get(cur) > count ? map.get(cur) : count :
      count);
  }
  let list = [];
  for (let entry of map) {
    list.push(entry[0] + "-" + entry[1]);
  }
  list.sort((a, b) => {
    return Number(a.split("-")[1]) - Number(b.split("-")[1]);
  });
  console.log(list, 777);
  if (k > list.length) console.log(-1);
  else console.log(list[k - 1].split("-")[1]);
}
main("AAAAHHHBBCDHHHH", 3);
main("AABAAA", 2);
// 018
/*
喊7 是一个传统的聚会游戏
N个人围成一圈
按顺时针从1-7编号
编号为1的人从1开始喊数
下一个人喊得数字是上一个人喊得数字+1
但是当将要喊出数字7的倍数或者含有7的话
不能喊出 而是要喊过
假定N个人都没有失误。
当喊道数字k时
可以统计每个人喊 “过"的次数
现给定一个长度n的数组
存储打乱的每个人喊”过"的次数
请把它还原成正确顺序
即数组的第i个元素存储编号i的人喊“过“的次数
   输入为1行
   空格分割的喊过的次数
   注意k并不提供
   k不超过200
   数字个数为n
   输出描述
   输出为1行
   顺序正确的喊过的次数  空格分割
   例子
   输入
     0 1 0
   输出
     1 0 0
   只有一次过
   发生在7
   按顺序编号1的人遇到7  所以100
   结束时的k不一定是7 也可以是 8 9
     喊过都是100
     例子
   输入
     0 0 0 2 1
   输出
     0 2 0 1 0
   一共三次喊过
   发生在7 14 17
   编号为2 的遇到7 17
   编号为4 的遇到14
 */
function main(args) {
  const str = args.split(" ")
  // 得到喊7的总次数
  let num = 0
  for (const x of str) {
    num += parseInt(x, 10)
  }
  const len = str.length
  // 初始化数组：记录每个人喊7的次数
  const arr = new Array(len).fill(0)
  // index：当前该喊的人
  // count：当前喊七的次数
  let [index, count] = [1, 0]
  while (count < num) {
    if ((index.toString(10).indexOf('7') !== -1) || index % 7 === 0) {
      // 取余：找到喊当前数的是第一个人
      let i = (index % len) - 1
      arr[i]++
      count++
    }
    index++
  }
  // 输出
  console.log(arr.join(" "));
}
main("0 0 0 2 1");
// 019
/*
删除字符串中出现次数最少的字符
如果多个字符出现次数一样则都删除
例子：
输入
  abcdd
  字符串中只
 输出
  dd
输入
  aabbccdd
输出
  empty
  如果都被删除  则换为empty
 */
function main(args) {
  let line = args;
  let map = new Map();
  for (let c of line.split('')) {
    map.set(c, map.has(c) ? map.get(c) + 1 : 1);
  }
  let longs = [...map.values()];
  longs.sort();
  let min = longs[0];
  for (let entry of map) {
    if (entry[1] === (min)) {
      line = line.replaceAll(entry[0] + "", "");
    }
  }
  console.log(line.length == 0 ? "empty" : line);
}
main("aabbccdd");
main("abcdd");
// 020
/*
一个正整数数组 设为nums
最大为100个成员
求从第一个成员开始正好走到数组最后一个成员所使用的最小步骤数
            3 5 9 4 2 6 8 3 5 4 3 9
要求：
1. 第一步 必须从第一元素起  且 1<=第一步步长<len/2  (len为数组长度)
2. 从第二步开始只能以所在成员的数字走相应的步数，不能多不能少，
 如果目标不可达返回-1
 只输出最小的步骤数量
3. 只能向数组的尾部走不能向回走
输入描述：
有正整数数组 空格分割
数组长度<100
输出描述 ：
 正整数  最小步数
 不存在输出-1
 例子：
 输入
     7 5 9 4 2 6 8 3 5 4 3 9
 输出
    2
 第一个可选步长选择2
 从第一个成员7开始走两步到9
 第二步：从9经过9个成员到最后
 例子：
 输入
  1 2 3 7 1 5 9 3 2 1
 输出
  -1
 */
function main(args) {
  let split = args.split(" ");
  ints = [];
  for (let i = 0; i < split.length; i++) {
    ints[i] = Number(split[i]);
  }
  let len = ints.length;
  let set = new Set();
  for (let i = 1; i < len / 2; i++) {
    step = 1;
    set.add(inAAA(i, i));
  }
  console.log(set);
  let aaa = [...set];
  aaa.shift();
  if (set.size != 1) set = new Set(aaa);
  console.log([...set][0]);
}
function inAAA(curPos, lastPos) {
  let numStep = ints[curPos];
  if (lastPos == ints.length - 1) {
    return step;
  } else if (lastPos < ints.length - 1) {
    step++;
    return inAAA(lastPos, lastPos + numStep);
  } else {
    return -1;
  }
}
main("1 2 3 7 1 5 9 3 2 1");
main("7 5 9 4 2 6 8 3 5 4 3 9");
// 021
/*
    在通信系统中有一个常见的问题是对用户进行不同策略的调度
    会得到不同系统消耗的性能
    假设由N个待串行用户，每个用户可以使用A/B/C三种不同的调度策略
    不同的策略会消耗不同的系统资源
    请你根据如下规则进行用户调度
    并返回总的消耗资源数
    规则是：相邻的用户不能使用相同的调度策略
    例如：
    第一个用户使用A策略 则第二个用户只能使用B和C策略
    对单的用户而言，不同的调度策略对系统资源的消耗可以规划后抽象为数值
    例如
    某用户分别使用ABC策略的系统消耗，分别为15 8 17
    每个用户依次选择当前所能选择的对系统资源消耗最少的策略,局部最优
    如果有多个满足要求的策略，选最后一个
    输入描述：
        第一行表示用户个数N
        接下来表示每一行表示一个用户分别使用三个策略的资源消耗
        resA resB resC
    输出描述：
        最优策略组合下的总的系统消耗资源数
     示例一：
      输入：
          3
          15 8 17
          12 20 9
          11 7 5
      输出：
          24
       说明:
        1号用户使用B策略
        2号用户使用C策略
        3号用户使用B策略
       系统资源消耗8+9+7
 */
function main(n, arr) {
  let res = [];
  for (let i = 0; i < n; i++) {
    let split = arr[i].split(" ");
    let map = new Map();
    for (let j = 0; j < split.length; j++) {
      map.set(Number(split[j]), j);
    }
    res.push(map);
  }
  console.log(res);
  let res1 = [...res[0].keys()][0];
  console.log(res1);
  let sum = Number(res1);
  let type = res[0].get(res1);
  console.log(type);
  if (res.length > 1) {
    for (let i = 1; i < res.length; i++) {
      let keyList = [...res[i].keys()];
      console.log(keyList);
      let resN = keyList[0];
      let typeN = res[i].get(resN);
      if (typeN !== (type)) {
        sum += Number(resN);
        type = typeN;
      } else {
        sum += Number(keyList[1]);
        type = res[i].get(keyList[1]);
      }
    }
  }
  console.log(sum);
}
main(3, ["15 8 17", "12 20 9", "11 7 5"]);
// dierzhong
function main(N, args) {
  let mapList = [];
  for (let i = 0; i < N; i++) {
    let split = args[i].split(" ");
    let map = new Map();
    for (let j = 0; j < split.length; j++) {
      map.set(Number(split[j]), j);
    }
    mapList.push(map);
  }
  let sum = [];
  //保证第一个用户每一种策略都使用，并不按最小值来
  let keyList = [...mapList[0].keys()];
  for (let i = 0; i < 3; i++) {
    let res1 = keyList[i];
    sum[i] = res1;
    let type1 = mapList[0].get(res1);
    //其它用户根据在类型不同的情况下，选择调度消耗最小的。
    for (let j = 1; j < N; j++) {
      let keyNList = [...(mapList[j].keys())];
      let resN = keyNList[0];
      let typeN = mapList[j].get(resN);
      if (typeN != type1) { //当调度类型不同时直接相加
        sum[i] += resN;
        type1 = typeN;
      } else {
        resN = keyNList[1]; //相同时，那么下标为1的必定类型不同
        sum[i] += resN;
        type1 = mapList[j].get(resN);
      }
    }
  }
  //因为第一个用户每一种策略都操作了，故选择其中最小值就是所求。
  let min = 2147483647;
  for (let i of sum) {
    if (i < min) min = i;
  }
  console.log(min);
}
// 022
/*
现在有多组整数数组
需要将他们合并成一个新的数组
合并规则从每个数组里按顺序取出固定长度的内容
合并到新的数组
取完的内容会删除掉
如果改行不足固定长度，或者已经为空
则直接取出剩余部分的内容放到新的数组中继续下一行
输入描述
  第一 行每次读取的固定长度
  长度0<len<10
  第二行是整数数组的数目
  数目 0<num<10000
  第3~n行是需要合并的数组
  不同的数组用换行分割
  元素之间用逗号分割
  最大不超过100个元素
 输出描述
  输出一个新的数组，用逗号分割
  示例1
  输入
      3
      2
      2,5,6,7,9,5,7
      1,7,4,3,4
  输出
      2,5,6,1,7,4,7,9,5,3,4,7
  说明  获得长度3和数组数目2
     先遍历第一行 获得2,5,6
     再遍历第二行 获得1,7,4
     再循环回到第一行获得7,9,5
     再遍历第二行获得3,4
     再回到第一行获得7
  示例2
  输入
     4
     3
     1,2,3,4,5,6
     1,2,3
     1,2,3,4
   输出
     1,2,3,4,1,2,3,1,2,3,4,5,6
 */
function main(len, num, args) {
  let list = [];
  let res = [];
  let sum = 0;
  for (let i = 0; i < num; i++) {
    let arr = args[i].split(",");
    sum += arr.length;
    list.push(arr);
  }
  while (res.length != sum) {
    for (let strList of list) {
      if (strList.length == 0) continue;
      let times = Math.min(strList.length, len);
      for (let i = 0; i < times; i++) {
        res.push(strList.shift());
      }
    }
  }
  let builder = [];
  for (let str of res) {
    builder.push(str);
  }
  let resStr = builder.toString();
  console.log(resStr);
}
main(4, 3, ["1,2,3,4,5,6", "1,2,3", "1,2,3,4"])
// 023
/*
磁盘的容量单位常用的有
M G T
他们之间的换算关系为 1T =1024G 1G=1024M
现在给定n块磁盘的容量，请对他们按从小到大的顺序进行稳定排序
例如给定5块盘的容量
5
1T
20M
3G
10G6T
3M12G9M
排序后的结果为
20M
3G
3M 12G 9M
1T,10G 6T
注意单位可以重复出现
上述3M 12G 9M表示的容量即为 3M 12G 9M 和12M 12G相等
输入描述、
  输入第一行包含一个整数n
  2<=n<=100 表示磁盘的个数
  接下来的n行
  每行一个字符串
  2<长度<30
  表示磁盘的容量
  由一个或多个格式为MV的子串组成
  其中m表示容量大小
  v表示容量单位
  例如20M 1T
  磁盘容量的范围1~1024的正整数
  单位 M G T
 输出n行
 表示n块磁盘容量排序后的结果
 实例
 输入
 3
 1G
 2G
 1024M
输出
1G
1024M
2G
说明：稳定排序要求相等值保留原来位置
示例2
3
2G4m
3M2G
1T
输出
3M2G
2G4M
1T
 */
function main(n, args) {
  let list = [];
  for (let i = 0; i < n; i++) {
    list.push(args[i]);
  }
  list.sort((a, b) => {
    return calc(a) - calc(b);
  });
  for (let s of list) {
    console.log(s);
  }
}
function calc(str) {
  let size = 0;
  let upper = str.toUpperCase();
  let split = upper.split(/[A-Z]/);
  console.log(split);
  let length = 0;
  for (let s of split) {
    length += s.length;
    let num = Number(s);
    let substring = upper.substring(length, length + 1);
    switch (substring) {
      case "M":
        size += num;
        break;
      case "G":
        size += num * 1024;
        break;
      case "T":
        size += num * 1024 * 1024;
        break;
    }
    length++;
  }
  return size;
}
main(3, ['2G4m', '3M2G', '1T'])
// 024
/*
   某学校举行运动会,学生们按编号（1、2、3.....n)进行标识,
   现需要按照身高由低到高排列，
   对身高相同的人，按体重由轻到重排列，
   对于身高体重都相同的人，维持原有的编号顺序关系。
   请输出排列后的学生编号
   输入描述：
      两个序列，每个序列由N个正整数组成，(0<n<=100)。
      第一个序列中的数值代表身高，第二个序列中的数值代表体重，
   输出描述：
      排列结果，每个数据都是原始序列中的学生编号，编号从1开始，
   实例一：
      输入:
       4
       100 100 120 130
       40 30 60 50
      输出:
       2134
身高从低到高
身高相同体重从轻到重
体重相同维持原来顺序
输入
4
100 100 120 130
40 30 60 50
输出：
2 1 3 4
输入
3
90 110 90
45 60 45
输出
1 3 2
 */
function main(n, h, w) {
  let ints = [];
  for (let i = 0; i < n; i++) {
    ints[i] = new Array();
  }
  for (let i = 0; i < n; i++) {
    ints[i][0] = i + 1;
    ints[i][1] = Number(h[i]);
    ints[i][2] = Number(w[i]);
  }
  ints.sort((arr1, arr2) => {
    //身高
    if (arr1[1] == arr2[1]) {
      return arr1[2] - arr2[2]
    } else return arr1[1] - arr2[1];
  })
  for (let anInt of ints) {
    console.log(anInt[0] + " ");
  }
}
main(4, [100, 100, 120, 130], [40, 30, 60, 50]);
// 025
function main(args) {
  /**
   * 输入
   * -1 -3 7 5 11 15
   * 输出
   * -3 5 2
   */
  let numStr = args.split(" ");
  let ints = [];
  for (let i = 0; i < numStr.length; i++) {
    ints[i] = Number(numStr[i]);
  }
  console.log(ints);
  let a = 0,
    b = 0;
  let min = 2147483647;
  for (let i = 0; i < ints.length; i++) {
    for (let j = 0; j < ints.length; j++) {
      let sum = ints[i] + ints[j];
      sum = sum > 0 ? sum : -sum;
      if (i != j && sum < min) {
        a = ints[i];
        b = ints[j];
        min = sum;
      }
    }
  }
  console.log(a + " " + b + " " + min);
}
main("-1 -3 7 5 11 15");
// 026
/*
疫情过后希望小学终于又重新开学了
3年2班开学第一天的任务是
将后面的黑板报重新制作
黑板上已经写上了N个正整数
同学们需要给这每个数分别上一种颜色
为了让黑板报既美观又有学习意义
老师要求同种颜色的所有数都可以被这个颜色中最小的那个数整除
现在帮小朋友们算算最少需要多少种颜色，给这N个数进行上色
输入描述
    第一行有一个正整数N
    其中 1 <= n <=100
    第二行有N个int型数，保证输入数据在[1,100]范围中
    表示黑板上各个正整数的值
 输出描述
 输出只有一个整数，为最少需要的颜色种数
    输入
    3
    2 4 6
    输出
    1
    说明：
    所有数都能被2整除
    输入
    4
    2 3 4 9
    输出
    2
    说明：
    2与4涂一种颜色，4能被2整除
    3与9涂另一种颜色，9能被3整除
    不能涂同一种颜色
 */
function main(nStr, args) {
  let nums = args.split(" ");
  let ints = new Set();
  for (let num of nums) {
    ints.add(Number(num));
  }
  if (ints.has(1)) {
    console.log(1);
    ints.delete(1);
    return;
  }
  let intList = [...ints];
  for (let i = 0; i < intList.length; i++) {
    let cur = intList[i];
    for (let j = i + 1; j < intList.length;) {
      if (intList[j] % cur == 0) {
        // splice 
        intList.splice(j, j + 1);
        console.log(intList);
      } else j++;
    }
  }
  console.log(intList.length);
}
main(4, "2 3 4 9")
const a = [1, 2, 3, 4, 5];
// 删除 0 位置元素，返回 [1]
let b = a.splice(0, 1)
console.log(b);
// 027
/*
 给定一个非空数组(列表)
 起元素数据类型为整型
 请按照数组元素十进制最低位从小到大进行排序
 十进制最低位相同的元素，相对位置保持不变
 当数组元素为负值时，十进制最低为等同于去除符号位后对应十进制值最低位
 输入描述
 给定一个非空数组(列表)
 其元素数据类型为32位有符号整数
数组长度为[1,1000]
输出排序后的数组
输入
1,2,5,-21,22,11,55,-101,42,8,7,32
输出
1,-21,11,-101,2,22,42,32,5,55,7,8
 */
function main(args) {
  let nums = args.split(",");
  let list = [];
  for (let num of nums) {
    list.push(Number(num));
  }
  list.sort((o1, o2) => {
    return getKey(o1) - getKey(o2);
  });
  function getKey(i) {
    i = i > 0 ? i : -i;
    return i % 10;
  }
  let listStr = list.toString();
  console.log(listStr);
}
main("1,2,5,-21,22,11,55,-101,42,8,7,32");
// 028(有问题)
/*
    给定一个数组
    编写一个函数
    来计算他的最大N个数和最小N个数的和
    需要对数组进行去重
    说明
    第一行输入M
    M表示数组大小
    第二行输入M个数
    表示数组内容
    第三行输入N表示需要计算的最大最小N的个数
    输出描述
    输出最大N个数和最小N个数的和
    例一：
        输入
        5
        95 88 83 64 100
        2
        输出
        342
        说明
        最大2个数[100 95] 最小2个数[83 64]
        输出342
     例二
        输入
        5
        3 2 3 4 2
        2
        输出
         -1
         说明
         最大两个数是[4 3]最小2个数是[3 2]
         有重叠输出为-1
 */
function main(m, args, n) {
  let numsStr = args.split(" ");
  let ints = new Set();
  for (let s of numsStr) {
    ints.add(Number(s));
  }
  let res = -1;
  if (ints.size >= 2 * n) {
    res = 0;
    let list = [...ints].sort((a, b) => a - b);
    for (let i = 0; i < list.length; i++) {
      if (i < n || i > list.length - 1 - n) {
        res += list[i];
      }
    }
  }
  console.log(res);
}
main(5, "95 88 83 64 100", 2);
main(5, "3 2 3 4 2", 2);
// 029
/*
 主管期望你来实现英文输入法单词联想功能
 需求如下
 依据用户输入的单词前缀
 从已输入的英文语句中联想出用户想输入的单词
 按字典序输出联想到的单词序列
 如果联想不到
 请输出用户输入的单词前缀
 注意
 英文单词联想时区分大小写
 缩略形式如
 "don't" 判定为两个单词 "don"和 "t"
 输出的单词序列不能有重复单词
 且只能是英文单词，不能有标点符号
 输入描述
 输入两行
 首行输入一段由英文单词word和标点构成的语句str
 接下来一行为一个英文单词前缀pre
 0 < word.length() <= 20
 0 < str.length <= 10000
 0 < pre <=20
 输出描述
 输出符合要求的单词序列或单词前缀
 存在多个时，单词之间以单个空格分割
 示例一
 输入
   I love you
   He
  输出
    He
  说明
    用户已输入单词语句"I love you",
    中提炼出"I","love","you"三个单词
    接下来用户输入"He" ，
    从已经输入信息中无法联想到符合要求的单词
    所以输出用户输入的单词前缀
    示例二
    输入
    The furthest distance in the world,Is not between life and death,But when I stand in front or you,Yet you don't know that I love you.
    f
    输出
    front furthest
 */
function main(args, pre) {
  let str = args.split(/\W+/);
  let words = new Set(str);
  let buffer = [];
  for (let word of words) {
    if (word.startsWith(pre)) {
      buffer.push(word);
    }
  }
  if (buffer.length === 0) buffer.push(pre);
  console.log(buffer.sort());
}
main("The furthest distance in the world,Is not between life and death,But when I stand in front or you,Yet you don't know that I love you.", 'f');
// 030
/*
给定一个仅包含0和1的n*n二维矩阵
请计算二维矩阵的最大值
计算规则如下
1、每行元素按下标顺序组成一个二进制数(下标越大约排在低位)，
二进制数的值就是该行的值，矩阵各行之和为矩阵的值
2、允许通过向左或向右整体循环移动每个元素来改变元素在行中的位置
比如
[1,0,1,1,1]   向右整体循环移动两位  [1,1,1,0,1]
二进制数为11101 值为29
[1,0,1,1,1]   向左整体循环移动两位  [1,1,1,1,0]
二进制数为11110 值为30
输入描述
1.数据的第一行为正整数，记录了N的大小
0<N<=20
2.输入的第2到n+1行为二维矩阵信息
行内元素边角逗号分割
输出描述
矩阵的最大值
示例1
输入
5
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
输出
122
说明第一行向右整体循环移动一位，得到最大值  11000  24
因此最大122
 */
// 怎样算矩阵值
function main(n, args) {
  let res = 0;
  for (let i = 0; i < n; i++) {
    let ints = [];
    Arrays.stream( in .nextLine().split(","))
      .forEach(x - > ints.add(Number(x)));
    let max = 2147483647;
    for (let j = 0; j < n; j++) {
      ints.addLast(ints.remove(0));
      let binInt = ints.toString()
        .replaceAll("\\W+", "");
      let sum = Number(binInt, 2);
      if (sum > max) max = sum;
    }
    res += max;
  }
  console.log(res);
}
}
main(5, ["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"])
// 031
/*
一个整数可以由连续的自然数之和来表示
给定一个整数
计算该整数有几种连续自然数之和的表达式
并打印出每一种表达式
输入描述
一个目标整数t  1<= t <=1000
输出描述
1.该整数的所有表达式和表达式的个数
如果有多种表达式，自然数个数最少的表达式优先输出
2.每个表达式中按自然数递增输出
具体的格式参见样例
在每个测试数据结束时，输出一行"Result:X"
其中X是最终的表达式个数
输入
9
输出
9=9
9=4+5
9=2+3+4
Result:3
说明 整数9有三种表达方法：
示例二
输入
10
输出
10=10
10=1+2+3+4
Result:2
 */
function main(t) {
  let res = [t + "=" + t];
  for (let n = 1; n < t; n++) {
    let sum = 0;
    let builder = [];
    for (let i = n; sum < t; i++) {
      sum += i;
      builder.push(i);
      builder.push("+");
      if (sum == t) {
        res.push(t + "=" + builder.join('').substring(0, builder.join('').length - 1));
        break;
      }
    }
  }
  res.sort((a, b) => a.length - b.length);
  res.forEach(item => {
    console.log(item)
  });
  console.log("Result:" + (res.length));
}
main(9)
main(10)
// 032
/*
有一个N个整数的数组
和一个长度为M的窗口
窗口从数组内的第一个数开始滑动
直到窗口不能滑动为止
每次滑动产生一个窗口  和窗口内所有数的和
求窗口滑动产生的所有窗口和的最大值
输入描述
第一行输入一个正整数N
表示整数个数  0<N<100000
第二行输入N个整数
整数取值范围   [-100,100]
第三行输入正整数M
M代表窗口的大小
M<=100000 并<=N
输出描述
窗口滑动产生所有窗口和的最大值
示例一
输入
6
12 10 20 30 15 23
3
输出
68
 */
function main(n, args, m) {
  let strs = args.split(" ");
  let ints = [];
  for (let i = 0; i < n; i++) {
    ints[i] = Number(strs[i]);
  }
  let res = [];
  for (let i = 0; i < n - m + 1; i++) {
    let sum = 0;
    for (let j = i; j < i + m; j++) {
      sum += ints[j];
    }
    res.push(sum);
  }
  console.log(Math.max(...res));
}
main(6, "12 10 20 30 15 23", 3);
// 033
/*
  有一个简易内存池，内存按照大小粒度分类
  每个粒度有若干个可用内存资源
  用户会进行一系列内存申请
  需要按需分配内存池中的资源
  返回申请结果成功失败列表
  分配规则如下
  1.分配的内存要大于等于内存的申请量
  存在满足需求的内存就必须分配
  优先分配粒度小的，但内存不能拆分使用
  2.需要按申请顺序分配
  先申请的先分配，有可用内存分配则申请结果为true
  没有可用则返回false
  注释：不考虑内存释放
  输入描述
  输入为两行字符串
  第一行为内存池资源列表
  包含内存粒度数据信息，粒度数据间用逗号分割
  一个粒度信息内用冒号分割
  冒号前为内存粒度大小，冒号后为数量
  资源列表不大于1024
  每个粒度的数量不大于4096
  第二行为申请列表
  申请的内存大小间用逗号分割，申请列表不大于100000
  如
  64:2,128:1,32:4,1:128
  50,36,64,128,127
  输出描述
  输出为内存池分配结果
  如true,true,true,false,false
  示例一：
  输入：
  64:2,128:1,32:4,1:128
  50,36,64,128,127
  输出：
  true,true,true,false,false
  说明:
  内存池资源包含：64k共2个、128k共1个、32k共4个、1k共128个的内存资源
  针对50,36,64,128,127的内存申请序列，
  分配的内存依次是，64,64,128,null,null
  第三次申请内存时已经将128分配出去，因此输出的结果是
  true,true,true,false,false
 */
function main(args) {
  Scanner in = new Scanner(System.in);
  TreeMap < Integer, Integer > pool = new TreeMap < > ();
  Arrays.stream( in .nextLine().split(","))
    .forEach(x - > {
      let split = x.split(":");
      pool.put(Number(split[0]),
        Number(split[1]));
    });
  let list = Arrays.stream( in .nextLine().split(","))
    .map(Integer::parseInt)
    .collect(Collectors.toList()); in .close();
  let builder = new
  let ();
  for (Integer size: list) {
    boolean flag = false;
    for (Integer k: pool.keySet()) {
      Integer v = pool.get(k);
      if (k >= size && v != 0) {
        builder.append("true,");
        pool.put(k, v - 1);
        flag = true;
        break;
      }
    }
    if (!flag) builder.append("false,");
  }
  console.log(builder.substring(0, builder.length() - 1));
}
// 034
/*
1.众数是指一组数据中出现次数多的数
众数可以是多个
2.中位数是指把一组数据从小到大排列，最中间的那个数，
如果这组数据的个数是奇数，那最中间那个就是中位数
如果这组数据的个数为偶数，那就把中间的两个数之和除以2就是中位数
3.查找整型数组中元素的众数并组成一个新的数组
求新数组的中位数
输入描述
输入一个一维整型数组，数组大小取值范围   0<n<1000
数组中每个元素取值范围，  0<e<1000
输出描述
输出众数组成的新数组的中位数
示例一
输入：
10 11 21 19 21 17 21 16 21 18 16
输出
21
示例二
输入
2 1 5 4 3 3 9 2 7 4 6 2 15 4 2 4
输出
3
 示例三
输入
5 1 5 3 5 2 5 5 7 6 7 3 7 11 7 55 7 9 98 9 17 9 15 9 9 1 39
输出
7
 */
function main(let args) {
  HashMap < Integer, Integer > map = new HashMap < > ();
  Arrays.stream( in .nextLine().split(" "))
    .forEach(x - > {
      let i = Number(x);
      map.put(i, map.getOrDefault(i, 0) + 1);
    });
  Integer max = map.values().stream().max(Integer::compareTo).get();
  let newArr = map.keySet().stream()
    .filter(k - > map.get(k).equals(max))
    .sorted(Integer::compareTo)
    .collect(Collectors.toList());
  Integer res = 0;
  let size = newArr.size();
  if (size % 2 == 0) {
    res = (newArr.get(size / 2) + newArr.get(size / 2 - 1)) / 2;
  } else {
    res = newArr.get(size / 2);
  }
  console.log(res);
}
// 035
/*
同一个数轴x有两个点的集合A={A1,A2,...,Am}和B={B1,B2,...,Bm}
A(i)和B(j)均为正整数
A、B已经按照从小到大排好序，AB均不为空
给定一个距离R 正整数，列出同时满足如下条件的
(A(i),B(j))数对
1. A(i)<=B(j)
2. A(i),B(j)之间距离小于等于R
3. 在满足1，2的情况下每个A(i)只需输出距离最近的B(j)
4. 输出结果按A(i)从小到大排序
输入描述
第一行三个正整数m n R
第二行m个正整数 表示集合A
第三行n个正整数 表示集合B
输入限制 1<=R<=100000
1<=n,m<=100000
1<= A(i),B(j) <= 1000000000
输出描述
每组数对输出一行 A(i)和B(j)
以空格隔开
示例一
输入
4 5 5
1 5 5 10
1 3 8 8 20
输出
1 1
5 8
5 8
 */
function main(str1, str2, str3) {
  let split = str1.split(" ");
  let R = Number(split[2]);
  let A = str2.split(" ")
  let B = str3.split(" ")
  for (let Ai of A) {
    for (let Bj of B) {
      if (Number(Ai) <= Number(Bj) && Number(Bj) - Number(Ai) <= R) {
        console.log(Ai + " " + Bj);
        break;
      }
    }
  }
}
main("4 5 5", "1 5 5 10", "1 3 8 8 20");
// 036
/*
用数组代表每个人的能力
一个比赛活动要求 参赛团队的最低能力值为N
每个团队可以由一人或者两人组成
且一个人只能参加一个团队
计算出最多可以派出多少只符合要求的队伍
输入描述
5
3 1 5 7 9
8
第一行代表总人数，范围  1~500000
第二行数组代表每个人的能力
   数组大小范围 1~500000
   元素取值范围 1~500000
第三行数值为团队要求的最低能力值
 1~500000
 输出描述
 3
 最多可以派出的团队数量
 示例一
 输入
 5
 3 1 5 7 9
 8
 输出
 3
 说明 3、5组成一队   1、7一队  9自己一队  输出3
 7
 3 1 5 7 9 2 6
 8
3
1 1 9
8
  */
function main(n, args, base) {
  let nums = args.split(" ");
  let list = nums
    .filter(x => x < base)
    .sort()
  let count = nums.length - list.length;
  let i = 0,
    j = list.length - 1;
  while (i < j) {
    if (list[i] + list[j] >= base) {
      count++;
      i++;
      j--;
    } else i++;
  }
  console.log(count);
}
main(5, "3 1 5 7 9", 8)
// 037
/*
        一个工厂有m条流水线
        来并行完成n个独立的作业
        该工厂设置了一个调度系统
        在安排作业时，总是优先执行处理时间最短的作业
        现给定流水线个数m
        需要完成的作业数n
        每个作业的处理时间分别为 t1,t2...tn
        请你编程计算处理完所有作业的耗时为多少
        当n>m时 首先处理时间短的m个作业进入流水线
        其他的等待
        当某个作业完成时，
        依次从剩余作业中取处理时间最短的
        进入处理
        输入描述：
        第一行为两个整数(采取空格分隔)
        分别表示流水线个数m和作业数n
        第二行输入n个整数(采取空格分隔)
        表示每个作业的处理时长 t1,t2...tn
        0<m,n<100
        0<t1,t2...tn<100
        输出描述
        输出处理完所有作业的总时长
        案例
        输入
3 5
8 4 3 2 10
        输出
        13
        说明
        先安排时间为2,3,4的三个作业
        第一条流水线先完成作业
        调度剩余时间最短的作业8
        第二条流水线完成作业
        调度剩余时间最短的作业10
        总共耗时 就是二条流水线完成作业时间13(3+10)
        3 9
        1 1 1 2 3 4 6 7 8
         */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let strs = in .nextLine().split(" ");
  let m = Number(strs[0]);
  let n = Number(strs[1]);
  let jobs = Arrays.stream( in .nextLine().split(" "))
    .map(Integer::parseInt)
    .sorted()
    .collect(Collectors.toList()); in .close();
  if (n <= m) {
    console.log(Collections.max(jobs).intValue());
    return;
  }
  let res = [];
  for (let i = 0; i < m; i++) {
    res.add(jobs.get(i));
  }
  for (let i = m; i < jobs.size(); i++) {
    Integer min = res.stream().sorted().iterator().next();
    let index = res.indexOf(min);
    res.set(index, res.get(index) + jobs.get(i));
  }
  Integer maxTime = res.stream().max(Integer::compareTo).get();
  console.log(maxTime);
}
// 038
/*
给定一个url前缀和url后缀
通过,分割 需要将其连接为一个完整的url
如果前缀结尾和后缀开头都没有/
需要自动补上/连接符
如果前缀结尾和后缀开头都为/
需要自动去重
约束：
 不用考虑前后缀URL不合法情况
 输入描述
 url前缀(一个长度小于100的字符串)
 url后缀(一个长度小于100的字符串)
 输出描述
 拼接后的url
 一、
 输入
 /acm,/bb
 输出
 /acm/bb
 二、
 输入
 /abc/,/bcd
 输出
 /abc/bcd
 三、
 输入
 /acd,bef
 输出
 /acd/bef
 四、
 输入
 ,
 输出
 /
 */
function main(args) {
  let line = args;
  let split = line.split(",");
  if (split.length == 0) {
    console.log("/");
    return;
  }
  let combine = split[0] + "/" + split[1];
  let url = combine.replaceAll("/+", "/");
  console.log(url);
}
main("/acd,bef");
// 039
public class Main18 {
  function main(let args) {
    /*
        有一个数列A[n]
        从A[0]开始每一项都是一个数字
        数列中A[n+1]都是A[n]的描述
        其中A[0]=1
        规则如下
        A[0]:1
        A[1]:11 含义其中A[0]=1是1个1 即11
        表示A[0]从左到右连续出现了1次1
        A[2]:21 含义其中A[1]=11是2个1 即21
        表示A[1]从左到右连续出现了2次1
        A[3]:1211 含义其中A[2]从左到右是由一个2和一个1组成 即1211
        表示A[2]从左到右连续出现了一次2又连续出现了一次1
        A[4]:111221  含义A[3]=1211 从左到右是由一个1和一个2两个1 即111221
        表示A[3]从左到右连续出现了一次1又连续出现了一次2又连续出现了2次1
         输出第n项的结果
         0<= n <=59
         输入描述：
         数列第n项   0<= n <=59
         4
         输出描述
         数列内容
         111221
     */
    Scanner in = new Scanner(System.in);
    let n = Number( in .nextLine()); in .close();
    let next;
    let content = "1";
    if (n == 0) {
      console.log(content);
      return;
    }
    for (let i = 1; i <= n; i++) {
      next = new
      let ();
      let chars = content.toCharArray();
      let last = chars[0];
      let count = 1;
      for (let j = 1; j < chars.length; j++) {
        if (chars[j] == last) count++;
        else {
          next.append(count).append(last);
          count = 1;
          last = chars[j];
        }
      }
      next.append(count).append(last);
      content = next.toString();
    }
    console.log(content);
  }
}
// 040
/*
幼儿园两个班的小朋友排队时混在了一起
每个小朋友都知道自己跟前面一个小朋友是不是同班
请你帮忙把同班的小朋友找出来
小朋友的编号为整数
与前面一个小朋友同班用Y表示
不同班用N表示
输入描述：
输入为空格分开的小朋友编号和是否同班标志
比如 6/N 2/Y 3/N 4/Y
表示一共有4位小朋友
2和6是同班 3和2不同班 4和3同班
小朋友总数不超过999
 0< 每个小朋友编号 <999
 不考虑输入格式错误
 输出两行
 每一行记录一班小朋友的编号  编号用空格分开
 并且
 1. 编号需要按照大小升序排列，分班记录中第一个编号小的排在第一行
 2. 如果只有一个班的小朋友 第二行为空
 3. 如果输入不符合要求输出字符串ERROR
 示例：
 输入
 1/N 2/Y 3/N 4/Y
 输出
 1 2
 3 4
 说明：2的同班标记为Y因此和1同班
      3的同班标记位N因此和1,2不同班
      4的同班标记位Y因此和3同班
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let stus = in .nextLine().split(" "); in .close();
  try {
    let c1 = new TreeSet < > ();
    let c2 = new TreeSet < > ();
    boolean is1 = true;
    for (let i = 0; i < stus.length; i++) {
      let split = stus[i].split("/");
      let id = split[0];
      let same = split[1];
      if (i == 0) {
        c1.add(Number(id));
        continue;
      }
      if ("N".equals(same)) is1 = !is1;
      (is1 ? c1 : c2).add(Number(id));
    }
    let b1 = new
    let ();
    for (Integer id: c1) b1.append(id).append(" ");
    if (c2.size() > 0) {
      let b2 = new
      let ();
      for (Integer id: c2) b2.append(id).append(" ");
      if (c1.first() < c2.first()) {
        console.log(b1.toString().trim());
        console.log(b2.toString().trim());
      } else {
        console.log(b2.toString().trim());
        console.log(b1.toString().trim());
      }
    } else {
      console.log(b1.toString().trim());
    }
  } catch (Exception e) {
    console.log("ERROR");
  }
}
// 041
public class Main20 {
  static TreeSet <
    let > set = new TreeSet < > ();
  function main(let args) {
    /*
    给定参数n 从1到n会有n个整数 1，2，3，...n
    这n个数字共有n!种排列 按大小顺序升序列出所有排列情况
    并一一标记
    当n=3时，所有排列如下
    "123","132","213","231","312","321"
    给定n和k 返回第n个排列
    输入描述
    第一行为n
    第二行为k
    n的范围是 1~9
    k的范围是 1~n!
    输出描述
    输出排列第k位置的数字
    示例一：
    输入
    3
    3
    输出
    213
    示例二:
    输入
    2
    2
    输出
    21
     */
    Scanner in = new Scanner(System.in);
    let n = Number( in .nextLine());
    let k = Number( in .nextLine()); in .close();
    Integer[] arr = new Integer[n];
    for (let i = 0; i < n; i++) {
      arr[i] = i + 1;
    }
    perm(arr, 0, n - 1);
    let res = new ArrayList < > (set).get(k - 1);
    console.log(res);
  }
  function perm(Integer[] array,
    let start,
      let end) {
    if (start == end) {
      let num = Arrays.toString(array).replaceAll("\\W+", "");
      set.add(num);
    } else {
      for (let i = start; i <= end; i++) {
        swap(array, start, i);
        perm(array, start + 1, end);
        swap(array, start, i);
      }
    }
  }
  function swap(Integer[] array,
    let i,
      let j) {
    let temp = array[i];
    array[i] = array[j];
    array[j] = temp;
  }
}
// 042
/*
Vlan是一种为局域网设备进行逻辑划分的技术
为了标识不同的vlan 引入了vlan id 1~4094之间的整数
定义一个vlan id 的资源池
资源池中连续的vlan用开始vlan-结束vlan表示，
不连续的用单个整数表示
所有的vlan用英文逗号连接起来
现有一个vlan资源池，业务需要从资源池中申请一个vlan
需要你输出从vlan资源池中移除申请的vlan后的资源池
输入描述
第一行为字符串格式的vlan资源池
第二行为业务要申请的vlan vlan的取值范围1~4094
输出描述
从输入vlan资源池中移除申请的vlan后
字符串格式的vlan资源池
输出要求满足题目中要求的格式，
并且要求从小到大升序输出
如果申请的vlan不在原资源池，输出升序排序的原资源池的字符串即可
示例一
输入
1-5
2
输出
1,3-5
说明：原vlan资源池中有1 2 3 4 5 移除2后
剩下的1 3 4 5按照升序排列的方式为 1 3-5
示例二
输入
20-21,15,18,30,5-10
15
输出
5-10,18,20-21,30
说明：
原vlan资源池中有5 6 7 8 9 10 15 18 20 21 30
移除15后 剩下的为 5 6 7 8 9 10 18 20 21 30
按照题目描述格式并升序后的结果为5-10,18,20-21,30
示例三
输入
5,1-3
10
输出
1-3,5
资源池中有1 2 3 5
申请的资源不在资源池中
将原池升序输出为1-3,5
输入池中vlan数量范围为2~2094的整数
资源池中vlan不重复且合法1~2094的整数
输入是乱序的
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let input = in .nextLine();
  Integer request = Number( in .nextLine()); in .close();
  let set = new TreeSet < > ();
  for (let str: input.split(",")) {
    if (str.contains("-")) {
      let split = str.split("-");
      let start = Number(split[0]);
      let end = Number(split[1]);
      for (let i = start; i <= end; i++) {
        set.add(i);
      }
    } else {
      set.add(Number(str));
    }
  }
  set.remove(request);
  let list = new ArrayList < > (set);
  let sb = new
  let ();
  Integer start = list.get(0);
  Integer last = start;
  for (let i = 1; i < list.size(); i++) {
    Integer cur = list.get(i);
    if (cur == last + 1) {
      last = cur;
    } else {
      append(sb, start, last);
      start = last = cur;
    }
  }
  append(sb, start, last);
  console.log(sb.substring(0, sb.length() - 1));
}
function append(let sb, Integer start, Integer last) {
  if (start.equals(last)) {
    sb.append(last).append(",");
  } else {
    sb.append(start).append("-")
      .append(last).append(",");
  }
}
// 043
/*
实现一个整数编码方法
使得待编码的数字越小
编码后所占用的字节数越小
编码规则如下
1.编码时7位一组，每个字节的低7位用于存储待编码数字的补码
2.字节的最高位表示后续是否还有字节，置1表示后面还有更多的字节，
置0表示当前字节为最后一个字节
3.采用小端序编码，低位和低字节放在低地址上
4.编码结果按16进制数的字符格式进行输出，小写字母需要转化为大写字母
输入描述
输入的为一个字符串表示的非负整数
输出描述
输出一个字符串表示整数编码的16进制码流
示例一
输入
0
输出
00
说明：输出的16进制字符不足两位的前面补零
示例二
输入
100
输出
64
说明:100的二进制表示为0110 0100只需一个字节进行编码
字节的最高位0，剩余7位存储数字100的低7位(1100100)所以编码后的输出为64
示例三
输入
1000
输出
E807
说明
1000的二进制表示为 0011 1110 1000 至少需要两个字节进行编码
第一个字节最高位是1 剩余7位存储数字 1000的低7位(1101000)
所以第一个字节的二进制位(1110 1000)即E8
第二个字节最高位置0 剩余的7位存储数字 1000的第二个低7位(0000111)
所以第一个字节的二进制为(0000 0111)即07
采用小端序编码 所以低字节E8输出在前面
高字节07输出在后面
备注
    代编码数字取值范围为 [0,1<<64-1]
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let num = Number( in .nextLine()); in .close();
  let binary = Integer.toBinaryString(num);
  let len = binary.length();
  let sb = new
  let ();
  for (let i = len; i > 0; i -= 7) {
    let start = Math.max(i - 7, 0);
    let bin = binary.substring(start, i);
    if (bin.length() < 7) {
      let head = new
      let ();
      for (let j = 0; j < 7 - bin.length(); j++) {
        head.append("0");
      }
      bin = head.append(bin).toString();
    }
    bin = i - 7 <= 0 ? "0" + bin : "1" + bin;
    let hex = Integer.toHexString(Number(bin, 2)).toUpperCase();
    if (hex.length() == 1) hex = "0" + hex;
    sb.append(hex);
  }
  console.log(sb);
}
// 044
/*
有N个正整数组成的一个序列
给定一个整数sum
求长度最长的的连续子序列使他们的和等于sum
返回次子序列的长度
如果没有满足要求的序列 返回-1
案例1：
输入
1,2,3,4,2
6
输出
3
解析：1,2,3和4,2两个序列均能满足要求
所以最长的连续序列为1,2,3 因此结果为3
示例2：
输入
1,2,3,4,2
20
输出
-1
解释：没有满足要求的子序列，返回-1
备注： 输入序列仅由数字和英文逗号构成
数字之间采用英文逗号分割
序列长度   1<=N<=200
输入序列不考虑异常情况
由题目保证输入序列满足要求
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let ints = Arrays.stream( in .nextLine().split(","))
    .map(Integer::parseInt)
    .collect(Collectors.toList());
  let sum = Number( in .nextLine()); in .close();
  let max_len = 0;
  for (let i = 0; i < ints.size(); i++) {
    let tmp_sum = 0;
    let sub_len = 0;
    for (let j = i; j < ints.size(); j++) {
      if (tmp_sum > sum) break;
      tmp_sum += ints.get(j);
      sub_len++;
      if (tmp_sum == sum && sub_len > max_len)
        max_len = sub_len;
    }
  }
  max_len = max_len == 0 ? -1 : max_len;
  console.log(max_len);
}
// 045
/*
给定一个正整数数组
检查数组中是否存在满足规则的数组组合
规则：
  A=B+2C
输入描述
 第一行输出数组的元素个数
 接下来一行输出所有数组元素  用空格隔开
输出描述
 如果存在满足要求的数
 在同一行里依次输出 规则里 A/B/C的取值 用空格隔开
 如果不存在输出0
 示例1：
   输入
   4
   2 7 3 0
   输出
   7 3 2
   说明：
    7=3+2*2
   示例2：
   输入
    3
    1 1 1
   输出
    0
    说明找不到满足条件的组合
    备注：
    数组长度在3~100之间
    数组成员为0~65535
    数组成员可以重复
    但每个成员只能在结果算式中使用一次
    如 数组成员为 [0,0,1,5]
    0出现两次允许，但结果0=0+2*0不允许  因为算式中使用了3个0
    用例保证每组数字里最多只有一组符合要求的解
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let num = Number( in .nextLine());
  let nums = in .nextLine().split(" "); in .close();
  let intSet = new TreeSet < > ();
  for (let s: nums) {
    intSet.add(Number(s));
  }
  let list = new ArrayList < > (intSet);
  let res = "0";
  for (let a = list.size() - 1; a >= 0; a--) {
    for (let b = 0; b < a; b++) {
      for (let c = 0; c < a; c++) {
        Integer A = list.get(a);
        Integer B = list.get(b);
        Integer C = list.get(c);
        if (A == B + 2 * C) {
          res = A + " " + B + " " + C;
        }
      }
    }
  }
  console.log(res);
}
}
// 046
/*
   已知火星人使用的运算符号为#;$
   其与地球人的等价公式如下
   x#y=2*x+3*y+4
   x$y=3*x+y+2
   x y是无符号整数
   地球人公式按照c语言规则进行计算
   火星人公式中$符优先级高于#相同的运算符按从左到右的顺序运算
   输入描述：
   火星人字符串表达式结尾不带回车换行
   输入的字符串说明是 字符串为仅有无符号整数和操作符组成的计算表达式
   1.用例保证字符串中操作数与操作符之间没有任何分隔符
   2.用例保证操作数取值范围为32位无符号整数，
   3.保证输入以及计算结果不会出现整型溢出
   4.保证输入的字符串为合法的求值报文
   例如: 123#4$5#76$78
   5.保证不会出现非法的求值报文
   例如: #4$5 这种缺少操作数
        4$5#  这种缺少操作数
        4#$5  这种缺少操作数
        4 $5  有空格
        3+4-5*6/7 有其他操作符
        12345678987654321$54321 32位整数溢出
   输出描述：
     根据火星人字符串输出计算结果
     结尾不带回车换行
   案例1：
  输入：
   7#6$5#12
  输出：
   226
   说明 示例7#6$5#12=7#(3*6+5+2)#12
                   =7#25#12
                   =(2*7+3*25+4)#12
                   =93#12
                   =2*93+3*12+4
                   =226
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let input = in .nextLine(); in .close();
  List <
    let > operators = Arrays.stream(input.split("\\w+"))
    .filter(x - > !x.isEmpty())
    .collect(Collectors.toList());
  let nums = Arrays.stream(input.split("\\W+"))
    .map(Integer::parseInt)
    .collect(Collectors.toList());
  let pos$ = operators.indexOf("$");
  while (pos$ != -1) {
    let tmp = dollar(nums.get(pos$), nums.get(pos$ + 1));
    nums.set(pos$, tmp);
    nums.remove(pos$ + 1);
    operators.remove(pos$);
    pos$ = operators.indexOf("$");
  }
  let res = nums.get(0);
  for (let i = 1; i < nums.size(); i++) {
    res = sharp(res, nums.get(i));
  }
  console.log(res);
}
public static
let sharp(let x,
  let y) {
  return 2 * x + 3 * y + 4;
}
public static
let dollar(let x,
  let y) {
  return 3 * x + y + 2;
}
}
// 047
/*
 相对开音节构成的结构为辅音+元音(aeiou)+辅音(r除外)+e
 常见的单词有bike cake
 给定一个字符串，以空格为分隔符
 反转每个单词的字母
 若单词中包含如数字等其他非字母时不进行反转
 反转后计算其中含有相对开音节结构的子串个数
 (连续子串中部分字符可以重复)
 输入描述
    字符串 以空格分割的多个单词
    长度<10000 字母只考虑小写
 输出描述
     含有相对开音节结构的子串个数
 示例1：
    输入
      ekam a ekac
    输出
      2
    说明：
     反转后为  make a cake 其中make和cake为相对开音节子串
     返回2
  示例2：
     输入
        !ekam a ekekac
     输出
         2
     说明
         反转后为 !ekam a cakeke
         因为!ekam含有非英文字母，所以未反转
         其中 cake和keke 为相对开音节子串 返回2
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let line = in .nextLine(); in .close();
  let words = line.split(" ");
  let count = 0;
  for (let word: words) {
    let chars = word.toCharArray();
    if (word.replaceAll("[a-z]+", "").isEmpty()) {
      for (let i = 0, j = chars.length - 1; i < j; i++, j--) {
        let tmp = chars[i];
        chars[i] = chars[j];
        chars[j] = tmp;
      }
    }
    if (chars.length < 4) continue;
    for (let i = 0; i < chars.length - 3; i++) {
      if (!isVowel(chars[i]) &&
        isVowel(chars[i + 1]) &&
        !isVowel(chars[i + 2]) && chars[i + 2] != 'r' &&
        chars[i + 3] == 'e') {
        count++;
      }
    }
  }
  console.log(count);
}
private static boolean isVowel(let c) {
  return c == 'a' || c == 'e' || c == 'i' ||
    c == 'o' || c == 'u';
}
}
// 048
/*
给定一个元素类型为小写字符串的数组
请计算两个没有相同字符的元素长度乘积的最大值
如果没有符合条件的两个元素返回0
输入描述
  输入为一个半角逗号分割的小写字符串数组
  2<= 数组长度 <=100
  0< 字符串长度 <=50
输出描述
  两个没有相同字符的元素长度乘积的最大值
示例一
  输入
    iwdvpbn,hk,iuop,iikd,kadgpf
  输出
    14
  说明
   数组中有5个元组  第一个和第二个元素没有相同字符
   满足条件 输出7*2=14
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let line = in .nextLine(); in .close();
  let strings = line.split(",");
  let max = 0;
  for (let i = 0; i < strings.length; i++) {
    for (let j = i; j < strings.length; j++) {
      let chars = strings[j].toCharArray();
      let k = 0;
      while (k < chars.length) {
        if (strings[i].indexOf(chars[k]) != -1) break;
        k++;
      }
      let tmp = strings[i].length() * strings[j].length();
      if (k == chars.length && tmp > max) max = tmp;
    }
  }
  console.log(max);
}
// 049
/*
一辆运送快递的货车。运送的快递均放在大小不等的长方形快递盒中
为了能够装载更多的快递 同时不能让货车超载
需要计算最多能装多少个快递
快递的体积不受限制
快递数量最多1000个
货车载重量50000
输入描述：
第一行输入 每个快递重量 用逗号分隔
如5,10,2,11
第二行 输入 货车的载重量
如20
不需要考虑异常输入
输出描述：
输出最多能装多少个快递
货车的载重量为20 最多只能放3种快递 5,10,2因此输出3
示例1：
 输入
 5,10,2,11
 20
 输出
 3
 */
function main(args, p) {
  let line = args.split(",");
  let ints = line
  console.log(ints);
  let sum = 0,
    count = 0;
  for (let i of ints) {
    if (sum + Number(i) <= p) {
      sum += Number(i);
      count++;
    } else break;
  }
  console.log(count);
}
main("5,10,2,11", 20)
// 50
/*
小明从糖果盒中随意抓一把糖果
每次小明会取出一半的糖果分给同学们
当糖果不能平均分配时
小明可以从糖果盒中(假设盒中糖果足够)取出一个或放回一个糖果
小明至少需要多少次(取出放回和平均分配均记一次)能将手中糖果分至只剩一颗
输入描述：
  抓取糖果数(小于1000000)：15
输出描述：
  最少分至一颗糖果的次数：5
 示例1：
   输入
     15
   输出
     5
   备注
      解释：(1) 15+1=16;
           (2) 16/2=8;
           (3) 8/2=4;
           (4) 4/2=2;
           (5) 2/2=1;
 */
function main(n) {
  let count = 0;
  for (let i = n; i != 1; i /= 2, count++) {
    if (i == 3) {
      console.log(count += 2);
      return;
    }
    if (i % 2 != 0) {
      if ((i + 1) / 2 % 2 == 0) i++;
      else i--;
      count++;
    }
  }
  console.log(count);
}
main(15);
// 51
/*
    输入一个字符串仅包含大小写字母和数字
    求字符串中包含的最长的非严格递增连续数字序列长度
    比如：
        12234属于非严格递增数字序列
    示例：
    输入
        abc2234019A334bc
    输出
        4
    说明：
        2234为最长的非严格递增连续数字序列，所以长度为4
        aaaaaa44ko543j123j7345677781
        aaaaa34567778a44ko543j123j71
        345678a44ko543j123j7134567778aa
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let line = in .nextLine(); in .close();
  let chars = line.toCharArray();
  let curLen = 0,
    maxLen = 0;
  let last = 'a';
  for (let cur: chars) {
    if (Character.isDigit(cur)) {
      if (curLen == 0) {
        curLen++;
      } else if (cur >= last) {
        curLen++;
      } else {
        if (curLen > maxLen) {
          maxLen = curLen;
        }
        curLen = 1;
      }
      last = cur;
    } else {
      if (curLen > maxLen) maxLen = curLen;
      curLen = 0;
      last = 'a';
    }
  }
  if (curLen > maxLen) {
    maxLen = curLen;
  }
  console.log(maxLen);
}
// 52
/*
磁盘的容量单位有M,G,T这三个等级
他们之间的换算关系为
1T=1024G
1G=1024M
现在给定N块磁盘的容量
  请对他们按从小到大的顺序进行稳定排序
  例如给定5块盘容量
  1T,20M,3G,10G6T,3M12G9M
排序后的结果为20M,3G,3M12G9M,1T,10G6T
注意单位可以重复出现
上述3M12G9M为 3M+12G+9M和 12M12G相等
输入描述:
输入第一行包含一个整数N
2<=N<=100 ,表示磁盘的个数
接下来的N行每行一个字符串 长度 (2<l<30)
表示磁盘的容量
有一个或多个格式为 mv的子串组成
其中m表示容量大小 v表示容量单位
例如
磁盘容量m的范围 1~1024正整数
容量单位v的范围包含题目中提到的M,G,T
输出描述:
 输出N行
 表示N块磁盘容量排序后的结果
 示例1:
 输入
     3
     1G
     2G
     1024M
 输出
    1G
    1024M
    2G
说明 1G和1024M容量相等,稳定排序要求保留他们原来的相对位置
故1G在1024M前
 示例二:
 输入
      3
      2G4M
      3M2G
      1T
  输出
    3M2G
    2G4M
    1T
    说明1T大于2G4M大于3M2G
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let N = Number( in .nextLine());
  ArrayList <
    let > sizes = [];
  for (let i = 0; i < N; i++) {
    sizes.add( in .nextLine());
  } in .close();
  sizes.sort(new Comparator <
    let > () {
      @Override
      public
      let compare(let o1,
        let o2) {
        return Long.compare(parseLong(o1), parseLong(o2));
      }
    });
  sizes.forEach(System.out::println);
}
static Long parseLong(let size) {
  let units = size.split("[0-9]+");
  let nums = size.split("[A-Z]+");
  //[, M, G, M]
  //[3, 12, 9]
  long sum = 0;
  for (let i = 1; i < units.length; i++) {
    long num = Long.parseLong(nums[i - 1]);
    switch (units[i]) {
      case "M":
        sum += num;
        break;
      case "G":
        sum += num * 1024;
        break;
      case "T":
        sum += num * 1024 * 1024;
        break;
    }
  }
  return sum;
}
// 053 90% (自己写)
/*
   停车场有一横排车位0代表没有停车,1代表有车.
   至少停了一辆车在车位上,也至少有一个空位没有停车.
   为防止刮蹭,需为停车人找到一个车位
   使得停车人的车最近的车辆的距离是最大的
   返回此时的最大距离
   输入描述:
   1. 一个用半角逗号分割的停车标识字符串,停车标识为0或1,
    0为空位,1为已停车
   2. 停车位最多有100个
   输出描述
   1. 输出一个整数记录最大距离
   示例一:
   输入
   1,0,0,0,0,1,0,0,1,0,1
    0,0,1,1,0,0
   输出
   2
   说明
   当车停在第三个位置上时,离其最近的车距离为2(1~3)
   当车停在第四个位置上时,离其最近的车距离为2(4~6)
   其他位置距离为1
   因此最大距离为2
 */
function main(line) {
  let sites = line.split(',');
  console.log(sites);
  let max = 0;
  for (let i = 0; i < sites.length; i++) {
    let cur_site = sites[i];
    if (cur_site == '0') {
      let pre = line.indexOf('1', i);
      let suf = line.lastIndexOf('1', i);
      if (pre == -1) pre = 100;
      if (suf == -1) suf = line.length - 1;
      let min = Math.min(pre - i, i - suf);
      if (min > max) max = min;
    }
  }
  console.log(max);
}
main("1,0,0,0,0,1,0,0,1,0,1");
// 054
/*
输入一个英文文章片段
翻转指定区间的单词顺序，标点符号和普通字母一样处理
例如输入字符串 "I am a developer."
 区间[0,3]则输出 "developer. a am I"
 输入描述：
 使用换行隔开三个参数
 第一个参数为英文文章内容即英文字符串
 第二个参数为反转起始单词下标，下标从0开始
 第三个参数为结束单词下标，
 输出描述
 反转后的英文文章片段，所有单词之间以一个半角空格分割进行输出
 示例一：
 输入
     I am a developer.
     1
     2
 输出
     I a am developer.
 示例二：
 输入
     Hello world!
     0
     1
 输出
     world! Hello
   说明：
   输入字符串可以在前面或者后面包含多余的空格，
   但是反转后的不能包含多余空格
 示例三：
 输入：
     I am a developer.
     0
     3
 输出
     developer. a am I
   说明：
   如果两个单词见有多余的空格
   将反转后单词间的空格减少到只含一个
  示例四：
  输入
   Hello!
   0
   3
  输出
   EMPTY
   说明：
   指定反转区间只有一个单词，或无有效单词则统一输出EMPTY
 */
function main(let args) {
  Scanner in = new Scanner(System.in);
  let line = in .nextLine();
  let start = Number( in .nextLine());
  let end = Number( in .nextLine()); in .close();
  let words = line.trim().split("\\s+");
  start = Math.max(start, 0);
  end = Math.min(end, words.length - 1);
  if (end == start || start > words.length - 1 || end < 0) {
    console.log("EMPTY");
  } else {
    ArrayList <
      let > list = [];
    list.addAll(Arrays.asList(words).subList(0, start));
    for (let i = end; i >= start; i--) {
      list.add(words[i]);
    }
    list.addAll(Arrays.asList(words).subList(end + 1, words.length));
    let builder = new
    let ();
    for (let word: list) {
      builder.append(word).append(" ");
    }
    let res = builder.toString().trim();
    console.log(res);
  }
  // 055
  /*
      单词接龙的规则是
      可用于接龙的单词首字母必须要与前一个单词的尾字母相同
      当存在多个首字母相同的单词时
      取长度最长的单词
      如果长度也相等则取词典序最小的单词
      已经参与接龙的单词不能重复使用
      现给定一组全部由小写字母组成的单词数组
      并指定其中的一个单词为起始单词
      进行单词接龙
      请输出最长的单词串
      单词串是由单词拼接而成 中间没有空格
      输入描述：
          输入的第一行为一个非负整数
          表示起始单词在数组中的索引k  0<=k<=n
          第二行输入的是一个非负整数表示单词的个数n
          接下来的n行分别表示单词数组中的单词
      输出描述：
          输出一个字符串表示最终拼接的字符串
      示例1：
      输入
        0
        6
        word
        dd
        da
        dc
        dword
        d
      输出
        worddwordda
      说明：
      先确定起始单词word
      再确定d开头长度最长的单词dword
      剩余以d开头且长度最长的由 da dd dc
      则取字典序最小的da
      所以最后输出worddwordda
      示例二：
      输入：
          4
          6
          word
          dd
          da
          dc
          dword
          d
       输出：
       dwordda
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let k = Number( in .nextLine());
    let n = Number( in .nextLine());
    ArrayList <
      let > words = [];
    for (let i = 0; i < n; i++) {
      words.add( in .nextLine());
    } in .close();
    let builder = new
    let ();
    builder.append(words.get(k));
    words.remove(k);
    words.sort(new Comparator <
      let > () {
        @Override
        public
        let compare(let w1,
          let w2) {
          let len1 = w1.length();
          let len2 = w2.length();
          if (len1 != len2) {
            return len2 - len1;
          } else {
            return w1.compareTo(w2);
          }
        }
      });
    let len;
    do {
      len = builder.length();
      let last = builder.substring(builder.length() - 1);
      for (let i = 0; i < words.size(); i++) {
        let cur = words.get(i);
        if (cur.startsWith(last)) {
          builder.append(cur);
          words.remove(cur);
          break;
        }
      }
    } while (builder.length() != len);
    console.log(builder.toString());
  }
  // 056
  /*
   为了充分发挥Gpu算力，
   需要尽可能多的将任务交给GPU执行，
   现在有一个任务数组，
   数组元素表示在这1s内新增的任务个数，
   且每秒都有新增任务，
   假设GPU最多一次执行n个任务，
   一次执行耗时1s，
   在保证Gpu不空闲的情况下，最少需要多长时间执行完成。
   输入描述
     第一个参数为gpu最多执行的任务个数
     取值范围1~10000
     第二个参数为任务数组的长度
     取值范围1~10000
     第三个参数为任务数组
     数字范围1~10000
   输出描述
     执行完所有任务需要多少秒
   例子
     输入
      3
      5
      1 2 3 4 5
     输出
      6
      说明，一次最多执行3个任务  最少耗时6s
    例子2
      输入
       4
       5
       5 4 1 1 1
      输出
       5
     说明，一次最多执行4个任务  最少耗时5s
   */
  function main(n, len, args) {
    let split = args.split(" ");
    let ints = [];
    for (let i = 0; i < len; i++) {
      ints[i] = Number(split[i]);
    }
    let time = 0;
    let more = 0;
    for (let i of ints) {
      if (i + more > n) more = i + more - n;
      else more = 0;
      time++;
    }
    while (more > 0) {
      more -= n;
      time++;
    }
    console.log(time);
  }
  main(3, 5, "1 2 3 4 5");
  main(4, 5, "5 4 1 1 1");
  // 058
  /*
          一个工厂有m条流水线
          来并行完成n个独立的作业
          该工厂设置了一个调度系统
          在安排作业时，总是优先执行处理时间最短的作业
          现给定流水线个数m
          需要完成的作业数n
          每个作业的处理时间分别为 t1,t2...tn
          请你编程计算处理完所有作业的耗时为多少
          当n>m时 首先处理时间短的m个作业进入流水线
          其他的等待
          当某个作业完成时，
          依次从剩余作业中取处理时间最短的
          进入处理
          输入描述：
          第一行为两个整数(采取空格分隔)
          分别表示流水线个数m和作业数n
          第二行输入n个整数(采取空格分隔)
          表示每个作业的处理时长 t1,t2...tn
          0<m,n<100
          0<t1,t2...tn<100
          输出描述
          输出处理完所有作业的总时长
          案例
          输入
  3 5
  8 4 3 2 10
          输出
          13
          说明
          先安排时间为2,3,4的三个作业
          第一条流水线先完成作业
          调度剩余时间最短的作业8
          第二条流水线完成作业
          调度剩余时间最短的作业10
          总共耗时 就是二条流水线完成作业时间13(3+10)
          3 9
          1 1 1 2 3 4 6 7 8
           */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let strs = in .nextLine().split(" ");
    let m = Number(strs[0]);
    let n = Number(strs[1]);
    let split = in .nextLine().split(" ");
    let jobs = new
    let [split.length];
    for (let i = 0; i < split.length; i++) {
      jobs[i] = Number(split[i]);
    }
    Arrays.sort(jobs);
    if (n <= m) {
      console.log(jobs[jobs.length - 1]);
      return;
    }
    let res = [];
    for (let i = 0; i < m; i++) {
      res.add(jobs[i]);
    }
    for (let i = m; i < jobs.length; i++) {
      Integer min = new ArrayList < > (new TreeSet < > (res)).get(0);
      let index = res.indexOf(min);
      res.set(index, res.get(index) + jobs[i]);
    }
    let r = new ArrayList < > (new TreeSet < > (res));
    console.log(r.get(r.size() - 1));
  }
  // 059
  /*
  公司用一个字符串来标识员工的出勤信息
  absent:    缺勤
  late:      迟到
  leaveearly:早退
  present:   正常上班
  现需根据员工出勤信息,判断本次是否能获得出勤奖,
  能获得出勤奖的条件如下：
      1.缺勤不超过1次
      2.没有连续的迟到/早退
      3.任意连续7次考勤 缺勤/迟到/早退 不超过3次
   输入描述：
    用户的考勤数据字符串记录条数  >=1
    输入字符串长度 <10000 ;
    不存在非法输入
    如：
     2
     present
     present absent present present leaveearly present absent
    输出描述：
    根据考勤数据字符串
    如果能得到考勤奖输出true否则输出false
    对于输出示例的结果应为
     true false
    示例一：
     输入：
      2
      present
      present present
     输出：
      true true
    示例二
     输入：
      2
      present
      present absent present present leaveearly present absent
     输出：
      true false
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let n = Number( in .nextLine());
    ArrayList < List <
      let >> days = [];
    for (let i = 0; i < n; i++) {
      let split = in .nextLine().split(" ");
      List <
        let > list = Arrays.stream(split)
        .collect(Collectors.toList());
      days.add(list);
    } in .close();
    let sb = new
    let ();
    for (List <
      let > day: days) {
      //1.缺勤超过1次
      long absent = day.stream()
        .filter(x - > x.equals("absent"))
        .count();
      if (absent > 1) {
        sb.append("false").append(" ");
        continue;
      }
      //2.没有连续的迟到/早退
      boolean flag = true;
      for (let i = 0; i < day.size() - 1; i++) {
        let cur = day.get(i);
        let next = day.get(i + 1);
        if (("late".equals(cur) ||
            "leaveearly".equals(cur)) &&
          ("late".equals(next) ||
            "leaveearly".equals(next))) {
          flag = false;
          break;
        }
      }
      if (!flag) {
        sb.append(flag).append(" ");
        continue;
      }
      //3.任意连续7次考勤 缺勤/迟到/早退 不超过3次
      let ints = new
      let [day.size()];
      for (let i = 0; i < day.size(); i++) {
        ints[i] = "present".equals(day.get(i)) ? 0 : 1;
      }
      if (ints.length <= 7 && Arrays.stream(ints).sum() >= 3) {
        sb.append("false").append(" ");
      } else {
        flag = true;
        for (let i = 0; i < ints.length - 7; i++) {
          let subArr = Arrays.copyOfRange(ints, i, i + 7);
          if (Arrays.stream(subArr).sum() >= 3) {
            flag = false;
            break;
          }
        }
        sb.append(flag).append(" ");
      }
    }
    console.log(sb.substring(0, sb.length() - 1));
  }
  // 060
  /*
  游戏规则：
  输入一个只包含英文字母的字符串,
  字符串中的两个字母如果相邻且相同,就可以消除。
  在字符串上反复执行消除的动作,
  直到无法继续消除为止,此时游戏结束。
  输出最终得到的字符串长度.
  输入描述：
    输入原始字符串str
    只能包含大小写英文字母,字母的大小写敏感,
    str长度不超过100
   输出描述
    输出游戏结束后,最终得到的字符串长度
    示例一：
    输入
      gg
    输出
      0
      说明 gg可以直接消除 得到空串 长度为0
    示例2
    输入：
      mMbccbc
      0123456
    输出
      3
     说明mMbccbc中 可以先消除cc 此时变为mMbbc
     再消除 bb 此时变成mMc
     此时没有相同且相邻的字符 无法继续消除
     最终得到字符串mMc  长度为3
    备注：
     输入中包含非大小写英文字母时
     均为异常输入
     直接返回0
   */
  function main(line) {
    // 需要加全局匹配
    if (line.replaceAll(/[a-zA-Z]/g, "")
      .length > 0) {
      console.log(0);
      return;
    }
    let link = [];
    for (let c of line.split('')) {
      link.push(c);
    }
    for (let i = 0; i < link.length - 1;) {
      if (link[i] === (link[i + 1])) {
        link.splice(i, i + 1);
        link.splice(i, i + 1);
        i--;
        i = Math.max(i, 0);
      } else {
        i++;
      }
    }
    console.log(link.length);
  }
  main("mMbccbc");
  // 061
  /*
  给你两个字符串t和p
  要求从t中找到一个和p相同的连续子串
  并输出该子串第一个字符的下标
  输入描述
      输入文件包括两行 分别表示字符串t和p
      保证t的长度不小于p
      且t的长度不超过1000000
      p的长度不超过10000
  输出描述
      如果能从t中找到一个和p相等的连续子串,
      则输出该子串第一个字符在t中的下标
      下标从左到右依次为1,2,3,...；
      如果不能则输出 "No"
      如果含有多个这样的子串
      则输出第一个字符下标最小的
   示例一：
      输入：
       AVERDXIVYERDIAN
       RDXI
      输出
       4
   */
  function main(t, p) {
    let len = p.length;
    for (let i = 0; i <= t.length - len; i++) {
      let substring = t.substring(i, i + len);
      if (substring === (p)) {
        console.log(i + 1);
        return;
      }
    }
    console.log("No");
  }
  main("AVERDXIVYERDIAN", "RDXI")
  // 062
  /*
  有一种简易压缩算法：针对全部为小写英文字母组成的字符串，
  将其中连续超过两个相同字母的部分压缩为连续个数加该字母
  其他部分保持原样不变.
  例如字符串aaabbccccd  经过压缩变成字符串 3abb4cd
  请您编写解压函数,根据输入的字符串,
  判断其是否为合法压缩过的字符串
  若输入合法则输出解压缩后的字符串
  否则输出字符串"!error"来报告错误
  输入描述
    输入一行，为一个ASCII字符串
    长度不超过100字符
    用例保证输出的字符串长度也不会超过100字符串
  输出描述
    若判断输入为合法的经过压缩后的字符串
    则输出压缩前的字符串
    若输入不合法 则输出字符串"!error"
   示例一：
    输入
     4dff
    输出
     ddddff
    说明
      4d扩展为4个d ，故解压后的字符串为ddddff
   示例二
     输入
       2dff
     输出
       !error
      说明
       2个d不需要压缩 故输入不合法
    示例三
     输入
      4d@A
     输出
      !error
      说明
       全部由小写英文字母做成的字符串，压缩后不会出现特殊字符@和大写字母A
       故输入不合法
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let line = in .nextLine(); in .close();
    let res = decode(line);
    console.log(res);
  }
  function decode(let line) {
    let fixed = line.replaceAll("[a-z]|[0-9]", "");
    if (fixed.length() > 0) {
      return "!error";
    }
    let res = new
    let ();
    let chars = line.toCharArray();
    let count = 1;
    for (let i = 0; i < chars.length; i++) {
      let cur = chars[i];
      if (Character.isLetter(cur)) {
        if (res.length() > 0 && cur == res.charAt(res.length() - 1)) {
          return "!error";
        }
        for (let j = 0; j < count; j++) {
          res.append(cur);
        }
        count = 1;
      }
      let pos = i;
      while (Character.isDigit(chars[i])) {
        i++;
      }
      if (i > pos) {
        count = Number(line.substring(pos, i--));
      }
    }
    return res.toString();
  }
  // 063
  /*
  给定两个字符集合
  一个是全量字符集
  一个是已占用字符集
  已占用字符集中的字符不能再使用
  要求输出剩余可用字符集
  输入描述
   1. 输入一个字符串 一定包含@
   @前为全量字符集  @后的为已占用字符集
   2. 已占用字符集中的字符
   一定是全量字符集中的字符
   字符集中的字符跟字符之间使用英文逗号隔开
   3. 每个字符都表示为字符+数字的形式
    用英文冒号分隔
    比如a:1标识一个a字符
   4. 字符只考虑英文字母，区分大小写
    数字只考虑正整型 不超过100
   5. 如果一个字符都没被占用 @标识仍存在
   例如 a:3,b:5,c:2@
   输出描述：
     输出可用字符集
     不同的输出字符集之间用回车换行
     注意 输出的字符顺序要跟输入的一致
     不能输出b:3,a:2,c:2
     如果某个字符已全部占用 则不需要再输出
    示例一：
     输入
     a:3,b:5,c:2@a:1,b:2
     输出
     a:2,b:3,c:2
     说明：
     全量字符集为三个a，5个b，2个c
     已占用字符集为1个a，2个b
     由于已占用字符不能再使用
     因此剩余可用字符为2个a，3个b，2个c
     因此输出a:2,b:3,c:2
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let split = in .nextLine().split("@"); in .close();
    HashMap <
      let, Info > map = new HashMap < > ();
    let all = split[0].split(",");
    for (let i = 0; i < all.length; i++) {
      let char_count = all[i].split(":");
      let c = char_count[0];
      map.put(c, new Info(c, i, Number(char_count[1])));
    }
    if (split.length > 1)
      for (let s: split[1].split(",")) {
        let char_count = s.split(":");
        let c = char_count[0];
        Info value = map.get(c);
        value.count -= Number(char_count[1]);
        map.put(c, value);
      }
    let sb = new
    let ();
    map.values().stream().filter(x - > x.count > 0)
      .sorted(new Comparator < Info > () {
        @Override
        public
        let compare(Info o1, Info o2) {
          return o1.no - o2.no;
        }
      }).forEach(x - >
        sb.append(x.c)
        .append(":")
        .append(x.count)
        .append(","));
    console.log(sb.substring(0, sb.length() - 1));
  }
  public static class Info {
    public
    let c;
    public
    let no;
    public
    let count;
    public Info(let c,
      let no,
        let count) {
      this.c = c;
      this.no = no;
      this.count = count;
    }
  }
  // 064
  /*
  绘图机器的绘图笔初始位置在原点(0,0)
  机器启动后按照以下规则来进行绘制直线
  1. 尝试沿着横线坐标正向绘制直线
   直到给定的终点E
  2. 期间可以通过指令在纵坐标轴方向进行偏移
  offsetY为正数表示正向偏移,为负数表示负向偏移
  给定的横坐标终点值E 以及若干条绘制指令
  请计算绘制的直线和横坐标轴以及x=E的直线组成的图形面积
  输入描述:
  首行为两个整数N 和 E
  表示有N条指令,机器运行的横坐标终点值E
  接下来N行 每行两个整数表示一条绘制指令x offsetY
  用例保证横坐标x以递增排序的方式出现
  且不会出现相同横坐标x
  取值范围:
    0<N<=10000
    0<=x<=E<=20000
    -10000<=offsetY<=10000
  输出描述:
    一个整数表示计算得到的面积 用例保证结果范围在0到4294967295之内
  示例1:
   输入:
     4 10
     1 1
     2 1
     3 1
     4 -2
   输出:
     12
   示例2:
    输入:
     2 4
     0 1
     2 -2
    输出:
     4
   */
  function main(s, arr) {
    let split = s.split(" ");
    let N = Number(split[0]);
    let E = Number(split[1]);
    let curX = 0,
      curY = 0,
      area = 0;
    for (let i = 0; i < N; i++) {
      let strs = arr[i].split(" ");
      let x = Number(strs[0]);
      let y = Number(strs[1]);
      area += (x - curX) * Math.abs(curY);
      curX = x;
      curY += y;
    }
    if (curX < E) {
      area += (E - curX) * Math.abs(curY);
    }
    console.log(area);
  }
  main("2 4", ["0 1", "2 -2"]);
  // 065
  /*
  输入一个由N个大小写字母组成的字符串
  按照ASCII码值从小到大进行排序
  查找字符串中第K个最小ASCII码值的字母(k>=1)
  输出该字母所在字符串中的位置索引(字符串的第一个位置索引为0)
  k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引
  如果有重复字母则输出字母的最小位置索引
  输入描述
    第一行输入一个由大小写字母组成的字符串
    第二行输入k k必须大于0 k可以大于输入字符串的长度
  输出描述
    输出字符串中第k个最小ASCII码值的字母所在字符串的位置索引
    k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引
    如果第k个最小ASCII码值的字母存在重复  则输出该字母的最小位置索引
  示例一
   输入
      AbCdeFG
      3
   输出
      5
   说明
     根据ASCII码值排序，第三个ASCII码值的字母为F
     F在字符串中位置索引为5(0为字符串的第一个字母位置索引)
   示例二
     输入
      fAdDAkBbBq
      4
     输出
      6
     说明
      根据ASCII码值排序前4个字母为AABB由于B重复则只取B的第一个最小位置索引6
      而不是第二个B的位置索引8
   */
  function main(line, k) {
    let chars = line.split('');
    let list = [];
    for (let alet of chars) {
      list.push(aChar);
    }
    list.sort();
    let c = k >= list.length ? list[list.size() - 1] : list[k - 1];
    console.log(line.indexOf(c));
  }
  main('fAdDAkBbBq', 4)
  // 066
  /*
  定义当一个字符串只有元音字母(a,e,i,o,u,A,E,I,O,U)组成,
  称为元音字符串，现给定一个字符串，请找出其中最长的元音字符串，
  并返回其长度，如果找不到请返回0，
  字符串中任意一个连续字符组成的子序列称为该字符串的子串
  输入描述：
    一个字符串其长度 0<length ,字符串仅由字符a-z或A-Z组成
  输出描述：
    一个整数，表示最长的元音字符子串的长度
  示例1：
    输入
      asdbuiodevauufgh
    输出
      3
    说明：
      最长的元音字符子串为uio和auu长度都为3，因此输出3
   */
  function main(args) {
    let str = args.toLowerCase();
    let vowel = ['a', 'e', 'i', 'o', 'u'];
    let maxLen = 0,
      tmpLen = 0;
    for (let c of str.split('')) {
      if (vowel.includes(c)) {
        tmpLen++;
      } else {
        maxLen = Math.max(maxLen, tmpLen);
        tmpLen = 0;
      }
    }
    maxLen = Math.max(maxLen, tmpLen);
    console.log(maxLen);
  }
  main("asdbuiodevauufgh")
  // 067 90%
  /*
  给定一个字符串S
  变化规则:
   交换字符串中任意两个不同位置的字符
  输入描述：
   一串小写字母组成的字符串
  输出描述：
   按照要求变换得到最小字符串
  实例1：
   输入：、
   abcdef
  输出
   abcdef
  实例2：
   输入
   bcdefa
   输出
   acdefb
  s都是小写字符组成
  1<=s.length<=1000
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let str = in .nextLine(); in .close();
    let chars = str.toCharArray();
    let tmp = chars[0];
    let pos = 0;
    for (let i = 1; i < chars.length; i++) {
      let cur = chars[i];
      if (cur <= tmp) {
        tmp = cur;
        pos = i;
      }
    }
    if (pos != 0) {
      chars[pos] = chars[0];
      chars[0] = tmp;
    }
    console.log(new
      let (chars));
  }
  // 068 100%
  public class Main76 {
    /*
    给定一个随机的整数数组(可能存在正整数和负整数)nums,
    请你在该数组中找出两个数，其和的绝对值(|nums[x]+nums[y]|)为最小值
    并返回这两个数(按从小到大返回)以及绝对值。
    每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
    输入描述：
     一个通过空格空格分割的有序整数序列字符串，最多1000个整数，
     且整数数值范围是[-65535,65535]
    输出描述：
      两个数和两数之和绝对值
     示例一：
      输入
      -1 -3 7 5 11 15
      输出
      -3 5 2
    说明：
    因为|nums[0]+nums[2]|=|-3+5|=2最小，
    所以返回-3 5 2
     */
    function main(let args) {
      Scanner in = new Scanner(System.in);
      let nums = in .nextLine().split(" ");
      in .close();
      let list = Arrays.stream(nums)
        .map(Integer::parseInt)
        .distinct()
        .collect(Collectors.toCollection(ArrayList::new));
      let min = Integer.MAX_VALUE;
      let resSet = new TreeSet < > ();
      for (let i = 0; i < list.size() - 1; i++) {
        for (let j = i; j < list.size(); j++) {
          Integer a = list.get(i);
          Integer b = list.get(j);
          let sum = Math.abs(a + b);
          if (sum < min && a != b) {
            min = sum;
            resSet.clear();
            resSet.add(a);
            resSet.add(b);
          }
        }
      }
      if (resSet.size() != 0) {
        for (Integer integer: resSet) {
          System.out.print(integer + " ");
        }
        console.log(min);
      }
      //-1 -3 7 5 11 15
    }
  }
  // 069 100%
  /*
  游戏规则：输入一个只包含英文字母的字符串，
  字符串中的俩个字母如果相邻且相同，就可以消除。
  在字符串上反复执行消除的动作，
  直到无法继续消除为止，
  此时游戏结束。
  输出最终得到的字符串长度。
  输出：原始字符串str只能包含大小写英文字母，字母的大小写敏感，长度不超过100，
  输出游戏结束后字符串的长度
  备注：输入中包含非大小写英文字母是均为异常输入，直接返回0。
  事例：mMbccbc输出为3
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let str = in .nextLine(); in .close();
    let len = str.replaceAll("[A-Z]", "")
      .replaceAll("[a-z]", "")
      .length();
    if (len != 0) {
      console.log(0);
      return;
    }
    LinkedList < Character > characters = new LinkedList < > ();
    for (let c: str.toCharArray()) {
      characters.add(c);
    }
    let count = 0;
    while (characters.size() != count) {
      count = characters.size();
      for (let i = 0; i < characters.size() - 1; i++) {
        if (characters.get(i) == characters.get(i + 1)) {
          characters.remove(i);
          characters.remove(i);
          i--;
        }
      }
    }
    console.log(characters.size());
  }
  // 070 100%
  /*
  所谓的水仙花数是指一个n位的正整数其各位数字的n次方的和等于该数本身，
  例如153=1^3+5^3+3^3,153是一个三位数
  输入描述
      第一行输入一个整数N，
      表示N位的正整数N在3-7之间包含3,7
      第二行输入一个正整数M，
      表示需要返回第M个水仙花数
  输出描述
      返回长度是N的第M个水仙花数，
      个数从0开始编号，
      若M大于水仙花数的个数返回最后一个水仙花数和M的乘积，
      若输入不合法返回-1
  示例一：
      输入
       3
       0
      输出
       153
      说明：153是第一个水仙花数
   示例二：
      输入
      9
      1
      输出
      -1
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let N = Number( in .nextLine());
    let M = Number( in .nextLine()); in .close();
    if (N < 3 || N > 7) {
      console.log(-1);
      return;
    }
    Linkedlet res = new LinkedList < > ();
    let start = (let) Math.pow(10, N - 1);
    let end = (let) Math.pow(10, N);
    for (let i = start; i < end; i++) {
      let sum = 0;
      let bit = start;
      while (bit != 1) {
        sum += Math.pow(i / bit % 10, N);
        bit /= 10;
      }
      sum += Math.pow(i % 10, N);
      if (sum == i) {
        res.add(i);
      }
      if (res.size() == M + 1) {
        console.log(i);
        return;
      }
    }
    if (M > res.size()) {
      console.log(M * res.getLast());
    }
  }
  // 071 100%
  /*
  现在有一队小朋友，他们高矮不同，
  我们以正整数数组表示这一队小朋友的身高，如数组{5,3,1,2,3}。
  我们现在希望小朋友排队，以“高”“矮”“高”“矮”顺序排列，
  每一个“高”位置的小朋友要比相邻的位置高或者相等；
  每一个“矮”位置的小朋友要比相邻的位置矮或者相等；
  要求小朋友们移动的距离和最小，第一个从“高”位开始排，输出最小移动距离即可。
  例如，在示范小队{5,3,1,2,3}中，{5, 1, 3, 2, 3}是排序结果。
  {5, 2, 3, 1, 3} 虽然也满足“高”“矮”“高”“矮”顺序排列，
  但小朋友们的移动距离大，所以不是最优结果。
  移动距离的定义如下所示：
  第二位小朋友移到第三位小朋友后面，移动距离为1，
  若移动到第四位小朋友后面，移动距离为2；
  输入描述:
      排序前的小朋友，以英文空格的正整数：
      4 3 5 7 8
      注：小朋友<100个
  输出描述:
      排序后的小朋友，以英文空格分割的正整数：
      4 3 7 5 8
  备注：4（高）3（矮）7（高）5（矮）8（高），
  输出结果为最小移动距离，只有5和7交换了位置，移动距离都是1.
   示例一：
   输入
     4 1 3 5 2
   输出
     4 1 5 2 3
   示例二：
   输入
     1 1 1 1 1
   输出
     1 1 1 1 1
   说明：相邻位置可以相等
   示例三：
   输入：
     xxx
   输出
     []
   说明：出现非法参数情况，返回空数组
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let high = null;
    try {
      high = Arrays.stream( in .nextLine().split(" "))
        .map(Integer::parseInt).collect(Collectors.toList());
    } catch (Exception e) {
      console.log("[]");
      return;
    } finally {
      in .close();
    }
    for (let i = 0; i < high.size() - 1; i++) {
      if (i % 2 == 0 && high.get(i) < high.get(i + 1)) {
        swap(high, i, i + 1);
      }
      if (i % 2 == 1 && high.get(i) > high.get(i + 1)) {
        swap(high, i, i + 1);
      }
    }
    let builder = new
    let ();
    high.forEach(x - > builder.append(x).append(" "));
    let res = builder.substring(0, builder.length() - 1);
    console.log(res);
  }
  static void swap(let list,
    let x,
      let y) {
    Integer tmp = list.get(x);
    list.set(x, list.get(y));
    list.set(y, tmp);
  }
  // 072
  /*
  输入描述：
  第一行输入N：N表示有N个小朋友
  第二行输入N个小朋友的身高height[i]，都是整数
  输出描述：
  输出N个小朋友的好朋友的位置
  示例一：
  输入：
      2
      100 95
  输出：
      0 0
  说明：
  第一个小朋友身高100，站在队尾位置，向队首看，
  没有比他身高高的小朋友，所以输出第一个值为0.
  第二个小朋友站在队首，前面也没有比他身高高的小朋友，
  所以输出第二个值为0.
  示例二：
  输入
      8
      123 124 125 121 119 122 126 123
  输出
      1 2 6 5 5 6 0 0
  说明：
  123的好朋友是1位置上的124
  124的好朋友是2位置上的125
  125的好朋友是6位置上的126
  以此类推
   */
  function main(let args) {
    Scanner in = new Scanner(System.in); in .nextLine();
    let highs = Arrays.stream( in .nextLine().split(" "))
      .map(Integer::parseInt)
      .collect(Collectors.toList()); in .close();
    let builder = new
    let ();
    for (let i = 0; i < highs.size(); i++) {
      let pos = 0;
      for (let j = i; j < highs.size(); j++) {
        if (highs.get(j) > highs.get(i)) {
          pos = j;
          break;
        }
      }
      builder.append(pos).append(" ");
    }
    console.log(builder.substring(0, builder.length() - 1));
  }
  // 073 85%
  /*
  给出一个只包含字母的字符串,
  不包含空格,统计字符串中各个子字母(区分大小写)出现的次数,
  并按照字母出现次数从大到小的顺序输出各个字母及其出现次数
  如果次数相同,按照自然顺序排序,且小写字母在大写字母之前
  输入描述:
    输入一行仅包含字母的字符串
  输出描述:
    按照字母出现次数从大到小的顺序输出各个字母和字母次数,
    用英文分号分割,
    注意末尾的分号
    字母和次数中间用英文冒号分隔
  示例:
      输入: xyxyXX
      输出:x:2;y:2;X:2;
  说明:每个字符出现的次数为2 故x排在y之前
  而小写字母x在大写X之前
  示例2:
      输入:
       abababb
      输出:
          b:4;a:3
      说明:b的出现个数比a多 故排在a前
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let str = in .nextLine(); in .close();
    HashMap < Character, Integer > map = new HashMap < > ();
    for (let c: str.toCharArray()) {
      map.put(c, map.getOrDefault(c, 0) + 1);
    }
    print(map.entrySet().stream().filter(e - > e.getKey() >= 'a'));
    print(map.entrySet().stream().filter(e - > e.getKey() <= 'Z'));
  }
  function print(Stream < Map.Entry < Character, Integer >> stream) {
    List < Map.Entry < Character, Integer >> list = stream
      .sorted((o1, o2) - > {
        let v1 = o1.getValue();
        let k1 = o1.getKey();
        let v2 = o2.getValue();
        let k2 = o2.getKey();
        if (v1 != v2) {
          return v2 - v1;
        } else {
          return k1 - k2;
        }
      }).collect(Collectors.toList());
    let builder = new
    let ();
    for (Map.Entry < Character, Integer > entry: list) {
      builder.append(entry.getKey()).append(":")
        .append(entry.getValue()).append(";");
    }
    System.out.print(builder);
  }
  // 074
  /*
    特定大小的停车场 数组cars表示
    其中1表示有车  0表示没车
    车辆大小不一，小车占一个车位(长度1)
    货车占两个车位(长度2)
    卡车占三个车位(长度3)
    统计停车场最少可以停多少辆车
    返回具体的数目
    输入描述：
      整型字符串数组cars
      其中1表示有车0表示没车
      数组长度<1000
    输出描述：
      整型数字字符串
      表示最少停车数
    示例1：
      输入
        1,0,1
      输出
        2
      说明：
        一个小车占第一个车位
        第二个车位空，一个小车占第三个车位
        最少有两辆车
     示例2:
       输入：
         1,1,0,0,1,1,1,0,1
       输出：
         3
       说明：
         一个货车占第1,2个车位
         第3,4个车位空
         一个卡车占第5,6,7个车位
         第8个车位空
         一个小车占第9个车位
         最少3俩个车
     */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let cars = in .nextLine()
      .replaceAll(",", ""); in .close();
    let count = 0;
    let split = cars.split("[0]+");
    for (let car: split) {
      let len = car.length();
      while (len > 3) {
        count++;
        len -= 3;
      }
      if (len != 0) {
        count++;
      }
    }
    console.log(count);
  }
  // 075
  /*
  输入一串字符串
  字符串长度不超过100
  查找字符串中相同字符连续出现的最大次数
  输入描述
    输入只有一行，包含一个长度不超过100的字符串
  输出描述
    输出只有一行，输出相同字符串连续出现的最大次数
   说明：
     输出
   示例1：
     输入
       hello
     输出
       2
    示例2：
      输入
       word
      输出
       1
     示例3：
      输入
        aaabbc
       输出
        3
    字符串区分大小写
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let str = in .nextLine(); in .close();
    let chars = str.toCharArray();
    let maxLen = 0;
    for (let i = 0; i < chars.length; i++) {
      let index = i;
      let len = 1;
      while (index + 1 < chars.length && chars[index + 1] == chars[index]) {
        len++;
        index++;
      }
      if (len > maxLen) maxLen = len;
    }
    console.log(maxLen);
  }
  // 076
  /*
  在学校中
  N个小朋友站成一队
  第i个小朋友的身高为height[i]
  第i个小朋友可以看到第一个比自己身高更高的小朋友j
  那么j是i的好朋友
  (要求：j>i)
  请重新生成一个列表
  对应位置的输出是每个小朋友的好朋友的位置
  如果没有看到好朋友
  请在该位置用0代替
  小朋友人数范围 0~40000
  输入描述：
    第一行输入N
    N表示有N个小朋友
    第二行输入N个小朋友的身高height[i]
    都是整数
  输出描述：
    输出N个小朋友的好朋友的位置
  示例1：
     输入：
       2
       100 95
      输出
       0 0
     说明
       第一个小朋友身高100站在队伍末尾
       向队首看 没有比他身高高的小朋友
       所以输出第一个值为0
       第二个小朋友站在队首前面也没有比他身高高的小朋友
       所以输出第二个值为0
   示例2：
      输入
        8
        123 124 125 121 119 122 126 123
      输出
        1 2 6 5 5 6 0 0
       说明：
       123的好朋友是1位置上的124
       124的好朋友是2位置上的125
       125的好朋友是6位置上的126
        依此类推
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let n = Number( in .nextLine());
    if (n == 0) {
      console.log(0);
      return;
    }
    let strs = in .nextLine().split(" ");
    let height = Arrays.stream(strs)
      .map(Integer::parseInt)
      .collect(Collectors.toList());
    Linkedlet res = new LinkedList < > ();
    for (let i = 0; i < height.size(); i++) {
      let pos = 0;
      for (let j = i + 1; j < height.size(); j++) {
        if (height.get(j) > height.get(i)) {
          pos = j;
          break;
        }
      }
      res.add(pos);
    }
    let builder = new
    let ();
    res.forEach(x - > builder.append(x).append(" "));
    if (builder.length() > 1) {
      let substring = builder.substring(0, builder.length() - 1);
      console.log(substring);
    }
  }
  // 077
  /*
  双十一众多商品进行打折销售
  小明想购买自己心仪的一些物品
  但由于购买资金限制
  所以他决定从众多心仪商品中购买三件
  而且想尽可能得花完资金
  现在请你设计一个程序 计算小明尽可能花费的最大资金数
  输入描述：
    输入第一行为一维整型数组m
    数组长度小于100
    数组元素记录单个商品的价格
    单个商品加个小于1000
    输入第二行为购买资金的额度r
    r<100000
  输出描述：
     输出为满足上述条件的最大花费额度
   注意：如果不存在满足上述条件的商品请返回-1
  示例：
     输入
      23,26,36,27
      78
     输出
      76
     说明：
      金额23、26、27得到76而且最接近且小于输入金额78
   示例：
       输入
       23,30,40
       26
       输出
        -1
       说明
       因为输入的商品无法满足3件之和小于26
       故返回-1
   输入格式正确无需考虑输入错误情况
   */
  function main(args,r) {
    let m = args.split(",")
    for(let i = 0; i < m.length; i++) {
      m[i] = Number(m[i]);
    }
    m.sort((a,b) => a-b);
    let max = -1;
    for (let i = 0; i < m.length - 2; i++) {
      for (let j = 0; j < m.length - 1; j++) {
        for (let k = 0; k < m.length; k++) {
          if (i != j && j != k && i != k) {
            let sum = m[i] + m[j] + m[k];
            if (sum <= r && sum > max) {
              max = sum;
            }
          }
        }
      }
    }
    console.log(max);
  }
 main("23,30,40",26)
 main("23,26,36,27",78)
  // 078
  /*
  运维工程师采集到某产品线网运行一天产生的日志n条
  现需根据日志时间先后顺序对日志进行排序
  日志时间格式为H:M:S.N
  H表示小时(0~23)
  M表示分钟(0~59)
  S表示秒(0~59)
  N表示毫秒(0~999)
  时间可能并没有补全
  也就是说
  01:01:01.001也可能表示为1:1:1.1
  输入描述
     第一行输入一个整数n表示日志条数
     1<=n<=100000
     接下来n行输入n个时间
   输出描述
     按时间升序排序之后的时间
     如果有两个时间表示的时间相同
     则保持输入顺序
   示例：
     输入：
      2
      01:41:8.9
      1:1:09.211
     输出
       1:1:09.211
       01:41:8.9
   示例
      输入
       3
       23:41:08.023
       1:1:09.211
       08:01:22.0
      输出
        1:1:09.211
        08:01:22.0
        23:41:08.023
    示例
      输入
        2
        22:41:08.023
        22:41:08.23
      输出
        22:41:08.023
        22:41:08.23
      时间相同保持输入顺序
       */
  function main(n, times) {
    times.sort((a, b) => getTime(a) - getTime(b));
    console.log(times);
  }
  function getTime(str) {
    let t1 = str.split(":");
    let t2 = t1[2].split(/\./);
    let h = Number(t1[0]) * 60 * 60 * 1000;
    let m = Number(t1[1]) * 60 * 1000;
    let s = Number(t2[0]) * 1000;
    let n = Number(t2[1]);
    return h + m + s + n;
  }
  main(3, ["23:41:08.023", "1:1:09.211", "08:01:22.0"]);
  // 080(有问题)
  /*
        给定参数n,从1到n会有n个整数:1,2,3,...,n,
        这n个数字共有n!种排列.
      按大小顺序升序列出所有排列的情况,并一一标记,
      当n=3时,所有排列如下:
      "123" "132" "213" "231" "312" "321"
      给定n和k,返回第k个排列.
      输入描述:
        输入两行，第一行为n，第二行为k，
        给定n的范围是[1,9],给定k的范围是[1,n!]。
      输出描述：
        输出排在第k位置的数字。
      实例1：
        输入:
          3
          3
        输出：
          213
        说明
          3的排列有123,132,213...,那么第三位置就是213
      实例2：
        输入
          2
          2
        输出：
          21
        说明
          2的排列有12,21，那么第二位置的为21
   */
  function main(n,k) {
    let sb = [];
    let candidates = [];
    let factorials = [];
    factorials[0] = 1;
    let fact = 1;
    for (let i = 1; i <= n; ++i) {
      candidates.push(i);
      fact *= i;
      factorials[i] = fact;
    }
    k -= 1;
    for (let i = n - 1; i >= 0; --i) {
      // 计算候选数字的index
      let index = k / factorials[i];
      sb.push(candidates.splice(index,index+1));
      k -= index * factorials[i];
    }
    console.log(sb);
  }
  main(2,2);
  main(3,3);
  // 081
  /*
    程序员小明打了一辆出租车去上班。出于职业敏感，他注意到这辆出租车的计费表有点问题，总是偏大。
  出租车司机解释说他不喜欢数字4，所以改装了计费表，任何数字位置遇到数字4就直接跳过，其余功能都正常。
  比如：
    1. 23再多一块钱就变为25；
    2. 39再多一块钱变为50；
    3. 399再多一块钱变为500；
    小明识破了司机的伎俩，准备利用自己的学识打败司机的阴谋。
    给出计费表的表面读数，返回实际产生的费用。
    输入描述:
      只有一行，数字N，表示里程表的读数。
      (1<=N<=888888888)。
    输出描述:
      一个数字，表示实际产生的费用。以回车结束。
    示例1：
    输入
      5
    输出
      4
    说明
      5表示计费表的表面读数。
      表示实际产生的费用其实只有4块钱。
    示例2：
    输入
      17
    输出
      15
    说明
      17表示计费表的表面读数。
      15表示实际产生的费用其实只有15块钱。
    示例3：
    输入
      100
    输出
      81
    说明：100表示计费表的表面读数，81表示实际产生的费用其实只有81块钱
   */
  function main(N) {
    let ans = N,
      temp = 0,
      k = 0,
      j = 1;
    while (N > 0) {
      //先判断个位上是否跳了4，如果个位上是5~9，就先temp=1。
      if (N % 10 > 4) {
        temp += (N % 10 - 1) * k + j;
      } else {
        temp += (N % 10) * k;
      }
      k = k * 9 + j; //k代表跳了多少次4，多收了多少个1元
      j *= 10; //j代表位数，1代表个位，10代表十位
      N = Math.floor(N / 10); //相当于将N整体右移一位
      console.log(N);
    }
    console.log(ans - temp);
  }
  main(100)
  // 082 100%
  /*
  1.输入字符串s输出s中包含所有整数的最小和，
  说明：1字符串s只包含a~z,A~Z,+,-，
  2.合法的整数包括正整数，一个或者多个0-9组成，如：0,2,3,002,102
  3.负整数，负号开头，数字部分由一个或者多个0-9组成，如-2,-012,-23,-00023
  输入描述：包含数字的字符串
  输出描述：所有整数的最小和
  示例：
    输入：
      bb1234aa
  　输出
      10
  　输入：
      bb12-34aa
  　输出：
      -31
  说明：1+2-(34)=-31
   */
  function main(line) {
    let chars = line.split('');
    let sum = 0;
    for (let i = 0; i < chars.length; i++) {
      let c = chars[i];
      if (c == '-') {
        i++;
        let start = i;
        while (i < chars.length && !isNaN(chars[i])) {
          i++;
        }
        let substring = line.substring(start, i);
        if (substring.length > 0) {
          sum -= Number(substring);
        }
        i--;
        continue;
      }
      if (!isNaN(c)) {
        sum += Number(c);
      }
    }
    console.log(sum);
  }
  main("bb1234aa")
  main("bb12-34aa")
  // 084 95%
  /*
  小组中每位都有一张卡片
  卡片是6位以内的正整数
  将卡片连起来可以组成多种数字
  计算组成的最大数字
  输入描述：
    ","分割的多个正整数字符串
    不需要考虑非数字异常情况
    小组种最多25个人
   输出描述：
     最大数字字符串
   示例一
     输入
      22,221
     输出
      22221
    示例二
      输入
        4589,101,41425,9999
      输出
        9999458941425101
   */
  function main(nums) {
    let builder = nums.split(",")
      .sort((s1, s2) => {
        let v1 = s1.split("");
        let v2 = s2.split("");
        let len1 = v1.length;
        let len2 = v2.length;
        if (len1 == len2) {
          return s2-(s1);
        }
        let min = Math.min(len1, len2);
        for (let i = 0; i < min; i++) {
          let c1 = v1[i];
          let c2 = v2[i];
          if (c1 != c2) {
            return c2 - c1;
          }
        }
        if (len1 > len2) {
          return v1[0] - v1[min];
        } else {
          return v2[min] - v2[0];
        }
      })
    console.log(builder.join(''));
  }
  main("4589,101,41425,9999");
  main("22,221");
  // 085 95%
  /*
    有一个特殊的五键键盘
    上面有A、Ctrl-C、Ctrl-X、Ctrl-V、Ctrl-A
    A键在屏幕上输出一个字母A
    Ctrl-C将当前所选的字母复制到剪贴板
    Ctrl-X将当前选择的字母复制到剪贴板并清空所选择的字母
    Ctrl-V将当前剪贴板的字母输出到屏幕
    Ctrl-A选择当前屏幕中所有字母
    注意：
      1. 剪贴板初始为空
      2. 新的内容复制到剪贴板会覆盖原有内容
      3. 当屏幕中没有字母时,Ctrl-A无效
      4. 当没有选择字母时Ctrl-C、Ctrl-X无效
      5. 当有字母被选择时A和Ctrl-V这两个输出功能的键,
         会先清空所选的字母再进行输出
    给定一系列键盘输入,
    输出最终屏幕上字母的数量
    输入描述:
       输入为一行
       为简化解析用数字12345分别代替A、Ctrl-C、Ctrl-X、Ctrl-V、Ctrl-A的输入
       数字用空格分割
    输出描述:
        输出一个数字为屏幕上字母的总数量
    示例一:
        输入:
          1 1 1
        输出:
          3
   示例二:
        输入:
          1 1 5 1 5 2 4 4
        输出:
          2
   */
  function main(let args) {
    Scanner in = new Scanner(System.in);
    let ops = in .nextLine(); in .close();
    let list = ops.split(" ");
    let builder = new
    let ();
    let choose = "";
    let tab = "";
    for (let op: list) {
      switch (op) {
        case "1":
          choose = reset(builder, choose);
          builder.append('A');
          break;
        case "2":
          if (!choose.isEmpty()) {
            tab = choose;
          }
          break;
        case "3":
          if (!choose.isEmpty()) {
            tab = choose;
            choose = "";
            builder = new
            let ();
          }
          break;
        case "4":
          choose = reset(builder, choose);
          builder.append(tab);
          break;
        case "5":
          if (builder.length() != 0) {
            choose = builder.toString();
          }
          break;
        default:
          break;
      }
      console.log(builder);
      console.log(builder.length());
    }
    console.log(builder.length());
  }
  function reset(let builder,
    let choose) {
    if (!choose.isEmpty()) {
      builder.replace(0, choose.length(), "");
      choose = "";
    }
    return choose;
  }
  // 086 100%
  /*
  给定一个射击比赛成绩单
  包含多个选手若干次射击的成绩分数
  请对每个选手按其最高三个分数之和进行降序排名
  输出降序排名后的选手id序列
  条件如下
    1. 一个选手可以有多个射击成绩的分数，且次序不固定
    2. 如果一个选手成绩少于3个，则认为选手的所有成绩无效，排名忽略该选手
    3. 如果选手的成绩之和相等，则相等的选手按照其id降序排列
   输入描述:
     输入第一行
         一个整数N
         表示该场比赛总共进行了N次射击
         产生N个成绩分数
         2<=N<=100
     输入第二行
       一个长度为N整数序列
       表示参与每次射击的选手id
       0<=id<=99
     输入第三行
        一个长度为N整数序列
        表示参与每次射击选手对应的成绩
        0<=成绩<=100
   输出描述:
      符合题设条件的降序排名后的选手ID序列
   示例一
      输入:
        13
        3,3,7,4,4,4,4,7,7,3,5,5,5
        53,80,68,24,39,76,66,16,100,55,53,80,55
      输出:
        5,3,7,4
      说明:
        该场射击比赛进行了13次
        参赛的选手为{3,4,5,7}
        3号选手成绩53,80,55 最高三个成绩的和为188
        4号选手成绩24,39,76,66  最高三个成绩的和为181
        5号选手成绩53,80,55  最高三个成绩的和为188
        7号选手成绩68,16,100  最高三个成绩的和为184
        比较各个选手最高3个成绩的和
        有3号=5号>7号>4号
        由于3号和5号成绩相等  且id 5>3
        所以输出5,3,7,4
   */
  function main(args) {
    let n = Number( in .nextLine());
    let ids = toIntList( in .nextLine());
    let scores = toIntList( in .nextLine());
    let map = new Map();
    for (let i = 0; i < n; i++) {
      Integer id = ids.get(i);
      Integer score = scores.get(i);
      let list = map.getOrDefault(id, []);
      list.add(score);
      map.put(id, list);
    }
    let builder = new
    let ();
    map.entrySet()
      .stream()
      .filter(x - > x.getValue().size() >= 3)
      .sorted((o1, o2) - > {
        Integer sum1 = sumT3(o1.getValue());
        Integer sum2 = sumT3(o2.getValue());
        if (sum1.equals(sum2)) {
          return o2.getKey() - o1.getKey();
        } else {
          return sum2 - sum1;
        }
      })
      .map(Map.Entry::getKey)
      .forEach(x - > builder.append(x).append(","));
    console.log(builder.substring(0, builder.length() - 1));
  }
  function sumT3(let list) {
    list.sort(Integer::compareTo);
    let sum = 0;
    for (let i = list.size() - 1; i >= list.size() - 3; i--) {
      sum += list.get(i);
    }
    return sum;
  }
  function toIntList(let str) {
    return Arrays.stream(str.split(","))
      .map(Integer::parseInt)
      .collect(Collectors.toList());
  }