js刷题ing--------2

PS:本文承接上一篇博客“js刷题ing--------1”.文章大体趋势为由易到难，若觉得前面的比较简单可从后面的看起

写一个 RecentCounter 类来计算特定时间范围内最近的请求。
请实现 RecentCounter 类：
RecentCounter() 初始化计数器，请求数为 0 。
int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
保证 每次对 ping 的调用都使用比之前更大的 t 值。

示例：
输入：
inputs = [“RecentCounter”, “ping”, “ping”, “ping”, “ping”]
inputs = [[], [1], [100], [3001], [3002]]
输出：[null, 1, 2, 3, 3]

解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3

var RecentCounter = function() {
   
    this.time = []
};

/** 
 * @param {number} t
 * @return {number}
 */
RecentCounter.prototype.ping = function(t) {
   
    this.time.push(t)
    while(this.time[0]<t-3000){
   
        this.time.shift()
    }
    return this.time.length
};

/**
 * Your RecentCounter object will be instantiated and called as such:
 * var obj = new RecentCounter()
 * var param_1 = obj.ping(t)
 */

给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。

/**
 * @param {number} x
 * @return {number}
 */
var mySqrt = function(x) {
   
    if(x === 0){
   
        return 0;
    }
    let left =0;
    let right = x;
    while(left <= right){
   
        let mid = Math.floor((left+right)/2);
        if(mid*mid === x){
   
            return mid;
        }else if(mid*mid < x){
   
            left = mid +1;
        }else{
   
            right = mid -1;
        }  
    }
    return right;
};
//Math.trunc()去除小数

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。
给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例 1：
输入：words = [“hello”,“leetcode”], order = “hlabcdefgijkmnopqrstuvwxyz”
输出：true
解释：在该语言的字母表中，‘h’ 位于 ‘l’ 之前，所以单词序列是按字典序排列的。

示例 2：
输入：words = [“word”,“world”,“row”], order = “worldabcefghijkmnpqstuvxyz”
输出：false
解释：在该语言的字母表中，‘d’ 位于 ‘l’ 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：
输入：words = [“apple”,“app”], order = “abcdefghijklmnopqrstuvwxyz”
输出：false
解释：当前三个字符 “app” 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 “apple” > “app”，因为 ‘l’ > ‘∅’，其中 ‘∅’ 是空白字符，定义为比任何其他字符都小（更多信息）。

/*
先利用题目给的字母表顺序 orderorder 结合ASCII值，将 wordswords 里的每一个外星语翻译成编程语言可判断的字符串，
所谓的翻译就是从hlabcdefgijkmnopqrstuvwxyz到abcdefghigklmnopqrstuvwxyz的映射，之后判断字符串大小即可。
*/
/**
 * @param {string[]} words
 * @param {string} order
 * @return {boolean}
 */
var isAlienSorted = function(words, order) {
   
    const dict = {
   }
    for(let i = 0; i < order.length; i++) dict[order[i]] = i
    words = words.map((word) => {
   
        return word.split('').reduce((res, w) => {
   
            return res + String.fromCharCode(97 + dict[w])
        }, '')
    })
    for(let i = 1; i < words.length; i++){
   
        if(words[i] < words[i - 1]) return false
    }
    return true
};
//字符串的比较为unicode编码的比较

给定两个数组，arr1 和 arr2，
arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例：
输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

var relativeSortArray = function(arr1, arr2) {
   
    	var obj = {
   }
	for(let i = 0; i<arr2.length; i++){
   
		obj[arr2[i]] = i
	}
	arr1 = arr1.sort((a,b)=>{
   
		if(obj[a] === undefined) obj[a]=arr2.length+a;
		if(obj[b] === undefined) obj[b]=arr2.length + b;
		return obj[a] - obj[b]
	})
	return arr1
};

将函数 fn 的执行上下文改为 obj 对象
输入：function () {return this.greeting + ', ’ + this.name + ‘!!!’;}, {greeting: ‘Hello’, name: ‘Rebecca’}
输出：Hello, Rebecca!!!

关于call、apply、bind的用法可参考这位大神写的

实现函数 functionFunction，调用之后满足如下条件：
1、返回值为一个函数 f
2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', ’
3、所有函数的参数数量为 1，且均为 String 类型
输入：functionFunction(‘Hello’)(‘world’)
输出：Hello, world

// 一个闭包完美解决
function functionFunction(str) {
   
    return f = function(arr){
   
        return str+", "+arr;
    };
     
}

实现函数 callIt，调用之后满足如下条件
1、返回的结果为调用 fn 之后的结果
2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {
   
   let r = [...arguments];
   let s = r.slice(1);
    return fn.apply(null,s);
}

二次封装函数：
实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
   
    var r=[...arguments]
    var s=r.slice(1)
    return result=function(){
   
        return fn.apply(this,s.concat([...arguments]))
    }
}

获取数字 num 二进制形式第 bit 位的值。注意：
1、bit 从 1 开始
2、返回 0 或 1
3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

function valueAtBit(num, bit) {
   
    if(bit < 1) return 
    let arr= num.toString(2).split('').reverse()
    return arr[bit-1]
}

给定二进制字符串，将其换算成对应的十进制数字

function base10(str) {
   
    return parseInt(str,2)
}

将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。

function convertToBinary(num) {
   
    let res=num.toString(2);
   return res.length<8?new Array(8-res.length).fill(0).join('')+res:res;
}

实现函数 makeClosures，调用之后满足如下条件：
1、返回一个函数数组 result，长度与 arr 相同
2、运行 result 中第 i 个函数，即 resulti，结果与 fn(arr[i]) 相同
示例：
var arr = [1,2,3];
var fn = function (x) {
return x * x;
}
var result = makeClosures(arr,fn);
(result1 === 4) === (fn(arr[1]) === 4) === true

function makeClosures(arr