2021年秋招遇到的前端笔试/面试题

**

本文仅用于记录本人2021年秋招遇到的部分前端笔试/面试题，答案仅供参考

**

1、跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

//贪心算法
function Jump(nums) {
   
	// 首位重合，必定能达到
    if (nums.length < 2) {
   
        return true
    }
    //pos记录每个位置（数组每个下标）所能达到的最大位置，即当前索引 + 当前值（此处省略了+0）
    let pos = nums[0]
    //遍历剩下的数组，当最大位置大于等于数组长度时，即可以到达最后，
    //反之若在遍历过程中，目前能到达的最大位置小于当前索引值，说明无法到达当前索引位置，故也不能到达数组尾
    for (let i = 1; i < nums.length; ++i) {
   
        if (pos >= i) {
   
            pos = Math.max(pos, i + nums[i])
        }
        if(pos < i) return false;
        if (pos >= nums.length - 1) {
   
            return true
        }
    }
    return false
};

2、岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。（如果1 的上下左右都为0，则视为一个岛屿，写出一个函数，计算数组中岛屿的个数。）

示例 1:
输入:
[
[1,1,1,1,0],
[1,1,0,1,0],
[1,1,0,0,0],
[0,0,0,0,0]
]
输出: 1

示例 2:
输入:
[
[1,1,0,0,0],
[1,1,0,0,0],
[0,0,1,0,0],
[0,0,0,1,1]
]
输出: 3

// 时间复杂度：O(MN)，其中 M 和 N 分别为行数和列数。
// 空间复杂度：O(MN)，在最坏情况下，整个网格均为陆地，深度优先搜索的深度达到 MN。
var numIslands0_1 = function(grid) {
   
    let count = 0
    for(let i = 0; i < grid.length; i++){
   
        for(let j = 0; j < grid[0].length; j++){
   
            if(grid[i][j] === "1"){
   
                grid[i][j] = "0"
                dfsVisit(i, j)
                count++
            }
        }
    }

    function dfsVisit(r, c){
   
        let dir = [[0,-1], [0,1], [-1,0], [1,0]] // 上下左右
        for(let k = 0; k < 4; k++){
   
            let row = r + dir[k][0],
                col = c + dir[k][1];
            if(row < 0 || row >= grid.length || col < 0 || col >= grid[0].length) continue
            if(grid[row][col] === "1"){
   
                grid[row][col] = "0"
                dfsVisit(row, col)
            }else{
   
                continue
            }
        }
    }
    return count
};

3、主流浏览器引擎前缀:

-webkit- ：（谷歌，Safari，新版Opera浏览器，以及几乎所有iOS系统中的浏览器（包括 iOS 系统中的火狐浏览器）；基本上所有基于WebKit 内核的浏览器）
-moz- ：（火狐浏览器）
-o- ：（旧版Opera浏览器）
-ms- ：（IE浏览器 和 Edge浏览器）
示例:

-webkit-transition: all 4s ease;
-moz-transition: all 4s ease;
-ms-transition: all 4s ease;
-o-transition: all 4s ease;
transition: all 4s ease; 

4、parseInt(“8X8”)+parseFloat(“8”)=16

5、Number(null)=0

6、不知为啥

obj={
   };
obj.log=console.log;
obj.log.call(console,this)//输出为window

7、对递归程序的优化的一般的手段为（A）

A 尾递归优化
B 循环优化
C 堆栈优化
D 停止值优化

8、在位运算中，操作数每右移一位，其结果相当于除以2 ，若左移1位，其结果相当于乘以2

9、找上中位数

给定两个有序数组arr1和arr2，已知两个数组的长度都为N，求两个数组中所有数的上中位数。上中位数：假设递增序列长度为n，若n为奇数，则上中位数为第n/2+1个数；否则为第n/2个数
输入为：arr1 = [1, 2, 3, 4], arr2 = [3, 4, 5, 6]，输出为3
输入为：arr1 = [0, 1, 2], arr2 = [3, 4, 5]，输出为2

function solve(arr1,arr2){
   
    var arr = arr1.concat(arr2)
    arr = arr.sort((a,b)=>{
   return a-b}) // 数组升序
    arr = dedupe(arr) // 数组去重
    var len = arr.length
    if(len==1) return arr[0] // 若长度只有一个则为本身
    else {
   
        var index = Math.ceil(len/2) // 无论奇数偶数个，向上取整
        return arr[index-1]
    }
}
// 数组去重函数
function dedupe(arr){
   
    return Array.from(new Set(arr))
}

10、给定一个数组由一些非负整数组成，现需要将他们进行排列并拼接，使得最后的结果最大，返回值需要是string类型，否则可能会溢出（每个数不可拆分）