9.14 米哈游前端笔试

一题没a。。。今天真的不怎么怎么回事了，笔试完心态崩了。

1. 快乐值，给一个数组，随意摆放数组内元素位置，如果相邻元素的平均值是非整数，则快乐值+1 问怎么摆快乐值最大
   输入：[112,111,114,116] 输出:[112,111,114,116] 共有2快乐值 <112,111> <111,114>
   思路：统计奇数跟偶数，判断哪个比较少，把少的插入到大的直接，再返回总的数组。(还是不知道哪里错了，答案说可以输出任意答案的。 脑子坏了 要输出字符串带空格，愣是没看见)(代码已修正)

   var findFun = function (nums) { 
    // 统计偶数跟奇数
    let odd = [] // ji
    let even = [] // ou
    let res = []
    for(let i=0;i<nums.length;i++){
        if(nums[i]%2==0){
            // 偶数
            even.push(nums[i])
        }else{
            odd.push(nums[i])
        }
    }
    let minNum = odd.length<even.length?true:false // false是奇数个数多
    if(minNum){
        // 奇数少
        while(odd.length>0){
            res.push(even.shift())
            res.push(odd.shift())
        }
        res = res.concat(even)
    }else{
        while(even.length>0){
            res.push(odd.shift())
            res.push(even.shift())
        }
   
        res = res.concat(odd)
    }
    return res.join(" ")
   }

2. 最长连续子串。给一个字符串，找出里面包含k个'mihoyo'字符串的最短字符串
   输入:"mihoyoyomihoyomimihoyo",2 输出:0 13或者8 22
   我的思路：暴力解直接开撕，结果只过了41%

   var subMihoyo = function (strs,k) { 
    let res = []
    // 处理这个子串
    function isMihoyo(substrs,knum){
        // 遍历
        let path = 0
        for(let i=0;i<substrs.length-5;i++){
            if(substrs[i]=='m'&&substrs[i+1]=='i'&&substrs[i+2]=='h'&&substrs[i+3]=='o'&&substrs[i+4]=='y'&&substrs[i+5]=='o'){
                path+=1
                i+=5
            }
        }
        if(path==knum){
            return true
        }
        return false
    }
    let i,j
    let n=0
    for(i=0;i<=strs.length-k*6;i++){
        j=k*6+i
        while(j<strs.length){
            // i应该什么时候移动？
            let substr = Array.from(strs).slice(i,j)
            if(isMihoyo(substr,k)){
                res.push([i,j-1])
                break
            }
            j++
        }
    }
    if(res.length>0){
        res.sort((a,b)=>(a[1]-a[0])-(b[1]-b[0]))
        return res[0].join(" ")
    }else{
        return -1
    }
   }

3. 递增序列，给一个数组，让里面元素严格增加。每次操作可以让第i个元素*2（翻倍）。最少需要多少次操作
   输入：[1,2,2,2] 输出：3
   思路：照样暴力，从序号1的元素开始翻倍呗。 果然超时了 16%

   var uptoSum = function(nums){
    // nums = [2,3,2,3,2]
    // 从第一个往后
    let res = 0
    for(let i=1;i<nums.length;i++){
        let pre = 0 
        if(nums[i]>nums[i-1]){
            continue
        }else{
            // 当前数字小于前面的数
            let temp = nums[i-1]
            let path = 0
            while(nums[i]<=temp){
                temp=temp/2
                path++
            }
            nums[i] = nums[i]*(2**path)
            res+=path
        }
    }
    return res
   }

   到这里做完，心态小崩，有点不想去思考其他思路了 T^T