牛客网-前端刷题记录（简单级）

HJ1 字符串最后一个单词的长度√

输入：
hello nowcoder
输出：
8

console.info(readline().split(" ").pop().length);

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
rl.on("line", function (line) {
  const tokens = line.split(" ");
  console.log(tokens.pop().length);
});

HJ2 计算某字符出现次数√

输入：
ABCabc
A
输出： 2

let source = readline().toLowerCase();
let target = readline().toLowerCase();
console.info(arr.filter(item => item === target).length);

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
let lines = [];
rl.on("line", function (line) {
  lines.push(line);
  if (lines.length === 2) {
    let [str, target] = lines;
    let res = str
      .toLowerCase()
      .split("")
      .filter((item) => item === target.toLowerCase());
    console.info(res.length);
  }
});

HJ4 字符串分隔√

输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入： abc
输出： abc00000

let input = readline();
while (input.length >= 8) {
  console.info(input.slice(0, 8));
  input = input.slice(8);
}
if (input.length > 0) {
  console.info(`${input}00000000`.slice(0, 8));
}

HJ5 进制转换√

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
输入：0xAA
输出：170

console.info(parseInt(readline(), 16));

HJ6 质数因子√√

输入：180
输出：2 2 3 3 5

function g(num) {
  let res = [];
  for (let i = 2; i <= Math.sqrt(num); i++) {
    while (num % i === 0) {
      res.push(i);
      num /= i;
    }
  }
  if (num > 1) res.push(num);
  console.log(res.join(" "));
}
let num = parseInt(readline());
g(num);

HJ8 合并表记录√√

数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4

let n = Number(readline());
let resMap = {};
while (n > 0) {
  let [key, val] = readline().split(" ");
  if (resMap[key]) {
    resMap[key] = Number(resMap[key]) + Number(val);
  } else {
    resMap[key] = Number(val);
  }
  n--;
}
for (let item in resMap) {
  console.info(item + " " + resMap[item]);
}

HJ10 字符个数统计√

编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。

输入： abc
输出： 3

let inputArr = readline().split("");
let targetArr = inputArr.filter((item) => {
  let num = item.toString().charCodeAt(0);
  if (num >= 0 && num <= 127) {
    return item;
  }
});
let res = [...new Set(targetArr)].length;
console.info(res);

HJ11 数字颠倒√

输入：1516000
输出：0006151

console.info(readline().split('').reverse().join(''));

HJ12 字符串反转√

输入：abcd
输出：dcba

console.info(readline().split('').reverse().join(''));

HJ13 句子逆序√

输入：I am a boy
输出：boy a am I

console.info(readline().split(' ').reverse().join(' '));

HJ14 字符串排序√

输入：
9
cap
to
cat
card
two
too
up
boat
boot
输出：
boat
boot
cap
card
cat
to
too
two
up

let num = parseInt(readline());
let result = [];
for (let i = 0; i < num; i++) {
  result.push(readline());
}
result.sort();
for (let i of result) {
  console.info(i);
}

HJ15 求int型正整数在内存中存储时1的个数√

输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。
输入： 5
输出： 2
说明：5的二进制为 101

let num = Number(readline()).toString(2);
console.info(num.match(/1/g).length);

HJ21 简单密码√√

现在有一种密码变换算法。
九键手机键盘上的数字与字母的对应： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.
而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
数字和其它的符号都不做变换。
输入：
YUANzhi1987
输出：
zvbo9441987

