美团点评2020校招前端方向笔试题

1，i, s, a都在栈中，new出来的对象A在堆上。(考察js堆与栈：栈内存主要用于存储各种基本类型的变量，包括Boolean、Number、String、Undefined、Null以及对象变量的指针，堆主要存储object,所以字符串变量i,s以及对象指针a都存在栈中，new出来的对象开辟内存存在堆上，对应地址是指针a存的内容)
2，执行完成后a.i的值还是字符串op。(考察参数传递按值传递：a是A类的实例，所以a.i='op'，a.func(a.i)这句执行函数，把a.i作为参数传递，该函数会复制一个变量，两个变量完全独立，所以在函数体里只是把复制的那个变量（一个新的局部变量）改变为'op9’,在函数体外的a.i并没有被改变)

foo-foo2-global

var bar = new obj.foo(); // 由于new绑定的优先级大于bind绑定,所以函数内部this还是obj{}
console.log(bar.name); // foo
// 此时执行顺序是var bar3,bar2=bar,bar3=bar2, 所以bar3/bar2/bar都是指向同一个对象
var bar3 = bar2 = bar;
bar2.name = 'foo2';
// 所以bar2修改属性，bar3的也改变了，此时输出为'foo2'
console.log(bar3.name);
// 定时器任务，在最后放入任务队列，window对象没有被改变，所以输出 'global'
setTimeout(function() {
console.log(window.name);
}, 0);

b->f->c->a->d

// 定时器任务属于宏任务，并且需要先在任务队列等待，等到同步任务执行完，执行栈清空，才会在任务队列中按顺序选任务进去
setTimeout(() => console.log('a'));//4. 打印a
//Promise 属于异步微任务，在本轮同步任务结束之前执行
Promise.resolve().then(
// 1. 打印 b
() => console.log('b')  // 单引号要改为',然后去掉;号
).then(
// 箭头函数的resolve传递的参数作为下一个then的参数
() => Promise.resolve('c').then(
// 执行箭头函数
(data) => {
// 把定时器任务也放入任务队列中等待，在第一个定时器之后
setTimeout(() => console.log('d')); //5. 打印d
// 2.打印 f
console.log('f');
// 此时返回的 数据作为下一个then的参数
return data;
}
)
).then(data => console.log(data)); // 3.打印 c

 var Person = (function () {
     function Person (name) {
          this._name = name;
     }
     Person.prototype.greet = function () {
          console.log(“Hi, my name is “ + this._name);
     }
     Person.prototype.greetDelay = function (time) {
          var _this = this;
          setTimeout(function () {
               console.log(“Hi, my name is “ + _this.name);
          }, time);
     }
})();
    

var fib = function(N) {
    if(N==0)return 0;
    if(N==2||N==1)return 1;
    var prev=1,curr=1;
    for(var i=3;i<=N;i++){
        var sum=prev+curr;
        prev=curr;
        curr=sum;
    }
    return curr;
};

var coinChange = function(coins, amount) {
    coins.sort((a, b) => b - a);
    let res = amount + 1;

    let dfs = function(index, cur, cnt) {
        let coins_i = coins[index];
        if (cnt + Math.ceil(cur / coins_i) >= res) return;

        if (cur % coins_i == 0) {
            res = cnt + Math.floor(cur / coins_i);
            return ;
        } 

        if (index == coins.length - 1) return ;

        for (let i = Math.floor(cur / coins_i); i >= 0; i--) 
            dfs(index + 1, cur - coins_i * i, cnt + i);
    }

    dfs(0, amount, 0);
    return res > amount ? -1 : res;
}

var minPathSum = function (grid) {
    // 时间复杂度和空间复杂度都是 O (m * n);
    if (grid.length === 0) return 0;
    const dp = [];
    const rows = grid.length;
    const cols = grid[0].length;
    // 实际上你也可以无差别全部填充为MAX_VALUE，对结果没影响,代码还会更少
    // 只是有点不专业而已
    for (let i = 0; i < rows + 1; i++) {
        dp[i] = [];
        // 初始化第一列
        dp[i][0] = Number.MAX_VALUE;
        for (let j = 0; j < cols + 1; j++) {
            // 初始化第一行
            if (i === 0) {
                dp[i][j] = Number.MAX_VALUE;
            }
        }
    }

    // tricky
    dp[0][1] = 0;

    for (let i = 1; i < rows + 1; i++) {
        for (let j = 1; j < cols + 1; j++) {
            // state transition
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i - 1][j - 1];
        }
    }

    return dp[rows][cols];
};