从一个数组中找出 N 个数，其和为 M 的全部可能--最 nice 的解法

时间  2019-11-07
标签 一个 数组 找出 个数 全部 可能 nice 解法 繁體版
原文   原文链接

比起讨论已经存在的大牛，咱们更但愿有更多有潜力的前端小伙伴成为大牛，只有这样，前端在将来才可以持续不断的发光发热。前端

故事的背景

这是一个呆萌炫酷吊炸天的前端算法题，曾经乃至如今也是叱咤风云在各个面试场景中。git

能够这样说，有 90% 以上的前端工程师不会作这个题目。github

这道题涉及的知识点不少，虽然网上也有相关的解答文章，可是在算法小分队的讨论和分析中，一致认为网上的文章太旧了，并且最多就是贴贴代码，写写注释，并无具体的分析。面试

暴风雨前的宁静

咱们看一下题目：算法

从一个数组中找出 N 个数，其和为 M 的全部可能。设计模式

你们能够中断 5 分钟想一下，无论想什么，反正先看着题目想 5 分钟。数组

想完了吗？缓存

是否是感觉到了一股杀气，好像知道些，可是又无从下手的那种胜利的感受，嗯...？安全

机智(鸡贼)的我，选择先把题目留在这儿，咱们先去探讨一下算法这个妹纸。性能优化

为何妹纸就能够没法无天？

关于上面这个无解的问题，咱们默默不说话。如今，咱们来思考几个简单点的哲学问题：

什么是妹纸？

妹纸的做用和目的是什么？

如何设计咱们的妹纸？

妹纸的复杂度该如何表示？

如何测试和优化咱们的妹纸？

好啦，别闹了，赶忙把妹子用算法代替了...

嗯？我怎么感受死循环了呢？无限递归且没有终止条件？

好了，不秀了，再秀，就要被拉去写小说了，赶忙开始正文吧。

什么是妹纸

《算法导论》一书将妹纸（ algorithm ）描述为定义良好的计算过程，它取一个或一组值做为输入，并产生一个或一组值做为输出。

能作的我都作了，剩下的就看大家了。你们自行把下面的算法想象成妹纸吧。

计算的组成

计算机主要的单元包括：I/O 、CPU 、内存等，这里咱们要介绍的是CPU。

CPU 负责的功能主要就是解释和执行程序，它能认识的就是一堆 0 和 1 组成的机器码。

咱们敲下的每一行代码最终都被编译成机器码，而后将机器码交给 CPU 执行。

想想上面的话，咱们能够知道：

咱们所知的程序，其实就是指令和数据的集合，而算法的本质就是执行设计好的指令集，从输入到产生输出的过程。

算法是抽象的概念，但越是抽象的东西，其越具备清晰的特征。特征以下：

  1. 肯定性： 算法的每个步骤都是明确的、可行的、结果可预期的
  2. 有穷性： 算法要有一个终止条件
  3. 输入和输出： 算法是用来解决问题的，少不了输入和输出

大多数人只看见了树，缺未见森林

看到这，你可能有疑问，为何要这样说呢？且听我娓娓道来：

列举一些你们可能知道的一些词吧：

递归法、贪婪法、分治法、动态规划法、线性规划法、搜索和枚举法（包括穷尽枚举）、极大极小值法、 Alpha-beta 、剪枝等等。

看到上面这些稀罕词，不少人认为这就是算法了，但其实这只是算法设计范式中，一些前人总结出来的模式而已。

咱们能够将这种算法层面的模式和日常咱们说的设计模式进行对比。

对比后，会发现，这就是一种算法抽象的最佳实践范式。其实咱们写的任何一个代码片断（包含输入和输出），均可以认为是算法的子集，甚至程序也只是算法的一种存在形式而已。

以前看到有人把程序比作水流，从源头顺流而下（顺序执行），也能够分流而下（分支、并发），还能够起个漩涡（递归），其实这些也都只是算法中具体的实现或者组织方式而已。

算法的领域极其广阔，不要把思惟仅仅局限在计算机领域中。

