小红书前端面试知识

ゝ一世哀愁。 2022-12-02 04:09 366阅读 0赞

**1**.使用Object.assign(obj1, obj2)可以实现对象的浅拷贝。  
**for…in 循环**只能遍历对象上的可枚举属性。  
**2.结果返回 true 的是（）**

> null == undefined  
> null === null

**3**.对于一些保密性较高的cookie后端可以通过设置HttpOnly标记，cookie只能通过http传递，前端js无法读取。  
**JSONP**用的是html的script标签，xmlhttprequest是浏览器内置的HTTP相关对象，两者不同。  
**同源策略**是浏览器的安全策略、  
**localStorage API** 不支持设置过期时间。

**4.requestAnimationFrame(foo)** 确保使浏览器在下一次重绘之前调用 foo 方法。

把<script>标签的引入放在文档末尾可以确保脚本下载和执行均在文档解析完成后发生。
    
    多个 <script> 标签使用 defer 属性引入脚本时，可以确保脚本的执行是按照其被引入的顺序的。

**5**.**JavaScript 严格模式下有哪些不同？**

> 1.  **this不再强制封装为一个对象**，若没有指定this的话则是undefined。
> 2.  给一个**未声明的变量赋值会触发ReferenceError错误**，而不再自动声明为全局变量。
> 3.  给对象的不可写属性或只读属性赋值、给不可拓展的对象新属性赋值、试图删除对象中不可删除的属性会**抛出TypeError错误**，而不再静默失败。
> 4.  **对象属性重名**，函数参数重名均为语法错误。
> 5.  **无法使用以0开头**的八进制表示数字的语法。
> 6.  为原始值设置属性将抛出**TypeError错误**。
> 7.  **禁用with语法**。
> 8.  **禁止删除声明**的变量.
> 9.  函数中**arguments对象**的属性值与函数参数值不再同步改变。
> 10. 增加了一些**保留字**无法被作为变量名或形参名使用。

**6**.**样式文件的加载**会阻塞脚本的执行。  
**iframe** 会阻塞主页面的 load 事件。  
**页面文档完全加载**并解析完毕之后会触发DOMContentLoaded 事件。  
**7.ajax 的 readyState 有哪几个状态，含义分别是什么？**  
5 个状态，分别是 0-4

0: 还没调用open方法 
    1: 未调用send方法，也就是还没发送数据给服务器
    2: 还没有接收到响应 
    3: 开始接收到了部分数据
    4: 接收完成，数据可以在客户端使用了

**8**.薯队长带着小红薯参加密室逃脱团建游戏，首先遇到了反转游戏，小红薯们根据游戏提示收集了多个单词线索，并将单词按要求加一个空格组 成了句子，最终要求把句子按单词反转解密。  
**说明**：收集的时候单词前后可能会有多个空格，反转后单词不能有多个空格，具体见输入输出样例。

> **输入描述:** 输入一个字符串。包含空格和可见字符。  
> 长度<=100000。  
> **输出描述:** 输出一个字符串，表示反转后结果。  
> **示例1**  
> 输入 the sky is blue!  
> 输出 blue! is sky the  
> **备注:** 输出一个字符串，表示反转后结果。

import sys
    s = [i for i in sys.stdin.readline().split()]
    for i in range(len(s)-1, -1, -1):
        print(s[i], end=' ')

**9**.  
薯队长写了n篇笔记，编号从1~n,每篇笔记都获得了不少点赞数。  
薯队长想从中选出一些笔记，作一个精选集合。挑选的时候有两个规则：  
1.不能出现连续编号的笔记。  
2.总点赞总数最多 。  
如果满足1，2条件有多种方案，挑选笔记总数最少的那种、

> **输入描述:** 输入包含两行。  
> 第一行整数n表示多少篇笔记。  
> 第二行n个整数分别表示n篇笔记的获得的点赞数。 （0<n<=1000, 0<=点赞数<=1000)  
> **输出描述:**  
> 输出两个整数x,y。空格分割。 x表示总点赞数，y表示挑选的笔记总数。  
> **示例1**  
> 输入 4 1 2 3 1  
> 输出 4 2

