[배열] 과제 번역

Author: Violet-Bora-Lee

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

@@ -1,17 +1,16 @@
-The result is `4`:
+정답은 `4`입니다.
 
 
 ```js run
-let fruits = ["Apples", "Pear", "Orange"];
+let fruits = ["사과", "배", "오렌지"];
 
 let shoppingCart = fruits;
 
-shoppingCart.push("Banana");
+shoppingCart.push("바나나");
 
 *!*
 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"];
+let fruits = ["사과", "배", "오렌지"];
 
-// push a new value into the "copy"
+// 배열을 '복사'한 후, push 메서드를 이용해 새로운 값을 추가합니다.
 let shoppingCart = fruits;
-shoppingCart.push("Banana");
+shoppingCart.push("바나나");
 
-// 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; // 어떤 요소도 선택하지 않으면 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)이 됩니다. 이는 배열의 크기를 2배 늘리면 알고리즘은 4배나 더 오래 걸린다는 의미입니다.
 
-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) { // 배열의 각 요소를
+    partialSum += item; // partialSum에 더합니다.
+    maxSum = Math.max(maxSum, partialSum); // 최대값을 기억해 놓습니다.
+    if (partialSum < 0) partialSum = 0; // 음수가 되면 0을 대입합니다.
   }
 
   return maxSum;
@@ -89,6 +89,6 @@ 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)입니다.
 
-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.
+알고리즘에 대한 상세한 정보는 [최대합 부분 배열 문제](http://en.wikipedia.org/wiki/Maximum_subarray_problem)에서 찾을 수 있습니다. 동작원리에 대해 확실히 이해가 되지 않았다면 위 예제의 알고리즘이 어떻게 동작하는지 찬찬히 살펴보세요. 그릉ㄹ 읽는 것보다 코드를 살펴보는게 훨씬 도움이 될 겁니다.

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

@@ -2,29 +2,29 @@ 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:
+요소 전체가 음수라면 아무런 요소도 선택하지 않아야 최댓값이 됩니다(부분 배열은 빈 배열). 그리고 합은 0이 됩니다.
 
 ```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/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Array operations.
+# 배열과 관련된 연산
 
-Let's try 5 array operations.
+배열과 관련된 다섯 가지 연산을 해봅시다.
 
-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`가 `arr`이고, `method`는 `2`인 메서드 `obj[method]()`를 호출하는 것과 문법적으로 동일합니다.
 
-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[2]`는 `arr`을 참조하는 `this`를 받고, 배열을 출력합니다.
 
 ```js run
 let arr = ["a", "b"];
@@ -9,7 +9,7 @@ arr.push(function() {
   alert( this );
 })
 
-arr[2](); // "a","b",function
+arr[2](); // a,b,function(){...}
 ```
 
-The array has 3 values: initially it had two, plus the function. 
+배열은 초기 2개의 값에 함수가 추가되어 총 3개의 값을 가집니다.

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,4 +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.
+해답에서 작지만 중요한 역할을 하는 부분에 주의를 기울여 주세요. `+value`로 입력받은 값을 숫자형으로 변경한 이후엔, 빈 문자열(정지 신호)을 0(유효한 숫자)과 구분할 수 없기 때문에, `prompt` 직후에 `value`를 숫자로 변환하지 않고 나중에 숫자로 변환하였습니다.
 
 
 ```js run demo
@@ -8,9 +8,9 @@ function sumInput() {
 
   while (true) {
 
-    let value = prompt("A number please?", 0);
+    let value = prompt("숫자를 입력해 주세요.", 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`은 유효한 숫자이므로, 사용자가 `0`을 입력하더라도 질문이 멈추지 말아야 합니다.
 
 [demo]