牛客网HW机试题JS解答（81-108）

HJ81 字符串字符匹配

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    let tokens = [];
    while ((line = await readline())) {
        tokens.push(line);
    }
    let [part, sum] = tokens;
    //判断字符串的匹配使用现成的match方法
    //  console.log(sum.match(part)!=null?true:false)
    //短字符串中的字符都在长字符串出现返回true，不要求个数可以使用set数据结构
    let s = [...new Set([...part])];
    let f = function (arr, str) {
        for (let i = 0; i < arr.length; i++) {
            if (!str.includes(arr[i])) return false;
        }
        return true;
    };
    console.log(f(s, sum));
})();

HJ82 将真分数分解为埃及分数

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
rl.on('line', function (line) {
    let [a,b] = line.split('/');
    let result = [];

    while(a > 0) {
        result.push('1/' + b);
        a--;
    }
    
    console.log(result.join('+'))
});

HJ83 二维数组操作

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    let linearr = [];
    while ((line = await readline())) {
        linearr.push(line);
    }
    let inputarr = []; //初始化要循环判断的数组
    for (let i = 0; i < linearr.length; i += 5) {
        //每5个一组
        inputarr.push(linearr.slice(i, i + 5));
    }
    // console.log(inputarr);
    inputarr.forEach((item) => {
        //判断行列数
        let rowCol = item[0].split(" ").map(Number);
        let [row, col] = rowCol;
        if (row > 9 || col > 9) {
            console.log(-1);
        } else {
            console.log(0);
        }
        //判断交换的坐标值
        let exchangeXy = item[1].split(" ").map(Number);
        if (
            exchangeXy[0] > row - 1 ||
            exchangeXy[2] > row - 1 ||
            exchangeXy[1] > col - 1 ||
            exchangeXy[3] > col - 1
        ) {
            console.log(-1);
        } else {
            console.log(0);
        }
        //判断插入行
        // 插入行的数字不能大于索引的最大值，总行数不能超过9
        let addRow = Number(item[2]);
        if (addRow > row - 1 || row === 9) {
            console.log(-1);
        } else {
            console.log(0);
        }
        //判断插入列
        // 插入列的数字不能大于索引的最大值，总列数不能超过9
        let addCol = Number(item[3]);
        if (addCol > col - 1 || col === 9) {
            console.log(-1);
        } else {
            console.log(0);
        }
        //判断查询值
        let queryXy = item[4].split(" ").map(Number);
        let [querRow, querCol] = queryXy;
        if (querRow > row - 1 || querCol > col - 1) {
            console.log(-1);
        } else {
            console.log(0);
        }
    });
})();

HJ84 统计大写字母个数

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    while(line = await readline()){
        let strArr = line.split('');
        let res = 0;
        strArr.forEach(item => {
            if(/[A-Z]/.test(item)){
                res++
            }
        })
        console.log(res)
    }
}()

HJ85 最长回文子串

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    while ((line = await readline())) {
        let maxLen = 1;
        let tempStr = "";
        for (let i = 0; i < line.length; i++) {
            // 第一层循环，找到首字母的位置
            for (let j = i + 1; j < line.length; j++) {
                // 第二层循环，找到长度
                tempStr = line.slice(i, j + 1);
                if (
                    tempStr === tempStr.split("").reverse().join("") &&
                    tempStr.length > maxLen
                ) {
                    // 判断回文串，和回文串的长度大小比较
                    maxLen = tempStr.length;
                }
            }
        }
        console.log(maxLen);
    }
})();

HJ86 求最大连续bit数

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    while(line = await readline()){
        let numStr = Number(line).toString(2);
        let arr = numStr.match(/1+/g).map(item => item.length);
        let maxL = Math.max(...arr);
        console.log(maxL);
    }
}()

HJ87 密码强度等级

密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。  
  
一、密码长度:  
5 分: 小于等于4 个字符  
10 分: 5 到7 字符  
25 分: 大于等于8 个字符  
  
二、字母:  
0 分: 没有字母  
10 分: 密码里的字母全都是小（大）写字母  
20 分: 密码里的字母符合”大小写混合“  
  
三、数字:  
0 分: 没有数字  
10 分: 1 个数字  
20 分: 大于1 个数字  
  
四、符号:  
0 分: 没有符号  
10 分: 1 个符号  
25 分: 大于1 个符号  
  
