题目地址：www.nowcoder.com/ta/huawei

从易到难，慢慢刷题！

未必能100%通过用例，写的难看，复杂度还高，哎，丢死人了。

入门

HJ7 取近似值

描述

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。

数据范围：保证输入的数字在 32 位浮点数范围内

输入描述：

输入一个正浮点数值

输出描述：

输出该数值的近似整数值

示例1

输入：

5.5

输出：

6

说明：

0.5>=0.5，所以5.5需要向上取整为6   

示例2

输入：

2.499

输出：

2

说明：

0.499<0.5，2.499向下取整为2   

解题

利用 Math.round()，自动向上取整

let num = parseFloat(readline());
console.log(Math.round(num));

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

描述

输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。

数据范围：保证在 32 位整型数字范围内\

输入描述：

 输入一个整数（int类型）

输出描述：

 这个数转换成2进制后，输出1的个数

示例1

输入：

5

输出：

2

示例2

输入：

0

输出：

0

题解

考察十进制至二进制的转化。

//十进制转其他
var x=110;
w(x);
w(x.toString(8));
w(x.toString(32));
w(x.toString(16));

//其他转十进制
var x='110';
w(parseInt(x,2));
w(parseInt(x,8));
w(parseInt(x,16));

let num = parseInt(readline())
num = num.toString(2);
let count = 0;
for(let i=0; i<num.length; i++){
    if(num[i] === '1'){
        count++
    }
}
console.log(count)

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

描述

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

数据范围：  ，元素大小满足 \

输入描述：

第一行输入数组元素个数
第二行输入待排序的数组，每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序，1代表降序排序

输出描述：

输出排好序的数字

示例1

输入：

8
1 2 4 9 3 55 64 25
0

输出：

1 2 3 4 9 25 55 64

示例2

输入：

5
1 2 3 4 5
1

输出：

5 4 3 2 1

解题

1. map(parseInt) 返回错误输出，原因是parseInt有多个参数输入。
2. arr.sort((a,b) => a - b); a - b 决定了数组按值排序顺序。
3. 使用 arr.join(' ') 而不是 arr.toString() 可避免数组内出现逗号

let num = parseInt(readline());
let arr = readline().split(' ').map((data)=>{
    parseInt(data);
    return data;
});
let sort_seq = readline();

function sortByValue(arr){
    arr = arr.sort((a,b) => a - b);
    return arr
}

if (sort_seq === '0'){
    sortByValue(arr)
    console.log(arr.join(' '));
}
else if (sort_seq === '1'){
    sortByValue(arr).reverse();
    console.log(arr.join(' '));
}

简单

HJ11 数字颠倒

描述

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

数据范围： \

输入描述：

输入一个int整数

输出描述：

将这个整数以字符串的形式逆序输出

示例1

输入：

1516000

输出：

0006151

示例2

输入：

0

输出：

0

解题

let line = readline();

function reverseLine(line){
    let rev_line = line.split('').reverse().join('');
    return rev_line
}

console.log(reverseLine(line));

HJ12 字符串反转

描述

接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述：

输入一行，为一个只包含小写字母的字符串。

输出描述：

输出该字符串反转后的字符串。

示例1

输入：

abcd

输出：

dcba

解题

let str = readline();

function rev_str(str){
    let rev = str.split('').reverse().join('');
    return rev;
}

console.log(rev_str(str));

HJ22 汽水瓶

描述

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是 5 瓶，方法如下：先用 9 个空瓶子换3瓶汽水，喝掉 3 瓶满的，喝完以后 4 个空瓶子，用 3 个再换一瓶，喝掉这瓶满的，这时候剩 2 个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用 3 个空瓶子换一瓶满的还给老板。如果小张手上有 n 个空汽水瓶，最多可以换多少瓶汽水喝？

数据范围：输入的正整数满足 

注意：本题存在多组输入。

允许如题面所述向老板借汽水。

输入的 0 仅表示输入结束，并不用输出结果

输入描述：

输入文件最多包含 10 组测试数据，每个数据占一行，仅包含一个正整数 n（ 1<=n<=100 ），表示小张手上的空汽水瓶数。n=0 表示输入结束，你的程序不应当处理这一行。

输出描述：

对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

示例1

输入：

3
10
81
0

输出：

1
5
40

说明：

样例 1 解释：用三个空瓶换一瓶汽水，剩一个空瓶无法继续交换
样例 2 解释：用九个空瓶换三瓶汽水，剩四个空瓶再用三个空瓶换一瓶汽水，剩两个空瓶，向老板借一瓶汽水喝完得三个空瓶换一瓶汽水还给老板 

