Merge branch 'master' into fix/typo

Author: trekhleb

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 .idea
 coverage
+.vscode

README.md

@@ -3,22 +3,22 @@
 [![Build Status](https://travis-ci.org/trekhleb/javascript-algorithms.svg?branch=master)](https://travis-ci.org/trekhleb/javascript-algorithms)
 [![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms)
 
-This repository contains JavaScript based examples of many 
+This repository contains JavaScript based examples of many
 popular algorithms and data structures.
 
 Each algorithm and data structure has its own separate README
 with related explanations and links for further reading (including ones
 to YouTube videos).
 
-_Read this in other languages:_ 
+_Read this in other languages:_
 [简体中文](https://github.com/trekhleb/javascript-algorithms/blob/master/README.zh-CN.md),
 [繁體中文](https://github.com/trekhleb/javascript-algorithms/blob/master/README.zh-TW.md)
 
 ## Data Structures
 
 A data structure is a particular way of organizing and storing data in a computer so that it can
-be accessed and modified efficiently. More precisely, a data structure is a collection of data 
-values, the relationships among them, and the functions or operations that can be applied to 
+be accessed and modified efficiently. More precisely, a data structure is a collection of data
+values, the relationships among them, and the functions or operations that can be applied to
 the data.
 
 * [Linked List](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/linked-list)
@@ -53,13 +53,14 @@ a set of rules that precisely define a sequence of operations.
   * [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
   * [Sieve of Eratosthenes](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/sieve-of-eratosthenes) - finding all prime numbers up to any given limit
   * [Is Power of Two](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/is-power-of-two) - check if the number is power of two (naive and bitwise algorithms)
+  * [Liu Hui π Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/liu-hui) - approximate π calculations based on N-gons
 * **Sets**
   * [Cartesian Product](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/cartesian-product) - product of multiple sets
   * [Power Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/power-set) - all subsets of a set
   * [Permutations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/permutations) (with and without repetitions)
   * [Combinations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/combinations) (with and without repetitions)
   * [Fisher–Yates Shuffle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
-  * [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS) 
+  * [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS)
   * [Longest Increasing subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
   * [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence) (SCS)
   * [Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
@@ -105,11 +106,11 @@ a set of rules that precisely define a sequence of operations.
   * [Tower of Hanoi](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/hanoi-tower)
   * [N-Queens Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/n-queens)
   * [Knight's Tour](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/knight-tour)
-  
+
 ### Algorithms by Paradigm
 
-An algorithmic paradigm is a generic method or approach which underlies the design of a class 
-of algorithms. It is an abstraction higher than the notion of an algorithm, just as an 
+An algorithmic paradigm is a generic method or approach which underlies the design of a class
+of algorithms. It is an abstraction higher than the notion of an algorithm, just as an
 algorithm is an abstraction higher than a computer program.
 
 * **Brute Force** - look at all the possibilities and selects the best solution
@@ -142,7 +143,7 @@ algorithm is an abstraction higher than a computer program.
   * [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray)
   * [Bellman-Ford Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/bellman-ford) - finding shortest path to all graph vertices
 * **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test
-if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a 
+if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a
 different path of finding a solution. Normally the DFS traversal of state-space is being used.
   * [Hamiltonian Cycle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/hamiltonian-cycle) - Visit every vertex exactly once
   * [N-Queens Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/n-queens)
@@ -188,13 +189,13 @@ npm test -- -t 'playground'
 [▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
 
 ### Big O Notation
-    
+
 Order of growth of algorithms specified in Big O notation.
-    
-![Big O graphs](https://github.com/trekhleb/javascript-algorithms/blob/master/assets/big-o-graph.png?raw=true)
+
+![Big O graphs](./assets/big-o-graph.png)
 
 Source: [Big O Cheat Sheet](http://bigocheatsheet.com/).
-    
+
 Below is the list of some of the most used Big O notations and their performance comparisons against different sizes of the input data.
 
 | Big O Notation | Computations for 10 elements | Computations for 100 elements | Computations for 1000 elements  |
@@ -208,12 +209,12 @@ Below is the list of some of the most used Big O notations and their performance
 | **O(N!)**      | 3628800                      | 9.3e+157                      | 4.02e+2567                      |
 
 ### Data Structure Operations Complexity
-        
+
 | Data Structure          | Access    | Search    | Insertion | Deletion  | Comments  |
-| ----------------------- | :-------: | :-------: | :-------: | :-------: | :-------- | 
+| ----------------------- | :-------: | :-------: | :-------: | :-------: | :-------- |
 | **Array**               | 1         | n         | n         | n         |           |
 | **Stack**               | n         | n         | 1         | 1         |           |
-| **Queue**               | n         | n         | 1         | 1         |           | 
+| **Queue**               | n         | n         | 1         | 1         |           |
 | **Linked List**         | n         | n         | 1         | 1         |           |
 | **Hash Table**          | -         | n         | n         | n         | In case of perfect hash function costs would be O(1) |
 | **Binary Search Tree**  | n         | n         | n         | n         | In case of balanced tree costs would be O(log(n)) |

README.zh-CN.md

@@ -170,7 +170,7 @@ npm test -- -t 'playground'
 
 大O符号中指定的算法的增长顺序。
 
-![Big O graphs](https://github.com/trekhleb/javascript-algorithms/blob/master/assets/big-o-graph.png?raw=true)
+![Big O graphs](./assets/big-o-graph.png)
 
 源: [Big O Cheat Sheet](http://bigocheatsheet.com/).
 

README.zh-TW.md

@@ -47,7 +47,7 @@ _Read this in other languages:_
   * [排列](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/permutations) (有/無重複)
   * [组合](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/combinations) (有/無重複)
   * [洗牌算法](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/fisher-yates) - 隨機置換一有限序列
-  * [最長共同子序列](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS) 
+  * [最長共同子序列](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS)
   * [最長遞增子序列](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
   * [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence) (SCS)
   * [背包問題](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
@@ -90,7 +90,7 @@ _Read this in other languages:_
   * [河內塔](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/hanoi-tower)
   * [N-皇后問題](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/n-queens)
   * [騎士走棋盤](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/knight-tour)
-  
+
 ### 演算法範型
 
 演算法的範型是一個泛用方法或設計一類底層演算法的方式。它是一個比演算法的概念更高階的抽象化，就像是演算法是比電腦程式更高階的抽象化。
@@ -166,11 +166,11 @@ npm test -- -t 'playground'
 ### 大 O 標記
 
 特別用大 O 標記演算法增長度的排序。
-    
-![Big O 表](https://github.com/trekhleb/javascript-algorithms/blob/master/assets/big-o-graph.png?raw=true)
+
+![Big O 表](./assets/big-o-graph.png)
 
 資料來源: [Big O Cheat Sheet](http://bigocheatsheet.com/).
-    
+
 下列列出幾個常用的 Big O 標記以及其不同大小資料量輸入後的運算效能比較。
 
 | Big O 標記     | 10個資料量需花費的時間 | 100個資料量需花費的時間 | 1000個資料量需花費的時間  |
@@ -184,12 +184,12 @@ npm test -- -t 'playground'
 | **O(N!)**      | 3628800                      | 9.3e+157                      | 4.02e+2567                      |
 
 ### 資料結構運作複雜度
-        
+
 | 資料結構                 | 存取      | 搜尋       | 插入      | 刪除      |
-| ----------------------- | :-------: | :-------: | :-------: | :-------: | 
+| ----------------------- | :-------: | :-------: | :-------: | :-------: |
 | **陣列**                | 1         | n         | n         | n         |
 | **堆疊**                | n         | n         | 1         | 1         |
-| **貯列**                | n         | n         | 1         | 1         | 
+| **貯列**                | n         | n         | 1         | 1         |
 | **鏈結串列**            | n         | n         | 1         | 1         |
 | **雜湊表**              | -         | n         | n         | n         |
 | **二元搜尋樹**          | n         | n         | n         | n         |

assets/big-o-graph.png

@@ -0,0 +1,92 @@
+# Liu Hui's π Algorithm
+
+Liu Hui remarked in his commentary to The Nine Chapters on the Mathematical Art,
+that the ratio of the circumference of an inscribed hexagon to the diameter of 
+the circle was `three`, hence `π` must be greater than three. He went on to provide 
+a detailed step-by-step description of an iterative algorithm to calculate `π` to 
+any required accuracy based on bisecting polygons; he calculated `π` to 
+between `3.141024` and `3.142708` with a 96-gon; he suggested that `3.14` was 
+a good enough approximation, and expressed `π` as `157/50`; he admitted that 
+this number was a bit small. Later he invented an ingenious quick method to 
+improve on it, and obtained `π ≈ 3.1416` with only a 96-gon, with an accuracy 
+comparable to that from a 1536-gon. His most important contribution in this 
+area was his simple iterative `π` algorithm.
+
+## Area of a circle
+
+Liu Hui argued:
+
+> Multiply one side of a hexagon by the radius (of its 
+circumcircle), then multiply this by three, to yield the 
+area of a dodecagon; if we cut a hexagon into a 
+dodecagon, multiply its side by its radius, then again 
+multiply by six, we get the area of a 24-gon; the finer 
+we cut, the smaller the loss with respect to the area 
+of circle, thus with further cut after cut, the area of 
+the resulting polygon will coincide and become one with 
+the circle; there will be no loss
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/6/69/Cutcircle2.svg)
+
+Liu Hui's method of calculating the area of a circle.
+
+Further, Liu Hui proved that the area of a circle is half of its circumference 
+multiplied by its radius. He said:
+
+> Between a polygon and a circle, there is excess radius. Multiply the excess 
+radius by a side of the polygon. The resulting area exceeds the boundary of 
+the circle
+
+In the diagram `d = excess radius`. Multiplying `d` by one side results in 
+oblong `ABCD` which exceeds the boundary of the circle. If a side of the polygon 
+is small (i.e. there is a very large number of sides), then the excess radius 
+will be small, hence excess area will be small.
+
+> Multiply the side of a polygon by its radius, and the area doubles; 
+hence multiply half the circumference by the radius to yield the area of circle.
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/9/95/Cutcircle.svg)
+
+The area within a circle is equal to the radius multiplied by half the 
+circumference, or `A = r x C/2 = r x r x π`.
+
+## Iterative algorithm
+
+Liu Hui began with an inscribed hexagon. Let `M` be the length of one side `AB` of 
+hexagon, `r` is the radius of circle.
+
+![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/4/46/Liuhui_geyuanshu.svg)
+
+Bisect `AB` with line `OPC`, `AC` becomes one side of dodecagon (12-gon), let 
+its length be `m`. Let the length of `PC` be `j` and the length of `OP` be `G`.
+
+`AOP`, `APC` are two right angle triangles. Liu Hui used 
+the [Gou Gu](https://en.wikipedia.org/wiki/Pythagorean_theorem) (Pythagorean theorem)
+theorem repetitively:
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/dbfc192c78539c3901c7bad470302ededb76f813)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/ccd12a402367c2d6614c88e75006d50bfc3a9929)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/65d77869fc02c302d2d46d45f75ad7e79ae524fb)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/a7a0d0d7f505a0f434e5dd80c2fef6d2b30d6100)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/c31b9acf38f9d1a248d4023c3bf286bd03007f37)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/0dee798efb0b1e3e64d6b3542106cb3ecaa4a383)
+
+![](https://wikimedia.org/api/rest_v1/media/math/render/svg/3ffeafe88d2983b364ad3442746063e3207fe842)
+
+
+From here, there is now a technique to determine `m` from `M`, which gives the 
+side length for a polygon with twice the number of edges. Starting with a 
+hexagon, Liu Hui could determine the side length of a dodecagon using this 
+formula. Then continue repetitively to determine the side length of a 
+24-gon given the side length of a dodecagon. He could do this recursively as 
+many times as necessary. Knowing how to determine the area of these polygons, 
+Liu Hui could then approximate `π`.
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Liu_Hui%27s_%CF%80_algorithm)

src/algorithms/math/liu-hui/README.md

@@ -0,0 +1,19 @@
+import liuHui from '../liuHui';
+
+describe('liuHui', () => {
+  it('should calculate π based on 12-gon', () => {
+    expect(liuHui(1)).toBe(3);
+  });
+
+  it('should calculate π based on 24-gon', () => {
+    expect(liuHui(2)).toBe(3.105828541230249);
+  });
+
+  it('should calculate π based on 6144-gon', () => {
+    expect(liuHui(10)).toBe(3.1415921059992717);
+  });
+
+  it('should calculate π based on 201326592-gon', () => {
+    expect(liuHui(25)).toBe(3.141592653589793);
+  });
+});

src/algorithms/math/liu-hui/__test__/liuHui.test.js

@@ -0,0 +1,54 @@
+/*
+ * Let circleRadius is the radius of circle.
+ * circleRadius is also the side length of the inscribed hexagon
+ */
+const circleRadius = 1;
+
+/**
+ * @param {number} sideLength
+ * @param {number} splitCounter
+ * @return {number}
+ */
+function getNGonSideLength(sideLength, splitCounter) {
+  if (splitCounter <= 0) {
+    return sideLength;
+  }
+
+  const halfSide = sideLength / 2;
+
+  // Liu Hui used the Gou Gu (Pythagorean theorem) theorem repetitively.
+  const perpendicular = Math.sqrt((circleRadius ** 2) - (halfSide ** 2));
+  const excessRadius = circleRadius - perpendicular;
+  const splitSideLength = Math.sqrt((excessRadius ** 2) + (halfSide ** 2));
+
+  return getNGonSideLength(splitSideLength, splitCounter - 1);
+}
+
+/**
+ * @param {number} splitCount
+ * @return {number}
+ */
+function getNGonSideCount(splitCount) {
+  // Liu Hui began with an inscribed hexagon (6-gon).
+  const hexagonSidesCount = 6;
+
+  // On every split iteration we make N-gons: 6-gon, 12-gon, 24-gon, 48-gon and so on.
+  return hexagonSidesCount * (splitCount ? 2 ** splitCount : 1);
+}
+
+/**
+ * Calculate the π value using Liu Hui's π algorithm
+ *
+ * @param {number} splitCount - number of times we're going to split 6-gon.
+ *  On each split we will receive 12-gon, 24-gon and so on.
+ * @return {number}
+ */
+export default function liuHui(splitCount = 1) {
+  const nGonSideLength = getNGonSideLength(circleRadius, splitCount - 1);
+  const nGonSideCount = getNGonSideCount(splitCount - 1);
+  const nGonPerimeter = nGonSideLength * nGonSideCount;
+  const approximateCircleArea = (nGonPerimeter / 2) * circleRadius;
+
+  // Return approximate value of pi.
+  return approximateCircleArea / (circleRadius ** 2);
+}