let str = readline().split("");
let theMap = {
  a: 2,
  b: 2,
  c: 2,
  d: 3,
  e: 3,
  f: 3,
  g: 4,
  h: 4,
  i: 4,
  j: 5,
  k: 5,
  l: 5,
  m: 6,
  n: 6,
  o: 6,
  p: 7,
  q: 7,
  r: 7,
  s: 7,
  t: 8,
  u: 8,
  v: 8,
  w: 9,
  x: 9,
  y: 9,
  z: 9,
};
for (let i = 0; i < str.length; i++) {
  if (/[a-z]/.test(str[i])) {
    str.splice(i, 1, theMap[str[i]]);
  }
  if (/[A-Z]/.test(str[i])) {
    if (str[i].charCodeAt(0) === 90) {
      str.splice(i, 1, "a");
    } else {
      str.splice(
        i,
        1,
        String.fromCharCode(str[i].charCodeAt(0) + 1).toLowerCase()
      );
    }
  }
}
console.info(str.join(""));

HJ22 汽水瓶√√

输入：
3
10
81
0
输出：
1
5
40
说明：
样例 1 解释：用三个空瓶换一瓶汽水，剩一个空瓶无法继续交换
样例 2 解释：用九个空瓶换三瓶汽水，剩四个空瓶再用三个空瓶换一瓶汽水，剩两个空瓶，向老板借一个空瓶再用三个空瓶换一瓶汽水喝完得一个空瓶还给老板

function drink(n, result) {
  if (n < 2) {
    return result;
  } else if (n === 2) {
    return result + 1;
  }
  result += parseInt(n / 3);
  let m = parseInt(n / 3) + (n % 3);
  return drink(m, result);
}
let line;
while (line = readline()) {
  let res = drink(Number(line), 0);
  console.info(res);
}

function g(n) {
  if (n < 2) return 0;
  if (n === 2) return 1;
  return parseInt(n / 3) + g(parseInt(n / 3) + (n % 3));
}
let line;
while ((line = readline())) {
  let n = g(Number(line));
  if (n) console.info(n);
}

HJ23 删除字符串中出现次数最少的字符√√

输入：
aabcddd
输出：
aaddd
先获取出现次数最少的字符，然后删除

let input = readline().split("");
let theMap = {};
for (let item of input) {
  theMap[item] ? theMap[item]++ : (theMap[item] = 1);
}
let arr = Object.entries(theMap).sort((a, b) => a[1] - b[1]);
let removeItems = [];
for (let item of arr) {
  if (item[1] === arr[0][1]) {
    removeItems.push(item[0]);
  }
}
let res = "";
for (let item of input) {
  if (!removeItems.includes(item)) {
    res += item;
  }
}
console.info(res);

HJ31 单词倒排√

示例1
输入：
I am a student
输出：
student a am I
示例2
输入：
$bo*y gi!r#l
输出：
l r gi y bo

let arr = readline().replace(/[^a-zA-Z]/g,' ').split(' ');
let res = arr.filter(item => item !== '');
console.info(res.reverse().join(' '));

HJ34 图片整理√

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、“a"到"z”、"0"到"9"表示。
输入：
Ihave1nose2hands10fingers
输出：
0112Iaadeeefghhinnnorsssv

let strList = readline().split("");
strList.sort((a, b) => {
  return a.charCodeAt(0) - b.charCodeAt(0);
});
console.info(strList.join(""));

HJ35 蛇形矩阵

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
输入：
4
输出：
1 3 6 10
2 5 9
4 8
7

//先构造出第一行 剩下的依次截取后-1即可。
// 第一行：1 3 6 10 (1+2=3+3=6+4=10) :第一行n个数字，第二个等于第一个只值+2，第三个等于第二个值+3，第四个等于第三个值+4
// 第二行截掉第一行的第一个再减1: 2 5 9
// 第三行截掉第一行第二个再减2类似：4 8
// 第四行截掉第一行第三个再减3：7
let row = Number(readline());
let arr = [1];
for (var i = 2; i < row + 1; i++) {
  //确定第一行
  arr.push(arr[arr.length - 1] + i);
}
for (var j = 0; j < row; j++) {
  let str = "";
  arr.slice(j).forEach((item) => {
    str = str + (item - j) + " ";
  });
  console.log(str);
}

HJ37 统计每个月兔子的总数√√

有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
输入：
3 第三个月
输出：
2 总共有2只兔子