解题

这道题其实不难，但是我踩到了一个大坑，甚至现在都没弄明白这个坑怎么回事。

最初的方法是这样的，单独用例可以通过，但到保存和提交就开始疯狂报错，显示运行超时，内存占用0K，我真的不知道发生了什么。

let line = readline();
let each_line = [];
while(line !== '0'){
    each_line.push(parseInt(line));
    line = readline();
}

function count_bottles(empty){
    let total = 0;

    while(empty !== 0){
        if (empty > 2){
            total += parseInt(empty/3);
            empty = parseInt(empty/3) + empty%3
        }
        else if(empty === 2){
            total +=1;
            empty = 0
            console.log(total)
        }
        else{
            empty=0;
            console.log(total)
        }
    }

}
each_line.forEach(count_bottles)

我从网上找了找答案，发现有一个简单的写法替代读了再塞array塞完再挨个调用的过程。

while(empty = readline()){
    let total = 0;

    while(empty !== 0){
        if (empty > 2){
            total += parseInt(empty/3);
            empty = parseInt(empty/3) + empty%3
        }
        else if(empty === 2){
            total +=1;
            empty = 0
            console.log(total)
        }
        else{
            empty=0;
            console.log(total)
        }
    }

}

while(line = readline()){} 这个写法对于多组输入确实有用，我得背一下。

事实上这道题还有个究极简单的写法：
只能说审题，然后逻辑思考很重要了，其实最后理解就是：2个空瓶就能换一瓶

let str;
while(str = readline()){
    console.log(Math.floor(parseInt(str)/2))
}

HJ31 单词倒排

描述

对字符串中的所有单词进行倒排。

说明：

1、构成单词的字符只有26个大写或小写英文字母；

2、非构成单词的字符均视为单词间隔符；

3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；

4、每个单词最长20个字母；

数据范围：字符串长度满足 

输入描述：

输入一行以空格来分隔的句子

输出描述：

输出句子的逆序

示例1

输入：

I am a student

输出：

student a am I

示例2

输入：

$bo*y gi!r#l

输出：

l r gi y bo

解题

这道题主要考正则表达，参考 www.runoob.com/jsref/jsref…

let line = readline();
let words = line.split(/[^a-zA-Z]+/).reverse().join(' ');
console.log(words)

HJ37 统计每个月兔子的总数

描述

有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？

本题有多组数据。

数据范围：每组输入满足 

输入描述：

多行输入，一行输入一个int型整数表示第n个月

输出描述：

每一行输出对应的兔子总数

示例1

输入：

1
2
3
4
5
9

输出：

1
1
2
3
5
34

解题

看到兔子就知道是斐波那契。F(n) = F(n-1) + F(n-2)；

这里没有使用递归，递归对空间和时间的消耗都很大，而且很可能导致栈溢出。 对于这种有时间和内存限制的考试来说有点小危险。

斐波那契本质是数列，i-1与i-2的和为i，干脆就用array将每个月兔子的数量列出，随后相加，即得出当前月份兔子的数量。

function rabbits(mon){
    let count = [];
    count[0] = 0;
    count[1] = 1;
    for(let i=2; i<=mon; i++){
        count[i] = count[i-1] + count[i-2];
    }
    return count[count.length-1];
}
while(mon = readline()){
    console.log(rabbits(mon));
}

HJ50 四则运算

描述

输入一个表达式（用字符串表示），求这个表达式的值。

保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

数据范围：表达式计算结果和过程中满足  ，字符串长度满足 

输入描述：

输入一个算术表达式

输出描述：

得到计算结果

示例1

输入：

3+2*{1+2*[-4/(8-6)+7]}

输出：

25

解题

乍一看非常像PPL里面编译器怎么开发，但是JS有个取巧的办法，利用eval()，将传入的字符串作为js代码执行。

但js不识别中括号和花括号，因此需要替换一下。

function replace_bracket(line){
    line = line.replace('[','(').replace(']',')').replace('{','(').replace('}',')')
    return line
}
let statement = readline();
let result = eval(replace_bracket(statement));
console.log(result);

HJ53 杨辉三角的变形

描述

以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上角数到右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。

求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。

数据范围： 

本题有多组输入数据

输入描述：

输入一个int整数

输出描述：

输出返回的int值

示例1

输入：

4
2

输出：

3
-1

解题

