牛客.md

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

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）

function getLastWordLen(str) {
  return str.split(/\s/).splice(-1)[0].length
}
print(getLastWordLen(readline()))

2.计算某字符出现次数

写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

输入描述：

第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。

function getTimes(str, letter) {
  let upLetter = letter.toUpperCase();
  let times = 0;
  for (let i = 0; i < str.length; i++) {
    if (str.charAt(i).toUpperCase() === upLetter) {
      times++;
    }
  }
  return times;
}
print(getTimes(readline(), readline()));

3.明明的随机数

明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

const set = new Set()
const length = readline()
for (let i = 0; i < length; ++i) {
  set.add(readline())
}
const ary = Array.from(set)
ary.sort((a, b) => a - b)
ary.forEach(e=> {
    print(e)  
})

4.字符串分割

这道题一开始写了个for循环的，先按8倍数逐个打印，最后遇到有剩下的，再进行补足，不过做了更多的判断，代码行数也较多，没有下面这个解法优雅。

function printBy8(str){
    const extra = str.length % 8
    const fillNum = extra ? 8 - extra : 0
    const fullStr = str.concat(new String('0').repeat(fillNum))
    for(let i = 0; i < fullStr.length;) {
      print(fullStr.substring(i, i += 8))
    }
}
printBy8(readline())

5.进制转换

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

这道题考察js基础，parseInt有接收特定进制转十进制的作用，而toString能将十进制转为特定进制。

print(parseInt(readline(), 16))

6.质数因子

功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）

这道题首先要知道什么是质数因子，任何大于1的数都能被拆分成若干个质数的乘积，另外X的质数因子一定小于等于根号X，即质因子的范围是2到根号X。

另外还有个特殊情况，就是输入的这个数，本身就是质数，但还要排除1这个数。

function getPrimeFactors(num) {
  let i = 2, temp = num, result = []
  while(i <= temp && i * i <= temp) {
    while(num % i === 0) {
      result.push(i)
      num /= i
    }
    ++i
  }
  if(num != 1) {
    result.push(num)
  }
  return result.join(' ')
}

print(getPrimeFactors(readline()))

7.取近似值

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

基础题，调用Math.round()

print(Math.round(parseFloat(readline())))

8.合并表记录

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

这道题考数据解构，对象具有一一映射关系，而且对象的key如果是数字，它是默认从小到大排序的。

while ((line = readline())) {
  let container = {};
  for (let i = 0; i < parseInt(line); i++) {
    const [k, v] = readline().split(" ");
    container[k] = +v + (container[k] || 0);
  }
  for (let key in container) {
    print(key + " " + container[key]);
  }
}

9.提取不重复的整数

输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

保证输入的整数最后一位不是 0 。

这道题考数组和set数据接口的基本功

const result = new Set([...readline()].reverse())
print(Array.from(result).join(''))

10.字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次

例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。

这道题考数据解构基本功，当然也可以通过循环去读取，做判断，但没那么优雅。

const line = readline()
print(Array.from(new Set([...line])).length)

11.数字颠倒

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

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

因为readline读取的是字符串类型，所以，我的思路是从后往前读取字符串，拼接起来。

当然也有另一种思路，就是把它转为数组，然后reverse，再join，一顿操作。

const line = readline()
let result = ''
for(let i = line.length - 1; i > -1; i--) {
  result += line.charAt(i)
}
print(result)

12.字符串反转

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

这道题的思路同上一道题，解法也一样。

13.句子逆序

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”

所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

注意本题有多组输入

这道题就是考数组操作。

while(line = readline()){
    print(line.split(' ').reverse().join(' '))
}

14.字符串排序

给定 n 个字符串，请对 n 个字符串按照字典序排列。

这道题可以直接.sort()，但我使用了一个冒泡排序。需要注意的是，字符串是可以直接进行大小比较的，因为其底层也是数字。

const tempArr = []
let line = readline()
for(let i = 0; i < line; i++){
  tempArr.push(readline())
}
for(let i = 0; i < line; i++) {
    for(let j = i + 1; j < line; j++) {
      if(tempArr[i] > tempArr[j]) {
          let temp = tempArr[i]
          tempArr[i] = tempArr[j]
          tempArr[j] = temp
      }
    }
}
tempArr.forEach(e => {
    print(e)
})