let readline = require("readline");
let rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
function getSum(month) {
  if (month < 3) {
    return 1;
  } else {
    return getSum(month - 1) + getSum(month - 2);
  }
}
rl.on("line", function (line) {
  console.info(getSum(line));
});

let n = Number(readline());
let cash = {};
function dp(n) {
  if (cash[n]) return cash[n];
  if (n < 3) return 1;
  cash[n - 1] = dp(n - 1);
  cash[n - 2] = dp(n - 2);
  return dp(n - 1) + dp(n - 2);
}
console.info(dp(n));

HJ40 统计字符√

输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\/;p0-=\][
输出：
26
3
10
12

let input = readline();
let all = input.length;
let enNum = input.match(/[a-zA-Z]/g);
let spaceNum = input.match(/[ ]/g);
let numberNum = input.match(/[0-9]/g);
let enLen = enNum ? enNum.length : 0;
let spaceLen = spaceNum ? spaceNum.length : 0;
let numberLen = numberNum ? numberNum.length : 0;
print(enLen);
print(spaceLen);
print(numberLen);
print(all - enLen - spaceLen - numberLen);

HJ51 输出单向链表中倒数第k个结点√

输入：
8
1 2 3 4 5 6 7 8
4
输出：
5

let line;
while ((line = readline())) {
  let arr = readline().split(" ");
  let index = parseInt(readline());
  console.log(arr.slice(-index)[0]);
}

HJ53 杨辉三角的变形

以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。
输入：
4
输出：
3

//杨辉三角规律                                行号  第一个偶数
//                    1                      1     -1
//                1   1   1                  2     -1
//            1   2   3   2   1              3     2
//         1  3   6   7   6   3   1          4     3
//      1  4  10  16  19  16  10  4  1       5     2
//   1  5  15 30  45  51  45  30  15 5  1    6     4
//
//  首个偶数在该行第几个的规律： -1 -1 （2 3 2 4）···（2 3 2 4）

let res = [2, 3, 2, 4];
let line;
while ((line = readline())) {
  let n = Number(line);
  if (n <= 2) {
    console.info(-1);
  } else {
    console.info(res[(n + 1) % 4]);
  }
}

HJ54 表达式求值√

给定一个字符串描述的算术表达式，计算出结果值。
输入字符串长度不超过 100 ，合法的字符包括 ”+, -, *, /, (, )” ， ”0-9” 。
输入：
400+5
输出：
405

console.info(eval(readline()))

HJ56 完全数计算√√

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
输入n，请输出n以内(含n)完全数的个数。
输入：
1000
输出：
3

let num;
while ((num = parseInt(readline()))) {
  let count = 0; //计数变量
  //第一个完全数是6，若小于6则输出0
  if (num < 6) {
    console.log(0);
  }
  for (let t = 6; t <= num; t++) {
    let sum = 0;
    //统计因数的和，计数到该数的1/2即可
    for (let i = 1; i <= t / 2; i++) {
      if (t % i == 0) sum += i;
    }
    if (sum == t) count++;
  }
  console.log(count);
}

function g(num) {
  let count = 0;
  for (let i = 6; i <= num; i++) {
    let sum = 0;
    for (let j = 1; j <= i / 2; j++) {
      if (i % j == 0) sum += j;
    }
    if (sum == i) count++;
  }
  console.log(count);
}
let num;
while ((num = parseInt(readline()))) {
  g(num);
}

HJ60 查找组成一个偶数最接近的两个素数√

任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。
输入：
20
输出：
7
13
输入：
4
输出：
2
2

function isSuShu(n) {
  if (n < 2) return false;
  let res = true;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) res = false;
  }
  return res;
}
function getRes(n) {
  let a = n / 2;
  let b = a;
  while (a > 1 && b > 1) {
    if (isSuShu(a) && isSuShu(b)) {
        break;
    } else {
      a--;
      b++;
    }
  }
    return [a,b];
}