• 找规律 杨辉三角的复杂程度起码为O(n^2)，一不小心就超时了。

通过观察三角会发现偶数位置有规律：

当n<3时，没有偶数，输出-1；
当n为奇数时，第一个偶数位置在第二，输出2；
当n为偶数且能被4整除时，第一个偶数位置在第三，输出3；
当n为偶数但不能被4整除时，偶数位置在第四，输出4；

while(num = readline()){
    console.log(get_even(num));
}
function get_even(n){
    if(n<3){
        return -1;
    }
    else if(n%2 == 1){
        return 2
    }
    else if(n%2 == 0 && n%4 == 0){
        return 3
    }
    else{
        return 4;
    }
}

• 真实使用杨辉三角的变形解题 - Python：

while True:
    try:
        n = int(input())
        res = - 1    #初始化结果为-1
        l = [[0]*(2*n+1) for _ in range(n)]    #以n行的长度创建二维矩阵，每行开头插入2个0
        l[0][2] = 1    #第一行起始值为1（因开头插入了两个0，所以第三位为1）
        for x in range(1,n):    #构造完整的杨辉三角矩阵
            for j in range(2,2*(x+2)-1):
                l[x][j] = l[x-1][j-2]+l[x-1][j-1]+l[x-1][j]
        for i in range(len(l[n-1][2:])):    #遍历杨辉三角矩阵最后一行，去掉开始插入的两个0
            if int(l[n-1][2:][i])%2 == 0:    #如果发现偶数，输入下标，并把答案res置为！=-1的值
                print(i+1)
                res = 0
                break
        if res == -1:    #如果前面没有找到偶数，那么res还是初始值，输出即可满足题意
            print(-1)
    except:
        break

HJ56 完全数计算

描述

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。

输入n，请输出n以内(含n)完全数的个数。

数据范围： 

本题输入含有多组样例。

输入描述：

输入一个数字n

输出描述：

输出不超过n的完全数的个数

示例1

输入：

1000
7
100

输出：

3
1
2

解题

首先，我套着算法皮的数学题。

这道题有个麻烦的地方是算法复杂度基本降不下去。写的时候很怕超时，好在没有。

完美数简介：
各个小于它的约数（真约数,列出某数的约数，去掉该数本身，剩下的就是它的真约数）的和等于它本身的自然数叫做完全数（Perfect number），又称完美数或完备数。 例如：第一个完全数是6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。第二个完全数是28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，

简而言之：

1. 遍历所有数
2. 找该数的所有因数（只要找到n/2就可以，大于n/2没有因数）
3. 求因数和，是否等于该数

显然要有两层for loop，O(n^2)

let num;
while(num = parseInt(readline())){
    let perfect = [];
    for(let j=2; j<num; j++){
        let count = [];
        for(let i=1; i<=j/2; i++){
            if(j%i === 0){
                count.push(i);
            }
        }
        function sum(arr) {
            return eval(arr.join("+"));
        }
        let tmp = sum(count);
        if(tmp === j){
            perfect.push(tmp);
        }
    }
    if(perfect.length > 0){
        console.log(perfect.length);
    }
}

HJ61 放苹果 （动态规划）

描述

把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

数据范围：，。

本题含有多组样例输入。

输入描述：

输入两个int整数

输出描述：

输出结果，int型

示例1

输入：

7 3

输出：

8

解题

考察动态规划

参考视频： www.bilibili.com/video/BV1X4…

function methods(m,n){
    // 苹果或盘子数小于0， 报错
    if(m<0 || n<0){
        return 0
    }
    // 苹果或盘子只有一个，只有一种可能
    else if(m === 1 || n === 1){
        return 1
    }
    // 引入递归
    else{
        // 起码一个盘子空着的情况 + 苹果多余盘子（即最多剩下m-n个苹果）的情况
        return methods(m,n-1) + methods(m-n,n)
    }
}
let line;
while(line = readline()){
    line = line.split(' ').map((data) =>{
        data = parseInt(data);
        return data;
    });
    console.log(methods(line[0],line[1]));
}

HJ62 查找输入整数二进制中1的个数 （进制转换）

描述

输入一个正整数，计算它在二进制下的1的个数。

*注意多组输入输出！！！！！！*

数据范围： 

输入描述：

输入一个整数

输出描述：

计算整数二进制中1的个数

示例1

输入：

5

输出：

2

说明：

5的二进制表示是101，有2个1   

示例2

输入：

0

输出：

0

解题

小心多组输入！！！

考进制转换