16.购物单

题目有些长，点链接查看吧。

这道题没做出来，是看的题解。

刚开始是卡在了主件与附件的关系，我打算拆分开，如果购买附件满意度更高，那如何再去操作对比主件，后来看题解，它是把主附件的不同组合计算出来了，是统一在一起的。

动态规划这块，也不是把商品组合作为外循环，而是把金额作为外循环。假如我有10块，在所有商品中，哪个满意度最高。假如我有20块，循环到商品a，是“目前20块的满意度”高，还是“回退掉商品a的价格+商品a的满意度”更高。

const [n, m] = readline().split(' ').map(Number);
let obj = {};
for (let i = 1; i <= m; i++) {
    const [v, p, q] = readline().split(" ").map(Number);
    if (q === 0) { // 编号
        if (!obj[i]) {
            obj[i] = [[v, p]];
        } else {
          // 数组第一个是主件
            obj[i].unshift([v, p]);
        }
    }else {
        if (!obj[q]) {
            obj[q] = [];
        }
      // 附件推到数组的后面
        obj[q].push([v, p]);
    }
}
let dp = new Array(n + 1).fill(0);
// 计算出总钱数的所有10位数，并大到小排序
let arr = dp.map((e,ind)=>ind).filter((f, ind) => ind % 10 == 0).reverse();
Object.keys(obj).forEach(el => {
   // 价格 满意度
    let w = [], v = [];
    const [one, ...other] = obj[el];
    w.push(one[0]);
    v.push(one[0] * one[1]);
    if (other && other.length > 0) {
        const [l, r] = other;
        // 主 + 附1
        w.push(w[0] + l[0]);
        v.push(v[0] + l[0] * l[1]);
        if (r) {
           // 主 + 附2
            w.push(w[0] + r[0]);
            v.push(v[0] + r[0] * r[1]);
           // 主 + 附1+ 附2
            w.push(w[0] + l[0] + r[0]);
            v.push(v[0] + l[0] * l[1] + r[0] * r[1]);
        }
    }
    arr.forEach(els => {
        for(let s= 0; s < w.length; s++) {
            if (els - w[s] >= 0) {
                dp[els] = Math.max(dp[els], dp[els- w[s]] + v[s]);
            }
        }
    })
})
console.log(dp[n]);

17.坐标移动

除了需要对正则比较熟悉，其他部分不难。

const data = readline().split(';').filter(e=>/^(A|S|W|D)\d+$/.test(e))
const result = data.reduce((acc,cur) => {
  const d = cur.charAt(0)
  const n = Number(cur.slice(1))
  switch(d) {
    case "A": acc[0] -= n
      break;
    case "D": acc[0] += n
      break;
    case "W": acc[1] += n
      break;
    case "S": acc[1] -= n
      break;
  }
  return acc
},[0 , 0])
console.log(result)

20.密码验证合格程序

密码要求:

1.长度超过8位

2.包括大小写字母.数字.其它符号,以上四种至少三种

3.不能有长度大于2的包含公共元素的子串重复 （注：其他符号不含空格或换行）

这道题是中等难度的题，刚开始在第三个条件卡了下。感觉需要提高枚举的思想。

while(line = readline()){
  console.log(validate(line))
}

function validate(pwd) {
  let isPass = 'NG'
  let lenVali = checkLen(pwd)
  let typeVali = checkType(pwd)
  let repeatVali = checkRepeat(pwd)
  if(lenVali && typeVali && repeatVali) {
    isPass = 'OK'
  }
  return isPass
}
function checkLen(pwd) {
  return pwd.length > 8
}
function checkType(pwd) {
  let num = 0
  if(/\d/.test(pwd)) num++
  if(/[a-z]/.test(pwd)) num++
  if(/[A-Z]/.test(pwd)) num++
  if(/[^\da-zA-Z]/.test(pwd)) num++
  return num >= 3
}
function checkRepeat(pwd) {
  let isRepeat = false
  for(let i = 0; i < pwd.length; i++) {
    let str = pwd.substring(i, i + 3) 
    let index = pwd.indexOf(str, i + 3)
    if(index > -1) {
      isRepeat = true
      return !isRepeat
    }
  }
  return !isRepeat
}