Feat: sword means offer (#22)

Rain120 · web-flow · commit 16d42637dcd8 · 2020-07-26T12:26:21.000+08:00
* feat: plop new docs or template set alias; update docs about alias

* feat: sword means offer: 03 find repeat number; fix: plop template; readme title

* fix: remove changelog at pre commit
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,9 +1,10 @@
-# 1.0.0 (2020-07-05)
+# 1.0.0 (2020-07-26)
 
 
 ### Bug Fixes
 
 * algorithms docs build bug ([c4ed72d](https://github.com/Rain120/awesome-javascript-code-implementation/commit/c4ed72d2da7b0f940a4f7530bdfaaa47631741ff))
+* changelog not add ([d69f43f](https://github.com/Rain120/awesome-javascript-code-implementation/commit/d69f43f5112ea7d55242b46ca670ad54741bd940))
 * ci bug ([f6185d6](https://github.com/Rain120/awesome-javascript-code-implementation/commit/f6185d6f29e1587bba76f0772433441602bc8db7))
 * deploy bug ([568b663](https://github.com/Rain120/awesome-javascript-code-implementation/commit/568b663a5fd6d1b4ab40043e0a693564d7dc3a84))
 * gitalk cannot login; feat: manifest ([ee9e237](https://github.com/Rain120/awesome-javascript-code-implementation/commit/ee9e237314451244a13c6c4c13f8a119572b6ecb))
@@ -50,21 +51,22 @@
 * observer pattern ([77c78f7](https://github.com/Rain120/awesome-javascript-code-implementation/commit/77c78f7359161c0e64b3143e3a66fea3f5d4eb46))
 * plop create code and docs model ([2dece76](https://github.com/Rain120/awesome-javascript-code-implementation/commit/2dece76fbfd83514551dbabadf7c54d73674730d))
 * plop new code and docs template ([61a936b](https://github.com/Rain120/awesome-javascript-code-implementation/commit/61a936b58bc52a1cf984dc6156746b43f65da7f1))
-* plop new docs or template set alias; update docs about alias ([99acb07](https://github.com/Rain120/awesome-javascript-code-implementation/commit/99acb07f03348613efab69049a240bf04928dc6b))
+* plop new docs or template set alias; update docs about alias ([3722bcc](https://github.com/Rain120/awesome-javascript-code-implementation/commit/3722bccea8605dfef55dd270e7f2ca14a1c03ae7))
 * promise; debugger launch ([cc8ad80](https://github.com/Rain120/awesome-javascript-code-implementation/commit/cc8ad803956e65431cedd97f1ebb333ffe78c28e))
 * proxy design ([e615f39](https://github.com/Rain120/awesome-javascript-code-implementation/commit/e615f39497043f4c2357c7366cb13226b57208e6))
 * sort -> bubbleSort(algorithm, readme, test) ([36fab7b](https://github.com/Rain120/awesome-javascript-code-implementation/commit/36fab7b029d425ac129b6c4f202b18a9a3852fef))
 * sort -> bucket, radix; algorithm -> binaryTree; add some types; docs: update readme; fix: tests format, ([b1d166c](https://github.com/Rain120/awesome-javascript-code-implementation/commit/b1d166c7e56e37f35ab0bc7628186eeae15a4b60))
+* sword means offer: 03 find repeat number; fix: plop template; readme title ([cf084d8](https://github.com/Rain120/awesome-javascript-code-implementation/commit/cf084d80099aa5445bd6522a6d8be373ad2c73fb))
 * update docs -> algorithm: binary tree, sort ([5d57bc4](https://github.com/Rain120/awesome-javascript-code-implementation/commit/5d57bc4489551bffeca34102f2fce61b59996873))
 * update docs -> design pattern function array object math primitive types utils ([1690af5](https://github.com/Rain120/awesome-javascript-code-implementation/commit/1690af5ed96c46341465f72866732837e5c72200))
 * update netlify status ([013b5ca](https://github.com/Rain120/awesome-javascript-code-implementation/commit/013b5ca5847873adabbff93a89daa41500ccf153))
 * update readme for plans ([b427b96](https://github.com/Rain120/awesome-javascript-code-implementation/commit/b427b9667cc97c77df75ef0af56eb84b6b4c3ba6))
 * update test.yml -> ci.yml and set command ([43b96b6](https://github.com/Rain120/awesome-javascript-code-implementation/commit/43b96b63fc2788a5ea37fa7567c6a6dced4b875f))
 * update vdom-diff docs ([06590c5](https://github.com/Rain120/awesome-javascript-code-implementation/commit/06590c56d0df7cbba68bb705cb7e159f6f765c3a))
 * update xmind ([cb23933](https://github.com/Rain120/awesome-javascript-code-implementation/commit/cb23933f46152c59a7b08f84d7355b35bba25002))
+* update xmind ([71317c6](https://github.com/Rain120/awesome-javascript-code-implementation/commit/71317c67376bc8196f80e25391adfdc9b2496380))
 * update xmind ([408ca68](https://github.com/Rain120/awesome-javascript-code-implementation/commit/408ca685142dc425e90be64a284016d57d580893))
 * update xmind ([4256758](https://github.com/Rain120/awesome-javascript-code-implementation/commit/4256758c5fe0a036ce3ececc43f848e48964d7a0))
-* update xmind ([71317c6](https://github.com/Rain120/awesome-javascript-code-implementation/commit/71317c67376bc8196f80e25391adfdc9b2496380))
 * update: plans; fix: readme bug ([d44e559](https://github.com/Rain120/awesome-javascript-code-implementation/commit/d44e559def7834fcccbb19797a1d29bf5cc4e5b7))
 * vdom diff algorithm ([3b7779d](https://github.com/Rain120/awesome-javascript-code-implementation/commit/3b7779dcad7e184027d1bddfa6387224c2f009d3))
 * vuepress docs v1.0.0 ([785caeb](https://github.com/Rain120/awesome-javascript-code-implementation/commit/785caeb41beeff7a0f53646fc952d1c89ebb61d5))
diff --git a/docs/.vuepress/utils/alias.json b/docs/.vuepress/utils/alias.json
@@ -51,5 +51,8 @@
   "quickSort": "快速排序",
   "radixSort": "基数排序",
   "selectionSort": "选择排序",
-  "shellSort": "希尔排序"
+  "shellSort": "希尔排序",
+  "sword-means-offer-------": "",
+  "sword-means-offer": "剑指 Offer",
+  "03-find-repeat-number": "03. 数组中重复的数字"
 }
diff --git a/docs/zh/algorithms/binaryTree/README.md b/docs/zh/algorithms/binaryTree/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 在计算机科学中, 二叉树是每个节点最多只有两个分支的树结构。通常分支被称作 "左子树" 或 "右子树"。二叉树的分支具有左右次序, 不能随意颠倒。
 
diff --git a/docs/zh/array/arrayMove/README.md b/docs/zh/array/arrayMove/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 通过 `splice`方法去复制需要移动的数组元素，并拼接新数组。
 
diff --git a/docs/zh/array/find/README.md b/docs/zh/array/find/README.md
@@ -10,7 +10,7 @@ Array.prototype.find = function(predicate, /* thisArg*/) {}
 function (collection, predicate) {}
 ```
 
-## 原理
+## 解题思路 or 实现原理
 
 `find` 方法对数组中的每一项元素执行一次 `predicate` 函数, 直至有一个 `predicate` 返回 `true`. 当找到了这样一个元素后, 该方法会立即返回这个元素的值, 否则返回 `undefined`. 注意`predicate` 函数会为数组中的每个索引调用即从 0 到 `length - 1`, 而不仅仅是那些被赋值的索引, 这意味着对于稀疏数组来说, 该方法的效率要低于那些只遍历有值的索引的方法.
 
diff --git a/docs/zh/array/isArray/README.md b/docs/zh/array/isArray/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 使用 `Object.prototype.toString` 取得对象的一个内部属性 `[[Class]]`，然后依据这个属性，返回 `'[object Array]'` 字符串作为结果(`ECMA`标准中使用`[[]]`来表示语言内部用到的、外部不可直接访问的属性，称为`内部属性`)。利用这 个方法，再配合 `call`，我们可以取得任何对象的内部属性 `[[Class]]`，然后把类型检测转化为字符串比较，以达到我们的目的。
 
diff --git a/docs/zh/design-pattern/singleton-pattern/README.md b/docs/zh/design-pattern/singleton-pattern/README.md
@@ -10,7 +10,7 @@
 
 - 单例类必须给所有其他对象提供这一实例。
 
-## 原理
+## 解题思路 or 实现原理
 
 一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法(必须是静态方法, 通常使用 `getInstance` 这个名称); 当我们调用这个方法时, 如果类持有的引用不为空就返回这个引用, 如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用; 同时我们还将该类的构造函数定义为私有方法, 这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象, 只有通过该类提供的静态方法来得到该类的唯一实例。
 
diff --git a/docs/zh/es6/promise/README.md b/docs/zh/es6/promise/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 `Promise` 对象是一个代理对象（代理一个值），被代理的值在`Promise`对象创建时可能是未知的。它允许你为异步操作的成功和失败分别绑定相应的处理方法`(handlers)`。 这让异步方法可以像同步方法那样返回值，但并不是立即返回最终执行结果，而是一个能代表未来出现的结果的`promise`对象。
 
diff --git a/docs/zh/function/debounce/README.md b/docs/zh/function/debounce/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 - Lodash
 
diff --git a/docs/zh/function/throttle/README.md b/docs/zh/function/throttle/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 - Lodash
 
diff --git a/docs/zh/object/is/README.md b/docs/zh/object/is/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 Object.is() 判断两个值是否相同. 如果下列任何一项成立, 则两个值相同：
 
diff --git a/docs/zh/primitive/apply/README.md b/docs/zh/primitive/apply/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 调用一个具有给定 `this` 值的函数，以及作为一个数组(或类似数组对象)提供的参数。
 
diff --git a/docs/zh/primitive/bind/README.md b/docs/zh/primitive/bind/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 创建一个新的函数, 在 `bind()` 被调用时, 这个新函数的 `this` 被指定为 `bind()` 的第一个参数, 而其余参数将作为新函数的参数, 供调用时使用。
 
diff --git a/docs/zh/primitive/call/README.md b/docs/zh/primitive/call/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 使用一个指定的 `this` 值和单独给出的一个或多个参数来调用一个函数。
 
diff --git a/docs/zh/primitive/instanceof/README.md b/docs/zh/primitive/instanceof/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 判断实例对象的`__proto__`和构造函数的`prototype`是不是引用同一个地址
 
diff --git a/docs/zh/primitive/new/README.md b/docs/zh/primitive/new/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 `new`关键字做了哪些事？
 
diff --git a/docs/zh/sort/bubbleSort/README.md b/docs/zh/sort/bubbleSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 冒泡排序（`Bubble Sort`）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
 
diff --git a/docs/zh/sort/bucketSort/README.md b/docs/zh/sort/bucketSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 桶排序是计数排序的升级版。它利用了函数的映射关系, 高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效, 我们需要做到这两点:
 
diff --git a/docs/zh/sort/countingSort/README.md b/docs/zh/sort/countingSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
 
diff --git a/docs/zh/sort/heapSort/README.md b/docs/zh/sort/heapSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 堆排序(`Heap sort`)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构, 并同时满足堆积的性质: 即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法: 
 
diff --git a/docs/zh/sort/insertionSort/README.md b/docs/zh/sort/insertionSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列, 对于未排序数据, 在已排序序列中从后向前扫描, 找到相应位置并插入。
 
diff --git a/docs/zh/sort/mergeSort/README.md b/docs/zh/sort/mergeSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 归并排序(`Merge sort`)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(`Divide and Conquer`)的一个非常典型的应用。
 
diff --git a/docs/zh/sort/quickSort/README.md b/docs/zh/sort/quickSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下, 排序 `n`个项目要 `Ο(nlogn)` 次比较。在最坏状况下则需要 `Ο(n2)` 次比较, 但这种状况并不常见。事实上, 快速排序通常明显比其他 `Ο(nlogn)` 算法更快, 因为它的内部循环(`inner loop`)可以在大部分的架构上很有效率地被实现出来。
 
diff --git a/docs/zh/sort/radixSort/README.md b/docs/zh/sort/radixSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 基数排序是一种非比较型整数排序算法, 其原理是将整数按位数切割成不同的数字, 然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数, 所以基数排序也不是只能使用于整数。
 
diff --git a/docs/zh/sort/selectionSort/README.md b/docs/zh/sort/selectionSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 选择排序是一种简单直观的排序算法 `d`, 无论什么数据进去都是 `O(n²)` 的时间复杂度。所以用到它的时候`d`, 数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
 
diff --git a/docs/zh/sort/shellSort/README.md b/docs/zh/sort/shellSort/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 希尔排序, 也称递减增量排序算法, 是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
 
diff --git a/docs/zh/sword-means-offer/03-find-repeat-number/README.md b/docs/zh/sword-means-offer/03-find-repeat-number/README.md
@@ -0,0 +1,33 @@
+## 题目
+
+找出数组中重复的数字。
+
+在一个长度为 `n` 的数组 `nums` 里的所有数字都在 **`0～n - 1`** 的范围内。数组中某些数字是重复的, 但不知道有几个数字重复了, 也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
+
+示例 1: 
+
+输入:
+
+```
+[2, 3, 1, 0, 2, 5, 3]
+输出: 2 或 3 
+```
+ 
+
+限制:
+
+```
+2 <= n <= 100000
+```
+
+来源: 力扣[LeetCode](https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof)
+
+## 解题思路 or 实现原理
+
+1. 遍历该数组, 检查是否出现过, 首次出现过就标识, 再次出现就返回该值。
+
+2. 由于题目限定了所有数字都在 **`0～n - 1`** 的范围内, 即元素位置 `index` 取到的值 **也会在当前数组的范围内**, 所以只需要遍历该数组, 如果遍历的值不等于当前的 `index`, 就把它放到对应的值位置上, 如果该位置上存在该值, 结果就是该值。
+
+## 实现代码
+
+<<< @/src/sword-means-offer/03-find-repeat-number/index.ts
diff --git a/docs/zh/sword-means-offer/README.md b/docs/zh/sword-means-offer/README.md
@@ -0,0 +1,9 @@
+### 剑指 Offer
+
+::: tip
+主要学习并实现 **剑指 Offer** 中的算法
+:::
+
+#### 目录
+
+- [x] [剑指 Offer 03. 数组中重复的数字](./03-find-repeat-number/README.md)
diff --git a/docs/zh/vdom-diff/README.md b/docs/zh/vdom-diff/README.md
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 ### 常规 DOM 渲染
 
diff --git a/package.json b/package.json
@@ -48,7 +48,7 @@
   },
   "husky": {
     "hooks": {
-      "pre-commit": "npm run changelog && npm run deploy && lint-staged",
+      "pre-commit": "npm run deploy && lint-staged",
       "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
     }
   },
diff --git a/plop-templates/code/README.md.hbs b/plop-templates/code/README.md.hbs
@@ -1,3 +1,3 @@
-### 原理
+### 解题思路 or 实现原理
 
 ### 参考
diff --git a/plop-templates/code/__tests__.ts.hbs b/plop-templates/code/__tests__.ts.hbs
@@ -2,11 +2,11 @@
  * @Author: Rainy
  * @Date: 2020-02-06 19:05:18
  * @LastEditors: Rainy
- * @LastEditTime: 2020-03-01 21:08:17
+ * @LastEditTime: 2020-07-25 11:12:14
  */
 
 import { {{name}} } from '.';
 
-test('{{name}} instanceof {{name}} should false', () => {
+test('Test {{name}}', () => {
   expect({{name}}()).toBe(undefined);
 });
diff --git a/plop-templates/docs/zh/README.md.hbs b/plop-templates/docs/zh/README.md.hbs
@@ -1,4 +1,4 @@
-## 原理
+## 解题思路 or 实现原理
 
 ## 实现代码
 
diff --git a/src/Array/arrayMove/README.md b/src/Array/arrayMove/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 通过 `splice`方法去复制需要移动的数组元素，并拼接新数组。
 
diff --git a/src/Array/find/README.md b/src/Array/find/README.md
@@ -10,7 +10,7 @@ Array.prototype.find = function(predicate, /* thisArg*/) {}
 function (collection, predicate) {}
 ```
 
-### 原理
+### 解题思路 or 实现原理
 
 `find` 方法对数组中的每一项元素执行一次 `predicate` 函数, 直至有一个 `predicate` 返回 `true`. 当找到了这样一个元素后, 该方法会立即返回这个元素的值, 否则返回 `undefined`. 注意`predicate` 函数会为数组中的每个索引调用即从 0 到 `length - 1`, 而不仅仅是那些被赋值的索引, 这意味着对于稀疏数组来说, 该方法的效率要低于那些只遍历有值的索引的方法.
 
diff --git a/src/Array/isArray/README.md b/src/Array/isArray/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 使用 `Object.prototype.toString` 取得对象的一个内部属性 `[[Class]]`，然后依据这个属性，返回 `'[object Array]'` 字符串作为结果(`ECMA`标准中使用`[[]]`来表示语言内部用到的、外部不可直接访问的属性，称为`内部属性`)。利用这 个方法，再配合 `call`，我们可以取得任何对象的内部属性 `[[Class]]`，然后把类型检测转化为字符串比较，以达到我们的目的。
 
diff --git a/src/Object/is/README.md b/src/Object/is/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 Object.is() 判断两个值是否相同. 如果下列任何一项成立, 则两个值相同：
 
diff --git a/src/algorithms/sort/bubbleSort/README.md b/src/algorithms/sort/bubbleSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
 
diff --git a/src/algorithms/sort/bucketSort/README.md b/src/algorithms/sort/bucketSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 桶排序是计数排序的升级版。它利用了函数的映射关系, 高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效, 我们需要做到这两点:
 
diff --git a/src/algorithms/sort/countingSort/README.md b/src/algorithms/sort/countingSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
 
diff --git a/src/algorithms/sort/heapSort/README.md b/src/algorithms/sort/heapSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 堆排序(`Heap sort`)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构, 并同时满足堆积的性质: 即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法: 
 
diff --git a/src/algorithms/sort/insertionSort/README.md b/src/algorithms/sort/insertionSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列, 对于未排序数据, 在已排序序列中从后向前扫描, 找到相应位置并插入。
 
diff --git a/src/algorithms/sort/mergeSort/README.md b/src/algorithms/sort/mergeSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 归并排序(`Merge sort`)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(`Divide and Conquer`)的一个非常典型的应用。
 
diff --git a/src/algorithms/sort/quickSort/README.md b/src/algorithms/sort/quickSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下, 排序 `n`个项目要 `Ο(nlogn)` 次比较。在最坏状况下则需要 `Ο(n2)` 次比较, 但这种状况并不常见。事实上, 快速排序通常明显比其他 `Ο(nlogn)` 算法更快, 因为它的内部循环(`inner loop`)可以在大部分的架构上很有效率地被实现出来。
 
diff --git a/src/algorithms/sort/radixSort/README.md b/src/algorithms/sort/radixSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 基数排序是一种非比较型整数排序算法, 其原理是将整数按位数切割成不同的数字, 然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数, 所以基数排序也不是只能使用于整数。
 
diff --git a/src/algorithms/sort/selectionSort/README.md b/src/algorithms/sort/selectionSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 选择排序是一种简单直观的排序算法 `d`, 无论什么数据进去都是 `O(n²)` 的时间复杂度。所以用到它的时候`d`, 数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
 
diff --git a/src/algorithms/sort/shellSort/README.md b/src/algorithms/sort/shellSort/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 希尔排序, 也称递减增量排序算法, 是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
 
diff --git a/src/design-pattern/singleton-pattern/README.md b/src/design-pattern/singleton-pattern/README.md
@@ -10,7 +10,7 @@
 
 - 单例类必须给所有其他对象提供这一实例。
 
-### 原理
+### 解题思路 or 实现原理
 
 一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法(必须是静态方法, 通常使用 `getInstance` 这个名称); 当我们调用这个方法时, 如果类持有的引用不为空就返回这个引用, 如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用; 同时我们还将该类的构造函数定义为私有方法, 这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象, 只有通过该类提供的静态方法来得到该类的唯一实例。
 
diff --git a/src/function/debounce/README.md b/src/function/debounce/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 #### 防抖
 
diff --git a/src/function/throttle/README.md b/src/function/throttle/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 #### 节流
 
diff --git a/src/primitive/apply/README.md b/src/primitive/apply/README.md
@@ -1,4 +1,4 @@
-### 原理
+### 解题思路 or 实现原理
 
 调用一个具有给定 `this` 值的函数，以及作为一个数组(或类似数组对象)提供的参数。
 
diff --git a/src/primitive/bind/README.md b/src/primitive/bind/README.md
diff --git a/src/primitive/call/README.md b/src/primitive/call/README.md
diff --git a/src/primitive/instanceof/README.md b/src/primitive/instanceof/README.md
diff --git a/src/primitive/new/README.md b/src/primitive/new/README.md
diff --git a/src/promise/README.md b/src/promise/README.md
diff --git a/src/sword-means-offer/03-find-repeat-number/README.md b/src/sword-means-offer/03-find-repeat-number/README.md
diff --git a/src/sword-means-offer/03-find-repeat-number/__tests__.ts b/src/sword-means-offer/03-find-repeat-number/__tests__.ts
diff --git a/src/sword-means-offer/03-find-repeat-number/index.ts b/src/sword-means-offer/03-find-repeat-number/index.ts