let num;
while(num = readline()){
    num = parseInt(num).toString(2);
    let count = 0;
    for(let i=0; i<num.length; i++){
        if(num[i] === '1'){
            count++
        }
    }
    console.log(count);
}

HJ66 配置文件恢复

放弃这题……太烦了

HJ72 百钱买百鸡问题

描述

公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

现要求你打印出所有花一百元买一百只鸡的方式。

输入描述：

输入任何一个整数，即可运行程序。

输出描述：

 输出有数行，每行三个整数，分别代表鸡翁，母鸡，鸡雏的数量

示例1

输入：

1

输出：

0 25 75
4 18 78
8 11 81
12 4 84

解题

没有复杂度要求，事情一下变得简单了，列方程5a + 3b + (1/3)*（100-a-b) = 100，两层 for loop 算出 a,b。 注意 c=100-a-b 需为整数, b取整。

function getChicken(){
    for(let a=0; a<=100/5; a++){
        for(let b=0; b<Math.round(100/3); b++){
            let c = 100-a-b;
            if(a*5+b*3+c*(1/3)===100 && c%3 ===0){
                console.log(a + ' ' + b + ' ' + c);
            }
        }
    }
}
let num;
while(num = readline()){
    getChicken()
}

HJ73 计算日期到天数转换

描述

根据输入的日期，计算是这一年的第几天。

保证年份为4位数且日期合法。

进阶：时间复杂度：，空间复杂度：

输入描述：

输入一行，每行空格分割，分别是年，月，日

输出描述：

输出是这一年的第几天

示例1

输入：

2012 12 31

输出：

366

示例2

输入：

1982 3 4

输出：

63

解题

• 闰年算法

if（(n%4 == 0 && n%100 != 0) || n %400 == 0）{}

function countDates(arr){
    let month = [31,28,31,30,31,30,31,31,30,31,30,31];
    let y = arr[0];
    let m = arr[1];
    let d = arr[2]

    if((y%4 == 0 && y%100 != 0) || y %400 == 0){
        month[1] +=1
    }
    let dates = 0;
    for(let i=0; i<m-1;i++){
        dates += month[i]
        
    }
    dates += d;
    
    return dates
}


let line;
while(line = readline()){
    let arr = line.split(' ');
    let tmp = arr.map((i) =>{
        return parseInt(i);
    })
    console.log(countDates(tmp));
}

HJ74 参数解析

描述

在命令行输入如下命令：

xcopy /s c:\ d:\e，

各个参数如下：

参数1：命令字xcopy

参数2：字符串/s

参数3：字符串c:\

参数4: 字符串d:\e

请编写一个参数解析程序，实现将命令行各个参数解析出来。

解析规则：

1.参数分隔符为空格
2.对于用""包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s "C:\program files" "d:"时，参数仍然是4个，第3个参数应该是字符串C:\program files，而不是C:\program，注意输出参数时，需要将""去掉，引号不存在嵌套情况。
3.参数不定长

4.输入由用例保证，不会出现不符合要求的输入

数据范围：字符串长度：

进阶：时间复杂度：，空间复杂度：

输入描述：

输入一行字符串，可以有空格

输出描述：

输出参数个数，分解后的参数，每个参数都独占一行

示例1

输入：

xcopy /s c:\ d:\e

输出：

4
xcopy
/s
c:\
d:\e

解题

挨个处理每一个字符, 遇到空就跳，遇到引号整个切下。

或许也可以用正则做，匹配的更准。

function splitCmd(line){
    let fragments = [];
    let word ='';
    while(line.length > 0){
        if(line[0] !== ' ' && line[0] !== "\""){
            word += line.splice(0,1);
        }
        if(line[0] ===" "){
            fragments.push(word)
            line.splice(0,1)
            word = '';
        }
        if(line[0] === '\"'){
            line.splice(0,1);
            let last = line.indexOf('\"')
            let word = line.splice(0, last).join('');
            line.splice(0,1);
            fragments.push(word);
            word = '';
        }
    }
    if(word !== ''){
        fragments.push(word);
    }
    let empty = fragments.indexOf('')
    empty > 0 ? fragments.splice(empty,1) :false;
    
    console.log(fragments.length)
    fragments.forEach(frag => console.log(frag));
}
let line;
while(line = readline()){
    splitCmd(line.split(''));
}

HJ75 公共子串计算

描述

给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。

注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。

数据范围：字符串长度：

进阶：时间复杂度：，空间复杂度：

输入描述：

