牛客网HW机试题JS解答（1-80）

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

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(' ')
        const len = tokens.length
        const lastStr = tokens[len - 1]
        console.log(lastStr.length)
    }
}()

HJ2计算某字符出现次数

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

void (async function () {
    let inputs = [];
    // Write your code here
    while ((line = await readline())) {
        inputs.push(line);
    }
    let str = inputs[0].trim().toUpperCase();
    let arr = []; // 记录元素
    let count = []; // 记录元素出现次数
    let li = line;
    for (let i = 0; i < str.length; i++) {
        if (arr.includes(str[i])) {
            let index = arr.indexOf(str[i]);
            count[index]++;
        } else {
            arr.push(str[i]);
            let index = arr.indexOf(str[i]);
           count[index] = 1;
        }
    }
    const index = arr.indexOf(inputs[1].toUpperCase());
    if(index < 0) {
        console.log(0)
    } else {
        console.log(count[index])
    }
})();

HJ3 明明的随机数

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

void (async function () {
    let inputs = [];
    while ((line = await readline())) {
        inputs.push(line);
    }
    const arr = inputs.slice(1);
    const newArr = [...new Set(arr)];
    newArr.sort(function(a, b){
        return a - b
    })
    for(let i = 0; i < newArr.length; i++) {
        console.log(newArr[i])
    }
})();

HJ4 字符串分隔

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

void async function () {
    let inputs = [];
    while ((line = await readline())) {
        inputs.push(line);
    }
    const num = inputs[0].length / 8
    let arr = []
    for(let i = 0; i < num; i ++) {
        arr.push(inputs[0].slice(i*8, i*8 + 8).padEnd(8, '00000000'))
    }
    for(let i = 0; i < arr.length; i++) {
        console.log(arr[i])
    } 
}()

HJ5 进制转换

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let output = []
    for(let i = 0; i < inputs.length; i++) {
        output.push(parseInt(inputs[i], 16))
    }
    for(let i = 0; i < output.length; i++) {
        console.log(output[i])
    }
}()

HJ6 质数因子

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 = parseInt(line.split(" "));
        //定义一个判断质数的方法
        function isPrime(num) {
            let isp = true;
            let sqrt = Math.sqrt(num);
            if (num == 1) isp = false;
            for (let i = 2; i <= sqrt; i++) {
                // isp=(num%i===0?false:true);
                if (num % i === 0) {
                    isp = false;
                    break;
                }
            }
            return isp;
        }
        //做除法
        let getarr = [];
        for (let i = 2; i < tokens; i++) {
            if (isPrime(i)) {
                while (tokens % i === 0) {
                    getarr.push(i);
                    tokens = tokens / i;
                }
                if (isPrime(tokens)) {
                    getarr.push(tokens);
                    break;
                }
            }
        }
        console.log(getarr.join(" "));
    }
})();

HJ7 取近似值

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let outStr = inputs[0].split('.')
    let intNum = outStr[0]
    let smallNum = outStr[1]
    if(smallNum >= 5 * Math.pow(10, smallNum.length - 1)) {
      intNum++
    }
    console.log(intNum)
}()

HJ8 合并表记录

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

void async function () {
    let inputs = []
    let keyArr = []
    let valueArr = []
    while(line = await readline()){
        inputs.push(line)
    }
    let len = inputs[0]
    for(let i = 1; i < inputs.length; i++) {
        let arr = inputs[i].split(' ')
        keyArr.push(arr[0])
        valueArr.push(arr[1])
    }
    let obj = {}
    for(let i = 0 ; i < keyArr.length; i++) {
        if(!obj.hasOwnProperty(keyArr[i])) {
            obj[keyArr[i]] = parseInt(valueArr[i])
        } else {
            obj[keyArr[i]] += parseInt(valueArr[i])
        }
    }
    const keys = Object.keys(obj)
    for(let i = 0; i < keys.length; i++) {
        console.log(keys[i], obj[keys[i]])
    }
}()

HJ9 提取不重复的整数

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = inputs[0].split('').reverse()
    let newArr = []
    for(let i = 0; i < arr.length; i++) {
        if(!newArr.includes(arr[i])) {
            newArr.push(arr[i])
        } 
    }
    console.log(newArr.join(''))
}()

HJ10 字符个数统计

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let str = inputs[0]
    let arr = str.split('')
    console.log([...new Set(arr)].length)
}()

HJ11 数字颠倒

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = inputs[0].split('')
    console.log(arr.reverse().join(''))
}()

HJ12 字符串反转

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = inputs[0].split('')
    console.log(arr.reverse().join(''))
}()

HJ13 句子逆序

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = inputs[0].split(' ')
    // for(let i = 0; i < arr.length; i++) {

    // }
    console.log(arr.reverse().join(' '))
}()

HJ14 字符串排序

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = inputs.slice(1)
    arr.sort()
    // console.log(arr)
    for(let i = 0; i < arr.length; i++) {
        console.log(arr[i])
    }
}()

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

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 inputs = []
    while(line = await readline()){
        inputs.push(line)
    }
    let arr = []
    let dec = inputs[0]
    while(dec > 0) {
        arr.push(dec % 2)
        dec = parseInt(dec / 2)
    }
    const binary = arr.reverse().filter(v => v===1)
    console.log(binary.length)
}()

HJ16 购物单

//前提0-1背包问题
function knapSack(w, val, capacity, n){
	var T = []
	for(let i = 0; i < n; i++){
		T[i] = [];
		for(let j = 0; j <= capacity; j++){
			if(j === 0){ //容量为0
				T[i][j] = 0;
				continue;
			}	
			if(j < w[i]){ //容量小于物品重量，本行hold不住
				if(i === 0){
					T[i][j] = 0; // i = 0时，不存在i-1，所以T[i][j]取0
				}else{
					T[i][j] = T[i-1][j]; //容量小于物品重量，参照上一行
				}
				continue;
			}
			if(i === 0){
				T[i][j] = val[i]; //第0行，不存在 i-1, 最多只能放这一行的那一个物品
			}else{
				T[i][j] = Math.max(val[i] + T[i-1][j-w[i]], T[i-1][j]);
			}
		}
	}
	findValue(w, val, capacity, n, T);
	return T;
}

//找到需要的物品
function findValue(w, val, capacity, n, T){
	var i = n - 1, j = capacity
	while ( i > 0 && j > 0 ){
		if(T[i][j] != T[i-1][j]){
			console.log('选择物品' + i + ',重量：' + w[i] + ',价值：' + values[i])
			j = j- w[i]
			i--
		}else{
			i--  //如果相等，那么就到 i-1 行
		}
	}
	if(i == 0 ){
		if(T[i][j] != 0){ //那么第一行的物品也可以取
			console.log('选择物品' + i + ',重量：' + w[i] + ',价值：' + values[i]);

		}
	}
}

// w = [2,3,4].  val = [3,4,5] , n = 3 , capacity = 5
//function knapSack([2,3,4],[3,4,5],5,3);
// 
let values = [3,4,5],
	weights = [2,3,4],
	capacity = 5,
	n = values.length;

