diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
index 3a281ef3f..b8f0a8b43 100644
--- a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
@@ -1,4 +1,4 @@
-The solution using a loop:
+Giải pháp sử dụng vòng lặp:
```js run
function sumTo(n) {
@@ -12,7 +12,7 @@ function sumTo(n) {
alert( sumTo(100) );
```
-The solution using recursion:
+Giải pháp sử dụng đệ quy:
```js run
function sumTo(n) {
@@ -23,7 +23,7 @@ function sumTo(n) {
alert( sumTo(100) );
```
-The solution using the formula: `sumTo(n) = n*(n+1)/2`:
+Giải pháp sử dụng công thức: `sumTo(n) = n*(n+1)/2`:
```js run
function sumTo(n) {
@@ -33,8 +33,8 @@ function sumTo(n) {
alert( sumTo(100) );
```
-P.S. Naturally, the formula is the fastest solution. It uses only 3 operations for any number `n`. The math helps!
+Tái bút: Đương nhiên, công thức là giải pháp nhanh nhất. Nó chỉ sử dụng 3 thao tác cho bất kỳ số `n` nào. Có toán giúp đỡ!
-The loop variant is the second in terms of speed. In both the recursive and the loop variant we sum the same numbers. But the recursion involves nested calls and execution stack management. That also takes resources, so it's slower.
+Biến thể vòng lặp là biến thể thứ hai về tốc độ. Trong cả biến thể đệ quy và vòng lặp, chúng ta tính tổng các số giống nhau. Nhưng đệ quy liên quan đến các cuộc gọi lồng nhau và quản lý ngăn xếp thực thi. Điều đó cũng cần tài nguyên, vì vậy nó chậm hơn.
-P.P.S. Some engines support the "tail call" optimization: if a recursive call is the very last one in the function (like in `sumTo` above), then the outer function will not need to resume the execution, so the engine doesn't need to remember its execution context. That removes the burden on memory, so counting `sumTo(100000)` becomes possible. But if the JavaScript engine does not support tail call optimization (most of them don't), there will be an error: maximum stack size exceeded, because there's usually a limitation on the total stack size.
+Tái bút nữa: Một số engine hỗ trợ tối ưu hóa "cuộc gọi đuôi": nếu một cuộc gọi đệ quy là cuộc gọi cuối cùng trong hàm (như trong `sumTo` ở trên), thì hàm bên ngoài sẽ không cần tiếp tục thực thi, vì vậy engine không cần để ghi nhớ bối cảnh thực hiện của nó. Điều đó loại bỏ gánh nặng cho bộ nhớ, vì vậy việc đếm `sumTo(100000)` trở nên khả thi. Nhưng nếu JavaScript engine không hỗ trợ tối ưu hóa lệnh gọi đuôi (hầu hết chúng không hỗ trợ), sẽ có lỗi: vượt quá kích thước ngăn xếp tối đa, vì thường có giới hạn về tổng kích thước ngăn xếp.
diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
index cabc13290..79ed84456 100644
--- a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
+++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
@@ -2,11 +2,11 @@ importance: 5
---
-# Sum all numbers till the given one
+# Tính tổng tất cả các số cho đến một số đã cho
-Write a function `sumTo(n)` that calculates the sum of numbers `1 + 2 + ... + n`.
+Viết hàm `sumTo(n)` để tính tổng các số `1 + 2 + ... + n`.
-For instance:
+Ví dụ:
```js no-beautify
sumTo(1) = 1
@@ -17,20 +17,20 @@ sumTo(4) = 4 + 3 + 2 + 1 = 10
sumTo(100) = 100 + 99 + ... + 2 + 1 = 5050
```
-Make 3 solution variants:
+Thực hiện 3 biến thể giải pháp:
-1. Using a for loop.
-2. Using a recursion, cause `sumTo(n) = n + sumTo(n-1)` for `n > 1`.
-3. Using the [arithmetic progression](https://en.wikipedia.org/wiki/Arithmetic_progression) formula.
+1. Sử dụng vòng lặp for.
+2. Sử dụng đệ quy, gây ra `sumTo(n) = n + sumTo(n-1)` cho `n > 1`.
+3. Sử dụng công thức [cấp số cộng](https://vi.wikipedia.org/wiki/C%E1%BA%A5p_s%E1%BB%91_c%E1%BB%99ng).
-An example of the result:
+Một ví dụ về kết quả:
```js
-function sumTo(n) { /*... your code ... */ }
+function sumTo(n) { /*... mã của bạn ... */ }
alert( sumTo(100) ); // 5050
```
-P.S. Which solution variant is the fastest? The slowest? Why?
+Tái bút: Biến thể giải pháp nào là nhanh nhất? Chậm nhất? Tại sao?
-P.P.S. Can we use recursion to count `sumTo(100000)`?
+Tái bút nữa: Chúng ta có thể sử dụng đệ quy để đếm `sumTo(100000)` không?
diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
index 09e511db5..c3cc207ba 100644
--- a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
@@ -1,6 +1,6 @@
-By definition, a factorial `n!` can be written as `n * (n-1)!`.
+Theo định nghĩa, giai thừa `n!` có thể được viết là `n * (n-1)!`.
-In other words, the result of `factorial(n)` can be calculated as `n` multiplied by the result of `factorial(n-1)`. And the call for `n-1` can recursively descend lower, and lower, till `1`.
+Nói cách khác, kết quả của `giai thừa(n)` có thể được tính bằng `n` nhân với kết quả của `giai thừa(n-1)`. Và lệnh gọi `n-1` có thể đệ quy giảm xuống thấp hơn và thấp hơn cho đến `1`.
```js run
function factorial(n) {
@@ -10,7 +10,7 @@ function factorial(n) {
alert( factorial(5) ); // 120
```
-The basis of recursion is the value `1`. We can also make `0` the basis here, doesn't matter much, but gives one more recursive step:
+Cơ sở của đệ quy là giá trị `1`. Chúng ta cũng có thể đặt `0` làm cơ sở ở đây, không quan trọng lắm, nhưng cung cấp thêm một bước đệ quy:
```js run
function factorial(n) {
diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
index d2aef2d90..f604f82ea 100644
--- a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
+++ b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
@@ -2,17 +2,17 @@ importance: 4
---
-# Calculate factorial
+# Tính giai thừa
-The [factorial](https://en.wikipedia.org/wiki/Factorial) of a natural number is a number multiplied by `"number minus one"`, then by `"number minus two"`, and so on till `1`. The factorial of `n` is denoted as `n!`
+[Giai thừa](https://vi.wikipedia.org/wiki/Giai_th%E1%BB%ABa) của một số tự nhiên là một số nhân với `"số trừ một"`, sau đó nhân với `"số trừ hai"`, v.v. `1`. Giai thừa của `n` được ký hiệu là `n!`
-We can write a definition of factorial like this:
+Chúng ta có thể viết một định nghĩa về giai thừa như thế này:
```js
n! = n * (n - 1) * (n - 2) * ...*1
```
-Values of factorials for different `n`:
+Giá trị của giai thừa cho `n` khác nhau:
```js
1! = 1
@@ -22,10 +22,10 @@ Values of factorials for different `n`:
5! = 5 * 4 * 3 * 2 * 1 = 120
```
-The task is to write a function `factorial(n)` that calculates `n!` using recursive calls.
+Nhiệm vụ là viết một hàm `factorial(n)` để tính toán `n!` bằng cách gọi đệ quy.
```js
alert( factorial(5) ); // 120
```
-P.S. Hint: `n!` can be written as `n * (n-1)!` For instance: `3! = 3*2! = 3*2*1! = 6`
+Tái bút: Gợi ý: `n!` có thể được viết là `n * (n-1)!` Ví dụ: `3! = 3*2! = 3*2*1! = 6`
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
index 36524a45a..4316a8442 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
@@ -1,6 +1,6 @@
-The first solution we could try here is the recursive one.
+Giải pháp đầu tiên chúng ta có thể thử ở đây là giải pháp đệ quy.
-Fibonacci numbers are recursive by definition:
+Các số Fibonacci được đệ quy theo định nghĩa:
```js run
function fib(n) {
@@ -12,11 +12,11 @@ alert( fib(7) ); // 13
// fib(77); // will be extremely slow!
```
-...But for big values of `n` it's very slow. For instance, `fib(77)` may hang up the engine for some time eating all CPU resources.
+...Nhưng đối với các giá trị lớn của `n` thì tốc độ rất chậm. Chẳng hạn, `fib(77)` có thể làm treo engine trong một thời gian và ăn hết tài nguyên CPU.
-That's because the function makes too many subcalls. The same values are re-evaluated again and again.
+Đó là bởi vì hàm thực hiện quá nhiều cuộc gọi phụ. Các giá trị tương tự được đánh giá lại nhiều lần.
-For instance, let's see a piece of calculations for `fib(5)`:
+Chẳng hạn, chúng ta hãy xem một đoạn tính toán cho `fib(5)`:
```js no-beautify
...
@@ -25,68 +25,68 @@ fib(4) = fib(3) + fib(2)
...
```
-Here we can see that the value of `fib(3)` is needed for both `fib(5)` and `fib(4)`. So `fib(3)` will be called and evaluated two times completely independently.
+Ở đây chúng ta có thể thấy rằng giá trị của `fib(3)` là cần thiết cho cả `fib(5)` và `fib(4)`. Vì vậy, `fib(3)` sẽ được gọi và đánh giá hai lần hoàn toàn độc lập.
-Here's the full recursion tree:
+Đây là cây đệ quy đầy đủ:
-We can clearly notice that `fib(3)` is evaluated two times and `fib(2)` is evaluated three times. The total amount of computations grows much faster than `n`, making it enormous even for `n=77`.
+Chúng ta có thể nhận thấy rõ ràng rằng `fib(3)` được đánh giá hai lần và `fib(2)` được đánh giá ba lần. Tổng lượng tính toán tăng nhanh hơn nhiều so với `n`, khiến nó trở nên khổng lồ ngay cả đối với `n=77`.
-We can optimize that by remembering already-evaluated values: if a value of say `fib(3)` is calculated once, then we can just reuse it in future computations.
+Chúng ta có thể tối ưu hóa điều đó bằng cách ghi nhớ các giá trị đã được đánh giá: nếu giá trị nói `fib(3)` được tính một lần, thì chúng ta chỉ có thể sử dụng lại giá trị đó trong các tính toán trong tương lai.
-Another variant would be to give up recursion and use a totally different loop-based algorithm.
+Một biến thể khác là từ bỏ đệ quy và sử dụng thuật toán dựa trên vòng lặp hoàn toàn khác.
-Instead of going from `n` down to lower values, we can make a loop that starts from `1` and `2`, then gets `fib(3)` as their sum, then `fib(4)` as the sum of two previous values, then `fib(5)` and goes up and up, till it gets to the needed value. On each step we only need to remember two previous values.
+Thay vì đi từ `n` xuống các giá trị thấp hơn, chúng ta có thể tạo một vòng lặp bắt đầu từ `1` và `2`, sau đó lấy `fib(3)` làm tổng, rồi `fib(4)` làm tổng của hai giá trị trước đó, sau đó là `fib(5)` và tăng dần cho đến khi đạt giá trị cần thiết. Trên mỗi bước chúng ta chỉ cần nhớ hai giá trị trước đó.
-Here are the steps of the new algorithm in details.
+Dưới đây là các bước của thuật toán mới một cách chi tiết.
-The start:
+Bắt đầu:
```js
-// a = fib(1), b = fib(2), these values are by definition 1
+// a = fib(1), b = fib(2), các giá trị này theo định nghĩa 1
let a = 1, b = 1;
-// get c = fib(3) as their sum
+// lấy c = fib(3) làm tổng của chúng
let c = a + b;
-/* we now have fib(1), fib(2), fib(3)
+/* bây giờ chúng ta có fib(1), fib(2), fib(3)
a b c
1, 1, 2
*/
```
-Now we want to get `fib(4) = fib(2) + fib(3)`.
+Bây giờ chúng ta muốn có `fib(4) = fib(2) + fib(3)`.
-Let's shift the variables: `a,b` will get `fib(2),fib(3)`, and `c` will get their sum:
+Hãy dịch chuyển các biến: `a,b` sẽ nhận được `fib(2),fib(3)`, và `c` sẽ nhận được tổng của chúng:
```js no-beautify
-a = b; // now a = fib(2)
-b = c; // now b = fib(3)
+a = b; // bây giờ a = fib(2)
+b = c; // bây giờ b = fib(3)
c = a + b; // c = fib(4)
-/* now we have the sequence:
+/* bây giờ chúng ta có trình tự:
a b c
1, 1, 2, 3
*/
```
-The next step gives another sequence number:
+Bước tiếp theo đưa ra một số thứ tự khác:
```js no-beautify
-a = b; // now a = fib(3)
-b = c; // now b = fib(4)
+a = b; // bây giờ a = fib(3)
+b = c; // bây giờ b = fib(4)
c = a + b; // c = fib(5)
-/* now the sequence is (one more number):
+/* bây giờ trình tự là (thêm một số):
a b c
1, 1, 2, 3, 5
*/
```
-...And so on until we get the needed value. That's much faster than recursion and involves no duplicate computations.
+...Và cứ như vậy cho đến khi chúng ta nhận được giá trị cần thiết. Điều đó nhanh hơn nhiều so với đệ quy và không cần tính toán trùng lặp.
-The full code:
+Mã đầy đủ:
```js run
function fib(n) {
@@ -105,6 +105,6 @@ alert( fib(7) ); // 13
alert( fib(77) ); // 5527939700884757
```
-The loop starts with `i=3`, because the first and the second sequence values are hard-coded into variables `a=1`, `b=1`.
+Vòng lặp bắt đầu với `i=3`, bởi vì các giá trị chuỗi thứ nhất và thứ hai được mã hóa cứng thành các biến `a=1`, `b=1`.
-The approach is called [dynamic programming bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming).
+Cách tiếp cận này được gọi là [quy hoạch động](https://vi.wikipedia.org/wiki/Quy_ho%E1%BA%A1ch_%C4%91%E1%BB%99ng).
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
index 3cdadd219..245c2841e 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
@@ -2,24 +2,24 @@ importance: 5
---
-# Fibonacci numbers
+# Dãy Fibonacci
-The sequence of [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number) has the formula Fn = Fn-1 + Fn-2. In other words, the next number is a sum of the two preceding ones.
+Dãy [số Fibonacci](https://vi.wikipedia.org/wiki/D%C3%A3y_Fibonacci) có công thức Fn = Fn-1 + Fn-2. Nói cách khác, số tiếp theo là tổng của hai số trước.
-First two numbers are `1`, then `2(1+1)`, then `3(1+2)`, `5(2+3)` and so on: `1, 1, 2, 3, 5, 8, 13, 21...`.
+Hai số đầu tiên là `1`, sau đó là `2(1+1)`, sau đó là `3(1+2)`, `5(2+3)`, v.v.: `1, 1, 2, 3, 5 , 8, 13, 21...`.
-Fibonacci numbers are related to the [Golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) and many natural phenomena around us.
+Các số Fibonacci có liên quan đến [Tỷ lệ vàng](https://vi.wikipedia.org/wiki/T%E1%BB%B7_l%E1%BB%87_v%C3%A0ng) và nhiều hiện tượng tự nhiên xung quanh chúng ta.
-Write a function `fib(n)` that returns the `n-th` Fibonacci number.
+Viết hàm `fib(n)` trả về số Fibonacci thứ n-th`.
-An example of work:
+Một ví dụ về công việc:
```js
-function fib(n) { /* your code */ }
+function fib(n) { /* mã của bạn */ }
alert(fib(3)); // 2
alert(fib(7)); // 13
alert(fib(77)); // 5527939700884757
```
-P.S. The function should be fast. The call to `fib(77)` should take no more than a fraction of a second.
+Tái bút: Các hàm nên được nhanh chóng. Lệnh gọi `fib(77)` sẽ mất không quá một phần giây.
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
index cfcbffea5..be5d118d6 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
@@ -1,6 +1,6 @@
-# Loop-based solution
+# Giải pháp dựa trên vòng lặp
-The loop-based variant of the solution:
+Biến thể dựa trên vòng lặp của giải pháp:
```js run
let list = {
@@ -30,7 +30,7 @@ function printList(list) {
printList(list);
```
-Please note that we use a temporary variable `tmp` to walk over the list. Technically, we could use a function parameter `list` instead:
+Hãy lưu ý rằng chúng ta sử dụng một biến tạm thời `tmp` để duyệt qua danh sách. Về mặt kỹ thuật, chúng ta có thể sử dụng tham số chức năng `list` để thay thế:
```js
function printList(list) {
@@ -43,15 +43,15 @@ function printList(list) {
}
```
-...But that would be unwise. In the future we may need to extend a function, do something else with the list. If we change `list`, then we lose such ability.
+...Nhưng đó sẽ là không khôn ngoan. Trong tương lai, chúng ta có thể cần mở rộng một hàm, làm điều gì đó khác với danh sách. Nếu chúng ta thay đổi `list`, thì chúng ta sẽ mất khả năng đó.
-Talking about good variable names, `list` here is the list itself. The first element of it. And it should remain like that. That's clear and reliable.
+Nói về tên biến tốt, `list` ở đây chính là danh sách. Yếu tố đầu tiên của nó. Và nó nên giữ nguyên như vậy. Điều đó rõ ràng và đáng tin cậy.
-From the other side, the role of `tmp` is exclusively a list traversal, like `i` in the `for` loop.
+Mặt khác, vai trò của `tmp` chỉ là duyệt danh sách, giống như `i` trong vòng lặp `for`.
-# Recursive solution
+# Giải pháp đệ quy
-The recursive variant of `printList(list)` follows a simple logic: to output a list we should output the current element `list`, then do the same for `list.next`:
+Biến thể đệ quy của `printList(list)` tuân theo logic đơn giản: để xuất danh sách, chúng ta nên xuất phần tử hiện tại `list`, sau đó thực hiện tương tự cho `list.next`:
```js run
let list = {
@@ -70,10 +70,10 @@ let list = {
function printList(list) {
- alert(list.value); // output the current item
+ alert(list.value); // xuất mục hiện tại
if (list.next) {
- printList(list.next); // do the same for the rest of the list
+ printList(list.next); // làm tương tự cho phần còn lại của danh sách
}
}
@@ -81,8 +81,8 @@ function printList(list) {
printList(list);
```
-Now what's better?
+Bây giờ cái nào tốt hơn?
-Technically, the loop is more effective. These two variants do the same, but the loop does not spend resources for nested function calls.
+Về mặt kỹ thuật, vòng lặp hiệu quả hơn. Hai biến thể này thực hiện tương tự, nhưng vòng lặp không dành tài nguyên cho các lệnh gọi hàm lồng nhau.
-From the other side, the recursive variant is shorter and sometimes easier to understand.
+Mặt khác, biến thể đệ quy ngắn hơn và đôi khi dễ hiểu hơn.
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
index 1076b952a..322262443 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
@@ -2,9 +2,9 @@ importance: 5
---
-# Output a single-linked list
+# Xuất danh sách liên kết đơn
-Let's say we have a single-linked list (as described in the chapter ):
+Giả sử chúng ta có một danh sách liên kết đơn (như được mô tả trong chương ):
```js
let list = {
@@ -22,8 +22,8 @@ let list = {
};
```
-Write a function `printList(list)` that outputs list items one-by-one.
+Viết một hàm `printList(list)` để xuất từng mục một trong danh sách.
-Make two variants of the solution: using a loop and using recursion.
+Thực hiện hai biến thể của giải pháp: sử dụng vòng lặp và sử dụng đệ quy.
-What's better: with recursion or without it?
+Điều gì tốt hơn: đệ quy hay không đệ quy?
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
index 4357ff208..c03507549 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
@@ -1,8 +1,8 @@
-# Using a recursion
+# Sử dụng đệ quy
-The recursive logic is a little bit tricky here.
+Logic đệ quy hơi rắc rối ở đây.
-We need to first output the rest of the list and *then* output the current one:
+Đầu tiên chúng ta cần xuất phần còn lại của danh sách và *sau đó* xuất danh sách hiện tại:
```js run
let list = {
@@ -31,13 +31,13 @@ function printReverseList(list) {
printReverseList(list);
```
-# Using a loop
+# Sử dụng một vòng lặp
-The loop variant is also a little bit more complicated then the direct output.
+Biến thể vòng lặp cũng phức tạp hơn một chút so với đầu ra trực tiếp.
-There is no way to get the last value in our `list`. We also can't "go back".
+Không có cách nào để lấy giá trị cuối cùng trong `danh sách` của chúng ta. Chúng ta cũng không thể "quay lại".
-So what we can do is to first go through the items in the direct order and remember them in an array, and then output what we remembered in the reverse order:
+Vì vậy, những gì chúng ta có thể làm là trước tiên xem qua các mục theo thứ tự trực tiếp và ghi nhớ chúng trong một array, sau đó xuất ra những gì chúng ta đã nhớ theo thứ tự ngược lại:
```js run
let list = {
@@ -71,4 +71,4 @@ function printReverseList(list) {
printReverseList(list);
```
-Please note that the recursive solution actually does exactly the same: it follows the list, remembers the items in the chain of nested calls (in the execution context stack), and then outputs them.
+Hãy lưu ý rằng giải pháp đệ quy thực sự hoạt động chính xác như vậy: nó tuân theo danh sách, ghi nhớ các mục trong chuỗi các lệnh gọi lồng nhau (trong ngăn xếp ngữ cảnh thực thi), sau đó xuất chúng.
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
index 81b1f3e33..f76b82165 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
@@ -2,8 +2,8 @@ importance: 5
---
-# Output a single-linked list in the reverse order
+# Xuất danh sách liên kết đơn theo thứ tự ngược lại
-Output a single-linked list from the previous task in the reverse order.
+Xuất danh sách liên kết đơn từ tác vụ trước đó theo thứ tự ngược lại.
-Make two solutions: using a loop and using a recursion.
+Thực hiện hai giải pháp: sử dụng vòng lặp và sử dụng đệ quy.
diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index 17fe5ea3e..6a593139a 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -1,18 +1,18 @@
-# Recursion and stack
+# Đệ quy và ngăn xếp
-Let's return to functions and study them more in-depth.
+Hãy quay lại các hàm và nghiên cứu chúng sâu hơn.
-Our first topic will be *recursion*.
+Chủ đề đầu tiên của chúng ta sẽ là *đệ quy*.
-If you are not new to programming, then it is probably familiar and you could skip this chapter.
+Nếu bạn không phải là người mới lập trình, thì nó có thể đã quen thuộc và bạn có thể bỏ qua chương này.
-Recursion is a programming pattern that is useful in situations when a task can be naturally split into several tasks of the same kind, but simpler. Or when a task can be simplified into an easy action plus a simpler variant of the same task. Or, as we'll see soon, to deal with certain data structures.
+Đệ quy là một mẫu lập trình hữu ích trong các tình huống khi một tác vụ có thể được chia thành nhiều tác vụ cùng loại nhưng đơn giản hơn. Hoặc khi một nhiệm vụ có thể được đơn giản hóa thành một hành động dễ dàng cộng với một biến thể đơn giản hơn của cùng một nhiệm vụ. Hoặc, như chúng ta sẽ sớm thấy, để xử lý các cấu trúc dữ liệu nhất định.
-When a function solves a task, in the process it can call many other functions. A partial case of this is when a function calls *itself*. That's called *recursion*.
+Khi một hàm giải quyết một nhiệm vụ, trong quá trình đó, nó có thể gọi nhiều hàm khác. Một phần trường hợp này là khi một hàm gọi *chính nó*. Cái đó được gọi là *đệ quy*.
-## Two ways of thinking
+## Hai cách suy nghĩ
-For something simple to start with -- let's write a function `pow(x, n)` that raises `x` to a natural power of `n`. In other words, multiplies `x` by itself `n` times.
+Để bắt đầu một cái gì đó đơn giản -- hãy viết một hàm `pow(x, n)` để nâng `x` lên lũy thừa tự nhiên của `n`. Nói cách khác, nhân `x` với chính nó `n` lần.
```js
pow(2, 2) = 4
@@ -20,15 +20,15 @@ pow(2, 3) = 8
pow(2, 4) = 16
```
-There are two ways to implement it.
+Có hai cách để thực hiện nó.
-1. Iterative thinking: the `for` loop:
+1. Tư duy lặp: vòng lặp `for`:
```js run
function pow(x, n) {
let result = 1;
- // multiply result by x n times in the loop
+ // nhân kết quả với x n lần trong vòng lặp
for (let i = 0; i < n; i++) {
result *= x;
}
@@ -39,7 +39,7 @@ There are two ways to implement it.
alert( pow(2, 3) ); // 8
```
-2. Recursive thinking: simplify the task and call self:
+2. Tư duy đệ quy: đơn giản hóa nhiệm vụ và tự gọi:
```js run
function pow(x, n) {
@@ -53,9 +53,9 @@ There are two ways to implement it.
alert( pow(2, 3) ); // 8
```
-Please note how the recursive variant is fundamentally different.
+Hãy lưu ý cách biến thể đệ quy khác nhau về cơ bản.
-When `pow(x, n)` is called, the execution splits into two branches:
+Khi `pow(x, n)` được gọi, quá trình thực thi sẽ chia thành hai nhánh:
```js
if n==1 = x
@@ -65,27 +65,27 @@ pow(x, n) =
else = x * pow(x, n - 1)
```
-1. If `n == 1`, then everything is trivial. It is called *the base* of recursion, because it immediately produces the obvious result: `pow(x, 1)` equals `x`.
-2. Otherwise, we can represent `pow(x, n)` as `x * pow(x, n - 1)`. In maths, one would write xn = x * xn-1. This is called *a recursive step*: we transform the task into a simpler action (multiplication by `x`) and a simpler call of the same task (`pow` with lower `n`). Next steps simplify it further and further until `n` reaches `1`.
+1. Nếu `n == 1`, thì mọi thứ đều tầm thường. Nó được gọi là *cơ sở* của đệ quy, bởi vì nó ngay lập tức tạo ra kết quả hiển nhiên: `pow(x, 1)` bằng `x`.
+2. Mặt khác, chúng ta có thể biểu diễn `pow(x, n)` dưới dạng `x * pow(x, n - 1)`. Trong toán học, người ta sẽ viết xn = x * xn-1. Đây được gọi là *bước đệ quy*: chúng ta chuyển đổi tác vụ thành một tác vụ đơn giản hơn (nhân với `x`) và một lệnh gọi đơn giản hơn cho cùng một tác vụ (`pow` với `n` thấp hơn). Các bước tiếp theo sẽ ngày càng đơn giản hóa nó cho đến khi `n` đạt đến `1`.
-We can also say that `pow` *recursively calls itself* till `n == 1`.
+Chúng ta cũng có thể nói rằng `pow` *gọi chính nó một cách đệ quy* cho đến khi `n == 1`.
-For example, to calculate `pow(2, 4)` the recursive variant does these steps:
+Ví dụ: để tính `pow(2, 4)` biến thể đệ quy thực hiện các bước sau:
1. `pow(2, 4) = 2 * pow(2, 3)`
2. `pow(2, 3) = 2 * pow(2, 2)`
3. `pow(2, 2) = 2 * pow(2, 1)`
4. `pow(2, 1) = 2`
-So, the recursion reduces a function call to a simpler one, and then -- to even more simpler, and so on, until the result becomes obvious.
+Vì vậy, đệ quy rút gọn lời gọi hàm thành một lời gọi hàm đơn giản hơn, và sau đó -- đơn giản hơn nữa, v.v., cho đến khi kết quả trở nên rõ ràng.
-````smart header="Recursion is usually shorter"
-A recursive solution is usually shorter than an iterative one.
+````smart header="Đệ quy thường ngắn hơn"
+Giải pháp đệ quy thường ngắn hơn giải pháp lặp lại.
-Here we can rewrite the same using the conditional operator `?` instead of `if` to make `pow(x, n)` more terse and still very readable:
+Ở đây chúng ta có thể viết lại tương tự bằng cách sử dụng toán tử điều kiện `?` thay vì `if` để làm cho `pow(x, n)` ngắn gọn hơn và vẫn rất dễ đọc:
```js run
function pow(x, n) {
@@ -94,45 +94,45 @@ function pow(x, n) {
```
````
-The maximal number of nested calls (including the first one) is called *recursion depth*. In our case, it will be exactly `n`.
+Số lượng cuộc gọi lồng nhau tối đa (bao gồm cả cuộc gọi đầu tiên) được gọi là *độ sâu đệ quy*. Trong trường hợp của chúng ta, nó sẽ chính xác là `n`.
-The maximal recursion depth is limited by JavaScript engine. We can rely on it being 10000, some engines allow more, but 100000 is probably out of limit for the majority of them. There are automatic optimizations that help alleviate this ("tail calls optimizations"), but they are not yet supported everywhere and work only in simple cases.
+Độ sâu đệ quy tối đa bị giới hạn bởi JavaScript engine. Chúng ta có thể dựa vào nó là 10000, một số engine cho phép nhiều hơn, nhưng 100000 có thể vượt quá giới hạn đối với phần lớn trong số chúng. Có các tối ưu hóa tự động giúp giảm bớt điều này ("tối ưu hóa cuộc gọi đuôi"), nhưng chúng chưa được hỗ trợ ở mọi nơi và chỉ hoạt động trong các trường hợp đơn giản.
-That limits the application of recursion, but it still remains very wide. There are many tasks where recursive way of thinking gives simpler code, easier to maintain.
+Điều đó hạn chế việc áp dụng đệ quy, nhưng nó vẫn còn rất rộng. Có nhiều tác vụ mà cách suy nghĩ đệ quy cho mã đơn giản hơn, dễ bảo trì hơn.
-## The execution context and stack
+## Bối cảnh thực thi và ngăn xếp
-Now let's examine how recursive calls work. For that we'll look under the hood of functions.
+Bây giờ hãy kiểm tra xem các cuộc gọi đệ quy hoạt động như thế nào. Đối với điều đó, chúng ta sẽ xem xét các hàm.
-The information about the process of execution of a running function is stored in its *execution context*.
+Thông tin về quá trình thực hiện một hàm đang chạy được lưu trữ trong *bối cảnh thực thi* của nó.
-The [execution context](https://tc39.github.io/ecma262/#sec-execution-contexts) is an internal data structure that contains details about the execution of a function: where the control flow is now, the current variables, the value of `this` (we don't use it here) and few other internal details.
+[Bối cảnh thực thi](https://tc39.github.io/ecma262/#sec-execution-contexts) là một cấu trúc dữ liệu nội bộ chứa thông tin chi tiết về việc thực thi một hàm: vị trí hiện tại của luồng điều khiển, các biến hiện tại , giá trị của `this` (chúng ta không sử dụng nó ở đây) và một số chi tiết nội bộ khác.
-One function call has exactly one execution context associated with it.
+Một lệnh gọi hàm có chính xác một ngữ cảnh thực thi được liên kết với nó.
-When a function makes a nested call, the following happens:
+Khi một hàm thực hiện một cuộc gọi lồng nhau, điều sau đây sẽ xảy ra:
-- The current function is paused.
-- The execution context associated with it is remembered in a special data structure called *execution context stack*.
-- The nested call executes.
-- After it ends, the old execution context is retrieved from the stack, and the outer function is resumed from where it stopped.
+- Hàm hiện tại đang tạm dừng.
+- Bối cảnh thực thi được liên kết với nó được ghi nhớ trong một cấu trúc dữ liệu đặc biệt được gọi là *ngăn xếp ngữ cảnh thực thi*.
+- Cuộc gọi lồng nhau thực hiện.
+- Sau khi nó kết thúc, bối cảnh thực thi cũ được lấy ra từ ngăn xếp và hàm bên ngoài được tiếp tục từ nơi nó dừng lại.
-Let's see what happens during the `pow(2, 3)` call.
+Hãy xem điều gì xảy ra trong lệnh gọi `pow(2, 3)`.
### pow(2, 3)
-In the beginning of the call `pow(2, 3)` the execution context will store variables: `x = 2, n = 3`, the execution flow is at line `1` of the function.
+Khi bắt đầu gọi `pow(2, 3)` ngữ cảnh thực thi sẽ lưu các biến: `x = 2, n = 3`, luồng thực thi nằm ở dòng `1` của hàm.
-We can sketch it as:
+Chúng ta có thể phác họa nó như sau:
- Context: { x: 2, n: 3, at line 1 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 1 }pow(2, 3)
-That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`:
+Đó là khi hàm bắt đầu thực thi. Điều kiện `n == 1` là sai, vì vậy luồng tiếp tục vào nhánh thứ hai của `if`:
```js run
function pow(x, n) {
@@ -149,76 +149,76 @@ alert( pow(2, 3) );
```
-The variables are same, but the line changes, so the context is now:
+Các biến giống nhau, nhưng dòng thay đổi, vì vậy ngữ cảnh bây giờ là:
- Context: { x: 2, n: 3, at line 5 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 5 }pow(2, 3)
-To calculate `x * pow(x, n - 1)`, we need to make a subcall of `pow` with new arguments `pow(2, 2)`.
+Để tính `x * pow(x, n - 1)`, chúng ta cần thực hiện lệnh gọi con của `pow` với các đối số mới `pow(2, 2)`.
### pow(2, 2)
-To do a nested call, JavaScript remembers the current execution context in the *execution context stack*.
+Để thực hiện lệnh gọi lồng nhau, JavaScript ghi nhớ ngữ cảnh thực thi hiện tại trong *ngăn xếp ngữ cảnh thực thi*.
-Here we call the same function `pow`, but it absolutely doesn't matter. The process is the same for all functions:
+Ở đây chúng ta gọi hàm tương tự là `pow`, nhưng nó hoàn toàn không thành vấn đề. Quá trình này giống nhau đối với tất cả các hàm:
-1. The current context is "remembered" on top of the stack.
-2. The new context is created for the subcall.
-3. When the subcall is finished -- the previous context is popped from the stack, and its execution continues.
+1. Bối cảnh hiện tại được "ghi nhớ" trên đầu ngăn xếp.
+2. Bối cảnh mới được tạo cho cuộc gọi phụ.
+3. Khi cuộc gọi con kết thúc -- bối cảnh trước đó được bật ra khỏi ngăn xếp và quá trình thực thi của nó tiếp tục.
-Here's the context stack when we entered the subcall `pow(2, 2)`:
+Đây là ngăn xếp ngữ cảnh khi chúng ta nhập lệnh gọi phụ `pow(2, 2)`:
- Context: { x: 2, n: 2, at line 1 }
+ Ngữ cảnh: { x: 2, n: 2, ở dòng 1 }pow(2, 2)
- Context: { x: 2, n: 3, at line 5 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 5 }pow(2, 3)
-The new current execution context is on top (and bold), and previous remembered contexts are below.
+Bối cảnh thực thi hiện tại mới ở trên cùng (và được in đậm) và các bối cảnh được ghi nhớ trước đó ở bên dưới.
-When we finish the subcall -- it is easy to resume the previous context, because it keeps both variables and the exact place of the code where it stopped.
+Khi chúng ta kết thúc cuộc gọi phụ -- thật dễ dàng để tiếp tục ngữ cảnh trước đó, bởi vì nó giữ cả hai biến và vị trí chính xác của mã nơi nó dừng lại.
```smart
-Here in the picture we use the word "line", as in our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`.
+Ở đây trong hình, chúng ta sử dụng từ "dòng", vì trong ví dụ của chúng ta chỉ có một lệnh gọi phụ trong dòng, nhưng nói chung một dòng mã có thể chứa nhiều lệnh gọi phụ, như `pow(…) + pow(…) + somethingElse(… )`.
-So it would be more precise to say that the execution resumes "immediately after the subcall".
+Vì vậy, sẽ chính xác hơn khi nói rằng quá trình thực thi sẽ tiếp tục "ngay sau cuộc gọi phụ".
```
### pow(2, 1)
-The process repeats: a new subcall is made at line `5`, now with arguments `x=2`, `n=1`.
+Quá trình lặp lại: một cuộc gọi phụ mới được thực hiện tại dòng `5`, bây giờ với các đối số `x=2`, `n=1`.
-A new execution context is created, the previous one is pushed on top of the stack:
+Một bối cảnh thực thi mới được tạo, bối cảnh trước đó được đẩy lên trên cùng của ngăn xếp:
- Context: { x: 2, n: 1, at line 1 }
+ Ngữ cảnh: { x: 2, n: 1, ở dòng 1 }pow(2, 1)
- Context: { x: 2, n: 2, at line 5 }
+ Ngữ cảnh: { x: 2, n: 2, ở dòng 5 }pow(2, 2)
- Context: { x: 2, n: 3, at line 5 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 5 }pow(2, 3)
-There are 2 old contexts now and 1 currently running for `pow(2, 1)`.
+Hiện có 2 ngữ cảnh cũ và 1 ngữ cảnh hiện đang chạy cho `pow(2, 1)`.
-### The exit
+### Lối thoát
-During the execution of `pow(2, 1)`, unlike before, the condition `n == 1` is truthy, so the first branch of `if` works:
+Trong quá trình thực thi `pow(2, 1)`, không giống như trước đây, điều kiện `n == 1` là đúng, vì vậy nhánh đầu tiên của `if` hoạt động:
```js
function pow(x, n) {
@@ -232,42 +232,42 @@ function pow(x, n) {
}
```
-There are no more nested calls, so the function finishes, returning `2`.
+Không còn lệnh gọi lồng nhau nào nữa, vì vậy hàm kết thúc, trả về `2`.
-As the function finishes, its execution context is not needed anymore, so it's removed from the memory. The previous one is restored off the top of the stack:
+Khi hàm kết thúc, bối cảnh thực thi của nó không còn cần thiết nữa, do đó, nó bị xóa khỏi bộ nhớ. Cái trước đó được khôi phục khỏi đầu ngăn xếp:
- Context: { x: 2, n: 2, at line 5 }
+ Ngữ cảnh: { x: 2, n: 2, ở dòng 5 }pow(2, 2)
- Context: { x: 2, n: 3, at line 5 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 5 }pow(2, 3)
-The execution of `pow(2, 2)` is resumed. It has the result of the subcall `pow(2, 1)`, so it also can finish the evaluation of `x * pow(x, n - 1)`, returning `4`.
+Quá trình thực thi `pow(2, 2)` được tiếp tục. Nó có kết quả của lệnh gọi phụ `pow(2, 1)`, vì vậy nó cũng có thể kết thúc việc đánh giá `x * pow(x, n - 1)`, trả về `4`.
-Then the previous context is restored:
+Sau đó, bối cảnh trước đó được khôi phục:
- Context: { x: 2, n: 3, at line 5 }
+ Ngữ cảnh: { x: 2, n: 3, ở dòng 5 }pow(2, 3)
-When it finishes, we have a result of `pow(2, 3) = 8`.
+Khi nó kết thúc, chúng ta có kết quả là `pow(2, 3) = 8`.
-The recursion depth in this case was: **3**.
+Độ sâu đệ quy trong trường hợp này là: **3**.
-As we can see from the illustrations above, recursion depth equals the maximal number of context in the stack.
+Như chúng ta có thể thấy từ các hình minh họa ở trên, độ sâu đệ quy bằng với số lượng ngữ cảnh tối đa trong ngăn xếp.
-Note the memory requirements. Contexts take memory. In our case, raising to the power of `n` actually requires the memory for `n` contexts, for all lower values of `n`.
+Lưu ý các yêu cầu bộ nhớ. Bối cảnh chiếm bộ nhớ. Trong trường hợp của chúng ta, việc nâng lên lũy thừa của `n` thực sự yêu cầu bộ nhớ cho ngữ cảnh `n`, cho tất cả các giá trị thấp hơn của `n`.
-A loop-based algorithm is more memory-saving:
+Thuật toán dựa trên vòng lặp tiết kiệm bộ nhớ hơn:
```js
function pow(x, n) {
@@ -281,19 +281,19 @@ function pow(x, n) {
}
```
-The iterative `pow` uses a single context changing `i` and `result` in the process. Its memory requirements are small, fixed and do not depend on `n`.
+`pow` lặp lại sử dụng một ngữ cảnh duy nhất thay đổi `i` và `kết quả` trong quy trình. Yêu cầu bộ nhớ của nó nhỏ, cố định và không phụ thuộc vào `n`.
-**Any recursion can be rewritten as a loop. The loop variant usually can be made more effective.**
+**Bất kỳ đệ quy nào cũng có thể được viết lại dưới dạng vòng lặp. Biến thể vòng lặp thường có thể được thực hiện hiệu quả hơn.**
-...But sometimes the rewrite is non-trivial, especially when function uses different recursive subcalls depending on conditions and merges their results or when the branching is more intricate. And the optimization may be unneeded and totally not worth the efforts.
+...Nhưng đôi khi việc viết lại không hề nhỏ, đặc biệt là khi hàm sử dụng các cuộc gọi con đệ quy khác nhau tùy thuộc vào điều kiện và hợp nhất kết quả của chúng hoặc khi việc phân nhánh phức tạp hơn. Và việc tối ưu hóa có thể không cần thiết và hoàn toàn không xứng đáng với những nỗ lực.
-Recursion can give a shorter code, easier to understand and support. Optimizations are not required in every place, mostly we need a good code, that's why it's used.
+Đệ quy có thể đưa ra đoạn mã ngắn hơn, dễ hiểu và dễ hỗ trợ hơn. Tối ưu hóa không phải bắt buộc ở mọi nơi, chủ yếu là chúng ta cần một mã tốt, đó là lý do tại sao nó được sử dụng.
-## Recursive traversals
+## Truyền tải đệ quy
-Another great application of the recursion is a recursive traversal.
+Một ứng dụng tuyệt vời khác của đệ quy là truyền tải đệ quy.
-Imagine, we have a company. The staff structure can be presented as an object:
+Hãy tưởng tượng, chúng ta có một công ty. Cấu trúc nhân viên có thể được trình bày dưới dạng một đối tượng:
```js
let company = {
@@ -322,34 +322,34 @@ let company = {
};
```
-In other words, a company has departments.
+Nói cách khác, một công ty có các phòng ban.
-- A department may have an array of staff. For instance, `sales` department has 2 employees: John and Alice.
-- Or a department may split into subdepartments, like `development` has two branches: `sites` and `internals`. Each of them has their own staff.
-- It is also possible that when a subdepartment grows, it divides into subsubdepartments (or teams).
+- Một bộ phận có thể có một array nhân viên. Chẳng hạn, bộ phận `sales` có 2 nhân viên: John và Alice.
+- Hoặc một bộ phận có thể chia thành các bộ phận nhỏ, như `development` có hai nhánh: `sites` và `internal`. Mỗi người trong số họ có nhân viên riêng của họ.
+- Cũng có thể khi một chi cục lớn lên thì chia thành các chi cục (hoặc tổ).
- For instance, the `sites` department in the future may be split into teams for `siteA` and `siteB`. And they, potentially, can split even more. That's not on the picture, just something to have in mind.
+ Chẳng hạn, bộ phận `sites` trong tương lai có thể được chia thành các nhóm cho `siteA` và `siteB`. Và họ, có khả năng, có thể chia nhiều hơn nữa. Đó không phải là hình ảnh, chỉ là một cái gì đó để có trong tâm trí.
-Now let's say we want a function to get the sum of all salaries. How can we do that?
+Bây giờ, giả sử chúng ta muốn một hàm lấy tổng của tất cả các mức lương. Làm thế nào chúng ta có thể làm điều đó?
-An iterative approach is not easy, because the structure is not simple. The first idea may be to make a `for` loop over `company` with nested subloop over 1st level departments. But then we need more nested subloops to iterate over the staff in 2nd level departments like `sites`... And then another subloop inside those for 3rd level departments that might appear in the future? If we put 3-4 nested subloops in the code to traverse a single object, it becomes rather ugly.
+Một cách tiếp cận lặp đi lặp lại là không dễ dàng, bởi vì cấu trúc không đơn giản. Ý tưởng đầu tiên có thể là tạo vòng lặp `for` trên `company` với vòng lặp con lồng nhau trên các phòng ban cấp 1. Nhưng sau đó, chúng ta cần nhiều vòng lặp con lồng nhau hơn để lặp lại nhân viên ở các phòng ban cấp 2 như `sites`... Và sau đó, một vòng lặp con khác bên trong các vòng lặp con đó dành cho các phòng ban cấp 3 có thể xuất hiện trong tương lai? Nếu chúng ta đặt 3-4 vòng lặp con lồng nhau trong mã để duyệt qua một đối tượng, nó sẽ trở nên khá xấu.
-Let's try recursion.
+Hãy thử đệ quy.
-As we can see, when our function gets a department to sum, there are two possible cases:
+Như chúng ta có thể thấy, khi hàm của chúng ta tính tổng một bộ phận, có hai trường hợp có thể xảy ra:
-1. Either it's a "simple" department with an *array* of people -- then we can sum the salaries in a simple loop.
-2. Or it's *an object* with `N` subdepartments -- then we can make `N` recursive calls to get the sum for each of the subdeps and combine the results.
+1. Hoặc đó là một bộ phận "đơn giản" với *array* người -- thì chúng ta có thể tính tổng tiền lương trong một vòng lặp đơn giản.
+2. Hoặc đó là *một đối tượng* có `N` bộ phận con -- khi đó chúng ta có thể thực hiện lệnh gọi đệ quy `N` để lấy tổng cho từng bộ phận con và kết hợp các kết quả.
-The 1st case is the base of recursion, the trivial case, when we get an array.
+Trường hợp đầu tiên là cơ sở của đệ quy, trường hợp tầm thường, khi chúng ta nhận được một array.
-The 2nd case when we get an object is the recursive step. A complex task is split into subtasks for smaller departments. They may in turn split again, but sooner or later the split will finish at (1).
+Trường hợp thứ 2 khi chúng ta lấy một đối tượng là bước đệ quy. Một nhiệm vụ phức tạp được chia thành các nhiệm vụ con cho các bộ phận nhỏ hơn. Họ có thể lần lượt chia tách một lần nữa, nhưng sớm hay muộn sự phân chia sẽ kết thúc ở (1).
-The algorithm is probably even easier to read from the code:
+Thuật toán có lẽ còn dễ đọc hơn từ mã:
```js run
-let company = { // the same object, compressed for brevity
+let company = { // cùng một đối tượng, được nén cho ngắn gọn
sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 1600 }],
development: {
sites: [{name: 'Peter', salary: 2000}, {name: 'Alex', salary: 1800 }],
@@ -357,15 +357,15 @@ let company = { // the same object, compressed for brevity
}
};
-// The function to do the job
+// Hàm thực hiện công việc
*!*
function sumSalaries(department) {
- if (Array.isArray(department)) { // case (1)
- return department.reduce((prev, current) => prev + current.salary, 0); // sum the array
+ if (Array.isArray(department)) { // trường hợp (1)
+ return department.reduce((prev, current) => prev + current.salary, 0); // tính tổng array
} else { // case (2)
let sum = 0;
for (let subdep of Object.values(department)) {
- sum += sumSalaries(subdep); // recursively call for subdepartments, sum the results
+ sum += sumSalaries(subdep); // gọi đệ quy các phân khu, tính tổng kết quả
}
return sum;
}
@@ -375,62 +375,62 @@ function sumSalaries(department) {
alert(sumSalaries(company)); // 7700
```
-The code is short and easy to understand (hopefully?). That's the power of recursion. It also works for any level of subdepartment nesting.
+Mã ngắn và dễ hiểu (mong rằng?). Đó là sức mạnh của đệ quy. Nó cũng hoạt động đối với bất kỳ cấp độ nào của việc lồng ghép các bộ phận phụ.
-Here's the diagram of calls:
+Đây là sơ đồ của các cuộc gọi:
-We can easily see the principle: for an object `{...}` subcalls are made, while arrays `[...]` are the "leaves" of the recursion tree, they give immediate result.
+Ta có thể dễ dàng nhận thấy nguyên tắc: đối với một đối tượng `{...}` thì thực hiện gọi con, còn mảng `[...]` là các "lá" của cây đệ quy thì cho kết quả ngay.
-Note that the code uses smart features that we've covered before:
+Lưu ý rằng mã này sử dụng các tính năng thông minh mà chúng ta đã đề cập trước đây:
-- Method `arr.reduce` explained in the chapter to get the sum of the array.
-- Loop `for(val of Object.values(obj))` to iterate over object values: `Object.values` returns an array of them.
+- Phương thức `arr.reduce` được giải thích trong chương để lấy tổng của array.
+- Vòng lặp `for(val of Object.values(obj))` để lặp qua các giá trị đối tượng: `Object.values` trả về một array của chúng.
-## Recursive structures
+## Cấu trúc đệ quy
-A recursive (recursively-defined) data structure is a structure that replicates itself in parts.
+Cấu trúc dữ liệu đệ quy (được xác định đệ quy) là cấu trúc sao chép chính nó thành từng phần.
-We've just seen it in the example of a company structure above.
+Chúng ta vừa thấy nó trong ví dụ về cấu trúc công ty ở trên.
-A company *department* is:
-- Either an array of people.
-- Or an object with *departments*.
+Một *bộ phận* của công ty là:
+- Hoặc là một array người.
+- Hoặc một đối tượng có *các phòng ban*.
-For web-developers there are much better-known examples: HTML and XML documents.
+Đối với các nhà phát triển web, có nhiều ví dụ nổi tiếng hơn: tài liệu HTML và XML.
-In the HTML document, an *HTML-tag* may contain a list of:
-- Text pieces.
-- HTML-comments.
-- Other *HTML-tags* (that in turn may contain text pieces/comments or other tags etc).
+Trong tài liệu HTML, một *HTML-tag* có thể chứa danh sách:
+- Đoạn văn bản.
+- Nhận xét HTML.
+- *Thẻ HTML* khác (có thể chứa các đoạn văn bản/nhận xét hoặc các thẻ khác, v.v.).
-That's once again a recursive definition.
+Đó là một lần nữa một định nghĩa đệ quy.
-For better understanding, we'll cover one more recursive structure named "Linked list" that might be a better alternative for arrays in some cases.
+Để hiểu rõ hơn, chúng ta sẽ đề cập đến một cấu trúc đệ quy khác có tên là "Danh sách được liên kết" có thể là một giải pháp thay thế tốt hơn cho array trong một số trường hợp.
-### Linked list
+### Danh sách liên kết
-Imagine, we want to store an ordered list of objects.
+Hãy tưởng tượng, chúng ta muốn lưu trữ một danh sách các đối tượng được sắp xếp theo thứ tự.
-The natural choice would be an array:
+Sự lựa chọn tự nhiên sẽ là một array:
```js
let arr = [obj1, obj2, obj3];
```
-...But there's a problem with arrays. The "delete element" and "insert element" operations are expensive. For instance, `arr.unshift(obj)` operation has to renumber all elements to make room for a new `obj`, and if the array is big, it takes time. Same with `arr.shift()`.
+...Nhưng có một vấn đề với array. Thao tác "xóa phần tử" và "chèn phần tử" rất tốn kém. Chẳng hạn, thao tác `arr.unshift(obj)` phải đánh số lại tất cả các phần tử để nhường chỗ cho một `obj` mới và nếu array lớn thì sẽ mất thời gian. Tương tự với `arr.shift()`.
-The only structural modifications that do not require mass-renumbering are those that operate with the end of array: `arr.push/pop`. So an array can be quite slow for big queues, when we have to work with the beginning.
+Các sửa đổi cấu trúc duy nhất không yêu cầu đánh số lại hàng loạt là những sửa đổi hoạt động với phần cuối của array: `arr.push/pop`. Vì vậy, một array có thể khá chậm đối với các hàng đợi lớn, khi chúng ta phải làm việc từ đầu.
-Alternatively, if we really need fast insertion/deletion, we can choose another data structure called a [linked list](https://en.wikipedia.org/wiki/Linked_list).
+Ngoài ra, nếu chúng ta thực sự cần chèn/xóa nhanh, chúng ta có thể chọn một cấu trúc dữ liệu khác được gọi là [danh sách liên kết](https://vi.wikipedia.org/wiki/Danh_s%C3%A1ch_li%C3%AAn_k%E1%BA%BFt).
-The *linked list element* is recursively defined as an object with:
-- `value`.
-- `next` property referencing the next *linked list element* or `null` if that's the end.
+*Phần tử danh sách được liên kết* được định nghĩa đệ quy là một đối tượng có:
+- `giá trị`.
+- Thuộc tính `next` tham chiếu đến *phần tử danh sách được liên kết* tiếp theo hoặc `null` nếu đó là phần cuối.
-For instance:
+Ví dụ:
```js
let list = {
@@ -448,11 +448,11 @@ let list = {
};
```
-Graphical representation of the list:
+Biểu diễn đồ họa của danh sách:
-An alternative code for creation:
+Một mã thay thế để tạo:
```js no-beautify
let list = { value: 1 };
@@ -462,9 +462,9 @@ list.next.next.next = { value: 4 };
list.next.next.next.next = null;
```
-Here we can even more clearly see that there are multiple objects, each one has the `value` and `next` pointing to the neighbour. The `list` variable is the first object in the chain, so following `next` pointers from it we can reach any element.
+Ở đây, chúng ta thậm chí có thể thấy rõ hơn rằng có nhiều đối tượng, mỗi đối tượng có `value` và `next` trỏ đến hàng xóm. Biến `list` là đối tượng đầu tiên trong chuỗi, do đó, theo các con trỏ `next` từ nó, chúng ta có thể tiếp cận bất kỳ phần tử nào.
-The list can be easily split into multiple parts and later joined back:
+Danh sách có thể dễ dàng chia thành nhiều phần và sau đó nối lại:
```js
let secondList = list.next.next;
@@ -473,15 +473,15 @@ list.next.next = null;
-To join:
+Để nối:
```js
list.next.next = secondList;
```
-And surely we can insert or remove items in any place.
+Và chắc chắn chúng ta có thể chèn hoặc xóa các mục ở bất kỳ đâu.
-For instance, to prepend a new value, we need to update the head of the list:
+Chẳng hạn, để thêm vào trước một giá trị mới, chúng ta cần cập nhật phần đầu của danh sách:
```js
let list = { value: 1 };
@@ -497,7 +497,7 @@ list = { value: "new item", next: list };
-To remove a value from the middle, change `next` of the previous one:
+Để xóa một giá trị ở giữa, hãy thay đổi `next` của giá trị trước đó:
```js
list.next = list.next.next;
@@ -505,38 +505,38 @@ list.next = list.next.next;
-We made `list.next` jump over `1` to value `2`. The value `1` is now excluded from the chain. If it's not stored anywhere else, it will be automatically removed from the memory.
+Chúng ta đã thực hiện chuyển `list.next` từ `1` sang giá trị `2`. Giá trị `1` hiện đã bị loại trừ khỏi chuỗi. Nếu nó không được lưu trữ ở bất kỳ nơi nào khác, nó sẽ tự động bị xóa khỏi bộ nhớ.
-Unlike arrays, there's no mass-renumbering, we can easily rearrange elements.
+Không giống như array, không cần đánh số lại hàng loạt, chúng ta có thể dễ dàng sắp xếp lại các phần tử.
-Naturally, lists are not always better than arrays. Otherwise everyone would use only lists.
+Đương nhiên, danh sách không phải lúc nào cũng tốt hơn array. Nếu không, mọi người sẽ chỉ sử dụng danh sách.
-The main drawback is that we can't easily access an element by its number. In an array that's easy: `arr[n]` is a direct reference. But in the list we need to start from the first item and go `next` `N` times to get the Nth element.
+Hạn chế chính là chúng ta không thể dễ dàng truy cập một phần tử bằng số của nó. Trong một array thì dễ: `arr[n]` là một tham chiếu trực tiếp. Nhưng trong danh sách, chúng ta cần bắt đầu từ mục đầu tiên và đi `next` `N` lần để lấy phần tử thứ N.
-...But we don't always need such operations. For instance, when we need a queue or even a [deque](https://en.wikipedia.org/wiki/Double-ended_queue) -- the ordered structure that must allow very fast adding/removing elements from both ends, but access to its middle is not needed.
+...Nhưng không phải lúc nào chúng ta cũng cần những thao tác như vậy. Chẳng hạn, khi chúng ta cần một hàng đợi hoặc thậm chí một [deque](https://en.wikipedia.org/wiki/Double-ended_queue) -- cấu trúc được sắp xếp phải cho phép thêm/xóa các phần tử ở cả hai đầu rất nhanh, nhưng truy cập vào giữa của nó là không cần thiết.
-Lists can be enhanced:
-- We can add property `prev` in addition to `next` to reference the previous element, to move back easily.
-- We can also add a variable named `tail` referencing the last element of the list (and update it when adding/removing elements from the end).
-- ...The data structure may vary according to our needs.
+Danh sách có thể được nâng cao:
+- Chúng ta có thể thêm thuộc tính `prev` ngoài `next` để tham chiếu phần tử trước đó, để di chuyển trở lại dễ dàng.
+- Chúng ta cũng có thể thêm một biến có tên `tail` tham chiếu đến phần tử cuối cùng của danh sách (và cập nhật nó khi thêm/bớt các phần tử ở cuối danh sách).
+- ...Cấu trúc dữ liệu có thể thay đổi tùy theo nhu cầu của chúng ta.
-## Summary
+## Tóm tắt
-Terms:
-- *Recursion* is a programming term that means calling a function from itself. Recursive functions can be used to solve tasks in elegant ways.
+Thuật ngữ:
+- *Đệ quy* là một thuật ngữ lập trình có nghĩa là gọi một hàm từ chính nó. Các hàm đệ quy có thể được sử dụng để giải quyết các tác vụ theo những cách tao nhã.
- When a function calls itself, that's called a *recursion step*. The *basis* of recursion is function arguments that make the task so simple that the function does not make further calls.
+ Khi một hàm gọi chính nó, đó được gọi là *bước đệ quy*. *Cơ sở* của đệ quy là các đối số hàm làm cho tác vụ trở nên đơn giản đến mức hàm không thực hiện thêm lệnh gọi nào nữa.
-- A [recursively-defined](https://en.wikipedia.org/wiki/Recursive_data_type) data structure is a data structure that can be defined using itself.
+- Cấu trúc dữ liệu [được xác định đệ quy](https://en.wikipedia.org/wiki/Recursive_data_type) là cấu trúc dữ liệu có thể được xác định bằng chính nó.
- For instance, the linked list can be defined as a data structure consisting of an object referencing a list (or null).
+ Chẳng hạn, danh sách được liên kết có thể được định nghĩa là cấu trúc dữ liệu bao gồm một đối tượng tham chiếu đến một danh sách (hoặc null).
```js
list = { value, next -> list }
```
- Trees like HTML elements tree or the department tree from this chapter are also naturally recursive: they branch and every branch can have other branches.
+ Các cây như cây phần tử HTML hoặc cây bộ phận trong chương này cũng có tính đệ quy tự nhiên: chúng phân nhánh và mỗi nhánh có thể có các nhánh khác.
- Recursive functions can be used to walk them as we've seen in the `sumSalary` example.
+ Các hàm đệ quy có thể được sử dụng để điều khiển chúng như chúng ta đã thấy trong ví dụ `sumSalary`.
-Any recursive function can be rewritten into an iterative one. And that's sometimes required to optimize stuff. But for many tasks a recursive solution is fast enough and easier to write and support.
+Bất kỳ hàm đệ quy nào cũng có thể được viết lại thành một hàm lặp. Và điều đó đôi khi cần thiết để tối ưu hóa nội dung. Nhưng đối với nhiều tác vụ, một giải pháp đệ quy đủ nhanh và dễ dàng hơn để viết và hỗ trợ.
diff --git a/1-js/06-advanced-functions/01-recursion/recursion-pow.svg b/1-js/06-advanced-functions/01-recursion/recursion-pow.svg
index 2b970a04a..cee0e28e5 100644
--- a/1-js/06-advanced-functions/01-recursion/recursion-pow.svg
+++ b/1-js/06-advanced-functions/01-recursion/recursion-pow.svg
@@ -1 +1 @@
-
\ No newline at end of file
+