JS算法练习 11.20

leetcode 2629 复合函数

请你编写一个函数，它接收一个函数数组 [f1, f2, f3，…， fn] ，并返回一个新的函数 fn ，它是函数数组的 复合函数 。

[f(x)， g(x)， h(x)] 的 复合函数 为 fn(x) = f(g(h(x))) 。

一个空函数列表的 复合函数 是 恒等函数 f(x) = x 。

你可以假设数组中的每个函数接受一个整型参数作为输入，并返回一个整型作为输出。

示例 1：

输入：functions = [x => x + 1, x => x * x, x => 2 * x], x = 4
输出：65
解释：
从右向左计算......
Starting with x = 4.
2 * (4) = 8
(8) * (8) = 64
(64) + 1 = 65

示例 2：

输出：functions = [x => 10 * x, x => 10 * x, x => 10 * x], x = 1
输入：1000
解释：
从右向左计算......
10 * (1) = 10
10 * (10) = 100
10 * (100) = 1000

var compose = function(functions) {
    
	return function(x) {
        let re = x
        for(let i = functions.length - 1; i >= 0; i--){
            let func = functions[i]
            re = func(re)
        }
        return re
    }
};

 leetcode 2631 分组

请你编写一段可应用于所有数组的代码，使任何数组调用 array. groupBy(fn) 方法时，它返回对该数组 分组后 的结果。

数组 分组 是一个对象，其中的每个键都是 fn(arr[i]) 的输出的一个数组，该数组中含有原数组中具有该键的所有项。

提供的回调函数 fn 将接受数组中的项并返回一个字符串类型的键。

每个值列表的顺序应该与元素在数组中出现的顺序相同。任何顺序的键都是可以接受的。

请在不使用 lodash 的 _.groupBy 函数的前提下解决这个问题。

示例 1：

输入：
array = [
  {"id":"1"},
  {"id":"1"},
  {"id":"2"}
], 
fn = function (item) { 
  return item.id; 
}
输出：
{ 
  "1": [{"id": "1"}, {"id": "1"}],   
  "2": [{"id": "2"}] 
}
解释：
输出来自函数 array.groupBy(fn)。
分组选择方法是从数组中的每个项中获取 "id" 。
有两个 "id" 为 1 的对象。所以将这两个对象都放在第一个数组中。
有一个 "id" 为 2 的对象。所以该对象被放到第二个数组中。

示例 2：

输入：
array = [
  [1, 2, 3],
  [1, 3, 5],
  [1, 5, 9]
]
fn = function (list) { 
  return String(list[0]); 
}
输出：
{ 
  "1": [[1, 2, 3], [1, 3, 5], [1, 5, 9]] 
}
解释：
数组可以是任何类型的。在本例中，分组选择方法是将键定义为数组中的第一个元素。
所有数组的第一个元素都是1，所以它们被组合在一起。
{
  "1": [[1, 2, 3], [1, 3, 5], [1, 5, 9]]
}

 超时了：

Array.prototype.groupBy = function(fn) {
    let dict = {}
    for(let i = 0; i < this.length; i++){
        if(fn(this[i]) in dict){
            let arr = dict[fn(this[i])]
            dict[fn(this[i])] = [...arr, this[i]]
        }else{
            dict[fn(this[i])] = [this[i]]
        }
    }
    return dict
};

题解只是没有解构数组，原来解构效率这么低吗

Array.prototype.groupBy = function(fn) {
    let dict = {}
    for(let i = 0; i < this.length; i++){
        let key = fn(this[i])
        if(key in dict){
            dict[key].push(this[i])
        }else{
            dict[key] = [this[i]]
        }
    }
    return dict
};

leetcode 2634 过滤数组中的元素

给定一个整数数组 arr 和一个过滤函数 fn，并返回一个过滤后的数组 filteredArr 。

fn 函数接受一个或两个参数：

• arr[i] - arr 中的数字
• i - arr[i] 的索引

filteredArr 应该只包含使表达式 fn(arr[i], i) 的值为 真值 的 arr 中的元素。真值 是指 Boolean(value) 返回参数为 true 的值。

请在不使用内置的 Array.filter 方法的情况下解决该问题。

示例 1：

输入：arr = [0,10,20,30], fn = function greaterThan10(n) { return n > 10; }
输出： [20,30]
解释：
const newArray = filter(arr, fn); // [20, 30]
过滤函数过滤掉不大于 10 的值

示例 2：

输入：arr = [1,2,3], fn = function firstIndex(n, i) { return i === 0; }
输出：[1]
解释：
过滤函数 fn 也可以接受每个元素的索引
在这种情况下，过滤函数删除索引不为 0 的元素

太简单了，下一个 

var filter = function(arr, fn) {
    let filterArr = []
    for(let i = 0; i < arr.length; i++){
        let re = fn(arr[i], i)
        if(re){
            filterArr.push(arr[i])
        }
    }
    return filterArr
};

 leetcode 2635 转换数组中每个元素

编写一个函数，这个函数接收一个整数数组 arr 和一个映射函数  fn ，通过该映射函数返回一个新的数组。

返回数组的创建语句应为 returnedArray[i] = fn(arr[i], i) 。

请你在不使用内置方法 Array.map 的前提下解决这个问题。

示例 1:

输入：arr = [1,2,3], fn = function plusone(n) { return n + 1; }
输出：[2,3,4]
解释： 
const newArray = map(arr, plusone); // [2,3,4]
此映射函数返回值是将数组中每个元素的值加 1。

示例 2:

输入：arr = [1,2,3], fn = function plusI(n, i) { return n + i; }
输出：[1,3,5]
解释：此映射函数返回值根据输入数组索引增加每个值。

和上一题差不多

var map = function(arr, fn) {
    let mapArr = []
    for(let i = 0; i < arr.length; i ++){
        let re = fn(arr[i], i)
        mapArr.push(re)
    }
    return mapArr
};