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

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md

@@ -0,0 +1,77 @@
+---
+id: 587d7dba367417b2b2512ba8
+title: 存在するかしないかをチェックする
+challengeType: 1
+forumTopicId: 301338
+dashedName: check-for-all-or-none
+---
+
+# --description--
+
+検索したいパターンの中に、存在するかどうかがわからない部分が含まれている場合があります。 しかし、そうした場合でも存在の有無をチェックすることが重要なことがあります。
+
+クエスチョンマーク `?` を使用すると、要素の存在の可能性を指定できます。 これは、直前の要素が 0 個か 1 個かをチェックします。 この記号は、前の要素が省略可能であるとみなすことができます。
+
+たとえば、アメリカ英語とイギリス英語には若干の違いがあり、クエスチョンマークを使用して両方のスペルにマッチすることができます。
+
+```js
+let american = "color";
+let british = "colour";
+let rainbowRegex= /colou?r/;
+rainbowRegex.test(american);
+rainbowRegex.test(british);
+```
+
+どちらの `test` メソッドも `true` を返します。
+
+# --instructions--
+
+正規表現の `favRegex` を変更して、アメリカ英語 (`favorite`) とイギリス英語 (`favourite`) の両方の単語にマッチするようにしてください。
+
+# --hints--
+
+正規表現にはオプション記号 `?` を使用してください。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.source.match(/\?/).length > 0);
+```
+
+正規表現は文字列 `favorite` にマッチする必要があります。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favorite'));
+```
+
+正規表現は文字列 `favourite` にマッチする必要があります。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favourite'));
+```
+
+正規表現は文字列 `fav` にマッチしないようにする必要があります。
+
+```js
+favRegex.lastIndex = 0;
+assert(!favRegex.test('fav'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let favWord = "favorite";
+let favRegex = /change/; // Change this line
+let result = favRegex.test(favWord);
+```
+
+# --solutions--
+
+```js
+let favWord = "favorite";
+let favRegex = /favou?r/;
+let result = favRegex.test(favWord);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md

@@ -0,0 +1,90 @@
+---
+id: 5c3dda8b4d8df89bea71600f
+title: 混在する文字のグループをチェックする
+challengeType: 1
+forumTopicId: 301339
+dashedName: check-for-mixed-grouping-of-characters
+---
+
+# --description--
+
+正規表現を使用して文字のグループをチェックするために、括弧 `()` を使用することがあります。
+
+文字列の中から `Penguin` または `Pumpkin` のどちらかを見つけたい場合は、`/P(engu|umpk)in/g` という正規表現を使用できます。
+
+次に、`test()` メソッドを使用して、必要な文字列グループがテスト文字列内にあるかどうかを確認してみます。
+
+```js
+let testStr = "Pumpkin";
+let testRegex = /P(engu|umpk)in/;
+testRegex.test(testStr);
+```
+
+この `test` メソッドは `true` を返します。
+
+# --instructions--
+
+正規表現を修正して、`Franklin Roosevelt` または `Eleanor Roosevelt` の名前を、大文字小文字を区別してチェックしてください。ミドルネームについては容認してください。
+
+次にコードを修正して、作成した正規表現を `myString` に対してチェックし、正規表現がマッチするかどうかに応じて `true` または `false` を返すようにしてください。
+
+# --hints--
+
+正規表現 `myRegex` は文字列 `Franklin D. Roosevelt` に対して `true` を返す必要があります。
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Franklin D. Roosevelt'));
+```
+
+正規表現 `myRegex` は文字列 `Eleanor Roosevelt` に対して `true` を返す必要があります。
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Eleanor Roosevelt'));
+```
+
+正規表現 `myRegex` は文字列 `Franklin Rosevelt` に対して `false` を返す必要があります。
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Franklin Rosevelt'));
+```
+
+正規表現 `myRegex` は文字列 `Frank Roosevelt` に対して `false` を返す必要があります。
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Frank Roosevelt'));
+```
+
+正規表現をテストするには `.test()` を使用する必要があります。
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+結果は `true` を返す必要があります。
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /False/; // Change this line
+let result = false; // Change this line
+// After passing the challenge experiment with myString and see how the grouping works
+```
+
+# --solutions--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /(Franklin|Eleanor).*Roosevelt/;
+let result = myRegex.test(myString);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md

@@ -0,0 +1,73 @@
+---
+id: 587d7db4367417b2b2512b92
+title: マッチしたものを抽出する
+challengeType: 1
+forumTopicId: 301340
+dashedName: extract-matches
+---
+
+# --description--
+
+ここまでは、単にパターンが文字列内に存在するかどうかをチェックしてきました。 `.match()` メソッドで見つけた実際のマッチ部分を抽出することもできます。
+
+`.match()` メソッドを使用するには、メソッドを文字列に適用し、括弧内に正規表現を渡します。
+
+例を示します。
+
+```js
+"Hello, World!".match(/Hello/);
+let ourStr = "Regular expressions";
+let ourRegex = /expressions/;
+ourStr.match(ourRegex);
+```
+
+ここで最初の `match` は `["Hello"]` を返し、2 番目の match は `["expressions"]` を返します。
+
+`.match` の構文は、これまで使用してきた `.test` メソッドの「反対」であることに注意してください。
+
+```js
+'string'.match(/regex/);
+/regex/.test('string');
+```
+
+# --instructions--
+
+`.match()` メソッドを適用して、文字列 `coding` を抽出してください。
+
+# --hints--
+
+`result` には文字列 `coding` が存在する必要があります。
+
+```js
+assert(result.join() === 'coding');
+```
+
+正規表現 `codingRegex` で文字列 `coding` を検索する必要があります。
+
+```js
+assert(codingRegex.source === 'coding');
+```
+
+`.match()` メソッドを使用する必要があります。
+
+```js
+assert(code.match(/\.match\(.*\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /change/; // Change this line
+let result = extractStr; // Change this line
+```
+
+# --solutions--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /coding/; // Change this line
+let result = extractStr.match(codingRegex); // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md

@@ -0,0 +1,61 @@
+---
+id: 587d7db6367417b2b2512b9b
+title: 怠惰なマッチングで文字を検索する
+challengeType: 1
+forumTopicId: 301341
+dashedName: find-characters-with-lazy-matching
+---
+
+# --description--
+
+正規表現では、<dfn>貪欲な</dfn>マッチは、正規表現パターンに合致した文字列の中で可能な限り最も長い部分を見つけ、それをマッチとして返します。 別の方法として<dfn>怠惰な</dfn>マッチと呼ばれるものがあり、これは正規表現パターンを満たす文字列の中で可能な限り最も短い部分を見つけます。
+
+たとえば正規表現 `/t[a-z]*i/` を文字列 `"titanic"` に適用してみましょう。 この正規表現は基本的には、`t` で始まり、`i` で終わり、その間にいくつかの文字があるパターンです。
+
+正規表現はデフォルトでは貪欲モードなので、マッチは `["titani"]` を返します。 つまり、パターンに合致する最も長い部分文字列を見つけます。
+
+一方で、`?` 文字を使用して怠惰なマッチングに変更することができます。 修正後の正規表現 `/t[a-z]*?i/` に対して `"titanic"` を適用すると、マッチとして `["ti"]` を返します。
+
+**注:** HTML を正規表現で解析することは避けるべきですが、正規表現を使用した HTML 文字列のパターンマッチングはまったく問題ありません。
+
+# --instructions--
+
+正規表現 `/<.*>/` を修正して、テキスト `"<h1>Winter is coming</h1>"` ではなく、HTML タグ `<h1>` を返すようにしてください。 正規表現のワイルドカード `.` は任意の文字にマッチすることを覚えておいてください。
+
+# --hints--
+
+`result` 変数は `<h1>` を含む配列になる必要があります。
+
+```js
+assert(result[0] == '<h1>');
+```
+
+`myRegex` で怠惰なマッチングを使用する必要があります。
+
+```js
+assert(/[^\\][\*\+\?]\?/.test(myRegex));
+```
+
+`myRegex` に文字列 `h1` を含めないでください。
+
+```js
+assert(!myRegex.source.match('h1'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let text = "<h1>Winter is coming</h1>";
+let myRegex = /<.*>/; // Change this line
+let result = text.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let text = "<h1>Winter is coming</h1>";
+let myRegex = /<.*?>/; // Change this line
+let result = text.match(myRegex);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db4367417b2b2512b93
+title: 複数回出現するマッチを検索する
+challengeType: 1
+forumTopicId: 301342
+dashedName: find-more-than-the-first-match
+---
+
+# --description--
+
+ここまではパターンを 1 回だけ抽出または検索することができました。
+
+```js
+let testStr = "Repeat, Repeat, Repeat";
+let ourRegex = /Repeat/;
+testStr.match(ourRegex);
+```
+
+この `match` は `["Repeat"]` を返します。
+
+パターンを複数回検索または抽出するには、`g` フラグを使用します。
+
+```js
+let repeatRegex = /Repeat/g;
+testStr.match(repeatRegex);
+```
+
+この `match` は値 `["Repeat", "Repeat", "Repeat"]` を返します。
+
+# --instructions--
+
+正規表現 `starRegex`を使用して、文字列 `twinkleStar` から両方の単語 `Twinkle` を検索して抽出してください。
+
+**注**  
+`/search/gi` のように正規表現に複数のフラグを付けることができます。
+
+# --hints--
+
+正規表現 `starRegex` でグローバルフラグ `g` を使用する必要があります。
+
+```js
+assert(starRegex.flags.match(/g/).length == 1);
+```
+
+正規表現 `starRegex` で大文字小文字を区別しないフラグ `i` を使用する必要があります。
+
+```js
+assert(starRegex.flags.match(/i/).length == 1);
+```
+
+単語 `Twinkle` の両方の出現にマッチする必要があります。
+
+```js
+assert(
+  result.sort().join() ==
+    twinkleStar
+      .match(/twinkle/gi)
+      .sort()
+      .join()
+);
+```
+
+マッチの `result` には 2 つの要素が含まれる必要があります。
+
+```js
+assert(result.length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /change/; // Change this line
+let result = twinkleStar; // Change this line
+```
+
+# --solutions--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /twinkle/gi;
+let result = twinkleStar.match(starRegex);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md

@@ -0,0 +1,108 @@
+---
+id: 587d7db7367417b2b2512b9c
+title: 1 人以上の犯罪者を捜す
+challengeType: 1
+forumTopicId: 301343
+dashedName: find-one-or-more-criminals-in-a-hunt
+---
+
+# --description--
+
+ちょっとひと休みして、新しく身につけた正規表現の記述スキルをテストしてみましょう。 犯罪者の集団が脱獄して逃げましたが、何人いるかはわかっていません。 しかし、他の人々に混じって集団で潜んでいることはわかっています。 犯罪者全員を一度に見つけてください。
+
+たとえば次のような方法で確認できます。
+
+正規表現 `/z+/` は、1 行の中で文字 `z` の 1 回以上の出現にマッチします。 次の文字列のすべてにマッチします。
+
+```js
+"z"
+"zzzzzz"
+"ABCzzzz"
+"zzzzABC"
+"abczzzzzzzzzzzzzzzzzzzzzabc"
+```
+
+しかし、次の文字列は文字 `z` がないのでマッチは見つかりません。
+
+```js
+""
+"ABC"
+"abcabc"
+```
+
+# --instructions--
+
+他の人々の集団に混じっている 1 人以上の犯罪者を見つける貪欲な正規表現を記述してください。 犯罪者は大文字 `C` で表現されます。
+
+# --hints--
+
+正規表現は文字列 `C` に潜む 1 人の犯罪者 (`C`) にマッチする必要があります。
+
+```js
+assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
+```
+
+正規表現は文字列 `CC` に潜む 2 人の犯罪者 (`CC`) にマッチする必要があります。
+
+```js
+assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
+```
+
+正規表現は文字列 `P1P5P4CCCcP2P6P3` に潜む 3 人の犯罪者 (`CCC`) にマッチする必要があります。
+
+```js
+assert(
+  'P1P5P4CCCcP2P6P3'.match(reCriminals) &&
+    'P1P5P4CCCcP2P6P3'.match(reCriminals)[0] == 'CCC'
+);
+```
+
+正規表現は文字列 `P6P2P7P4P5CCCCCP3P1` に潜む 5 人の犯罪者 (`CCCCC`) にマッチする必要があります。
+
+```js
+assert(
+  'P6P2P7P4P5CCCCCP3P1'.match(reCriminals) &&
+    'P6P2P7P4P5CCCCCP3P1'.match(reCriminals)[0] == 'CCCCC'
+);
+```
+
+正規表現は犯罪者のいない空の文字列 `""` にはマッチしない必要があります。
+
+```js
+reCriminals.lastIndex = 0;
+assert(!reCriminals.test(''));
+```
+
+正規表現は犯罪者のいない文字列 `P1P2P3` にはマッチしない必要があります。
+
+```js
+reCriminals.lastIndex = 0;
+assert(!reCriminals.test('P1P2P3'));
+```
+
+正規表現は文字列 `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3` に潜む 50 人の犯罪者 (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) にマッチする必要があります。
+
+```js
+assert(
+  'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+    reCriminals
+  ) &&
+    'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+      reCriminals
+    )[0] == 'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let reCriminals = /./; // Change this line
+```
+
+# --solutions--
+
+```js
+let reCriminals = /C+/; // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md

@@ -0,0 +1,109 @@
+---
+id: 587d7db4367417b2b2512b91
+title: マッチングでケースを無視する (大文字と小文字を区別しない)
+challengeType: 1
+forumTopicId: 301344
+dashedName: ignore-case-while-matching
+---
+
+# --description--
+
+ここまで、文字列のリテラルな (文字のとおりの) マッチを行う正規表現を見てきました。 しかし、場合によっては大文字と小文字の違いにかかわらずマッチさせたいことがあります。
+
+英語で大文字と小文字の違いのことをケース (またはレターケース) と呼びます。 大文字の例としては、`A`、`B`、`C` があります。 小文字の例としては、`a`、`b`、`c` があります。
+
+フラグと呼ばれるものを使用して、両方のケースにマッチさせることができます。 フラグは他にもありますが、ここでの主役はケースを無視するフラグである `i` フラグです。 これを正規表現の末尾に付けて使用できます。 このフラグを使用する例として、`/ignorecase/i` があります。 この正規表現は文字列 `ignorecase`、`igNoreCase`、および `IgnoreCase` にマッチします。
+
+# --instructions--
+
+ケースに関係なく `freeCodeCamp` にマッチする正規表現 `fccRegex` を記述してください。 正規表現は省略形やスペース付きのバリエーションにマッチさせないでください。
+
+# --hints--
+
+正規表現は文字列 `freeCodeCamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0; 
+assert(fccRegex.test('freeCodeCamp'));
+```
+
+正規表現は文字列 `FreeCodeCamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCodeCamp'));
+```
+
+正規表現は文字列 `FreecodeCamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreecodeCamp'));
+```
+
+正規表現は文字列 `FreeCodecamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCodecamp'));
+```
+
+正規表現は文字列 `Free Code Camp` にマッチしない必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(!fccRegex.test('Free Code Camp'));
+```
+
+正規表現は文字列 `FreeCOdeCamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCOdeCamp'));
+```
+
+正規表現は文字列 `FCC` にマッチしない必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(!fccRegex.test('FCC'));
+```
+
+正規表現は文字列 `FrEeCoDeCamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FrEeCoDeCamp'));
+```
+
+正規表現は文字列 `FrEeCodECamp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FrEeCodECamp'));
+```
+
+正規表現は文字列 `FReeCodeCAmp` にマッチする必要があります。
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FReeCodeCAmp'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /change/; // Change this line
+let result = fccRegex.test(myString);
+```
+
+# --solutions--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /freecodecamp/i; // Change this line
+let result = fccRegex.test(myString);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md

@@ -0,0 +1,90 @@
+---
+id: 587d7db4367417b2b2512b90
+title: 異なる候補の文字列にマッチさせる
+challengeType: 1
+forumTopicId: 301345
+dashedName: match-a-literal-string-with-different-possibilities
+---
+
+# --description--
+
+`/coding/` のような正規表現を使用すると、別の文字列にあるパターン `coding` を検索できます。
+
+これは単一の文字列を検索するのにとても便利ですが、1 つのパターンのみに限定されています。 `alternation` または `OR` 演算子と呼ばれる `|` を使用すると、複数のパターンを検索できます。
+
+この演算子はその前後のパターンにマッチします。 たとえば、文字列 `yes` または `no` にマッチさせたい場合、必要な正規表現は `/yes|no/` となります。
+
+また、3 つ以上のパターンを検索することもできます。 それには `OR` 演算子を増やして `/yes|no|maybe/` のように分割し、より多くのパターンを追加します。
+
+# --instructions--
+
+正規表現 `petRegex` を完成させて、ペット `dog`、`cat`、`bird`、または `fish` にマッチさせてください。
+
+# --hints--
+
+正規表現 `petRegex` は文字列 `John has a pet dog.` に対して `true` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('John has a pet dog.'));
+```
+
+正規表現 `petRegex` は文字列 `Emma has a pet rock.` に対して `false` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Emma has a pet rock.'));
+```
+
+正規表現 `petRegex` は文字列 `Emma has a pet bird.` に対して `true` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Emma has a pet bird.'));
+```
+
+正規表現 `petRegex` は文字列 `Liz has a pet cat.` に対して `true` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Liz has a pet cat.'));
+```
+
+正規表現 `petRegex` は文字列 `Kara has a pet dolphin.` に対して `false` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Kara has a pet dolphin.'));
+```
+
+正規表現 `petRegex` は文字列 `Alice has a pet fish.` に対して `true` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Alice has a pet fish.'));
+```
+
+正規表現 `petRegex` は文字列 `Jimmy has a pet computer.` に対して `false` を返す必要があります。
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Jimmy has a pet computer.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /change/; // Change this line
+let result = petRegex.test(petString);
+```
+
+# --solutions--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /dog|cat|bird|fish/; // Change this line
+let result = petRegex.test(petString);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md

@@ -0,0 +1,98 @@
+---
+id: 587d7db7367417b2b2512b9f
+title: すべての英文字と数字にマッチさせる
+challengeType: 1
+forumTopicId: 301346
+dashedName: match-all-letters-and-numbers
+---
+
+# --description--
+
+文字クラスを使用して、アルファベットのすべての文字を `[a-z]` で検索することができました。 この種の文字クラスはよく使用されるのでそのためのショートカットがありますが、それにはいくつかの余分な文字も含まれています。
+
+JavaScript でアルファベットにマッチする最も近い文字クラスは `\w` で、 このショートカットは `[A-Za-z0-9_]` と同等です。 この文字クラスは大文字と小文字に加えて数字にもマッチします。 また、アンダースコア文字 (`_`) も含まれていることに注意してください。
+
+```js
+let longHand = /[A-Za-z0-9_]+/;
+let shortHand = /\w+/;
+let numbers = "42";
+let varNames = "important_var";
+longHand.test(numbers);
+shortHand.test(numbers);
+longHand.test(varNames);
+shortHand.test(varNames);
+```
+
+これら 4 つの `test` 呼び出しはすべて `true` を返します。
+
+これらのショートカット文字クラスは<dfn>文字クラスの略記</dfn>とも呼ばれます。
+
+# --instructions--
+
+文字クラス `\w` を使用して、さまざまな引用符や文字列の英数字の個数を数えてください。
+
+# --hints--
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(alphabetRegexV2.global);
+```
+
+正規表現をすべての英数字にマッチさせるために、略記文字 `\w` を使用する必要があります。
+
+```js
+assert(/\\w/.test(alphabetRegexV2.source));
+```
+
+正規表現は、文字列 `The five boxing wizards jump quickly.` の中に英数字を 31 文字見つける必要があります。
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(alphabetRegexV2).length === 31
+);
+```
+
+正規表現は、文字列 `Pack my box with five dozen liquor jugs.` の中に英数字を 32 文字見つける必要があります。
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(alphabetRegexV2).length ===
+    32
+);
+```
+
+正規表現は、文字列 `How vexingly quick daft zebras jump!` の中に英数字を 30 文字見つける必要があります。
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(alphabetRegexV2).length === 30
+);
+```
+
+正規表現は、文字列 `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` の中に英数字を 36 文字見つける必要があります。
+
+```js
+assert(
+  '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(alphabetRegexV2)
+    .length === 36
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /change/; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /\w/g; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db8367417b2b2512ba1
+title: 数字以外のすべてにマッチさせる
+challengeType: 1
+forumTopicId: 301347
+dashedName: match-all-non-numbers
+---
+
+# --description--
+
+前回のチャレンジでは、ショートカット `\d` で小文字の `d` を使用して数字を検索する方法を示しました。 似たようなショートカットで、代わりに大文字の `D` を使用して数字以外を検索することもできます。
+
+数字以外の文字を検索するためのショートカットは `\D` です。 これは文字クラス `[^0-9]` と同等です。0 から 9 の数字以外の単一の文字を検索します。
+
+# --instructions--
+
+文字クラスの略記 `\D` を使用して、映画のタイトルに含まれている数字以外の文字の個数を数えてください。
+
+# --hints--
+
+正規表現で、数字以外の文字にマッチするショートカット文字を使用する必要があります。
+
+```js
+assert(/\\D/.test(noNumRegex.source));
+```
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(noNumRegex.global);
+```
+
+正規表現は、文字列 `9` の中に数字以外のものを見つけない必要があります。
+
+```js
+assert('9'.match(noNumRegex) == null);
+```
+
+正規表現は、文字列 `Catch 22` の中に数字以外の 6 個の文字を見つける必要があります。
+
+```js
+assert('Catch 22'.match(noNumRegex).length == 6);
+```
+
+正規表現は、文字列 `101 Dalmatians` の中に数字以外の 11 個の文字を見つける必要があります。
+
+```js
+assert('101 Dalmatians'.match(noNumRegex).length == 11);
+```
+
+正規表現は、文字列 `One, Two, Three` の中に数字以外の 15 個の文字を見つける必要があります。
+
+```js
+assert('One, Two, Three'.match(noNumRegex).length == 15);
+```
+
+正規表現は、文字列 `21 Jump Street` の中に数字以外の 12 個の文字を見つける必要があります。
+
+```js
+assert('21 Jump Street'.match(noNumRegex).length == 12);
+```
+
+正規表現は、文字列 `2001: A Space Odyssey` の中に数字以外の 17 個の文字を見つける必要があります。
+
+```js
+assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /change/; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /\D/g; // Change this line
+let result = movieName.match(noNumRegex).length;
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md

@@ -0,0 +1,85 @@
+---
+id: 5d712346c441eddfaeb5bdef
+title: すべての数字にマッチさせる
+challengeType: 1
+forumTopicId: 18181
+dashedName: match-all-numbers
+---
+
+# --description--
+
+英数字のような一般的な文字列パターンのショートカットを学びました。 もう一つの一般的なパターンは、数字や数値のみの検索です。
+
+数字を探すためのショートカットは `\d`で、小文字の `d` です。 これは文字クラス `[0-9]` と同等で、0 から 9 までの数字のうち任意の数字 1 文字を検索します。
+
+# --instructions--
+
+文字クラスの略記 `\d` を使用して、映画のタイトルに含まれている数字の個数を数えてください。 単語で書かれた数字 (6 ではなく「six」) は数えません。
+
+# --hints--
+
+正規表現で、数字にマッチするショートカット文字を使用する必要があります。
+
+```js
+assert(/\\d/.test(numRegex.source));
+```
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(numRegex.global);
+```
+
+正規表現は、文字列 `9` の中に 1 つ数字を見つける必要があります。
+
+```js
+assert('9'.match(numRegex).length == 1);
+```
+
+正規表現は、文字列 `Catch 22` の中に 2 つ数字を見つける必要があります。
+
+```js
+assert('Catch 22'.match(numRegex).length == 2);
+```
+
+正規表現は、文字列 `101 Dalmatians` の中に 3 つ数字を見つける必要があります。
+
+```js
+assert('101 Dalmatians'.match(numRegex).length == 3);
+```
+
+正規表現は、文字列 `One, Two, Three` の中に数字を見つけない必要があります。
+
+```js
+assert('One, Two, Three'.match(numRegex) == null);
+```
+
+正規表現は、文字列 `21 Jump Street` の中に 2 つ数字を見つける必要があります。
+
+```js
+assert('21 Jump Street'.match(numRegex).length == 2);
+```
+
+正規表現は、文字列 `2001: A Space Odyssey` の中に 4 つ数字を見つける必要があります。
+
+```js
+assert('2001: A Space Odyssey'.match(numRegex).length == 4);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /change/; // Change this line
+let result = movieName.match(numRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /\d/g; // Change this line
+let result = movieName.match(numRegex).length;
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md

@@ -0,0 +1,119 @@
+---
+id: 587d7db5367417b2b2512b94
+title: ワイルドカードのピリオドを使用してあらゆるものにマッチさせる
+challengeType: 1
+forumTopicId: 301348
+dashedName: match-anything-with-wildcard-period
+---
+
+# --description--
+
+パターンにある正確な文字がわからない (またはわかる必要がない) こともあります。 マッチするすべての単語を考えようとして、スペルミスをすると長い時間がかかってしまいます。 幸い、ワイルドカード文字 `.` を使用して時間を省くことができます。
+
+ワイルドカード文字 `.` は任意の 1 文字にマッチします。 このワイルドカードは `dot` (ドット)、`period` (ピリオド) とも呼ばれます。 ワイルドカード文字も正規表現で他の文字とまったく同じように使用できます。 たとえば、`hug`、`huh`、`hut`、`hum` にマッチさせたい場合は、正規表現 `/hu./` を使用して 4 つの単語すべてにマッチさせることができます。
+
+```js
+let humStr = "I'll hum a song";
+let hugStr = "Bear hug";
+let huRegex = /hu./;
+huRegex.test(humStr);
+huRegex.test(hugStr);
+```
+
+これらの `test` 呼び出しはどちらも `true` を返します。
+
+# --instructions--
+
+正規表現 `unRegex` を完成させて、文字列 `run`、`sun`、`fun`、`pun`、`nun`、`bun` にマッチさせてください。 正規表現ではワイルドカード文字を使用してください。
+
+# --hints--
+
+`.test()` メソッドを使用する必要があります。
+
+```js
+assert(code.match(/\.test\(.*\)/));
+```
+
+正規表現 `unRegex`でワイルドカード文字を使用する必要があります。
+
+```js
+assert(/\./.test(unRegex.source));
+```
+
+正規表現 `unRegex` は、文字列 `Let us go on a run.` の `run` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Let us go on a run.'));
+```
+
+正規表現 `unRegex` は、文字列 `The sun is out today.` の `sun` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('The sun is out today.'));
+```
+
+正規表現 `unRegex` は、文字列 `Coding is a lot of fun.` の `fun` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Coding is a lot of fun.'));
+```
+
+正規表現 `unRegex` は、文字列 `Seven days without a pun makes one weak.` の `pun` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Seven days without a pun makes one weak.'));
+```
+
+正規表現 `unRegex` は、文字列 `One takes a vow to be a nun.` の `nun` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('One takes a vow to be a nun.'));
+```
+
+正規表現 `unRegex` は、文字列 `She got fired from the hot dog stand for putting her hair in a bun.` の `bun` にマッチする必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(
+  unRegex.test(
+    'She got fired from the hot dog stand for putting her hair in a bun.'
+  )
+);
+```
+
+正規表現 `unRegex` は、文字列 `There is a bug in my code.` にマッチしない必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('There is a bug in my code.'));
+```
+
+正規表現 `unRegex` は、文字列 `Catch me if you can.` にマッチしない必要があります。
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('Catch me if you can.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /change/; // Change this line
+let result = unRegex.test(exampleStr);
+```
+
+# --solutions--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /.un/; // Change this line
+let result = unRegex.test(exampleStr);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md

@@ -0,0 +1,73 @@
+---
+id: 587d7db7367417b2b2512b9d
+title: 先頭の文字列パターンにマッチさせる
+challengeType: 1
+forumTopicId: 301349
+dashedName: match-beginning-string-patterns
+---
+
+# --description--
+
+これまでのチャレンジで、正規表現を使用して多くのマッチを探せることがわかりました。 正規表現では、文字列内で特定の位置にあるパターンを検索することもできます。
+
+以前のチャレンジでは、文字セットの内側でキャレット文字 (`^`) を使用して、`[^thingsThatWillNotBeMatched]` という形式で否定の文字セットを作成しました。 文字セットの外側でキャレットを使用すると、文字列の先頭にあるパターンを検索できます。
+
+```js
+let firstString = "Ricky is first and can be found.";
+let firstRegex = /^Ricky/;
+firstRegex.test(firstString);
+let notFirst = "You can't find Ricky now.";
+firstRegex.test(notFirst);
+```
+
+最初の `test` 呼び出しは `true` を返し、2 番目の呼び出しは `false` を返します。
+
+# --instructions--
+
+正規表現でキャレット文字を使用して、文字列 `rickyAndCal` の先頭にある `Cal` のみを検索してください。
+
+# --hints--
+
+正規表現で、1 文字目が大文字の文字列 `Cal` を検索する必要があります。
+
+```js
+assert(calRegex.source == '^Cal');
+```
+
+正規表現でフラグを使用しないでください。
+
+```js
+assert(calRegex.flags == '');
+```
+
+正規表現は、文字列の先頭にある文字列 `Cal` にマッチする必要があります。
+
+```js
+calRegex.lastIndex = 0;
+assert(calRegex.test('Cal and Ricky both like racing.'));
+```
+
+正規表現は、文字列の途中にある文字列 `Cal` にマッチしない必要があります。
+
+```js
+calRegex.lastIndex = 0;
+assert(!calRegex.test('Ricky and Cal both like racing.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /change/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
+
+# --solutions--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /^Cal/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db6367417b2b2512b99
+title: 1 回以上出現する文字にマッチさせる
+challengeType: 1
+forumTopicId: 301350
+dashedName: match-characters-that-occur-one-or-more-times
+---
+
+# --description--
+
+場合によっては、1 行に 1 回以上出現する文字 (または文字のグループ) にマッチさせる必要があります。 つまり、少なくとも 1 回出現し、繰り返される可能性がある文字です。
+
+`+` 文字を使用すると、そうしたマッチかどうかを調べることができます。 文字やパターンは連続して存在する必要があることに注意してください。 つまり、文字は連続して繰り返されている必要があります。
+
+たとえば、 `/a+/g` は `abc` で 1 つのマッチを見つけ、`["a"]` を返します。 `+` があるため、`aabc` でも単一のマッチを見つけ、`["aa"]` を返します。
+
+文字列 `abab` の場合は、`b` が間に入っていて `a` が連続していないため、2 つのマッチ `["a", "a"]` を見つけて返します。 文字列 `bcd` には `a`がないので、マッチしません。
+
+# --instructions--
+
+`Mississippi` で、文字 `s` が複数回出現する箇所にマッチを見つける必要があります。 `+` 記号を使用する正規表現を記述してください。
+
+# --hints--
+
+正規表現 `myRegex` で `+` 記号を使用して、1 つまたは複数の文字 `s` にマッチさせる必要があります。
+
+```js
+assert(/\+/.test(myRegex.source));
+```
+
+正規表現 `myRegex` は 2 つのアイテムにマッチする必要があります。
+
+```js
+assert(result.length == 2);
+```
+
+`result` 変数は、2 つの `ss` のマッチを含む配列となる必要があります。
+
+```js
+assert(result[0] == 'ss' && result[1] == 'ss');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /change/; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /s+/g; // Change this line
+let result = difficultSpelling.match(myRegex);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md

@@ -0,0 +1,96 @@
+---
+id: 587d7db6367417b2b2512b9a
+title: 0 回以上出現する文字にマッチさせる
+challengeType: 1
+forumTopicId: 301351
+dashedName: match-characters-that-occur-zero-or-more-times
+---
+
+# --description--
+
+前回のチャレンジでは、プラス `+` 記号を使用して、1 回以上出現する文字を検索しました。 0 回以上出現する文字にマッチするオプションもあります。
+
+それにはアスタリスクまたはスター `*` 文字を使用します。
+
+```js
+let soccerWord = "gooooooooal!";
+let gPhrase = "gut feeling";
+let oPhrase = "over the moon";
+let goRegex = /go*/;
+soccerWord.match(goRegex);
+gPhrase.match(goRegex);
+oPhrase.match(goRegex);
+```
+
+3 つの `match` 呼び出しは順に、値 `["goooooooo"]`、`["g"]`、`null` を返します。
+
+# --instructions--
+
+このチャレンジでは、`chewieQuote` を文字列 `Aaaaaaaaaaaaaaaarrrgh!` としてすでに初期化してあります。 `*` 文字を使用する正規表現 `chewieRegex` を作成し、`chewieQuote` の中で、大文字 `A` の直後に 0 個以上の小文字 `a` が続く箇所にマッチさせてください。 この正規表現にフラグや文字クラスは必要ありません。また、他のどの引用符ともマッチさせないでください。
+
+# --hints--
+
+正規表現 `chewieRegex` で `*` 文字を使用して、0 個以上の文字 `a` にマッチさせる必要があります。
+
+```js
+assert(/\*/.test(chewieRegex.source));
+```
+
+正規表現は `chewieQuote` にある文字列 `A` にマッチする必要があります。
+
+```js
+assert(result[0][0] === 'A');
+```
+
+正規表現は `chewieQuote` にある文字列 `Aaaaaaaaaaaaaaaa` にマッチする必要があります。
+
+```js
+assert(result[0] === 'Aaaaaaaaaaaaaaaa');
+```
+
+正規表現 `chewieRegex` は `chewieQuote` にある 16 文字にマッチする必要があります。
+
+```js
+assert(result[0].length === 16);
+```
+
+正規表現は文字列 `He made a fair move. Screaming about it can't help you.` にあるどの文字にもマッチしない必要があります。
+
+```js
+assert(
+  !"He made a fair move. Screaming about it can't help you.".match(chewieRegex)
+);
+```
+
+正規表現は文字列 `Let him have it. It's not wise to upset a Wookiee.` にあるどの文字にもマッチしない必要があります。
+
+```js
+assert(
+  !"Let him have it. It's not wise to upset a Wookiee.".match(chewieRegex)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+let chewieRegex = /change/; // Change this line
+// Only change code above this line
+
+let result = chewieQuote.match(chewieRegex);
+```
+
+# --solutions--
+
+```js
+  let chewieRegex = /Aa*/;
+  let result = chewieQuote.match(chewieRegex);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md

@@ -0,0 +1,66 @@
+---
+id: 587d7db7367417b2b2512b9e
+title: 末尾の文字列パターンにマッチさせる
+challengeType: 1
+forumTopicId: 301352
+dashedName: match-ending-string-patterns
+---
+
+# --description--
+
+前回のチャレンジでは、キャレット文字を使用して文字列の先頭にあるパターンを検索することを学びました。 文字列の末尾でパターンを検索する方法もあります。
+
+正規表現の末尾でドル記号 `$` を使用すると、文字列の末尾を検索できます。
+
+```js
+let theEnding = "This is a never ending story";
+let storyRegex = /story$/;
+storyRegex.test(theEnding);
+let noEnding = "Sometimes a story will have to end";
+storyRegex.test(noEnding);
+```
+
+最初の `test` 呼び出しは `true` を返し、2 番目の呼び出しは `false` を返します。
+
+# --instructions--
+
+アンカー文字 (`$`) を使用して、文字列 `caboose` の末尾にある文字列 `caboose` にマッチさせてください。
+
+# --hints--
+
+正規表現で末尾にドル記号 `$` を使用して `caboose` を検索する必要があります。
+
+```js
+assert(lastRegex.source == 'caboose$');
+```
+
+正規表現でフラグを使用しないでください。
+
+```js
+assert(lastRegex.flags == '');
+```
+
+文字列 `The last car on a train is the caboose` の末尾にある `caboose` にマッチさせる必要があります。
+
+```js
+lastRegex.lastIndex = 0;
+assert(lastRegex.test('The last car on a train is the caboose'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /change/; // Change this line
+let result = lastRegex.test(caboose);
+```
+
+# --solutions--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /caboose$/; // Change this line
+let result = lastRegex.test(caboose);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md

@@ -0,0 +1,92 @@
+---
+id: 587d7db8367417b2b2512ba0
+title: 英文字と数字以外のすべてのものにマッチさせる
+challengeType: 1
+forumTopicId: 301353
+dashedName: match-everything-but-letters-and-numbers
+---
+
+# --description--
+
+ショートカットを使用して、`\w` で英数字 `[A-Za-z0-9_]` にマッチさせることができることを学びました。 しかし英数字以外のものを検索したいと思うのが自然なパターンかもしれません。
+
+`\w` の反対を `\W` で検索できます。 ちなみに、逆のパターンでは大文字を使用します。 このショートカットは `[^A-Za-z0-9_]` と同じです。
+
+```js
+let shortHand = /\W/;
+let numbers = "42%";
+let sentence = "Coding!";
+numbers.match(shortHand);
+sentence.match(shortHand);
+```
+
+最初の `match` 呼び出しは値 `["%"]` を返し、2 番目は `["!"]` を返します。
+
+# --instructions--
+
+文字クラスの略記 `\W` を使用して、さまざまな引用符や文字列にある英数字以外の文字の数を数えてください。
+
+# --hints--
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(nonAlphabetRegex.global);
+```
+
+正規表現は、文字列 `The five boxing wizards jump quickly.` の中に英数字以外を 6 文字見つける必要があります。
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(nonAlphabetRegex).length == 6
+);
+```
+
+正規表現を英数字以外の文字にマッチさせるために、略記文字を使用する必要があります。
+
+```js
+assert(/\\W/.test(nonAlphabetRegex.source));
+```
+
+正規表現は、文字列 `Pack my box with five dozen liquor jugs.` の中に英数字以外を 8 文字見つける必要があります。
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(nonAlphabetRegex).length == 8
+);
+```
+
+正規表現は、文字列 `How vexingly quick daft zebras jump!` の中に英数字以外を 6 文字見つける必要があります。
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(nonAlphabetRegex).length == 6
+);
+```
+
+正規表現は、文字列 `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` の中に英数字以外を 12 文字見つける必要があります。
+
+```js
+assert(
+  '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(nonAlphabetRegex)
+    .length == 12
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let nonAlphabetRegex = /change/; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards_jump quickly.";
+let nonAlphabetRegex = /\W/g; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md

@@ -0,0 +1,71 @@
+---
+id: 587d7db5367417b2b2512b96
+title: アルファベットの文字にマッチさせる
+challengeType: 1
+forumTopicId: 301354
+dashedName: match-letters-of-the-alphabet
+---
+
+# --description--
+
+<dfn>文字セット</dfn>を使用して、マッチ対象の文字のグループを指定する方法を見てきました。しかし、マッチさせる文字の範囲が広い場合 (たとえば、アルファベットのすべての文字など)、たくさんの入力が必要になります。 幸い、その作業を手早く簡単にしてくれる組み込み機能があります。
+
+文字セットの中でハイフン文字 `-` を使用すると、マッチさせる文字の範囲を定義することができます。
+
+たとえば、小文字の `a` から `e` までマッチさせるには、`[a-e]` と記述します。
+
+```js
+let catStr = "cat";
+let batStr = "bat";
+let matStr = "mat";
+let bgRegex = /[a-e]at/;
+catStr.match(bgRegex);
+batStr.match(bgRegex);
+matStr.match(bgRegex);
+```
+
+3 つの `match` 呼び出しは順に、値 `["cat"]`、`["bat"]`、`null` を返します。
+
+# --instructions--
+
+文字列 `quoteSample` 内のすべての文字をマッチさせてください。
+
+**注**: 必ず大文字と小文字の両方をマッチさせてください。
+
+# --hints--
+
+正規表現 `alphabetRegex` は 35 個のアイテムにマッチする必要があります。
+
+```js
+assert(result.length == 35);
+```
+
+正規表現 `alphabetRegex` でグローバルフラグを使用する必要があります。
+
+```js
+assert(alphabetRegex.flags.match(/g/).length == 1);
+```
+
+正規表現 `alphabetRegex` で大文字小文字を区別しないフラグを使用する必要があります。
+
+```js
+assert(alphabetRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /change/; // Change this line
+let result = alphabetRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /[a-z]/gi; // Change this line
+let result = quoteSample.match(alphabetRegex); // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md

@@ -0,0 +1,74 @@
+---
+id: 587d7db3367417b2b2512b8f
+title: リテラル文字列にマッチさせる
+challengeType: 1
+forumTopicId: 301355
+dashedName: match-literal-strings
+---
+
+# --description--
+
+前回のチャレンジでは、正規表現 `/Hello/` を使用して `Hello` という単語を検索しました。 その正規表現は文字列 `Hello` のリテラルマッチ (記述した文字のとおりのマッチ) を検索しました。 ここでは、文字列 `Kevin` のリテラルマッチを検索する別の例を紹介します。
+
+```js
+let testStr = "Hello, my name is Kevin.";
+let testRegex = /Kevin/;
+testRegex.test(testStr);
+```
+
+この `test` 呼び出しは `true` を返します。
+
+`Kevin` の他の形式にはマッチしません。 たとえば、正規表現 `/Kevin/` は `kevin` または `KEVIN` にはマッチしません。
+
+```js
+let wrongRegex = /kevin/;
+wrongRegex.test(testStr);
+```
+
+この `test` 呼び出しは `false` を返します。
+
+以降のチャレンジでは、これらの他の形式にもマッチする方法を紹介します。
+
+# --instructions--
+
+正規表現 `waldoRegex` を完成させて、文字列 `waldoIsHiding` にある `"Waldo"` をリテラルマッチで検索してください。
+
+# --hints--
+
+正規表現 `waldoRegex` で文字列 `Waldo` を見つける必要があります。
+
+```js
+waldoRegex.lastIndex = 0;
+assert(waldoRegex.test(waldoIsHiding));
+```
+
+正規表現 `waldoRegex` では他に何も検索しないでください。
+
+```js
+waldoRegex.lastIndex = 0;
+assert(!waldoRegex.test('Somewhere is hiding in this text.'));
+```
+
+正規表現でリテラル文字列のマッチを実行する必要があります。
+
+```js
+assert(!/\/.*\/i/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /search/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
+
+# --solutions--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /Waldo/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md

@@ -0,0 +1,78 @@
+---
+id: 587d7db9367417b2b2512ba4
+title: 空白以外の文字にマッチさせる
+challengeType: 1
+forumTopicId: 18210
+dashedName: match-non-whitespace-characters
+---
+
+# --description--
+
+小文字の `s` による `\s` を使用した空白の検索方法を学びました。 空白以外のすべてのものを検索することもできます。
+
+空白以外を検索するには `\S` を使用します。これには大文字の `s` を使用します。 このパターンは、空白、キャリッジリターン、タブ、フォームフィード、および改行文字にマッチしません。 文字クラス `[^ \r\t\f\n\v]` に似たものと考えることができます。
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let nonSpaceRegex = /\S/g;
+whiteSpace.match(nonSpaceRegex).length;
+```
+
+`.length` メソッドによって返される値は `32` になります。
+
+# --instructions--
+
+正規表現 `countNonWhiteSpace` を変更して、文字列にある複数の空白以外の文字を検索してください。
+
+# --hints--
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(countNonWhiteSpace.global);
+```
+
+正規表現を空白以外のすべての文字にマッチさせるために、略記文字 `\S` を使用する必要があります。
+
+```js
+assert(/\\S/.test(countNonWhiteSpace.source));
+```
+
+正規表現は、文字列 `Men are from Mars and women are from Venus.` の中に 35 個のスペース以外の文字を見つける必要があります。
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countNonWhiteSpace)
+    .length == 35
+);
+```
+
+正規表現は、文字列 `Space: the final frontier.` の中に 23 個のスペース以外の文字を見つける必要があります。
+
+```js
+assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
+```
+
+正規表現は、文字列 `MindYourPersonalSpace` の中に 21 個のスペース以外の文字を見つける必要があります。
+
+```js
+assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /change/; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /\S/g; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md

@@ -0,0 +1,63 @@
+---
+id: 587d7db5367417b2b2512b97
+title: 数字とアルファベットの文字にマッチさせる
+challengeType: 1
+forumTopicId: 301356
+dashedName: match-numbers-and-letters-of-the-alphabet
+---
+
+# --description--
+
+ハイフン (`-`) を使用した文字の範囲のマッチは英文字に限定されません。 数字の範囲のマッチでも有効です。
+
+たとえば、`/[0-5]/` は `0` ～ `5` の間の任意の数字 (`0` と `5` を含む) にマッチします。
+
+また、英文字と数字の範囲を単一の文字セットに組み合わせることも可能です。
+
+```js
+let jennyStr = "Jenny8675309";
+let myRegex = /[a-z0-9]/ig;
+jennyStr.match(myRegex);
+```
+
+# --instructions--
+
+`h` ～ `s` の文字範囲と `2` ～ `6` の数字範囲にマッチする単一の正規表現を作成してください。 正規表現に適切なフラグを含めることを忘れないでください。
+
+# --hints--
+
+正規表現 `myRegex` は 17 個のアイテムにマッチする必要があります。
+
+```js
+assert(result.length == 17);
+```
+
+正規表現 `myRegex` でグローバルフラグを使用する必要があります。
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+正規表現 `myRegex` で大文字小文字を区別しないフラグを使用する必要があります。
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /[h-s2-6]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db5367417b2b2512b95
+title: 複数の候補を持つ単一の文字にマッチさせる
+challengeType: 1
+forumTopicId: 301357
+dashedName: match-single-character-with-multiple-possibilities
+---
+
+# --description--
+
+リテラルパターン (`/literal/`) とワイルドカード文字 (`/./`) にマッチさせる方法を学びました。 これらは正規表現の極端なもので、前者は完全にマッチするものを見つけ、後者はすべてにマッチします。 これら両極端の間をとったオプションがあります。
+
+<dfn>文字クラス</dfn>を使用すると、ある程度柔軟にリテラルパターンを検索できます。 文字クラスでは、マッチさせたい文字のグループを角括弧 (`[` と `]`) で囲むことで定義できます。
+
+たとえば、`bag`、`big`、`bug` にマッチし、`bog` にマッチしないようにするには、 正規表現 `/b[aiu]g/` を作成します。 `[aiu]` は、文字 `a`、`i`、または `u` にのみマッチする文字クラスです。
+
+```js
+let bigStr = "big";
+let bagStr = "bag";
+let bugStr = "bug";
+let bogStr = "bog";
+let bgRegex = /b[aiu]g/;
+bigStr.match(bgRegex);
+bagStr.match(bgRegex);
+bugStr.match(bgRegex);
+bogStr.match(bgRegex);
+```
+
+4 つの `match` 呼び出しは順に、値 `["big"]`、`["bag"]`、`["bug"]`、`null` を返します。
+
+# --instructions--
+
+母音 (`a`、`e`、`i`、`o`、`u`) を持つ文字クラスを正規表現 `vowelRegex` で使用して、文字列 `quoteSample` 内のすべての母音を検索してください。
+
+**注:** 必ず大文字と小文字の両方をマッチさせてください。
+
+# --hints--
+
+25 個の母音をすべて見つける必要があります。
+
+```js
+assert(result.length == 25);
+```
+
+正規表現 `vowelRegex` で文字クラスを使用する必要があります。
+
+```js
+assert(/\[.*\]/.test(vowelRegex.source));
+```
+
+正規表現 `vowelRegex` でグローバルフラグを使用する必要があります。
+
+```js
+assert(vowelRegex.flags.match(/g/).length == 1);
+```
+
+正規表現 `vowelRegex` で大文字小文字を区別しないフラグを使用する必要があります。
+
+```js
+assert(vowelRegex.flags.match(/i/).length == 1);
+```
+
+正規表現はどの子音にもマッチしない必要があります。
+
+```js
+assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /change/; // Change this line
+let result = vowelRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /[aeiou]/gi; // Change this line
+let result = quoteSample.match(vowelRegex); // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md

@@ -0,0 +1,57 @@
+---
+id: 587d7db6367417b2b2512b98
+title: 未指定の単一の文字にマッチさせる
+challengeType: 1
+forumTopicId: 301358
+dashedName: match-single-characters-not-specified
+---
+
+# --description--
+
+ここまでは、マッチさせたい文字のセットを作成していましたが、マッチさせたくない文字のセットを作成することもできます。 このタイプの文字セットのことを<dfn>否定文字セット</dfn>と呼びます。
+
+否定文字セットを作成するには、開始角括弧の後の、マッチさせたくない文字の前に、キャレット文字 (`^`) を置きます。
+
+たとえば、 `/[^aeiou]/gi` は母音でないすべての文字にマッチします。 `.`、`!`、`[`、`@`、`/` などの文字および空白にはマッチします。そのため、母音の否定文字セットは母音の文字だけを除外します。
+
+# --instructions--
+
+数字でも母音でもないすべての文字にマッチする単一の正規表現を作成してください。 正規表現に適切なフラグを含めることを忘れないでください。
+
+# --hints--
+
+正規表現 `myRegex` は 9 個のアイテムにマッチする必要があります。
+
+```js
+assert(result.length == 9);
+```
+
+正規表現 `myRegex` でグローバルフラグを使用する必要があります。
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+正規表現 `myRegex` で大文字小文字を区別しないフラグを使用する必要があります。
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /[^0-9aeiou]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md

@@ -0,0 +1,77 @@
+---
+id: 587d7db8367417b2b2512ba3
+title: 空白にマッチさせる
+challengeType: 1
+forumTopicId: 301359
+dashedName: match-whitespace
+---
+
+# --description--
+
+ここまでのチャレンジでは、アルファベットと数字の文字のマッチングについて説明しました。 文字間の空白やスペースにマッチさせることもできます。
+
+空白を検索するには `\s` (小文字の `s`) を使用できます。 このパターンは、空白にマッチするだけでなく、キャリッジリターン、タブ、フォームフィード、改行文字にもマッチします。 文字クラス`[ \r\t\f\n\v]` に似たものと考えることができます。
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let spaceRegex = /\s/g;
+whiteSpace.match(spaceRegex);
+```
+
+この `match` 呼び出しは `[" ", " "]` を返します。
+# --instructions--
+
+正規表現 `countWhiteSpace` を変更して、文字列内の複数の空白を検索してください。
+
+# --hints--
+
+正規表現でグローバルフラグを使用する必要があります。
+
+```js
+assert(countWhiteSpace.global);
+```
+
+正規表現を空白にマッチさせるために、略記文字 `\s` を使用する必要があります。
+
+```js
+assert(/\\s/.test(countWhiteSpace.source));
+```
+
+正規表現は、文字列 `Men are from Mars and women are from Venus.` の中に 8 個のスペースを見つける必要があります。
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countWhiteSpace).length ==
+    8
+);
+```
+
+正規表現は、文字列 `Space: the final frontier.` の中に 3 個のスペースを見つける必要があります。
+
+```js
+assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
+```
+
+正規表現は、文字列 `MindYourPersonalSpace` の中にスペースを見つけない必要があります。
+
+```js
+assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /change/; // Change this line
+let result = sample.match(countWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /\s/g;
+let result = sample.match(countWhiteSpace);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md

@@ -0,0 +1,122 @@
+---
+id: 587d7dba367417b2b2512ba9
+title: 肯定先読みと否定先読み
+challengeType: 1
+forumTopicId: 301360
+dashedName: positive-and-negative-lookahead
+---
+
+# --description--
+
+<dfn>先読み</dfn>とは、文字列の先頭から調べるように JavaScript に指示するパターンです。 これは、同じ文字列で複数のパターンを検索する場合に便利です。
+
+先読みには<dfn>肯定先読み</dfn>と<dfn>否定先読み</dfn>の 2 種類があります。
+
+肯定先読みは、検索パターン内に要素が存在することを確認しますが、実際にはマッチさせません。 肯定先読みは、`(?=...)` として使用します。ここで `...` は、必要ですがマッチさせない部分です。
+
+一方、否定先読みは、検索パターン内に要素が存在しないことを確認します。 否定先読みは、`(?!...)` として使用します。ここで `...` は、そこで必要としていないパターンです。 否定先読みの部分が存在しない場合は、パターンの残りの部分が返されます。
+
+先読みは少しわかりにくいですが、いくつか役に立つ例もあります。
+
+```js
+let quit = "qu";
+let noquit = "qt";
+let quRegex= /q(?=u)/;
+let qRegex = /q(?!u)/;
+quit.match(quRegex);
+noquit.match(qRegex);
+```
+
+これらの `match` 呼び出しはどちらも `["q"]` を返します。
+
+より実用的な用法として、先読みを使用して 1 つの文字列の中で 2 つ以上のパターンをチェックすることができます。 次に示すのは、3 文字から 6 文字までの文字と、少なくとも 1 つの数字を探す、ごく単純なパスワードチェッカーの例です。
+
+```js
+let password = "abc123";
+let checkPass = /(?=\w{3,6})(?=\D*\d)/;
+checkPass.test(password);
+```
+
+# --instructions--
+
+`pwRegex` で先読みを使用して、5 文字を超える長さがあり、2 つの連続した数字を含むパスワードにマッチさせてください。
+
+# --hints--
+
+正規表現で肯定先読み``を 2 つ使用する必要があります。
+
+```js
+assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
+```
+
+正規表現は文字列 `astronaut` にマッチしない必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('astronaut'));
+```
+
+正規表現は文字列 `banan1` にマッチしない必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('banan1'));
+```
+
+正規表現は文字列 `bana12` にマッチする必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('bana12'));
+```
+
+正規表現は文字列 `abc123` にマッチする必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('abc123'));
+```
+
+正規表現は文字列 `12345` にマッチしない必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('12345'));
+```
+
+正規表現は文字列 `8pass99` にマッチする必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('8pass99'));
+```
+
+正規表現は文字列 `1a2bcde` にマッチしない必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('1a2bcde'));
+```
+
+正規表現は文字列 `astr1on11aut` にマッチする必要があります。
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('astr1on11aut'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sampleWord = "astronaut";
+let pwRegex = /change/; // Change this line
+let result = pwRegex.test(sampleWord);
+```
+
+# --solutions--
+
+```js
+let pwRegex =  /(?=\w{6})(?=\w*\d{2})/;
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md

@@ -0,0 +1,61 @@
+---
+id: 587d7dbb367417b2b2512bac
+title: 先頭と末尾から空白を削除する
+challengeType: 1
+forumTopicId: 301362
+dashedName: remove-whitespace-from-start-and-end
+---
+
+# --description--
+
+文字列の両端に不要な空白文字が含まれていることがあります。 文字列の先頭と末尾の空白を削除する処理はよく行われます。
+
+# --instructions--
+
+正規表現で適切な文字列メソッドを使用して、文字列の先頭と末尾の空白を削除してください。
+
+**注:** `String.prototype.trim()` メソッドもこの例では有効ですが、正規表現を使用してこのチャレンジを完了する必要があります。
+
+# --hints--
+
+`result` は文字列 `Hello, World!` と等しくなる必要があります。
+
+```js
+assert(result === 'Hello, World!');
+```
+
+解答では `String.prototype.trim()` メソッドを使用しないでください。
+
+```js
+assert(!code.match(/\.?[\s\S]*?trim/));
+```
+
+`result` 変数に文字列を直接設定しないでください。
+
+```js
+assert(!code.match(/result\s*=\s*["'`].*?["'`]/));
+```
+
+`hello` 変数の値は変更しないでください。
+
+```js
+assert(hello === '   Hello, World!  ');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let hello = "   Hello, World!  ";
+let wsRegex = /change/; // Change this line
+let result = hello; // Change this line
+```
+
+# --solutions--
+
+```js
+let hello = "   Hello, World!  ";
+let wsRegex = /^(\s+)(.+[^\s])(\s+)$/;
+let result = hello.replace(wsRegex, '$2');
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md

@@ -0,0 +1,136 @@
+---
+id: 587d7db8367417b2b2512ba2
+title: ユーザー名の候補を制限する
+challengeType: 1
+forumTopicId: 301363
+dashedName: restrict-possible-usernames
+---
+
+# --description--
+
+ユーザー名はインターネット上の至るところで使用されています。 これらは、お気に入りのサイトでユーザーを一意に識別するものです。
+
+データベース内ですべてのユーザー名を確認する必要があります。 ユーザー名を作成する際に、ユーザーが従わなければならない簡単なルールをいくつか示します。
+
+1) ユーザー名には英数字のみが使用できます。
+
+2) ユーザー名に数字を付ける場合は末尾にのみ付けることができます。 末尾には 0 個以上の数字を付けることができます。 ユーザー名を数字で始めることはできません。
+
+3) ユーザー名には小文字と大文字が使用できます。
+
+4) ユーザー名の長さは 2 文字以上にする必要があります。 ユーザー名を 2 文字にする場合は、文字としてアルファベットのみが使用できます。
+
+# --instructions--
+
+上記の制約に合うように正規表現 `userCheck` を変更してください。
+
+# --hints--
+
+正規表現は文字列 `JACK` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('JACK'));
+```
+
+正規表現は文字列 `J` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('J'));
+```
+
+正規表現は文字列 `Jo` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Jo'));
+```
+
+正規表現は文字列 `Oceans11` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Oceans11'));
+```
+
+正規表現は文字列 `RegexGuru` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('RegexGuru'));
+```
+
+正規表現は文字列 `007` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('007'));
+```
+
+正規表現は文字列 `9` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('9'));
+```
+
+正規表現は文字列 `A1` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('A1'));
+```
+
+正規表現が文字列 `BadUs3rnam3` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('BadUs3rnam3'));
+```
+
+正規表現は文字列 `Z97` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Z97'));
+```
+
+正規表現は文字列 `c57bT3` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('c57bT3'));
+```
+
+正規表現は文字列 `AB1` にマッチする必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('AB1'));
+```
+
+正規表現は文字列 `J%4` にマッチしない必要があります。
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('J%4'))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let username = "JackOfAllTrades";
+let userCheck = /change/; // Change this line
+let result = userCheck.test(username);
+```
+
+# --solutions--
+
+```js
+let username = "JackOfAllTrades";
+const userCheck = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i;
+let result = userCheck.test(username);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md