// console.log(knapSack(weights, values, capacity, n));
const t = knapSack(weights, values, capacity, n)
console.log(t)

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
    //1. 读取数据
    let token = [];
    while ((line = await readline())) {
        let tokens = line.split(" ");
        token.push(tokens.map(Number));
    }
    let [N, m] = token[0];
    let V = [0],
        W = [0],
        R = [0];
    let temp;
    for (let i = 1; i < token.length; i++) {
        V.push(token[i][0]);
        W.push(token[i][1]);
        R.push(token[i][2]);
    }

    //2. 分段
    //求最大公因数
    function gcd(a, b) {
        if (b == 0) {
            return a;
        }
        var r = a % b;
        return gcd(b, r);
    }
    //求一组数的最大公因数
    let gap = V.concat(N).reduce((prev, curr) => gcd(prev, curr));
    //统一单位大小
    V = V.map((v) => v / gap);
    //dp表
    let containerLength = N / gap;
    let container = new Array(containerLength + 1).fill(0);

    let inCart = new Array(containerLength + 1).fill(new Array(1).fill(0));
    for (let i = 1; i < m + 1; i++) {
        //前i个物体
        for (let j = containerLength; j >= V[i]; j--) {
            //容量为j
            let curr = j,
                before = j - V[i];
            let wealth,
                currValue,
                prevValue = container[curr];
            let [mainItemValue, mainItemWeight] = [V[R[i]], W[R[i]]];
            //       console.log(i,container);
            //       console.log(inCart[curr]);
            if (!inCart[before].includes(i)) {
                //没有重复当前的这个物件
                if (inCart[before].includes(R[i])) {
                    //如果主件已入购物车
                    wealth = V[i] * W[i];
                    currValue = container[j - V[i]] + wealth;
                    if (currValue > prevValue) {
                        container[j] = currValue;
                        inCart[curr] = inCart[before].concat([i]);
                    }
                } else if (j - mainItemValue - V[i] >= 0) {
                    //如果主件没进，那么考虑把主件也并在一起
                    wealth = mainItemValue * mainItemWeight + V[i] * W[i];
                    currValue = container[j - mainItemValue - V[i]] + wealth;
                    if (
                        !inCart[j - mainItemValue - V[i]].includes(i) &&
                        //                      !inCart[j-mainItemValue-V[i]].includes(R[i])  &&
                        currValue > prevValue
                    ) {
                        container[j] = currValue;
                        inCart[curr] = inCart[j - mainItemValue - V[i]].concat([
                            i,
                            R[i],
                        ]);
                    }
                }
            }
        }
    }
    console.log(container[containerLength] * gap);
})();

HJ17 坐标移动

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 value = 0;
    while ((line = await readline())) {
        value = line.split(";");
        let result = [0, 0];
        value.forEach((el) => {
            if (
                (el[0] == "A" ||
                    el[0] == "D" ||
                    el[0] == "W" ||
                    el[0] == "S") &&
                el.length <= 3 &&
                parseInt(el[1]) >= 0
            ) {
                if (parseInt(el[2]) >= 0 || !el[2]) {
                    a = 99;
                    switch (el[0]) {
                        case "A":
                            result[0] -= parseInt(el.slice(1));
                            break;
                        case "D":
                            result[0] += parseInt(el.slice(1));
                            break;
                        case "W":
                            result[1] += parseInt(el.slice(1));
                            break;
                        case "S":
                            result[1] -= parseInt(el.slice(1));
                            break;
                    }
                }
            }
        });
        console.log(result.join(","));
    }
})();

HJ18 识别有效的IP地址和掩码并进行分类统计

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

void (async function () {
    /**
     * 1.需要注意以10,172.16,192.168开头的几个私网ip
     * 2.一个ip可以同时属于私网ip和ABCDE类，2处都计数
     * 3.需要注意以0,127开头的不计入任何类的ip
     * 4.输出顺序: A B C D E 错误 私有
     */
    let inputArr = [];
    while ((line = await readline())) {
        let tokens = line.split("~");
        inputArr.push({
            ip: tokens[0],
            mask: tokens[1],
        });
    }
    console.log(handleips(inputArr));
    //输出最后得到要打印的字符串的方法
    function handleips(ips) {
        let a = 0,
            b = 0,
            c = 0,
            d = 0,
            e = 0,
            error = 0,
            privite = 0;
        for (let i = 0, l = ips.length; i < ips.length; i++) {
            let ipRes = isValidIP(ips[i].ip);
            let maskRes = isValidMask(ips[i].mask);
            let first = ips[i].ip.split(".")[0]; //拿到ip的第一个数字;
            let second = ips[i].ip.split(".")[1]; //拿到ip的第二个数字;
            if (first == "0" || first == "127") continue; //不计入任何类的
            if (ipRes && maskRes) {
                if (
                    //私网ip
                    first == "10" ||
                    (first == "172" && second >= 16 && second <= 31) ||
                    (first == "192" && second == "168")
                ) {
                    privite++;
                }
                if (first <= 126) {
                    a++;
                } else if (first >= 128 && first <= 191) {
                    b++;
                } else if (first >= 192 && first <= 223) {
                    c++;
                } else if (first >= 224 && first <= 239) {
                    d++;
                } else if (first >= 240) {
                    e++;
                }
            } else {
                //有ip或者掩码非法
                error++;
            }
        }
        return `${a} ${b} ${c} ${d} ${e} ${error} ${privite}`;
    }
    //判断ip是否合法
    function isValidIP(ip) {
        let status = true;
        //判断除了数字和 . 以外有没有其他字符
        if (/[^0-9\.]/.test(ip)) status = false;
        // .的个数为3
        let arrOfdot = ip.split("").filter((i) => i === ".");
        if (arrOfdot.length !== 3) status = false;
        //以.拆分得到的数组每个位置不能为空字符串
        // 每个数在0-255之间
        // 每个数如果大于0的时候不能以0开头
        let arr = ip.split(".");
        arr.forEach((item) => {
            if (item.length === 0) return (status = false);
            if (Number(item) < 0 || Number(item) > 255) return (status = false);
            if (Number(item) > 0 && item.startsWith(0)) return (status = false);
        });
        return status;
    }
    //判断子网掩码是否合法
    function isValidMask(mask) {
        if (!isValidIP(mask)) return false;
        const maskarr = mask.match(/\d+/g);
        let maskStr = ""; //一个32位的二进制字符串
        maskarr.forEach((item) => {
            maskStr += parseInt(item).toString(2).padStart(8, "0");
        });
        return /^1+0+$/.test(maskStr);
    }
})();

HJ19 简单错误记录

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

void (async function () {
    let errArr = [];
    while ((line = await readline())) {
        let tokens = line.split(" ");
        let nummber = tokens[1];
        let namearr = tokens[0].split("\\");
        let name = namearr[namearr.length - 1].slice(-16); //名称只保留最后16位
        //在已有的错误记录中寻找和当前输入的这条相同的错误记录
        let index = errArr.findIndex(
            (item) => item.name == name && item.nummber == nummber
        );
        if (index != -1) {
            //找到了的话则,不加新的错误记录，原有的相同的那条的数量加1
            errArr[index].count++;
        } else {
            //没找到则新加一条错误记录
            errArr.push({
                name,
                nummber,
                count: 1,
            });
        }
    }
    //只输出最后8条错误记录;
    errArr.slice(-8).forEach((item) => {
        console.log(item.name + " " + item.nummber + " " + item.count);
    });
})();

HJ20 密码验证合格程序

// 方法1
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 vaildStr = line.length > 8
        let vaildType = judgeType(line)
        let vaildRepeat = isRepeat(line)
        if(vaildStr && vaildType && vaildRepeat) {
            console.log('OK')
        } else {
            console.log('NG')
        }
    }
    // 检验密码中是否包含大小写字母、数字、其他符号的四种中三种之上
    function judgeType(str) {
        let num = 0
        if(/[a-z]/.test(str)) num++
        if(/[A-Z]/.test(str)) num++
        if(/[0-9]/.test(str)) num++
        if(/[^0-9a-zA-Z]/.test(str)) num++
        return num >= 3
    }
    // 检验密码中是否包含超两位的子字符串重复
    function isRepeat(str) {
        let arr = []
        for(let i = 0; i < str.length - 2; i++){
            let tempStr = str.slice(i, i + 3)  // 表示从i截取到i+3的字符串
            if(arr.includes(tempStr)){
                return false
            } else {
                arr.push(tempStr)
            }
        }
        return true
    }
}()

// 方法2
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 regListOne = [/^.{1,8}$/, /(.{3,}).*\1+.*/] 
        let firstCheck = regListOne.every(item => !item.test(line))
        if(firstCheck) {
            // 大小写字母、数字、其他符号（除大小写字母、数字、换行符、空白符）
            let regListTwo = [/[a-z]/, /[A-Z]/, /\d/, /[^a-zA-Z\d\n\s]/]
            let secondCheck = regListTwo.filter(item => item.test(line))
            let result = secondCheck.length >= 3 ? 'OK' : 'NG'  // 至少满足三个条件
            console.log(result)
        } else {
            console.log('NG')
        }
    }
}()