五、奖励（只能选符合最多的那一种奖励）:  
2 分: 字母和数字  
3 分: 字母、数字和符号  
5 分: 大小写字母、数字和符号

最后的评分标准:  
>= 90: 非常安全  
>= 80: 安全（Secure）  
>= 70: 非常强  
>= 60: 强（Strong）  
>= 50: 一般（Average）  
>= 25: 弱（Weak）  
>= 0:  非常弱（Very_Weak）  
  
对应输出为：   
VERY_SECURE  
SECURE  
VERY_STRONG  
STRONG  
AVERAGE  
WEAK  
VERY_WEAK  
  
请根据输入的密码字符串，进行安全评定。  
  
注：  
字母：a-z, A-Z  
数字：0-9  
符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)  
!"#$%&'()*+,-./     (ASCII码：0x21~0x2F)  
:;<=>?@             (ASCII码：0x3A~0x40)  
[\]^_`              (ASCII码：0x5B~0x60)  
{|}~                (ASCII码：0x7B~0x7E)  
  
提示:  
1 <= 字符串的长度<= 300  

输入描述：输入一个string的密码

输出描述：输出密码等级

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    while ((line = await readline())) {
        let count = 0;
        let numReg = new RegExp(/[0-9]/, "g");
        let letterReg = new RegExp(/[a-zA-Z]/, "g");
        let symbolReg = new RegExp(/[^0-9a-zA-Z]/, "g");
        let obj = {
            // 用来在判断的时候，添加加分项
            a: 0, // 字母
            b: 0, // 数字
            c: 0, // 符号
        };

        if (line.length > 4) {
            // 密码长度
            if (line.length > 7) {
                count += 25;
            } else {
                count += 10;
            }
        } else {
            count += 5;
        }

        if (line.match(letterReg)) {
            // 判断是否包含大小写字母
            obj.a = 1;
            let arr = line.match(letterReg);
            let str = arr.join("");
            let lowerArr = str.match(/[a-z]/g); // 小写字母
            let upperArr = str.match(/[A-Z]/g); // 大写字母
            if (
                (lowerArr && lowerArr.length === arr.length) ||
                (upperArr && upperArr.length === arr.length)
            ) {
                // 字母全是大写字母，或者全是小写字母
                count += 10;
            } else {
                count += 20;
                obj.a = 2;
            }
        } else {
            count += 0;
        }

        if (line.match(numReg)) {
            // 判断是否包含数字
            obj.b = 1;
            if (line.match(numReg).length > 1) {
                count += 20;
            } else {
                count += 10;
            }
        } else {
            count += 0;
        }

        if (line.match(symbolReg)) {
            // 判断是否包含符号
            obj.c = 1;
            if (line.match(symbolReg).length > 1) {
                count += 25;
            } else {
                count += 10;
            }
        } else {
            count += 0;
        }

        if (obj.a >= 1 && obj.b === 1) {
            if (obj.a === 2 && obj.c === 1) {
                // 大小写字母、数字和符号
                count += 5;
            } else if (obj.a === 1 && obj.c === 1) {
                // 字母、数字和符号
                count += 3;
            } else {
                // 字母和数字
                count += 2;
            }
        }
        let arr = [
            "VERY_SECURE",
            "SECURE",
            "VERY_STRONG",
            "STRONG",
            "AVERAGE",
            "WEAK",
            "VERY_WEAK",
        ];
        if (count >= 90) {
            console.log(arr[0]);
        } else if (count >= 80) {
            console.log(arr[1]);
        } else if (count >= 70) {
            console.log(arr[2]);
        } else if (count >= 60) {
            console.log(arr[3]);
        } else if (count >= 50) {
            console.log(arr[4]);
        } else if (count >= 25) {
            console.log(arr[5]);
        } else {
            console.log(arr[6]);
        }
    }
})();

HJ88 扑克牌大小

// 解题思路：
// 两副手牌主要分为两种情况，一种手牌数量不对等，另一种手牌数量对等。
// 第一种情况进行分析，判断两副手牌含有炸弹和王炸的情况，都没有则输出错误，都有则输出手牌数量少的（必然是王炸），否则就输出有炸弹或王炸的那副手牌
// 第二种情况就简单多了，只要有可能是个子，对子，三个，炸弹，顺子相互比较。顺子已经从小到大排列好了。所以这几种手牌都只需要比较首张牌的大小。
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
const card = [
    "3",
    "4",
    "5",
    "6",
    "7",
    "8",
    "9",
    "10",
    "J",
    "Q",
    "K",
    "A",
    "2",
    "joker",
    "JOKER",
];
void (async function () {
    while ((line = await readline())) {
        let idx = 0;
        for (let i = 0; i < line.length; i++) {
            if (line[i] === "-") {
                idx = i;
            }
        }
        let arr1 = line.slice(0, idx).split(" ");
        let arr2 = line.slice(idx + 1).split(" ");
        // 手牌数量不相同的情况
        if (arr1.length !== arr2.length) {
            if (
                hasBombORjokers(arr1) === false &&
                hasBombORjokers(arr2) === false
            ) {
                //arr1和arr2都没有炸弹和王炸
                console.log("ERROR");
            } else if (
                hasBombORjokers(arr1) === true &&
                hasBombORjokers(arr2) === true
            ) {
                let temp =
                    arr1.length < arr2.length ? arr1.join(" ") : arr2.join(" ");
                console.log(temp);
            } else if (hasBombORjokers(arr1) === true) {
                // 只有arr1有炸弹或王炸
                console.log(arr1.join(" "));
            } else if (hasBombORjokers(arr2) === true) {
                // 只有arr2有炸弹或王炸
                console.log(arr2.join(" "));
            }
        } else {
            // 顺子相互比较的情况
            if (arr1.length === 5) {
                compare(arr1[0], arr2[0], arr1, arr2);
            } else {
                // 个子，对子，三个，炸弹相互比较的情况
                let n1 = arr1[0];
                let n2 = arr2[0];
                compare(n1, n2, arr1, arr2);
            }
        }
    }
})();
// 判断是否含有炸弹或王炸
function hasBombORjokers(arr) {
    if (
        (arr.indexOf("joker") >= 0 && arr.indexOf("JOKER") >= 0) ||
        (arr.every((val) => val === arr[0]) && arr.length === 4)
    ) {
        return true;
    }
    return false;
}
// 比较手牌大小
function compare(num1, num2, arr1, arr2) {
    // 查找大小
    let c1 = card.indexOf(num1);
    let c2 = card.indexOf(num2);
    if (c1 > c2) {
        console.log(arr1.join(" "));
    } else {
        console.log(arr2.join(" "));
    }
}

HJ89 24点运算

var readLine = require("readline");
rl = readLine.createInterface({
    input: process.stdin,
    output: process.stdout,
});

var lineNum = 1;
var inputs = [];
rl.on("line", function (input) {
    inputs.push(input.trim());
    if (inputs.length === lineNum) {
        algorithmExe(inputs);
        inputs = [];
    }
});

function puke2Num(str) {
    var num = Number(str);
    if (!isNaN(Number(str))) {
        return num;
    }
    if (str === "J") return 11;
    if (str === "Q") return 12;
    if (str === "K") return 13;
    if (str === "A") return 1;
    return null;
}
function check(nums) {
    for (let i = 0; i < nums.length; i++) {
        const element = nums[i];
        if (!element) {
            return false;
        }
    }
    return true;
}

function extracOpe(ope) {
    switch (ope) {
        case 0:
            return "+";
        case 1:
            return "-";
        case 2:
            return "*";
        case 3:
            return "/";
    }
}

function calc(a, b) {
    return [a + b, a - b, a * b, a / b];
}
function algorithmExe(inputArr) {
    var pukeNums = inputArr[0].split(" ").map((item) => puke2Num(item));
    if (!check(pukeNums)) {
        console.log("ERROR");
        return;
    }
    for (let i = 0; i < pukeNums.length; i++) {
        const a = pukeNums[i];
        for (let j = 0; j < pukeNums.length; j++) {
            if (j === i) continue;
            const b = pukeNums[j];
            var calcs = calc(a, b);
            for (let k = 0; k < calcs.length; k++) {
                var ab = calcs[k];
                for (let m = 0; m < pukeNums.length; m++) {
                    if (m !== i && m !== j) {
                        var calcs1 = calc(ab, pukeNums[m]);
                        for (let l = 0; l < calcs1.length; l++) {
                            const abc = calcs1[l];
                            for (let n = 0; n < pukeNums.length; n++) {
                                if (n !== m && n !== j && n !== i) {
                                    var abcd = calc(abc, pukeNums[n]);
                                    for (let o = 0; o < abcd.length; o++) {
                                        if (abcd[o] === 24) {
                                            logResult(
                                                pukeNums[i],
                                                pukeNums[j],
                                                pukeNums[m],
                                                pukeNums[n],
                                                k,
                                                l,
                                                o
                                            );
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    console.log("NONE");
}

function num2Puke(num) {
    if (num >= 2 && num <= 10) {
        return num;
    }
    if (num === 11) return "J";
    if (num === 12) return "Q";
    if (num === 13) return "K";
    if (num === 1) return "A";
}

function logResult(a1, b1, c1, d1, ope1, ope2, ope3) {
    var a = num2Puke(a1);
    var b = num2Puke(b1);
    var c = num2Puke(c1);
    var d = num2Puke(d1);
    var str =
        a + extracOpe(ope1) + b + extracOpe(ope2) + c + extracOpe(ope3) + d;
    console.log(str);
}

HJ90 合法IP

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    while ((line = await readline())) {
        let status = "YES";
        //判断除了数字和 . 以外有没有其他字符
        if (/[^0-9\.]/.test(line)) status = "NO";
        // .的个数为3
        let arrOfdot = line.split("").filter((i) => i === ".");
        if (arrOfdot.length !== 3) status = "NO";
        //以.拆分得到的数组每个位置不能为空字符串
        // 每个数在0-255之间
        // 每个数如果大于0的时候不能以0开头
        let arr = line.split(".");
        arr.forEach((item) => {
            if (item.length === 0) return (status = "NO");
            if (Number(item) < 0 || Number(item) > 255) return (status = "NO");
            if (Number(item) > 0 && item.startsWith(0)) return (status = "NO");
        });
        console.log(status);
    }
})();

HJ91 走方格的方案数

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    while ((line = await readline())) {
        let lineArr = line.split(" ").map(Number);
        let [n, m] = lineArr;
        console.log(solution(n, m));
    }
    /**
     * 动态规划
     * dp[i][j] = dp[i-1][j] + dp[i][j-1]
     * 举个例子，2×2的网格
     *      (1)————(1)————(1)
     *       |      |      |
     *      (1)————(2)————(3)
     *       |      |      |
     *      (1)————(3)————(6)
     * 每个顶点标注到达网格的右下角的走路的方案总数（括号里面的数）
     * 即每一个顶点的方案数等于其上侧的方案数和其左侧的方案数之和
     * dp[i][j] = dp[i-1][j] + dp[i][j-1]
     */
    function solution(n, m) {
        let dp = new Array(n + 1).fill().map((e) => new Array(m + 1).fill(1));
        for (let i = 1; i <= n; i++) {
            for (let j = 1; j <= m; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[n][m];
    }
})();

HJ92 在字符串中找出连续最长的数字串

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    while ((line = await readline())) {
        let max = 1;
        let maxStrArr = [];
        for (let i = 0; i < line.length; i++) {
            for (let j = i + 1; j <= line.length; j++) {
                let tempStr = line.slice(i, j);
                if (tempStr.length > max && !/[^0-9]/.test(tempStr)) {
                    max = tempStr.length;
                    maxStrArr = [tempStr];
                } else if (tempStr.length === max && !/[^0-9]/.test(tempStr)) {
                    maxStrArr.push(tempStr);
                }
            }
        }
        console.log(maxStrArr.join("") + "," + max);
    }
})();

HJ93 数组分组

const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});
let k = 0;
let n = 0;
let nums = [];
rl.on("line", function (line) {
    if (k === 0) {
        n = Number(line);
        k++;
    } else {
        nums = line.split(" ").map((e) => Number(e));
        getArr();
    }
});

function getArr() {
    let multi5 = [];
    let multi3 = [];
    let others = [];
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] % 3 === 0 && nums[i] % 5 !== 0) {
            multi3.push(nums[i]);
        } else if (nums[i] % 5 === 0) {
            multi5.push(nums[i]);
        } else {
            others.push(nums[i]);
        }
    }
    let sum5 =
        multi5.length > 0
            ? multi5.reduce((prev, current) => prev + current)
            : 0;
    let sum3 =
        multi3.length > 0
            ? multi3.reduce((prev, current) => prev + current)
            : 0;
    console.log(isExists(sum5, sum3, others, 0));
}

function isExists(sum5, sum3, others, index) {
    if (others.length === 0 && sum5 !== sum3) {
        return false;
    } else if (others.length === 0 && sum5 === sum3) {
        return true;
    } else if (others.length === index && sum5 !== sum3) {
        return false;
    } else if (others.length === index && sum5 === sum3) {
        return true;
    } else if (index < others.length) {
        return (
            isExists(sum5 + others[index], sum3, others, index + 1) ||
            isExists(sum5, sum3 + others[index], others, index + 1)
        );
    } else {
        return false;
    }
}

HJ94 记票统计

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    let inputArr = [];
    while ((line = await readline())) {
        inputArr.push(line);
    }
    let peopleNum = Number(inputArr[0]); //总人数
    let peopleArr = inputArr[1].split(" ");
    let voteNum = Number(inputArr[2]); //总票数
    let voteArr = inputArr[3].split(" ");
    let obj = {}; //存放每个候选人的票数
    for (let i = 0; i < peopleArr.length; i++) {
        //循环候选人
        let cur = peopleArr[i];
        obj[cur] = 0;
        for (let j = 0; j < voteArr.length; j++) {
            //循环每一票
            if (voteArr[j] === cur) {
                obj[cur]++; //给被投票的计数
            }
        }
    }
    let invalidNum = 0; //总无效票数
    let totalValid = 0; //总有效票数
    for (k in obj) {
        totalValid += obj[k];
    }
    //用总票数减去每个候选人的票数，得到无效票数
    invalidNum = voteNum - totalValid;
    obj["Invalid"] = invalidNum;
    for (k in obj) {
        console.log(`${k} : ${obj[k]}`);
    }
})();

HJ95 人民币转换

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    while ((line = await readline())) {
        let [num1, num2] = line.split(".");
        const strs = num1
            .replace(/(?=(\d{4})+$)/g, ".")
            .split(".")
            .filter(Boolean); // 从后往前，每4位一组 ['30','2345']
        const chars = [
            "零",
            "壹",
            "贰",
            "叁",
            "肆",
            "伍",
            "陆",
            "柒",
            "捌",
            "玖",
        ];
        const unit = ["", "拾", "佰", "仟"];
        const bigUnit = ["", "万", "亿"];
        //转换4位以下的数字的方法
        function _tranform(numStr) {
            let result = "";
            for (let i = 0; i < numStr.length; i++) {
                const digit = +numStr[i];
                const c = chars[digit];
                const u = unit[numStr.length - i - 1];
                if (digit == 0) {
                    //如果当前位置上字符为‘0’
                    // 如果当前result末尾已经是零，则不拼接；不是'零'，才可以拼接上这个零;
                    //保证中间有多个0时只读一个零，如3001;
                    if (result[result.length - 1] !== chars[0]) {
                        result += c; //而且为零的拼接时不要单位
                    }
                } else {
                    result += c + u;
                }
            }
            // 如果最后末尾还是零的话，说明是形如'3000'或'3010'这种,需要处理一下
            if (result[result.length - 1] === chars[0]) {
                result = result.slice(0, -1);
            }
            return result;
        }
        // console.log(_tranform('1090'))
        let result = "人民币";
        //处理整数部分 num1 -> strs
        for (let i = 0; i < strs.length; i++) {
            const part = strs[i];
            const c = _tranform(part);
            const u = c ? bigUnit[strs.length - i - 1] : "";
            result += c + u;
        }
        // console.log(result);
        if (result !== "人民币") {
            result = (result + "元").replace(/壹拾/g, "拾");
        }
        //处理小数部分 num2 角和分
        if (num2 == "00") {
            result += "整";
        } else {
            if (num2[0] !== "0") {
                result += chars[num2[0]] + "角";
            }
            if (num2[1] !== "0") {
                result += chars[num2[1]] + "分";
            }
        }
        console.log(result);
    }
})();

HJ96 表示数字

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    let str=""
    while(line = await readline()){
        str=line
    }
    //字符串替换,第一个参数可以是普通字符串和正则式，第二个参数可以是字符串和函数，函数参数是匹配到的正则式或者字符串
    // console.log(str.replace(/\d+/g,item=>"*"+item+"*"))
    console.log(str.replace(/\d+/g,item=>`*${item}*`))
    
}()

HJ97 记负均正

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    let inputArr = [];
    while ((line = await readline())) {
        inputArr.push(line);
    }
    let n = Number(inputArr[0]);
    let numArr = inputArr[1].split(" ").map(Number);
    //用filter将正，负数分开
    let negative = numArr.filter((item) => item < 0); //负数的数组
    let positive = numArr.filter((item) => item > 0); //正数的数组
    let result = [negative.length]; //结果数组
    let reverAge; //正数的平均值
    if (positive.length) {
        //数组的reduce方法求和
        let total = positive.reduce((pre, cur) => pre + cur);
        //toFixed方法保留1位小数
        reverAge = (total / positive.length).toFixed(1);
    } else {
        //说明正数个数为0
        reverAge = "0.0";
    }
    result.push(reverAge);
    console.log(result.join(" "));
})();

HJ98 自动售货系统

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    while ((line = await readline())) {
        // console.log(line);
        let inputs = line.split(";");
        let things = {
            A1: {
                price: 2,
                num: 0,
            },
            A2: {
                price: 3,
                num: 0,
            },
            A3: {
                price: 4,
                num: 0,
            },
            A4: {
                price: 5,
                num: 0,
            },
            A5: {
                price: 8,
                num: 0,
            },
            A6: {
                price: 6,
                num: 0,
            },
        };
        let money = {
            1: 0,
            2: 0,
            5: 0,
            10: 0,
        };
        let yue = 0;
        for (let input of inputs) {
            let ins = input.split(" ");
            if (ins[0] === "r") {
                Object.keys(things).map((item, index) => {
                    things[item].num = ins[1].split("-")[index] * 1;
                });
                Object.keys(money).map((item, index) => {
                    money[item] = ins[2].split("-")[index] * 1;
                });
                console.log("S001:Initialization is successful");
            }
            if (ins[0] === "p") {
                if (["1", "2", "5", "10"].includes(ins[1])) {
                    if (
                        ins[1] * 1 > 2 &&
                        ins[1] * 1 > money[1] + money[2] * 2
                    ) {
                        console.log("E003:Change is not enough, pay fail");
                    } else if (soldOut(things)) {
                        console.log("E005:All the goods sold out");
                    } else {
                        money[ins[1]] += 1;
                        yue += ins[1] * 1;
                        console.log(`S002:Pay success,balance=${yue}`);
                    }
                } else {
                    console.log("E002:Denomination error");
                }
            }
            if (ins[0] === "b") {
                if (things[ins[1]]) {
                    if (things[ins[1]].num === 0) {
                        console.log("E007:The goods sold out");
                    } else if (things[ins[1]].price > yue) {
                        console.log("E008:Lack of balance");
                    } else {
                        yue -= things[ins[1]].price;
                        console.log(`S003:Buy success,balance=${yue}`);
                    }
                } else {
                    console.log("E006:Goods does not exist");
                }
            }
            if (input === "c") {
                if (yue === 0) {
                    console.log("E009:Work failure");
                } else {
                    c(yue, money);
                    yue = 0;
                }
            }
            if (input[0] === "q") {
                if (ins[0] === "q") {
                    if (ins[1] === "0") {
                        Object.keys(things).map((item) => {
                            console.log(
                                `${item} ${things[item].price} ${things[item].num}`
                            );
                        });
                    } else if (ins[1] === "1") {
                        Object.keys(money).map((item) => {
                            console.log(
                                `${item} yuan coin number=${money[item]}`
                            );
                        });
                    } else {
                        console.log("E010:Parameter error");
                    }
                } else {
                    console.log("E010:Parameter error");
                }
            }
        }
    }
})();

function soldOut(things) {
    let bool = true;
    Object.keys(things).map((item) => {
        if (things[item].num !== 0) {
            bool = false;
        }
    });
    return bool;
}
function c(yue, money) {
    let s = yue;
    let list = {
        1: 0,
        2: 0,
        5: 0,
        10: 0,
    };
    let keys = Object.keys(money).reverse(),
        index = 0;
    while (s > 0 && index < keys.length) {
        if (s >= keys[index]) {
            if (money[keys[index]]) {
                s -= keys[index];
                list[keys[index]] = list[keys[index]] + 1;
                money[keys[index]] = money[keys[index]] - 1;
            } else {
                index++;
            }
        } else {
            index++;
        }
    }
    Object.keys(list).map((item) => {
        console.log(`${item} yuan coin number=${list[item]}`);
    });
}

HJ99 自守数

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    while ((line = await readline())) {
        let num = Number(line);
        let count = 0;
        for (let i = 0; i <= num; i++) {
            if (isSelf(i)) {
                count++;
            }
        }
        console.log(count);
    }
    //判断是否是自守数的方法
    function isSelf(n) {
        let s = n.toString();
        let ss = (n * n).toString();
        if (ss.endsWith(s)) return true;
        return false;
    }
})();

HJ100 等差数列

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    while(line = await readline()){
        let n = Number(line);
        let a1 = 2,d=3;
        let result = n*(n-1)*d/2 + n*a1;//等差数列前n项的和
        console.log(result);
    }
}()

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    let a = await readline()
    ,b=await readline(),
    c=await readline()
    if(c==0){
        let d=b.split(' ').sort((f,s)=>f-s).join(" ")
        console.log(d)
    }else{
        let d=b.split(' ').sort((f,s)=>s-f).join(" ")
        console.log(d)
    }
}()

HJ102 字符统计

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void (async function () {
    while ((line = await readline())) {
        let map = new Map();
        // 利用哈希表统计每个字符的出现次数
        for (let item of line) {
            let m = item.charCodeAt();
            if (!map.has(m)) {
                map.set(m, 1);
            } else {
                let temp = map.get(m);
                map.set(m, temp + 1);
            }
        }
        let arr = [],
            res = [];
        // 得到ASCLL码和次数的二维数组
        for (let [x, y] of map) {
            arr.push([x, y]);
        }
        // 按照题目要求排序
        arr.sort((a, b) => b[1] - a[1] || a[0] - b[0]);
        for (let value of arr) {
            let s = String.fromCodePoint(value[0]);
            res.push(s);
        }
        console.log(res.join(""));
    }
})();

HJ103 Redraiment的走法

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    let n = 0;
    let arr = [];
    while ((line = await readline())) {
        if (n === 0) {
            n = parseInt(line);
        } else {
            arr = line.split(" ").map(Number);
            // 初始化dp数组--以i结尾的的最长递增子序列长度，初始值为1
            let dp = Array(arr.length).fill(1);
            let res = 1;
            for (let i = 1; i < arr.length; i++) {
                for (j = 0; j < i; j++) {
                    if (arr[i] > arr[j]) {
                        dp[i] = Math.max(dp[i], dp[j] + 1);
                    }
                }
                res = Math.max(res, dp[i]);
            }
            console.log(res);
        }
    }
})();

HJ105 记负均正II

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    let a=0,b=[],c=0
    while(line = await readline()){
        if(line<0){
            b.push(line)
        }else{
            a=(a+parseInt(line))
            c++
        }
    }
    if(c!=0){
      a=a/c      
    }

    console.log(b.length)
    console.log(a.toFixed(1))
}()

HJ106 字符逆序

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    while ((line = await readline())) {
        let lineArr = line.split("");
        console.log(lineArr.reverse().join(""));
    }
})();

HJ107 求解立方根

const rl = require("readline").createInterface({
    input: process.stdin,
});

rl.on("line", function (line) {
    let num = parseFloat(line);
    let flag = true;
    if (num.toString().includes("-")) {
        num = -num;
        flag = false;
    }
    let start = 0;
    while (
        !(
            start * start * start <= num &&
            (start + 1) * (start + 1) * (start + 1) >= num
        )
    ) {
        start++;
    }

    let fir = start + 0.0;
    while (
        !(
            fir * fir * fir <= num &&
            (fir + 0.1) * (fir + 0.1) * (fir + 0.1) >= num
        )
    ) {
        fir += 0.1;
    }

    let sec = fir + 0.0;
    while (
        !(
            sec * sec * sec <= num &&
            (sec + 0.01) * (sec + 0.01) * (sec + 0.01) >= num
        )
    ) {
        sec += 0.01;
    }

    let third = sec + 0.0;
    while (
        !(
            third * third * third <= num &&
            (third + 0.001) * (third + 0.001) * (third + 0.001) >= num
        )
    ) {
        third += 0.001;
    }

    if (flag) {
        console.log(third.toFixed(1));
    } else {
        console.log("-" + third.toFixed(1));
    }
});

HJ108 求最小公倍数

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    while(line = await readline()){
        let tokens = line.split(' ');
        let i=1,a=1
        do{
            if(a%tokens[0]==0&&a%tokens[1]==0){
                i=0
                console.log(a)
            }else{
                a++
            }
        }while(i)
    }
}()