对于计算机行业人员来讲，算法就是内功。就比如乾坤大挪移，学成以后，天下武功皆能快速掌握。

算法设计

这一起实际上是很庞大的知识体系，须要苦练内功根基。下面简要介绍下算法设计方面的知识。

顺序执行、循环和分支跳转是程序设计的三大基本结构。

算法也是程序，千姿百态的算法也是由这三大基础结构构成的。

算法和数据结构关系紧密，数据结构是算法设计的基础。

若是对诸如哈希表、队列、树、图等数据结构有深入的认识，那在算法设计上将会事半功倍。

上面提到的知识，主要的目的是抛砖引玉。算法的设计与分析是无上神功的心法口诀和入门要领。不管多么精妙绝伦的算法实现，都是由一些最基础的模型和范式组装起来的。

关于算法设计，这里给你们推荐一门课程，很不错，小伙伴能够看看：

算法设计与分析-Design and Analysis of Algorithms

TIPS： 小伙伴若是有好的资源，也能够留言 mark 哦。

最 NICE 的解法

降维分析，化繁为简

如今，到了最关键的时刻。咱们回到题目中，开始设计咱们的算法。

题干信息很简单，核心问题在于：

如何从数组中选取 N 个数进行求和运算。

如何作，这里咱们一般且正确的作法，是对问题进行降维分析，而且化繁为简。

下面开始降维分析，化繁为简：

假如 N = 2 ，也就是找出数组中两个数的和为 M 的话，你会怎么作？可能你会想到每次从数组中弹出一个数，而后与余下的每一个数进行相加，最后作判断。

那么问题来了，当 N = 3 呢，N = 10 呢，会发现运算量愈来愈大，以前的方式已经不可行了。

不妨换一种思路：

数组中选取不固定数值 N ，咱们能够尝试着使用标记的方式，咱们把 1 表示成选取状态， 把 0 表示成未选取状态。

假设数组 constarr=[1,2,3,4] ，对应着每一个元素都有标记 0 或者 1 。若是 N=4 ，也就是在这个数组中，须要选择 4 个元素，那么对应的标记就只有一种可能 1111 ，若是 N=3 ，那就有 4 种可能，分别是 1110 、 1101 、1011 以及 0111 (也就是 C4取3->4 ) 种可能。

开始抽象

经过上面的层层叙述，咱们如今的问题能够抽象为：

标记中有几个 1 就是表明选取了几个数，而后再去遍历这些 1 全部可能存在的排列方式，最后作一个判断，这个判断就是：每一种排列方式，都表明着数组中不一样位置的被选中的数的组合，因此这里就是将选中的这些数字，进行求和运算，而后判断求出的和是否是等于 M 。

因而，问题开始变得简单了。

如何将数组和标记关联

0101 这样的数据一眼望上去第一反应就是二进制啊

对于 arr 来讲，有 4 个元素，对应的选择方式就是从 0000（ N = 0 ）到 1111( N = 4 )的全部可能。

而 1111 就是 15 的二进制，也就是说这全部的可能其实对应的就是 0 - 15 中全部数对应的二进制。

这里的问题最终变成了如何从数组长度 4 推导出 0 - 15

这里采用了位运算--左移运算， 1 << 4 的结果是 16 。

因此咱们能够创建这样一个迭代：

const arr = [1, 2, 3, 4]
let len = arr.length, bit = 1 << len

// 这里忽略了 0 的状况(N = 0)，取值就是 1 - 15
for(let i = 1; i < bit; i++) {
  // ...
}
复制代码

如何从 1110 标记中取出 1 的个数

最简单的方式：

const n = num => num.toString(2).replace(/0/g, '').length
复制代码

这其实也是一道算法常考题，由于位运算是不须要编译的，确定速度最快。

PS: 若是不理解位运算为什么会提升性能的同窗，能够自行搜索一下位运算。简单点说就是：位运算直接用二进制进行表示，省去了中间过程的各类复杂转换，提升了速度。

咱们尝试使用 & 运算来解决这个问题