HJ21 简单密码

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 b = [];
    while ((line = await readline())) {
        for (var i = 0; i < line.length; i++) {
            if ("A" <= line[i] && "Z" > line[i]) {
                let a = line[i].charCodeAt() + 1;
                b.push(String.fromCharCode(a).toLowerCase());
            } else if ("Z" == line[i]) {
                b.push("a");
            } else if ("a" <= line[i] && "c" >= line[i]) {
                b.push("2");
            } else if ("d" <= line[i] && "f" >= line[i]) {
                b.push("3");
            } else if ("g" <= line[i] && "i" >= line[i]) {
                b.push("4");
            } else if ("j" <= line[i] && "l" >= line[i]) {
                b.push("5");
            } else if ("m" <= line[i] && "o" >= line[i]) {
                b.push("6");
            } else if ("p" <= line[i] && "s" >= line[i]) {
                b.push("7");
            } else if ("t" <= line[i] && "v" >= line[i]) {
                b.push("8");
            } else if ("w" <= line[i] && "z" >= line[i]) {
                b.push("9");
            } else {
                b.push(line[i]);
            }
        }
    }
    console.log(b.join(""));
})();

HJ22 汽水瓶

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 inputArr = []
    while(line = await readline()){
        inputArr.push(line.split(' '))
    }
    let finalArr = [];
    for(let i = 0;i < inputArr.length;i++){
        if(inputArr[i] !=0 ){
            finalArr.push(count(inputArr[i]))
        }
    }
    console.log(finalArr.join('\n'))
    // 使用递归计算数目
    function count(num){
        if(num<2){
            return 0
        }else if(num == 2){
            return 1
        }else{
            let num1 = Math.floor(num/3);
            let num2 = num % 3;
            return num1 + count(num1 + num2);
        }
    }
}()

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

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 inputArr = []
    while(line = await readline()){
        inputArr.push(...line.split(''))
    }
    let mymap = new Map()
    // 用map统计每一种字符的个数
    inputArr.forEach((item) => {
        if(mymap.has(item)){
            mymap.set(item,mymap.get(item)+1)
        }else{
            mymap.set(item,1)
        }
    })
    let minnum = 20
    let removeArr = []
    // 找到字符最少的 字符数
    mymap.forEach((val,key) => {
        if(val <= minnum){
            minnum = val
        }
    })
    // 找到最少的字符 可能有多个
    mymap.forEach((val,key) => {
        if(val == minnum){
            removeArr.push(key)
        }
    })
    // 移除所有最少的字符
    removeArr.forEach((item) => {
        inputArr =  inputArr.join('').split(item)
    })
    console.log(inputArr.join(''))
}()

HJ24 合唱队

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let arr = lineArr[1].split(" ").map((e) => Number(e));
    let firstDp = solution(arr); // 从左至右去处理数组
    let secondDp = solution(arr.reverse()).reverse(); // 将数组反转，从右至左去处理，然后再进行反转
    let max = 0;
    for (let i = 0; i < firstDp.length; i++) {
        // 找出递增数列最多的那个
        max = Math.max(max, firstDp[i] + secondDp[i] - 1);
    }
    // arr.length-max则表示需要删除多少项，才可以形成队列
    console.log(arr.length - max);
    /**
     * 函数是为了将从数组的一项，增加到多项，然后把每一项都进行比较。
     * 如果第j项比第i项要小，那就说明是可以形成递增的数列，让dp[i] = Math.max(dp[i], dp[j]+1).
     * dp是用来存储第i项的递增数列的个数
     * 如果dp[i]比dp[j]+1要大，那么则保持原样，如果要小，则dp[i]赋值为dp[j+1]
     */
    function solution(arr) {
        let dp = [];
        for (let i = 0; i < arr.length; i++) {
            dp[i] = 1;
            for (let j = 0; j < i; j++) {
                if (arr[j] < arr[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        return dp;
    }
})();

HJ25 数据分类处理

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

const lines = [];
rl.on("line", (line) => {
    lines.push(...line.split(",").map((x) => x.split(" ")));
});

rl.on("close", () => {
    const list = lines[0].slice(1);
    const r = [...new Set(lines[1].slice(1).sort((a, b) => a - b))];
    const outList = [];
    r.forEach((a, ia) => {
        const rList = [];
        list.forEach((b, ib) => {
            if (b.includes(a)) {
                rList.push(ib);
                rList.push(b);
            }
        });
        if (rList.length !== 0) {
            rList.unshift(rList.length / 2);
            rList.unshift(a);
            outList.push(...rList);
        }
    });
    outList.unshift(outList.length);
    console.log(outList.join(" "));
});

HJ26 字符串排序

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

rl.on("line", (line) => {
    const a = line.split("");
    const a1 = a.filter(
        (x) =>
            x.toLocaleLowerCase().charCodeAt() > 96 &&
            x.toLocaleLowerCase().charCodeAt() < 123
    );
    const a2 = [];
    a.forEach((x, i) => {
        if (
            !(
                x.toLocaleLowerCase().charCodeAt() > 96 &&
                x.toLocaleLowerCase().charCodeAt() < 123
            )
        ) {
            a2.push([x, i]);
        }
    });
    a1.sort(
        (a, b) =>
            a.toLocaleLowerCase().charCodeAt() -
            b.toLocaleLowerCase().charCodeAt()
    );
    a2.forEach((x) => {
        a1.splice(x[1], 0, x[0]);
    });
    console.log(a1.join(""));
});

HJ27 查找兄弟单词

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(" ");
        let len = Number(lineArr[0]); // 需要检测单词组成的数组的长度
        let index = Number(lineArr[lineArr.length - 1]); // 指定的索引
        let tempArr = []; // 存储检测单词组成的数组
        for (let i = 1; i <= len + 1; i++) {
            tempArr.push(lineArr[i]);
        }
        let target = tempArr[len]; // 找到目标单词
        let judgeStr = target.split("").sort().join(""); // 对目标单词排序拼接
        let list = []; // 存储兄弟单词组成的数组
        for (let i = 0; i < len; i++) {
            let temp = tempArr[i].split("").sort().join("");
            if (tempArr[i] !== target && temp === judgeStr)
                list.push(tempArr[i]);
        }
        let result = list.sort(); // 对兄弟单词进行排序，升序
        console.log(result.length);
        if (result[index - 1]) console.log(result[index - 1]); // 可能存在指定索引不在数组长度之内
    }
})();

HJ28 素数伴侣

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 odd = [];
        let even = [];
        // 把数据分成奇数和偶数，因为奇数+偶数才能得出奇数，所有素数除了2以外都是奇数
        (await readline()).split(" ").forEach((v) => {
            v = Number(v);
            if (v % 2 === 0) {
                even.push(v);
            } else {
                odd.push(v);
            }
        });

        if (odd.length == 0 || even.length == 0) {
            console.log(0);
            return;
        }
        // 遍历并找到所有素数伴侣
        const map = [];
        for (let i = 0; i < odd.length; i++) {
            map[i] = new Array(even.length);
            for (let j = 0; j < even.length; j++) {
                map[i][j] = isPrime(odd[i] + even[j]);
            }
        }

        let count = 0;
        let usedEven = []; // 存放每次遍历里面的偶数下标，防止无限递归
        let matchArr = []; // matchArr[j]存放偶数j对应的奇数下标i
        for (let i = 0; i < odd.length; i++) {
            if (isMach(i)) {
                count++;
                usedEven = [];
            }
        }

        console.log(count);

        function isMach(i) {
            for (let j = 0; j < even.length; j++) {
                // i、j对应的奇偶数的话如果不是素数或者当前偶数下标在这次isMach递归中已经使用过则直接跳过当前循环
                if (!map[i][j] || usedEven[j]) continue;
                usedEven[j] = true;
                // 如果j没有匹配过，或者原来跟j匹配的奇数matchArr[j]能找到其他匹配
                if (matchArr[j] === undefined || isMach(matchArr[j])) {
                    matchArr[j] = i;
                    return true;
                }
            }
            return false;
        }
        function isPrime(n) {
            let res = true;
            for (let i = 2; i * i <= n; i++) {
                if (n % i === 0) {
                    res = false;
                }
            }
            return res;
        }
    }
})();