输入两个只包含小写字母的字符串

输出描述：

输出一个整数，代表最大公共子串的长度

示例1

输入：

asdfas
werasdfaswer

输出：

6

解题

时间复杂度给的很够，直接俩 loop 暴力破解。其实应该老实用动态规划做的。

function maxSubstring(arr){
    let max = 0;
    let first = arr[0];
    let second = arr[1];
    for(let i=0; i <= first.length; i++){
        for(let j=1; j <= first.length; j++){
            let tmp = first.substring(i,j);
            if(second.includes(tmp)){
                tmp.length > max ? max = tmp.length : max = max;
            }
        }
    }
    console.log(max);
}
let arr = [];
let line;
while(line = readline()){
    arr.push(line);
}
maxSubstring(arr);

HJ76 尼科彻斯定理

描述

验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。

例如：

1^3=1

2^3=3+5

3^3=7+9+11

4^3=13+15+17+19

输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。

本题含有多组输入数据。

数据范围：数据组数：，

进阶：时间复杂度：，空间复杂度：\

输入描述：

输入一个int整数

输出描述：

输出分解后的string

示例1

输入：

6

输出：

31+33+35+37+39+41

解题

找规律，经观察：第一项为n (n-1)+1，最后一项为n(n+1)-1。

let num;
while(num = readline()){
    num = parseInt(num);
    let arr = [];
    let start = num*(num-1)+1;
    let end = num*(num+1)-1;
    for(let i=start; i<=end; i+=2){
        arr.push(i);
    }
    let str = arr.join("+");
    console.log(str);
}

HJ83 二维数组操作

描述

有一个大小的数据表，你会依次进行以下5种操作：

1.输入和，初始化大小的表格。

2.输入x_1x1​、y_1y1​、x_2x2​、y_2y2​，交换坐标在(x_1,y_1)(x1​,y1​)和(x_2,y_2)(x2​,y2​)的两个数。

3.输入，在第行上方添加一行。

4.输入，在第列左边添加一列。

5.输入、，查找坐标为的单元格的值。\

请编写程序，判断对表格的各种操作是否合法。

详细要求:

1.数据表的最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误。

2.对于插入操作，如果插入后行数或列数超过9了则应返回错误。如果插入成功了则将数据表恢复至初始化的大小，多出的数据则应舍弃。\

3.所有输入坐标操作，对大小的表格，行号坐标只允许0m-1，列号坐标只允许0n-1。超出范围应该返回错误。

本题含有多组样例输入！

数据范围：数据组数：

进阶：时间复杂度：，空间复杂度：\

输入描述：

输入数据按下列顺序输入：
1 表格的行列值
2 要交换的两个单元格的行列值
3 输入要插入的行的数值
4 输入要插入的列的数值
5 输入要查询的单元格的坐标

输出描述：

输出按下列顺序输出：
1 初始化表格是否成功，若成功则返回0， 否则返回-1
2 输出交换单元格是否成功
3 输出插入行是否成功
4 输出插入列是否成功
5 输出查询单元格数据是否成功

解题

瞅了一眼这道题通过率不高，估计和我一样题干看一半就抓狂的人不少。

HJ84 统计大写字母个数

描述

找出给定字符串中大写字符(即'A'-'Z')的个数。

数据范围：字符串长度：

字符串中可能包含空格或其他字符

进阶：时间复杂度：，空间复杂度：\

输入描述：

本题含有多组样例输入
对于每组样例，输入一行，代表待统计的字符串

输出描述：

对于每组样例，输出一个整数，代表字符串中大写字母的个数 示例1

输入：

