chore(i18n,learn): processed translations (#45235)

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md

@@ -25,39 +25,37 @@ function equalityTest(myVal) {
 `myVal` が `10` と等しい場合には、等価演算子は `true` を返し、中括弧内のコードが実行されて、関数は `Equal` を返します。 それ以外の場合、関数は `Not Equal` を返します。 JavaScript では、比較する 2 つのデータの<dfn>データ型</dfn>が異なる場合 (たとえば `numbers` と `strings`)、必ず一方の型が他方の型に変換されます。 これを「型強制」と呼びます。 これが行われることで、次のような値の比較が可能になります。
 
 ```js
-1   ==  1
-1   ==  2
-1   == '1'
-"3" ==  3
+1   ==  1  // true
+1   ==  2  // false
+1   == '1' // true
+"3" ==  3  // true
 ```
 
-これらの式は上から順に、`true`、`false`、`true`、`true` と評価されます。
-
 # --instructions--
 
-`val` が `12` と等しい場合に関数が文字列 `Equal` を返すように、指定された行に等価演算子を追加してください。
+Add the equality operator to the indicated line so that the function will return the string `Equal` when `val` is equivalent to `12`.
 
 # --hints--
 
-`testEqual(10)` は文字列 `Not Equal` を返す必要があります。
+`testEqual(10)` should return the string `Not Equal`
 
 ```js
 assert(testEqual(10) === 'Not Equal');
 ```
 
-`testEqual(12)` は文字列 `Equal` を返す必要があります。
+`testEqual(12)` should return the string `Equal`
 
 ```js
 assert(testEqual(12) === 'Equal');
 ```
 
-`testEqual("12")` は文字列 `Equal` を返す必要があります。
+`testEqual("12")` should return the string `Equal`
 
 ```js
 assert(testEqual('12') === 'Equal');
 ```
 
-`==` 演算子を使用してください。
+You should use the `==` operator
 
 ```js
 assert(code.match(/==/g) && !code.match(/===/g));

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md

@@ -16,63 +16,61 @@ dashedName: comparison-with-the-greater-than-operator
 **例**
 
 ```js
-5   >  3
-7   > '3'
-2   >  3
-'1' >  9
+5   >  3  // true
+7   > '3' // true
+2   >  3  // false
+'1' >  9  // false
 ```
 
-これらの式は上から順に、`true`、`true`、`false`、`false` と評価されます。
-
 # --instructions--
 
-return ステートメントの意味が正しくなるように、指定された行に大なり演算子を追加してください。
+Add the greater than operator to the indicated lines so that the return statements make sense.
 
 # --hints--
 
-`testGreaterThan(0)` は文字列 `10 or Under` を返す必要があります。
+`testGreaterThan(0)` should return the string `10 or Under`
 
 ```js
 assert(testGreaterThan(0) === '10 or Under');
 ```
 
-`testGreaterThan(10)` は文字列 `10 or Under` を返す必要があります。
+`testGreaterThan(10)` should return the string `10 or Under`
 
 ```js
 assert(testGreaterThan(10) === '10 or Under');
 ```
 
-`testGreaterThan(11)` は文字列 `Over 10` を返す必要があります。
+`testGreaterThan(11)` should return the string `Over 10`
 
 ```js
 assert(testGreaterThan(11) === 'Over 10');
 ```
 
-`testGreaterThan(99)` は文字列 `Over 10` を返す必要があります。
+`testGreaterThan(99)` should return the string `Over 10`
 
 ```js
 assert(testGreaterThan(99) === 'Over 10');
 ```
 
-`testGreaterThan(100)` は文字列 `Over 10` を返す必要があります。
+`testGreaterThan(100)` should return the string `Over 10`
 
 ```js
 assert(testGreaterThan(100) === 'Over 10');
 ```
 
-`testGreaterThan(101)` は文字列 `Over 100` を返す必要があります。
+`testGreaterThan(101)` should return the string `Over 100`
 
 ```js
 assert(testGreaterThan(101) === 'Over 100');
 ```
 
-`testGreaterThan(150)` は文字列 `Over 100` を返す必要があります。
+`testGreaterThan(150)` should return the string `Over 100`
 
 ```js
 assert(testGreaterThan(150) === 'Over 100');
 ```
 
-`>` 演算子を 2 回以上使用してください。
+You should use the `>` operator at least twice
 
 ```js
 assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md

@@ -16,63 +16,61 @@ dashedName: comparison-with-the-greater-than-or-equal-to-operator
 **例**
 
 ```js
-6   >=  6
-7   >= '3'
-2   >=  3
-'7' >=  9
+6   >=  6  // true
+7   >= '3' // true
+2   >=  3  // false
+'7' >=  9  // false
 ```
 
-これらの式は上から順に、`true`、`true`、`false`、`false` と評価されます。
-
 # --instructions--
 
-return ステートメントの意味が正しくなるように、指定された行に大なりイコール演算子を追加してください。
+Add the greater than or equal to operator to the indicated lines so that the return statements make sense.
 
 # --hints--
 
-`testGreaterOrEqual(0)` は文字列 `Less than 10` を返す必要があります。
+`testGreaterOrEqual(0)` should return the string `Less than 10`
 
 ```js
 assert(testGreaterOrEqual(0) === 'Less than 10');
 ```
 
-`testGreaterOrEqual(9)` は文字列 `Less than 10` を返す必要があります。
+`testGreaterOrEqual(9)` should return the string `Less than 10`
 
 ```js
 assert(testGreaterOrEqual(9) === 'Less than 10');
 ```
 
-`testGreaterOrEqual(10)` は文字列 `10 or Over` を返す必要があります。
+`testGreaterOrEqual(10)` should return the string `10 or Over`
 
 ```js
 assert(testGreaterOrEqual(10) === '10 or Over');
 ```
 
-`testGreaterOrEqual(11)` は文字列 `10 or Over` を返す必要があります。
+`testGreaterOrEqual(11)` should return the string `10 or Over`
 
 ```js
 assert(testGreaterOrEqual(11) === '10 or Over');
 ```
 
-`testGreaterOrEqual(19)` は文字列 `10 or Over` を返す必要があります。
+`testGreaterOrEqual(19)` should return the string `10 or Over`
 
 ```js
 assert(testGreaterOrEqual(19) === '10 or Over');
 ```
 
-`testGreaterOrEqual(100)` は文字列 `20 or Over` を返す必要があります。
+`testGreaterOrEqual(100)` should return the string `20 or Over`
 
 ```js
 assert(testGreaterOrEqual(100) === '20 or Over');
 ```
 
-`testGreaterOrEqual(21)` は文字列 `20 or Over` を返す必要があります。
+`testGreaterOrEqual(21)` should return the string `20 or Over`
 
 ```js
 assert(testGreaterOrEqual(21) === '20 or Over');
 ```
 
-`>=` 演算子を 2 回以上使用してください。
+You should use the `>=` operator at least twice
 
 ```js
 assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md

@@ -14,52 +14,50 @@ dashedName: comparison-with-the-inequality-operator
 **例**
 
 ```js
-1 !=  2
-1 != "1"
-1 != '1'
-1 != true
-0 != false
+1 !=  2    // true
+1 != "1"   // false
+1 != '1'   // false
+1 != true  // false
+0 != false // false
 ```
 
-これらの式は上から順に、`true`、`false`、`false`、`false`、`false` と評価されます。
-
 # --instructions--
 
-`val` が `99` と等しくない場合に関数が文字列 `Not Equal` を返すように、`if` ステートメントに不等価演算子 `!=` を追加してください。
+Add the inequality operator `!=` in the `if` statement so that the function will return the string `Not Equal` when `val` is not equivalent to `99`.
 
 # --hints--
 
-`testNotEqual(99)` は文字列 `Equal` を返す必要があります。
+`testNotEqual(99)` should return the string `Equal`
 
 ```js
 assert(testNotEqual(99) === 'Equal');
 ```
 
-`testNotEqual("99")` は文字列 `Equal` を返す必要があります。
+`testNotEqual("99")` should return the string `Equal`
 
 ```js
 assert(testNotEqual('99') === 'Equal');
 ```
 
-`testNotEqual(12)` は文字列 `Not Equal` を返す必要があります。
+`testNotEqual(12)` should return the string `Not Equal`
 
 ```js
 assert(testNotEqual(12) === 'Not Equal');
 ```
 
-`testNotEqual("12")` は文字列 `Not Equal` を返す必要があります。
+`testNotEqual("12")` should return the string `Not Equal`
 
 ```js
 assert(testNotEqual('12') === 'Not Equal');
 ```
 
-`testNotEqual("bob")` は文字列 `Not Equal` を返す必要があります。
+`testNotEqual("bob")` should return the string `Not Equal`
 
 ```js
 assert(testNotEqual('bob') === 'Not Equal');
 ```
 
-`!=` 演算子を使用してください。
+You should use the `!=` operator
 
 ```js
 assert(code.match(/(?!!==)!=/));

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md

@@ -14,58 +14,56 @@ dashedName: comparison-with-the-less-than-operator
 **例**
 
 ```js
-2   < 5
-'3' < 7
-5   < 5
-3   < 2
-'8' < 4
+2   < 5 // true
+'3' < 7 // true
+5   < 5 // false
+3   < 2 // false
+'8' < 4 // false
 ```
 
-これらの式は上から順に、`true`、`true`、`false`、`false`、`false` と評価されます。
-
 # --instructions--
 
-return ステートメントの意味が正しくなるように、指定された行に小なり演算子を追加してください。
+Add the less than operator to the indicated lines so that the return statements make sense.
 
 # --hints--
 
-`testLessThan(0)` は文字列 `Under 25` を返す必要があります。
+`testLessThan(0)` should return the string `Under 25`
 
 ```js
 assert(testLessThan(0) === 'Under 25');
 ```
 
-`testLessThan(24)` は文字列 `Under 25` を返す必要があります。
+`testLessThan(24)` should return the string `Under 25`
 
 ```js
 assert(testLessThan(24) === 'Under 25');
 ```
 
-`testLessThan(25)` は文字列 `Under 55` を返す必要があります。
+`testLessThan(25)` should return the string `Under 55`
 
 ```js
 assert(testLessThan(25) === 'Under 55');
 ```
 
-`testLessThan(54)` は文字列 `Under 55` を返す必要があります。
+`testLessThan(54)` should return the string `Under 55`
 
 ```js
 assert(testLessThan(54) === 'Under 55');
 ```
 
-`testLessThan(55)` は文字列 `55 or Over` を返す必要があります。
+`testLessThan(55)` should return the string `55 or Over`
 
 ```js
 assert(testLessThan(55) === '55 or Over');
 ```
 
-`testLessThan(99)` は文字列 `55 or Over` を返す必要があります。
+`testLessThan(99)` should return the string `55 or Over`
 
 ```js
 assert(testLessThan(99) === '55 or Over');
 ```
 
-`<` 演算子を 2 回以上使用してください。
+You should use the `<` operator at least twice
 
 ```js
 assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md

@@ -14,64 +14,62 @@ dashedName: comparison-with-the-less-than-or-equal-to-operator
 **例**
 
 ```js
-4   <= 5
-'7' <= 7
-5   <= 5
-3   <= 2
-'8' <= 4
+4   <= 5 // true
+'7' <= 7 // true
+5   <= 5 // true
+3   <= 2 // false
+'8' <= 4 // false
 ```
 
-これらの式は上から順に、`true`、`true`、`true`、`false`、`false` と評価されます。
-
 # --instructions--
 
-return ステートメントの意味が正しくなるように、指定された行に小なりイコール演算子を追加してください。
+Add the less than or equal to operator to the indicated lines so that the return statements make sense.
 
 # --hints--
 
-`testLessOrEqual(0)` は文字列 `Smaller Than or Equal to 12` を返す必要があります。
+`testLessOrEqual(0)` should return the string `Smaller Than or Equal to 12`
 
 ```js
 assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
 ```
 
-`testLessOrEqual(11)` は文字列 `Smaller Than or Equal to 12` を返す必要があります。
+`testLessOrEqual(11)` should return the string `Smaller Than or Equal to 12`
 
 ```js
 assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
 ```
 
-`testLessOrEqual(12)` は文字列 `Smaller Than or Equal to 12` を返す必要があります。
+`testLessOrEqual(12)` should return the string `Smaller Than or Equal to 12`
 
 ```js
 assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
 ```
 
-`testLessOrEqual(23)` は文字列 `Smaller Than or Equal to 24` を返す必要があります。
+`testLessOrEqual(23)` should return the string `Smaller Than or Equal to 24`
 
 ```js
 assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
 ```
 
-`testLessOrEqual(24)` は文字列 `Smaller Than or Equal to 24` を返す必要があります。
+`testLessOrEqual(24)` should return the string `Smaller Than or Equal to 24`
 
 ```js
 assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
 ```
 
-`testLessOrEqual(25)` は文字列 `More Than 24` を返す必要があります。
+`testLessOrEqual(25)` should return the string `More Than 24`
 
 ```js
 assert(testLessOrEqual(25) === 'More Than 24');
 ```
 
-`testLessOrEqual(55)` は文字列 `More Than 24` を返す必要があります。
+`testLessOrEqual(55)` should return the string `More Than 24`
 
 ```js
 assert(testLessOrEqual(55) === 'More Than 24');
 ```
 
-`<=` 演算子を 2 回以上使用してください。
+You should use the `<=` operator at least twice
 
 ```js
 assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md

@@ -16,39 +16,37 @@ dashedName: comparison-with-the-strict-equality-operator
 **例**
 
 ```js
-3 ===  3
-3 === '3'
+3 ===  3  // true
+3 === '3' // false
 ```
 
-これらの条件ではそれぞれ、`true` と `false` を返すことになります。
-
-2 番目の例では、 `3` は `Number` 型で、 `'3'` は `String` 型です。
+In the second example, `3` is a `Number` type and `'3'` is a `String` type.
 
 # --instructions--
 
-`if` ステートメントで厳密等価演算子を使用して、`val` が `7` と厳密に等しい場合に関数が文字列 `Equal` を返すようにしてください。
+Use the strict equality operator in the `if` statement so the function will return the string `Equal` when `val` is strictly equal to `7`.
 
 # --hints--
 
-`testStrict(10)` は文字列 `Not Equal` を返す必要があります。
+`testStrict(10)` should return the string `Not Equal`
 
 ```js
 assert(testStrict(10) === 'Not Equal');
 ```
 
-`testStrict(7)` は文字列 `Equal` を返す必要があります。
+`testStrict(7)` should return the string `Equal`
 
 ```js
 assert(testStrict(7) === 'Equal');
 ```
 
-`testStrict("7")` は文字列 `Not Equal` を返す必要があります。
+`testStrict("7")` should return the string `Not Equal`
 
 ```js
 assert(testStrict('7') === 'Not Equal');
 ```
 
-`===` 演算子を使用してください。
+You should use the `===` operator
 
 ```js
 assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md

@@ -14,44 +14,42 @@ dashedName: comparison-with-the-strict-inequality-operator
 **例**
 
 ```js
-3 !==  3
-3 !== '3'
-4 !==  3
+3 !==  3  // false
+3 !== '3' // true
+4 !==  3  // true
 ```
 
-これらの式は順に `false`、`true`、`true` と評価されます。
-
 # --instructions--
 
-`val` が `17` と厳密に等しくない場合に関数が文字列 `Not Equal` を返すように、`if` ステートメントに厳密不等価演算子を追加してください。
+Add the strict inequality operator to the `if` statement so the function will return the string `Not Equal` when `val` is not strictly equal to `17`
 
 # --hints--
 
-`testStrictNotEqual(17)` は文字列 `Equal` を返す必要があります。
+`testStrictNotEqual(17)` should return the string `Equal`
 
 ```js
 assert(testStrictNotEqual(17) === 'Equal');
 ```
 
-`testStrictNotEqual("17")` は文字列 `Not Equal` を返す必要があります。
+`testStrictNotEqual("17")` should return the string `Not Equal`
 
 ```js
 assert(testStrictNotEqual('17') === 'Not Equal');
 ```
 
-`testStrictNotEqual(12)` は文字列 `Not Equal` を返す必要があります。
+`testStrictNotEqual(12)` should return the string `Not Equal`
 
 ```js
 assert(testStrictNotEqual(12) === 'Not Equal');
 ```
 
-`testStrictNotEqual("bob")` は文字列 `Not Equal` を返す必要があります。
+`testStrictNotEqual("bob")` should return the string `Not Equal`
 
 ```js
 assert(testStrictNotEqual('bob') === 'Not Equal');
 ```
 
-`!==` 演算子を使用してください。
+You should use the `!==` operator
 
 ```js
 assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md

@@ -32,16 +32,14 @@ FAV_PET = "Dogs";
 `var` がコード内に存在しないようにしてください。
 
 ```js
-(getUserInput) => assert(!getUserInput('index').match(/var/g));
+assert.notMatch(code, /var/g);
 ```
 
 `fCC` をすべて大文字に変更する必要があります。
 
 ```js
-(getUserInput) => {
-  assert(getUserInput('index').match(/(FCC)/));
-  assert(!getUserInput('index').match(/fCC/));
-}
+assert.match(code, /(FCC)/);
+assert.notMatch(code, /(fCC)/);
 ```
 
 `FCC` は `const` で宣言された定数変数である必要があります。
@@ -54,14 +52,13 @@ assert.match(code, /const\s+FCC/);
 `fact` は `let` を使用して宣言する必要があります。
 
 ```js
-(getUserInput) => assert(getUserInput('index').match(/(let fact)/g));
+assert.match(code, /(let\s+fact)/g);
 ```
 
 `console.log` を、`FCC` と `fact` 変数が出力されるように変更する必要があります。
 
 ```js
-(getUserInput) =>
-  assert(getUserInput('index').match(/console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g));
+assert.match(code, /console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g);
 ```
 
 # --seed--

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md

@@ -42,19 +42,19 @@ let camper = "David";
 `var` がコード内に存在しない必要があります。
 
 ```js
-(getUserInput) => assert(!getUserInput('index').match(/var/g));
+assert.notMatch(code, /var/g);
 ```
 
 `catName` は文字列 `Oliver` である必要があります。
 
 ```js
-assert(catName === 'Oliver');
+assert.equal(catName, 'Oliver');
 ```
 
 `catSound` は文字列 `Meow!` である必要があります。
 
 ```js
-assert(catSound === 'Meow!');
+assert.equal(catSound, 'Meow!');
 ```
 
 # --seed--