HJ29 字符串加解密

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

void (async function () {
    // 有限数据量，直接枚举出全部，查表就可以了
    let str1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    let str2 = "bcdefghijklmnopqrstuvwxyzaBCDEFGHIJKLMNOPQRSTUVWXYZA1234567890";
    let data = [];
    while ((line = await readline())) {
        data.push(line);
    }
    let arr1 = []; //解密后的字符集合；
    let arr2 = []; // 加密后的字符集合
    for (char of data[0]) {
        arr1.push(str2[str1.indexOf(char)]);
    }
    console.log(arr1.join(""));
    for (char of data[1]) {
        arr2.push(str1[str2.indexOf(char)]);
    }
    console.log(arr2.join(""));
})();

HJ30 字符串合并处理

// 第三步实际上就是：1，十六进制 转 二进制；2，二进制翻转；3，翻转后转十六进制
// 注意点就是二进制翻转前注意在前面补0补足4位 padStart(4,0)。
const rl = require("readline").createInterface({ input: process.stdin });
rl.on("line", (line) => {
    // 第一步
    const arr = line.replace(" ", "").split("");
    // 第二步
    const arr0 = arr.filter((x, i) => i % 2 === 0).sort();
    const arr1 = arr.filter((x, i) => i % 2 === 1).sort();
    const arr2 = [];
    for (let i = 0; i < arr0.length; i++) {
        arr2.push(arr0[i]);
        arr2.push(arr1[i]);
    }
    // 第三步
    const arr3 = arr2.map((x) => {
        if (/^[\da-fA-F]$/.test(x)) {
            return parseInt(
                parseInt(x, 16)
                    .toString(2)
                    .padStart(4, 0)
                    .split("")
                    .reverse()
                    .join(""),
                2
            )
                .toString(16)
                .toUpperCase();
        } else {
            return x;
        }
    });
    console.log(arr3.filter((x) => x).join(""));
});

HJ31 单词倒排

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

rl.on('line',line=>{
    console.log(line.replaceAll(/[^a-zA-Z]/g,' ').split(' ').reverse().join(' '))
})

HJ32 密码截取

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 = 0;
        /**
         * 这里的最长对称字符串，有两种情况
         * 第一种，是偶数对称
         * 第二种，是奇数对称，由于中间还有一个字符，所以需要加上1，才能得到最终所需的长度
         */
        for (let i = 0; i < line.length; i++) {
            let first = check(line, i, i + 1);
            let second = check(line, i, i + 2) + 1;
            maxLen = Math.max(first, second, maxLen);
        }
        console.log(maxLen);
    }
    /**
     * 函数为得到最长的对称字符串，利用双指针法，中心扩散
     * str：传入的字符串
     * start：左指针
     * end：右指针
     */
    function check(str, start, end) {
        let result = 0;
        while (start >= 0 && end <= str.length && str[start] === str[end]) {
            result += 2;
            start--;
            end++;
        }
        return result;
    }
})();

HJ33 整数与IP地址间的转换

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let first = lineArr[0].split(".");
    let second = lineArr[1];
    // IP地址转十进制
    let ipStr = "";
    for (let i = 0; i < first.length; i++) {
        // toString(2)转二进制，padStart()方法用于补足字符串前面，直到指定长度
        let temp = Number(first[i]).toString(2).padStart(8, "0");
        ipStr += temp;
    }
    console.log(parseInt(ipStr, 2)); // 转为十进制
    // 十进制转IP地址
    let changeStr = Number(second).toString(2).padStart(32, "0");
    let changeArr = []; // 用于存储八位二进制的数组
    for (let i = 0; i < 32; i += 8) {
        changeArr.push(changeStr.slice(i, i + 8));
    }
    let strArr = changeArr.map((item) => parseInt(item, 2)); // 将数组的每一项转十进制
    console.log(strArr.join("."));
})();

HJ34 图片整理

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('').sort().join('');
        console.log(tokens)
    }
}()

HJ35 蛇形矩阵

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 num = Number(line);
        let cur = 1;
        for (let i = 1; i <= num; i++) {
            let arr = [];
            let temp = cur;
            for (let j = i + 1; j <= num + 1; j++) {
                arr.push(temp);
                temp += j;
            }
            cur += i;
            console.log(arr.join(" "));
        }
    }
})();

HJ36 字符串加密

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

const ZM = 'A B C D E F G H I J K L M N O P Q R S T U V W X Y Z'.split(' ')
void async function () {
    var keyStr = await readline()
    var str = await readline()
    var newZM = getNewZM(keyStr) // 得到新的字母表
    var res = []
    for(var i = 0; i < str.length; i ++){
        if(/[a-zA-Z]/.test(str.charAt(i))){ // 处理字母
            var upChar = str.charAt(i).toUpperCase()// 都按照大写处理
            oldIndex = ZM.indexOf(upChar) // 找到该字母在原字母表中的位置
            if(/[a-z]/.test(str.charAt(i))){ // 如果原来是小写，新的也要转为小写
                res.push(newZM[oldIndex].toLowerCase())
            }else{
                res.push(newZM[oldIndex])
            }
        }else{ // 处理空格
            res.push(str.charAt(i))
        }
    }
    console.log(res.join(''))
}()
// 得到新的字母表
function getNewZM(str){
    var res = []
    for(var i = 0; i < str.length; i ++){
        var temp = str.charAt(i).toUpperCase()
        if(res.indexOf(temp) == -1){ // 去重
            res.push(temp)
        }
    }
    for(var i = 0; i < 26; i ++){
        if(res.indexOf(ZM[i]) == -1){
            res.push(ZM[i])
        }
    }
    // console.log(res)
    return res
}

HJ37 统计每个月兔子的总数

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;
        function countRabbit(n){
            if(n == 1 || n == 2){  return 1
            }else{ return countRabbit(n-1) + countRabbit(n-2) }
        }
        console.log(countRabbit(tokens))
    }
}()

HJ38 求小球落地5次后所经历的路程和第5次反弹的高度

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 h = parseInt(line);
        let s = h + h*0.5*2 + h * Math.pow(0.5,2)*2 + h*Math.pow(0.5,3)*2 + h*Math.pow(0.5,4)*2;
        let H = h*Math.pow(0.5,5);
        console.log(s);
        console.log(H);
    }
}()

HJ39 判断两个IP是否属于同一子网

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
let m = 0
let nums = []
void async function () {
    while(line = await readline()){
        m++
        nums.push(line)
        if(m % 3 === 0){
          let [mask,ip1,ip2] = nums
          if(!checkSubnetMask(mask) || !checkIp(ip1) || !checkIp(ip2)){
              console.log(1)
              nums = []
              continue
          }               
          console.log(isEqualSubnet(ip1,ip2,mask))
          nums = []
        }
    }
}()
// 判断子网掩码是否合法
function checkSubnetMask(mask){
    let maskArr = mask.split('.').map(val=>parseInt(val))
    let isValid = true
    let substr = ""
    for(let i = 0; i < maskArr.length; i++){
        // 筛选合法子网掩码区间
        if(maskArr[i] < 0 || maskArr[i] > 255){
             return false
        }
        // 转化为八位二进制并补零
        substr += maskArr[i].toString(2).padStart(8,'0')
    }
    if(substr.indexOf('01') > 0){
        isValid = false
    }else if(substr.indexOf('0') < 0 || substr.indexOf('1') < 0){
        isValid = false        
    }
    return isValid
}
// 判断ip地址是否合法
function checkIp(ip){
  let ipArr = ip.split('.').map(val=>parseInt(val))
  for (let i = 0; i < ipArr.length; i++){
    if(ipArr[i] < 0 || ipArr[i] > 255){
      return false
    }
  }
  return true
}
// 判断两个ip地址是否属于统一子网络
function isEqualSubnet(ip1,ip2,mask){
  let ipArr1 = ip1.split('.').map(val=>parseInt(val))
  let ipArr2 = ip2.split('.').map(val=>parseInt(val))
  let maskArr = mask.split('.').map(val=>parseInt(val))
  let ipstr1 = "",ipstr2 = "",maskstr = ""
  let ans1 = [],ans2 = []
    ipArr1.forEach(subnet=>{
        ipstr1 += parseInt(subnet).toString(2).padStart(8,'0')
    })
    ipArr2.forEach(subnet=>{
        ipstr2 += parseInt(subnet).toString(2).padStart(8,'0')
    })
    maskArr.forEach(subnet=>{
        maskstr += parseInt(subnet).toString(2).padStart(8,'0')
    })
    let ipBinary1 = ipstr1.split('').map(val=>parseInt(val))
    let ipBinary2 = ipstr2.split('').map(val=>parseInt(val))
    let maskBinary = maskstr.split('').map(val=>parseInt(val))
    for(let i = 0; i < maskBinary.length; i++){
        ans1[i] = ipBinary1[i] * maskBinary[i]
        ans2[i] = ipBinary2[i] * maskBinary[i]
        if(ans1[i] != ans2[i]){
            return 2
        }
    }
  return 0
}

