算法题

1、Promise的考察

// 假设本地机器无法做加减乘除运算，需要通过远程请求让服务端来实现。
// 以加法为例，现有远程API的模拟实现

const addRemote = async (a, b) => new Promise(resolve => {
  setTimeout(() => resolve(a + b), 1000)
});

// 请实现本地的add方法，调用addRemote，能最优的实现输入数字的加法。
async function add(...inputs) {
  // 你的实现
}

// 请用示例验证运行结果:
add(1, 2，3)
  .then(result => {
    console.log(result); // 6
});

方法一、使用递归

async function add(...args) {
  let res = 0;
  if (args.length === 0) return res;
  if (args.length === 1) return args[0];
  
  const a = args.pop();
  const b = args.pop();
  args.push(await addRemote(a, b));
  return add(...args);
}

方法二：使用reduce+Promise链式调用+递归

 async function add (...args){
      return args.reduce((promiseChain,cur)=>{
        console.log("promiseChain",promiseChain); // Promise对象
        return promiseChain.then(res=>{
          return addRemote(res,cur)
        })
      },Promise.resolve(0))
    }

方法三、递归+时间更少

 function add(...args){
      if(args.length<=1) return Promise.resolve(args[0])
      const promiseList = []
      for(let i =0; i*2<args.length-1;i++){
        const promise = addRemote(args[i*2],args[i*2+1])
        promiseList.push(promise)
      }
      if(args.length%2){
        promiseList.push(Promise.resolve(args[args.length-1]))
      }
      console.log(promiseList);  //Promise对象  第一次递归
       // 0: Promise {<fulfilled>: 3}
       // 1: Promise {<fulfilled>: 7}
       // 2: Promise {<fulfilled>: 5}
      return Promise.all(promiseList).then(res=>{
        console.log(res); //第一次递归[3,7,5]
        add(...res)
      })
    }

2、实现一个函数sum函数

sum(1, 2, 3).valueOf() // 6 
sum(2, 3)(2).valueOf() // 7 
sum(1)(2)(3)(4).valueOf() // 10
sum(2)(4, 1)(2).valueOf() // 9

分析：

1. sum函数可以传递一个或者多个参数

2. sum函数调用后返回的是一个新的函数且参数可传递一个或者多个

3. 调用.valueOf时完成最后计算

const sum=(...args)=>{
      // 声明add函数，其实主要是缓存参数的作用
     // 注意add调用完成还是会返回add函数本身，使其可以链式调用
          const add = (...args2)=>{
            args_ = [...args,...args2]
            return add
          }
          add.valueOf = ()=>args_.reduce((res,cur)=>res+cur,0)
          return add
        }
        console.log(sum(2,3)(4).valueOf())

 3、版本比较

compareVersion(arr) {
      arr.sort((a, b) => {
        let i = 0;
        const arr1 = a.split('.');
        const arr2 = b.split('.');
        debugger;
        while (true) {
          const s1 = arr1[i];
          const s2 = arr2[i++];
          if (s1 === undefined || s2 === undefined) {
            return arr2.length - arr1.length;
          }
          if (s1 === s2) continue;
          return s2 - s1;
        }
      });
    },

4、字符串组合

输入：['a','b','c']

输出：[’abc','acb','bac','bca','cab','cba']

stringGroup(list = [], result = [], current = '', temp = '') {
      current += temp;
      if (list.length === 0) {
        // 递归的出口，将对应结果添加到list中
        return result.push(current);
      }
      debugger;
      for (let i = 0; i < list.length; i++) {
        // 每次递归 固定第一个字符
        temp = list.shift();
        this.stringGroup(list, result, current, temp);
        // 将删除的temp重新添加到queue尾部，实现将数组反转的效果，如[a,b,c]反转为[c,b,a]
        list.push(temp);
      }
      // 这里去重是解决str中有重复的字母，比如str为'aacd'
      return [...new Set(result)];
    },

5、两数之和

输入：nums = [2,7,11,15], target = 9
输出：[0,1]

var twoSum = function(nums, target) {
    const map = new Map()
    for(let i=0;i<nums.length;i++){
        const targetNum  = target - nums[i]
        if(map.has(targetNum )){
            return [map.get(targetNum),i]
        }else{
            map.set(nums[i],i)
        }
    }
};

 6、二叉树最大深度

给定一个二叉树，找出其最大深度。给定二叉树 [3,9,20,null,null,15,7]

var maxDepth = function(root) {
    if(!root) return 0
    const left = maxDepth(root.left)
    const right = maxDepth(root.right)
    return Math.max(left,right)+1
};

 7、命名方式中划线改小驼峰

function transName(arr) {
    let res = arr.map(e => {
        let items = e.split('-').map((item, index) => {
            if (index) {
                let first = item.substring(0,1)
                let rest = item.substring(1)
                return first.toUpperCase()+rest
            }else{
                return item.toLowerCase()
            }
        })
        return items.join('')
    })
    return res
}

console.log(transName(['A-b-cee', 'ca-de-ea', 'e-fe-eaa','f-g','mn']))
//['aBCee', 'caDeEa', 'eFeEaa', 'fG', 'mn']