let line;
while ((line = readline())) {
  let [a, b] = getRes(Number(line));
  console.info(a);
  console.info(b);
}

HJ61 放苹果√√

把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。
输入：
7 3
输出：
8

// 递归
// 设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，
// 当n>m(盘子大于苹果)：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)
// 当n<=m(盘子小于等于苹果)：不同的放法可以分成两类：
// 1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);
// 2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n) = f(m-n,n).
// 而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n)
// 递归出口条件说明：
// 当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
// 当没有苹果可放时，定义为１种放法；
// 递归的两条路，第一条n会逐渐减少，终会到达出口n==1;
// 第二条m会逐渐减少，因为n>m时，我们会return f(m,m)　所以终会到达出口m==0．
function count(apple, disk) {
  if (apple === 0 || disk === 1) {
    return 1;
  } else if (disk > apple) {
    return count(apple, apple);
  } else {
    return count(apple, disk - 1) + count(apple - disk, disk);
  }
}

let [apple, disk] = readline().split(" ").map(Number);
console.info(count(apple, disk));

HJ62 查找输入整数二进制中1的个数√

输入一个正整数，计算它在二进制下的1的个数。
注意多组输入输出！！！！！！
输入：
5
输出：
2
说明：
5的二进制表示是101，有2个1
输入：
0
输出：
0

let line;
while ((line = readline())) {
  let i = Number(line).toString(2);
  let ii = i.match(/1/g);
  console.info(ii.length);
}

HJ72 百钱买百鸡问题√

公元五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
现要求你打印出所有花一百元买一百只鸡的方式。
输入描述：
输入任何一个整数，即可运行程序。
输出描述：
输出有数行，每行三个整数，分别代表鸡翁，母鸡，鸡雏的数量
输入：
1
输出：
0 25 75
4 18 78
8 11 81
12 4 84

for (let i = 0; i <= 20; i++) {
  for (let j = 0; j <= 33; j++) {
    for (let k = 0; k <= 100; k++) {
      if (i + j + k == 100 && 5 * i + 3 * j + k * (1/3) == 100) {
        console.info(i, j, k);
      }
    }
  }
}

HJ73 计算日期到天数转换√

输入：
2012 12 31
输出：
366

let input = readline();
let [y, m ,d] = input.split(' ');
let sum = 0;
for(let i = 1; i < Number(m); i++) {// 1到m-1月
    sum += new Date(Number(y), i, 0).getDate();
}
console.info(sum + Number(d));

HJ76 尼科彻斯定理√√

验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
例如：
1^3=1
2^3=3+5
3^3=7+9+11
4^3=13+15+17+19
输入：
6
输出：
31+33+35+37+39+41

前n项和公式为：Sn=n*a1+n(n-1)d/2 或 Sn=n(a1+an)/2

// 遍历查找
// 1^3=1            1的立方由1个连续奇数和构成
// 2^3=3+5          2的立方由2个连续奇数和构成
// 3^3=7+9+11       3的立方由3个连续奇数和构成
// 4^3=13+15+17+19  4的立方由4个连续奇数和构成
//                  m的立方由m个连续奇数和构成
// 可以通过等比数列求和得到连续奇数之和为：
// m∗i+m∗(m−1)，即我们遍历1到m^3
// 找到满足上述等差数列之和等于三次幂的第一个数，然后输出以它开始的连续的m个奇数即可。
// “等差数列{an}的通项公式为：an=a1+(n-1)d。前n项和公式为：Sn=n*a1+n(n-1)d/2或Sn=n(a1+an)/2 。”
let n = Number(readline());
let res = [];
let pow = Math.pow(n, 3);
for (let a1 = 1; a1 < pow; a1 += 2) {
  // 比较等差数列（等差为2）和与三次幂是否相等
  if (n * a1 + n * (n - 1) === pow) {
    // 找到首项a1
    res.push(a1);
    // 相等开始输出连续n个数字
    for (let j = 1; j < n; j++) {
      res.push(a1 + j * 2);
    }
  }
}
console.info(res.join("+"));

