Arrays (#63)

* draft: article 50%

* feat: translation of Arrays

* Update 1-js/05-data-types/04-array/2-create-array/task.md

Co-Authored-By: Jason Huang <[email protected]>

* Apply suggestions from code review

Co-Authored-By: Jason Huang <[email protected]>

Author: lenchen1112

1-js/05-data-types/04-array/1-item-value/solution.md

@@ -1,5 +1,4 @@
-The result is `4`:
-
+結果是 `4`：
 
 ```js run
 let fruits = ["Apples", "Pear", "Orange"];
@@ -13,5 +12,5 @@ alert( fruits.length ); // 4
 */!*
 ```
 
-That's because arrays are objects. So both `shoppingCart` and `fruits` are the references to the same array.
+這是因為陣列是個物件，所以 `shoppingCart` 和 `fruits` 這兩者皆是對同一個陣列的參考。
 

1-js/05-data-types/04-array/1-item-value/task.md

@@ -2,18 +2,18 @@ importance: 3
 
 ---
 
-# Is array copied?
+# 陣列是否被複製？
 
-What is this code going to show?
+這段程式碼會顯示什麼？
 
 ```js
 let fruits = ["Apples", "Pear", "Orange"];
 
-// push a new value into the "copy"
+// push 一個新的值到 "copy" 內
 let shoppingCart = fruits;
 shoppingCart.push("Banana");
 
-// what's in fruits?
+// fruits 內會變成？
 alert( fruits.length ); // ?
 ```
 

1-js/05-data-types/04-array/10-maximal-subarray/solution.md

@@ -1,43 +1,43 @@
-# Slow solution
+# 慢的解法
 
-We can calculate all possible subsums.
+我們可以計算所有可能的子總和。
 
-The simplest way is to take every element and calculate sums of all subarrays starting from it.
+最簡單的方法是取出每個元素並計算所有由它開始的子陣列總和。
 
-For instance, for `[-1, 2, 3, -9, 11]`:
+舉個例，如 `[-1, 2, 3, -9, 11]`：
 
 ```js no-beautify
-// Starting from -1:
+// 由 -1 開始：
 -1
 -1 + 2
 -1 + 2 + 3
 -1 + 2 + 3 + (-9)
 -1 + 2 + 3 + (-9) + 11
 
-// Starting from 2:
+// 由 2 開始：
 2
 2 + 3
 2 + 3 + (-9)
 2 + 3 + (-9) + 11
 
-// Starting from 3:
+// 由 3 開始：
 3
 3 + (-9)
 3 + (-9) + 11
 
-// Starting from -9
+// 由 -9 開始：
 -9
 -9 + 11
 
-// Starting from 11
+// 由 11 開始：
 11
 ```
 
-The code is actually a nested loop: the external loop over array elements, and the internal counts subsums starting with the current element.
+該程式碼事實上會是個巢狀迴圈：外部迴圈遍歷陣列元素，而內部的則計數由目前元素開始的子總和。
 
 ```js run
 function getMaxSubSum(arr) {
-  let maxSum = 0; // if we take no elements, zero will be returned
+  let maxSum = 0; // 若我們沒拿到元素，回傳零
 
   for (let i = 0; i < arr.length; i++) {
     let sumFixedStart = 0;
@@ -57,25 +57,25 @@ alert( getMaxSubSum([1, 2, 3]) ); // 6
 alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100
 ```
 
-The solution has a time complexety of [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation). In other words, if we increase the array size 2 times, the algorithm will work 4 times longer.
+該解法的時間複雜度為 [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation) 。換句話說，若我們增加兩倍的陣列大小，該演算法就會多花四倍的時間。
 
-For big arrays (1000, 10000 or more items) such algorithms can lead to a serious sluggishness.
+對於大陣列來說（1000、10000 或更多項目）該演算法可能導致嚴重的延遲。
 
-# Fast solution
+# 快的解法
 
-Let's walk the array and keep the current partial sum of elements in the variable `s`. If `s` becomes negative at some point, then assign `s=0`. The maximum of all such `s` will be the answer.
+我們來遍歷陣列並在變數 `s` 中維持目前的元素部分總和。若 `s` 在某個時間點變成負值，那就指定 `s=0`。所有 `s` 中的最大值將會是答案。
 
-If the description is too vague, please see the code, it's short enough:
+若這個描述太模糊了，請直接看程式碼，夠簡短了：
 
 ```js run demo
 function getMaxSubSum(arr) {
   let maxSum = 0;
   let partialSum = 0;
 
-  for (let item of arr) { // for each item of arr
-    partialSum += item; // add it to partialSum
-    maxSum = Math.max(maxSum, partialSum); // remember the maximum
-    if (partialSum < 0) partialSum = 0; // zero if negative
+  for (let item of arr) { // for..of arr 的每個 item
+    partialSum += item; // 將它加入 partialSum
+    maxSum = Math.max(maxSum, partialSum); // 記住最大值
+    if (partialSum < 0) partialSum = 0; // 若為負則指定零
   }
 
   return maxSum;
@@ -89,6 +89,7 @@ alert( getMaxSubSum([1, 2, 3]) ); // 6
 alert( getMaxSubSum([-1, -2, -3]) ); // 0
 ```
 
-The algorithm requires exactly 1 array pass, so the time complexity is O(n).
+該演算法只需要遍歷陣列恰好一次，所以時間複雜度為 O(n)。
+
+你可以在這裡找到更多關於該演算法的細節資訊：[Maximum subarray problem](http://en.wikipedia.org/wiki/Maximum_subarray_problem)。若覺得對於它如何運作依然沒那麼明顯，請追蹤上述例子中的演算法來看看它是如何運作的，這麼做會比任何文字還要有用。
 
-You can find more detail information about the algorithm here: [Maximum subarray problem](http://en.wikipedia.org/wiki/Maximum_subarray_problem). If it's still not obvious why that works, then please trace the algorithm on the examples above, see how it works, that's better than any words.

1-js/05-data-types/04-array/10-maximal-subarray/task.md

@@ -2,29 +2,30 @@ importance: 2
 
 ---
 
-# A maximal subarray
+# 最大子陣列
 
-The input is an array of numbers, e.g. `arr = [1, -2, 3, 4, -9, 6]`.
+給予一個數值陣列，如 `arr = [1, -2, 3, 4, -9, 6]`。
 
-The task is: find the contiguous subarray of `arr` with the maximal sum of items.
+此課題是：找出 `arr` 的某個項目連續的子陣列，其項目加總為最大。
 
-Write the function `getMaxSubSum(arr)` that will return that sum.
+寫一個函式 `getMaxSubSum(arr)` 並回傳該加總值。
 
-For instance: 
+舉個例：
 
 ```js
-getMaxSubSum([-1, *!*2, 3*/!*, -9]) = 5 (the sum of highlighted items)
+getMaxSubSum([-1, *!*2, 3*/!*, -9]) = 5（被標示項目的加總）
 getMaxSubSum([*!*2, -1, 2, 3*/!*, -9]) = 6
 getMaxSubSum([-1, 2, 3, -9, *!*11*/!*]) = 11
 getMaxSubSum([-2, -1, *!*1, 2*/!*]) = 3
 getMaxSubSum([*!*100*/!*, -9, 2, -3, 5]) = 100
-getMaxSubSum([*!*1, 2, 3*/!*]) = 6 (take all)
+getMaxSubSum([*!*1, 2, 3*/!*]) = 6（全拿）
 ```
 
-If all items are negative, it means that we take none (the subarray is empty), so the sum is zero:
+若所有項目都是負值，代表我們不要拿任何東西（子陣列為空），所以加總為零：
 
 ```js
 getMaxSubSum([-1, -2, -3]) = 0
 ```
 
-Please try to think of a fast solution: [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation) or even O(n) if you can.
+請試著思考快速的解法：[O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation) ，或者可以的話甚至可達 O(n)。
+

1-js/05-data-types/04-array/2-create-array/solution.md

@@ -1,5 +1,4 @@
 
-
 ```js run
 let styles = ["Jazz", "Blues"];
 styles.push("Rock-n-Roll");

1-js/05-data-types/04-array/2-create-array/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Array operations.
+# 陣列操作
 
-Let's try 5 array operations.
+來試試 5 個陣列操作吧。
 
-1. Create an array `styles` with items "Jazz" and "Blues".
-2. Append "Rock-n-Roll" to the end.
-3. Replace the value in the middle by "Classics". Your code for finding the middle value should work for any arrays with odd length.
-4. Strip off the first value of the array and show it.
-5. Prepend `Rap` and `Reggae` to the array.
+1. 建立一個擁有 "Jazz" 和 "Blues" 作為項目的陣列 `styles`。
+2. 附加 "Rock-n-Roll" 到其末端。
+3. 使用 "Classics" 替換正中央的值，你寫的用於找出正中央值的程式碼，應該要能對任意奇數長度陣列運作。
+4. 抽離陣列第一個值並顯示它。
+5. 由前端附加 `Rap` 和 `Reggae` 至陣列中。
 
-The array in the process:
+這些過程中的陣列要長這樣：
 
 ```js no-beautify
 Jazz, Blues

1-js/05-data-types/04-array/3-call-array-this/solution.md

@@ -1,6 +1,6 @@
-The call `arr[2]()` is syntactically the good old `obj[method]()`, in the role of `obj` we have `arr`, and in the role of `method` we have `2`.
+呼叫 `arr[2]()` 語法上和 `obj[method]()` 相同，對應 `obj` 的是 `arr`，而 `method` 對應著 `2`。
 
-So we have a call of the function `arr[2]` as an object method. Naturally, it receives `this` referencing the object `arr` and outputs the array:
+所以我們有著視 `arr[2]` 為物件方法的函式呼叫。自然地，它接收參考至物件 `arr` 的 `this` 並輸出陣列：
 
 ```js run
 let arr = ["a", "b"];
@@ -12,4 +12,5 @@ arr.push(function() {
 arr[2](); // "a","b",function
 ```
 
-The array has 3 values: initially it had two, plus the function. 
+該陣列有三個值：一開始有兩個，再加上該函式。
+

1-js/05-data-types/04-array/3-call-array-this/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Calling in an array context
+# 於陣列上下文內呼叫
 
-What is the result? Why?
+這樣的結果是什麼？為什麼？
 
 ```js
 let arr = ["a", "b"];

1-js/05-data-types/04-array/5-array-input-sum/solution.md

@@ -1,5 +1,4 @@
-Please note the subtle, but important detail of the solution. We don't convert `value` to number instantly after `prompt`, because after `value = +value` we would not be able to tell an empty string (stop sign) from the zero (valid number). We do it later instead.
-
+請注意這個解法中微妙又重要的細節，我們不立刻在 `prompt` 之後轉換 `value` 為數值，因為在 `value = +value` 之後我們已經無法分辨空字串（停止的信號）和零（有效數值）。我們晚點再處理轉換這件事。
 
 ```js run demo
 function sumInput() {
@@ -10,7 +9,7 @@ function sumInput() {
 
     let value = prompt("A number please?", 0);
 
-    // should we cancel?
+    // 該終止了嗎？
     if (value === "" || value === null || !isFinite(value)) break;
 
     numbers.push(+value);

1-js/05-data-types/04-array/5-array-input-sum/task.md

@@ -2,14 +2,14 @@ importance: 4
 
 ---
 
-# Sum input numbers
+# 加總輸入的數值
 
-Write the function `sumInput()` that:
+寫個函式 `SumInput()` 用於：
 
-- Asks the user for values using `prompt` and stores the values in the array.
-- Finishes asking when the user enters a non-numeric value, an empty string, or presses "Cancel".
-- Calculates and returns the sum of array items.
+- 使用 `prompt` 詢問使用者來輸入值，並儲存值到陣列中。
+- 當使用者輸入非數值的值、空字串或按下 "Cancel" 後結束詢問。
+- 計算並回傳陣列項目的加總。
 
-P.S. A zero `0` is a valid number, please don't stop the input on zero.
+註：一個零 `0` 視為有效的數值，請不要在遇到零時停止詢問輸入。
 
 [demo]