def getMaxStar(n,nums):
        dp = [0 for _ in range(n+1)]
        dp2 = [0 for _ in range(n+1)]
        dp[1] = nums[0]
        dp2[1] = 1
        for i in range(2,n+1):
            if dp[i-1] < dp[i-2]+nums[i-1]:
                dp[i] = dp[i-2]+nums[i-1]
                dp2[i] = dp2[i-2]+1
            else:
                dp[i] = dp[i-1]
                dp2[i] = dp2[i-1]
        print(dp[-1], dp2[-1])
        
    n = eval(input())
    nums = [int(i) for i in input().split()]
    getMaxStar(n, nums)

**10**.薯队长来到了迷宫的尽头，面前出现了N只魔物，Hi表示第i只魔物的血量，薯队长需要在T个回合内击败所有魔物才能获胜。  
每个回合薯队长可 以选择物理攻击一只魔物，对其造成1点伤害（物理攻击次数无上限）; 或者消耗1点法力释放必杀技对其造成固定X点伤害（薯队长开始拥有M 点法力）。  
问X至少多大，薯队长才有机会获胜；如果无论如何都无法在T回合内获胜，则输出-1 。

> **输入描述:** 第一行三个整数分别表示：N，T，M  
> 第二行有N个整数：H1，H2，H3…HN  
> **输出描述:** 输出一个整数，表示必杀技一次最少造成多少固定伤害  
> **示例1**  
> 输入 3 4 3 5 2 1  
> 输出 3  
> **备注:**  
> 对于50%的数据： 0<N<10^3 0<T<10^3 0<=M<=T 0<Hi<10^4  
> 对于100%的数据 0<N<10^5 0<T<10^5 0<=M<=T 0<Hi<10^7

**考察点**：二分搜索、贪心  
**思路**：沿着\[0,max\_hp\]的范围搜索最合适的伤害值，注意对一些特殊情形的处理。  
使用函数check\_valid判断当前技能伤害能否过关。  
首先是根据法力值的大小先对整体的怪物进行伤害，只求打满最大的伤害而不去补刀。  
之后根据剩余的血量重排序，此时：  
如果没有了法力值，则只需要判断血量和是不是大约剩余轮数。  
如果剩余法力值，则根据重排序的结果，优先清掉血量高的怪物，之后再判断剩余的轮数够不够清掉所有的怪物。