HJ80 整型数组合并√

将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。
输入：
3
1 2 5
4
-1 0 3 2
输出：
-101235

// 合并、去重、排序
readline();
let arr1 = readline();
readline();
let arr2 = readline();
let newArr = (arr1 + " " + arr2).split(" ");
let arr = [...new Set(newArr)];
arr.sort((a, b) => a - b);
console.info(arr.join(""));

HJ81 字符串字符匹配√

输入：
bc
abc
输出：
true
说明：
其中abc含有bc，输出"true"

let shortStr = null;
while ((shortStr = readline())) {
  let longStr = readline();
  let result = "true";
  for (let item of shortStr) {
    if (!longStr.includes(item)) {
      result = "false";
      break;
    }
  }
  console.log(result);
}

HJ83 二维数组操作

输入描述：
输入数据按下列顺序输入：
1 表格的行列值
2 要交换的两个单元格的行列值
3 输入要插入的行的数值
4 输入要插入的列的数值
5 输入要查询的单元格的坐标
输出描述：
输出按下列顺序输出：
1 初始化表格是否成功，若成功则返回0， 否则返回-1
2 输出交换单元格是否成功
3 输出插入行是否成功
4 输出插入列是否成功
5 输出查询单元格数据是否成功
示例1
输入：
4 9
5 1 2 6
0
8
2 3
4 7
4 2 3 2
3
3
4 7
输出：
0
-1
0
-1
0
0
-1
0
0
-1
说明：
本组样例共有2组样例输入。
第一组样例：
1.初始化数据表为4行9列，成功
2.交换第5行1列和第2行6列的数据，失败。因为行的范围应该是(0,3)，不存在第5行。
3.在第0行上方添加一行，成功。
4.在第8列左边添加一列，失败。因为列的总数已经达到了9的上限。
5.查询第2行第3列的值，成功。
第二组样例：
1.初始化数据表为4行7列，成功
2.交换第4行2列和第3行2列的数据，失败。因为行的范围应该是(0,3)，不存在第4行。
3.在第3行上方添加一行，成功。
4.在第3列左边添加一列，成功。
5.查询第4行7列的值，失败。因为虽然添加了一行一列，但数据表会在添加后恢复成4行7列的形态，所以行的区间仍然在[0,3]，列的区间仍然在[0,6]，无法查询到(4,7)坐标。

function res1(arr) {
  let [m, n] = arr[0].split(" ").map(Number);
  let [x1, y1, x2, y2] = arr[1].split(" ").map(Number);
  let x = Number(arr[2]);
  let y = Number(arr[3]);
  let [newX, newY] = arr[4].split(" ").map(Number);

  let mArr, table;

  if (m <= 9 && n <= 9) {
    mArr = new Array(m).fill(1);
    table = new Array(n).fill(mArr);
    console.info(0);
  } else {
    console.info(-1);
  }

  if (x1 > m - 1 || y1 > n - 1 || x2 > m - 1 || y2 > n - 1) {
    print(-1);
  } else {
    let a = table[y1][x1];
    table[y1][x1] = table[y2][x2];
    table[y2][x2] = a;
    print(0);
  }

  if (x <= m - 1 && m <= 8) {
    table.splice(x - 1, 0, mArr);
    table.pop();
    print(0);
  } else {
    print(-1);
  }

  if (y <= n - 1 && n <= 8) {
    table.map((item) => {
      item.splice(y - 1, 0, 1);
      item.pop();
    });
    print(0);
  } else {
    print(-1);
  }

  if (newX <= table[0].length - 1 && newY <= table.length - 1) {
    print(0);
  } else {
    print(-1);
  }
}

let list = [];
let line;
while ((line = readline())) {
  list.push(line);
  if (list.length === 5) {
    res1(list);
    list = [];
  }
}

HJ84 统计大写字母个数√

