Add some basic math algo

Author: Ren0503

README.md

@@ -50,7 +50,7 @@ Thuật toán là một đặc tả rõ ràng về cách giải quyết một l
   * `B` [Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) - tìm ước số chung lớn nhất (GCD)
   * `B` [Least Common Multiple](src/algorithms/math/least-common-multiple) - tìm bội số chung nhỏ nhất (LCM)
   * `B` [Sieve of Eratosthenes](src/algorithms/math/sieve-of-eratosthenes) - tìm tất cả số nguyên tố theo giới hạn được đưa.
-  * `B` [Is Power of Two](src/algorithms/math/is-power-of-two) - kiểm tra một số có phải bình phương của 2 (dương lẫn âm).
+  * `B` [Is Power of Two](src/algorithms/math/is-power-of-two) - kiểm tra một số có phải luỹ thừa của 2.
   * `B` [Pascal's Triangle](src/algorithms/math/pascal-triangle) - tam giác Pascal.
   * `B` [Complex Number](src/algorithms/math/complex-number) - số phức và các phép toán cơ bản.
   * `B` [Radian & Degree](src/algorithms/math/radian) - chuyển từ radian sang độ và ngược lại.

src/algorithms/math/euclidean-algorithm/README.md

@@ -0,0 +1,24 @@
+# Thuật toán Euclidean
+
+Trong toán học, thuật toán Euclidean hay Euclid's, là một phương pháp hiệu quả để tính ước chung lớn nhất (GCD) của hai số, GCD của hai số là số lớn nhất mà cả hai cùng chia hết hay chia không có phần dư.
+
+Thuật toán Euclidean được xây dựng dựa trên nguyên tắc ước chung lớn nhất của hai số không thay đổi, nếu số lớn hơn được thay thế bởi hiệu số của nó với số nhỏ hơn. Ví dụ, `21` là GCD của `252` và `147` (vì `252 = 21 × 12` và `147 = 21 × 7`) đồng thời `21` cũng là GCD của `147` và `105 = 252 − 147`.
+Vì sự thay đổi này sẽ làm cho số lớn hơn thành số nhỏ hơn, nên quá trình này sẽ lặp lại cho đến khi nào hai số bằng nhau. Khi đó, chúng sẽ là GCD của hai số ban đầu.
+
+Bằng cách đảo ngược các bước, GCD có thể được biểu thị dưới dạng tổng của hai số ban đầu, mỗi số nhân với một số nguyên dương hoặc âm, ví dụ: `21 = 7 × 147 + (−4) × 252`. GCD thể hiện theo cách này được gọi là bổ đề Bézout.
+
+![GCD](https://upload.wikimedia.org/wikipedia/commons/3/37/Euclid%27s_algorithm_Book_VII_Proposition_2_3.png)
+
+Phương pháp của Euclid để tìm ước chung lớn nhất (GCD) của hai đoạn có độ dài bắt đầu là `BA` và `DC`, cả hai đều được xác định theo một "đơn vị" chung. Độ dài `DC` ngắn hơn, nó được dùng để "đo" `BA`, nhưng chỉ một lần vì phần dư `EA` nhỏ hơn `DC`. EA sẽ đo (hai lần) chiều dài của `DC`, với phần còn lại `FC` ngắn hơn `EA`. Sau đó `FC` đo (ba lần) độ dài` EA`. Bởi vì không có phần dư, quá trình kết thúc với `FC` là` GCD`. Ở ví dụ bên phải của Nicgastus với các số `49` và `21` dẫn đến GCD của họ là `7`.
+
+![GCD](https://upload.wikimedia.org/wikipedia/commons/7/74/24x60.svg)
+
+Hình chữ nhật `24 x 60` được bao phủ bởi mười ô vuông `12 x 12`, trong đó `12` là GCD của `24 'và `60`. Nói một cách tổng quát hơn, một hình chữ nhật `a-by-b` có thể được bao phủ bởi các ô vuông có độ dài cạnh `c` chỉ khi `c` là ước chung của `a` và `b`.
+
+![GCD](https://upload.wikimedia.org/wikipedia/commons/1/1c/Euclidean_algorithm_1071_462.gif)
+
+Hoạt ảnh dựa trên phép trừ của thuật toán Euclide. Hình chữ nhật ban đầu có kích thước `a = 1071` và `b = 462`. Các hình vuông có kích thước `462 × 462` được đặt bên trong nó để lại một hình chữ nhật `462 × 147`. Hình chữ nhật này được lắp bằng các ô vuông `147 × 147` cho đến khi còn lại một hình chữ nhật `21 × 147`, lần lượt được lắp bằng các ô vuông `21 × 21`, không để lại gì cả, diện tích đã bị che khuất hoàn toàn. Kích thước hình vuông nhỏ nhất, `21`, là GCD của `1071` và `462`.
+
+## Liên kết
+
+[Wikipedia](https://en.wikipedia.org/wiki/Euclidean_algorithm)

src/algorithms/math/euclidean-algorithm/euclideanAlgorithm.js

@@ -0,0 +1,15 @@
+/**
+ * Phiên bản đệ quy của Thuật toán Euclid tìm ước số chung lớn nhất (GCD).
+ * @param {number} originalA
+ * @param {number} originalB
+ * @return {number}
+ */
+export default function euclideanAlgorithm(originalA, originalB) {
+    // Làm cho số nhập vào luôn dương.
+    const a = Math.abs(originalA);
+    const b = Math.abs(originalB);
+
+    // Để làm cho thuật toán hoạt động nhanh hơn thay vì trừ một số cho số kia
+    // chúng ta có thể sử dụng thao tác chia lấy phần dư.
+    return (b === 0) ? a : euclideanAlgorithm(b, a % b);
+}

src/algorithms/math/euclidean-algorithm/euclideanAlgorithmIterative.js

@@ -0,0 +1,20 @@
+/**
+ * Phiên bản dùng vòng lặp của Thuật toán Euclid tìm ước số chung lớn nhất (GCD).
+ * @param {number} originalA
+ * @param {number} originalB
+ * @return {number}
+ */
+export default function euclideanAlgorithmIterative(originalA, originalB) {
+    // Làm cho số nhập vào luôn dương.
+    let a = Math.abs(originalA);
+    let b = Math.abs(originalB);
+
+    // Trừ một số bởi số lớn hơn cho đến khi chúng bằng nhau.
+    // Kết quả sẽ là GCD thì chúng sẽ thoát khỏi vòng lặp. Hoặc là chúng bằng 0
+    while (a && b && a !== b) {
+        [a, b] = a > b ? [a - b, b] : [a, b - a];
+    }
+
+    // Trả về số khác 0 từ phép trừ cuối cùng (đấy là GCD).
+    return a || b;
+}

src/algorithms/math/is-power-of-true/README.md

@@ -0,0 +1,44 @@
+# Luỹ thừa của hai
+
+Cho một số nguyên, viết hàm kiểm tra nó phải luỹ thừa của hai hay không.
+
+**Giải pháp đơn giản**
+
+Đơn giản nhất, ta chỉ cần liên tục chia lấy dư cho hai mỗi lần làm như vậy ta cần kiểm tra xem phần dữ có luôn bằng `0` không. Nếu có lần nào nó bằng `1` thì số đấy không phải luỹ thừa của hai.
+
+**Giải pháp bitwise**
+
+Luỹ thừa của hai ở dạng nhị phân luôn chỉ có một bit có giá trị là `1`. Trừ khi đấy là số nguyên có dấu (ví dụ: số nguyên có dấu 8-bit có giá trị -128 sẽ là : `10000000`)
+
+```
+1: 0001
+2: 0010
+4: 0100
+8: 1000
+```
+
+Vì vậy, sau khi kiểm tra rằng số đấy lớn hơn không, chúng ta có thể sử dụng một thủ thuật bitwise để kiểm tra số đó chỉ có một bit là `1`.
+
+```
+number & (number - 1)
+```
+
+Ví dụ thao tác với số `8` như sau :
+
+```
+  1000
+- 0001
+  ----
+  0111
+
+  1000
+& 0111
+  ----
+  0000
+```
+
+## Liên kết
+
+- [GeeksForGeeks](https://www.geeksforgeeks.org/program-to-find-whether-a-no-is-power-of-two/)
+- [Bitwise Solution on Stanford](http://www.graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2)
+- [Binary number subtraction on YouTube](https://www.youtube.com/watch?v=S9LJknZTyos&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=66)

src/algorithms/math/is-power-of-true/isPowerOfTwo.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number} number
+ * @return {boolean}
+ */
+export default function isPowerOfTwo(number) {
+    // 1 (2^0) là luỹ thừa của hai nhỏ nhất.
+    if (number < 1) {
+        return false;
+    }
+
+    // Ta sẽ kiểm tra xem có thể chia number cho hai 
+    // nhiều lần mà không có dư.
+    let dividedNumber = number;
+    while (dividedNumber !== 1) {
+        if (dividedNumber % 2 !== 0) {
+            // Đối với bất kỳ trường hợp nào khi phần dư khác không, chúng ta có thể
+            // nói rằng số này không phải là lũy thừa của hai.
+            return false;
+        }
+
+        dividedNumber /= 2;
+    }
+
+    return true;
+}

src/algorithms/math/is-power-of-true/isPowerOfTwoBitwise.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number} number
+ * @return {boolean}
+ */
+export default function isPowerOfTwoBitwise(number) {
+    // 1 (2^0) là luỹ thừa của hai nhỏ nhất.
+    if (number < 1) {
+        return false;
+    }
+
+    /*
+     * Luỹ thừa của hai ở dạng nhị phân như sau:
+     * 1: 0001
+     * 2: 0010
+     * 4: 0100
+     * 8: 1000
+     *
+     * Ta thấy luôn chỉ có một bit có giá trị là `1`. Trừ khi đấy là số nguyên có dấu 
+     * (ví dụ: số nguyên có dấu 8-bit có giá trị -128 sẽ là : `10000000`)
+     *
+     * Vì vậy, sau khi kiểm tra rằng số đấy lớn hơn không, chúng ta có thể sử dụng 
+     * một thủ thuật bitwise để kiểm tra số đó chỉ có một bit là `1`.
+     */
+    return (number & (number - 1)) === 0;
+}

src/algorithms/math/least-common-multiple/README.md

@@ -0,0 +1,41 @@
+# Bội chung nhỏ nhất
+
+Trong lý thuyết số học, bội số chung nhỏ nhất hoặc bội chung nhỏ nhất của hai số nguyên `a` và `b`, thường được ký hiệu là `LCM (a, b)`, là số nguyên dương nhỏ nhất có thể chia hết cho cả `a` và` b`. Vì phép chia số cho số 0 là undefined, nên định nghĩa này chỉ có nghĩa nếu `a` và `b` đều khác 0. 
+
+## Ví dụ
+
+Bội chung nhỏ nhất của 4 và 6?
+
+Bội số của 4 là :
+```
+4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, ...
+```
+
+Và bội số của 6 là :
+```
+6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, ...
+```
+
+Các bội số chung của `4` và `6` trong danh sách là :
+
+```
+12, 24, 36, 48, 60, 72, ....
+```
+
+Vì vậy theo danh sách, bội số chung đầu tiên của `4` và `6` cũng là bội số chung nhỏ nhất là `12`.
+
+## Tính bội số chung nhỏ nhất
+
+Công thức sau đây tính bội số chung nhỏ nhất bằng cách lấy tích hai số (luôn dương) chia cho ước số chung lớn nhất (GCD) :
+
+```
+lcm(a, b) = |a * b| / gcd(a, b)
+```
+
+![LCM](https://upload.wikimedia.org/wikipedia/commons/c/c9/Symmetrical_5-set_Venn_diagram_LCM_2_3_4_5_7.svg)
+
+Biểu đồ Venn cho thấy bội số chung nhỏ nhất của kết hợp của `2`, `3`, `4`,`5` và `7` (`6` được bỏ qua dó nó có dạng là `2 × 3`, cả hai số đều đã được biểu diễn).
+
+## Liên kết
+
+[Wikipedia](https://en.wikipedia.org/wiki/Least_common_multiple)

src/algorithms/math/least-common-multiple/leastCommonMultiple.js

@@ -0,0 +1,11 @@
+import euclideanAlgorithm from '../euclidean-algorithm/euclideanAlgorithm';
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+
+export default function leastCommonMultiple(a, b) {
+    return ((a === 0) || (b === 0)) ? 0 : Math.abs(a * b) / euclideanAlgorithm(a, b);
+}

src/algorithms/math/pascal-triangle/README.md

@@ -0,0 +1,42 @@
+# Tam giác Pascal
+
+Trong toán học, **Tam giác Pascal** là một mảng tam giác của các [hệ số nhị thức](https://en.wikipedia.org/wiki/Binomial_coefficient).
+
+Các hàng của tam giác Pascal được liệt kê theo quy ước bắt đầu bằng hàng `n = 0` ở trên cùng (hàng `0`). Các mục trong mỗi hàng được đánh số từ đầu bên trái với `k = 0` và thường được đặt so le so với các số trong các hàng liền kề. Tam giác có thể được xây dựng theo cách sau: Trong hàng `0` (hàng trên cùng), có một số 1 duy nhất. Mỗi số của mỗi hàng tiếp theo được xây dựng bằng cách thêm số ở trên và bên trái với số ở trên và sang bên phải, coi các mục trống là `0`. Ví dụ: số ban đầu trong hàng đầu tiên (hoặc bất kỳ số nào khác) là `1` (tổng của `0` và `1`), trong khi các số `1` và `3` trong hàng thứ ba được thêm vào để tạo ra số 4 ở hàng thứ tư.
+
+![Pascal's Triangle](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
+
+## Công thức
+
+Mục nhập trong hàng thứ n và cột thứ k của tam giác Pascal được ký hiệu ![Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/206415d3742167e319b2e52c2ca7563b799abad7). Ví dụ: mục nhập khác duy nhất ở hàng trên cùng là ![Formula example](https://wikimedia.org/api/rest_v1/media/math/render/svg/b7e35f86368d5978b46c07fd6dddca86bd6e635c). 
+
+Với ký hiệu này, việc xây dựng đoạn trước có thể được viết như sau :
+
+![Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/203b128a098e18cbb8cf36d004bd7282b28461bf)
+
+với mọi số nguyên n không âm và mọi số nguyên k nằm trong khoảng từ 0 đến n.
+
+![Binomial Coefficient](https://wikimedia.org/api/rest_v1/media/math/render/svg/a2457a7ef3c77831e34e06a1fe17a80b84a03181)
+
+## Tính toán các mục nhập tam giác trong thời gian O (n)
+
+Ta biết rằng mục nhập thứ `i` ở dòng `lineNumber` là một hệ số nhị thức `C(lineNumber, i)` và tất cả các dòng bắt đầu bằng `1`. Ý tưởng để tính `C(lineNumber, i)` sử dụng `C(lineNumber, i-1)`. Và có thể được tính bằng thời gian `O(1)` như sau :
+
+```
+C(lineNumber, i)   = lineNumber! / ((lineNumber - i)! * i!)
+C(lineNumber, i - 1) = lineNumber! / ((lineNumber - i + 1)! * (i - 1)!)
+```
+
+Chúng ta có thể suy ra biểu thức sau từ hai biểu thức trên:
+
+```
+C(lineNumber, i) = C(lineNumber, i - 1) * (lineNumber - i + 1) / i
+```
+
+Vì vậy, `C(lineNumber, i)` có thể được tính toán
+từ `C(lineNumber, i - 1)` trong thời gian `O(1)`.
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Pascal%27s_triangle)
+- [GeeksForGeeks](https://www.geeksforgeeks.org/pascal-triangle