def check_valid(num, turn, magic, hps, damage):
        # 使用技能造成伤害但不补刀，最后剩下法力值的时候在进行补刀
        i = 0
        for i in range(num):
            # 释放技能的次数为整除的次数或者是魔力值的次数，取小的那个
    
            spell_time = min(hps[i] // damage, magic)
            hps[i] -= spell_time * damage
            turn -= spell_time
            magic -= spell_time
            if magic == 0: break
        # 去除刚好整除的值
    
        hps = sorted(hps)
        i = 0
        if hps[-1] == 0:return True
        while hps[i] == 0:
            i += 1
        hps = hps[i:]
        # 普攻或者技能能够清掉
    
        if sum(hps) <= turn : return True
        if len(hps) <= magic:
            return True
    
        # 还剩余法力值，此时怪物的血量必定都小于技能伤害，按血量从高到低使用技能
    
        else:
            last = len(hps) - 1
            while magic > 0:
                last -= 1
                magic -= 1
                turn -= 1
            # 无法力值，判断能否用普攻清完
    
            hps = hps[:last+1]
            return turn >= sum(hps)
    
    
    def main():
        num, turn, magic = list(map(int, input().split()))
        hps = list(map(int, input().split()))
    
        #回合不够必定输
    
        if len(hps) > turn: return -1
    
        # 法力值为零且血量和大于回合数 必定输
        if magic == 0 and sum(hps) > turn: return -1
    
        left, right = 0, int(max(hps))
        while left < right:
            mid = (left + right) // 2
            # 注意python浅拷贝的坑
    
            if check_valid(num, turn, magic, hps.copy(), damage=mid):
                right = mid
            else:
                left = mid+1
        # 如果left = max(hps)，同样是不存在伤害值满足条件，left一直右移直到越界
    
        return left if left < max(hps) else -1
    
    print(main())

java100%case通过代码如下：

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner in = new Scanner(System.in);
            int n = in.nextInt();
            int t = in.nextInt();
            int m = in.nextInt();
            Integer[] h = new Integer[n];
            int maxH=0,totalH=0;
            //获取怪物血量输入，顺便找出最大怪物血量，顺便计算怪物总血量。
            for (int i=0;i<h.length;i++){
                int s = in.nextInt();
                h[i] = s;
                maxH=Math.max(maxH,s);
                totalH+=s;
            }
            //如果怪物总血量小于回合数，说明平A就能解决所有怪物，所以必杀技伤害为最低0
            if(totalH<=t){
                System.out.println(0);
                return;
            }
            //把怪物的血量从大到小排序
            Arrays.sort(h,Collections.reverseOrder());
            /*从2到最大怪兽血量maxH，进行升序循环判断，找到第一个伤害就是，最低必杀技伤害
            Q:为什么从2开始？A:因为普工伤害为1，必杀技小于等于普工伤害时，都使用普工解决就可以
            */
            for (int i=2;i<=maxH;i++){
                //判断该必杀技伤害是否能够通关
                if(dfs(h,t,m,i,totalH)){
                    System.out.println(i);
                    return;
                }
            }
            System.out.println(-1);
        }
        public static boolean dfs(Integer[] h,int t,int m,int x,int totalH){
            //判断回合数是否大于蓝量
            if(t>m){
                //看所有蓝量用完后再在回合内使用普工时，所能造成的总血量是否大于怪物总血量，如果不行，则无法通关
                if(t-m+m*x>=totalH){
                    /**
                    怪物血量大于必杀技伤害的，每一个都使用必杀技，确保必杀技伤害不溢出。
                    **/
                    Integer[] ht = Arrays.copyOf(h,h.length);
                    int j=0;
                    for(int i=0;i<h.length&&m>0&&h[i]>=x;i++){
                        int st = h[i]/x;
                        int sx = h[i]%x;
                        if(st<=m){
                            ht[i] = sx;
                            totalH -= st*x;
                            m-=st;
                            t-=st;
                        }else{
                            ht[i] -= m*x;
                            totalH -= m*x;
                            m=0;
                            t-=m;
                        }
                    }
                    //如果必杀技使用完毕，则只能进行平砍，判断怪物总剩余血量是否小于等于剩余回合数就行
                    if(m==0){
                        return totalH<=t-m;
                    }else {
                        //如果必杀技未使用完毕，则直接对剩余血量最多的怪再次使用必杀技，确保必杀技利益最大化。
                        //怪物剩余血量再排序
                        Arrays.sort(ht, Collections.reverseOrder());
                        //由于java最后10%的案例超时，所以判断了一下剩余蓝量是否大于怪物数量的一半
                        if(m>ht.length/2){
                            //如果超过一半，则只需计算另外一半未死的怪物血量就是剩余怪物总血量
                            totalH = 0;
                            for (int i = m; i < ht.length; i++) {
                                totalH += ht[i];
                            }
                        }else {
                            //如果没有超过一半，则每一只怪死掉后，总血量减去该怪物的剩余血量就行
                            for (int i = 0; i < m; i++) {
                                totalH -= ht[i];
                            }
                        }
                        //通过以上步骤算出怪物剩余总血量，如果小于使用全部技能后的回合数，就能平A通关了，如果不行则不能进行通关操作
                        return totalH <= t - m;
                    }
                }else{
                    return false;
                }
            }else{
                //如果回合数小于等于蓝量，则全程使用必杀技，看是否通关。
                //直接回合数*必杀技看是否大于怪物总血量
                return t*x>=totalH;
            }
        }
    }