// 输入：A 1 0 1 1150175017(&^%&$vabovbaoadd 123#$%#%#O
// 输出：2
const reg = /([A-Z])/g;
while ((line = readline())) {
  const groups = line.match(reg);
  if (groups) {
    console.info(groups.length);
  } else {
    console.info(0);
  }
}

HJ85 最长回文子串√

输入：
cdabbacc
输出：
4
说明：
abba为最长的回文子串

//暴力解，获取全部字串并依次判断是否为回文，同时不断更新最长的字串长度
function isHui(str) {
  for (let i = 0; i < str.length; i++) {
    if (str[i] != str[str.length - 1 - i]) {
      return false;
    }
  }
  return true;
}
function getMaxHuiLength(str) {
  let currentHuiLength = 0;
  let maxHuiLength = 0;
  for (let i = 0; i < s.length; i++) {
    for (let j = i; j < s.length; j++) {
      let str = s.substring(i, j + 1);
      if (isHui(str)) {
        currentHuiLength = str.length;
      }
      maxHuiLength = Math.max(currentHuiLength, maxHuiLength);
    }
  }
  return maxHuiLength;
}
let s = readline();
console.info(getMaxHuiLength(s));

HJ86 求最大连续bit数√

输入：
200
输出：
2
说明：
200的二进制表示是11001000，最多有2个连续的1。

let line;
while ((line = readline())) {
  let res = Number(line)
    .toString(2)
    .split("0")
    .sort((a, b) => Number(b) - Number(a))[0].length;
  console.info(res);
}

HJ87 密码强度等级

输入：
38$@NoNoN
输出：
VERY_SECURE
说明：
样例的密码长度大于等于8个字符，得25分；大小写字母都有所以得20分；有两个数字，所以得20分；包含大于1符号，所以得25分；由于该密码包含大小写字母、数字和符号，所以奖励部分得5分，经统计得该密码的密码强度为25+20+20+25+5=95分。

function solution(str) {
  let score = 0;

  // 密码长度
  if (str.lenght <= 4) {
    score += 5;
  } else if (str.length <= 7) {
    score += 10;
  } else {
    score += 25;
  }
  let lowerCaseCharNum = 0; //英文小写字母
  let upperCaseCharNum = 0; //英文大写字母
  let numberNum = 0; //数字个数
  let otherNum = 0; //符号

  // 每种字符可能的长度
  for (let i = 0; i < str.length; i++) {
    let char = str.charAt(i);
    if (/[a-z]/.test(char)) {
      lowerCaseCharNum++;
    } else if (/[A-Z]/.test(char)) {
      upperCaseCharNum++;
    } else if (/[1-9]/.test(char)) {
      numberNum++;
    } else if (isOtherChar(char)) {
      otherNum++;
    }
  }

  // 字母
  if (!lowerCaseCharNum && !upperCaseCharNum) {
    score += 0;
  } else if (lowerCaseCharNum && upperCaseCharNum) {
    score += 20;
  } else {
    score += 10;
  }

  // 数字
  if (numberNum === 1) {
    score += 10;
  } else if (numberNum > 1) {
    score += 20;
  }

  // 符号
  if (otherNum === 1) {
    score += 10;
  } else if (otherNum > 1) {
    score += 25;
  }

  // 奖励
  if (lowerCaseCharNum && upperCaseCharNum && numberNum && otherNum) {
    score += 5;
  } else if ((lowerCaseCharNum || upperCaseCharNum) && numberNum && otherNum) {
    score += 3;
  } else if ((lowerCaseCharNum || upperCaseCharNum) && numberNum) {
    score += 2;
  }

  if (score >= 90) {
    return "VERY_SECURE";
  } else if (score >= 80) {
    return "SECURE";
  } else if (score >= 70) {
    return "VERY_STRONG";
  } else if (score >= 60) {
    return "STRONG";
  } else if (score >= 50) {
    return "AVERAGE";
  } else if (score >= 25) {
    return "WEAK";
  }
  return "VERY_WEAK";
}