HJ40 统计字符

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 arr = new Array(4).fill(0); // 等同于let arr = [0,0,0,0]
        for (let i = 0; i < line.length; i++) {
            let temp = line[i].charCodeAt();
            if ((temp >= 65 && temp <= 90) || (temp >= 97 && temp <= 122)) {
                // 英文字符的ASCII码取值范围
                arr[0]++;
            } else if (temp == 32) {
                // 空格的ASCII码
                arr[1]++;
            } else if (temp >= 48 && temp <= 57) {
                // 数字的ASCII码
                arr[2]++;
            } else {
                arr[3]++;
            }
        }
        arr.forEach((item) => {
            console.log(item);
        });
    }
})();

HJ41 称砝码

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let weightArr = lineArr[1].split(" ").map((e) => Number(e)); // 重量
    let numberArr = lineArr[2].split(" ").map((e) => Number(e)); // 数量
    let obj = { 0: true }; // 用来计算有多少种放法对应的重量
    for (let i = 0; i < weightArr.length; i++) {
        // 可以存储当前遍历中所有放法的重量
        let arr = Object.keys(obj).map((e) => Number(e)); // Object.keys()得到对应对象的key的数组
        for (let j = 0; j <= numberArr[i]; j++) {
            arr.forEach((item) => {
                let val = item + weightArr[i] * j;
                if (!obj[val]) obj[val] = true;
            });
        }
    }
    console.log(Object.keys(obj).length);
})();

HJ42 学英语

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

void (async function () {
    let unique = [
        "zero",
        "one",
        "two",
        "three",
        "four",
        "five",
        "six",
        "seven",
        "eight",
        "nine",
        "ten",
        "eleven",
        "twelve",
        "thirteen",
        "forteen",
        "fifteen",
        "sixteen",
        "seventeen",
        "eighteen",
        "nineteen",
        "twenty",
    ];
    let tens = [
        "zero",
        "ten",
        "twenty",
        "thirty",
        "forty",
        "fifty",
        "sixty",
        "seventy",
        "eighty",
        "ninety",
    ];
    let seperator = ["", " thousand ", " million "];
    let str = await readline();
    let reg = /^\d{1,9}$/g;
    if (!reg.test(str)) {
        console.log("error");
        return;
    }
    let numStr = Array.from(str);
    let ans = "";
    let index = -1;
    while (numStr.length > 0) {
        index++;
        let threeChar = numStr.splice(Math.max(numStr.length - 3, 0), 3);
        let num = parseInt(threeChar.join(""));
        if (num === 0) continue;
        ans = transformThree(num) + seperator[index] + ans;
    }
    console.log(ans);

    function transformThree(num) {
        if (num < 100) return transformTwo(num);
        if (num % 100 === 0) return unique[num / 100] + " hundred";
        return (
            unique[parseInt(num / 100)] +
            " hundred and " +
            transformTwo(num % 100)
        );
    }

    function transformTwo(num) {
        if (num <= 20) return unique[num];
        if (num % 10 === 0) return tens[parseInt(num / 10)];
        return tens[parseInt(num / 10)] + " " + unique[num % 10];
    }
})();

HJ43 迷宫问题

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line.split(" ").map((e) => Number(e)));
    }
    let [n, m] = lineArr[0];
    let arr = lineArr.slice(1);
    function findRoute(x, y, route) {
        const newRoute = [...route]; 
        // 注意此处要对路径数组深拷贝防止污染，不然走错误的路时route也会被记录
        newRoute.push([x, y]); // 记录路径，并标记坐标
        arr[x][y] = 2; // 标记走过的路径
        if (x === n - 1 && y === m - 1) {
            // 当从左上角走到右下角，代表已经走出迷宫了
            for (let item of newRoute) {
                // 打印输出之前记录的路径
                console.log(`(${item[0]},${item[1]})`);
            }
            return newRoute;
        }
        if (x - 1 >= 0 && arr[x - 1][y] === 0) {
            // 向上走
            findRoute(x - 1, y, newRoute);
        }
        if (x + 1 < n && arr[x + 1][y] === 0) {
            // 向下走
            findRoute(x + 1, y, newRoute);
        }
        if (y - 1 >= 0 && arr[x][y - 1] === 0) {
            // 向左走
            findRoute(x, y - 1, newRoute);
        }
        if (y + 1 < m && arr[x][y + 1] === 0) {
            // 向右走
            findRoute(x, y + 1, newRoute);
        }
    }
    findRoute(0, 0, []);
})();

HJ44 Sudoku

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

void (async function () {
    let num = [];
    let line;
    while ((line = await readline())) {
        num.push(line.split(" ").map(Number));
    }
    // console.log(num)
    let flag = false; // flag 为true时表示推算完成，结束递归

    function check(n) {
        //判断当前位置的值是否满足条件
        let h = parseInt(n / 9); // 行号
        let l = n % 9; // 列号
        for (let i = 0; i < 9; i++) {
            //同一列值中不能有重复
            if (i != h && num[i][l] == num[h][l]) {
                return false;
            }
        }
        for (let j = 0; j < 9; ++j) {
            // 同一行不能有重复
            if (j != l && num[h][j] == num[h][l]) {
                return false;
            }
        }
        for (let i = parseInt(h / 3) * 3; i < parseInt(h / 3) * 3 + 3; ++i) {
            // 3*3九宫格不能有重复
            for (
                let j = parseInt(l / 3) * 3;
                j < parseInt(l / 3) * 3 + 3;
                ++j
            ) {
                if ((i != h || j != l) && num[i][j] == num[h][l]) {
                    return false;
                }
            }
        }
        return true;
    }
    function dfs(n) {
        if (n == 81) {
            // 如果已经递归到右下角，输出整个盘面，并设置flag为true,结束递归
            num.forEach((item) => {
                console.log(item.join(" "));
            });
            flag = true;
            return;
        }
        let h = parseInt(n / 9); //行号
        let l = n % 9; //列号
        // console.log(num[h])
        if (num[h][l] == 0) {
            // 如果当前位置为0，说明需要推算
            for (let i = 1; i <= 9; i++) {
                // 枚举1-9的数字，判断哪个满足条件
                num[h][l] = i;
                if (check(n)) {
                    //判断当前数字是否满足条件
                    dfs(n + 1); // 如果满足条件继续往下递归
                    if (flag) {
                        // 如果flag为true表示整个盘面的递归结束了
                        return true;
                    }
                }
            }
            num[h][l] = 0; // 需要回溯，恢复num[h][n]的值为0
        } else {
            // 当前位置不为0；往下一格递归
            dfs(n + 1);
        }
    }
    function main() {
        dfs(0); // 从左上角开始递归
        return 0;
    }
    main();
})();

