chore(i18n,curriculum): processed translations - new ukrainian (#44447)

curriculum/challenges/ukrainian/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--
+
+Іноді шаблони, які ви хочете знайте, можуть мати частини, які можуть або існувати або ні. Однак може бути важливо все-таки перевірити їх.
+
+Ви можете вказати можливу наявність елемента за допомогою знаку питання, `?`. Таким чином ви зможете перевірити відсутність або наявність одного з попередніх елементів. Вважайте, що цей символ вказує на те, що попередній елемент необов'язковий.
+
+Наприклад, в американській та британській англійській мові є незначні відмінності правопису, і ви можете скористатися знаком питання, щоб відповідати обом системам орфографії.
+
+```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/ukrainian/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--
+
+Ви маєте отримати `true` для рядка `Franklin D. Roosevelt` за допомогою вашого регулярного виразу `myRegex`
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Franklin D. Roosevelt'));
+```
+
+Ви маєте отримати `true` для рядка `Eleanor Roosevelt` за допомогою вашого регулярного виразу `myRegex`
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Eleanor Roosevelt'));
+```
+
+Ви маєте отримати `false` для рядка `Franklin Rosevelt` за допомогою вашого регулярного виразу `myRegex`
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Franklin Rosevelt'));
+```
+
+Ви маєте отримати `false` для рядка `Frank Roosevelt` за допомогою вашого регулярного виразу `myRegex`
+
+```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/ukrainian/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"]`, а другий - `["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/ukrainian/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>greedy</dfn>) знаходить найдовшу можливу частину рядка, яка відповідає шаблону регулярного виразу та видає його як збіг. Альтернативою є "лінивий" збіг (<dfn>lazy</dfn>), який знаходить найменшу можливу частину рядка, що відповідає шаблону регулярного виразу.
+
+Ви можете застосувати регулярний вираз `/t[a-z]*i/` до рядка `"titanic"`. Цей регулярний вираз фактично є шаблоном, який починається з `t`, закінчується на `i` та має кілька літер між ними.
+
+Регулярні вирази за замовчуванням "жадібні", тому збіг видасть `["titani"]`. Він знаходить найбільший можливий підрядок, який відповідає шаблону.
+
+Однак ви можете застосувати символ `?`, щоб змінити його на "лінивий" пошук збігів. Код `"titanic"`, зіставлений зі скоригованим регулярним виразом `/t[a-z]*?i/`, видає `["ti"]`.
+
+**Примітка:** Слід уникати синтаксичного аналізу HTML регулярних виразів, але ви можете зіставляти рядок HTML з шаблоном за допомогою регулярних виразів.
+
+# --instructions--
+
+Виправте регулярний вираз `/<.*>/`, аби він видав теґ HTML `<h1>`, а не текст `"<h1>Winter is coming</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/ukrainian/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--
+
+До цього ви могли вилучати або шукати шаблон лише один раз.
+
+```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--
+
+Знайдіть і вилучіть обидва слова `Twinkle` з рядка `twinkleStar` за допомогою регулярного виразу `starRegex`.
+
+**Примітка**  
+Ви можете мати декілька прапорців у вашому регулярному виразі, як у `/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` повинен містити в собі два елементи.
+
+```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/ukrainian/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md

@@ -0,0 +1,108 @@
+---
+id: 587d7db7367417b2b2512b9c
+title: Знайдіть одного або більше злочинців у переслідуванні
+challengeType: 1
+forumTopicId: 301343
+dashedName: find-one-or-more-criminals-in-a-hunt
+---
+
+# --description--
+
+Настав час зупинитися та перевірити ваші нові навички написання регулярних виразів. Група злочинців втекла з в'язниці, але ви не знаєте скільки. Однак ви знаєте, що вони тримаються разом, коли довкола них інші люди. Ви відповідаєте за те, щоб знайти всіх злочинців одразу.
+
+Ось приклад, який допоможе вам розібратися, як це зробити:
+
+Регулярний вираз `/z+/` відповідає літері `z`, коли вона з'являється один або кілька разів поспіль. Він знайде збіги в усіх цих рядках:
+
+```js
+"z"
+"zzzzzz"
+"ABCzzzz"
+"zzzzABC"
+"abczzzzzzzzzzzzzzzzzzzzzabc"
+```
+
+Але він не знайде збігів у цих рядках, оскільки в них немає жодного символу на позначення літери `z`:
+
+```js
+""
+"ABC"
+"abcabc"
+```
+
+# --instructions--
+
+Напишіть "жадібний" регулярний вираз, який знайде одного або кількох злочинців в групі інших людей. Злочинець позначений великою літерою `C`.
+
+# --hints--
+
+Ваш регулярний вираз має знайти одного злочинця (`C`) в рядку `C`
+
+```js
+assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
+```
+
+Ваш регулярний вираз має знайти двох злочинців (`CC`) у рядку `CC`
+
+```js
+assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
+```
+
+Ваш регулярний вираз має знайти трьох злочинців (`CCC`) у рядку `P1P5P4CCCcP2P6P3`.
+
+```js
+assert(
+  'P1P5P4CCCcP2P6P3'.match(reCriminals) &&
+    'P1P5P4CCCcP2P6P3'.match(reCriminals)[0] == 'CCC'
+);
+```
+
+Ваш регулярний вираз має знайти п'ятьох злочинців (`CCCCC`) у рядку `P6P2P7P4P5CCCCCP3P1`
+
+```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'));
+```
+
+Ваш регулярний вираз має знайти п'ятдесят злочинців (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) у рядку `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
+
+```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/ukrainian/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--
+
+Напишіть регулярний вираз `fccRegex`, щоб знайти `freeCodeCamp` незалежно від регістру. Ваш регулярний вираз не повинен збігатися зі скороченнями або варіаціями з пробілами.
+
+# --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/ukrainian/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` в іншому рядку.
+
+Це корисно для пошуку окремих рядків, але він обмежений лише одним шаблоном. Ви можете шукати кілька шаблонів одразу за допомогою оператора `alternation` або `OR`: `|`.
+
+Цей оператор знаходить збіги шаблонів до або після нього. Наприклад, якщо ви хочете знайти збіги рядків `yes` або `no`, ваш регулярний вираз матиме такий вигляд: `/yes|no/`.
+
+Ви також можете шукати більше ніж два шаблони одночасно. Ви можете зробити це, додавши більше шаблонів з більшою кількістю операторів `OR`, що їх розділяють, наприклад: `/yes|no|maybe/`.
+
+# --instructions--
+
+Напишіть регулярний вираз `petRegex`, який відповідав би таким домашнім тваринам: `dog`, `cat`, `bird` або `fish`.
+
+# --hints--
+
+Ви маєте отримати `true` для рядка `John has a pet dog.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('John has a pet dog.'));
+```
+
+Ви маєте отримати `false` для рядка `Emma has a pet rock.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Emma has a pet rock.'));
+```
+
+Ви маєте отримати `true` для рядка `Emma has a pet bird.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Emma has a pet bird.'));
+```
+
+Ви маєте отримати `true` для рядка `Liz has a pet cat.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Liz has a pet cat.'));
+```
+
+Ви маєте отримати `false` для рядка `Kara has a pet dolphin.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Kara has a pet dolphin.'));
+```
+
+Ви маєте отримати `true` для рядка `Alice has a pet fish.` за допомогою вашого регулярного виразу `petRegex`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Alice has a pet fish.'));
+```
+
+Ви маєте отримати `false` для рядка `Jimmy has a pet computer.` за допомогою вашого регулярного виразу `petRegex`
+
+```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/ukrainian/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);
+```
+
+У результаті використання усіх чотирьох викликів `test` ви отримаєте `true`.
+
+Ці скорочення класів символів також відомі як <dfn>скорочення класів символів</dfn>.
+
+# --instructions--
+
+Застосуйте скорочення класу символів `\w`, щоб підрахувати кількість буквено-цифрових символів у різних цитатах і рядках.
+
+# --hints--
+
+Ваш регулярний вираз повинен використовувати глобальний прапорець.
+
+```js
+assert(alphabetRegexV2.global);
+```
+
+Ваш регулярний вираз повинен використовувати скорочений символ `\w`, щоб встановити відповідність з усіма символами, які є буквено-цифровими.
+
+```js
+assert(/\\w/.test(alphabetRegexV2.source));
+```
+
+Ваш регулярний вираз повинен знайти 31 буквено-цифровий символ в рядку `The five boxing wizards jump quickly.`
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(alphabetRegexV2).length === 31
+);
+```
+
+Ваш регулярний вираз повинен знайти 32 буквено-цифрових символи в рядку `Pack my box with five dozen liquor jugs.`
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(alphabetRegexV2).length ===
+    32
+);
+```
+
+Ваш регулярний вираз повинен знайти 30 буквено-цифрових символів у рядку `How vexingly quick daft zebras jump!`
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(alphabetRegexV2).length === 30
+);
+```
+
+Ваш регулярний вираз повинен знайти 36 буквено-цифрових символів у рядку `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+
+```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/ukrainian/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);
+```
+
+Ваш регулярний вираз повинен знайти 6 нецифрових символів у рядку `Catch 22`.
+
+```js
+assert('Catch 22'.match(noNumRegex).length == 6);
+```
+
+Ваш регулярний вираз повинен знайти 11 нецифрових символів у рядку `101 Dalmatians`.
+
+```js
+assert('101 Dalmatians'.match(noNumRegex).length == 11);
+```
+
+Ваш регулярний вираз повинен знайти 15 нецифрових символів у рядку `One, Two, Three`.
+
+```js
+assert('One, Two, Three'.match(noNumRegex).length == 15);
+```
+
+Ваш регулярний вираз повинен знайти 12 нецифрових символів у рядку `21 Jump Street`.
+
+```js
+assert('21 Jump Street'.match(noNumRegex).length == 12);
+```
+
+Ваш регулярний вираз повинен знайти 17 нецифрових символів у рядку `2001: A Space Odyssey`.
+
+```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/ukrainian/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.
+
+# --instructions--
+
+Застосуйте скорочений клас символів `\d`, щоб підрахувати кількість цифрових символів у назвах фільмів. Числа прописом («шість» замість 6) не рахуються.
+
+# --hints--
+
+Ваш регулярний вираз повинен містити скорочений символ, щоб знайти збіги з цифровими символами
+
+```js
+assert(/\\d/.test(numRegex.source));
+```
+
+Ваш регулярний вираз повинен використовувати глобальний прапорець.
+
+```js
+assert(numRegex.global);
+```
+
+Ваш регулярний вираз повинен знайти 1 цифровий символ у рядку `9`.
+
+```js
+assert('9'.match(numRegex).length == 1);
+```
+
+Ваш регулярний вираз повинен знайти 2 цифрових символи у рядку `Catch 22`.
+
+```js
+assert('Catch 22'.match(numRegex).length == 2);
+```
+
+Ваш регулярний вираз повинен знайти 3 цифрових символи у рядку `101 Dalmatians`.
+
+```js
+assert('101 Dalmatians'.match(numRegex).length == 3);
+```
+
+Ваш регулярний вираз не повинен знайти цифрових символів у рядку `One, Two, Three`.
+
+```js
+assert('One, Two, Three'.match(numRegex) == null);
+```
+
+Ваш регулярний вираз повинен знайти 2 цифрові символи у рядку `21 Jump Street`.
+
+```js
+assert('21 Jump Street'.match(numRegex).length == 2);
+```
+
+Ваш регулярний вираз повинен знайти 4 цифрові символи у рядку `2001: A Space Odyssey`.
+
+```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/ukrainian/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--
+
+Іноді ви не знаєте (або вам не потрібні) точні символи у шаблонах. Обмірковування усіх слів які відповідають, скажімо, орфографічній помилці, займе багато часу. На щастя, ви можете заощадити час, використовуючи спеціальний символ: `.`
+
+Спеціальний символ `.` відповідатиме будь-якому одному символу. Спеціальний символ також називають `dot` та `period`. Цей спеціальний символ можна використати як і будь-який інший символ у регулярному виразі. Наприклад, якщо ви хотіли б знайти `hug`, `huh`, `hut`, і `hum`, ви можете використати регулярний вираз `/hu./` для пошуку усіх чотирьох слів.
+
+```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` повинен знайти `run` у рядку `Let us go on a run.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Let us go on a run.'));
+```
+
+Ваш регулярний вираз `unRegex` повинен знайти `sun` у рядку `The sun is out today.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('The sun is out today.'));
+```
+
+Ваш регулярний вираз `unRegex` повинен знайти `fun` у рядку `Coding is a lot of fun.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Coding is a lot of fun.'));
+```
+
+Ваш регулярний вираз `unRegex` повинен знайти `pun` у рядку `Seven days without a pun makes one weak.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Seven days without a pun makes one weak.'));
+```
+
+Ваш регулярний вираз `unRegex` повинен знайти `nun` у рядку `One takes a vow to be a nun.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('One takes a vow to be a nun.'));
+```
+
+Ваш регулярний вираз `unRegex` повинен знайти `bun` у рядку `She got fired from the hot dog stand for putting her hair in a 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/ukrainian/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`, тоді ж як другий повернеться як `false`.
+
+# --instructions--
+
+Використовуйте символ карет у регулярному виразі для того, щоб знайти `Cal` лише на початку рядка `rickyAndCal`.
+
+# --hints--
+
+Ваш регулярний вираз повинен шукати рядок `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/ukrainian/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db6367417b2b2512b99
+title: Пошук збігів, що трапляються один чи більше разів
+challengeType: 1
+forumTopicId: 301350
+dashedName: match-characters-that-occur-one-or-more-times
+---
+
+# --description--
+
+Іноді вам треба знайти символ (або групу символів), що з'являються один чи більше разів поспіль. Це означає, що він зустрічається принаймні раз та може повторюватися.
+
+Можна використати `+` символ для того, щоб перевірити чи це так. Пам'ятайте, символ або шаблон мають бути постійно присутніми. Тобто символ має повторюватися один за іншим.
+
+Наприклад, `/a+/g` знайде один збіг в `abc` та поверне `["a"]`. Завдяки `+`, програма також знайде один збіг в `aabc` та поверне `["aa"]`.
+
+Але якщо замість цього була виконана перевірка рядка `abab`, було б знайдено два збіги та повернено `["a", "a"]`, так як символи `a` не стоять підряд: між ними є символ `b`. І нарешті, оскільки в рядку `bcd` немає `a`, програма не знайде збігів.
+
+# --instructions--
+
+Ви хочете знайти збіги, коли літера `s` з'являється один чи більше разів у `Mississippi`. Напишіть регулярний вираз, що містить знак `+`.
+
+# --hints--
+
+Ваш регулярний вираз `myRegex` має використовувати символ `+` для збігу з одним чи більше `s`-символами.
+
+```js
+assert(/\+/.test(myRegex.source));
+```
+
+Ваш регулярний вираз `myRegex` повинен збігатися з двома елементами.
+
+```js
+assert(result.length == 2);
+```
+
+Змінна `result` має бути масивом з двома збігами `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/ukrainian/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md

@@ -0,0 +1,96 @@
+---
+id: 587d7db6367417b2b2512b9a
+title: Пошук збігів, що трапляються нуль чи більше разів
+challengeType: 1
+forumTopicId: 301351
+dashedName: match-characters-that-occur-zero-or-more-times
+---
+
+# --description--
+
+Останнє завдання потребувало використання знака `+` для пошуку символів, що зустрічаються один чи більше разів. Існує також варіант пошуку символів, що зустрічаються нуль чи більше разів.
+
+Символ, за допомогою якого це можна зробити, називається "астерікс" або "зірочка": `*`.
+
+```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);
+```
+
+По черзі три виклики `match` повернуть значення `["goooooooo"]`, `["g"]` та `null`.
+
+# --instructions--
+
+Для цього завдання, `chewieQuote` було привласнено значення рядка `Aaaaaaaaaaaaaaaarrrgh!` за замовчуванням. Створіть регулярний вираз `chewieRegex`, що використовує символ `*`, для пошуку збігів з великим символом `A`, за яким одразу стоїть нуль чи більша кількість маленьких символів `a` у `chewieQuote`. Ваш регулярний вираз не потребує маркерів чи класів символів та не може збігатися з іншими лапками.
+
+# --hints--
+
+Ваш регулярний вираз`chewieRegex` має використовувати символ `*` задля пошуку збігів нуля чи більше `a`-символів.
+
+```js
+assert(/\*/.test(chewieRegex.source));
+```
+
+Ваш регулярний вираз має збігатися з рядком `A` у `chewieQuote`.
+
+```js
+assert(result[0][0] === 'A');
+```
+
+Ваш регулярний вираз має збігатися з рядком `Aaaaaaaaaaaaaaaa` у `chewieQuote`.
+
+```js
+assert(result[0] === 'Aaaaaaaaaaaaaaaa');
+```
+
+У вашому регулярному виразі `chewieRegex` має збігатися 16 символів із рядком `chewieQuote`.
+
+```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/ukrainian/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`, тоді ж як другий повернеться як `false`.
+
+# --instructions--
+
+Використовуйте знак прив'язки (`$`), щоб знайти відповідність рядка `caboose` у кінці рядка `caboose`.
+
+# --hints--
+
+Ви можете також виконати пошук `caboose` знаком прив'язки долар `$` у регулярному виразі.
+
+```js
+assert(lastRegex.source == 'caboose$');
+```
+
+Ваш регулярний вираз не повинен містити жодних маркерів.
+
+```js
+assert(lastRegex.flags == '');
+```
+
+Ви можете знайти відповідність до `caboose` у кінці рядка `The last car on a train is the 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/ukrainian/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--
+
+Ви вже дізналися, що можна використовувати скорочення для пошуку відповідності алфавітно-цифрового індикатора `[A-Za-z0-9_]`, використовуючи `\w`. Звісно, вам може бути потрібно знайти протилежне до алфавітно-цифрового індикатора.
+
+Ви можете знайти протилежне значення функції `\w` з `\W`. Майте на увазі, що протилежний шаблон використовується з великою літерою. Це скорочення збігається з `[^A-Za-z0-9_]`.
+
+```js
+let shortHand = /\W/;
+let numbers = "42%";
+let sentence = "Coding!";
+numbers.match(shortHand);
+sentence.match(shortHand);
+```
+
+Перший виклик `match` повернеться як `["%"]`, а другий — як `["!"]`.
+
+# --instructions--
+
+Застосуйте скорочення класу символів `\W`, щоб підрахувати кількість алфавітно-цифрових символів у різних цитатах і рядках.
+
+# --hints--
+
+Ваш регулярний вираз повинен використовувати глобальний прапорець.
+
+```js
+assert(nonAlphabetRegex.global);
+```
+
+Ваш регулярний вираз повинен знайти 6 не алфавітно-цифрових символів у рядку `The five boxing wizards jump quickly.`.
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(nonAlphabetRegex).length == 6
+);
+```
+
+Ваш регулярний вираз повинен використовувати символи скорочення, щоб знайти відповідності до не алфавітно-цифрових символів.
+
+```js
+assert(/\\W/.test(nonAlphabetRegex.source));
+```
+
+Ваш регулярний вираз повинен знайти 8 не алфавітно-цифрових символів у рядку `Pack my box with five dozen liquor jugs.`
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(nonAlphabetRegex).length == 8
+);
+```
+
+Ваш регулярний вираз повинен знайти 6 не алфавітно-цифрових символів у рядку `How vexingly quick daft zebras jump!`
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(nonAlphabetRegex).length == 6
+);
+```
+
+Ваш регулярний вираз повинен знайти 12 не алфавітно-цифрових символів у рядку `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+
+```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/ukrainian/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);
+```
+
+По черзі три виклики `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/ukrainian/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`, щоб знайти `"Waldo"` в рядку `waldoIsHiding` з точним збігом.
+
+# --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/ukrainian/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));
+```
+
+Ваш регулярний вираз повинен знайти 35 знаків, що не є пробілами, у рядку `Men are from Mars and women are from Venus.`
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countNonWhiteSpace)
+    .length == 35
+);
+```
+
+Ваш регулярний вираз повинен знайти 23 знаки, що не є пробілами, у рядку `Space: the final frontier.`
+
+```js
+assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
+```
+
+Ваш регулярний вираз повинен знайти 21 знак, що не є пробілом, у рядку `MindYourPersonalSpace`
+
+```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/ukrainian/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/ukrainian/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>character classes</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);
+```
+
+По черзі чотири виклики `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/ukrainian/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/ukrainian/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.`
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countWhiteSpace).length ==
+    8
+);
+```
+
+Регулярний вираз повинен знайти три пробіли в рядку `Space: the final frontier.`
+
+```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/ukrainian/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>Lookaheads</dfn> - це шаблони, які вказують JavaScript заглянути у ваш рядок заздалегідь, щоб перевірити наявність шаблонів далі. Це може бути корисно при пошуку декількох шаблонів на одному рядку.
+
+Існує два типи виглядів: <dfn>позитивний огляд</dfn> і <dfn>негативний огляд</dfn>.
+
+Позитивне передбачення шукатиме, щоб переконатися, що елемент у шаблоні пошуку є, але насправді не відповідатиме йому. Позитивне передбачення використовується як `(?=...)`, де `...` необхідна частина, яка не збігається.
+
+З іншого боку, негативне передбачення буде стежити за тим, щоб елемент в зразку пошуку був відсутній. Негативне передбачення використовується як `(?=...)`, де `...` необхідний шаблон, який не збігається. Решта шаблону повертається, якщо немає негативного передбачення.
+
+Lookaheads є трохи заплутаними, але деякі приклади допоможуть вам в цьому.
+
+```js
+let quit = "qu";
+let noquit = "qt";
+let quRegex= /q(?=u)/;
+let qRegex = /q(?!u)/;
+quit.match(quRegex);
+noquit.match(qRegex);
+```
+
+У результаті використання обох `match`цих викликів ви отримаєте `["q"]`.
+
+Більш практичне використання передбачень - перевірка двох або більше шаблонів в одному рядку. Ось (примітивно) проста перевірка пароля, яка шукає від З до 6 символів і принаймні хоча б одне число:
+
+```js
+let password = "abc123";
+let checkPass = /(?=\w{3,6})(?=\D*\d)/;
+checkPass.test(password);
+```
+
+# --instructions--
+
+Для розпізнавання паролів, що більші за 5 символів використовуйте lookaheads у `pwRegex` для пошуку паролів, більших за 5 символів і має дві послідовні цифри.
+
+# --hints--
+
+Ваш регулярний вираз має використовувати два додатних `lookaheads`.
+
+```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/ukrainian/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/ukrainian/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) Числа повинні бути лише в кінці імені користувача. У кінці їх може бути нуль або більше. Ім'я користувача не повинно починатися з числа.
+
+3) Літери в імені користувача можуть бути нижнього та верхнього регістру.
+
+4) Імена користувачів повинні містити щонайменше два символи. Ім'я користувача з двох символів може містити лише символи літер алфавіту.
+
+# --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/ukrainian/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>Capture groups</dfn> можна використовувати для пошуку повторюваних підрядків.
+
+Групи захоплення створюються за допомогою оточення візерунка регулярного виразу, що має бути зафіксованим в дужках. В такому разі ціль полягає у захваті слова, що складається зі алфавітно-цифрових символів, отже група захоплення має `\w+` позначатися дужками: `/(\w+)/`.
+
+Підрядок, що відповідає групі зберігається до тимчасової "змінної", доступ до якої можна отримати у межах одного й того ж самого регулярного виразу за допомогою зворотнього слешу і номера групи захоплення (напр. `\1`). Групи захоплення автоматично нумеруються за порядком запуску (зліва направо), починаючи з 1.
+
+Наданий приклад дорівнює тричі розділеному пробілами слову:
+
+```js
+let repeatRegex = /(\w+) \1 \1/;
+repeatRegex.test(repeatStr); // Returns true
+repeatStr.match(repeatRegex); // Returns ["row row row", "row"]
+```
+
+Використовуючи метод `.match()` в рядку, можна повернути масив і відповідний підрядок разом з захопленими ним групами.
+
+
+# --instructions--
+
+Для збігання рядку, що складається лише з одного й того ж самого номера, який повторюється тільки три рази і розділений одинарними пробілами, використовуйте групи захоплення в `reRegex`.
+
+# --hints--
+
+Ваш регулярний вираз має користуватися класом скорочених символів для цифр.
+
+```js
+assert(reRegex.source.match(/\\d/));
+```
+
+Ваш регулярний вираз має повторно використовувати групу захоплення двічі.
+
+```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/ukrainian/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--
+
+Ви можете визначити найменшу та найбільшу кількість шаблонів за допомогою специфікатора кількості, використовуючи фігурні дужки. Іноді вам потрібна лише певна кількість збігів.
+
+Щоб вказати певну кількість шаблонів, просто поставте одне число у фігурні дужки.
+
+Наприклад, щоб мати збіг лише зі словом `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);
+```
+
+По черзі три виклики `test` повернуться як `false`, `true` і `false`.
+
+# --instructions--
+
+Змініть регулярний вираз `timRegex`, щоб він мав збіг зі словом `Timber`, тільки якщо в ньому є чотири літери `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'));
+```
+
+Регулярний вираз не повинен збігатися з рядком `Timber` з 30 літерами `m`.
+
+```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/ukrainian/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);
+```
+
+По черзі три виклики `test` повернуться як `true`, `false`, і `true`.
+
+# --instructions--
+
+Змініть регулярний вираз `haRegex`, щоб він збігався зі словом `Hazzah`, тільки якщо в ньому є чотири або більше літер `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);
+```
+
+Регулярний вираз повинен збігатися з рядком `Hazzah` з 30 літерами `z`.
+
+```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/ukrainian/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--
+
+Згадайте, що ми можете використати знак плюс `+`, щоб шукати один та більше знаків і зірочку `*`, щоб шукати нуль та більше знаків. Це зручно, але іноді потрібно знайти збіги для певного діапазону шаблонів.
+
+Ви можете визначити найменшу та найбільшу кількість шаблонів за допомогою <dfn>специфікатора кількості</dfn>. Специфікатори кількості використовуються з фігурними дужками (`{` and `}`). У фігурні дужки ви ставите два числа: для найменшої та найбільшої кількості шаблонів.
+
+Наприклад, щоб знайти збіг лише для літери `a`, яка трапляється від `3` до `5` разів у рядку `ah`, ваш регулярний вираз має виглядати так: `/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`, тоді ж як другий повернеться як `false`.
+
+# --instructions--
+
+Змініть регулярний вираз `ohRegex`, щоб він збігався з усією фразою `Oh no`, тільки якщо в ньому від `3` до `6` літер `h`.
+
+# --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/ukrainian/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()` є регулярний вираз для шаблону, який ви хочете знайти. Другим параметром є рядок для заміни збігу або функції для виконання чогось.
+
+```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--
+
+Напишіть регулярний вираз `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` має використовувати принаймні три групи захоплення.
+
+```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/ukrainian/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db3367417b2b2512b8e
+title: Використання тестового методу
+challengeType: 1
+forumTopicId: 301369
+dashedName: using-the-test-method
+---
+
+# --description--
+
+У мовах програмування регулярні вирази використовуються для відповідності частин рядків. Ви створюєте шаблони, які допоможуть зробити цю відповідність.
+
+Якщо ви хочете знайти слово `the` у рядку `The dog chased the cat`, то можете використати наступний регулярний вираз: `/the/`. Зверніть увагу на те, що лапки в регулярному виразі не потрібні.
+
+JavaScript має декілька способів використання регулярних виразів. Один із способів тестування регулярного виразу - це використання методу `.test()`. Метод `.test()` приймає регулярний вираз, застосовує його до рядка (який розміщений всередині дужок), і видає `true` чи `false`, якщо ваш шаблон знаходить щось або ні.
+
+```js
+let testStr = "freeCodeCamp";
+let testRegex = /Code/;
+testRegex.test(testStr);
+```
+
+Метод `test` у цьому разі видає `true`.
+
+# --instructions--
+
+Застосуйте регулярний вираз `myRegex` до рядка `myString` за допомогою методу `.test()` method.
+
+# --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
+```