// 判断是否是其他字符
function isOtherChar(char) {
  let num = parseInt(char.charCodeAt(0));
  if (num >= 0x21 && num <= 0x2f) {
    return true;
  } else if (num >= 0x3a && num <= 0x40) {
    return true;
  } else if (num >= 0x5b && num <= 0x60) {
    return true;
  } else if (num >= 0x7b && num <= 0x7e) {
    return true;
  }
  return false;
}

let line;
while ((line = readline())) {
  console.log(solution(line));
}

HJ91 走方格的方案数√

请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走
注：沿棋盘格之间的边缘线行走
输入：
2 2
输出：
6

// f(m, n) = f(m, n - 1) + f(m - 1, n)
// 以左上角为mn,右下角为00
const dp = (m, n) => {
  if (m === 0 || n === 0) {
    return 1;
  }
  // 目的地的上一步只可能是同一行的左侧或者同一列的上侧
  return dp(m, n - 1) + dp(m - 1, n);
};
while ((line = readline())) {
  const [n, m] = line.split(" ").map(Number);
  console.log(dp(m, n));
}

HJ94 记票统计√

输入：
4
A B C D
8
A D E CF A GG A B
输出：
A : 3
B : 1
C : 0
D : 1
Invalid : 3
说明：
E CF GG三张票是无效的，所以Invalid的数量是3.

let personsNum = readline();
let persons = readline().split(" ");
let voteNum = Number(readline());
let votes = readline().split(" ");
let validNum = 0;
for (let item of persons) {
  let count = votes.filter((one) => one === item).length;
  validNum += count;
  console.info(`${item} : ${count}`);
}
console.info(`Invalid : ${voteNum - validNum}`);

HJ96 表示数字√

将一个字符中所有的整数前后加上符号“”，其他字符保持不变。连续的数字视为一个整数。
输入：
Jkdi234klowe90a3
输出：
Jkdi234klowe90a3*

let input;
while ((input = readline())) {
  let res = input.replace(/[0-9]+/g, function (item) {
    return "*" + item + "*";
  });
  console.info(res);
}

HJ97 记负均正√

首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。
0即不是正整数，也不是负数，不计入计算。如果没有正数，则平均值为0。
输入：
11
1 2 3 4 5 6 7 8 9 0 -1
输出：
1 5.0

let len;
while ((len = readline())) {
  len = parseInt(len);
  let inputArr = readline().split(" ");
  let lessNum = 0;
  let sum = 0;
  let sumNum = 0;
  for (let item of inputArr) {
    if (parseInt(item) > 0) {
      sum += parseInt(item);
      sumNum++;
    }
    if (parseInt(item) < 0) {
      lessNum++;
    }
  }
  console.info(lessNum, (sum / sumNum).toFixed(1));
}

HJ99 自守数√

自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n(包括n)以内的自守数的个数
输入：6
输出：4
说明：
有0，1，5，6这四个自守数
输入：1
输出：2
说明：
有0, 1这两个自守数

let line;
while ((line = readline())) {
  let num = parseInt(line);
  let count = 0;
  for (let i = 0; i <= num; i++) {
    let power = Math.pow(i, 2);
    let str = String(power);
    let idot = String(i);
    if (str.endsWith(idot)) {
      count++;
    }
  }
  console.log(count);
}

HJ100 等差数列√

等差数列 2，5，8，11，14。。。。
（从 2 开始的 3 为公差的等差数列）
输出求等差数列前n项和
输入：2
输出：7
说明：
2+5=7
输入：275
输出：113575
说明：
2+5+…+821+824=113575

let n = parseInt(readline());
let count = 2;
let last = 2;
for (let i = 1; i < n; i++) {
  last += 3;
  count += last;
}
console.info(count);

HJ102 字符统计√

输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。
输入：
aaddccdc
输出：
cda
说明：
样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.