HJ45 名字的漂亮度

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
    // 这道题主要就是看名字中重复次数最多的那个字符，赋予26漂亮度，然后按照次数逐次递减
    let lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let len = Number(lineArr[0]); // 行数，代表有多少个名字
    let nameArr = []; // 存储所有的名字
    for (let i = 0; i < len; i++) {
        nameArr.push(lineArr[i + 1]);
    }
    nameArr.forEach((item) => {
        let obj = {}; // 存储名字中单个字符出现的次数
        for (let i = 0; i < item.length; i++) {
            obj[item[i]] ? obj[item[i]]++ : (obj[item[i]] = 1);
        }
        let tempArr = Object.values(obj).sort((a, b) => b - a); // 提取出obj的value值得数组，并降序
        let total = 0; // 整个名字的漂亮度
        let fen = 26;
        tempArr.forEach((e) => {
            total += e * fen;
            fen--;
        });
        console.log(total);
    });
})();

HJ46 截取字符串

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
    line = await readline()
    n = await readline()
    console.log(line.substr(0,n))
}()

HJ48 从单向链表中删除指定值的节点

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 arr = line.split(" ");
        let nodeNum = arr.shift();
        let headValue = arr.shift();
        let deleteNode = arr.pop();
        let result = [];
        for (let i = 0; i < nodeNum; i++) {
            let current = arr.splice(0, 2);
            if (result.indexOf(current[1]) > -1) {
                result.splice(result.indexOf(current[1]) + 1, 0, current[0]);
            } else {
                result.push(current[1], current[0]);
            }
        }
        if (result.includes(deleteNode)) {
            result.splice(result.indexOf(deleteNode), 1);
        }
        console.log(result.join(" "));
    }
})();

HJ50 四则运算

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.replace(/[\[\{]/g, "(").replace(/[\]\}]/g, ")");
        console.log(Function(`return (${tokens})`)());
    }
})();

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

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);
    }
    for (let i = 0; i < inputArr.length; i += 3) {
        //每三行为1组循环输出
        let all = Number(inputArr[i]);
        let target = Number(inputArr[i + 2]);
        let numArr = inputArr[i + 1].split(" ");
        let result = numArr[all - target];
        console.log(result);
    }
})();

HJ52 计算字符串的编辑距离

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let [first, second] = lineArr;
    let firstLen = first.length;
    let secondLen = second.length;
    let dp = new Array(firstLen + 1)
        .fill(0)
        .map(() => new Array(secondLen + 1).fill(0));
    for (let i = 1; i <= firstLen; i++) {
        // 设置边界值
        dp[i][0] = i;
    }
    for (let j = 1; j <= secondLen; j++) {
        // 设置边界值
        dp[0][j] = j;
    }
    for (let i = 1; i <= firstLen; i++) {
        for (let j = 1; j <= secondLen; j++) {
            if (first[i - 1] === second[j - 1]) {
                // 当两个字符串的首位字符串相等时
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                // 当两位字符串的首位字符串不相等时，需要空出一个数
                dp[i][j] =
                    1 + Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    console.log(dp[firstLen][secondLen]);
})();

HJ53 杨辉三角的变形

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()) {
        if (line == 1 || line == 2) console.log(-1)
        else if (line % 2 == 1) console.log(2)
        else if (line % 4 == 0) console.log(3)
        else console.log(4)
    }
}()

HJ54 表达式求值

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(eval(line))
        console.log(Function(`return ${line}`)())
    }
}()

HJ55 挑7

//本题重点，只要是这个数字可以被7整除，或者这个数字的字符串类型中包含7即可
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 num = Number(line)
        let arr = []
        for(let i = 1; i <= num; i++){
            if(i % 7 === 0 || i.toString().includes('7')) arr.push(i)
        }
        console.log(arr.length)
    }
}()

HJ56 完全数计算

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 a = [],
            b = [],
            c = 0;
        for (let i = 2; i < line; i += 2) {
            for (let j = 1; j <= i / 2; j++) {
                if (i % j == 0) {
                    a.push(j);
                }
            }
            for (let j = 0; j < a.length; j++) {
                c += a[j];
            }
            if (c == i) {
                b.push(i);
                c = 0;
                a = [];
            } else {
                c = 0;
                a = [];
            }
        }
        console.log(b.length);
    }
})();

HJ57 高精度整数加法

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
    /**
     * 解题步骤
     * 1.先将两个字符串用split方法，转换出数组
     * 2.判断两个字符串数组的长度和暂存数temp
     * 3.使用~~first.pop()的目的，保证若前者长度小于后者长度，此时first.pop()=undefined，而~~undefined=0
     * 4.然后将同一位置的数字进行相加，若大于两者之和大于9，则需要进位，即将temp的值变为1，也就是true
     */
    let lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let first = lineArr[0].split("");
    let second = lineArr[1].split("");
    let temp = 0; // 暂存数
    let result = "";
    while (first.length || second.length || temp) {
        temp += ~~first.pop() + ~~second.pop(); // 此处temp为Number类型
        result = (temp % 10) + result; // 此处result为String类型
        temp = temp > 9 ? 1 : 0; // 判断是否需要进位
    }
    console.log(result);
})();

HJ58 输入n个整数，输出其中最小的k个

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.split(" "));
    }
    let [sum, part] = tokens[0];
    let nums = tokens[1].map((item) => Number(item));
    // console.log(nums)
    let f = (a, b) => (a > b ? 1 : a == b ? 0 : -1);
    nums.sort(f);
    console.log(nums.slice(0, part).join(" "));
})();

HJ59 找出字符串中第一个只出现一次的字符

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 strarr = line.split("");
        let obj = {}; //收集每个字符出现的次数
        for (let i = 0; i < strarr.length; i++) {
            if (obj[strarr[i]] >= 1) {
                obj[strarr[i]] += 1;
            } else {
                obj[strarr[i]] = 1;
            }
        }
        for (key in obj) {
            //遍历obj找到第一个value为1的打印即可
            if (obj[key] == 1) {
                console.log(key);
                return;
            }
        }
        console.log("-1");
    }
})();

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

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;
    while ((line = await readline())) {
        n = Number(line);
    }
    //判断是否为素数
    let f1 = function (n) {
        for (let i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) return false;
        }
        return true;
    };
    let min = 0,
        max = 0,
        diff = n;
    for (let i = 2; i <= n / 2; i++) {
        if (f1(i) && f1(n - i)) {
            if (diff > n - 2 * i) {
                diff = n - 2 * i;
                min = i;
                max = n - i;
            }
        }
    }
    console.log(min);
    console.log(max);
})();

HJ61 放苹果

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 arr = line.split(" ");
        let appleNum = Number(arr[0]);
        let plateNum = Number(arr[1]);
        fn(appleNum, plateNum);
    }
    /**
     * 动态规划
     * fn(m, n)，m为苹果数，n为盘子数；dp[m][n]表示将m个苹果放入n个盘子的摆放总数
     * 第一步，先处理一些边缘节点，比如0个苹果、1个苹果、1个盘子
     * 第二步，分为两种情况
     *      1.当i>=j时，也就是说苹果数大于盘子数，需要考虑是不是每个盘子都摆放苹果。
                 如果不摆放完盘子，那么至少有一个空盘子，放法有dp[i][j-1]；
                 如果摆放完盘子，那么每个盘子至少有一个苹果，放法有dp[i-j][j]。
                 那么摆放总数有dp[i][j]=dp[i][j-1] + dp[i-j][j]
     *      2.当i<j时，也就是说苹果数小于盘子数，那么盘子一定至少有一个是空的，那么放法有dp[i][j]=dp[i][j-1]
     */
    function fn(m, n) {
        // m代表苹果数，n代表盘子数
        // dp[m][n]表示将m个苹果放入n个盘子的摆放方案总数
        let dp = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(0));
        for (let i = 1; i <= n; i++) {
            dp[0][i] = 1; // 0个苹果，一种放法
            dp[1][i] = 1; // 1个苹果，一种放法
        }
        for (let i = 0; i <= m; i++) {
            dp[i][1] = 1; // 1个盘子，一种放法
        }
        for (let i = 2; i <= m; i++) {
            for (let j = 2; j <= n; j++) {
                if (i >= j) {
                    dp[i][j] = dp[i][j - 1] + dp[i - j][j];
                } else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        console.log(dp[m][n]);
    }
})();

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

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 inputarr = [];
    while ((line = await readline())) {
        inputarr.push(Number(line));
    }
    inputarr.forEach((item) => {
        let strOb = item.toString(2);
        let arrOf1 = strOb.split("").filter((item) => Number(item) == 1);
        console.log(arrOf1.length);
    });
})();