@@ -0,0 +1,115 @@
+---
+id: 587d7dbb367417b2b2512baa
+title: キャプチャグループを使用してパターンを再利用する
+challengeType: 1
+forumTopicId: 301364
+dashedName: reuse-patterns-using-capture-groups
+---
+
+# --description--
+
+次のように複数回出現する単語にマッチさせたいとします。
+
+```js
+let repeatStr = "row row row your boat";
+```
+
+`/row row row/` を使用することもできますが、繰り返される具体的な言葉がわからない場合はどうしますか？ <dfn>キャプチャグループ</dfn>を使用すると、繰り返される部分文字列を見つけることができます。
+
+キャプチャグループは、キャプチャする正規表現パターンを丸括弧で囲んで構成します。 この例では、英数字で構成される単語をキャプチャすることが目的なので、キャプチャグループは `\w+` を丸括弧で囲んだ `/(\w+)/` になります。
+
+グループにマッチした部分文字列は一時的な「変数」に保存されます。 これには同じ正規表現の中で、バックスラッシュ (または円記号) とキャプチャグループの番号を使用してアクセスできます (例: `\1`)。 キャプチャグループは、開始括弧の位置に応じて (左から右の順で) 自動的に 1 から番号付けされます。
+
+次の例は、スペースで 3 つに区切られた単語にマッチします。
+
+```js
+let repeatRegex = /(\w+) \1 \1/;
+repeatRegex.test(repeatStr); // Returns true
+repeatStr.match(repeatRegex); // Returns ["row row row", "row"]
+```
+
+文字列に `.match()` メソッドを使用すると、キャプチャグループとともに、一致した部分文字列を持つ配列が返されます。
+
+
+# --instructions--
+
+`reRegex` でキャプチャグループを使用して、単一のスペースで区切られ、同じ数字のみが正確に 3 回繰り返される構成の文字列にマッチさせてください。
+
+# --hints--
+
+正規表現で数字の略記文字クラスを使用する必要があります。
+
+```js
+assert(reRegex.source.match(/\\d/));
+```
+
+正規表現でキャプチャグループを 2 回再利用する必要があります。
+
+```js
+assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
+```
+
+正規表現は文字列 `42 42 42` にマッチする必要があります。
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('42 42 42'));
+```
+
+正規表現は文字列 `100 100 100` にマッチする必要があります。
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('100 100 100'));
+```
+
+正規表現は文字列 `42 42 42 42` にマッチしない必要があります。
+
+```js
+assert.equal('42 42 42 42'.match(reRegex.source), null);
+```
+
+正規表現は文字列 `42 42` にマッチしない必要があります。
+
+```js
+assert.equal('42 42'.match(reRegex.source), null);
+```
+
+正規表現は文字列 `101 102 103` にマッチしない必要があります。
+
+```js
+reRegex.lastIndex = 0;
+assert(!reRegex.test('101 102 103'));
+```
+
+正規表現は文字列 `1 2 3` にマッチしない必要があります。
+
+```js
+reRegex.lastIndex = 0;
+assert(!reRegex.test('1 2 3'));
+```
+
+正規表現は文字列 `10 10 10` にマッチする必要があります。
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('10 10 10'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /change/; // Change this line
+let result = reRegex.test(repeatNum);
+```
+
+# --solutions--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /^(\d+)\s\1\s\1$/;
+let result = reRegex.test(repeatNum);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md

@@ -0,0 +1,92 @@
+---
+id: 587d7db9367417b2b2512ba7
+title: マッチさせる数を厳密に指定する
+challengeType: 1
+forumTopicId: 301365
+dashedName: specify-exact-number-of-matches
+---
+
+# --description--
+
+中括弧を使用して、数量指定子でパターンの最小数と最大数を指定できます。 特定の数のマッチしか必要としない場合があります。
+
+特定数のパターンを指定するには、中括弧の間に数字を 1 つ指定します。
+
+たとえば、単語 `hah` に対して文字 `a` を `3` 回だけマッチさせる正規表現は、`/ha{3}h/` となります。
+
+```js
+let A4 = "haaaah";
+let A3 = "haaah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleHA = /ha{3}h/;
+multipleHA.test(A4);
+multipleHA.test(A3);
+multipleHA.test(A100);
+```
+
+3 つの `test` 呼び出しは順に、`false`、`true`、`false` を返します。
+
+# --instructions--
+
+正規表現 `timRegex` を変更して、単語 `Timber` に対して 4 つの文字 `m` を持つ場合のみにマッチさせてください。
+
+# --hints--
+
+正規表現で中括弧を使用してください。
+
+```js
+assert(timRegex.source.match(/{.*?}/).length > 0);
+```
+
+正規表現は文字列 `Timber` にマッチしない必要があります。
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timber'));
+```
+
+正規表現は文字列 `Timmber` にマッチしない必要があります。
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmber'));
+```
+
+正規表現は文字列 `Timmmber` にマッチしない必要があります。
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmmber'));
+```
+
+正規表現は文字列 `Timmmmber` にマッチする必要があります。
+
+```js
+timRegex.lastIndex = 0;
+assert(timRegex.test('Timmmmber'));
+```
+
+正規表現は、30 個の `m` を持つ文字列 `Timber` にマッチしない必要があります。
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Ti' + 'm'.repeat(30) + 'ber'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /change/; // Change this line
+let result = timRegex.test(timStr);
+```
+
+# --solutions--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /Tim{4}ber/; // Change this line
+let result = timRegex.test(timStr);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md

@@ -0,0 +1,95 @@
+---
+id: 587d7db9367417b2b2512ba6
+title: 最小マッチ数のみを指定する
+challengeType: 1
+forumTopicId: 301366
+dashedName: specify-only-the-lower-number-of-matches
+---
+
+# --description--
+
+中括弧を使用して、数量指定子でパターンの最小数と最大数を指定できます。 上限なしでパターンの最小数だけを指定したい場合があります。
+
+パターンの最小数だけを指定するには、最初の数字の後にコンマを置いてください。
+
+たとえば、文字列 `hah` に対して文字 `a` が少なくとも `3` 回出現する場合にマッチさせる正規表現は、`/ha{3,}h/` となります。
+
+```js
+let A4 = "haaaah";
+let A2 = "haah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleA = /ha{3,}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+multipleA.test(A100);
+```
+
+3 つの `test` 呼び出しは順に、`true`、`false`、`true` を返します。
+
+# --instructions--
+
+正規表現 `haRegex` を変更して、単語 `Hazzah` を 4 つ以上の文字 `z` を持つ場合のみにマッチさせてください。
+
+# --hints--
+
+正規表現で中括弧を使用してください。
+
+```js
+assert(haRegex.source.match(/{.*?}/).length > 0);
+```
+
+正規表現は文字列 `Hazzah` にマッチしない必要があります。
+
+```js
+haRegex.lastIndex = 0;
+assert(!haRegex.test('Hazzah'));
+```
+
+正規表現は文字列 `Hazzzah` にマッチしない必要があります。
+
+```js
+haRegex.lastIndex = 0;
+assert(!haRegex.test('Hazzzah'));
+```
+
+正規表現は文字列 `Hazzzzah` にマッチする必要があります。
+
+```js
+assert('Hazzzzah'.match(haRegex)[0].length === 8);
+```
+
+正規表現は文字列 `Hazzzzzah` にマッチする必要があります。
+
+```js
+assert('Hazzzzzah'.match(haRegex)[0].length === 9);
+```
+
+正規表現は文字列 `Hazzzzzzah` にマッチする必要があります。
+
+```js
+assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
+```
+
+正規表現は、30 個の `z` を持つ文字列 `Hazzah` にマッチする必要があります。
+
+```js
+assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /change/; // Change this line
+let result = haRegex.test(haStr);
+```
+
+# --solutions--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /Haz{4,}ah/; // Change this line
+let result = haRegex.test(haStr);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md

@@ -0,0 +1,93 @@
+---
+id: 587d7db9367417b2b2512ba5
+title: マッチ数の上限と下限を指定する
+challengeType: 1
+forumTopicId: 301367
+dashedName: specify-upper-and-lower-number-of-matches
+---
+
+# --description--
+
+プラス記号 `+` を使用して 1 個以上の文字を検索し、アスタリスク `*` を使用して 0 個以上の文字を検索することについてすでに説明しました。 これらは便利ですが、パターンの特定の範囲にマッチさせたい場合もあります。
+
+<dfn>数量指定子</dfn>を使用すると、パターン数の下限と上限を指定できます。 数量指定子は中括弧 (`{` と `}`) と一緒に使用します。 中括弧の間に 2 つの数字を入れると、パターンの最小数と最大数になります。
+
+たとえば、文字列 `ah` の中で文字 `a` が `3` 回から `5` 回まで出現する場合のみにマッチさせる正規表現は、`/a{3,5}h/` となります。
+
+```js
+let A4 = "aaaah";
+let A2 = "aah";
+let multipleA = /a{3,5}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+```
+
+最初の `test` 呼び出しは `true`を返し、2 番目の呼び出しは `false` を返します。
+
+# --instructions--
+
+正規表現 `ohRegex` を変更して、フレーズ `Oh no` について全体で文字 `h` が `3` 個から `6` 個まで出現する場合のみにマッチさせてください。
+
+# --hints--
+
+正規表現で中括弧を使用してください。
+
+```js
+assert(ohRegex.source.match(/{.*?}/).length > 0);
+```
+
+正規表現は文字列 `Ohh no` にマッチしない必要があります。
+
+```js
+ohRegex.lastIndex = 0;
+assert(!ohRegex.test('Ohh no'));
+```
+
+正規表現は文字列 `Ohhh no` にマッチする必要があります。
+
+```js
+assert('Ohhh no'.match(ohRegex)[0].length === 7);
+```
+
+正規表現は文字列 `Ohhhh no` にマッチする必要があります。
+
+```js
+assert('Ohhhh no'.match(ohRegex)[0].length === 8);
+```
+
+正規表現は文字列 `Ohhhhh no` にマッチする必要があります。
+
+```js
+assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
+```
+
+正規表現は文字列 `Ohhhhhh no` にマッチする必要があります。
+
+```js
+assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
+```
+
+正規表現は文字列 `Ohhhhhhh no` にマッチしない必要があります。
+
+```js
+ohRegex.lastIndex = 0;
+assert(!ohRegex.test('Ohhhhhhh no'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /change/; // Change this line
+let result = ohRegex.test(ohStr);
+```
+
+# --solutions--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /Oh{3,6} no/; // Change this line
+let result = ohRegex.test(ohStr);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md

@@ -0,0 +1,88 @@
+---
+id: 587d7dbb367417b2b2512bab
+title: キャプチャグループを使用して検索と置換をする
+challengeType: 1
+forumTopicId: 301368
+dashedName: use-capture-groups-to-search-and-replace
+---
+
+# --description--
+
+検索は便利ですが、 マッチさせたテキストを変更 (または置換) すると、検索をさらに強力にすることができます。
+
+文字列では `.replace()` を使用して文字列内のテキストを検索したり置換したりできます。 `.replace()` への最初の入力には、検索したい正規表現パターンを渡します。 2 番目のパラメーターには、マッチしたものを置き換える文字列や、何かを実行する関数を渡します。
+
+```js
+let wrongText = "The sky is silver.";
+let silverRegex = /silver/;
+wrongText.replace(silverRegex, "blue");
+```
+
+この `replace` 呼び出しは文字列 `The sky is blue.` を返します。
+
+また、置換文字列のキャプチャグループにドル記号 (`$`) でアクセスすることもできます。
+
+```js
+"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
+```
+
+この `replace` 呼び出しは文字列 `Camp Code` を返します。
+
+# --instructions--
+
+3 つのキャプチャグループを使用して正規表現 `fixRegex` を記述し、文字列 `one two three` 内の各単語を検索してください。 次に、`replaceText` 変数を更新して、`one two three` を文字列 `three two one` に置き換え、 `result` 変数に結果を代入してください。 ドル記号 (`$`) の構文を使用して、置換文字列でキャプチャグループを使用してください。
+
+# --hints--
+
+検索と置換に `.replace()` を使用してください。
+
+```js
+assert(code.match(/\.replace\(.*\)/));
+```
+
+正規表現で、文字列 `one two three` を文字列 `three two one` に変更する必要があります。
+
+```js
+assert(result === 'three two one');
+```
+
+最後の行を変更しないでください。
+
+```js
+assert(code.match(/result\s*=\s*str\.replace\(.*?\)/));
+```
+
+`fixRegex` では少なくとも 3 つのキャプチャグループを使用する必要があります。
+
+```js
+assert(new RegExp(fixRegex.source + '|').exec('').length - 1 >= 3);
+```
+
+`replaceText` では丸括弧付きの部分マッチ文字列を使用する必要があります (つまり、n 番目の括弧付きの部分マッチ文字列である $n は、n 番目のキャプチャグループに対応します)。
+
+```js
+{
+  const re = /(\$\d{1,2})+(?:[\D]|\b)/g;
+  assert(replaceText.match(re).length >= 3);
+}
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let str = "one two three";
+let fixRegex = /change/; // Change this line
+let replaceText = ""; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
+
+# --solutions--
+
+```js
+let str = "one two three";
+let fixRegex = /(\w+) (\w+) (\w+)/g; // Change this line
+let replaceText = "$3 $2 $1"; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```

curriculum/challenges/japanese/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db3367417b2b2512b8e
+title: test メソッドを使用する
+challengeType: 1
+forumTopicId: 301369
+dashedName: using-the-test-method
+---
+
+# --description--
+
+正規表現は、プログラミング言語で文字列の一部分にマッチさせる場合に使用します。 その際、マッチングに役立つパターンを作成します。
+
+文字列 `The dog chased the cat` で単語 `the` を見つけたい場合は、正規表現 `/the/` を使用できます。 正規表現の中では引用符は必須ではありません。
+
+JavaScript では、正規表現を複数の方法で使用することができます。 正規表現をテストする方法の 1 つとして、`.test()` メソッドの使用があります。 `.test()` は正規表現を受け取り、それを (丸括弧内に配置された) 文字列に適用して、パターンが何かにマッチした場合は `true` を返し、何も見つからなかった場合は `false` を返します。
+
+```js
+let testStr = "freeCodeCamp";
+let testRegex = /Code/;
+testRegex.test(testStr);
+```
+
+この `test` メソッドは `true` を返します。
+
+# --instructions--
+
+`.test()` メソッドを使用して、文字列 `myString` に正規表現 `myRegex` を適用してください。
+
+# --hints--
+
+`.test()` を使用して正規表現をテストする必要があります。
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+結果は `true` を返す必要があります。
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex.test(myString); // Change this line
+```