add123#$%#%#O
150175017(&^%&$vabovbao
A 1 0 11

输出：

1
0
1

解题

let line;
while(line = readline()){
    let reg = /[A-Z]/g
    let result = line.match(reg);
    result !== null ? console.log(result.length) : console.log(0);
    
}

HJ85 最长回文子串

描述

给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。

所谓回文串，指左右对称的字符串。

所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串\

数据范围：字符串长度

进阶：时间复杂度：，空间复杂度：\

输入描述：

输入一个仅包含小写字母的字符串

输出描述：

返回最长回文子串的长度\

示例1

输入：

cdabbacc

输出：

4

解题

智障解法：暴力破解

let line;
while(line = readline()){
    let max = 0;
    for(let i=0; i<=line.length; i++){
        for(let j=0; j<line.length; j++){
            let sub = line.substring(i,j);
            let rev = sub.split('').reverse().join('');
            if(sub === rev){
                sub.length > max ? max = sub.length : false;
            }
        }
    }
    console.log(max);
}

HJ86 求最大连续bit数

描述

求一个int类型数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1\

本题含有多组样例输入。

数据范围：数据组数：，

进阶：时间复杂度：，空间复杂度：\

输入描述：

输入一个int类型数字

输出描述：

输出转成二进制之后连续1的个数

示例1

输入：

3
5
200

输出：

2
1
2

说明：

3的二进制表示是11，最多有2个连续的1。
5的二进制表示是101，最多只有1个连续的1。   

解题

连续的 1 中间或许间隔 0，则以 0 为切分符号，获得每一段 1 的数组，找出数组中长度最大的一项。

let line;
while(line = readline()){
    let bin = parseInt(line).toString(2).split("0");
    let max = 0;
    bin.forEach((i) =>{
        i.length > max ? max = i.length : false
    })
    console.log(max);
}

HJ97 记负均正

描述

首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。

0即不是正整数，也不是负数，不计入计算

数据范围：  ，输入的整数都满足 \

输入描述：

本题有多组输入用例。

首先输入一个正整数n，
然后输入n个整数。

输出描述：

输出负数的个数，和所有正整数的平均值。

示例1

输入：

5
1 2 3 4 5
10 
1 2 3 4 5 6 7 8 9 0

输出：

0 3.0
0 5.0

解题

保留小数: toFixed(<位数>)

let arr = [];
let line;
while(line = readline()){
    arr.push(line);
}
for(let i=0; i<arr.length; i+=2){
    let len = arr[i];
    let series = arr[i+1].split(' ').map((n) => parseInt(n));
    let negative = 0;
    let positive = [];
    series.forEach((n) =>{
        if(n > 0){
            positive.push(n);
        }
        else if(n < 0){
            negative++;
        }
    });
    let mean = eval(positive.join('+')) / (positive.length);
    mean = mean.toFixed(1);
    console.log(negative + " " + mean);
}

HJ91 走方格的方案数

描述

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

注：沿棋盘格之间的边缘线行走

本题含有多组样例输入。

数据范围： 

输入描述：

每组样例输入两个正整数n和m，用空格隔开。(1≤n,m≤8)

输出描述：

每组样例输出一行结果\

示例1

输入：

2 2
1 2

输出：

6
3

解题

function paths(m,n){
    if(m === 0 || n === 0){
        return 1;
    }
    else{
        return paths(m-1,n) + paths(m,n-1);
    }
}
let line;
while(line = readline()){
    line = line.split(' ');
    line.forEach((num) => parseInt(num))
    let [m,n] = line;
    console.log(paths(m,n));
}

HJ100 等差数列

描述

等差数列 2，5，8，11，14。。。。

（从 2 开始的 3 为公差的等差数列）

输出求等差数列前n项和

本题有多组输入

数据范围： 

输入描述：

输入一个正整数n。

输出描述：

输出一个相加后的整数。

示例1

输入：

2

输出：

7

说明：

2+5=7 

示例2

输入：

275

输出：

113575

说明：

2+5+...+821+824=113575

解题

// 末项 an = a1 + (n-1)*d
// 等差数列求和：首项加末项乘项数除2

let n;
while(n = parseInt(readline())){
    let d = 3;
    let a1 = 2;
    let an = a1 + (n-1)*d;
    let sum = ((a1+an) * n )/ 2
    console.log(sum);
}

HJ106 字符逆序

描述

将一个字符串str的内容颠倒过来，并输出。

数据范围：\

输入描述：

输入一个字符串，可以有空格

输出描述：

输出逆序的字符串

示例1

输入：

I am a student

输出：

tneduts a ma I

示例2

输入：

nowcoder

输出：

redocwon

解题

let line;
while(line = readline()){
    console.log(line.split('').reverse().join(''));
}

HJ108 求最小公倍数

描述

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

数据范围：

输入描述：

输入两个正整数A和B。

输出描述：

输出A和B的最小公倍数。

示例1

输入：

5 7

输出：

35

示例2

输入：

2 4

输出：

4

解题

let line;
while(line = readline()){
    line = line.split(' ').map(num => parseInt(num));
    let [a,b] = line;
    console.log(common_multiple(a,b));
    
}
function common_multiple(a,b){
    let max = a * b;
    let result = max;
    for(let i=a; i<=max; i++){
        if(i%a === 0 && i%b ===0 && i < max){
            return i;
        }
    }
    return max;
}