HJ63 DNA序列

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 str = inputArr[0],
        len = Number(inputArr[1]);
    let max = 0;
    let result = "";
    for (let i = 0; i < str.length - len + 1; i++) {
        let tempStr = str.substr(i, len);
        let count = 0; //临时记录字符串中
        for (key of tempStr) {
            if (key === "G" || key === "C") {
                count++;
            }
        }
        //逐个遍历每个子串,遇到比原来大的就替换，最后就得到了最大的子串
        if (count > max) {
            max = count;
            result = tempStr;
        }
    }
    console.log(result);
})();

HJ64 MP3光标位置

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

void (async function () {
    // total歌曲数量    udStr命令集字符串
    while (((total = await readline()), (udStr = await readline()))) {
        //核心思路：双指针滑动窗口   歌曲列表展开平铺,  显示窗口前后滑动，遇到边界特殊处理
        let udArr = udStr.split("");
        let songsArr = [];
        for (let i = 0; i < Number(total); i++) {
            songsArr.push(i + 1);
        }
        let left = 0; //窗口左边界
        let right = total >= 4 ? 3 : total - 1; //窗口右边界
        let point = 0; //光标

        // 函数调用
        let resultArr = [];
        udArr.forEach((item) => {
            if (item == "U") {
                resultArr = dealU(point, left, right, total);
                point = resultArr[0];
                left = resultArr[1];
                right = resultArr[2];
            } else {
                resultArr = dealD(point, left, right, total);
                point = resultArr[0];
                left = resultArr[1];
                right = resultArr[2];
            }
        });
        // 输出结果
        let resultSongs = [];
        for (let i = left; i <= right; i++) {
            resultSongs.push(i + 1);
        }
        console.log(resultSongs.join(" "));
        console.log(point + 1);

        // 处理指令
        // U指令
        function dealU(point, left, right, total) {
            //不翻页情况 point 在left和right中间
            if (point > left) {
                point -= 1;
            } else if (point == left) {
                // 需要翻页情况  point在left时  U
                //在数组边界时
                if (left == 0) {
                    point = total - 1; //跳转到最后一首歌
                    right = total - 1; //右边界 指向 最后一首歌
                    left = total >= 4 ? right - 3 : 0;
                } else {
                    //普通翻页
                    point = point - 1;
                    left -= 1;
                    right -= 1;
                }
            }
            return [point, left, right];
        }
        // D指令
        function dealD(point, left, right, total) {
            // 不翻页情况
            if (point < right) {
                point += 1;
            } else if (point == right) {
                // 特殊翻页
                if (right == total - 1) {
                    point = 0;
                    left = 0; //不管是多少数量的歌曲，特殊翻页时 left均为0
                    right = total >= 4 ? 3 : total - 1;
                } else {
                    //一般翻页
                    point += 1;
                    left += 1;
                    right += 1;
                }
            }
            return [point, left, right];
        }
    }
})();

HJ65 查找两个字符串a,b中的最长公共子串

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);
    }
    // 先找出2个字符串中，最长最短的字符串,以及最短字符串的长度;
    let minStr, maxStr, minLen;
    if (lineArr[0].length >= lineArr[1].length) {
        maxStr = lineArr[0];
        minStr = lineArr[1];
        minLen = lineArr[1].length;
    } else {
        maxStr = lineArr[1];
        minStr = lineArr[0];
        minLen = lineArr[0].length;
    }
    //定义最大子串的长度以及最大子串；
    let max = 0;
    let resultStr = "";
    // 循环minStr的所有子串，如果也是maxStr的子串，则是公共子串，
    //并且逐一替换最大值,最后的到最终结果
    for (let i = 0; i < minLen; i++) {
        for (let j = i + 1; j <= minLen; j++) {
            let tempStr = minStr.slice(i, j);
            if (maxStr.includes(tempStr) && tempStr.length > max) {
                resultStr = tempStr;
                max = tempStr.length;
            }
        }
    }
    console.log(resultStr);
})();

HJ66 配置文件恢复

// 解题思路：把输入的字符串分为一字串和二字串两种情况。根据题意，一字串唯一能盘匹配的条件只有reset；二字串则需要匹配两个唯一关键词。
// 将中的命令数组分为c1和c2，它们分别代表前后两个关键词，只有两个关键词都能匹配得上才符合条件，而且这样匹配上的命令不得有一条以上，否则还是
// 得输出错误指令
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void (async function () {
    const c1 = ["reset", "board", "board", "reboot", "backplane"];
    const c2 = ["board", "add", "delete", "backplane", "abort"];
    const act = [
        "reset what",
        "board fault",
        "where to add",
        "no board at all",
        "impossible",
        "install first",
    ];
    const fail = "unknown command";
    while ((line = await readline())) {
        let item = line.split(" ");
        let cnt = 0,
            index = 0;
        // 一字串的情况
        if (item.length === 1) {
            if ("reset".indexOf(item) === 0) {
                console.log(act[0]);
            } else {
                console.log(fail);
            }
        } else {
            // 二字串的情况
            let [n1, n2] = item;
            for (let i = 0; i < c1.length; i++) {
                if (c1[i].indexOf(n1) === 0 && c2[i].indexOf(n2) === 0) {
                    //  记录符合条件的字串数量和索引
                    ++cnt;
                    index = i;
                }
            }
            if (cnt === 1) {
                console.log(act[index + 1]);
            } else {
                console.log(fail);
            }
        }
    }
})();

HJ67 24点游戏算法

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 status // 设置一个状态来表示是否可以得到24
    while(line = await readline()){
        let lineArr = line.split(' ').map(e => Number(e))
        status = false // 状态默认为false，如果可以得到24，则将state置为true
        solution(-1, 0, lineArr) // 这里step设置为0，是因为一进去就是step++，变为0，pre为0，是因为未进行四则运算的初始值
        console.log(status)
    }
    /**
     * 类似于深度优先
     * step为运算次数，pre是进行任意四则运算的结果，arr为初始数组
     */
    function solution(step, pre, arr) { 
        if(step === 3) { // 已经运算四次
            if(pre === 24){ // 如果得到的数为24
                status = true
                return
            }
        } else {
            step++ // 每次运算，step加一
            for(let i = 0; i < arr.length; i++){
                let newArr = JSON.parse(JSON.stringify(arr)) // 不改变原始数组，还可以使用arr.slice()和arr.concat()也不会改变原数组，只会生成一个数组副本，返回给newArr
                let num = newArr.splice(i, 1)[0] // 删除新数组的每一项的后面一位作为四则运算，splice()会返回一个包含删除的那些数据项的新数组，会改变原数组
                solution(step, pre+num, newArr)
                solution(step, pre-num, newArr)
                solution(step, pre*num, newArr)
                solution(step, pre/num, newArr)
            }
            return
        }
    }
}()

HJ68 成绩排序

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 num = Number(inputArr[0]);
    let sortType = Number(inputArr[1]); //1升序    0降序
    let originArr = inputArr.slice(2);
    let dataArr = []; //用于存放json格式的数组数据
    for (let i = 0; i < originArr.length; i++) {
        dataArr.push({
            name: originArr[i].split(" ")[0],
            scort: Number(originArr[i].split(" ")[1]),
        });
    }
    //将数据按照scort分数排序
    if (sortType === 1) {
        dataArr.sort((a, b) => a.scort - b.scort);
    } else if (sortType === 0) {
        dataArr.sort((a, b) => b.scort - a.scort);
    }
    //再转化为字符串格式的数组，进行输出
    let resultArr = [];
    dataArr.forEach((item) => {
        resultArr.push(item.name + " " + item.scort);
    });
    resultArr.forEach((item) => {
        console.log(item);
    });
})();

