蚂蚁金服笔试真题：如何防止重复请求？两数之和求解?

也许你我素未谋面，但很可能相见恨晚，我是前端胖头鱼

前言

胖头鱼最近在整理一些以往亲身经历的面试真题时，发现了两道很有意思的题目，来自蚂蚁金服某次在线笔试。如何防止重复发送请求？ 有没有发现平时的业务也会有类似的场景需要处理？看来蚂蚁还是将题目与实际业务结合了。两数之和，用减法做加法。

如何防止重复发送请求？

问题： 业务需求中，经常有只需要请求一次，以防止用户重复点击行为导致的触发重复请求。

传递请求方法（执行后返回promise），返回一个新方法。连续触发时，只执行一次。

// 示例
let count = 1;
let promiseFunction = () =>
  new Promise(rs =>
    window.setTimeout(() => {
      rs(count++);
    })
  );
let firstFn = firstPromise(promiseFunction);
firstFn().then(console.log); // 1
firstFn().then(console.log); // 1
firstFn().then(console.log); // 1

题目解析

题目的愿意是阻止重复发送请求，firstFn执行的回调复用这一个请求的结果，那么实现就很简单啦！可以将请求的实例先存储起来，而成功和失败内部都可以感知到，进而将其重新置空，接受下一次请求。

function firstPromise(promiseFunction) {
  let p = null;
  return function (...args) {
    // 请求的实例，已存在意味着正在请求中，直接返回实例，不触发新的请求
    return p
      ? p
      // 否则发送请求，且在finally时将p置空，那么下一次请求可以重新发起
      : (p = promiseFunction.apply(this, args).finally(() => (p = null)));
  };
}

测试一下

let count = 1;
let promiseFunction = () =>
  new Promise((rs) =>
    setTimeout(() => {
      rs(count++);
    }, 1000)
  );
let firstFn = firstPromise(promiseFunction);
firstFn().then(console.log); // 1
firstFn().then(console.log); // 1
firstFn().then(console.log); // 1

setTimeout(() => {
  firstFn().then(console.log); // 2
  firstFn().then(console.log); // 2
  firstFn().then(console.log); // 2
}, 3000);

可以看到虽然我们调用了firstFn6次，但是实际请求只发生了两次（因为count只由1变成了2），恭喜，蚂蚁的笔试题第一道你通过了。

两数之和

两数之和。一道leetCode原题，我当时想都没想就直接双层循环了事，结果可想而知，题目是解出来了，但明显不是面试官想要的...

来看看题目：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]
 

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？

"憨厚"直觉法

看到这个题目我心里窃喜，居然面这么简单的题目，😋嘿嘿。双层循环不就出来了么。

const twoSum = (nums, target) => {
  const len = nums.length
  for (let i = 0; i < len; i++) {
    // 同一个元素在答案里不能重复出现所以j = i + 1
    for (let j = i + 1; j < len ; j++) {
      // 找到答案，return
      if (nums[ i] + nums[ j ] === target) {
        return [ i, j ]
      }
    }
  }
}

万万没想到，居然通过了所有case...

憨厚直觉法有什么缺点呢？

进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？，题目的最后提醒我们有没有时间复杂度小于O(n^2)的算法，就是说还有更优解。

面试官看到这双层循环（时间复杂度为O(n^2)），印象肯定就不太好了，所以一旦实际面试中写出了双层，甚至是n层循环，一定要停住脚步，思考用空间换时间。

"Map"空间换时间法

以这道题为例，是可以用一次循环搞定的，只要将加法变成减法，把遍历过的值用一个对象sumCache存起来，遍历过程中看看sumCache是否存在当前值的差值，有直接返回即结束。

画个图一起试试看：

输入：[2,7,11,15]

第一步: 读取2, sumCache是空的，将2作为key，索引0作为值存入sumCache

第二步：读取7,发现目标值9 - 7 = 2，2存在于sumCache中，那么将0和1索引直接返回

是不是感觉map法很简单明了，比for循环爽多了

const twoSum = (nums, target) => {
  const len = nums.length
  const sumCache = {}

  for (let i = 0; i < len; i++) {
    const value = nums[ i ]
    // 计算差值
    const diff = target - value
    // 如果差值已经存在过，直接返回对应的索引
    if (typeof sumCache[ diff ] !== 'undefined') {
      return [ sumCache[ diff ], i ]
    } else {
      // 否则存起来
      sumCache[ value ] = i
    }
  }
}

空间换时间的方法，瞬间将时间减少近一半以上，稍微牺牲了一点空间，不过这一定是面试官更想看到的答案噢

结尾

希望能一直给大家分享实用、基础、进阶的知识点，一起早早下班，快乐摸鱼。

期待你在掘金关注我：前端胖头鱼，也可以在公众号里找到我：前端胖头鱼。