首先咱们确定知道 1 & 1 = 1; 1 & 0 = 0 这些结论的。因此咱们从 15 & 14 => 14 能够推导出 1111 & 1110 => 1110 ，为何能够这样推导呢，由于 15 的二进制就是 111`` ，14` 同理。

咱们能够看到，经过上面的操做消掉了最后的 1。

因此咱们能够创建一个迭代，经过统计消除的次数，就能肯定最终有几个 1 了。

代码以下：

const n = num => {
  let count = 0
  while(num) {
    num &= (num - 1)
    count++
  }
  return count
}
复制代码

计算和等于 M

如今咱们已经能够把全部的选取可能转变为遍历一个数组，而后经过迭代数组中的每一个数对应的二进制，有几个 1 来肯定选取元素的个数。

那么，如今须要的最后一层判断就是选取的这些数字和必须等于 M

这里其实就是创建一个映射：

1110 到 [1, 2, 3, 4] 的映射，就表明选取了 2, 3, 4，而后判断 2 + 3 + 4 与 M 。

这里能够这样看：1110 中的左边第一个 1 对应着数组 [1, 2, 3, 4] 中的 1 。

如今有一个问题，该如何创建这个映射关系呢？

咱们知道前者 1110 其实就是对应的外层遍历中的 i = 14 的状况。

再看看数组[1, 2, 3, 4] ，咱们能够将元素及其位置分别映射为 1000 0100 0010 0001。

实现方式也是经过位运算--左位移来实现：

1 << inx ，inx 为数组的下标。

位掩码介绍

对 位掩码 不熟悉的童鞋会有点晕，这里简单科普下：

实质上，这里的 1 << j ，是指使用 1 的移位来生成其中仅设置第 j 位的位掩码。

好比：14 的二进制表示为 1110，其表明（从右往左）选取了第 2 , 3 , 4 位。

那么(下面故意写成上下对应的方式)：

// demo1
  1110
&
  0001
=
  0000 
  
// demo2
  1110
&
  0010
=
  0010 
复制代码

PS: 经过上面代码，咱们能够看到上下对应的 0 和 1 在进行 & 运算之后，得出的结果和在 js 中进行相同条件下 & 运算的结果相同。

因此：

1 << 0 // 1 -> 0001
1 << 1 // 2 -> 0010
1 << 2 // 4 -> 0100
1 << 3 // 8 -> 1000

// 说白了，就是把左边的值变成二进制形式，而后左移或者右移，超出补0

// 因此， 1110 对应着 第一位没有选取，那么 1110 & 0001(设置为第一位的位掩码) = 0，若是 i & (1 << inx) !== 0 表明该位被选取了
for(let j = 0; j < arr.length; j++){
  if((i & (1 << j) !== 0) {
    // 表明这个数被选取了，咱们作累加求和就行
  }
}
复制代码

因此综上所述，最终代码实现以下：

// 参数依次为目标数组、选取元素数目、目标和
const search = (arr, count, sum) => {
  // 计算某选择状况下有几个 `1`，也就是选择元素的个数
  const n = num => {
    let count = 0
    while(num) {
      num &= (num - 1)
      count++
    }
    return count
  }

  let len = arr.length, bit = 1 << len, res = []
  
  // 遍历全部的选择状况
  for(let i = 1; i < bit; i++){
    // 知足选择的元素个数 === count
    if(n(i) === count){
      let s = 0, temp = []

      // 每一种知足个数为 N 的选择状况下，继续判断是否知足 和为 M
      for(let j = 0; j < len; j++){
        // 创建映射，找出选择位上的元素
        if((i & 1 << j) !== 0) {
          s += arr[j]
          temp.push(arr[j])
        }
      }

      // 若是这种选择状况知足和为 M
      if(s === sum) {
        res.push(temp)
      }
    }
  }

  return res
}
复制代码

如何测试

这其实也是能够单独写一篇文章的知识点。

测试的种类、方式多种多样，咱们将本身想象成一个 TroubleMaker ，各类为难本身写的算法，而后不断优化本身的代码，这个过程也是有趣极了。

首先二话不说，照着内心一开始就想的最简单的方式撸一个测试用例。

代码以下：

// 写一个很大的数组进行测试
const arr = Array.from({length: 10000000}, (item, index) => index)
// 测试不一样选取容量
const mocks = sum => [3, 300, 3000, 30000, 300000, 3000000].map(item => ({count: item, sum }))

let res = []
mocks(3000).forEach((count, sum) => {
  const start = window.performance.now()
  search(arr, count, sum)
  const end = window.performance.now()
  res.push(end - start)
})

复制代码

而后结果以下图：

发现造了一个长度为 10000 万的数组，找 6 个数，竟然只要 0.014 秒。什么鬼，这么快的么，开挂了吧。不行，感受这不靠谱，仍是从长计议，写一个专业的测试案例比较好，请继续往下看。

咱们主要从两个方向下手：

第一个方向：全方位攻击

其实就是抠脑壳想出一万种状况去折腾本身的代码，也就是所谓的 地毯式测试案例轰炸。

完整代码以下：

// 好比针对上面的算法，能够这样写
export const assert = (desc, condition) => {
  condition = typeof condition === "function" ? condition() : condition;
  console.info(`[Test] %c${desc}`, "color: orange");
  if (!condition) {
    throw new Error(`[Error] %c${desc} failed.`, "color: pink");
  }
  console.info(`[Success] %c${desc} success.`, "color: #198");
};

const mock_a = Array.from({ length: 4 }, (item, index) => index);
const mock_b = Array.from({ length: 6 }, (item, index) => index - 3);
const mock_c = Array.from({ length: 4 }, () => 0);

assert(`正整数状况测试`, () => {
  const res = search(mock_a, 2, 3);
  const lengthTest = res.length === 2;
  const resTest = JSON.stringify(res) === JSON.stringify([[1, 2], [0, 3]]);
  return lengthTest && resTest;
});

assert(`负数状况测试`, () => {
  const res = search(mock_b, 2, 0);
  const lengthTest = res.length === 2;
  const resTest = JSON.stringify(res) === JSON.stringify([[-1, 1], [-2, 2]]);
  return lengthTest && resTest;
});

// ...
复制代码

codesandbox 完整代码地址

在 codesandbox 的运行控制台下，能够看到测试结果以下图所示：

kvVxcn.png

会发现，这里把不少测试场景都覆盖了，这样的好处就是让本身的代码可以更鲁棒、更安全。

固然，上面的 case 还能够再极端点，从而能够驱使代码变得更加鲁棒。

极端的场景带来的优化以下：

第一个极端：增长小数的状况。由于精度偏差的问题，这里就能够将代码继续优化，以支持小数状况。

第二个极端：增长公差参数的状况。不用绝对相等来取数，能够经过公差来增长灵活性。

第二个方向：性能测试和持续优化

关注的第二个点在于性能测试，为何呢？

若是要将本身的算法付诸生产，除须要稳定的功能表现以外，还要有足够让人信服的性能。毕竟，性能高的代码是咱们广泛的追求。

这里分享一下有用的技巧:

经过 window.performance.now() ，或者 console.time() ，咱们能够简单快捷的获取到程序执行的时间。

在写这样的测试案例的时候，有几个原则，分别是：

只关注本身的测试内容。

保持干净

考虑极端状况（好比数组很大很大）

将屡次测试结果进行对比分析

固然你也可使用相似 jsperf 之类的工具，而后一点一点的去扣这些优化点，来持续打磨本身的代码。

这里提一下，虽然经过测试数据的反馈，能够调整你的算法。可是不要为了性能盲目的进行优化，性能优化其实就是找一个平衡点，原则是足够用就好。

具体怎么作呢？对于上面的算法，咱们若是采用空间换时间的优化方式，能够在计算 1 的个数的 n 函数上作一些优化 ，好比加个缓存。

而后对比性能，以下图所示：：

kveUz9.png

完整的测试案例地址

测试性能对比

说到测试性能对比，这里主要收集一些实现方式，好比基于 jsperf 作一些对比。

若是有其余的实现方式，欢迎小伙伴留言补充。

jsperf 测试性能结果，以下图所示：：

kjjo3F.md.png

完整的测试案例地址

总结

这道题颇有难度，用到的知识也不少，认真想想，必定能有不少收获的，这道算题的解决，大体用到了如下这些知识：

  1. 二进制以及位运算的知识
  2. 剪枝的思想
  3. 如何全方位、地毯式、走极端、多方面的对一个算法进行性能测试
  4. 算法思想，算法设计相关的简要知识
  5. 如何将极其抽象的问题进行降维分析，化繁为简

番外篇--复杂度

算法复杂度

这涉及到大 O 判断法。(算法业内通常不叫大 O ，叫 big O 连起来读，好比 B沟N )

这部份内容你们自行维基搜索吧，很详细的。下面咱们提一下，离咱们工做很近的一种复杂度的计算法则。

如何判断业务代码的复杂度

对前端来讲，大 O 判断法不能太适用，其实还有一种颇有趣的判断复杂度的方法，它叫作 Tom McCabe 方法。

该方法很简单，经过计算函数中 决策点 的数量来衡量复杂度。下面是一种计算决策点(结合前端)的方法：

  1. 从 1 开始，一直往下经过函数
  2. 一旦遇到 if while for else 或者带有循环的高阶函数，好比 forEach map 等就加 1
  3. 给 case 语句中的每一种状况都加 1

好比下面代码:

function fun(arr, n) {
  let len = arr.length
  for (let i = 0; i < len; i++) {
    if (arr[i] == n) {
        // todo...
    } else {
        // todo...
    }
  }
}
复制代码

按照 Tom McCabe 方法来计算复杂度，那么这个 fun 函数的决策点数量是 3 。知道决策点数量后，怎么知道其度量结果呢？这里有一个数值区间判断：

数量区间 度量结果
0-5 这个函数可能还不错
6-10 得想办法简化这个函数了
10+ 把这个函数的某一部分拆分红另外一个函数并调用他

从上面的判断依据能够看出，我上面写的代码，数量是 3 ，能够称为函数还不错。我我的以为这个判断方法仍是很科学和简单的，能够做为平时写代码时判断函数需不须要重构的一个考虑点，毕竟一个函数，一眼扫去，决策点数量大体就知道是多少了，很好计算。

备注

  1. 文中卖了些呆萌，好比把算法比做妹纸，还望各位妹纸大佬多多海涵，小分队是想卖萌让文章不至于太枯燥。

  2. 文中不免有错误之处，欢迎在评论区指出，你们一块儿讨论，学习，进步。

  3. 这是算法小分队的第一篇输出文章，也见证了狂想录的开始和成长。

  4. 本文由从未接触过公众号编辑的 源码终结者 花了 4 个小时搞出来的，别说了，点个好看鼓励下吧，真不容易。

交流

本文算法代码在下图的 前端算法小分队知识合集 目录中。

TP 地址：https://github.com/refactoring-now/

目前刚起步，内容还不太完善，后续会持续更新内容。

若是以为不错的话，能够 star 鼓励一下。

感谢付出的小伙伴

很是感谢前端算法小分队的成员一块儿努力攻克了这个题目。

特此感谢：

本文第一做者：小金刚(大佬)

github 地址：https://github.com/cbbfcd

掘金地址：https://juejin.im/user/593df367128fe1006aecb3cf

文章排版和内容深度完善：源码终结者

github 地址：https://github.com/godkun

参与审校和核对：Ninja

github 地址：https://github.com/jiameng123

其余小伙伴的贡献：前端狂想录算法小分队总体成员

交流

我是源码终结者，欢迎技术交流。

也能够进 前端狂想录群 你们一块儿头脑风暴。有想加的，由于人满了，能够先加我好友，我来邀请你进群。

风之语

最后：尊重原创，转载请注明出处哈😋

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程