HJ69 矩阵乘法

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

![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c0fbe25488584815974333fb0fa8de7d~tplv-k3u1fbpfcp-watermark.image?)
void (async function () {
    /**
     * 1 2 3     1 2 1 2
     * 3 2 1     2 1 1 3
     *           3 3 1 2
     */
    let inputArr = [];
    while ((line = await readline())) {
        inputArr.push(line);
    }
    let rowX = Number(inputArr[0]); //x行数
    let colX = Number(inputArr[1]); //x列数
    let rowY = colX; //y行数
    let colY = Number(inputArr[2]); //y列数
    let inputArrX = inputArr.slice(3, 3 + rowX);
    let inputArrY = inputArr.slice(3 + rowX);
    let arrX = [],
        arrY = [];
    //得到x的数组结构[[1,2,3],[3,2,1]] arrX
    inputArrX.forEach((item) => {
        arrX.push(item.split(" ").map(Number));
    });
    inputArrY = inputArrY.map((item) => item.split(" ").map(Number));
    //得到y的数组结构[[1,2,3],[2,1,3], [1,1,1], [2,3,2]] arrY
    for (let i = 0; i < colY; i++) {
        let itemArr = [];
        for (let j = 0; j < inputArrY.length; j++) {
            itemArr.push(inputArrY[j][i]);
        }
        arrY.push(itemArr);
    }
    //计算2个数组的积的和的方法
    function getTotal(arr1, arr2) {
        let total = 0;
        for (let i = 0; i < arr1.length; i++) {
            total += arr1[i] * arr2[i];
        }
        return total;
    }
    let resultArr = [];//最后输出的数组
    for(let i = 0;i<arrX.length;i++){
        let resultLine = [];//循环arrX,逐次得到每行输出的数组
        for(let j = 0; j<arrY.length;j++){
            resultLine.push(getTotal(arrX[i],arrY[j]))
        }
        resultArr.push(resultLine);
    }
    resultArr.forEach(item => {
        console.log(item.join(' '));
    })
})();

HJ70 矩阵乘法计算量估算

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 ((n = Number(await readline()))) {
        let obj = [];
        for (let i = 0; i < n; i++) {
            let key = String.fromCharCode("A".charCodeAt(0) + i);
            obj[key] = (await readline()).split(" ").map(Number);
        }
        let ruleStr = await readline();
        let count = 0;
        let stack = [];
        for (let i = 0; i < ruleStr.length; i++) {
            if (ruleStr[i] !== ")") {
                // 不是右括号就入栈
                stack.push(ruleStr[i]);
            } else {
                // 右括号出栈
                let list = [];
                let temp = stack.pop();
                while (temp !== "(" && temp) {
                    // 把遇到左括号前的矩阵都弹出来存放到list
                    let item = temp instanceof Array ? temp : obj[temp];
                    list.unshift(item);
                    temp = stack.pop();
                }
                // 把list的矩阵按顺序计算
                let newMatrix = list.reduce((pre, cur, index) => {
                    count += index ? pre[0] * cur[1] * cur[0] : 0;
                    return index ? [pre[0], cur[1]] : cur;
                }, null);
                // 把计算结果重新放回栈中
                stack.push(newMatrix);
            }
        }
        console.log(count);
    }
})();

HJ71 字符串通配符

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 line = await readline();
    var line2 = await readline();
    var regStr = line
        .toLowerCase()
        .replace(/\*+/g, "*")
        .replace(/\*/g, "[a-z0-9.]*")
        .replace(/\?/g, "[a-z0-9.]");
    var reg = new RegExp("^" + regStr + "$", "ig");
    console.log(reg.test(line2));
})();

HJ72 百钱买百鸡问题

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())) {
        /**
         * 整出一个方程式
         * 设公鸡为a，母鸡为b，小鸡为c
         * 可得5a+3b+(1/3*c) = 100 和 a+b+c = 100
         * 得7a+4b = 100
         */
        for (let i = 0; i < 20; i++) {
            for (let j = 0; j < 33; j++) {
                if (7 * i + 4 * j === 100) {
                    let k = 100 - i - j;
                    console.log(i + " " + j + " " + k);
                }
            }
        }
    }
})();

HJ73 计算日期到天数转换

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 a = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
        let b = 0;
        for (let i = 0; i < tokens[1] - 1; i++) {
            //匹配数组，累加天数
            b += a[i];
        }
        //判断是否润年，月份不是2月
        if (
            (tokens[0] % 4 == 0 && tokens[0] % 100 != 0 && tokens[1] != 2) ||
            (tokens[0] % 400 == 0 && tokens[1] != 2)
        ) {
            //是便累加的天数+1天+日
            console.log(b + 1 + parseInt(tokens[2]));
        } else {
            console.log(b + parseInt(tokens[2]));
        }
    }
})();

HJ74 参数解析

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 canDivide = true;
        let result = [];
        let tmp = "";
        for (let i = 0; i < line.length; i++) {
            if (line[i] === '"' && canDivide) {
                canDivide = false;
            } else if (line[i] === " " && !canDivide) {
                // 双引号里面遇到空格 照常拼接
                tmp += line[i];
            } else if (line[i] === " " && canDivide) {
                tmp && result.push(tmp);
                tmp = "";
            } else if (line[i] === '"' && !canDivide) {
                // 双引号结束了
                canDivide = true;
                result.push(tmp);
                tmp = "";
            } else {
                tmp += line[i];
            }
            if (i === line.length - 1 && /[^"]/.test(line[i])) {
                result.push(tmp);
            }
        }
        console.log(result.length);
        result.forEach((item) => {
            console.log(item);
        });
    }
})();

HJ75 公共子串计算

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 lineArr = [];
    while ((line = await readline())) {
        lineArr.push(line);
    }
    let [first, second] = lineArr;
    let max = 0; // 公共子字符串的最大长度
    for (let i = 0; i < first.length; i++) {
        for (let j = i; j <= first.length; j++) {
            let tempStr = first.slice(i, j); // slice(i,j)代表从字符串的第i项开始截取后面j项
            if (second.includes(tempStr) && tempStr.length > max) {
                // 除了includes()，还可以使用startWith()
                max = tempStr.length;
            }
        }
    }
    console.log(max);
})();

HJ76 尼科彻斯定理

//找规律得到的方法
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    //找规律，当正整数为n时，组成它立方的n个奇数的第一个为n(n-1)+1;
    while ((line = await readline())) {
        const n = Number(line);
        let resultArr = [];
        let first = n * (n - 1) + 1; //第一个奇数
        resultArr.push(first);
        //将其他的n-1个奇数push进去
        for (let i = 1; i < n; i++) {
            resultArr.push(first + 2 * i);
        }
        let resultStr = "";
        resultArr.forEach((item) => {
            resultStr += `${item}+`;
        });
        resultStr = resultStr.slice(0, resultStr.length - 1);
        console.log(resultStr);
    }
})();

HJ77 火车进站

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 trains = (await readline()).split(" ");
        let res = [];
        backtrack(0, [], []);
        console.log(res.sort().join("\n"));
        function backtrack(i, out, stack) {
            if (out.length === n) {
                res.push(out.join(" "));
                return;
            }
            // 先进站，要回溯
            if (stack.length >= 0 && i < n) {
                stack.push(trains[i]);
                backtrack(i + 1, out.slice(), stack.slice());
                stack.pop();
            }
            // 出站
            if (stack.length > 0 && i <= n) {
                out.push(stack.pop());
                backtrack(i, out, stack);
            }
        }
    }
})();

HJ80 整型数组合并

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);
    }
    const arr1 = inputArr[1].split(" ").map(Number);
    const arr2 = inputArr[3].split(" ").map(Number);
    const arr = arr1.concat(arr2); //拼接数组
    const resultArr = [...new Set(arr)]; //数组去重
    resultArr.sort((a, b) => a - b); //排序
    console.log(resultArr.join(""));
})();