let str = readline().split("");
let map = new Map();
for (let i = 0; i < str.length; i++) {
  map.get(str[i]) ? map.set(str[i], map.get(str[i]) + 1) : map.set(str[i], 1);
}
let arr = Array.from(map);
arr.sort((a, b) => {
  if (a[1] === b[1]) {
    return a[0].charCodeAt() - b[0].charCodeAt();
  } else {
    return b[1] - a[1];
  }
});
let res = "";
for (let item of arr) {
  res += item[0];
}
console.info(res);

HJ106 字符逆序√

输入：
I am a student
输出：
tneduts a ma I

let input = readline();
console.info(input.split('').reverse().join(''));

HJ108 求最小公倍数√√

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值
输入：5 7
输出：35
输入：2 4
输出：4

// 先求最大公约数，再求最小公倍数     最小公倍数 = （x*y）/最大公约数
function gongyue(a, b) {
  while (a % b !== 0) {
    let temp = a % b;
    a = b;
    b = temp;
  }
  return b;
}
function gongbei(a, b) {
  return (a * b) / gongyue(a, b);
}
let [a, b] = readline().split(" ").map(Number);
console.info(gongbei(a, b));

• HJ7 取近似值

输入：5.5
输出：6
说明：
0.5>=0.5，所以5.5需要向上取整为6

输入：2.499
输出：2
说明：
0.499<0.5，2.499向下取整为2

let num = readline();
let intNum = parseInt(num);
if(parseFloat(num) >= intNum + 0.5) {
    console.info(intNum + 1);
} else {
    console.info(intNum);
}

• HJ9 提取不重复的整数

输入：9876673
输出：37689

let input = readline();
let res = "";
let map = {};
for (let i = input.length - 1; i >= 0; i--) {
  if (!map[input[i]]) {
    res += input[i];
    map[input[i]] = true;
  }
}
console.info(res);

• HJ26 字符串排序

编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y

输入：A Famous Saying: Much Ado About Nothing (2012/8).
输出：A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).

let res = "";
let arr = readline().split("");
let sorted = [];
for (let i = 0; i < 26; i++) {
  for (let j = 0; j < arr.length; j++) {
    // 为大写字母或小写字母（从A~Z或a~z排序）
    if (arr[j].charCodeAt(0) == 65 + i || arr[j].charCodeAt(0) == 97 + i) {
      sorted.push(arr[j]);
    }
  }
}
for (let i = 0; i < arr.length; i++) {
  if (!/[A-Za-z]/g.test(arr[i])) {
    sorted.splice(i, 0, arr[i]);
  }
}
console.log(sorted.join(""));

• HJ31 单词倒排

对字符串中的所有单词进行倒排。说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；

输入：$bo*y gi!r#l
输出：l r gi y bo

let arr = readline().replace(/[^a-zA-Z]/g,' ').split(' ');
let res = arr.filter(item => item !== '');
console.info(res.reverse().join(' '));

• HJ40 统计字符

输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。

输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\/;p0-=\][
输出：
26
3
10
12

let input = readline();
let all = input.length;
let enNum = input.match(/[a-zA-Z]/g);
let spaceNum = input.match(/[ ]/g);
let numberNum = input.match(/[0-9]/g);
let enLen = enNum ? enNum.length : 0;
let spaceLen = spaceNum ? spaceNum.length : 0;
let numberLen = numberNum ? numberNum.length : 0;
print(enLen);
print(spaceLen);
print(numberLen);
print(all - enLen - spaceLen - numberLen);

BC173 牛牛逆序输出

描述：牛牛在尝试把一个整数逆序地输出。
输入描述：输入一个正整数 n。保证个位数不是 0 
输出描述：逆序输出这个正整数。
示例1
	输入：2345
	输出：5432

let list = readline().split("");
let res = "";
function rev(arr) {
  if (arr.length === 0) {
    return;
  }
  res += arr.pop();
  return rev(arr);
}
rev(list);
console.info(res);