Add languages Russian, Arabic, Chinese, Portuguese (#18305)

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/100-doors.russian.md

@@ -0,0 +1,64 @@
+---
+title: 100 doors
+id: 594810f028c0303b75339acb
+challengeType: 5
+videoUrl: ''
+localeTitle: 100 дверей
+---
+
+## Description
+<section id="description"><p> Есть 100 дверей подряд, все изначально закрыты. Вы делаете 100 проходов у дверей. В первый раз, зайдите в каждую дверь и «переключите» дверь (если дверь закрыта, откройте ее, если она открыта, закройте ее). Во второй раз заходите только к каждой второй двери (т. Е. К двери №2, №4, №6, ...) и переключите ее. В третий раз посетите каждую 3-ю дверь (т. Е. Дверь № 3, №6, №9, ...) и т. Д., Пока вы не посетите только 100-ю дверь. </p><p> Внедрите функцию определения состояния дверей после последнего прохода. Верните конечный результат в массив, только если номер двери включен в массив, если он открыт. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>getFinalOpenedDoors</code> - это функция.
+    testString: 'assert(typeof getFinalOpenedDoors === "function", "<code>getFinalOpenedDoors</code> is a function.");'
+  - text: <code>getFinalOpenedDoors</code> должен возвращать массив.
+    testString: 'assert(Array.isArray(getFinalOpenedDoors(100)), "<code>getFinalOpenedDoors</code> should return an array.");'
+  - text: <code>getFinalOpenedDoors</code> не <code>getFinalOpenedDoors</code> правильных результатов.
+    testString: 'assert.deepEqual(getFinalOpenedDoors(100), solution, "<code>getFinalOpenedDoors</code> did not produce the correct results.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function getFinalOpenedDoors (numDoors) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/24-game.russian.md

@@ -0,0 +1,69 @@
+---
+title: 24 game
+id: 5951e88f64ebf159166a1176
+challengeType: 5
+videoUrl: ''
+localeTitle: 24 игра
+---
+
+## Description
+<section id="description"><p> Реализуйте функцию, которая принимает в качестве аргумента строку из четырех цифр: каждая цифра от 1 ──► 9 (включительно) с разрешенными повторениями и возвращает арифметическое выражение, которое оценивается с номером 24. Если такого решения не существует, не существует никакого решения ». </p><p> Правила: </p> Допускаются только следующие операторы / функции: умножение, деление, сложение, вычитание. Отдел должен использовать с плавающей точкой или рациональную арифметику и т. Д. Для сохранения остатков. Формирование нескольких цифр из предоставленных цифр не разрешено. (Таким образом, ответ 12 + 12 при наличии 1, 2, 2 и 1 неверен). Порядок цифр, когда они указаны, не обязательно сохраняется. <p> Пример ввода: </p> <code>solve24(&quot;4878&quot;);</code> <code>solve24(&quot;1234&quot;);</code> <code>solve24(&quot;6789&quot;);</code> <code>solve24(&quot;1127&quot;);</code> <p> Пример выходов (строк): </p> <code>(7-8/8)*4</code> <code>3*1*4*2</code> <code>(6*8)/(9-7)</code> <code>(1+7)*(2+1)</code> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>solve24</code> - функция.
+    testString: 'assert(typeof solve24 === "function", "<code>solve24</code> is a function.");'
+  - text: <code>solve24(&quot;4878&quot;)</code> должен вернуться <code>(7-8/8)*4</code> или <code>4*(7-8/8)</code>
+    testString: 'assert(include(answers[0], solve24(testCases[0])), "<code>solve24("4878")</code> should return <code>(7-8/8)*4</code> or <code>4*(7-8/8)</code>");'
+  - text: <code>solve24(&quot;1234&quot;)</code> должен возвращать любое расположение <code>1*2*3*4</code>
+    testString: 'assert(include(answers[1], solve24(testCases[1])), "<code>solve24("1234")</code> should return any arrangement of <code>1*2*3*4</code>");'
+  - text: <code>solve24(&quot;6789&quot;)</code> должен возвращать <code>(6*8)/(9-7)</code> или <code>(8*6)/(9-7)</code>
+    testString: 'assert(include(answers[2], solve24(testCases[2])), "<code>solve24("6789")</code> should return <code>(6*8)/(9-7)</code> or <code>(8*6)/(9-7)</code>");'
+  - text: <code>solve24(&quot;1127&quot;)</code> должен возвращать перестановку <code>(1+7)*(1*2)</code>
+    testString: 'assert(include(answers[3], solve24(testCases[3])), "<code>solve24("1127")</code> should return a permutation of <code>(1+7)*(1*2)</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function solve24 (numStr) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.russian.md

@@ -0,0 +1,71 @@
+---
+title: 9 billion names of God the integer
+id: 5949b579404977fbaefcd736
+challengeType: 5
+videoUrl: ''
+localeTitle: 9 миллиардов имен Бога - целое число
+---
+
+## Description
+<section id="description"><p> Эта задача - вариация <a href="https://en.wikipedia.org/wiki/The Nine Billion Names of God#Plot_summary" title="wp: Девять миллиардов имен Бога # Plot_summary">рассказа Артура Кларка</a> . </p><p> (Решители должны знать о последствиях выполнения этой задачи.) </p><p> Подробно, чтобы указать, что подразумевается под «именем»: </p><p> Целое число 1 имеет 1 имя «1». </p><p> Целое число 2 имеет 2 имени «1 + 1» и «2». </p><p> Целое число 3 имеет 3 имени «1 + 1 + 1», «2 + 1» и «3». </p><p> Целое число 4 имеет 5 имен «1 + 1 + 1 + 1», «2 + 1 + 1», «2 + 2», «3 + 1», «4». </p><p> Целое число 5 имеет 7 имен «1 + 1 + 1 + 1 + 1», «2 + 1 + 1 + 1», «2 + 2 + 1», «3 + 1 + 1», «3 + 2», «4 + 1», «5». </p><p> Это можно визуализировать в следующем виде: </p><pre> 1
+        1 1
+      1 1 1
+    1 2 1 1
+  1 2 2 1 1
+1 3 3 2 1 1
+</pre><p> Где строка $ n $ соответствует целому числу $ n $, а каждый столбец $ C $ в строке $ m $ слева направо соответствует числу имен, начинающихся с $ C $. </p><p> Необязательно заметим, что сумма $ n $ -ой строки $ P (n) $ является <a href="http://mathworld.wolfram.com/PartitionFunctionP.html" title="ссылка: http://mathworld.wolfram.com/PartitionFunctionP.html">целочисленной статистикой</a> . </p> задача <p> Реализуйте функцию, которая возвращает сумму $ n $ -ой строки. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>numberOfNames</code> - это функция.
+    testString: 'assert(typeof numberOfNames === "function", "<code>numberOfNames</code> is a function.");'
+  - text: <code>numberOfNames(5)</code> должно равняться 7.
+    testString: 'assert.equal(numberOfNames(5), 7, "<code>numberOfNames(5)</code> should equal 7.");'
+  - text: <code>numberOfNames(12)</code> должно равняться 77.
+    testString: 'assert.equal(numberOfNames(12), 77, "<code>numberOfNames(12)</code> should equal 77.");'
+  - text: <code>numberOfNames(18)</code> должно равняться 385.
+    testString: 'assert.equal(numberOfNames(18), 385, "<code>numberOfNames(18)</code> should equal 385.");'
+  - text: <code>numberOfNames(23)</code> должно равняться 1255.
+    testString: 'assert.equal(numberOfNames(23), 1255, "<code>numberOfNames(23)</code> should equal 1255.");'
+  - text: <code>numberOfNames(42)</code> должен равняться 53174.
+    testString: 'assert.equal(numberOfNames(42), 53174, "<code>numberOfNames(42)</code> should equal 53174.");'
+  - text: <code>numberOfNames(123)</code> должно равняться 2552338241.
+    testString: 'assert.equal(numberOfNames(123), 2552338241, "<code>numberOfNames(123)</code> should equal 2552338241.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function numberOfNames (num) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/abc-problem.russian.md

@@ -0,0 +1,74 @@
+---
+title: ABC Problem
+id: 594810f028c0303b75339acc
+challengeType: 5
+videoUrl: ''
+localeTitle: Проблема с ABC
+---
+
+## Description
+<section id="description"><p> Вам предоставляется коллекция блоков ABC (например, блоков алфавита детства). На каждом блоке есть 20 блоков с двумя буквами. На всех сторонах блоков гарантируется полный алфавит. Сбор образцов блоков: </p><p> (БО) </p><p> (КСК) </p><p> (DQ) </p><p> (CP) </p><p> (НС) </p><p> (GT) </p><p> (RE) </p><p> (ТГ) </p><p> (КТ) </p><p> (ФС) </p><p> (ДВ) </p><p> (HU) </p><p> (VI) </p><p> (AN) </p><p> (ОВ) </p><p> (ЭР) </p><p> (ФС) </p><p> (LY) </p><p> (ПК) </p><p> (ЗМ) </p><p> Некоторые правила, которые следует учитывать: </p> Когда используется буква на блоке, этот блок нельзя использовать снова. Функция должна быть нечувствительна к регистру. <p> Реализуйте функцию, которая принимает строку (слово) и определяет, может ли слово быть записано с данным набором блоков. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>canMakeWord</code> - это функция.
+    testString: 'assert(typeof canMakeWord === "function", "<code>canMakeWord</code> is a function.");'
+  - text: <code>canMakeWord</code> должен возвращать логическое значение.
+    testString: 'assert(typeof canMakeWord("hi") === "boolean", "<code>canMakeWord</code> should return a boolean.");'
+  - text: <code>canMakeWord(&quot;bark&quot;)</code> должен возвращать true.
+    testString: 'assert(canMakeWord(words[0]), "<code>canMakeWord("bark")</code> should return true.");'
+  - text: <code>canMakeWord(&quot;BooK&quot;)</code> должен возвращать false.
+    testString: 'assert(!canMakeWord(words[1]), "<code>canMakeWord("BooK")</code> should return false.");'
+  - text: <code>canMakeWord(&quot;TReAT&quot;)</code> должен возвращать true.
+    testString: 'assert(canMakeWord(words[2]), "<code>canMakeWord("TReAT")</code> should return true.");'
+  - text: <code>canMakeWord(&quot;COMMON&quot;)</code> должен возвращать false.
+    testString: 'assert(!canMakeWord(words[3]), "<code>canMakeWord("COMMON")</code> should return false.");'
+  - text: <code>canMakeWord(&quot;squAD&quot;)</code> должен возвращать true.
+    testString: 'assert(canMakeWord(words[4]), "<code>canMakeWord("squAD")</code> should return true.");'
+  - text: <code>canMakeWord(&quot;conFUSE&quot;)</code> должен возвращать true.
+    testString: 'assert(canMakeWord(words[5]), "<code>canMakeWord("conFUSE")</code> should return true.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function canMakeWord (word) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.russian.md

@@ -0,0 +1,66 @@
+---
+title: 'Abundant, deficient and perfect number classifications'
+id: 594810f028c0303b75339acd
+challengeType: 5
+videoUrl: ''
+localeTitle: 'Обильные, неполные и совершенные классификации номеров'
+---
+
+## Description
+<section id="description"><p> Они определяют три классификации положительных целых чисел на основе их <a href="http://rosettacode.org/wiki/Proper divisors" title="Собственные делители">правильных делителей</a> . </p><p> Пусть $ P (n) $ - сумма собственных делителей n, где собственные делители - все натуральные n, отличные от n. </p><p> Если <code>P(n) &lt; n</code> то n классифицируется как «несовершенный», </p><p> Если <code>P(n) === n</code> то n классифицируется как &quot;совершенный&quot; </p><p> Если <code>P(n) &gt; n</code> то n классифицируется как &quot;обильное&quot; </p><p> Пример: </p><p> 6 имеет собственные делители 1, 2 и 3. </p><p> 1 + 2 + 3 = 6, поэтому 6 классифицируется как совершенное число. </p><p> Внедрите функцию, которая вычисляет, сколько целых чисел от 1 до 20 000 (включительно) находятся в каждом из трех классов. Выведите результат как массив в следующем формате <code>[deficient, perfect, abundant]</code> . </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>getDPA</code> - это функция.
+    testString: 'assert(typeof getDPA === "function", "<code>getDPA</code> is a function.");'
+  - text: <code>getDPA</code> должен возвращать массив.
+    testString: 'assert(Array.isArray(getDPA(100)), "<code>getDPA</code> should return an array.");'
+  - text: Возвращаемое значение <code>getDPA</code> должно иметь длину 3.
+    testString: 'assert(getDPA(100).length === 3, "<code>getDPA</code> return value should have a length of 3.");'
+  - text: '<code>getDPA(20000)</code> должен равняться [15043, 4, 4953]'
+    testString: 'assert.deepEqual(getDPA(20000), solution, "<code>getDPA(20000)</code> should equal [15043, 4, 4953]");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function getDPA (num) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/accumulator-factory.russian.md

@@ -0,0 +1,66 @@
+---
+title: Accumulator factory
+id: 594810f028c0303b75339ace
+challengeType: 5
+videoUrl: ''
+localeTitle: Аккумуляторный завод
+---
+
+## Description
+<section id="description"><p> Создайте функцию, которая принимает один (числовой) аргумент и возвращает другую функцию, которая является аккумулятором. Возвращенная функция аккумулятора, в свою очередь, также принимает один числовой аргумент и возвращает сумму всех числовых значений, переданных до этого аккумулятора (включая начальное значение, переданное при создании аккумулятора). </p><p> Правила: </p><p> Не используйте глобальные переменные. </p><p> Подсказка: </p><p> Закрытие сохраняет внешнее состояние. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>accumulator</code> - это функция.
+    testString: 'assert(typeof accumulator === "function", "<code>accumulator</code> is a function.");'
+  - text: <code>accumulator(0)</code> должен возвращать функцию.
+    testString: 'assert(typeof accumulator(0) === "function", "<code>accumulator(0)</code> should return a function.");'
+  - text: <code>accumulator(0)(2)</code> должен вернуть номер.
+    testString: 'assert(typeof accumulator(0)(2) === "number", "<code>accumulator(0)(2)</code> should return a number.");'
+  - text: 'Передача значений 3, -4, 1.5 и 5 должна возвращать 5.5.'
+    testString: 'assert(testFn(5) === 5.5, "Passing in the values 3, -4, 1.5, and 5 should return 5.5.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function accumulator (sum) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/ackermann-function.russian.md

@@ -0,0 +1,60 @@
+---
+title: Ackermann function
+id: 594810f028c0303b75339acf
+challengeType: 5
+videoUrl: ''
+localeTitle: Функция Аккермана
+---
+
+## Description
+<section id="description"><p> Функция Аккермана является классическим примером рекурсивной функции, особенно потому, что она не является примитивной рекурсивной функцией. Он растет очень быстро в стоимости, равно как и размер его дерева вызовов. </p><p> Функция Аккермана обычно определяется следующим образом: </p> $$ A (m, n) = \ begin {cases} n + 1 &amp; \ mbox {if} m = 0 \\ A (m-1, 1) &amp; \ mbox {if} m&gt; 0 \ mbox {и} n = 0 \\ A (m-1, A (m, n-1)) &amp; \ mbox {if} m&gt; 0 \ mbox {и} n&gt; 0. \ end {cases} $$ <p> Его аргументы никогда не отрицательны и всегда заканчиваются. Напишите функцию, которая возвращает значение $ A (m, n) $. Произвольная точность предпочтительнее (поскольку функция растет так быстро), но не требуется. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>ack</code> - функция.
+    testString: 'assert(typeof ack === "function", "<code>ack</code> is a function.");'
+  - text: '<code>ack(0, 0)</code> должен возвращать 1.'
+    testString: 'assert(ack(0, 0) === 1, "<code>ack(0, 0)</code> should return 1.");'
+  - text: '<code>ack(1, 1)</code> должен вернуть 3.'
+    testString: 'assert(ack(1, 1) === 3, "<code>ack(1, 1)</code> should return 3.");'
+  - text: '<code>ack(2, 5)</code> должен вернуть 13.'
+    testString: 'assert(ack(2, 5) === 13, "<code>ack(2, 5)</code> should return 13.");'
+  - text: '<code>ack(3, 3)</code> должен вернуть 61.'
+    testString: 'assert(ack(3, 3) === 61, "<code>ack(3, 3)</code> should return 61.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function ack (m, n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/align-columns.russian.md

@@ -0,0 +1,89 @@
+---
+title: Align columns
+id: 594810f028c0303b75339ad0
+challengeType: 5
+videoUrl: ''
+localeTitle: Выровнять столбцы
+---
+
+## Description
+<section id="description"><p> Учитывая текстовый файл многих строк, где поля в строке обозначаются одним символом <code>$</code> , напишите программу, которая выравнивает каждый столбец полей, гарантируя, что слова в каждом столбце разделены хотя бы одним пробелом. Кроме того, разрешите каждое слово в столбце быть либо оправданным, либо оправданным, либо оправданным по центру в его столбце. </p><p> Используйте следующий текст для тестирования своих программ: </p><pre> Учитывая $ в $ текста $ файл $ из $ многих $ линий
+где $ поля $ в $ а $ линия $
+составляют $ очерчены $ на $ «доллар» в размере $ одноместный $ символа $
+написать $ в $ программе
+что $ совпадет $ каждый $ столбец $ из $ полей
+от $ обеспечения $, что $ слова $ в $ каждый $
+колонка $ являются $ $ разделены на $ по $ мере $ за $ пространство.
+Кроме того, $ позволяют $ за $ каждого $ слова $ в $ A $ столбец $ до $ быть $ либо $ остался $
+оправданный, $ права $ оправдано
+или $ центр $ оправдана $ в $ его $ колонке.
+</pre><p> Обратите внимание, что: </p> Примеры строк ввода текста могут или не могут иметь завершающие символы доллара. Все столбцы должны иметь одинаковое выравнивание. Последовательные символы пробела, создаваемые рядом с концом строк, несущественны для целей задачи. Текст вывода будет отображаться моноширинным шрифтом в текстовом редакторе или базовом терминале. Минимальное пространство между столбцами должно быть вычислено из текста, а не жестко закодировано. Не требуется добавлять разделительные символы между столбцами или вокруг них. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>formatText</code> - это функция.
+    testString: 'assert(typeof formatText === "function", "<code>formatText</code> is a function.");'
+  - text: '<code>formatText</code> с указанным выше вводом и «правильным» обоснованием должен <code>formatText</code> следующее:'
+    testString: 'assert.strictEqual(formatText(testInput, "right"), rightAligned, "<code>formatText</code> with the above input and "right" justification should produce the following: ");'
+  - text: '<code>formatText</code> с указанным выше вводом и «левым» обоснованием должен <code>formatText</code> следующее:'
+    testString: 'assert.strictEqual(formatText(testInput, "left"), leftAligned, "<code>formatText</code> with the above input and "left" justification should produce the following: ");'
+  - text: '<code>formatText</code> с указанным выше вводом и выравниванием «центра» должно приводить к следующему:'
+    testString: 'assert.strictEqual(formatText(testInput, "center"), centerAligned, "<code>formatText</code> with the above input and "center" justification should produce the following: ");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+const testArr = [
+  'Given$a$text$file$of$many$lines',
+  'where$fields$within$a$line$',
+  'are$delineated$by$a$single$"dollar"$character',
+  'write$a$program',
+  'that$aligns$each$column$of$fields$',
+  'by$ensuring$that$words$in$each$',
+  'column$are$separated$by$at$least$one$space.',
+  'Further,$allow$for$each$word$in$a$column$to$be$either$left$',
+  'justified,$right$justified',
+  'or$center$justified$within$its$column.'
+];
+
+function formatText (input, justification) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/amicable-pairs.russian.md

@@ -0,0 +1,67 @@
+---
+title: Amicable pairs
+id: 5949b579404977fbaefcd737
+challengeType: 5
+videoUrl: ''
+localeTitle: Дружественные пары
+---
+
+## Description
+<section id="description"> Два целых числа $ N $ и $ M $ называются <a href="https://en.wikipedia.org/wiki/Amicable numbers" title="wp: дружественные номера">дружественными парами,</a> если $ N \ neq M $ и сумма <a href="http://rosettacode.org/wiki/Proper divisors" title="Собственные делители">собственных делителей</a> $ N $ ($ \ mathrm {sum} (\ mathrm {propDivs} (N)) $) $ = M $, а также $ \ mathrm {sum} (\ mathrm {propDivs} (M)) = N $. Пример: 1184 и 1210 являются дружной парой с соответствующими делителями: 1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 и 1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 соответственно. Задача: рассчитать и показать здесь дружественные пары ниже 20 000 (их восемь). Связанные задачи <a href="http://rosettacode.org/wiki/Proper divisors" title="Собственные делители">Правильные делители</a> <a href="http://rosettacode.org/wiki/Abundant, deficient and perfect number classifications" title="Обильные, неполные и совершенные классификации номеров">Обильные, неполные и совершенные классификации чисел Классификация</a> <a href="http://rosettacode.org/wiki/Aliquot sequence classifications" title="Классификация последовательности аликвот">последовательности аликвот</a> и ее дружественная классификация. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>amicablePairsUpTo</code> - это функция.
+    testString: 'assert(typeof amicablePairsUpTo === "function", "<code>amicablePairsUpTo</code> is a function.");'
+  - text: '<code>amicablePairsUpTo(300)</code> должен возвратить <code>[[220,284]]</code> .'
+    testString: 'assert.deepEqual(amicablePairsUpTo(300), answer300, "<code>amicablePairsUpTo(300)</code> should return <code>[[220,284]]</code>.");'
+  - text: '<code>amicablePairsUpTo(3000)</code> должен вернуть <code>[[220,284],[1184,1210],[2620,2924]]</code> .'
+    testString: 'assert.deepEqual(amicablePairsUpTo(3000), answer3000, "<code>amicablePairsUpTo(3000)</code> should return <code>[[220,284],[1184,1210],[2620,2924]]</code>.");'
+  - text: '<code>amicablePairsUpTo(20000)</code> должен возвращать <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code> .'
+    testString: 'assert.deepEqual(amicablePairsUpTo(20000), answer20000, "<code>amicablePairsUpTo(20000)</code> should return <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function amicablePairsUpTo (maxNum) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/averages-mode.russian.md

@@ -0,0 +1,65 @@
+---
+title: Averages-Mode
+id: 594d8d0ab97724821379b1e6
+challengeType: 5
+videoUrl: ''
+localeTitle: Сред-Mode
+---
+
+## Description
+<section id="description"><p> Напишите программу , чтобы найти <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: Режим (статистика)">режим</a> значение коллекции. </p><p> Случай, когда коллекция пуст, может быть проигнорирован. Необходимо следить за тем, чтобы режим не был уникальным. </p><p> Если это не подходит или возможно поддерживать общую коллекцию, используйте вектор (массив), если это возможно. Если это не подходит или возможно поддерживать неопределенный тип значения, используйте целые числа. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>mode</code> - это функция.
+    testString: 'assert(typeof mode === "function", "<code>mode</code> is a function.");'
+  - text: '<code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> должен равняться <code>[6]</code>'
+    testString: 'assert.deepEqual(mode(arr1), [6], "<code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> should equal <code>[6]</code>");'
+  - text: '<code>mode([1, 2, 4, 4, 1])</code> должен быть равен <code>[1, 4]</code> .'
+    testString: 'assert.deepEqual(mode(arr2).sort(), [1, 4], "<code>mode([1, 2, 4, 4, 1])</code> should equal <code>[1, 4]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function mode (arr) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.russian.md

@@ -0,0 +1,70 @@
+---
+title: Averages-Pythagorean means
+id: 594d966a1467eb84194f0086
+challengeType: 5
+videoUrl: ''
+localeTitle: Средние значения - пифагорейские средства
+---
+
+## Description
+<section id="description"><p class="rosetta__paragraph"> Вычислите все три <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/Pythagorean means" title="wp: Пифагорейский означает">пифагорейских средства</a> набора целых чисел от <big>1</big> до <big>10</big> (включительно). </p><p class="rosetta__paragraph"> Покажите, что для этого набора натуральных чисел <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> . </p> Наиболее распространенным из трех означает <a class="rosetta__link--rosetta" href="http://rosettacode.org/wiki/Averages/Arithmetic mean" title="Средние / Средние арифметические">среднее арифметическое</a> - это сумма списка, деленная на его длину: <big>$ A (x_1, \ ldots, x_n) = \ frac {x_1 + \ cdots + x_n} {n} $</big> <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/Geometric mean" title="wp: среднее геометрическое">Геометрическая Среднее означает</a> $ n $ -ый корень из произведения списка: <big>$ G (x_1, \ ldots, x_n) = \ sqrt [n] {x_1 \ cdots x_n} $</big> <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/Harmonic mean" title="wp: Гармоническое среднее">Гармоническое среднее</a> $ n $, деленное на сумму обратный каждому элементу в списке: <big>$ H (x_1, \ ldots, x_n) = \ frac {n} {\ frac {1} {x_1} + \ cdots + \ frac {1} {x_n}} $</big> <p class="rosetta__paragraph"> Предположим, что вход представляет собой упорядоченный массив всех включенных чисел. </p><p class="rosetta__paragraph"> Для ответа, пожалуйста, выведите объект в следующем формате: </p><pre class="rosetta__pre"> {
+  значения: {
+    Арифметика: 5.5,
+    Геометрический: 4.528728688116765,
+    Гармонический: 3.414171521474055
+  },
+  test: &#39;является A&gt; = G&gt; = H? да&#39;
+}
+</pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Функция <code>pythagoreanMeans</code> - это функция.
+    testString: 'assert(typeof pythagoreanMeans === "function", "<code>pythagoreanMeans</code> is a function.");'
+  - text: '<code>pythagoreanMeans([1, 2, ..., 10])</code> должен равняться тому же самому выходу.'
+    testString: 'assert.deepEqual(pythagoreanMeans(range1), answer1, "<code>pythagoreanMeans([1, 2, ..., 10])</code> should equal the same output above.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function pythagoreanMeans (rangeArr) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/averages-root-mean-square.russian.md

@@ -0,0 +1,62 @@
+---
+title: Averages-Root mean square
+id: 594da033de4190850b893874
+challengeType: 5
+videoUrl: ''
+localeTitle: Средние значения - средний квадрат
+---
+
+## Description
+<section id="description"><p> Вычислите <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: средний квадрат корня">средний квадрат корня</a> чисел от 1 до 10 включительно. </p><p> Корневой средний квадрат также известен по его инициалам RMS (или rms) и как квадратичное среднее. </p><p> RMS рассчитывается как среднее из квадратов чисел, с квадратным корнем: </p><p> <big>$$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $$</big> </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>rms</code> - это функция.
+    testString: 'assert(typeof rms === "function", "<code>rms</code> is a function.");'
+  - text: '<code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> должны равняться <code>6.2048368229954285</code> .'
+    testString: 'assert.equal(rms(arr1), answer1, "<code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> should equal <code>6.2048368229954285</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function rms (arr) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/babbage-problem.russian.md

@@ -0,0 +1,63 @@
+---
+title: Babbage problem
+id: 594db4d0dedb4c06a2a4cefd
+challengeType: 5
+videoUrl: ''
+localeTitle: Проблема с Бэббиджем
+---
+
+## Description
+<section id="description"><p> <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Чарльз Бэббидж</a> , смотрящий вперед на те проблемы, которые мог бы решить его аналитический движок, привел этот пример: </p><blockquote> Какое наименьшее положительное целое число, квадрат которого заканчивается цифрами 269 696? </blockquote><p> - Бэббидж, письмо лорду Боудену, 1837 год; см. Hollingdale and Tootill, <i>Electronic Computers</i> , второе издание, 1970, с. 125. </p><p> Он думал, что ответ может быть 99 736, чья площадь составляет 9 947 269 696; но он не мог быть уверен. </p><p> Задача состоит в том, чтобы выяснить, есть ли у Бэббиджа правильный ответ. </p><p> Реализуйте функцию, чтобы вернуть наименьшее целое число, удовлетворяющее задаче Бэббиджа. Если Бэббидж был прав, верните номер Бэббиджа. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>babbage</code> - это функция.
+    testString: 'assert(typeof babbage === "function", "<code>babbage</code> is a function.");'
+  - text: '<code>babbage(99736, 269696)</code> не должен возвращать 99736 (есть меньший ответ).'
+    testString: 'assert.equal(babbage(babbageAns, endDigits), answer, "<code>babbage(99736, 269696)</code> should not return 99736 (there is a smaller answer).");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function babbage (babbageNum, endDigits) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/balanced-brackets.russian.md

@@ -0,0 +1,97 @@
+---
+title: Balanced brackets
+id: 594dc6c729e5700999302b45
+challengeType: 5
+videoUrl: ''
+localeTitle: Сбалансированные кронштейны
+---
+
+## Description
+<section id="description"><p> Определите, сбалансирована ли сгенерированная строка скобок; то есть, состоит ли он целиком из пар открывающих / закрывающих скобок (в этом порядке), ни одно из которых не выполняется. </p> Примеры: <p class="rosetta__paragraph"> (пусто) true </p><p class="rosetta__paragraph"> <code>[]</code> true </p><p class="rosetta__paragraph"> <code>][</code> false </p><p class="rosetta__paragraph"> <code>[][]</code> true </p><p class="rosetta__paragraph"> <code>][][</code> false </p><p class="rosetta__paragraph"> <code>[]][[]</code> false </p><p class="rosetta__paragraph"> <code>[[[[]]]]</code> true </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>isBalanced</code> - это функция.
+    testString: 'assert(typeof isBalanced === "function", "<code>isBalanced</code> is a function.");'
+  - text: '<code>isBalanced(&quot;[]&quot;)</code> должен возвращать true.'
+    testString: 'assert(isBalanced(testCases[0]), "<code>isBalanced("[]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;]][[[][][][]][&quot;)</code> должен возвращать значение false.'
+    testString: 'assert(!isBalanced(testCases[1]), "<code>isBalanced("]][[[][][][]][")</code> should return false.");'
+  - text: '<code>isBalanced(&quot;[][[[[][][[[]]]]]]&quot;)</code> должен возвращать true.'
+    testString: 'assert(isBalanced(testCases[2]), "<code>isBalanced("[][[[[][][[[]]]]]]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[3]), "<code>isBalanced("][")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[[]]]][[]&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[4]), "<code>isBalanced("[[[]]]][[]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][[]&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[5]), "<code>isBalanced("][[]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][[][]][[[]]&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[6]), "<code>isBalanced("][[][]][[[]]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[][]]][&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[7]), "<code>isBalanced("[[][]]][")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[[]]][[]]]][][[&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[8]), "<code>isBalanced("[[[]]][[]]]][][[")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[]][[]]][[[[][]]&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[9]), "<code>isBalanced("[]][[]]][[[[][]]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][]][[][&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[10]), "<code>isBalanced("][]][[][")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[]][[][]]&quot;)</code> должен возвращать true.'
+    testString: 'assert(isBalanced(testCases[11]), "<code>isBalanced("[[]][[][]]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[]]&quot;)</code> должен возвращать true.'
+    testString: 'assert(isBalanced(testCases[12]), "<code>isBalanced("[[]]")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;]][]][[]][[[&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[13]), "<code>isBalanced("]][]][[]][[[")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][]][][[&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[14]), "<code>isBalanced("][]][][[")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;][][&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[15]), "<code>isBalanced("][][")</code> should return true.");'
+  - text: '<code>isBalanced(&quot;[[]]][][][[]][&quot;)</code> должен возвращать true.'
+    testString: 'assert(!isBalanced(testCases[16]), "<code>isBalanced("[[]]][][][[]][")</code> should return true.");'
+  - text: <code>isBalanced(&quot;&quot;)</code> должен возвращать true.
+    testString: 'assert(isBalanced(testCases[17]), "<code>isBalanced("")</code> should return true.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function isBalanced (str) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.russian.md

@@ -0,0 +1,77 @@
+---
+title: Circles of given radius through two points
+id: 5951815dd895584b06884620
+challengeType: 5
+videoUrl: ''
+localeTitle: Круги заданного радиуса через две точки
+---
+
+## Description
+<section id="description"><p> Учитывая две точки на плоскости и радиус, обычно через две точки могут быть проведены два круга заданного радиуса. </p> Исключения: радиус нуля должен рассматриваться как никогда не описывающий круги (за исключением случая, когда точки совпадают). Если точки совпадают, то может быть проведено бесконечное число кругов с точкой на их окружности, если радиус не равен нулю, а затем сворачивает круги в точку. Если точки образуют диаметр, верните один круг. Если точки слишком далеки друг от друга, круги не могут быть нарисованы. Задача: выполнить функцию, которая принимает две точки и радиус и возвращает два круга через эти точки. Для каждого результирующего круга укажите координаты для центра каждого круга, округленного до четырех десятичных цифр. Возвращает каждую координату в виде массива и координирует ее как массив массивов. Для краевых случаев возвращайте следующее: если точки находятся на диаметре, верните одну точку. Если радиус также равен нулю, верните <code>&quot;Radius Zero&quot;</code> . Если точки совпадают, верните <code>&quot;Coincident point. Infinite solutions&quot;</code> . Если точки находятся дальше друг от друга, чем диаметр, верните <code>&quot;No intersection. Points further apart than circle diameter&quot;</code> . Примеры входов: <pre> p1 p2 r
+0,1234, 0,9876 0,8765, 0,2345 2,0
+0,0000, 2,0000 0,0000, 0,0000 1,0
+0,1234, 0,9876 0,1234, 0,9876 2,0
+0,1234, 0,9876 0,8765, 0,2345 0,5
+0,1234, 0,9876 0,1234, 0,9876 0,0
+</pre> Ref: <a href="http://mathforum.org/library/drmath/view/53027.html" title="ссылка: http://mathforum.org/library/drmath/view/53027.html">Поиск центра круга из двух точек и радиуса</a> из математического форума @ Drexel </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>getCircles</code> - это функция.
+    testString: 'assert(typeof getCircles === "function", "<code>getCircles</code> is a function.");'
+  - text: '<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> должны возвращать <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code> .'
+    testString: 'assert.deepEqual(getCircles(...testCases[0]), answers[0], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> should return <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code>.");'
+  - text: '<code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> должны возвращать <code>[0, 1]</code>'
+    testString: 'assert.deepEqual(getCircles(...testCases[1]), answers[1], "<code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> should return <code>[0, 1]</code>");'
+  - text: '<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> должны возвращать <code>Coincident point. Infinite solutions</code>'
+    testString: 'assert.deepEqual(getCircles(...testCases[2]), answers[2], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> should return <code>Coincident point. Infinite solutions</code>");'
+  - text: '<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> должен возвращать <code>No intersection. Points further apart than circle diameter</code>'
+    testString: 'assert.deepEqual(getCircles(...testCases[3]), answers[3], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> should return <code>No intersection. Points further apart than circle diameter</code>");'
+  - text: '<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> должны возвращать <code>Radius Zero</code>'
+    testString: 'assert.deepEqual(getCircles(...testCases[4]), answers[4], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> should return <code>Radius Zero</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function getCircles (...args) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/closest-pair-problem.russian.md

@@ -0,0 +1,127 @@
+---
+title: Closest-pair problem
+id: 5951a53863c8a34f02bf1bdc
+challengeType: 5
+videoUrl: ''
+localeTitle: Проблема ближайшей пары
+---
+
+## Description
+<section id="description"> Задача: <p> Предоставить функцию для поиска ближайших двух точек среди множества заданных точек в двух измерениях, т. <a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: Ближайшая проблема с двумя точками">Е. Решить задачу Ближайшей пары точек</a> в плоском случае. </p><p> Прямым решением является алгоритм O (n <sup>2</sup> ) (который мы можем назвать алгоритмом грубой силы); псевдокод (с использованием индексов) может быть простым: </p><pre> bruteForceClosestPair из P (1), P (2), ... P (N)
+если N &lt;2, то
+  return ∞
+еще
+  minDistance ← | P (1) - P (2) |
+  minPoints ← {P (1), P (2)}
+  foreach i ∈ [1, N-1]
+    foreach j ∈ [i + 1, N]
+      если | P (i) - P (j) | &lt;minDistance тогда
+        minDistance ← | P (i) - P (j) |
+        minPoints ← {P (i), P (j)}
+      ENDIF
+    ENDFOR
+  ENDFOR
+  return minDistance, minPoints
+ENDIF
+</pre><p> Лучший алгоритм основан на подходе рекурсивного разделения и покорения, как это объясняется также в <a href="https://en.wikipedia.org/wiki/Closest pair of points problem#Planar_case" title="wp: Ближайшая проблема с двумя точками # Planar_case">самой близкой проблеме точек Википедии</a> , которая является O (n log n); псевдокод может быть: </p><pre> ближайшая пара (xP, yP)
+  где xP - P (1) .. P (N), отсортированная по координате x, и
+  yP - P (1). P (N), отсортированный по координате y (по возрастанию)
+если N ≤ 3, то
+  возвращать ближайшие точки xP с использованием алгоритма грубой силы
+еще
+  xL ← точки xP от 1 до ⌈N / 2⌉
+  xR ← точки xP от ⌈N / 2⌉ + 1 до N
+  xm ← xP (⌈N / 2⌉) <sub>x</sub>
+  yL ← {p ∈ yP: p <sub>x</sub> ≤ xm}
+  yR ← {p ∈ yP: p <sub>x</sub> &gt; xm}
+  (dL, pairL) ← ближайшая пара (xL, yL)
+  (dR, pairR) ← ближайшая пара (xR, yR)
+  (dmin, pairMin) ← (dR, pairR)
+  если dL &lt;dR, тогда
+    (dmin, pairMin) ← (dL, pairL)
+  ENDIF
+  yS ← {p ∈ yP: | xm - p <sub>x</sub> | &lt;dmin}
+  nS ← число точек в yS
+  (ближайший, ближайший) ← (dmin, pairMin)
+  для i от 1 до nS - 1
+    k ← i + 1
+    в то время как k ≤ nS и yS (k) <sub>y</sub> - yS (i) <sub>y</sub> &lt;dmin
+      если | yS (k) - yS (i) | &lt;ближе
+        (ближайший ближайший Pair) ← (| yS (k) - yS (i) |, {yS (k), yS (i)})
+      ENDIF
+      k ← k + 1
+    ENDWHILE
+  ENDFOR
+  вернуться ближайший, ближайший
+ENDIF
+</pre> Ссылки и дальнейшие чтения: <a href="http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf" title="ссылка: http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf">Самая близкая</a> <a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: Ближайшая проблема с двумя точками">пара проблем точек</a> <a href="http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html" title="ссылка: http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html">Ближайшая пара (McGill)</a> <a href="http://www.cs.ucsb.edu/~suri/cs235/ClosestPair.pdf" title="ссылка: http://www.cs.ucsb.edu/~suri/cs235/ClosestPair.pdf">Ближайшая пара (UCSB)</a> <a href="http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf" title="ссылка: http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf">Ближайшая пара (WUStL)</a> <a href="http://www.cs.iupui.edu/~xkzou/teaching/CS580/Divide-and-conquer-closestPair.ppt" title="ссылка: http://www.cs.iupui.edu/~xkzou/teaching/CS580/Divide-and-conquer-closestPair.ppt">Ближайшая пара (IUPUI)</a> <p> Для ввода предположим, что аргумент представляет собой массив объектов (точек) с элементами <code>x</code> и <code>y</code> установленными в числа. Для вывода возвращаем объект, содержащий пары ключ: значение для <code>distance</code> и <code>pair</code> (т. Е. Пару из двух ближайших точек). </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>getClosestPair</code> - это функция.
+    testString: 'assert(typeof getClosestPair === "function", "<code>getClosestPair</code> is a function.");'
+  - text: Расстояние должно быть следующим.
+    testString: 'assert.equal(getClosestPair(points1).distance, answer1.distance, "Distance should be the following.");'
+  - text: Баллы должны быть следующими.
+    testString: 'assert.deepEqual(JSON.parse(JSON.stringify(getClosestPair(points1))).pair, answer1.pair, "Points should be the following.");'
+  - text: Расстояние должно быть следующим.
+    testString: 'assert.equal(getClosestPair(points2).distance, answer2.distance, "Distance should be the following.");'
+  - text: Баллы должны быть следующими.
+    testString: 'assert.deepEqual(JSON.parse(JSON.stringify(getClosestPair(points2))).pair, answer2.pair, "Points should be the following.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+const Point = function (x, y) {
+  this.x = x;
+  this.y = y;
+};
+Point.prototype.getX = function () {
+  return this.x;
+};
+Point.prototype.getY = function () {
+  return this.y;
+};
+
+function getClosestPair (pointsArr) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/combinations.russian.md

@@ -0,0 +1,75 @@
+---
+title: Combinations
+id: 5958469238c0d8d2632f46db
+challengeType: 5
+videoUrl: ''
+localeTitle: Комбинации
+---
+
+## Description
+<section id="description"> Задача: <p> Учитывая неотрицательные целые числа <big>m</big> и <big>n</big> , генерируйте все размерные <big>m</big> <a href="http://mathworld.wolfram.com/Combination.html" title="ссылка: http://mathworld.wolfram.com/Combination.html">комбинаций</a> целых чисел от <big>0</big> (ноль) до <big>n-1</big> в отсортированном порядке (каждая комбинация сортируется и вся таблица сортируется). </p> Пример: <p> <big>3</big> гребня <big>5</big> : </p><pre> 0 1 2
+0 1 3
+0 1 4
+0 2 3
+0 2 4
+0 3 4
+1 2 3
+1 2 4
+1 3 4
+2 3 4
+</pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>combinations</code> - это функция.
+    testString: 'assert(typeof combinations === "function", "<code>combinations</code> is a function.");'
+  - text: '<code>combinations(3, 5)</code> должны возвращать <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code> .'
+    testString: 'assert.deepEqual(combinations(testInput1[0], testInput1[1]), testOutput1, "<code>combinations(3, 5)</code> should return <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code>.");'
+  - text: '<code>combinations(4, 6)</code> должны возвращать <code>[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]</code>'
+    testString: 'assert.deepEqual(combinations(testInput2[0], testInput2[1]), testOutput2, "<code>combinations(4, 6)</code> should return <code>[[0,1,2,3],  [0,1,2,4],  [0,1,2,5],  [0,1,3,4],  [0,1,3,5],  [0,1,4,5],  [0,2,3,4],  [0,2,3,5],  [0,2,4,5],  [0,3,4,5],  [1,2,3,4],  [1,2,3,5],  [1,2,4,5],  [1,3,4,5],  [2,3,4,5]]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function combinations (m, n) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/comma-quibbling.russian.md

@@ -0,0 +1,71 @@
+---
+title: Comma quibbling
+id: 596e414344c3b2872167f0fe
+challengeType: 5
+videoUrl: ''
+localeTitle: Запястья
+---
+
+## Description
+<section id="description"><p> Comma quibbling - это задача, первоначально заданная Эриком Липпертом в его <a href="http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx" title="ссылка: http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx">блоге</a> . </p> Задача: <p> Напишите функцию для генерации вывода строки, которая представляет собой конкатенацию входных слов из списка / последовательности, где: </p> Ввод без слов выводит строку вывода только двух символов скобок «{}». Ввод только одного слова, например [&quot;ABC&quot;], выводит строку вывода слова внутри двух фигурных скобок, например, &quot;{ABC}&quot;. Ввод двух слов, например [&quot;ABC&quot;, &quot;DEF&quot;], выдает строку вывода двух слов внутри двух фигурных скобок словами, разделенными строкой &quot;и&quot;, например &quot;{ABC и DEF}&quot;. Ввод трех или более слов, например [&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;], выводит строку вывода всего, кроме последнего слова, разделенного символом &quot;,&quot; с последним словом, разделенным символом &quot;и&quot; «и все в фигурных скобках; например, «{ABC, DEF, G и H}». <p> Протестируйте свою функцию со следующей серией входов, показывающей ваш вывод здесь, на этой странице: </p> [] # (Нет входных слов). [&quot;ABC&quot;] [&quot;ABC&quot;, &quot;DEF&quot;] [&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;] <p> Примечание. Предположим, что для этой задачи слова являются непустыми строками символов верхнего регистра. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>quibble</code> - это функция.
+    testString: 'assert(typeof quibble === "function", "<code>quibble</code> is a function.");'
+  - text: '<code>quibble([&quot;ABC&quot;])</code> должен возвращать строку.'
+    testString: 'assert(typeof quibble(["ABC"]) === "string", "<code>quibble(["ABC"])</code> should return a string.");'
+  - text: '<code>quibble([])</code> должен возвращать &quot;{}&quot;.'
+    testString: 'assert.equal(quibble(testCases[0]), results[0], "<code>quibble([])</code> should return "{}".");'
+  - text: '<code>quibble([&quot;ABC&quot;])</code> должен вернуть &quot;{ABC}&quot;.'
+    testString: 'assert.equal(quibble(testCases[1]), results[1], "<code>quibble(["ABC"])</code> should return "{ABC}".");'
+  - text: '<code>quibble([&quot;ABC&quot;, &quot;DEF&quot;])</code> должен возвращать &quot;{ABC и DEF}&quot;.'
+    testString: 'assert.equal(quibble(testCases[2]), results[2], "<code>quibble(["ABC", "DEF"])</code> should return "{ABC and DEF}".");'
+  - text: '<code>quibble([&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;])</code> должны возвращать &quot;{ABC, DEF, G и H}&quot;.'
+    testString: 'assert.equal(quibble(testCases[3]), results[3], "<code>quibble(["ABC", "DEF", "G", "H"])</code> should return "{ABC,DEF,G and H}".");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function quibble (words) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.russian.md

@@ -0,0 +1,88 @@
+---
+title: Compare a list of strings
+id: 596e457071c35c882915b3e4
+challengeType: 5
+videoUrl: ''
+localeTitle: Сравнить список строк
+---
+
+## Description
+<section id="description"><p> Учитывая <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">список</a> произвольно многих строк, реализуйте функцию для каждого из следующих условий: </p> если все они лексически равны, если каждая строка лексически меньше, чем одна после нее (т. е. является ли список в строгом порядке) </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>allEqual</code> - это функция.
+    testString: 'assert(typeof allEqual === "function", "<code>allEqual</code> is a function.");'
+  - text: <code>azSorted</code> - это функция.
+    testString: 'assert(typeof azSorted === "function", "<code>azSorted</code> is a function.");'
+  - text: '<code>allEqual([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> возвращает true.'
+    testString: 'assert(allEqual(testCases[0]), "<code>allEqual(["AA", "AA", "AA", "AA"])</code> returns true.");'
+  - text: '<code>azSorted([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> возвращает false.'
+    testString: 'assert(!azSorted(testCases[0]), "<code>azSorted(["AA", "AA", "AA", "AA"])</code> returns false.");'
+  - text: '<code>allEqual([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> возвращает false.'
+    testString: 'assert(!allEqual(testCases[1]), "<code>allEqual(["AA", "ACB", "BB", "CC"])</code> returns false.");'
+  - text: '<code>azSorted([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> возвращает true.'
+    testString: 'assert(azSorted(testCases[1]), "<code>azSorted(["AA", "ACB", "BB", "CC"])</code> returns true.");'
+  - text: '<code>allEqual([])</code> возвращает true.'
+    testString: 'assert(allEqual(testCases[2]), "<code>allEqual([])</code> returns true.");'
+  - text: '<code>azSorted([])</code> возвращает true.'
+    testString: 'assert(azSorted(testCases[2]), "<code>azSorted([])</code> returns true.");'
+  - text: '<code>allEqual([&quot;AA&quot;])</code> возвращает true.'
+    testString: 'assert(allEqual(testCases[3]), "<code>allEqual(["AA"])</code> returns true.");'
+  - text: '<code>azSorted([&quot;AA&quot;])</code> возвращает true.'
+    testString: 'assert(azSorted(testCases[3]), "<code>azSorted(["AA"])</code> returns true.");'
+  - text: '<code>allEqual([&quot;BB&quot;, &quot;AA&quot;])</code> возвращает false.'
+    testString: 'assert(!allEqual(testCases[4]), "<code>allEqual(["BB", "AA"])</code> returns false.");'
+  - text: '<code>azSorted([&quot;BB&quot;, &quot;AA&quot;])</code> возвращает false.'
+    testString: 'assert(!azSorted(testCases[4]), "<code>azSorted(["BB", "AA"])</code> returns false.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function allEqual (arr) {
+  // Good luck!
+  return true;
+}
+
+function azSorted (arr) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.russian.md

@@ -0,0 +1,67 @@
+---
+title: Convert seconds to compound duration
+id: 596fd036dc1ab896c5db98b1
+challengeType: 5
+videoUrl: ''
+localeTitle: Преобразование секунд в составную продолжительность
+---
+
+## Description
+<section id="description"> Задача: <p> Внедрите функцию, которая: </p> принимает положительное целое число, представляющее продолжительность в секундах в качестве входных данных (например, <code>100</code> ), и возвращает строку, которая показывает ту же самую длительность, разложенную на недели, дни, часы, минуты и секунды, как описано ниже (например, « <code>1 min, 40 sec</code> «). <p> Продемонстрируйте, что он проходит следующие три теста: </p><p style="font-size:115%; margin:1em 0 0 0"> Испытательные случаи </p><table><tbody><tr><th> номер ввода </th><th> номер выхода </th></tr><tr><td> 7259 </td><td> <code>2 hr, 59 sec</code> </td> </tr><tr><td> 86400 </td><td> <code>1 d</code> </td> </tr><tr><td> 6000000 </td><td> <code>9 wk, 6 d, 10 hr, 40 min</code> </td> </tr></tbody></table><p style="font-size:115%; margin:1em 0 0 0"> Детали </p> Следует использовать следующие пять единиц: <table><tbody><tr><th> Ед. изм </th><th> суффикс, используемый для вывода </th><th> преобразование </th></tr><tr><td> неделю </td><td> <code>wk</code> </td> <td> 1 неделя = 7 дней </td></tr><tr><td> день </td><td> <code>d</code> </td> <td> 1 день = 24 часа </td></tr><tr><td> час </td><td> <code>hr</code> </td> <td> 1 час = 60 минут </td></tr><tr><td> минут </td><td> <code>min</code> </td> <td> 1 минута = 60 секунд </td></tr><tr><td> второй </td><td> <code>sec</code> </td> <td></td></tr></tbody></table> Тем не менее, включают только количества с ненулевыми значениями на выходе (например, return « <code>1 d</code> », а не « <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> »). Увеличивайте более высокий приоритет блоков по сравнению с меньшими (например, возврат <code>2 min, 10 sec</code> а не <code>1 min, 70 sec</code> или <code>130 sec</code> ). Обозначьте форматирование, показанное в тестовых сценариях (количества, отсортированные от наибольшего до наименьшего и разделенные запятой + пробелом, значение и единица каждая величина разделяется пробелом). <p></p><hr style="margin:1em 0;"><p></p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>convertSeconds</code> - это функция.
+    testString: 'assert(typeof convertSeconds === "function", "<code>convertSeconds</code> is a function.");'
+  - text: '<code>convertSeconds(7259)</code> должен возвращаться <code>2 hr, 59 sec</code> .'
+    testString: 'assert.equal(convertSeconds(testCases[0]), results[0], "<code>convertSeconds(7259)</code> should return <code>2 hr, 59 sec</code>.");'
+  - text: <code>convertSeconds(86400)</code> должен возвращать <code>1 d</code> .
+    testString: 'assert.equal(convertSeconds(testCases[1]), results[1], "<code>convertSeconds(86400)</code> should return <code>1 d</code>.");'
+  - text: '<code>convertSeconds(6000000)</code> должен возвращать <code>9 wk, 6 d, 10 hr, 40 min</code> .'
+    testString: 'assert.equal(convertSeconds(testCases[2]), results[2], "<code>convertSeconds(6000000)</code> should return <code>9 wk, 6 d, 10 hr, 40 min</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function convertSeconds (sec) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.russian.md

@@ -0,0 +1,67 @@
+---
+title: Count occurrences of a substring
+id: 596fda99c69f779975a1b67d
+challengeType: 5
+videoUrl: ''
+localeTitle: Количество вхождений подстроки
+---
+
+## Description
+<section id="description"> Задача: <p> Создайте функцию или покажите встроенную функцию, чтобы подсчитать количество неперекрывающихся вхождений подстроки внутри строки. </p><p> Функция должна принимать два аргумента: </p> первый аргумент - строка для поиска, а вторая - подстрока, которую нужно искать. <p> Он должен возвращать целочисленное число. </p><p> Соответствие должно давать наибольшее количество совпадающих совпадений. </p><p> В общем, это по существу означает совмещение слева направо или справа налево. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>countSubstring</code> - это функция.
+    testString: 'assert(typeof countSubstring === "function", "<code>countSubstring</code> is a function.");'
+  - text: '<code>countSubstring(&quot;the three truths&quot;, &quot;th&quot;)</code> должны возвращать <code>3</code> .'
+    testString: 'assert.equal(countSubstring(testCases[0], searchString[0]), results[0], "<code>countSubstring("the three truths", "th")</code> should return <code>3</code>.");'
+  - text: '<code>countSubstring(&quot;ababababab&quot;, &quot;abab&quot;)</code> должен возвращать <code>2</code> .'
+    testString: 'assert.equal(countSubstring(testCases[1], searchString[1]), results[1], "<code>countSubstring("ababababab", "abab")</code> should return <code>2</code>.");'
+  - text: '<code>countSubstring(&quot;abaabba*bbaba*bbab&quot;, &quot;a*b&quot;)</code> должен возвращать <code>2</code> .'
+    testString: 'assert.equal(countSubstring(testCases[2], searchString[2]), results[2], "<code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> should return <code>2</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function countSubstring (str, subStr) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/count-the-coins.russian.md

@@ -0,0 +1,55 @@
+---
+title: Count the coins
+id: 59713bd26bdeb8a594fb9413
+challengeType: 5
+videoUrl: ''
+localeTitle: Подсчитайте монеты
+---
+
+## Description
+<section id="description"><p> В <a href="https://en.wikipedia.org/wiki/United_States" title="ссылка: https://en.wikipedia.org/wiki/United_States">американской</a> валюте существует четыре типа обычных монет: </p> кварталы (25 центов), десять центов (10 центов), никель (5 центов) и пенни (1 цент) <p> Существует шесть способов внести изменения в 15 центов: </p> Копейка и никель Копейка и 5 пенни 3 никеля 2 никеля и 5 пенни Никель и 10 пенни 15 пенни Задача: <p> Внедрить функцию, чтобы определить, сколько способов внести изменения в доллар, используя эти общие монеты? (1 доллар = 100 центов). </p> Ссылка: <a href="http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_Temp_52" title="ссылка: http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_Temp_52">алгоритм из MIT Press</a> . </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>countCoins</code> - это функция.
+    testString: 'assert(typeof countCoins === "function", "<code>countCoins</code> is a function.");'
+  - text: <code>countCoints()</code> должен возвращать 242.
+    testString: 'assert.equal(countCoins(), 242, "<code>countCoints()</code> should return 242.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function countCoins () {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/cramers-rule.russian.md

@@ -0,0 +1,65 @@
+---
+title: Cramer's rule
+id: 59713da0a428c1a62d7db430
+challengeType: 5
+videoUrl: ''
+localeTitle: Правило Крамера
+---
+
+## Description
+<section id="description"><p> В <a href="https://en.wikipedia.org/wiki/linear algebra" title="wp: линейная алгебра">линейной алгебре</a> <a href="https://en.wikipedia.org/wiki/Cramer&#x27;s rule" title="wp: правило Крамера">правило Крамера</a> является явной формулой для решения <a href="https://en.wikipedia.org/wiki/system of linear equations" title="wp: система линейных уравнений">системы линейных уравнений</a> с таким количеством уравнений, как неизвестные, действительные всякий раз, когда система имеет единственное решение. Он выражает решение в терминах детерминантов матрицы (квадратного) коэффициента и полученных из нее матриц путем замены одного столбца на вектор правых частей уравнений. </p><p> Данный </p><p><big></big></p><p> <big>$ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z &amp; = {\ color {red} d_1} \\ a_2x + b_2y + c_2z &amp; = {\ color {red} d_2} \\ a_3x + b_3y + c_3z &amp; = {\ цвет {красный} D_3} \ конец {матрица} \ правом. $</big> </p><p> который в матричном формате </p><p><big></big></p><p> <big>$ \ begin {bmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {bmatrix} \ begin {bmatrix} x \\ y \\ z \ end {bmatrix} = \ begin {bmatrix} {\ color {red} d_1} \\ {\ color {red} d_2} \\ {\ color {red} d_3} \ end {bmatrix}. $</big> </p><p> Тогда значения $ x, y $ и $ z $ можно найти следующим образом: </p><p><big></big></p><p> <big>$ x = \ frac {\ begin {vmatrix} {\ color {red} d_1} &amp; b_1 &amp; c_1 \\ {\ color {red} d_2} &amp; b_2 &amp; c_2 \\ {\ color {red} d_3} &amp; b_3 &amp; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix} } a_1 &amp; {\ color {red} d_1} &amp; c_1 \\ a_2 &amp; {\ color {red} d_2} &amp; c_2 \\ a_3 &amp; {\ color {red} d_3} &amp; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ text {и} z = \ frac {\ begin {vmatrix} a_1 &amp; b_1 &amp; {\ color {red} d_1} \\ a_2 &amp; b_2 &amp; {\ color {red} d_2} \\ a_3 &amp; b_3 &amp; {\ color {red} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}. $</big> </p> задача <p> Учитывая следующую систему уравнений: </p><p> <big>$ \ begin {cases} 2w-x + 5y + z = -3 \\ 3w + 2x + 2y-6z = -32 \ w + 3x + 3y-z = -47 \\ 5w-2x-3y + 3z = 49 \\ \ end {cases} $</big> </p><p> решаем для <big>$ w $, $ x $, $ y $</big> и <big>$ z $</big> , используя правило Крамера. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>cramersRule</code> - это функция.
+    testString: 'assert(typeof cramersRule === "function", "<code>cramersRule</code> is a function.");'
+  - text: '<code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> должны возвращать <code>[2, -12, -4, 1]</code> .'
+    testString: 'assert.deepEqual(cramersRule(matrices[0], freeTerms[0]), answers[0], "<code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> should return <code>[2, -12, -4, 1]</code>.");'
+  - text: '<code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> должны возвращать <code>[1, 1, -1]</code> .'
+    testString: 'assert.deepEqual(cramersRule(matrices[1], freeTerms[1]), answers[1], "<code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> should return <code>[1, 1, -1]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function cramersRule (matrix, freeTerms) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/date-format.russian.md

@@ -0,0 +1,67 @@
+---
+title: Date format
+id: 59669d08d75b60482359409f
+challengeType: 5
+videoUrl: ''
+localeTitle: Формат даты
+---
+
+## Description
+<section id="description"> Задача: <p> Возвращает массив с текущей датой в форматах: </p><p> - 2007-11-23 и </p><p> - Воскресенье, 23 ноября 2007 г. </p><p> Пример вывода: <code>[&#39;2007-11-23&#39;, &#39;Sunday, November 23, 2007&#39;]</code> </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>getDateFormats</code> - это функция.
+    testString: 'assert(typeof getDateFormats === "function", "<code>getDateFormats</code> is a function.");'
+  - text: Должен возвращать объект.
+    testString: 'assert(typeof getDateFormats() === "object", "Should return an object.");'
+  - text: Должен возвращать массив с 2 элементами.
+    testString: 'assert(getDateFormats().length === 2, "Should returned an array with 2 elements.");'
+  - text: Должна вернуть правильную дату в правильном формате
+    testString: 'assert.deepEqual(getDateFormats(), dates, equalsMessage);'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function getDateFormats () {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/date-manipulation.russian.md

@@ -0,0 +1,73 @@
+---
+title: Date manipulation
+id: 5966c21cf732a95f1b67dd28
+challengeType: 5
+videoUrl: ''
+localeTitle: Обработка даты
+---
+
+## Description
+<section id="description"> Задача: <p> Учитывая строку даты в EST, выведите указанную дату в виде строки с добавлением 12 часов к времени. </p><p> Часовой пояс должен быть сохранен. </p><p> Пример ввода: </p><p> <code>&quot;March 7 2009 7:30pm EST&quot;</code> </p> <p> Пример вывода: </p><p> <code>&quot;March 8 2009 7:30am EST&quot;</code> </p> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>add12Hours</code> - это функция.
+    testString: 'assert(typeof add12Hours === "function", "<code>add12Hours</code> is a function.");'
+  - text: <code>add12Hours(dateString)</code> должен возвращать строку.
+    testString: 'assert(typeof add12Hours(tests[0]) === "string", "<code>add12Hours(dateString)</code> should return a string.");'
+  - text: '<code>add12Hours(&quot;&quot; + tests[0] + &quot;&quot;)</code> должны возвращать <code>&quot;&quot; + answers[0] + &quot;&quot;</code>'
+    testString: 'assert(add12Hours(tests[0]) === answers[0], "<code>add12Hours("" + tests[0] + "")</code> should return <code>"" + answers[0] + ""</code>");'
+  - text: 'Должен ли день обмена менять. <code>add12Hours(&quot;&quot; + tests[1] + &quot;&quot;)</code> должны возвращать <code>&quot;&quot; + answers[1] + &quot;&quot;</code>'
+    testString: 'assert(add12Hours(tests[1]) === answers[1], "Should handel day change. <code>add12Hours("" + tests[1] + "")</code> should return <code>"" + answers[1] + ""</code>");'
+  - text: 'Должен ли перенос месяца в високосный год. <code>add12Hours(&quot;&quot; + tests[2] + &quot;&quot;)</code> должны возвращать <code>&quot;&quot; + answers[2] + &quot;&quot;</code>'
+    testString: 'assert(add12Hours(tests[2]) === answers[2], "Should handel month change in a leap years. <code>add12Hours("" + tests[2] + "")</code> should return <code>"" + answers[2] + ""</code>");'
+  - text: 'Должен ли перенос месяца в течение общих лет. <code>add12Hours(&quot;&quot; + tests[3] + &quot;&quot;)</code> должны возвращать <code>&quot;&quot; + answers[3] + &quot;&quot;</code>'
+    testString: 'assert(add12Hours(tests[3]) === answers[3], "Should handel month change in a common years. <code>add12Hours("" + tests[3] + "")</code> should return <code>"" + answers[3] + ""</code>");'
+  - text: 'Должен измениться год выпуска. <code>add12Hours(&quot;&quot; + tests[4] + &quot;&quot;)</code> должны возвращать <code>&quot;&quot; + answers[4] + &quot;&quot;</code>'
+    testString: 'assert(add12Hours(tests[4]) === answers[4], "Should handel year change. <code>add12Hours("" + tests[4] + "")</code> should return <code>"" + answers[4] + ""</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function add12Hours (dateString) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/day-of-the-week.russian.md

@@ -0,0 +1,67 @@
+---
+title: Day of the week
+id: 5966f99c45e8976909a85575
+challengeType: 5
+videoUrl: ''
+localeTitle: День недели
+---
+
+## Description
+<section id="description"><p> Компания решает, что всякий раз, когда Xmas падает на воскресенье, они отдают своим работникам все дополнительные оплачиваемые отпуска, так что вместе с любыми праздничными днями работникам не придется работать на следующей неделе (с 25 декабря по 1 января). </p><p> Задача: </p><p> Напишите функцию, которая запускает год начала и конец года и возвращает массив всех лет, в которые 25 декабря будет воскресенье. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>findXmasSunday</code> - это функция.
+    testString: 'assert(typeof findXmasSunday === "function", "<code>findXmasSunday</code> is a function.");'
+  - text: '<code>findChristmasSunday(2000, 2100)</code> должен возвращать массив.'
+    testString: 'assert(typeof findXmasSunday(2000, 2100) === "object", "<code>findChristmasSunday(2000, 2100)</code> should return an array.");'
+  - text: '<code>findChristmasSunday(2008, 2121</code> должен вернуться [1977, 1983, 1988, 1994, 2005, 2011, 2016]'
+    testString: 'assert.deepEqual(findXmasSunday(1970, 2017), firstSolution, "<code>findChristmasSunday(2008, 2121</code> should return [1977, 1983, 1988, 1994, 2005, 2011, 2016]");'
+  - text: '<code>findChristmasSunday(2008, 2121</code> должны вернуться [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]'
+    testString: 'assert.deepEqual(findXmasSunday(2008, 2121), secondSolution, "<code>findChristmasSunday(2008, 2121</code> should return [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function findXmasSunday (start, end) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.russian.md

@@ -0,0 +1,91 @@
+---
+title: Deal cards for FreeCell
+id: 59694356a6e7011f7f1c5f4e
+challengeType: 5
+videoUrl: ''
+localeTitle: Карты сделок для FreeCell
+---
+
+## Description
+<section id="description"><p> Free Cell - это карточная игра для пасьянсов, которую Пол Альфил представил системе PLATO в 1978 году. Джим Хорн в Microsoft заменил имя на FreeCell и переопределил игру для <a href="http://rosettacode.org/wiki/DOS" title="DOS">DOS</a> , а затем <a href="http://rosettacode.org/wiki/Windows" title="Windows">Windows</a> . </p><p> В этой версии реализовано 32000 номеров. ( <a href="http://www.solitairelaboratory.com/fcfaq.html" title="ссылка: http://www.solitairelaboratory.com/fcfaq.html">Часто задаваемые вопросы FreeCell</a> рассказывают об этой истории.) </p><p> Когда игра стала популярной, Джим Хорн раскрыл <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="ссылка: http://www.solitairelaboratory.com/mshuffle.txt">алгоритм</a> , а другие реализации FreeCell начали воспроизводить сделки Microsoft. </p><p> Эти сделки пронумерованы от 1 до 32000. </p><p> Более новые версии от Microsoft имеют 1 миллион сделок, пронумерованных от 1 до 1000000; некоторые реализации позволяют использовать номера за пределами этого диапазона. </p><p> Алгоритм использует этот <a href="http://rosettacode.org/wiki/linear congruential generator" title="линейный конгруэнтный генератор">линейный конгруэнтный генератор</a> от Microsoft C: </p> $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $ $ rand_n = state_n \ div 2 ^ {16} $ $ rand_n $ находится в диапазоне от 0 до 32767. <p> Алгоритм: </p> Выделите RNG с номером сделки. Создайте <a href="http://rosettacode.org/wiki/array" title="массив">массив</a> из 52 карт: туз клубов, туз бриллиантов, туз сердец, туз пик, 2 из клубов, 2 бриллиантов и т. Д. Через звания: туз, 2, 3, 4, 5, 6, 7, 8, 9, 10, Джек, Королева, Король. Индексы массива от 0 до 51, с Ace of Clubs в 0 и King of Spades - 51. Пока массив не будет пустым: выберите случайную карту с индексом ≡ следующее случайное число (длина массива мод). Поменяйте эту случайную карту последней карточкой массива. Удалите эту случайную карту из массива. (Длина массива снижается на 1.) Обработайте эту случайную карту. Сделки все 52 карты, лицевой стороной вверх, через 8 столбцов. Первые 8 карт идут в 8 столбцах, следующие 8 карт идут на первые 8 карт и так далее. Пример: <p> Заказать карты </p><p></p><pre> 1 2 3 4 5 6 7 8
+ 9 10 11 12 13 14 15 16
+17 18 19 20 21 22 23 24
+25 26 27 28 29 30 31 32
+33 34 35 36 37 38 39 40
+41 42 43 44 45 46 47 48
+49 50 51 52 </pre><p></p><p> Игра №1 </p><p></p><pre> [
+[&#39;JD&#39;, &#39;2D&#39;, &#39;9H&#39;, &#39;JC&#39;, &#39;5D&#39;, &#39;7H&#39;, &#39;7C&#39;, &#39;5H&#39;],
+[&#39;KD&#39;, &#39;KC&#39;, &#39;9S&#39;, &#39;5S&#39;, &#39;AD&#39;, &#39;QC&#39;, &#39;KH&#39;, &#39;3H&#39;],
+[&#39;2S&#39;, &#39;KS&#39;, &#39;9D&#39;, &#39;QD&#39;, &#39;JS&#39;, &#39;AS&#39;, &#39;AH&#39;, &#39;3C&#39;],
+[&#39;4C&#39;, &#39;5C&#39;, &#39;TS&#39;, &#39;QH&#39;, &#39;4H&#39;, &#39;AC&#39;, &#39;4D&#39;, &#39;7S&#39;],
+[3S, TD, 4S, TH, 8H, 2C, JH, 7D,
+[6D, 8S, 8D, QS, 6C, 3D, 8C,
+[&#39;6S&#39;, &#39;9C&#39;, &#39;2H&#39;, &#39;6H&#39;]
+] </pre><p></p><p> Игра № 617 </p><p></p><pre> [
+[&#39;7D&#39;, &#39;AD&#39;, &#39;5C&#39;, &#39;3S&#39;, &#39;5S&#39;, &#39;8C&#39;, &#39;2D&#39;, &#39;AH&#39;],
+[&#39;TD&#39;, &#39;7S&#39;, &#39;QD&#39;, &#39;AC&#39;, &#39;6D&#39;, &#39;8H&#39;, &#39;AS&#39;, &#39;KH&#39;],
+[&#39;TH&#39;, &#39;QC&#39;, &#39;3H&#39;, &#39;9D&#39;, &#39;6S&#39;, &#39;8D&#39;, &#39;3D&#39;, &#39;TC&#39;],
+[&#39;KD&#39;, &#39;5H&#39;, &#39;9S&#39;, &#39;3C&#39;, &#39;8S&#39;, &#39;7H&#39;, &#39;4D&#39;, &#39;JS&#39;],
+[4C, QS, 9C, 9H, 7C,
+[&#39;4S&#39;, &#39;TS&#39;, &#39;2H&#39;, &#39;5D&#39;, &#39;JC&#39;, &#39;6C&#39;, &#39;JH&#39;, &#39;QH&#39;],
+[&#39;JD&#39;, &#39;KS&#39;, &#39;KC&#39;, &#39;4H&#39;]
+] </pre><p></p> Задача: <p> Напишите функцию, чтобы взять номер сделки и раздавать карты в том же порядке, что и этот алгоритм. </p><p> Функция должна возвращать двухмерный массив, представляющий плату FreeCell. </p><p> Сделки можно также проверить на <a href="http://freecellgamesolutions.com/" title="ссылка: http://freecellgamesolutions.com/">решения FreeCell для 1000000 игр</a> . </p><p> (Вызов видео решения, и он отображает первоначальную сделку.) </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>dealFreeCell</code> - это функция.
+    testString: 'assert(typeof dealFreeCell === "function", "<code>dealFreeCell</code> is a function.");'
+  - text: <code>dealFreeCell(seed)</code> должен возвращать объект.
+    testString: 'assert(typeof dealFreeCell(1) === "object", "<code>dealFreeCell(seed)</code> should return an object.");'
+  - text: <code>dealFreeCell(seed)</code> должен возвращать массив длиной 7.
+    testString: 'assert(dealFreeCell(1).length === 7, "<code>dealFreeCell(seed)</code> should return an array of length 7.");'
+  - text: '<code>dealFreeCell(1)</code> должен возвращать массив, идентичный примеру «Игра №1»,'
+    testString: 'assert.deepEqual(dealFreeCell(1), game1, "<code>dealFreeCell(1)</code> should return an array identical to example "Game #1"");'
+  - text: '<code>dealFreeCell(617)</code> должен возвращать массив, идентичный примеру «Game # 617»,'
+    testString: 'assert.deepEqual(dealFreeCell(617), game617, "<code>dealFreeCell(617)</code> should return an array identical to example "Game #617"");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function dealFreeCell (seed) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/deepcopy.russian.md

@@ -0,0 +1,69 @@
+---
+title: Deepcopy
+id: 596a8888ab7c01048de257d5
+challengeType: 5
+videoUrl: ''
+localeTitle: DeepCopy
+---
+
+## Description
+<section id="description"> Задача: <p> Напишите функцию, которая возвращает глубокую копию данного объекта. </p><p> Копия не должна быть тем же самым объектом, который был дан. </p><p> Эта задача не будет проверяться: </p> Объекты со свойствами, которые являются функциями. Объекты Date или объект со свойствами, которые являются объектами Date. RegEx или объект со свойствами, которые являются объектами RegEx. Прототипирование копий </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>deepcopy</code> должна быть функцией.
+    testString: 'assert(typeof deepcopy === "function", "<code>deepcopy</code> should be a function.");'
+  - text: '<code>deepcopy({test: &quot;test&quot;})</code> должен возвращать объект.'
+    testString: 'assert(typeof deepcopy(obj1) === "object", "<code>deepcopy({test: "test"})</code> should return an object.");'
+  - text: 'Не следует возвращать тот же объект, который был предоставлен.'
+    testString: 'assert(deepcopy(obj2) != obj2, "Should not return the same object that was provided.");'
+  - text: 'Когда передан объект, содержащий массив, должен возвращать глубокую копию объекта.'
+    testString: 'assert.deepEqual(deepcopy(obj2), obj2, "When passed an object containing an array, should return a deep copy of the object.");'
+  - text: 'При передаче объекта, содержащего другой объект, следует вернуть глубокую копию объекта.'
+    testString: 'assert.deepEqual(deepcopy(obj3), obj3, "When passed an object containing another object, should return a deep copy of the object.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function deepcopy (obj) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.russian.md

@@ -0,0 +1,79 @@
+---
+title: Define a primitive data type
+id: 597089c87eec450c68aa1643
+challengeType: 5
+videoUrl: ''
+localeTitle: Определить примитивный тип данных
+---
+
+## Description
+<section id="description"> Задача: <p> Определите тип, который ведет себя как целое число, но имеет наименьшее допустимое значение 1 и самое высокое допустимое значение 10. </p> Ошибки. Если вы попытаетесь создать экземпляр <code>Num</code> со значением за пределами 1 - 10, он должен выбросить <code>TypeError</code> с сообщением об ошибке <code>&#39;Out of range&#39;</code> . Если вы попытаетесь создать экземпляр <code>Num</code> со значением, которое не является числом, оно должно <code>TypeError</code> с сообщением об ошибке <code>&#39;Not a Number&#39;</code> . </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>Num</code> должно быть функцией.
+    testString: 'assert(typeof Num === "function", "<code>Num</code> should be a function.");'
+  - text: <code>new Num(4)</code> должен возвращать объект.
+    testString: 'assert(typeof (new Num(4)) === "object", "<code>new Num(4)</code> should return an object.");'
+  - text: '<code>new Num(\&#39;test\&#39;)</code> должен вызывать TypeError с сообщением «Не номер».'
+    testString: 'assert(throws(() => new Num("test"), TypeError, "Not a Number"), "<code>new Num(\"test\")</code> should throw a TypeError with message \"Not a Number\".");'
+  - text: <code>new Num(0)</code> должен вызывать TypeError с сообщением «Вне диапазона».
+    testString: 'assert(throws(() => new Num(0), TypeError, "Out of range"), "<code>new Num(0)</code> should throw a TypeError with message \"Out of range\".");'
+  - text: <code>new Num(-5)</code> должен вызывать TypeError с сообщением «Вне диапазона».
+    testString: 'assert(throws(() => new Num(-5), TypeError, "Out of range"), "<code>new Num(-5)</code> should throw a TypeError with message \"Out of range\".");'
+  - text: <code>new Num(10)</code> должен вызывать TypeError с сообщением «Вне диапазона».
+    testString: 'assert(throws(() => new Num(11), TypeError, "Out of range"), "<code>new Num(10)</code> should throw a TypeError with message \"Out of range\".");'
+  - text: <code>new Num(20)</code> должен вызывать TypeError с сообщением «Вне диапазона».
+    testString: 'assert(throws(() => new Num(20), TypeError, "Out of range"), "<code>new Num(20)</code> should throw a TypeError with message \"Out of range\".");'
+  - text: <code>new Num(3) + new Num(4)</code> должен равняться 7.
+    testString: 'assert.equal(new Num(3) + new Num(4), 7, "<code>new Num(3) + new Num(4)</code> should equal 7.");'
+  - text: <code>new Num(3) - new Num(4)</code> должен равняться -1.
+    testString: 'assert.equal(new Num(3) - new Num(4), -1, "<code>new Num(3) - new Num(4)</code> should equal -1.");'
+  - text: <code>new Num(3) * new Num(4)</code> должен равняться 12.
+    testString: 'assert.equal(new Num(3) * new Num(4), 12, "<code>new Num(3) * new Num(4)</code> should equal 12.");'
+  - text: '<code>new Num(3) / new Num(4)</code> должен равняться 0,75.'
+    testString: 'assert.equal(new Num(3) / new Num(4), 0.75, "<code>new Num(3) / new Num(4)</code> should equal 0.75.");'
+  - text: <code>new Num(3) &lt; new Num(4)</code> должен быть правдой.
+    testString: 'assert(new Num(3) < new Num(4), "<code>new Num(3) < new Num(4)</code> should be true.");'
+  - text: <code>new Num(3) &gt; new Num(4)</code> должен быть ложным.
+    testString: 'assert(!(new Num(3) > new Num(4)), "<code>new Num(3) > new Num(4)</code> should be false.");'
+  - text: '<code>(new Num(5)).toString()</code> должен возвращать &#39;5 \&#39;'
+    testString: 'assert.equal((new Num(5)).toString(), "5", "<code>(new Num(5)).toString()</code> should return \"5\"");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function Num (n) {
+  // Good luck!
+  return n;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/department-numbers.russian.md

@@ -0,0 +1,67 @@
+---
+title: Department Numbers
+id: 59f40b17e79dbf1ab720ed7a
+challengeType: 5
+videoUrl: ''
+localeTitle: Номера отделений
+---
+
+## Description
+<section id="description"><p> Существует высоко организованный город, который решил присвоить номер каждому из своих отделов: </p> Отдел полиции Отдел санитарии Отдел пожарной охраны <p> Каждый отдел может иметь число от 1 до 7 (включительно). </p><p> Три номера отделов должны быть уникальными (отличными друг от друга) и должны содержать до 12. </p><p> Начальник полиции не любит странные цифры и хочет иметь четное число для своего отдела. </p> Задача: <p> Напишите программу, которая выводит все допустимые комбинации: </p><p> [2, 3, 7] </p><p> [2, 4, 6] </p><p> [2, 6, 4] </p><p> [2, 7, 3] </p><p> [4, 1, 7] </p><p> [4, 2, 6] </p><p> [4, 3, 5] </p><p> [4, 5, 3] </p><p> [4, 6, 2] </p><p> [4, 7, 1] </p><p> [6, 1, 5] </p><p> [6, 2, 4] </p><p> [6, 4, 2] </p><p> [6, 5, 1] </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>combinations</code> должны быть функцией.
+    testString: 'assert(typeof combinations === "function", "<code>combinations</code> should be a function.");'
+  - text: '<code>combinations([1, 2, 3], 6)</code> должны возвращать массив.'
+    testString: 'assert(Array.isArray(combinations([1, 2, 3], 6)), "<code>combinations([1, 2, 3], 6)</code> should return an Array.");'
+  - text: '<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> должны возвращать массив длиной 14.'
+    testString: 'assert(combinations(nums, total).length === len, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return an array of length 14.");'
+  - text: '<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> должны возвращать все допустимые комбинации.'
+    testString: 'assert.deepEqual(combinations(nums, total), result, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return all valid combinations.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function combinations (possibleNumbers, total) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/discordian-date.russian.md

@@ -0,0 +1,67 @@
+---
+title: Discordian date
+id: 59f4eafba0343628bb682785
+challengeType: 5
+videoUrl: ''
+localeTitle: Дискордианская дата
+---
+
+## Description
+<section id="description"> Задача: <p> Преобразуйте заданную дату из <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: григорианский календарь">григорианского календаря</a> в <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: Дискордианский календарь">Дискордианский календарь</a> . </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>discordianDate</code> - это функция.
+    testString: 'assert(typeof discordianDate === "function", "<code>discordianDate</code> is a function.");'
+  - text: '<code>discordianDate(new Date(2010, 6, 22))</code> должен вернуть <code>&quot;Pungenday, the 57th day of Confusion in the YOLD 3176&quot;</code> .'
+    testString: 'assert(discordianDate(new Date(2010, 6, 22)) === "Pungenday, the 57th day of Confusion in the YOLD 3176", "<code>discordianDate(new Date(2010, 6, 22))</code> should return <code>"Pungenday, the 57th day of Confusion in the YOLD 3176"</code>.");'
+  - text: '<code>discordianDate(new Date(2012, 1, 28))</code> должен вернуть <code>&quot;Prickle-Prickle, the 59th day of Chaos in the YOLD 3178&quot;</code> .'
+    testString: 'assert(discordianDate(new Date(2012, 1, 28)) === "Prickle-Prickle, the 59th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 1, 28))</code> should return <code>"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"</code>.");'
+  - text: '<code>discordianDate(new Date(2012, 1, 29))</code> должен вернуть <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\&quot;s Day!&quot;</code> .'
+    testString: 'assert(discordianDate(new Date(2012, 1, 29)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!", "<code>discordianDate(new Date(2012, 1, 29))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!"</code>.");'
+  - text: '<code>discordianDate(new Date(2012, 2, 1))</code> должен вернуть <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178&quot;</code> .'
+    testString: 'assert(discordianDate(new Date(2012, 2, 1)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 2, 1))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178"</code>.");'
+  - text: '<code>discordianDate(new Date(2010, 0, 5))</code> должен вернуть <code>&quot;Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!&quot;</code> ,'
+    testString: 'assert(discordianDate(new Date(2010, 0, 5)) === "Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!", "<code>discordianDate(new Date(2010, 0, 5))</code> should return <code>"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"</code>.");'
+  - text: '<code>discordianDate(new Date(2011, 4, 3))</code> должен вернуть <code>&quot;Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!&quot;</code> ,'
+    testString: 'assert(discordianDate(new Date(2011, 4, 3)) === "Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!", "<code>discordianDate(new Date(2011, 4, 3))</code> should return <code>"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"</code>.");'
+  - text: '<code>discordianDate(new Date(2015, 9, 19))</code> должен вернуть <code>&quot;Boomtime, the 73rd day of Bureaucracy in the YOLD 3181&quot;</code> .'
+    testString: 'assert(discordianDate(new Date(2015, 9, 19)) === "Boomtime, the 73rd day of Bureaucracy in the YOLD 3181", "<code>discordianDate(new Date(2015, 9, 19))</code> should return <code>"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function discordianDate (date) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/element-wise-operations.russian.md

@@ -0,0 +1,65 @@
+---
+title: Element-wise operations
+id: 599c333915e0ea32d04d4bec
+challengeType: 5
+videoUrl: ''
+localeTitle: Элементные операции
+---
+
+## Description
+<section id="description"><p> Реализуйте основные матричные матричные и скалярно-матричные операции. </p><p> Воплощать в жизнь: </p><p> :: * дополнение </p><p> :: * вычитание </p><p> :: * умножение </p><p> :: * раздел </p><p> :: * возведение в степень </p><p> Первым параметром будет операция, которая должна быть выполнена, например: «m_add» для добавления матрицы и «s_add» для скалярного добавления. Второй и третий параметры будут представлять собой матрицы, на которых должны выполняться операции. </p></section>
+
+## Instructions
+undefined
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>operation</code> - это функция.
+    testString: 'assert(typeof operation === "function", "<code>operation</code> is a function.");'
+  - text: '<code>operation(&quot;m_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны вернуться <code>[[2,4],[6,8]]</code> .'
+    testString: 'assert.deepEqual(operation("m_add", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[2, 4], [6, 8]], "<code>operation("m_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[2,4],[6,8]]</code>.");'
+  - text: '<code>operation(&quot;s_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны возвращать <code>[[3,4],[5,6]]</code> .'
+    testString: 'assert.deepEqual(operation("s_add", [[1, 2], [3, 4]], 2), [[3, 4], [5, 6]], "<code>operation("s_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[3,4],[5,6]]</code>.");'
+  - text: '<code>operation(&quot;m_sub&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны возвращать <code>[[0,0],[0,0]]</code> .'
+    testString: 'assert.deepEqual(operation("m_sub", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[0, 0], [0, 0]], "<code>operation("m_sub",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[0,0],[0,0]]</code>.");'
+  - text: '<code>operation(&quot;m_mult&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны возвращать <code>[[1,4],[9,16]]</code> .'
+    testString: 'assert.deepEqual(operation("m_mult", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 4], [9, 16]], "<code>operation("m_mult",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,4],[9,16]]</code>.");'
+  - text: '<code>operation(&quot;m_div&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны возвращать <code>[[1,1],[1,1]]</code> .'
+    testString: 'assert.deepEqual(operation("m_div", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 1], [1, 1]], "<code>operation("m_div",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,1],[1,1]]</code>.");'
+  - text: '<code>operation(&quot;m_exp&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> должны вернуться <code>[[1,4],[27,256]]</code> .'
+    testString: 'assert.deepEqual(operation("m_exp", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 4], [27, 256]], "<code>operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,4],[27,256]]</code>.");'
+  - text: '<code>operation(&quot;m_add&quot;,[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> должен возвращать <code>[[10,12,14,16],[18,20,22,24]]</code> .'
+    testString: 'assert.deepEqual(operation("m_add", [[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]), [[10, 12, 14, 16], [18, 20, 22, 24]], "<code>operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> should return <code>[[10,12,14,16],[18,20,22,24]]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function operation (op, arr1, arr2) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/emirp-primes.russian.md

@@ -0,0 +1,60 @@
+---
+title: Emirp primes
+id: 599d0ba974141b0f508b37d5
+challengeType: 5
+videoUrl: ''
+localeTitle: Бонусы Эмирпа
+---
+
+## Description
+<section id="description"><p> Эмирп (первичный, записанный в обратном порядке) - это простые числа, которые при обратном (в их десятичном представлении) являются разными штрихами. </p><p> Напишите функцию, которая должна быть способна: Показывать первые числа <b>n</b> номеров. Покажите числа eprimes в диапазоне. Покажите количество eprimes в диапазоне. Покажите номер <b>n <sup>th</sup></b> eprimes. </p><p> Функция должна иметь два параметра. Первый получит <b>n</b> или диапазон в виде массива. Вторая будет получать логическое значение, которое указывает, возвращает ли функция eprimes в виде массива или одного числа (количество простых чисел в диапазоне или <b>n- <sup>го</sup></b> числа). В соответствии с параметрами функция должна возвращать массив или число. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>emirps</code> - это функция.
+    testString: 'assert(typeof emirps === "function", "<code>emirps</code> is a function.");'
+  - text: '<code>emirps(20,true)</code> должны вернуться <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code>'
+    testString: 'assert.deepEqual(emirps(20, true), [13, 17, 31, 37, 71, 73, 79, 97, 107, 113, 149, 157, 167, 179, 199, 311, 337, 347, 359, 389], "<code>emirps(20,true)</code> should return <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code>");'
+  - text: <code>emirps(10000)</code> должен вернуть <code>948349</code>
+    testString: 'assert.deepEqual(emirps(10000), 948349, "<code>emirps(10000)</code> should return <code>948349</code>");'
+  - text: '<code>emirps([7700,8000],true)</code> должны быть возвращены <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code>'
+    testString: 'assert.deepEqual(emirps([7700, 8000], true), [7717, 7757, 7817, 7841, 7867, 7879, 7901, 7927, 7949, 7951, 7963], "<code>emirps([7700,8000],true)</code> should return <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code>");'
+  - text: '<code>emirps([7700,8000],true)</code> должен вернуть <code>11</code>'
+    testString: 'assert.deepEqual(emirps([7700, 8000], false), 11, "<code>emirps([7700,8000],true)</code> should return <code>11</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function emirps(n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/entropy.russian.md

@@ -0,0 +1,64 @@
+---
+title: Entropy
+id: 599d15309e88c813a40baf58
+challengeType: 5
+videoUrl: ''
+localeTitle: Энтропия
+---
+
+## Description
+<section id="description"> Задача: <p> Вычислите энтропию Шеннона H данной входной строки. </p><p> Учитывая выборочную случайную переменную $ X $, которая представляет собой строку из $ N $ &quot;символов&quot; (всего символов), состоящую из $ n $ различных символов (n = 2 для двоичных), энтропия Шеннона X в битах / символе: </p><p> $ H_2 (X) = - \ sum_ {i = 1} ^ n \ frac {count_i} {N} \ log_2 \ left (\ frac {count_i} {N} \ right) $ </p><p> где $ count_i $ - количество символов $ n_i $. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>entropy</code> - функция.
+    testString: 'assert(typeof entropy === "function", "<code>entropy</code> is a function.");'
+  - text: <code>entropy(&quot;0&quot;)</code> должна возвращать <code>0</code>
+    testString: 'assert.equal(entropy("0"), 0, "<code>entropy("0")</code> should return <code>0</code>");'
+  - text: <code>entropy(&quot;01&quot;)</code> должна вернуть <code>1</code>
+    testString: 'assert.equal(entropy("01"), 1, "<code>entropy("01")</code> should return <code>1</code>");'
+  - text: ''
+    testString: 'assert.equal(entropy("0123"), 2, "<code>entropy("0123")</code> should return <code>2</code>");'
+  - text: <code>entropy(&quot;01234567&quot;)</code> должна вернуть <code>3</code>
+    testString: 'assert.equal(entropy("01234567"), 3, "<code>entropy("01234567")</code> should return <code>3</code>");'
+  - text: <code>entropy(&quot;0123456789abcdef&quot;)</code> должна возвращать <code>4</code>
+    testString: 'assert.equal(entropy("0123456789abcdef"), 4, "<code>entropy("0123456789abcdef")</code> should return <code>4</code>");'
+  - text: <code>entropy(&quot;1223334444&quot;)</code> должна быть возвращена <code>1.8464393446710154</code>
+    testString: 'assert.equal(entropy("1223334444"), 1.8464393446710154, "<code>entropy("1223334444")</code> should return <code>1.8464393446710154</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function entropy (s) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/equilibrium-index.russian.md

@@ -0,0 +1,72 @@
+---
+title: Equilibrium index
+id: 5987fd532b954e0f21b5d3f6
+challengeType: 5
+videoUrl: ''
+localeTitle: Равновесный индекс
+---
+
+## Description
+<section id="description"><p> Равновесный индекс последовательности является индексом в такой последовательности, что сумма элементов при более низких индексах равна сумме элементов с более высокими индексами. </p><p> Например, в последовательности <big>$ A $</big> : </p><p> :::: <big>$ A_0 = -7 $</big> </p><p> :::: <big>$ A_1 = 1 $</big> </p><p> :::: <big>$ A_2 = 5 $</big> </p><p> :::: <big>$ A_3 = 2 $</big> </p><p> :::: <big>$ A_4 = -4 $</big> </p><p> :::: <big>$ A_5 = 3 $</big> </p><p> :::: <big>$ A_6 = 0 $</big> </p><p> 3 - показатель равновесия, поскольку: </p><p> :::: <big>$ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> </p><p> 6 также является показателем равновесия, поскольку: </p><p> :::: <big>$ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> </p><p> (сумма нулевых элементов равна нулю) </p><p> 7 не является индексом равновесия, поскольку он не является допустимым индексом последовательности <big>$ A $</big> . </p><p> Напишите функцию, которая, учитывая последовательность, возвращает свои равновесные индексы (если они есть). </p><p> Предположим, что последовательность может быть очень длинной. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>equilibrium</code> является функцией.
+    testString: 'assert(typeof equilibrium === "function", "<code>equilibrium</code> is a function.");'
+  - text: '<code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> должно вернуться <code>[3,6]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[0]), ans[0], "<code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> should return <code>[3,6]</code>.");'
+  - text: '<code>equilibrium([2, 4, 6])</code> должно возвращаться <code>[]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[1]), ans[1], "<code>equilibrium([2, 4, 6])</code> should return <code>[]</code>.");'
+  - text: '<code>equilibrium([2, 9, 2])</code> должно возвращаться <code>[1]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[2]), ans[2], "<code>equilibrium([2, 9, 2])</code> should return <code>[1]</code>.");'
+  - text: '<code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> должно возвращать <code>[0,1,2,3,4,5,6]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[3]), ans[3], "<code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> should return <code>[0,1,2,3,4,5,6]</code>.");'
+  - text: '<code>equilibrium([1])</code> должно возвращаться <code>[0]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[4]), ans[4], "<code>equilibrium([1])</code> should return <code>[0]</code>.");'
+  - text: '<code>equilibrium([])</code> должно возвращаться <code>[]</code> .'
+    testString: 'assert.deepEqual(equilibrium(tests[5]), ans[5], "<code>equilibrium([])</code> should return <code>[]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function equilibrium (a) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.russian.md

@@ -0,0 +1,62 @@
+---
+title: Ethiopian multiplication
+id: 599d1566a02b571412643b84
+challengeType: 5
+videoUrl: ''
+localeTitle: Эфиопское умножение
+---
+
+## Description
+<section id="description"><p> Эфиопское умножение - это метод умножения целых чисел, использующий только добавление, удвоение и уменьшение пополам. </p><p> Метод: </p> Возьмите два числа, чтобы их умножить и записать их в верхней части двух столбцов. В левом столбце повторите половину последнего номера, отбрасывая любые остатки и записывая результат ниже последнего в том же столбце, пока не напишите значение 1. В правом столбце многократно удвоите последнее число и запишите результат ниже. остановитесь, когда вы добавите результат в ту же строку, что и в столбце слева. 1. Изучите созданную таблицу и отбросьте любую строку, где значение в левом столбце четное. Суммируйте значения в правой колонке, которые останутся для получения результата умножения исходных двух чисел вместе <p> Например: 17 × 34 </p><p> 17 34 </p><p> Половина первого столбца: </p><p> 17 34 </p><p> 8 </p><p> 4 </p><p> 2 </p><p> 1 </p><p> Удвоение второй колонки: </p><p> 17 34 </p><p> 8 68 </p><p> 4 136 </p><p> 2 272 </p><p> 1 544 </p><p> Stratch-out rows, чья первая ячейка четная: </p><p> 17 34 </p><p> 8 <strike>68</strike> </p><p> 4 <strike>136</strike> </p><p> 2 <strike>272</strike> </p><p> 1 544 </p><p> Суммируйте оставшиеся числа в правом столбце: </p><p> 17 34 </p><p> 8 - </p><p> 4 --- </p><p> 2 --- </p><p> 1 544 </p><p> ==== </p><p> 578 </p><p> Так 17, умноженное на 34, по эфиопскому методу - 578. </p> Задача: <p> Задача состоит в том, чтобы определить три названные функции / методы / процедуры / подпрограммы: </p> один на половину целого числа, один для двойного целого числа, и один, чтобы указать, является ли целое четным. <p> Используйте эти функции для создания функции, которая делает эфиопское умножение. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>eth_mult</code> - это функция.
+    testString: 'assert(typeof eth_mult === "function", "<code>eth_mult</code> is a function.");'
+  - text: '<code>eth_mult(17,34)</code> должен вернуть <code>578</code> .'
+    testString: 'assert.equal(eth_mult(17, 34), 578, "<code>eth_mult(17,34)</code> should return <code>578</code>.");'
+  - text: '<code>eth_mult(23,46)</code> должен вернуть <code>1058</code> .'
+    testString: 'assert.equal(eth_mult(23, 46), 1058, "<code>eth_mult(23,46)</code> should return <code>1058</code>.");'
+  - text: '<code>eth_mult(12,27)</code> должен вернуть <code>324</code> .'
+    testString: 'assert.equal(eth_mult(12, 27), 324, "<code>eth_mult(12,27)</code> should return <code>324</code>.");'
+  - text: '<code>eth_mult(56,98)</code> должен вернуть <code>5488</code> .'
+    testString: 'assert.equal(eth_mult(56, 98), 5488, "<code>eth_mult(56,98)</code> should return <code>5488</code>.");'
+  - text: '<code>eth_mult(63,74)</code> должен вернуть <code>4662</code> .'
+    testString: 'assert.equal(eth_mult(63, 74), 4662, "<code>eth_mult(63,74)</code> should return <code>4662</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function eth_mult (a, b) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/euler-method.russian.md

@@ -0,0 +1,60 @@
+---
+title: Euler method
+id: 59880443fb36441083c6c20e
+challengeType: 5
+videoUrl: ''
+localeTitle: Метод Эйлера
+---
+
+## Description
+<section id="description"><p> Метод Эйлера численно аппроксимирует решения обыкновенных дифференциальных уравнений первого порядка (ОДУ) с заданным начальным значением. Это явный метод решения начальных задач (IVP), как описано <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: метод Эйлера">на странице wikipedia</a> . </p><p> ОДУ должно быть представлено в следующем виде: </p><p> :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> </p><p> с начальным значением </p><p> :: <big>$ y (t_0) = y_0 $</big> </p><p> Чтобы получить числовое решение, мы заменим производную на LHS с помощью разностной аппроксимации: </p><p> :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> </p><p> затем решить для $ y (t + h) $: </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> </p><p> который является таким же, как </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> </p><p> Итеративное правило решения: </p><p> :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> </p><p> где <big>$ h $</big> - размер шага, наиболее важный параметр для точности решения. Чем меньше размер шага, тем выше точность, но также и стоимость вычислений, поэтому его всегда нужно выбирать вручную в зависимости от проблемы. </p><p> Пример: закон охлаждения Ньютона </p><p> Закон охлаждения Ньютона описывает, как объект начальной температуры <big>$ T (t_0) = T_0 $</big> остывает в среде с температурой <big>$ T_R $</big> : </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> </p><p> или </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> </p><p> В нем говорится, что скорость охлаждения <big>$ \ frac {dT (t)} {dt} $</big> объекта пропорциональна текущей разности температур <big>$ \ Delta T = (T (t) - T_R) $</big> в окружающую среду. </p><p> Аналитическое решение, которое мы будем сравнивать с численным приближением, </p><p> :: <big>$ T (t) = T_R + (T_0 - T_R) \; е ^ {-} $ кт</big> </p> Задача: <p> Внедрить рутину метода Эйлера, а затем использовать его для решения данного примера закона охлаждения Ньютона с ним для трех разных размеров шага: </p><p> :: * 2 с </p><p> :: * 5 с и </p><p> :: * 10 с </p><p> и сравнить с аналитическим решением. </p> Начальные значения: <p> :: * начальная температура <big>$ T_0 $</big> должна быть 100 ° C </p><p> :: * комнатная температура <big>$ T_R $</big> должна составлять 20 ° C </p><p> :: * постоянная охлаждения <big>$ k $</big> должна составлять 0,07 </p><p> :: * интервал времени для вычисления должен составлять от 0 с ──► 100 с </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>eulersMethod</code> - это функция.
+    testString: 'assert(typeof eulersMethod === "function", "<code>eulersMethod</code> is a function.");'
+  - text: '<code>eulersMethod(0, 100, 100, 10)</code> должен возвращать число.'
+    testString: 'assert(typeof eulersMethod(0, 100, 100, 10) === "number", "<code>eulersMethod(0, 100, 100, 10)</code> should return a number.");'
+  - text: '<code>eulersMethod(0, 100, 100, 10)</code> должен возвращать 20.0424631833732.'
+    testString: 'assert.equal(eulersMethod(0, 100, 100, 2), 20.0424631833732, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.0424631833732.");'
+  - text: '<code>eulersMethod(0, 100, 100, 10)</code> должен возвращать 20.01449963666907.'
+    testString: 'assert.equal(eulersMethod(0, 100, 100, 5), 20.01449963666907, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.01449963666907.");'
+  - text: '<code>eulersMethod(0, 100, 100, 10)</code> должен возвращать 20.000472392.'
+    testString: 'assert.equal(eulersMethod(0, 100, 100, 10), 20.000472392, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.000472392.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function eulersMethod (x1, y1, x2, h) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.russian.md

@@ -0,0 +1,62 @@
+---
+title: Evaluate binomial coefficients
+id: 598de241872ef8353c58a7a2
+challengeType: 5
+videoUrl: ''
+localeTitle: Оценить биномиальные коэффициенты
+---
+
+## Description
+<section id="description"><p> Напишите функцию для вычисления биномиального коэффициента при заданном значении n и k. </p><p> Эта формула рекомендуется: </p> $ \ binom {n} {k} = \ frac {n!} {(nk)! k!} = \ frac {n (n-1) (n-2) \ ldots (n-k + 1)} { k (k-1) (k-2) \ ldots 1} $ </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>binom</code> - функция.
+    testString: 'assert(typeof binom === "function", "<code>binom</code> is a function.");'
+  - text: '<code>binom(5,3)</code> следует вернуть 10.'
+    testString: 'assert.equal(binom(5, 3), 10, "<code>binom(5,3)</code> should return 10.");'
+  - text: '<code>binom(7,2)</code> должен вернуть 21.'
+    testString: 'assert.equal(binom(7, 2), 21, "<code>binom(7,2)</code> should return 21.");'
+  - text: '<code>binom(10,4)</code> должен вернуть 210.'
+    testString: 'assert.equal(binom(10, 4), 210, "<code>binom(10,4)</code> should return 210.");'
+  - text: '<code>binom(6,1)</code> должен вернуть 6.'
+    testString: 'assert.equal(binom(6, 1), 6, "<code>binom(6,1)</code> should return 6.");'
+  - text: '<code>binom(12,8)</code> должен вернуть 495.'
+    testString: 'assert.equal(binom(12, 8), 495, "<code>binom(12,8)</code> should return 495.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function binom (n, k) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.russian.md

@@ -0,0 +1,118 @@
+---
+title: Execute a Markov algorithm
+id: 59e09e6d412c5939baa02d16
+challengeType: 5
+videoUrl: ''
+localeTitle: Выполнить алгоритм Маркова
+---
+
+## Description
+<section id="description"> Задача: <p> Создайте интерпретатор для <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: алгоритм Маркова">алгоритма Маркова</a> . </p><p> Правила имеют синтаксис: </p><p><ruleset> знак равно <comment> | <rule> ) <newline> +) * </newline></rule></comment></ruleset></p><p><comment> знак равно <any character=""> } </any></comment></p><p><rule> знак равно <pattern><whitespace> -&gt; <whitespace> [.] <replacement></replacement></whitespace></whitespace></pattern></rule></p><p><whitespace> знак равно <tab> | <space> ) [ <whitespace> ] </whitespace></space></tab></whitespace></p><p> В каждой строке есть одно правило. </p><p> Если есть <b>.</b> (период), присутствующий до <replacement> , то это правило окончания, в этом случае интерпретатор должен остановить выполнение. </replacement></p><p> Набор правил состоит из последовательности правил с необязательными комментариями. </p><p> <big><big>Rulesets</big></big> </p><p> Используйте следующие тесты для записей: </p> Правила 1: <pre> Этот файл правил извлекается из Википедии:
+http://en.wikipedia.org/wiki/Markov_AlgorithmA -&gt; яблоко
+B -&gt; сумка
+S -&gt; магазин
+T -&gt;
+магазин -&gt; мой брат
+никогда не использовалось -&gt; .terminating rule
+</pre><p> Пример текста: </p><p> <code>I bought a B of As from T S.</code> </p> <p> Должен генерировать вывод: </p><p> <code>I bought a bag of apples from my brother.</code> </p> Правила 2: <p> Проверка правила завершения </p><pre> Немного изменен из правил на WikipediaA -&gt; apple
+B -&gt; сумка
+S -&gt; .shop
+T -&gt;
+магазин -&gt; мой брат
+никогда не использовалось -&gt; .terminating rule </pre><p> Пример текста: </p><p> <code>I bought a B of As from T S.</code> </p> <p> Должна генерировать: </p><p> <code>I bought a bag of apples from T shop.</code> </p> Правила 3: <p> Это проверяет правильный порядок замещения и может задерживать простые подпрограммы на основе регулярного выражения, если специальные символы регулярного выражения не экранируются. </p><pre> BNF Синтаксические правила тестированияA -&gt; apple
+WWWW -&gt; с
+Багаж -&gt; -&gt;. *
+B -&gt; сумка
+-&gt;. * -&gt; деньги
+W -&gt; WW
+S -&gt; .shop
+T -&gt;
+магазин -&gt; мой брат
+никогда не использовалось -&gt; .terminating rule
+</pre><p> Пример текста: </p><p> <code>I bought a B of As W my Bgage from T S.</code> </p> <p> Должна генерировать: </p><p> <code>I bought a bag of apples with my money from T shop.</code> </p> Правила 4: <p> Это проверяет правильность порядка сканирования правил и может задерживать процедуры замены, которые сканируются в неправильном порядке. Он реализует общий механизм унарного умножения. (Обратите внимание, что входное выражение должно быть помещено в символы подчеркивания в этой реализации.) </p><pre> ## Unary Multiplication Engine, для тестирования алгоритмов Алгоритма Маркова
+## Донал Стипендиаты.
+Унарное сложение engine_ + 1 -&gt; _1 +
+1 + 1 -&gt; 11+
+Переход для преобразования из расщепления умножения в обычный
+addition1! -&gt; 1
+,! -&gt;! +
+_! -&gt; _
+Унарное умножение путем дублирования левой стороны, правое время 1 * 1 -&gt; x, @ y
+1x -&gt; xX
+X, -&gt; 1,1
+X1 -&gt; 1X
+_x -&gt; _X
+, х -&gt;, X
+y1 -&gt; 1y
+y_ -&gt; _
+Следующая фаза применения 1 @ 1 -&gt; x, @ y
+1 @ _ -&gt; @_
+, @ _ ​​-&gt;! _
+++ -&gt; +
+Очистка выводов для добавления_1 -&gt; 1
+1 + _ -&gt; 1
+_ + _ -&gt;
+</pre><p> Пример текста: </p><p> <code>_1111*11111_</code> </p> <p> должен генерировать вывод: </p><p> <code>11111111111111111111</code> </p> Правила 5: <p> Простая <a href="http://en.wikipedia.org/wiki/Turing_machine" title="ссылка: http://en.wikipedia.org/wiki/Turing_machine">машина Тьюринга</a> , </p><p> реализуя <a href="http://en.wikipedia.org/wiki/Busy_beaver" title="ссылка: http://ru.wikipedia.org/wiki/Busy_beaver">трехгосударственный бобр</a> . </p><p> Лента состоит из 0s и 1s, состояния A, B, C и H (для Halt), а положение головы указывается путем записи буквы состояния перед символом, где находится голова. </p><p> Все части исходной ленты, на которой работает машина, должны быть указаны на входе. </p><p> Кроме того, демонстрируя, что алгоритм Маркова является Turing-полным, он также заставил меня поймать ошибку в реализации C ++, которая не была захвачена первыми четырьмя наборами правил. </p><pre> Машина Тьюринга: бобер с тремя состояниями
+# состояние A, символ 0 =&gt; запись 1, перемещение вправо, новое состояние BA0 -&gt; 1B
+состояние A, символ 1 =&gt; запись 1, перемещение влево, новое состояние C0A1 -&gt; C01
+1A1 -&gt; C11
+состояние B, символ 0 =&gt; запись 1, перемещение влево, новое состояние A0B0 -&gt; A01
+1B0 -&gt; A11
+состояние B, символ 1 =&gt; записать 1, двигаться вправо, новое состояние BB1 -&gt; 1B
+состояние C, символ 0 =&gt; запись 1, перемещение влево, новое состояние B0C0 -&gt; B01
+1C0 -&gt; B11
+состояние C, символ 1 =&gt; запись 1, перемещение влево, halt0C1 -&gt; H01
+1C1 -&gt; H11
+</pre><p> Этот набор правил должен </p><p> <code>000000A000000</code> </p> <p> в </p><p> <code>00011H1111000</code> </p> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>markov</code> - функция.
+    testString: 'assert(typeof markov === "function", "<code>markov</code> is a function.");'
+  - text: '<code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> должен вернуться «Я купил мешок с яблоками от моего брата».'
+    testString: 'assert.deepEqual(markov(rules[0],tests[0]),outputs[0],"<code>markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")</code> should return "I bought a bag of apples from my brother.".");'
+  - text: '<code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> должен вернуться« Я купил мешок яблок из магазина T ».'
+    testString: 'assert.deepEqual(markov(rules[1],tests[1]),outputs[1],"<code>markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")</code> should return "I bought a bag of apples from T shop.".");'
+  - text: '<code>markov([&quot;A -&gt; apple&quot;,&quot;WWWW -&gt; with&quot;,&quot;Bgage -&gt; -&gt;.*&quot;,&quot;B -&gt; bag&quot;,&quot;-&gt;.* -&gt; money&quot;,&quot;W -&gt; WW&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As W my Bgage from T S.&quot;)</code> должен вернуться« Я купил мешок с яблоками с моими деньгами из магазина T ».'
+    testString: 'assert.deepEqual(markov(rules[2],tests[2]),outputs[2],"<code>markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")</code> should return "I bought a bag of apples with my money from T shop.".");'
+  - text: '<code>markov([&quot;_+1 -&gt; _1+&quot;,&quot;1+1 -&gt; 11+&quot;,&quot;1! -&gt; !1&quot;,&quot;,! -&gt; !+&quot;,&quot;_! -&gt; _&quot;,&quot;1*1 -&gt; x,@y&quot;,&quot;1x -&gt; xX&quot;,&quot;X, -&gt; 1,1&quot;,&quot;X1 -&gt; 1X&quot;,&quot;_x -&gt; _X&quot;,&quot;,x -&gt; ,X&quot;,&quot;y1 -&gt; 1y&quot;,&quot;y_ -&gt; _&quot;,&quot;1@1 -&gt; x,@y&quot;,&quot;1@_ -&gt; @_&quot;,&quot;,@_ -&gt; !_&quot;,&quot;++ -&gt; +&quot;,&quot;_1 -&gt; 1&quot;,&quot;1+_ -&gt; 1&quot;,&quot;_+_ -&gt; &quot;],&quot;_1111*11111_&quot;)</code> должен возвращать&quot; 11111111111111111111 &quot;.'
+    testString: 'assert.deepEqual(markov(rules[3],tests[3]),outputs[3],"<code>markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")</code> should return "11111111111111111111".");'
+  - text: '<code>markov([&quot;A0 -&gt; 1B&quot;,&quot;0A1 -&gt; C01&quot;,&quot;1A1 -&gt; C11&quot;,&quot;0B0 -&gt; A01&quot;,&quot;1B0 -&gt; A11&quot;,&quot;B1 -&gt; 1B&quot;,&quot;0C0 -&gt; B01&quot;,&quot;1C0 -&gt; B11&quot;,&quot;0C1 -&gt; H01&quot;,&quot;1C1 -&gt; H11&quot;],&quot;&quot;)</code> должны возвращать« 00011H1111000 ».'
+    testString: 'assert.deepEqual(markov(rules[4],tests[4]),outputs[4],"<code>markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")</code> should return "00011H1111000".");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function markov (rules,test) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/execute-brain.russian.md

@@ -0,0 +1,133 @@
+---
+title: Execute Brain****
+id: 59e0a8df964e4540d5abe599
+challengeType: 5
+videoUrl: ''
+localeTitle: Выполнить мозг ****
+---
+
+## Description
+<section id="description"><p> Напишите функцию для реализации интерпретатора Brain ****. Функция примет строку как параметр и должна вернуть строку в качестве вывода. Более подробная информация приведена ниже: </p><p> RCBF представляет собой набор компиляторов и интерпретаторов <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***,</a> написанных для Rosetta Code на разных языках. </p><p> Ниже приведены ссылки на каждую из версий RCBF. </p><p> Для реализации необходимо только правильно выполнить следующие инструкции: </p><p> {| </p><p> ! Command </p><p> !Описание </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>&gt;</code> || Переместите указатель вправо </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>&lt;</code> || Переместите указатель влево </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>+</code> || Увеличение ячейки памяти под указателем </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>-</code> || Уменьшить ячейку памяти под указателем </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>.</code> || Вывести символ, обозначенный ячейкой указателем </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>,</code> || Введите символ и сохраните его в ячейке указателя </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>[</code> || Перейти мимо соответствия <code>]</code> если ячейка под указателем равна 0 </p><p> | - </p><p> | стиль = «выравнивание текста: центр» | <code>]</code> || Вернитесь к совпадению <code>[</code> если ячейка под указателем отлична от нуля </p><p> |} </p><p> Любой размер ячейки разрешен, поддержка EOF ( <u>E</u> nd- <u>O-</u> <u>F</u> ile) необязательна, равно как и ограниченная или неограниченная память. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>brain(bye)</code> должен возвращать строку
+    testString: 'assert(typeof brain(bye) === "string", "<code>brain(bye)</code> should return a string");'
+  - text: '<code>brain("++++++[>++++++++++<-]>+++++.")</code should return "A"'
+    testString: 'assert.equal(brain("++++++[>++++++++++<-]>+++++."),"A", "<code>brain("++++++[>++++++++++<-]>+++++.")</code should return "A"");'
+  - text: '<code>brain(bye)</code> должен возвращать <code>Goodbye, World!\\r\\n</code>'
+    testString: 'assert.equal(brain(bye), "Goodbye, World!\r\n", "<code>brain(bye)</code> should return <code>Goodbye, World!\\r\\n</code>");'
+  - text: '<code>brain(hello)</code> должен вернуть <code>Hello World!\\n</code> &#39;'
+    testString: 'assert.equal(brain(hello), "Hello World!\n", "<code>brain(hello)</code> should return <code>Hello World!\\n</code>");'
+  - text: '<code>brain(fib)</code> должен возвращать <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code>'
+    testString: 'assert.equal(brain(fib), "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89", "<code>brain(fib)</code> should return <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function brain (prog) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+### Before Test
+<div id='js-setup'>
+
+```js
+let fib=`+
+
+++
+
++++
+
+++++
+
++>+>>
+
+>>++++
+
++++++++
+
+++++++++
+
++++++++++
+
+++++++++++
+
+++++++>++++
+
+++++++++++++
+
++++++++++++++
+
++++<<<<<<[>[>>
+
+>>>>+>+<<<<<<<-
+
+]>>>>>>>[<<<<<<<
+
++>>>>>>>-]<[>++++
+
+++++++[-<-[>>+>+<<
+
+<-]>>>[<<<+>>>-]+<[
+
+>[-]<[-]]>[<<[>>>+<<
+
+<-]>>[-]]<<]>>>[>>+>+
+
+<<<-]>>>[<<<+>>>-]+<[>
+
+[-]<[-]]>[<<+>>[-]]<<<<
+
+<<<]>>>>>[++++++++++++++
+
++++++++++++++++++++++++++
+
++++++++++.[-]]++++++++++<[
+
+->-<]>+++++++++++++++++++++
+
++++++++++++++++++++++++++++.
+
+[-]<<<<<<<<<<<<[>>>+>+<<<<-]>
+
+>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]
+
+<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+
+
+>-]>[<+>-]<<<-]`;
+let hello='++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'
+let bye='++++++++++[>+>+++>++++>+++++++>++++++++>+++++++++>++++++++++>+++++++++++>++++++++++++<<<<<<<<<-]>>>>+.>>>>+..<.<++++++++.>>>+.<<+.<<<<++++.<++.>>>+++++++.>>>.+++.<+++++++.--------.<<<<<+.<+++.---.';
+
+```
+
+</div>
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/extensible-prime-generator.russian.md

@@ -0,0 +1,60 @@
+---
+title: Extensible prime generator
+id: 598ee8b91b410510ae82efef
+challengeType: 5
+videoUrl: ''
+localeTitle: Расширяемый первичный генератор
+---
+
+## Description
+<section id="description"><p> Напишите генератор простых чисел, чтобы он автоматически регулировался для генерации любого разумно высокого премьер. </p> Генератор должен иметь возможность: Показывать первые <b>n</b> простых чисел. Показывать простые числа в диапазоне. Показывать количество простых чисел в диапазоне. Показывать <b>n- <sup>е</sup></b> простое число. <p> Функция должна иметь два параметра. Первый получит <b>n</b> или диапазон в виде массива. Вторая будет получать логическое значение, которое указывает, возвращает ли функция числа простых чисел в виде массива или одного числа (числа простых чисел в диапазоне или <b>n- <sup>го</sup></b> числа). В соответствии с параметрами функция должна возвращать массив. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>primeGenerator</code> - функция.
+    testString: 'assert(typeof primeGenerator === "function", "<code>primeGenerator</code> is a function.");'
+  - text: <code>primeGenerator</code> - функция.
+    testString: 'assert.deepEqual(primeGenerator(20, true), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71], "<code>primeGenerator</code> is a function.");'
+  - text: <code>primeGenerator</code> - функция.
+    testString: 'assert.deepEqual(primeGenerator([100, 150], true), [101, 103, 107, 109, 113, 127, 131, 137, 139, 149], "<code>primeGenerator</code> is a function.");'
+  - text: <code>primeGenerator</code> - функция.
+    testString: 'assert.equal(primeGenerator([7700, 8000], false), 30, "<code>primeGenerator</code> is a function.");'
+  - text: <code>primeGenerator</code> - функция.
+    testString: 'assert.equal(primeGenerator(10000, false), 104729, "<code>primeGenerator</code> is a function.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function primeGenerator (num, showPrimes) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/factorial.russian.md

@@ -0,0 +1,68 @@
+---
+title: Factorial
+id: 597b2b2a2702b44414742771
+challengeType: 5
+videoUrl: ''
+localeTitle: Факториал
+---
+
+## Description
+<section id="description"><p> Напишите функцию для возврата факториала числа. </p><p> Факториал числа определяется: </p> п! = n * (n-1) * (n-2) * ..... * 1 <p> Например: 3! = 3 * 2 * 1 = 6 4! = 4 * 3 * 2 * 1 = 24 </p><p> Примечание: 0! = 1 </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>factorial</code> - это функция.
+    testString: 'assert(typeof factorial === "function", "<code>factorial</code> is a function.");'
+  - text: <code>factorial(2)</code> должен возвращать число.
+    testString: 'assert(typeof factorial(2) === "number", "<code>factorial(2)</code> should return a number.");'
+  - text: <code>factorial(3)</code> должен вернуть 6. &quot;)
+    testString: 'assert.equal(factorial(3),results[0],"<code>factorial(3)</code> should return 6.");'
+  - text: <code>factorial(3)</code> должен вернуть 120. »)
+    testString: 'assert.equal(factorial(5),results[1],"<code>factorial(3)</code> should return 120.");'
+  - text: '<code>factorial(3)</code> должен вернуть 3,628,800. &quot;)'
+    testString: 'assert.equal(factorial(10),results[2],"<code>factorial(3)</code> should return 3,628,800.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function factorial (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/factors-of-an-integer.russian.md

@@ -0,0 +1,66 @@
+---
+title: Factors of an integer
+id: 597f1e7fbc206f0e9ba95dc4
+challengeType: 5
+videoUrl: ''
+localeTitle: Факторы целого числа
+---
+
+## Description
+<section id="description"><p> Напишите функцию, возвращающую множители положительного целого числа. </p><p> Этими факторами являются положительные целые числа, по которым число, подлежащее учету, можно разделить, чтобы получить положительный целочисленный результат. </p> /// </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>factors</code> - это функция.
+    testString: 'assert(typeof factors === "function", "<code>factors</code> is a function.");'
+  - text: '<code>factors(45)</code> должны вернуться <code>[1,3,5,9,15,45]</code> .'
+    testString: 'assert.deepEqual(factors(45), ans[0], "<code>factors(45)</code> should return <code>[1,3,5,9,15,45]</code>.");'
+  - text: '<code>factors(53)</code> должны возвращать <code>[1,53]</code> .'
+    testString: 'assert.deepEqual(factors(53), ans[1], "<code>factors(53)</code> should return <code>[1,53]</code>.");'
+  - text: '<code>factors(64)</code> должны возвращать <code>[1,2,4,8,16,32,64]</code> .'
+    testString: 'assert.deepEqual(factors(64), ans[2], "<code>factors(64)</code> should return <code>[1,2,4,8,16,32,64]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function factors (num) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/farey-sequence.russian.md

@@ -0,0 +1,60 @@
+---
+title: Farey sequence
+id: 59c3ec9f15068017c96eb8a3
+challengeType: 5
+videoUrl: ''
+localeTitle: Последовательность Farey
+---
+
+## Description
+<section id="description"><p> Напишите функцию, которая возвращает последовательность Farey порядка n. Функция должна иметь один параметр, который равен n. Он должен возвращать последовательность в виде массива. Подробнее читайте ниже: </p><p> Последовательность <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: последовательность Farey">Farey</a> F <sub>n</sub> порядка n представляет собой последовательность полностью восстановленных фракций между 0 и 1, которые, если в младших членах, имеют знаменатели, меньшие или равные n, упорядоченные в порядке возрастания. </p><p> Последовательность Farey иногда некорректно называется серией Farey. </p><p> Каждая последовательность Farey: </p><p> :: * начинается со значения 0, обозначаемого дробью $ \ frac {0} {1} $ </p><p> :: * заканчивается значением 1, обозначаемым дробью $ \ frac {1} {1} $. </p><p> Последовательности Farey от 1 до 5: </p><p> $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ </p><p></p><p> $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ </p><p></p><p> $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ </p><p></p><p> $ {\ bf \ it {F}} _ 4 = \ frac {0} {1}, \ frac {1} {4}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {3} {4}, \ frac {1} {1} $ </p><p></p><p> $ {\ bf \ it {F}} _ 5 = \ frac {0} {1}, \ frac {1} {5}, \ frac {1} {4}, \ frac {1} {3}, \ frac {2} {5}, \ frac {1} {2}, \ frac {3} {5}, \ frac {2} {3}, \ frac {3} {4}, \ frac {4} {5 }, \ frac {1} {1} $ </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>farey</code> - это функция.
+    testString: 'assert(typeof farey === "function", "<code>farey</code> is a function.");'
+  - text: <code>farey(3)</code> должен возвращать массив
+    testString: 'assert(Array.isArray(farey(3)), "<code>farey(3)</code> should return an array");'
+  - text: '<code>farey(3)</code> должен возвращать <code>[&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/3&quot;]</code>'
+    testString: 'assert.deepEqual(farey(3), ["1/3","1/2","2/3"], "<code>farey(3)</code> should return <code>["1/3","1/2","2/3"]</code>");'
+  - text: '<code>farey(4)</code> должен возвращать <code>[&quot;1/4&quot;,&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;2/3&quot;,&quot;3/4&quot;]</code>'
+    testString: 'assert.deepEqual(farey(4), ["1/4","1/3","1/2","2/4","2/3","3/4"], "<code>farey(4)</code> should return <code>["1/4","1/3","1/2","2/4","2/3","3/4"]</code>");'
+  - text: '<code>farey(5)</code> должен возвращать <code>[&quot;1/5&quot;,&quot;1/4&quot;,&quot;1/3&quot;,&quot;2/5&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;3/5&quot;,&quot;2/3&quot;,&quot;3/4&quot;,&quot;4/5&quot;]</code>'
+    testString: 'assert.deepEqual(farey(5), ["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"], "<code>farey(5)</code> should return <code>["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function farey (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.russian.md

@@ -0,0 +1,74 @@
+---
+title: Fibonacci n-step number sequences
+id: 598eef80ba501f1268170e1e
+challengeType: 5
+videoUrl: ''
+localeTitle: Число n-ступенчатых чисел Фибоначчи
+---
+
+## Description
+<section id="description"><p> Напишите функцию для генерации последовательности n-шаговых последовательностей Фибоначчи и последовательностей Лукаса. Первым параметром будет n. Второй параметр будет состоять из числа возвращаемых элементов. Третий параметр будет определять, следует ли выводить последовательность Фибоначчи или последовательность Лукаса. Если параметр «f», то верните последовательность Фибоначчи, и если это «l», верните последовательность Лукаса. Последовательности должны быть возвращены как массив. Более подробная информация приведена ниже: </p><p> Эти ряды чисел являются расширением обычной <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Последовательность Фибоначчи">последовательности Фибоначчи,</a> где: </p> При $ n = 2 $ мы имеем последовательность Фибоначчи; с начальными значениями $ [1, 1] $ и $ F_k ^ 2 = F_ {k-1} ^ 2 + F_ {k-2} ^ 2 $ При $ n = 3 $ мы имеем трибоначчивую последовательность; с начальными значениями $ [1, 1, 2] $ и $ F_k ^ 3 = F_ {k-1} ^ 3 + F_ {k-2} ^ 3 + F_ {k-3} ^ 3 $ При $ n = 4 $, мы имеем последовательность tetranacci; с начальными значениями $ [1, 1, 2, 4] $ и $ F_k ^ 4 = F_ {k-1} ^ 4 + F_ {k-2} ^ 4 + F_ {k-3} ^ 4 + F_ {k -4} ^ 4 $ ... Для общего $ n&gt; 2 $ мы имеем последовательность $ n $ -последовательности Фибоначчи - $ F_k ^ n $; с начальными значениями первых $ n $ значений $ (n-1) $ &#39;th Fibonacci $ n $ -ступенчатой ​​последовательности $ F_k ^ {n-1} $; и $ k $ -ное значение этой $ n $ -ой последовательности является $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $ <p> При малых значениях $ n $ <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Префикс номера # Greek_series">греческие числовые префиксы</a> иногда используются для индивидуального обозначения каждой серии. </p><p> {| style = &quot;text-align: left;&quot; border = &quot;4&quot; cellpadding = &quot;2&quot; cellspacing = &quot;2&quot; </p><p> | + Последовательности Фибоначчи $ n $ -ступят </p><p> | - style = &quot;background-color: rgb (255, 204, 255);&quot; </p><p> ! $ n $ !! Название серии !! Значения </p><p> | - </p><p> | 2 || Фибоначчи || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... </p><p> | - </p><p> | 3 || Трибоначчи || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... </p><p> | - </p><p> | 4 || тетранацци || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... </p><p> | - </p><p> | 5 || пентаначчи || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... </p><p> | - </p><p> | 6 || гексаначчи || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... </p><p> | - </p><p> | 7 || Гептаначи || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... </p><p> | - </p><p> | 8 || октоначчи || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... </p><p> | - </p><p> | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... </p><p> | - </p><p> | 10 || деканаци || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... </p><p> |} </p><p> Последовательности союзников могут быть сгенерированы при изменении начальных значений: </p><p> Серия <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: номер Лукаса">Lucas</a> суммирует два предыдущих значения, такие как ряд фибоначчи для $ n = 2 $, но использует начальные значения $ [2, 1] $. </p><p><!-- Lucas numbers, Lucas number, Lucas series     [added to make searches easier.] --></p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>fib_luc</code> является функцией.
+    testString: 'assert(typeof fib_luc === "function", "<code>fib_luc</code> is a function.");'
+  - text: '<code>fib_luc(2,10,&quot;f&quot;)</code> должен вернуть <code>[1,1,2,3,5,8,13,21,34,55]</code> .'
+    testString: 'assert.deepEqual(fib_luc(2,10,"f"),ans[0],"<code>fib_luc(2,10,"f")</code> should return <code>[1,1,2,3,5,8,13,21,34,55]</code>.");'
+  - text: '<code>fib_luc(3,15,&quot;f&quot;)</code> должен вернуться <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code> .'
+    testString: 'assert.deepEqual(fib_luc(3,15,"f"),ans[1],"<code>fib_luc(3,15,"f")</code> should return <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code>.");'
+  - text: '<code>fib_luc(4,15,&quot;f&quot;)</code> должен вернуться <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code> .'
+    testString: 'assert.deepEqual(fib_luc(4,15,"f"),ans[2],"<code>fib_luc(4,15,"f")</code> should return <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code>.");'
+  - text: '<code>fib_luc(2,10,&quot;l&quot;)</code> должен возвращать <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code> .'
+    testString: 'assert.deepEqual(fib_luc(2,10,"l"),ans[3],"<code>fib_luc(2,10,"l")</code> should return <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code>.");'
+  - text: '<code>fib_luc(3,15,&quot;l&quot;)</code> должны возвращать <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code> .'
+    testString: 'assert.deepEqual(fib_luc(3,15,"l"),ans[4],"<code>fib_luc(3,15,"l")</code> should return <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code>.");'
+  - text: '<code>fib_luc(4,15,&quot;l&quot;)</code> должен возвращать <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code> .'
+    testString: 'assert.deepEqual(fib_luc(4,15,"l"),ans[5],"<code>fib_luc(4,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code>.");'
+  - text: '<code>fib_luc(5,15,&quot;l&quot;)</code> должен возвращать <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code> .'
+    testString: 'assert.deepEqual(fib_luc(5,15,"l"),ans[6],"<code>fib_luc(5,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function fib_luc (n, len, w) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/fibonacci-sequence.russian.md

@@ -0,0 +1,60 @@
+---
+title: Fibonacci sequence
+id: 597f24c1dda4e70f53c79c81
+challengeType: 5
+videoUrl: ''
+localeTitle: Последовательность Фибоначчи
+---
+
+## Description
+<section id="description"><p> Напишите функцию для генерации <big>n- <sup>го</sup></big> числа Фибоначчи. </p> /// <p> <big>N- <sup>е</sup></big> число Фибоначчи дается: /// </p><p> F <sub>n</sub> = F <sub>n-1</sub> + F <sub>n-2</sub> </p> /// <p> Первые два члена серии - 0, 1. </p> /// <p> Следовательно, ряд равен: 0, 1, 1, 2, 3, 5, 8, 13 ... </p> /// </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>fibonacci</code> - это функция.
+    testString: 'assert(typeof fibonacci === "function", "<code>fibonacci</code> is a function.");'
+  - text: <code>fibonacci(2)</code> должны возвращать число.
+    testString: 'assert(typeof fibonacci(2) == "number", "<code>fibonacci(2)</code> should return a number.");'
+  - text: <code>fibonacci(3)</code> должны вернуть 1. &quot;)
+    testString: 'assert.equal(fibonacci(3),1,"<code>fibonacci(3)</code> should return 1.");'
+  - text: <code>fibonacci(5)</code> должны возвращать 3. &quot;)
+    testString: 'assert.equal(fibonacci(5),3,"<code>fibonacci(5)</code> should return 3.");'
+  - text: <code>fibonacci(10)</code> должны вернуть 34. »)
+    testString: 'assert.equal(fibonacci(10),34,"<code>fibonacci(10)</code> should return 34.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function fibonacci(n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/fibonacci-word.russian.md

@@ -0,0 +1,64 @@
+---
+title: Fibonacci word
+id: 5992e222d397f00d21122931
+challengeType: 5
+videoUrl: ''
+localeTitle: Слово Фибоначчи
+---
+
+## Description
+<section id="description"><p> Напишите функцию для возврата слов Фибоначчи до N. N будет предоставлена ​​в качестве параметра функции. Функция должна возвращать массив объектов. Объекты должны иметь вид: {N: 1, Length: 1, Entropy: 0, Word: &#39;1&#39;}. Более подробная информация приведена ниже: </p><p> Слово Фибоначчи может быть создано способом, аналогичным последовательности Фибоначчи, <a href="http://hal.archives-ouvertes.fr/docs/00/36/79/72/PDF/The_Fibonacci_word_fractal.pdf" title="ссылка: http://hal.archives-ouvertes.fr/docs/00/36/79/72/PDF/The_Fibonacci_word_fractal.pdf">как описано здесь</a> : </p><p> Определите F_Word <sub>1</sub> как 1 </p><p> Определить F_Word <sub>2</sub> как 0 </p><p> Форма F_Word <sub>3</sub> как F_Word <sub>2,</sub> объединенная с F_Word <sub>1,</sub> то есть: 01 </p><p> Форма F_Word <sub>n</sub> как F_Word <sub>n-1,</sub> связанная с F_word <sub>n-2</sub> </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>fibWord</code> - это функция.
+    testString: 'assert(typeof fibWord === "function", "<code>fibWord</code> is a function.");'
+  - text: <code>fibWord(5)</code> должен возвращать массив.
+    testString: 'assert(Array.isArray(fibWord(5)),"<code>fibWord(5)</code> should return an array.");'
+  - text: '<code>fibWord(5)</code> должен возвращать <code>&#39;+JSON.stringify(ans)+&#39;</code> .'
+    testString: 'assert.deepEqual(fibWord(5),ans,"<code>fibWord(5)</code> should return <code>"+JSON.stringify(ans)+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function fibWord (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/fractran.russian.md

@@ -0,0 +1,72 @@
+---
+title: Fractran
+id: 5a7dad05be01840e1778a0d1
+challengeType: 3
+videoUrl: ''
+localeTitle: Fractran
+---
+
+## Description
+<section id="description"><div class="rosetta"><p class="rosetta__paragraph"> <span class="rosetta__text--bold"><a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a></span> - полный эзотерический язык программирования Тьюринга, изобретенный математиком <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: Джон Хортон Конвей">Джоном Хортоном Конвеем</a> . </p><br><p class="rosetta__paragraph"> Программа FRACTRAN представляет собой упорядоченный список положительных дробей $ P = (f_1, f_2, \ ldots, f_m) $ вместе с начальным положительным целым числом $ n $. </p><br><p class="rosetta__paragraph"> Программа запускается путем обновления целого числа $ n $ следующим образом: </p><br><ul class="rosetta__unordered-list"><li class="rosetta__list-item--unordered"> для первой фракции $ f_i $ в списке, для которого $ nf_i $ является целым числом, замените $ n $ на $ nf_i $; </li><li class="rosetta__list-item--unordered"> повторите это правило, пока никакая фракция в списке не выдает целое число при умножении на $ n $, а затем остановится. </li></ul><br><p class="rosetta__paragraph"> Конвей дал программу для простых чисел в FRACTRAN: </p><br><p class="rosetta__paragraph"> <span class="rosetta__text--indented">17 долл. США, долл. США, долл. США, долл. США / $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $</span> </p><br><p class="rosetta__paragraph"> Начиная с $ n = 2 $, эта программа FRACTRAN изменит $ n $ на $ 15 = 2 \ times (15/2) $, затем $ 825 = 15 \ times (55/1) $, генерируя следующую последовательность целых чисел: </p><br><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $</span> </p><br><p class="rosetta__paragraph"> После 2 эта последовательность содержит следующие степени 2: </p><br><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 ^ 2 = 4 $, $ 2 ^ 3 = 8 $, $ 2 ^ 5 = 32 $, $ 2 ^ 7 = 128 $, $ 2 ^ {11} = 2048 $, $ 2 ^ {13} = 8192 $, $ 2 ^ {17 } = 131072 $, $ 2 ^ {19} = 524288 $, $ \ ldots $</span> </p><br><p class="rosetta__paragraph"> которые являются главными полномочиями 2. </p><br><dl class="rosetta__description-list"><dt class="rosetta__description-title"> Задача: </dt></dl><p class="rosetta__paragraph"> Напишите функцию, которая принимает программу fractran как строковый параметр и возвращает первые 10 номеров программы в виде массива. Если результат не содержит 10 чисел, тогда возвращаем числа как есть. </p></div></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>fractran</code> должна быть функцией.
+    testString: 'assert(typeof fractran=="function","<code>fractran</code> should be a function.");'
+  - text: '<code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> должен возвращать массив.'
+    testString: 'assert(Array.isArray(fractran(tests[0])),"<code>fractran(""+tests[0]+"")</code> should return an array.");'
+  - text: '<code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[0])+&quot;</code> .'
+    testString: 'assert.deepEqual(fractran(tests[0]),results[0],"<code>fractran(""+tests[0]+"")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
+  - text: '<code>fractran(&quot;&quot;+tests[1]+&quot;&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[1])+&quot;</code> .'
+    testString: 'assert.deepEqual(fractran(tests[1]),results[1],"<code>fractran(""+tests[1]+"")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
+  - text: '<code>fractran(&quot;&quot;+tests[2]+&quot;&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[2])+&quot;</code> .'
+    testString: 'assert.deepEqual(fractran(tests[2]),results[2],"<code>fractran(""+tests[2]+"")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
+  - text: '<code>fractran(&quot;&quot;+tests[3]+&quot;&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[3])+&quot;</code> .'
+    testString: 'assert.deepEqual(fractran(tests[3]),results[3],"<code>fractran(""+tests[3]+"")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
+  - text: '<code>fractran(&quot;&quot;+tests[4]+&quot;&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[4])+&quot;</code> .'
+    testString: 'assert.deepEqual(fractran(tests[4]),results[4],"<code>fractran(""+tests[4]+"")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function fractran (progStr) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/gamma-function.russian.md

@@ -0,0 +1,72 @@
+---
+title: Gamma function
+id: 5a23c84252665b21eecc7e76
+challengeType: 5
+videoUrl: ''
+localeTitle: Гамма-функция
+---
+
+## Description
+<section id="description"> Внедрите один алгоритм (или более) для вычисления функции <a href="https://en.wikipedia.org/wiki/Gamma function">Gamma</a> ($ \ Gamma $) (только в реальном поле). Гамма-функция может быть определена как: <div style="padding-left: 4em;"> <big><big>$ \ Gamma (x) = \ displaystyle \ int_0 ^ \ infty t ^ {x-1} e ^ {- t} dt $</big></big> </div></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>gamma</code> должна быть функцией.
+    testString: 'assert(typeof gamma=="function","<code>gamma</code> should be a function.")'
+  - text: '<code>gamma(&quot;+tests[0]+&quot;)</code> должно возвращать число.'
+    testString: 'assert(typeof gamma(tests[0])=="number","<code>gamma("+tests[0]+")</code> should return a number.")'
+  - text: '<code>gamma(&quot;+tests[0]+&quot;)</code> должен возвращать <code>&quot;+results[0]+&quot;</code> .'
+    testString: 'assert.equal(gamma(tests[0]),results[0],"<code>gamma("+tests[0]+")</code> should return <code>"+results[0]+"</code>.")'
+  - text: '<code>gamma(&quot;+tests[1]+&quot;)</code> должны возвращать <code>&quot;+results[1]+&quot;</code> .'
+    testString: 'assert.equal(gamma(tests[1]),results[1],"<code>gamma("+tests[1]+")</code> should return <code>"+results[1]+"</code>.")'
+  - text: '<code>gamma(&quot;+tests[2]+&quot;)</code> должен возвращать <code>&quot;+results[2]+&quot;</code> .'
+    testString: 'assert.equal(gamma(tests[2]),results[2],"<code>gamma("+tests[2]+")</code> should return <code>"+results[2]+"</code>.")'
+  - text: '<code>gamma(&quot;+tests[3]+&quot;)</code> должны возвращать <code>&quot;+results[3]+&quot;</code> .'
+    testString: 'assert.equal(gamma(tests[3]),results[3],"<code>gamma("+tests[3]+")</code> should return <code>"+results[3]+"</code>.")'
+  - text: '<code>gamma(&quot;+tests[4]+&quot;)</code> должны возвращать <code>&quot;+results[4]+&quot;</code> .'
+    testString: 'assert.equal(gamma(tests[4]),results[4],"<code>gamma("+tests[4]+")</code> should return <code>"+results[4]+"</code>.")'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function gamma (x) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/gaussian-elimination.russian.md

@@ -0,0 +1,72 @@
+---
+title: Gaussian elimination
+id: 5a23c84252665b21eecc7e77
+challengeType: 5
+videoUrl: ''
+localeTitle: Гауссово исключение
+---
+
+## Description
+<section id="description"> Напишите функцию для решения \ (Ax = b \), используя гауссово исключение, затем обратную замену. \ (A \) является матрицей \ (n \ times n \). Кроме того, \ (x \) и \ (b \) являются \ (n \) на 1 векторы. Чтобы повысить точность, используйте частичный поворот и масштабирование. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>gaussianElimination</code> должно быть функцией.
+    testString: 'assert(typeof gaussianElimination=="function","<code>gaussianElimination</code> should be a function.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+JSON.stringify(tests[0][1])+&quot;)</code> должны возвращать массив.'
+    testString: 'assert(Array.isArray(gaussianElimination(tests[0][0],tests[0][1])),"<code>gaussianElimination("+JSON.stringify(tests[0][0])+","+JSON.stringify(tests[0][1])+")</code> should return an array.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+JSON.stringify(tests[0][1])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[0])+&quot;</code> .'
+    testString: 'assert.deepEqual(gaussianElimination(tests[0][0],tests[0][1]),results[0],"<code>gaussianElimination("+JSON.stringify(tests[0][0])+","+JSON.stringify(tests[0][1])+")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[1][0])+&quot;,&quot;+JSON.stringify(tests[1][1])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[1])+&quot;</code> .'
+    testString: 'assert.deepEqual(gaussianElimination(tests[1][0],tests[1][1]),results[1],"<code>gaussianElimination("+JSON.stringify(tests[1][0])+","+JSON.stringify(tests[1][1])+")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[2][0])+&quot;,&quot;+JSON.stringify(tests[2][1])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[2])+&quot;</code> .'
+    testString: 'assert.deepEqual(gaussianElimination(tests[2][0],tests[2][1]),results[2],"<code>gaussianElimination("+JSON.stringify(tests[2][0])+","+JSON.stringify(tests[2][1])+")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[3][0])+&quot;,&quot;+JSON.stringify(tests[3][1])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[3])+&quot;</code> .'
+    testString: 'assert.deepEqual(gaussianElimination(tests[3][0],tests[3][1]),results[3],"<code>gaussianElimination("+JSON.stringify(tests[3][0])+","+JSON.stringify(tests[3][1])+")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
+  - text: '<code>gaussianElimination(&quot;+JSON.stringify(tests[4][0])+&quot;,&quot;+JSON.stringify(tests[4][1])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[4])+&quot;</code> .'
+    testString: 'assert.deepEqual(gaussianElimination(tests[4][0],tests[4][1]),results[4],"<code>gaussianElimination("+JSON.stringify(tests[4][0])+","+JSON.stringify(tests[4][1])+")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function gaussianElimination (A,b) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/general-fizzbuzz.russian.md

@@ -0,0 +1,76 @@
+---
+title: General FizzBuzz
+id: 5a23c84252665b21eecc7e78
+challengeType: 5
+videoUrl: ''
+localeTitle: Общие вопросы FizzBuzz
+---
+
+## Description
+<section id="description"> Напишите обобщенную версию <a href="http://rosettacode.org/wiki/FizzBuzz">FizzBuzz,</a> которая работает для любого списка факторов вместе со своими словами. Это в основном реализация «fizzbuzz», где правила игры предоставляются пользователю. Создайте функцию для ее реализации. Функция должна принимать два параметра. Первым будет массив с правилами FizzBuzz. Например: <code>[ [3,&quot;Fizz&quot;] , [5,&quot;Buzz&quot;] ]</code> . Это указывает на то, что <code>Fizz</code> следует печатать, если число кратно 3 и <code>Buzz</code> если оно кратно 5. Если оно кратно, то строки должны быть объединены в порядке, указанном в массиве. В этом случае <code>FizzBuzz</code> если число кратно 3 и 5. Второй параметр - это номер, для которого функция должна возвращать строку, как указано выше. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>genFizzBuzz</code> должен быть функцией.
+    testString: 'assert(typeof genFizzBuzz=="function","<code>genFizzBuzz</code> should be a function.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+tests[0][1]+&quot;)</code> должны возвращать тип.'
+    testString: 'assert(typeof genFizzBuzz(tests[0][0],tests[0][1])=="string","<code>genFizzBuzz("+JSON.stringify(tests[0][0])+","+tests[0][1]+")</code> should return a type.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+tests[0][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[0]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[0][0],tests[0][1]),results[0],"<code>genFizzBuzz("+JSON.stringify(tests[0][0])+","+tests[0][1]+")</code> should return <code>""+results[0]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[1][0])+&quot;,&quot;+tests[1][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[1]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[1][0],tests[1][1]),results[1],"<code>genFizzBuzz("+JSON.stringify(tests[1][0])+","+tests[1][1]+")</code> should return <code>""+results[1]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[2][0])+&quot;,&quot;+tests[2][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[2]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[2][0],tests[2][1]),results[2],"<code>genFizzBuzz("+JSON.stringify(tests[2][0])+","+tests[2][1]+")</code> should return <code>""+results[2]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[3][0])+&quot;,&quot;+tests[3][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[3]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[3][0],tests[3][1]),results[3],"<code>genFizzBuzz("+JSON.stringify(tests[3][0])+","+tests[3][1]+")</code> should return <code>""+results[3]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[4][0])+&quot;,&quot;+tests[4][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[4]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[4][0],tests[4][1]),results[4],"<code>genFizzBuzz("+JSON.stringify(tests[4][0])+","+tests[4][1]+")</code> should return <code>""+results[4]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[5][0])+&quot;,&quot;+tests[5][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[5]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[5][0],tests[5][1]),results[5],"<code>genFizzBuzz("+JSON.stringify(tests[5][0])+","+tests[5][1]+")</code> should return <code>""+results[5]+""</code>.");'
+  - text: '<code>genFizzBuzz(&quot;+JSON.stringify(tests[6][0])+&quot;,&quot;+tests[6][1]+&quot;)</code> должны возвращать <code>&quot;&quot;+results[6]+&quot;&quot;</code> .'
+    testString: 'assert.equal(genFizzBuzz(tests[6][0],tests[6][1]),results[6],"<code>genFizzBuzz("+JSON.stringify(tests[6][0])+","+tests[6][1]+")</code> should return <code>""+results[6]+""</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function genFizzBuzz (rules, num) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.russian.md

@@ -0,0 +1,72 @@
+---
+title: Generate lower case ASCII alphabet
+id: 5a23c84252665b21eecc7e7a
+challengeType: 5
+videoUrl: ''
+localeTitle: Создание алфавита ASCII в нижнем регистре
+---
+
+## Description
+<section id="description"> Напишите функцию для генерации массива символов ASCII нижнего регистра для заданного диапазона. Например: для диапазона от 1 до 4 функция должна возвращать <code>[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code> . </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>lascii</code> должен быть функцией.
+    testString: 'assert(typeof lascii=="function","<code>lascii</code> should be a function.");'
+  - text: '<code>lascii(&quot;a&quot;,&quot;d&quot;)</code> должен возвращать массив.'
+    testString: 'assert(Array.isArray(lascii("a","d")),"<code>lascii("a","d")</code> should return an array.");'
+  - text: '« <code>lascii(&quot;a&quot;,&quot;d&quot;)</code> должен возвращать <code>[ &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; ]</code> ».'
+    testString: 'assert.deepEqual(lascii("a","d"),results[0],"<code>lascii("a","d")</code> should return <code>[ "a", "b", "c", "d" ]</code>.");'
+  - text: '« <code>lascii(&quot;c&quot;,&quot;i&quot;)</code> должен возвращать <code>[ &quot;c&quot;, &quot;d&quot;, &quot;e&quot;, &quot;f&quot;, &quot;g&quot;, &quot;h&quot;, &quot;i&quot; ]</code> ».'
+    testString: 'assert.deepEqual(lascii("c","i"),results[1],"<code>lascii("c","i")</code> should return <code>[ "c", "d", "e", "f", "g", "h", "i" ]</code>.");'
+  - text: '« <code>lascii(&quot;m&quot;,&quot;q&quot;)</code> должен возвращать <code>[ &quot;m&quot;, &quot;n&quot;, &quot;o&quot;, &quot;p&quot;, &quot;q&quot; ]</code> ».'
+    testString: 'assert.deepEqual(lascii("m","q"),results[2],"<code>lascii("m","q")</code> should return <code>[ "m", "n", "o", "p", "q" ]</code>.");'
+  - text: '« <code>lascii(&quot;k&quot;,&quot;n&quot;)</code> должен возвращать <code>[ &quot;k&quot;, &quot;l&quot;, &quot;m&quot;, &quot;n&quot; ]</code> .»)'
+    testString: 'assert.deepEqual(lascii("k","n"),results[3],"<code>lascii("k","n")</code> should return <code>[ "k", "l", "m", "n" ]</code>.");'
+  - text: '« <code>lascii(&quot;t&quot;,&quot;z&quot;)</code> должен возвращать <code>[ &quot;t&quot;, &quot;u&quot;, &quot;v&quot;, &quot;w&quot;, &quot;x&quot;, &quot;y&quot;, &quot;z&quot; ]</code> .&quot;'
+    testString: 'assert.deepEqual(lascii("t","z"),results[4],"<code>lascii("t","z")</code> should return <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function lascii (cFrom, cTo) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/generatorexponential.russian.md

@@ -0,0 +1,64 @@
+---
+title: GeneratorExponential
+id: 5a23c84252665b21eecc7e7b
+challengeType: 5
+videoUrl: ''
+localeTitle: GeneratorExponential
+---
+
+## Description
+<section id="description"> Генератор - это исполняемый объект (например, функция или процедура), который содержит код, который дает последовательность значений по одному, так что каждый раз, когда вы вызываете генератор, предоставляется следующее значение в последовательности. Генераторы часто строятся поверх сопрограмм или объектов, так что внутреннее состояние объекта обрабатывается «естественно». Генераторы часто используются в ситуациях, когда последовательность потенциально бесконечна и где можно построить следующее значение последовательности с минимальным состоянием. Напишите функцию, которая использует генераторы для генерации квадратов и кубов. Создайте новый генератор, который фильтрует все кубы из генератора квадратов. Функция должна возвращать значение \ (n ^ {th} \) отфильтрованного генератора. Например, для \ (n = 7 \) функция должна возвращать 81, так как последовательность будет 4,9,16,25,36,49,81. Здесь 64 отфильтровывается, так как это куб. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>exponentialGenerator</code> должен быть функцией.
+    testString: 'assert(typeof exponentialGenerator=="function","<code>exponentialGenerator</code> should be a function.");'
+  - text: <code>exponentialGenerator()</code> должен возвращать число.
+    testString: 'assert(typeof exponentialGenerator(10)=="number","<code>exponentialGenerator()</code> should return a number.");'
+  - text: <code>exponentialGenerator(10)</code> должен вернуть <code>144</code> .
+    testString: 'assert.equal(exponentialGenerator(10),144,"<code>exponentialGenerator(10)</code> should return <code>144</code>.");'
+  - text: <code>exponentialGenerator(12)</code> должен возвращать <code>196</code> .
+    testString: 'assert.equal(exponentialGenerator(12),196,"<code>exponentialGenerator(12)</code> should return <code>196</code>.");'
+  - text: <code>exponentialGenerator(14)</code> должен возвращать <code>256</code> .
+    testString: 'assert.equal(exponentialGenerator(14),256,"<code>exponentialGenerator(14)</code> should return <code>256</code>.");'
+  - text: <code>exponentialGenerator(20)</code> должен возвращать <code>484</code> .
+    testString: 'assert.equal(exponentialGenerator(20),484,"<code>exponentialGenerator(20)</code> should return <code>484</code>.");'
+  - text: <code>exponentialGenerator(25)</code> должен возвращать <code>784</code> .
+    testString: 'assert.equal(exponentialGenerator(25),784,"<code>exponentialGenerator(25)</code> should return <code>784</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function exponentialGenerator (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/gray-code.russian.md

@@ -0,0 +1,66 @@
+---
+title: Gray code
+id: 5a23c84252665b21eecc7e80
+challengeType: 5
+videoUrl: ''
+localeTitle: Серый код
+---
+
+## Description
+<section id="description"> <a href="https://en.wikipedia.org/wiki/Gray code">Серый код</a> - это форма двоичного кодирования, где переходы между последовательными числами отличаются только одним битом. Это полезное кодирование для снижения опасности аппаратных данных со значениями, которые быстро изменяются и / или подключаются к более медленному оборудованию в качестве входных данных. Он также полезен для генерации входных данных для <a href="https://en.wikipedia.org/wiki/Karnaugh map">карт Карно</a> в порядке слева направо или сверху вниз. Создайте функцию для кодирования числа и декодирования числа из кода Grey. Функция должна иметь 2 параметра. Первый будет логическим. Функция должна кодироваться для истины и декодирования для false. Второй параметр будет номером, который должен быть закодирован / декодирован. Отображение нормальных двоичных представлений, представлений серого кода и декодированных значений кода Grey для всех 5-битных двоичных чисел (0-31 включительно, что приводит к 0 не нужно). Существует много возможных кодов Грея. Следующее кодирует так называемый «двоичный отраженный серый код». <br> Кодирование (MSB - бит 0, b - двоичный, g - код Grey): <code><br> if b[i-1] = 1 <br> <span style="padding-left:1em">g[i] = not b[i]</span> <br> else <br> <span style="padding-left:1em">g[i] = b[i]</span> <br></code> Или: <br> <code>g = b xor (b logically right shifted 1 time)</code> <br> Декодирование (MSB - бит 0, b - двоичный, g - код Grey): <br> <code>b[0] = g[0] <br> for other bits: <br> b[i] = g[i] xor b[i-1] <br></code> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>gray</code> должен быть функцией.
+    testString: 'assert(typeof gray=="function","<code>gray</code> should be a function.");'
+  - text: '<code>gray(true,177)</code> должен возвращать число.'
+    testString: 'assert(typeof gray(true,177)=="number","<code>gray(true,177)</code> should return a number.");'
+  - text: '<code>gray(true,177)</code> должен возвращать <code>233</code> .'
+    testString: 'assert.equal(gray(true,177),233,"<code>gray(true,177)</code> should return <code>233</code>.");'
+  - text: '<code>gray(true,425)</code> должен возвращать <code>381</code> .'
+    testString: 'assert.equal(gray(true,425),381,"<code>gray(true,425)</code> should return <code>381</code>.");'
+  - text: '<code>gray(true,870)</code> должен возвращать <code>725</code> .'
+    testString: 'assert.equal(gray(true,870),725,"<code>gray(true,870)</code> should return <code>725</code>.");'
+  - text: '<code>gray(false,233)</code> должен вернуть <code>177</code> .'
+    testString: 'assert.equal(gray(false,233),177,"<code>gray(false,233)</code> should return <code>177</code>.");'
+  - text: '<code>gray(false,381)</code> должен возвращать <code>425</code> .'
+    testString: 'assert.equal(gray(false,381),425,"<code>gray(false,381)</code> should return <code>425</code>.");'
+  - text: '<code>gray(false,725)</code> должен возвращать <code>870</code> .'
+    testString: 'assert.equal(gray(false,725),870,"<code>gray(false,725)</code> should return <code>870</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function gray(enc, number) {
+ // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/greatest-common-divisor.russian.md

@@ -0,0 +1,66 @@
+---
+title: Greatest common divisor
+id: 5a23c84252665b21eecc7e82
+challengeType: 5
+videoUrl: ''
+localeTitle: Наибольший общий делитель
+---
+
+## Description
+<section id="description"> Напишите функцию, которая возвращает наибольший общий делитель двух целых чисел. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>gcd</code> должна быть функцией.
+    testString: 'assert(typeof gcd=="function","<code>gcd</code> should be a function.");'
+  - text: '<code>gcd(24,36)</code> должен вернуть число.'
+    testString: 'assert(typeof gcd(24,36)=="number","<code>gcd(24,36)</code> should return a number.");'
+  - text: '<code>gcd(24,36)</code> должен вернуть <code>12</code> .'
+    testString: 'assert.equal(gcd(24,36),12,"<code>gcd(24,36)</code> should return <code>12</code>.");'
+  - text: '<code>gcd(30,48)</code> должен вернуть <code>6</code> .'
+    testString: 'assert.equal(gcd(30,48),6,"<code>gcd(30,48)</code> should return <code>6</code>.");'
+  - text: '<code>gcd(10,15)</code> должен вернуть <code>5</code> .'
+    testString: 'assert.equal(gcd(10,15),5,"<code>gcd(10,15)</code> should return <code>5</code>.");'
+  - text: '<code>gcd(100,25)</code> должен вернуть <code>25</code> .'
+    testString: 'assert.equal(gcd(100,25),25,"<code>gcd(100,25)</code> should return <code>25</code>.");'
+  - text: '<code>gcd(13,250)</code> должен вернуть <code>1</code> .'
+    testString: 'assert.equal(gcd(13,250),1,"<code>gcd(13,250)</code> should return <code>1</code>.");'
+  - text: '<code>gcd(1300,250)</code> должен вернуть <code>50</code> .'
+    testString: 'assert.equal(gcd(1300,250),50,"<code>gcd(1300,250)</code> should return <code>50</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function gcd(a, b) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/greatest-subsequential-sum.russian.md

@@ -0,0 +1,74 @@
+---
+title: Greatest subsequential sum
+id: 5a23c84252665b21eecc7e84
+challengeType: 5
+videoUrl: ''
+localeTitle: Наибольшая подпоследовательная сумма
+---
+
+## Description
+<section id="description"> Если задана последовательность целых чисел, найдите непрерывную подпоследовательность, которая максимизирует сумму ее элементов, т. Е. Элементы ни одной отдельной подпоследовательности не прибавляют к значению, большему, чем это. Считается, что пустая подпоследовательность имеет сумму \ (0 \); таким образом, если все элементы отрицательны, результат должен быть пустой. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>maximumSubsequence</code> должна быть функцией.
+    testString: 'assert(typeof maximumSubsequence=="function","<code>maximumSubsequence</code> should be a function.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[0])+&quot;)</code> должен возвращать массив.'
+    testString: 'assert(Array.isArray(maximumSubsequence(tests[0])),"<code>maximumSubsequence("+JSON.stringify(tests[0])+")</code> should return an array.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[0])+&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[0])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[0]),results[0],"<code>maximumSubsequence("+JSON.stringify(tests[0])+")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[1])+&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[1])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[1]),results[1],"<code>maximumSubsequence("+JSON.stringify(tests[1])+")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[2])+&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[2])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[2]),results[2],"<code>maximumSubsequence("+JSON.stringify(tests[2])+")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[3])+&quot;)</code> должны возвращать <code>&quot;+JSON.stringify(results[3])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[3]),results[3],"<code>maximumSubsequence("+JSON.stringify(tests[3])+")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[4])+&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[4])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[4]),results[4],"<code>maximumSubsequence("+JSON.stringify(tests[4])+")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
+  - text: '<code>maximumSubsequence(&quot;+JSON.stringify(tests[5])+&quot;)</code> должен возвращать <code>&quot;+JSON.stringify(results[5])+&quot;</code> .'
+    testString: 'assert.deepEqual(maximumSubsequence(tests[5]),results[5],"<code>maximumSubsequence("+JSON.stringify(tests[5])+")</code> should return <code>"+JSON.stringify(results[5])+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function maximumSubsequence (population) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/hailstone-sequence.russian.md

@@ -0,0 +1,66 @@
+---
+title: Hailstone sequence
+id: 595608ff8bcd7a50bd490181
+challengeType: 5
+videoUrl: ''
+localeTitle: Последовательность градиента
+---
+
+## Description
+<section id="description"><p> Последовательность чисел Hailstone может быть сгенерирована из начального положительного целого числа, n: </p> Если n равно 1, последовательность заканчивается. Если n четно, то следующее n последовательности <code>= n/2</code> Если n нечетно, то следующее n последовательности <code>= (3 * n) + 1</code> <p> (Неподтвержденная) <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: гипотеза Collatz">гипотеза Collatz</a> заключается в том, что последовательность градиентов для любого начального числа всегда заканчивается. </p><p> Последовательность градиента также известна как номера градиента (поскольку значения обычно подвержены нескольким спуску и восхождениям, таким как град в облаке) или как последовательность Collatz. </p> Задача: создать процедуру для генерации последовательности градиента для числа. Используйте процедуру, чтобы показать, что последовательность градиента для числа 27 содержит 112 элементов, начиная с <code>27, 82, 41, 124</code> и заканчивая <code>8, 4, 2, 1</code> Покажите число менее 100 000, которое имеет самую длинную последовательность градиента вместе с этим длина последовательности. (Но не показывайте действительную последовательность!) См. Также: <a href="http://xkcd.com/710" title="ссылка: http://xkcd.com/710">xkcd</a> (humourous). </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>hailstoneSequence</code> - это функция.
+    testString: 'assert(typeof hailstoneSequence === "function", "<code>hailstoneSequence</code> is a function.");'
+  - text: '<code>hailstoneSequence()</code> должен возвращать <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code>'
+    testString: 'assert.deepEqual(hailstoneSequence(), res, "<code>hailstoneSequence()</code> should return <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+// noprotect
+function hailstoneSequence () {
+  const res = [];
+  // Good luck!
+
+  return res;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/happy-numbers.russian.md

@@ -0,0 +1,76 @@
+---
+title: Happy numbers
+id: 594810f028c0303b75339ad1
+challengeType: 5
+videoUrl: ''
+localeTitle: Счастливые номера
+---
+
+## Description
+<section id="description"><p> Счастливое число определяется следующим процессом: </p><p> Начиная с любого положительного целого числа, замените число на сумму квадратов его цифр и повторите процесс до тех пор, пока число не будет равно 1 (где оно останется), или оно бесконечно завершается в цикле, который не включает в себя 1. Эти цифры для которых этот процесс заканчивается на 1, являются счастливыми номерами, а те, которые не заканчиваются на 1, - это несчастливые цифры. </p><p> Реализуйте функцию, которая возвращает true, если число счастливое, или false, если нет. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>happy</code> функция.
+    testString: 'assert(typeof happy === "function", "<code>happy</code> is a function.");'
+  - text: <code>happy(1)</code> должен возвращать логическое значение.
+    testString: 'assert(typeof happy(1) === "boolean", "<code>happy(1)</code> should return a boolean.");'
+  - text: <code>happy(1)</code> должен возвращать истину.
+    testString: 'assert(happy(1), "<code>happy(1)</code> should return true.");'
+  - text: <code>happy(2)</code> должен возвращать false.
+    testString: 'assert(!happy(2), "<code>happy(2)</code> should return false.");'
+  - text: <code>happy(7)</code> должен вернуться к истине.
+    testString: 'assert(happy(7), "<code>happy(7)</code> should return true.");'
+  - text: <code>happy(10)</code> должен вернуться к истине.
+    testString: 'assert(happy(10), "<code>happy(10)</code> should return true.");'
+  - text: <code>happy(13)</code> должен вернуться к истине.
+    testString: 'assert(happy(13), "<code>happy(13)</code> should return true.");'
+  - text: <code>happy(19)</code> должен вернуться к истине.
+    testString: 'assert(happy(19), "<code>happy(19)</code> should return true.");'
+  - text: <code>happy(23)</code> должен вернуться к истине.
+    testString: 'assert(happy(23), "<code>happy(23)</code> should return true.");'
+  - text: <code>happy(28)</code> должен вернуться к истине.
+    testString: 'assert(happy(28), "<code>happy(28)</code> should return true.");'
+  - text: <code>happy(31)</code> должен вернуться к истине.
+    testString: 'assert(happy(31), "<code>happy(31)</code> should return true.");'
+  - text: '<code>happy(32)</code> должен возвращать true :.'
+    testString: 'assert(happy(32), "<code>happy(32)</code> should return true:.");'
+  - text: <code>happy(33)</code> должен вернуть ложь.
+    testString: 'assert(!happy(33), "<code>happy(33)</code> should return false.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function happy (number) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.russian.md

@@ -0,0 +1,68 @@
+---
+title: Harshad or Niven series
+id: 595668ca4cfe1af2fb9818d4
+challengeType: 5
+videoUrl: ''
+localeTitle: Серия Harshad или Niven
+---
+
+## Description
+<section id="description"><p> Номера <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="ссылка: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> или Niven представляют собой целые положительные числа ≥ 1, которые делятся на сумму их цифр. </p><p> Например, 42 является <a href="http://rosettacode.org/wiki/oeis:A005349" title="OEIS: A005349">числом Харшада,</a> поскольку 42 делится на (4 + 2) без остатка. </p> Предположим, что ряд определяется как числа в порядке возрастания. Задача: <p> Реализуйте функцию для генерации последовательных членов последовательности Harshad. </p><p> Используйте его, чтобы перечислить первые двадцать членов последовательности и перечислите первое число Harshad, превышающее 1000. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>isHarshadOrNiven</code> - это функция.
+    testString: 'assert(typeof isHarshadOrNiven === "function", "<code>isHarshadOrNiven</code> is a function.");'
+  - text: '<code>isHarshadOrNiven()</code> должен возвращать <code>{&quot;firstTwenty&quot;: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42],&quot;firstOver1000&quot;: 1002}</code>'
+    testString: 'assert.deepEqual(isHarshadOrNiven(), res, "<code>isHarshadOrNiven()</code> should return <code>{"firstTwenty": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42],"firstOver1000": 1002}</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function isHarshadOrNiven () {
+  const res = {
+    firstTwenty: [],
+    firstOver1000: undefined
+  };
+  // Change after this line
+
+  return res;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.russian.md

@@ -0,0 +1,73 @@
+---
+title: Hash from two arrays
+id: 595671d4d2cdc305f0d5b36f
+challengeType: 5
+videoUrl: ''
+localeTitle: Хэш из двух массивов
+---
+
+## Description
+<section id="description"> Задача: <p> Используя два массива равной длины, создайте объект Hash, в котором элементы из одного массива (ключи) связаны с элементами другого (значения) </p> Связанная задача: <a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Ассоциативные массивы / Создание">Ассоциативные массивы / Создание</a> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>arrToObj</code> - функция.
+    testString: 'assert(typeof arrToObj === "function", "<code>arrToObj</code> is a function.");'
+  - text: '<code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> должны возвращать <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: &quot;e&quot; }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[0]), res[0], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }</code>");'
+  - text: '<code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;])</code> должны возвращать <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: undefined }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[1]), res[1], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }</code>");'
+  - text: '<code>arrToObj([1, 2, 3], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> должны возвращать <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot; }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[2]), res[2], "<code>arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])</code> should return <code>{ 1: "a", 2: "b", 3: "c" }</code>");'
+  - text: '<code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4, 5])</code> должны возвращать <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: 5 }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[3]), res[3], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }</code>");'
+  - text: '<code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4])</code> должны возвращать <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: undefined }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[4]), res[4], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }</code>");'
+  - text: '<code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], [1, 2, 3, 4, 5])</code> должны возвращать <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 }</code>'
+    testString: 'assert.deepEqual(arrToObj(...testCases[5]), res[5], "<code>arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3  }</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function arrToObj (keys, vals) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/hash-join.russian.md

@@ -0,0 +1,75 @@
+---
+title: Hash join
+id: 5956795bc9e2c415eb244de1
+challengeType: 5
+videoUrl: ''
+localeTitle: Присоединиться
+---
+
+## Description
+<section id="description"><p> <a href="https://en.wikipedia.org/wiki/Join_(SQL)#Inner_join" title="wp: Join_ (SQL) #Inner_join">Внутреннее соединение</a> - это операция, которая объединяет две таблицы данных в одну таблицу на основе совпадающих значений столбцов. Простейшим способом реализации этой операции является алгоритм <a href="https://en.wikipedia.org/wiki/Nested loop join" title="wp: Соединение вложенного цикла">объединения вложенных циклов</a> , но более масштабируемой альтернативой является алгоритм <a href="https://en.wikipedia.org/wiki/hash join" title="wp: hash join">хеш-соединения</a> . </p><p> Внедрите алгоритм «хеш-соединения» и продемонстрируйте, что он проходит тестовый сценарий, указанный ниже. </p><p> Вы должны представлять таблицы как структуры данных, которые кажутся естественными на вашем языке программирования. </p><p> Алгоритм «хеш-соединения» состоит из двух шагов: </p> Хэш-фаза. Создайте <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">мультимап</a> из одной из двух таблиц, сопоставляя их со всеми значениями столбца объединения со всеми строками, которые его содержат. Мультимап должен поддерживать хэш-ориентированный поиск, который масштабируется лучше, чем простой линейный поиск, потому что в этом весь смысл этого алгоритма. В идеале мы должны создать мультимап для меньшей таблицы, таким образом минимизируя время его создания и размер памяти. Фаза присоединения. Сканируйте другую таблицу и найдите соответствующие строки, просмотрев созданный ранее мультимап. <p> В псевдокоде алгоритм может быть выражен следующим образом: </p><pre> пусть A = первая входная таблица (или, в идеале, большая)
+пусть B = вторая входная таблица (или, в идеале, меньшая)
+пусть j <sub>A</sub> = идентификатор столбца соединения таблицы A
+пусть j <sub>B</sub> = идентификатор столбца соединения таблицы B
+пусть M <sub>B</sub> = мультимап для отображения из отдельных значений в несколько строк таблицы B (начинается пустым)
+пусть C = выходная таблица (начинается пустая)
+для каждой строки b в таблице B:
+  место b в multimap M <sub>B</sub> под клавишей b (j <sub>B</sub> )
+для каждой строки a в таблице A:
+  для каждой строки b в мультимадре M <sub>B</sub> под ключом a (j <sub>A</sub> ):
+    пусть c = конкатенация строки a и строки b
+    поместите строку c в таблицу C <p></p>
+</pre> Прецедент <p> вход </p><table><tbody><tr><td style="padding: 4px; margin: 5px;"><table style="border:none; border-collapse:collapse;"><tbody><tr><td style="border:none"> <i>A =</i> </td><td style="border:none"><table><tbody><tr><th style="padding: 4px; margin: 5px;"> Возраст </th><th style="padding: 4px; margin: 5px;"> имя </th></tr><tr><td style="padding: 4px; margin: 5px;"> 27 </td><td style="padding: 4px; margin: 5px;"> Иона </td></tr><tr><td style="padding: 4px; margin: 5px;"> 18 </td><td style="padding: 4px; margin: 5px;"> Алан </td></tr><tr><td style="padding: 4px; margin: 5px;"> 28 </td><td style="padding: 4px; margin: 5px;"> слава </td></tr><tr><td style="padding: 4px; margin: 5px;"> 18 </td><td style="padding: 4px; margin: 5px;"> Popeye </td></tr><tr><td style="padding: 4px; margin: 5px;"> 28 </td><td style="padding: 4px; margin: 5px;"> Алан </td></tr></tbody></table></td><td style="border:none; padding-left:1.5em;" rowspan="2"></td><td style="border:none"> <i>B =</i> </td><td style="border:none"><table><tbody><tr><th style="padding: 4px; margin: 5px;"> символ </th><th style="padding: 4px; margin: 5px;"> Немезида </th></tr><tr><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Киты </td></tr><tr><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Пауки </td></tr><tr><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> привидения </td></tr><tr><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Zombies </td></tr><tr><td style="padding: 4px; margin: 5px;"> слава </td><td style="padding: 4px; margin: 5px;"> Buffy </td></tr></tbody></table></td></tr><tr><td style="border:none"> <i>j <sub>A</sub> =</i> </td><td style="border:none"> <i><code>Name</code> (т.е. столбец 1)</i> </td><td style="border:none"> <i>j <sub>B</sub> =</i> </td><td style="border:none"> <i><code>Character</code> (т.е. столбец 0)</i> </td></tr></tbody></table></td><td style="padding: 4px; margin: 5px;"></td></tr></tbody></table><p> Вывод </p><table><tbody><tr><th style="padding: 4px; margin: 5px;"> A.Age </th><th style="padding: 4px; margin: 5px;"> Имя </th><th style="padding: 4px; margin: 5px;"> B.Character </th><th style="padding: 4px; margin: 5px;"> B.Nemesis </th></tr><tr><td style="padding: 4px; margin: 5px;"> 27 </td><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Киты </td></tr><tr><td style="padding: 4px; margin: 5px;"> 27 </td><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Иона </td><td style="padding: 4px; margin: 5px;"> Пауки </td></tr><tr><td style="padding: 4px; margin: 5px;"> 18 </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> привидения </td></tr><tr><td style="padding: 4px; margin: 5px;"> 18 </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Zombies </td></tr><tr><td style="padding: 4px; margin: 5px;"> 28 </td><td style="padding: 4px; margin: 5px;"> слава </td><td style="padding: 4px; margin: 5px;"> слава </td><td style="padding: 4px; margin: 5px;"> Buffy </td></tr><tr><td style="padding: 4px; margin: 5px;"> 28 </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> привидения </td></tr><tr><td style="padding: 4px; margin: 5px;"> 28 </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Алан </td><td style="padding: 4px; margin: 5px;"> Zombies </td></tr></tbody></table><p></p><p></p><p> Порядок строк в выходной таблице не имеет значения. </p><p> Если вы используете численные индексированные массивы для представления строк таблицы (вместо обращения к столбцам по имени), вы можете представить выходные строки в форме <code style="white-space:nowrap">[[27, &quot;Jonah&quot;], [&quot;Jonah&quot;, &quot;Whales&quot;]]</code> , </p><hr></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>hashJoin</code> - это функция.
+    testString: 'assert(typeof hashJoin === "function", "<code>hashJoin</code> is a function.");'
+  - text: '<code>hashJoin([{ age: 27, name: &quot;Jonah&quot; }, { age: 18, name: &quot;Alan&quot; }, { age: 28, name: &quot;Glory&quot; }, { age: 18, name: &quot;Popeye&quot; }, { age: 28, name: &quot;Alan&quot; }], [{ character: &quot;Jonah&quot;, nemesis: &quot;Whales&quot; }, { character: &quot;Jonah&quot;, nemesis: &quot;Spiders&quot; }, { character: &quot;Alan&quot;, nemesis: &quot;Ghosts&quot; }, { character:&quot;Alan&quot;, nemesis: &quot;Zombies&quot; }, { character: &quot;Glory&quot;, nemesis: &quot;Buffy&quot; }, { character: &quot;Bob&quot;, nemesis: &quot;foo&quot; }])</code> должен возвращать <code>[{&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Whales&quot;}, {&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Spiders&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Glory&quot;, &quot;B_character&quot;: &quot;Glory&quot;, &quot;B_nemesis&quot;: &quot;Buffy&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}]</code>'
+    testString: 'assert.deepEqual(hashJoin(hash1, hash2), res, "<code>hashJoin([{ age: 27, name: "Jonah" }, { age: 18, name: "Alan" }, { age: 28, name: "Glory" }, { age: 18, name: "Popeye" }, { age: 28, name: "Alan" }], [{ character: "Jonah", nemesis: "Whales" }, { character: "Jonah", nemesis: "Spiders" }, { character: "Alan", nemesis: "Ghosts" }, { character:"Alan", nemesis: "Zombies" }, { character: "Glory", nemesis: "Buffy" }, { character: "Bob", nemesis: "foo" }])</code> should return <code>[{"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Whales"}, {"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Spiders"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}, {"A_age": 28,"A_name": "Glory", "B_character": "Glory", "B_nemesis": "Buffy"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function hashJoin (hash1, hash2) {
+  // Good luck!
+  return [];
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/heronian-triangles.russian.md

@@ -0,0 +1,71 @@
+---
+title: Heronian triangles
+id: 595b98f8b5a2245e243aa831
+challengeType: 5
+videoUrl: ''
+localeTitle: Херонические треугольники
+---
+
+## Description
+<section id="description"><p> <a href="https://en.wikipedia.org/wiki/Heron&#x27;s formula" title="wp: формула Герона">Формула Героя</a> для области треугольника с учетом длины трех ее сторон <big>a,</big> <big>b</big> и <big>c</big> определяется следующим образом: </p><p> <big>$$ A = \ sqrt {s (sa) (sb) (sc)}, $$</big> </p><p> где <big>s</big> - половина периметра треугольника; то есть, </p><p> <big>$$ з = \ гидроразрыва {а + B + C} {2} $$.</big> </p><p> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="ссылка: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Херонические треугольники</a> - это треугольники, стороны и области которых являются целыми числами. </p><p> Примером может служить треугольник со сторонами 3, 4, 5, площадь которых равна 6 (а по периметру - 12). </p><p> Заметим, что любой треугольник, чьи стороны все целые кратные 3, 4, 5; такие как 6, 8, 10, также будут иероническим треугольником. </p><p> Определите примитивный херонийский треугольник как хернийский треугольник, где наибольший общий делитель </p><p> всех трех сторон 1 (единство). </p><p> Это исключает, например, треугольник 6, 8, 10. </p> Задача: <p> Реализуйте функцию, основанную на формуле Героя, которая возвращает первые <code>n <sub>th</sub></code> упорядоченные треугольники в массиве массивов. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>heronianTriangle</code> - это функция.
+    testString: 'assert(typeof heronianTriangle === "function", "<code>heronianTriangle</code> is a function.");'
+  - text: '<code>heronianTriangle()</code> должен возвращать <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code>'
+    testString: 'assert.deepEqual(heronianTriangle(testCases[0]), res[0], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code>");'
+  - text: '<code>heronianTriangle()</code> должен возвращать <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>'
+    testString: 'assert.deepEqual(heronianTriangle(testCases[1]), res[1], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>");'
+  - text: '<code>heronianTriangle()</code> должен возвращать <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code>'
+    testString: 'assert.deepEqual(heronianTriangle(testCases[2]), res[2], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code>");'
+  - text: '<code>heronianTriangle()</code> должен возвращать <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code>'
+    testString: 'assert.deepEqual(heronianTriangle(testCases[3]), res[3], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+// noprotect
+function heronianTriangle (n) {
+  // Good luck!
+
+  return [];
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.russian.md

@@ -0,0 +1,87 @@
+---
+title: Hofstadter Figure-Figure sequences
+id: 59622f89e4e137560018a40e
+challengeType: 5
+videoUrl: ''
+localeTitle: Последовательности Рисунка Hofstadter
+---
+
+## Description
+<section id="description"><p> Эти две последовательности положительных целых чисел определяются как: </p><p> <big>$$ R (1) = 1 \; \ S (1) = 2 \\ R (n) = R (n-1) + S (n-1), \ quad n&gt; 1. $$</big> </p><p> Последовательность <big>$ S (n) $</big> дополнительно определяется как последовательность положительных целых чисел, не присутствующих в <big>$ R (n) $</big> . </p><p> Последовательность <big>$ R $</big> начинается: </p><p> 1, 3, 7, 12, 18, ... </p><p> Последовательность <big>$ S $</big> начинается: </p><p> 2, 4, 5, 6, 8, ... </p> Задача: создать две функции с именем ffr и ffs, которые при задании n возвращают R (n) или S (n) соответственно. (Обратите внимание, что R (1) = 1 и S (1) = 2, чтобы избежать ошибок, , Максимальное значение n не должно приниматься. Sloane <a href="http://oeis.org/A005228" title="ссылка: http://oeis.org/A005228">A005228</a> и <a href="http://oeis.org/A030124" title="ссылка: http://oeis.org/A030124">A030124</a> . <a href="http://mathworld.wolfram.com/HofstadterFigure-FigureSequence.html" title="ссылка: http://mathworld.wolfram.com/HofstadterFigure-FigureSequence.html">Wolfram MathWorld</a> Wikipedia: <a href="https://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Figure-Figure_sequences" title="wp: Hofstadter_sequence # Hofstadter_Figure-Figure_sequences">последовательности Hofstadter Figure-Figure</a> . </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>ffr</code> - функция.
+    testString: 'assert(typeof ffr === "function", "<code>ffr</code> is a function.");'
+  - text: <code>ffs</code> - функция.
+    testString: 'assert(typeof ffs === "function", "<code>ffs</code> is a function.");'
+  - text: <code>ffr</code> должно возвращать целое число.
+    testString: 'assert(Number.isInteger(ffr(1)), "<code>ffr</code> should return integer.");'
+  - text: <code>ffs</code> должно возвращать целое число.
+    testString: 'assert(Number.isInteger(ffs(1)), "<code>ffs</code> should return integer.");'
+  - text: <code>ffr()</code> должен возвращать <code>69</code>
+    testString: 'assert.equal(ffr(ffrParamRes[0][0]), ffrParamRes[0][1], "<code>ffr()</code> should return <code>69</code>");'
+  - text: <code>ffr()</code> должен вернуть <code>1509</code>
+    testString: 'assert.equal(ffr(ffrParamRes[1][0]), ffrParamRes[1][1], "<code>ffr()</code> should return <code>1509</code>");'
+  - text: <code>ffr()</code> должен возвращать <code>5764</code>
+    testString: 'assert.equal(ffr(ffrParamRes[2][0]), ffrParamRes[2][1], "<code>ffr()</code> should return <code>5764</code>");'
+  - text: <code>ffr()</code> должен вернуть <code>526334</code>
+    testString: 'assert.equal(ffr(ffrParamRes[3][0]), ffrParamRes[3][1], "<code>ffr()</code> should return <code>526334</code>");'
+  - text: <code>ffs()</code> должен возвращать <code>14</code>
+    testString: 'assert.equal(ffs(ffsParamRes[0][0]), ffsParamRes[0][1], "<code>ffs()</code> should return <code>14</code>");'
+  - text: <code>ffs()</code> должен вернуть <code>59</code>
+    testString: 'assert.equal(ffs(ffsParamRes[1][0]), ffsParamRes[1][1], "<code>ffs()</code> should return <code>59</code>");'
+  - text: <code>ffs()</code> должен возвращать <code>112</code>
+    testString: 'assert.equal(ffs(ffsParamRes[2][0]), ffsParamRes[2][1], "<code>ffs()</code> should return <code>112</code>");'
+  - text: <code>ffs()</code> должен возвращать <code>1041</code>
+    testString: 'assert.equal(ffs(ffsParamRes[3][0]), ffsParamRes[3][1], "<code>ffs()</code> should return <code>1041</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+// noprotect
+function ffr(n) {
+  return n;
+}
+
+function ffs(n) {
+  return n;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/hofstadter-q-sequence.russian.md

@@ -0,0 +1,71 @@
+---
+title: Hofstadter Q sequence
+id: 59637c4d89f6786115efd814
+challengeType: 5
+videoUrl: ''
+localeTitle: Последовательность Хофстадтера Q
+---
+
+## Description
+<section id="description"><p> Последовательность <a href="https://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Q_sequence" title="wp: Hofstadter_sequence # Hofstadter_Q_sequence">Hofstadter Q</a> определяется как: </p><p> $ Q (1) = Q (2) = 1, \\ Q (n) = Q \ big (nQ (n-1) \ big) + Q \ big (nQ (n-2)), \ quad n&gt; 2. $ </p><p> Он определен как <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Последовательность Фибоначчи">последовательность Фибоначчи</a> , но в то время как следующий член в последовательности Фибоначчи представляет собой сумму двух предыдущих членов, в последовательности Q предыдущие два члена говорят вам, как далеко вернуться в последовательность Q, чтобы найти два числа суммировать, чтобы сделать следующий член последовательности. </p> Задача: Внедрить уравнение Хоффстадтера Q Sequence в JavaScript </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>hofstadterQ</code> является функцией.
+    testString: 'assert(typeof hofstadterQ === "function", "<code>hofstadterQ</code> is a function.");'
+  - text: <code>hofstadterQ()</code> должен возвращать <code>integer</code>
+    testString: 'assert(Number.isInteger(hofstadterQ(1000)), "<code>hofstadterQ()</code> should return <code>integer</code>");'
+  - text: <code>hofstadterQ(1000)</code> должен вернуть <code>502</code>
+    testString: 'assert.equal(hofstadterQ(testCase[0]), res[0], "<code>hofstadterQ(1000)</code> should return <code>502</code>");'
+  - text: <code>hofstadterQ(1500)</code> должен вернуть <code>755</code>
+    testString: 'assert.equal(hofstadterQ(testCase[1]), res[1], "<code>hofstadterQ(1500)</code> should return <code>755</code>");'
+  - text: <code>hofstadterQ(2000)</code> должен вернуть <code>1005</code>
+    testString: 'assert.equal(hofstadterQ(testCase[2]), res[2], "<code>hofstadterQ(2000)</code> should return <code>1005</code>");'
+  - text: <code>hofstadterQ(2500)</code> должен вернуть <code>1261</code>
+    testString: 'assert.equal(hofstadterQ(testCase[3]), res[3], "<code>hofstadterQ(2500)</code> should return <code>1261</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function hofstadterQ (n) {
+  // Good luck!
+  return n;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/i-before-e-except-after-c.russian.md

@@ -0,0 +1,66 @@
+---
+title: I before E except after C
+id: 5a23c84252665b21eecc7eb0
+challengeType: 5
+videoUrl: ''
+localeTitle: 'I до E, за исключением C'
+---
+
+## Description
+<section id="description"> Фраза <a href="https://en.wikipedia.org/wiki/I before E except after C">«I до E, за исключением C»</a> - широко известная мнемоника, которая должна помочь при написании английских слов. Используя предоставленные слова, проверьте, являются ли два подкласса фразы правдоподобными: <ol><li style="margin-bottom: 5px;"> <i>«Я до E, когда не предшествует C».</i> </li><li> <i>«E до I, когда предшествует C».</i> </li></ol> Если обе подфразы правдоподобны, то исходную фразу можно назвать правдоподобной. Напишите функцию, которая принимает слово и проверяет, соответствует ли это слово этому правилу. Функция должна возвращать true, если она соответствует правилу, в противном случае false. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>IBeforeExceptC</code> должен быть функцией.
+    testString: 'assert(typeof IBeforeExceptC=="function","<code>IBeforeExceptC</code> should be a function.");'
+  - text: <code>IBeforeExceptC(&quot;receive&quot;)</code> должен возвращать логическое значение.
+    testString: 'assert(typeof IBeforeExceptC("receive")=="boolean","<code>IBeforeExceptC("receive")</code> should return a boolean.");'
+  - text: <code>IBeforeExceptC(&quot;receive&quot;)</code> должен возвращать <code>true</code> .
+    testString: 'assert.equal(IBeforeExceptC("receive"),true,"<code>IBeforeExceptC("receive")</code> should return <code>true</code>.");'
+  - text: <code>IBeforeExceptC(&quot;science&quot;)</code> должен возвращать <code>false</code> .
+    testString: 'assert.equal(IBeforeExceptC("science"),false,"<code>IBeforeExceptC("science")</code> should return <code>false</code>.");'
+  - text: <code>IBeforeExceptC(&quot;imperceivable&quot;)</code> должен возвращать <code>true</code> .
+    testString: 'assert.equal(IBeforeExceptC("imperceivable"),true,"<code>IBeforeExceptC("imperceivable")</code> should return <code>true</code>.");'
+  - text: <code>IBeforeExceptC(&quot;inconceivable&quot;)</code> должен возвращать <code>true</code> .
+    testString: 'assert.equal(IBeforeExceptC("inconceivable"),true,"<code>IBeforeExceptC("inconceivable")</code> should return <code>true</code>.");'
+  - text: <code>IBeforeExceptC(&quot;insufficient&quot;)</code> должен возвращать <code>false</code> .
+    testString: 'assert.equal(IBeforeExceptC("insufficient"),false,"<code>IBeforeExceptC("insufficient")</code> should return <code>false</code>.");'
+  - text: <code>IBeforeExceptC(&quot;omniscient&quot;)</code> должен возвращать <code>false</code> .
+    testString: 'assert.equal(IBeforeExceptC("omniscient"),false,"<code>IBeforeExceptC("omniscient")</code> should return <code>false</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function IBeforeExceptC (word) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/iban.russian.md

@@ -0,0 +1,72 @@
+---
+title: IBAN
+id: 5a23c84252665b21eecc7eaf
+challengeType: 5
+videoUrl: ''
+localeTitle: Они были
+---
+
+## Description
+<section id="description"> <a href="https://en.wikipedia.org/wiki/International_Bank_Account_Number">Международный номер банковского счета (IBAN)</a> является международно согласованным средством определения банковских счетов через национальные границы с уменьшенным риском распространения <a href="https://en.wikipedia.org/wiki/Transcription_error">ошибок транскрипции</a> . IBAN состоит из 34 буквенно-цифровых символов: <ul><li> сначала двухбуквенный код страны ISO 3166-1 alpha-2 </li><li> затем две контрольные цифры и </li><li> наконец, базовый номер банковского счета для конкретной страны (BBAN). </li></ul> Контрольные цифры позволяют проверить работоспособность номера банковского счета, чтобы подтвердить его целостность даже перед отправкой транзакции. Напишите функцию, которая принимает строку IBAN в качестве параметра. Если это верно, верните true. В противном случае верните false. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>isValid</code> должна быть функцией.
+    testString: 'assert(typeof isValid=="function","<code>isValid</code> should be a function.");'
+  - text: '<code>isValid(&quot;&quot;+tests[0]+&quot;&quot;)</code> должен возвращать логическое значение.'
+    testString: 'assert(typeof isValid(tests[0])=="boolean","<code>isValid(""+tests[0]+"")</code> should return a boolean.");'
+  - text: '<code>isValid(&quot;&quot;+tests[0]+&quot;&quot;)</code> должен возвращать <code>true</code> .'
+    testString: 'assert.equal(isValid(tests[0]),true,"<code>isValid(""+tests[0]+"")</code> should return <code>true</code>.");'
+  - text: '<code>isValid(&quot;&quot;+tests[1]+&quot;&quot;)</code> должен возвращать <code>false</code> .'
+    testString: 'assert.equal(isValid(tests[1]),false,"<code>isValid(""+tests[1]+"")</code> should return <code>false</code>.");'
+  - text: '<code>isValid(&quot;&quot;+tests[2]+&quot;&quot;)</code> должен возвращать <code>false</code> .'
+    testString: 'assert.equal(isValid(tests[2]),false,"<code>isValid(""+tests[2]+"")</code> should return <code>false</code>.");'
+  - text: '<code>isValid(&quot;&quot;+tests[3]+&quot;&quot;)</code> должен возвращать <code>false</code> .'
+    testString: 'assert.equal(isValid(tests[3]),false,"<code>isValid(""+tests[3]+"")</code> should return <code>false</code>.");'
+  - text: '<code>isValid(&quot;&quot;+tests[4]+&quot;&quot;)</code> должны возвращать <code>true</code> .'
+    testString: 'assert.equal(isValid(tests[4]),true,"<code>isValid(""+tests[4]+"")</code> should return <code>true</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function isValid (iban) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/identity-matrix.russian.md

@@ -0,0 +1,70 @@
+---
+title: Identity matrix
+id: 5a23c84252665b21eecc7eb1
+challengeType: 5
+videoUrl: ''
+localeTitle: Единичная матрица
+---
+
+## Description
+<section id="description"> <i>Единичная матрица</i> является квадратной матрицей размера \ (n \ times n \), где диагональные элементы - все <b>1</b> s (одни), а все остальные элементы - все <b>0</b> s (нули). \ begin {bmatrix} 1 &amp; 0 &amp; 0 \ cr 0 &amp; 1 &amp; 0 \ cr 0 &amp; 0 &amp; 1 \ cr \ end {bmatrix} Напишите функцию, которая принимает число «n» в качестве параметра и возвращает единичную матрицу порядок nx n. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>idMatrix</code> должна быть функцией.
+    testString: 'assert(typeof idMatrix=="function","<code>idMatrix</code> should be a function.");'
+  - text: <code>idMatrix(1)</code> должен возвращать массив.
+    testString: 'assert(Array.isArray(idMatrix(1)),"<code>idMatrix(1)</code> should return an array.");'
+  - text: '<code>idMatrix(1)</code> должен возвращать <code>&quot;+JSON.stringify(results[0])+&quot;</code> .'
+    testString: 'assert.deepEqual(idMatrix(1),results[0],"<code>idMatrix(1)</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
+  - text: '<code>idMatrix(2)</code> должен возвращать <code>&quot;+JSON.stringify(results[1])+&quot;</code> .'
+    testString: 'assert.deepEqual(idMatrix(2),results[1],"<code>idMatrix(2)</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
+  - text: '<code>idMatrix(3)</code> должен возвращать <code>&quot;+JSON.stringify(results[2])+&quot;</code> .'
+    testString: 'assert.deepEqual(idMatrix(3),results[2],"<code>idMatrix(3)</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
+  - text: '<code>idMatrix(4)</code> должен возвращать <code>&quot;+JSON.stringify(results[3])+&quot;</code> .'
+    testString: 'assert.deepEqual(idMatrix(4),results[3],"<code>idMatrix(4)</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function idMatrix (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/iterated-digits-squaring.russian.md

@@ -0,0 +1,67 @@
+---
+title: Iterated digits squaring
+id: 5a23c84252665b21eecc7ec1
+challengeType: 5
+videoUrl: ''
+localeTitle: Итерированные цифры в квадрате
+---
+
+## Description
+<section id="description"> Если вы добавите квадрат цифр натурального числа (целое число больше нуля), вы всегда заканчиваете либо 1, либо 89: <pre> 15 -&gt; 26 -&gt; 40 -&gt; 16 -&gt; 37 -&gt; 58 -&gt; 89
+7 -&gt; 49 -&gt; 97 -&gt; 130 -&gt; 10 -&gt; 1 </pre> Напишите функцию, которая принимает число как параметр и возвращает 1 или 89 после выполнения указанного процесса. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>iteratedSquare</code> должна быть функцией.
+    testString: 'assert(typeof iteratedSquare=="function","<code>iteratedSquare</code> should be a function.");'
+  - text: <code>iteratedSquare(4)</code> должен вернуть число.
+    testString: 'assert(typeof iteratedSquare(4)=="number","<code>iteratedSquare(4)</code> should return a number.");'
+  - text: <code>iteratedSquare(4)</code> должен вернуть <code>89</code> .
+    testString: 'assert.equal(iteratedSquare(4),89,"<code>iteratedSquare(4)</code> should return <code>89</code>.");'
+  - text: <code>iteratedSquare(7)</code> должен вернуть <code>1</code> .
+    testString: 'assert.equal(iteratedSquare(7),1,"<code>iteratedSquare(7)</code> should return <code>1</code>.");'
+  - text: <code>iteratedSquare(15)</code> должен вернуть <code>89</code> .
+    testString: 'assert.equal(iteratedSquare(15),89,"<code>iteratedSquare(15)</code> should return <code>89</code>.");'
+  - text: <code>iteratedSquare(20)</code> должен вернуть <code>89</code> .
+    testString: 'assert.equal(iteratedSquare(20),89,"<code>iteratedSquare(20)</code> should return <code>89</code>.");'
+  - text: <code>iteratedSquare(70)</code> должен вернуть <code>1</code> .
+    testString: 'assert.equal(iteratedSquare(70),1,"<code>iteratedSquare(70)</code> should return <code>1</code>.");'
+  - text: <code>iteratedSquare(100)</code> должен вернуть <code>1</code> .
+    testString: 'assert.equal(iteratedSquare(100),1,"<code>iteratedSquare(100)</code> should return <code>1</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function iteratedSquare (n) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/jaro-distance.russian.md

@@ -0,0 +1,72 @@
+---
+title: Jaro distance
+id: 5a23c84252665b21eecc7ec2
+challengeType: 5
+videoUrl: ''
+localeTitle: Расстояние Jaro
+---
+
+## Description
+<section id="description"> Расстояние Jaro является мерой сходства между двумя строками. Чем выше расстояние Jaro для двух строк, тем более похожи строки. Оценка нормализуется так, что <b>0 не</b> приравнивается к подобию, а <b>1</b> - точное совпадение. Определение Расстояние Jaro \ (d_j \) двух заданных строк \ (s_1 \) и \ (s_2 \) - это \ begin {align} d_j = \ begin {cases} 0 &amp; &amp; \ text {if} m = 0 \\\ \ {\ frac {1} {3}} \ left ({\ frac {m} {| s_ {1} |}} + {\ frac {m} {| s_ {2} |}} + {\ frac { mt} {m}} \ right) &amp; &amp; \ text {other} \ end {cases} \ end {align} Где: <ul><li> \ (m \) - количество <i>совпадающих символов</i> ; </li><li> \ (t \) - половина числа <i>транспозиций</i> . </li></ul> Два символа из \ (s_1 \) и \ (s_2 \) соответственно, считаются <i>совпадающими,</i> только если они одинаковы, а не дальше \ (\ left \ lfloor \ frac {\ max (| s_1 |, | s_2 |)} {2} \ право \ rfloor-1 \). Каждый символ \ (s_1 \) сравнивается со всеми его совпадающими символами в \ (s_2 \). Количество совпадающих (но разных порядковых порядков) символов, деленное на 2, определяет количество <i>транспозиций</i> . <b>Пример.</b> С учетом строк \ (s_1 \) <i>DWAYNE</i> и \ (s_2 \) <i>DUANE</i> находим: <ul><li> \ (т = 4 \) </li><li> \ (| s_1 | = 6 \) </li><li> \ (| s_2 | = 5 \) </li><li> \ (t = 0 \) </li></ul> Мы находим оценку Джаро: \ (d_j = \ frac {1} {3} \ left (\ frac {4} {6} + \ frac {4} {5} + \ frac {4-0} {4} \ right) = 0.822 \). Напишите функцию a, которая принимает две строки в качестве параметров и возвращает связанное расстояние Jaro. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>jaro</code> должен быть функцией.
+    testString: 'assert(typeof jaro=="function","<code>jaro</code> should be a function.");'
+  - text: '<code>jaro(&quot;&quot;+tests[0][0]+&quot;&quot;,&quot;&quot;+tests[0][1]+&quot;&quot;)</code> должны возвращать число.'
+    testString: 'assert(typeof jaro(tests[0][0],tests[0][1])=="number","<code>jaro()</code> should return a number.");'
+  - text: '<code>jaro(&quot;&quot;+tests[0][0]+&quot;&quot;,&quot;&quot;+tests[0][1]+&quot;&quot;)</code> должны возвращать <code>&quot;+results[0]+&quot;</code> .'
+    testString: 'assert.equal(jaro(tests[0][0],tests[0][1]),results[0],"<code>jaro(""+tests[0][0]+"",""+tests[0][1]+"")</code> should return <code>"+results[0]+"</code>.");'
+  - text: '<code>jaro(&quot;&quot;+tests[1][0]+&quot;&quot;,&quot;&quot;+tests[1][1]+&quot;&quot;)</code> должны возвращать <code>&quot;+results[1]+&quot;</code> .'
+    testString: 'assert.equal(jaro(tests[1][0],tests[1][1]),results[1],"<code>jaro(""+tests[1][0]+"",""+tests[1][1]+"")</code> should return <code>"+results[1]+"</code>.");'
+  - text: '<code>jaro(&quot;&quot;+tests[2][0]+&quot;&quot;,&quot;&quot;+tests[2][1]+&quot;&quot;)</code> должны возвращать <code>&quot;+results[2]+&quot;</code> .'
+    testString: 'assert.equal(jaro(tests[2][0],tests[2][1]),results[2],"<code>jaro(""+tests[2][0]+"",""+tests[2][1]+"")</code> should return <code>"+results[2]+"</code>.");'
+  - text: '<code>jaro(&quot;&quot;+tests[3][0]+&quot;&quot;,&quot;&quot;+tests[3][1]+&quot;&quot;)</code> должны возвращать <code>&quot;+results[3]+&quot;</code> .'
+    testString: 'assert.equal(jaro(tests[3][0],tests[3][1]),results[3],"<code>jaro(""+tests[3][0]+"",""+tests[3][1]+"")</code> should return <code>"+results[3]+"</code>.");'
+  - text: '<code>jaro(&quot;&quot;+tests[4][0]+&quot;&quot;,&quot;&quot;+tests[4][1]+&quot;&quot;)</code> должны возвращать <code>&quot;+results[4]+&quot;</code> .'
+    testString: 'assert.equal(jaro(tests[4][0],tests[4][1]),results[4],"<code>jaro(""+tests[4][0]+"",""+tests[4][1]+"")</code> should return <code>"+results[4]+"</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function jaro (s, t) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/jortsort.russian.md

@@ -0,0 +1,74 @@
+---
+title: JortSort
+id: 5a23c84252665b21eecc7ec4
+challengeType: 5
+videoUrl: ''
+localeTitle: JortSort
+---
+
+## Description
+<section id="description"> jortSort - это набор инструментов сортировки, который заставляет пользователя выполнять работу и гарантирует эффективность, потому что вам больше не нужно сортировать. Первоначально он был представлен Jenn «Moneydollars» Шиффер на престижном <a href="https://www.youtube.com/watch?v=pj4U_W0OFoE">JSConf</a> . jortSort - это функция, которая принимает один массив сопоставимых объектов в качестве аргумента. Затем он сортирует массив в порядке возрастания и сравнивает отсортированный массив с первоначально предоставленным массивом. Если массивы совпадают (т. Е. Исходный массив уже был отсортирован), функция возвращает true. Если массивы не совпадают (т. Е. Исходный массив не был отсортирован), функция возвращает false. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>jortsort</code> должен быть функцией.
+    testString: 'assert(typeof jortsort=="function","<code>jortsort</code> should be a function.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[0])+&quot;)</code> должен возвращать логическое значение.'
+    testString: 'assert(typeof jortsort(tests[0].slice())=="boolean","<code>jortsort("+JSON.stringify(tests[0])+")</code> should return a boolean.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[0])+&quot;)</code> должен возвращать <code>true</code> .'
+    testString: 'assert.equal(jortsort(tests[0].slice()),true,"<code>jortsort("+JSON.stringify(tests[0])+")</code> should return <code>true</code>.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[1])+&quot;)</code> должен возвращать <code>false</code> .'
+    testString: 'assert.equal(jortsort(tests[1].slice()),false,"<code>jortsort("+JSON.stringify(tests[1])+")</code> should return <code>false</code>.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[2])+&quot;)</code> должен возвращать значение <code>false</code> .'
+    testString: 'assert.equal(jortsort(tests[2].slice()),false,"<code>jortsort("+JSON.stringify(tests[2])+")</code> should return <code>false</code>.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[3])+&quot;)</code> должен возвращать <code>true</code> .'
+    testString: 'assert.equal(jortsort(tests[3].slice()),true,"<code>jortsort("+JSON.stringify(tests[3])+")</code> should return <code>true</code>.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[4])+&quot;)</code> должен возвращать значение <code>false</code> .'
+    testString: 'assert.equal(jortsort(tests[4].slice()),false,"<code>jortsort("+JSON.stringify(tests[4])+")</code> should return <code>false</code>.");'
+  - text: '<code>jortsort(&quot;+JSON.stringify(tests[5])+&quot;)</code> должен возвращать <code>true</code> .'
+    testString: 'assert.equal(jortsort(tests[5].slice()),true,"<code>jortsort("+JSON.stringify(tests[5])+")</code> should return <code>true</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function jortsort (array) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/josephus-problem.russian.md

@@ -0,0 +1,64 @@
+---
+title: Josephus problem
+id: 5a23c84252665b21eecc7ec5
+challengeType: 5
+videoUrl: ''
+localeTitle: Проблема Иосифа
+---
+
+## Description
+<section id="description"> <a href="https://en.wikipedia.org/wiki/Josephus problem">Проблема Джозефуса</a> - математическая головоломка с мрачным описанием: $ n $ заключенные стоят по кругу, последовательно пронумерованные от $ 0 $ до $ n-1 $. Палач ходит по кругу, начиная с заключенного $ 0 $, удаляя каждого $ k $ -ного заключенного и убивая его. По мере того как процесс продолжается, круг становится все меньше и меньше, пока остается только один заключенный, который затем освобождается. Например, если есть $ n = 5 $ заключенных и $ k = 2 $, то порядок, в котором заключенные будут убиты (назовем его «последовательностью убийства»), будет 1, 3, 0 и 4, а оставшийся в живых будет # 2. Учитывая любые <big>$ n, k&gt; 0 $</big> , выясните, кто из заключенных будет последним выжившим. В одном из таких инцидентов было 41 заключенный, и каждый 3- <sup>й</sup> заключенный был убит ( <big>$ k = 3 $</big> ). Среди них было умное имя Джофа, который разработал проблему, стоял в выжившем положении и продолжал рассказывать историю. Каким он был? Напишите функцию, которая берет начальное число заключенных и «k» в качестве параметра и возвращает число заключенного, который выживает. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>josephus</code> должен быть функцией.
+    testString: 'assert(typeof josephus=="function","<code>josephus</code> should be a function.");'
+  - text: '<code>josephus(30,3)</code> должен вернуть число.'
+    testString: 'assert(typeof josephus(30,3)=="number","<code>josephus(30,3)</code> should return a number.");'
+  - text: '<code>josephus(30,3)</code> должен вернуться <code>29</code> .'
+    testString: 'assert.equal(josephus(30,3),29,"<code>josephus(30,3)</code> should return <code>29</code>.");'
+  - text: '<code>josephus(30,5)</code> должен вернуться <code>3</code> .'
+    testString: 'assert.equal(josephus(30,5),3,"<code>josephus(30,5)</code> should return <code>3</code>.");'
+  - text: '<code>josephus(20,2)</code> должен вернуться <code>9</code> .'
+    testString: 'assert.equal(josephus(20,2),9,"<code>josephus(20,2)</code> should return <code>9</code>.");'
+  - text: '<code>josephus(17,6)</code> должен вернуться <code>2</code> .'
+    testString: 'assert.equal(josephus(17,6),2,"<code>josephus(17,6)</code> should return <code>2</code>.");'
+  - text: '<code>josephus(29,4)</code> должен вернуться <code>2</code> .'
+    testString: 'assert.equal(josephus(29,4),2,"<code>josephus(29,4)</code> should return <code>2</code>.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function josephus (init, kill) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/s-expressions.russian.md

@@ -0,0 +1,67 @@
+---
+title: S-Expressions
+id: 59667989bf71cf555dd5d2ff
+challengeType: 5
+videoUrl: ''
+localeTitle: S-выражение
+---
+
+## Description
+<section id="description"><p> <a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-выражение">S-выражения</a> - один из удобных способов анализа и хранения данных. </p> Задача: <p> Напишите простой читатель / парсер для S-Expressions, который обрабатывает строки с кавычками и без кавычек, целые числа и поплавки. </p><p> Функция должна читать одно, но вложенное S-выражение из строки и возвращать его как (вложенный) массив. </p><p> Новые строки и другие пробелы могут игнорироваться, если они не содержатся в цитируемой строке. </p><p> &quot; <tt>()</tt> &quot; Внутри цитируемых строк не интерпретируются, а рассматриваются как часть строки. </p><p> Обработка скрытых кавычек внутри строки необязательна; таким образом &quot; <tt>(foo&quot; bar)</tt> &quot;может рассматриваться как строка&quot; <tt>foo &quot;bar</tt> &quot; или как ошибка. </p><p> Для этого читатель не должен распознавать « <tt>\</tt> » для экранирования, но должен, кроме того, распознавать номера, если язык имеет соответствующие типы данных. </p><p> Обратите внимание, что за исключением « <tt>(» «</tt> » (« <tt>\</tt> », если поддерживается escaping) и пробелов нет специальных символов. Все остальное разрешено без кавычек. </p><p> Читатель должен уметь читать следующий ввод </p><p></p><pre> ((данные «котируемые данные» 123 4.5)
+    (данные (! @ # (4.5) &quot;(более&quot; &quot;данные)&quot;)))
+</pre><p></p><p> и превратить его в родную структуру данных. (см. реализации <a href="http://rosettacode.org/wiki/#Pike" title="#Pike">Pike</a> , <a href="http://rosettacode.org/wiki/#Python" title="#Python">Python</a> и <a href="http://rosettacode.org/wiki/#Ruby" title="#Рубин">Ruby</a> для примеров встроенных структур данных.) </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>parseSexpr</code> - это функция.
+    testString: 'assert(typeof parseSexpr === "function", "<code>parseSexpr</code> is a function.");'
+  - text: '<code>parseSexpr(&quot;(data1 data2 data3)&quot;)</code> должен возвращать [&quot;data1&quot;, &quot;data2&quot;, &quot;data3&quot;] &quot;)'
+    testString: 'assert.deepEqual(parseSexpr(simpleSExpr), simpleSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return ["data1", "data2", "data3"]");'
+  - text: '<code>parseSexpr(&#39;(data1 data2 data3)&#39;)</code> должен возвращать массив с 3 элементами &quot;)'
+    testString: 'assert.deepEqual(parseSexpr(basicSExpr), basicSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return an array with 3 elements");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function parseSexpr(str) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.russian.md

@@ -0,0 +1,60 @@
+---
+title: 'Sailors, coconuts and a monkey problem'
+id: 59da22823d04c95919d46269
+challengeType: 5
+videoUrl: ''
+localeTitle: 'Моряки, кокосы и проблема обезьяны'
+---
+
+## Description
+<section id="description"><p> Пять матросов потерпели кораблекрушение на острове и собирают большую кучу кокосовых орехов в течение дня. </p><p> В эту ночь первый моряк просыпается и решает взять свою первую долю раньше, поэтому пытается разделить кучу кокосов одинаково на пять кучек, но обнаруживает, что остался один кокос, поэтому он бросает его обезьяне, а затем прячет «свою», одну из пяти одинаковых по размеру груды кокосов и подталкивает еще четыре свай вместе, чтобы снова сформировать одну видимую груду кокосов и ложиться спать. </p><p> Короче говоря, каждый из моряков, в свою очередь, встает один раз ночью и выполняет те же действия, что и разделение кокосовой кучи на пять, и обнаруживает, что один кокос оставлен и дает кокосовому кокосовому ореху обезьяне. </p><p> Утром (после тайного и раздельного действия каждого из пяти матросов в ночное время) оставшиеся кокосы делятся на пять равных свай для каждого из моряков, после чего обнаруживается, что куча кокосовых орехов одинаково делится среди моряков без остатка. (Ничего для обезьяны утром). </p><p> Задание: </p><pre> <code> Create a function that returns the the minimum possible size of the initial pile of coconuts collected during the day for N sailors.</code> </pre><p> Заметка: </p><pre> <code> Of course the tale is told in a world where the collection of any amount of coconuts in a day and multiple divisions of the pile, etc can occur in time fitting the story line, so as not to affect the mathematics.</code> </pre><p> Cf: </p><p> <a href="https://www.youtube.com/watch?v=U9qU20VmvaU" title="ссылка: https://www.youtube.com/watch?v=U9qU20VmvaU">Обезьяны и кокосы - Numberphile</a> (видео) Аналитическое решение. </p><pre> <code> &lt;a href=&quot;http://oeis.org/A002021&quot; title=&quot;link: http://oeis.org/A002021&quot;&gt;A002021 Pile of coconuts problem&lt;/a&gt; The On-Line Encyclopedia of Integer Sequences. (Although some of its references may use the alternate form of the tale).</code> </pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>splitCoconuts</code> - это функция.
+    testString: 'assert(typeof splitCoconuts === "function", "<code>splitCoconuts</code> is a function.");'
+  - text: <code>splitCoconuts(5)</code> должен вернуть 3121.
+    testString: 'assert(splitCoconuts(5) === 3121, "<code>splitCoconuts(5)</code> should return 3121.");'
+  - text: <code>splitCoconuts(6)</code> должен возвращать 233275.
+    testString: 'assert(splitCoconuts(6) === 233275, "<code>splitCoconuts(6)</code> should return 233275.");'
+  - text: <code>splitCoconuts(7)</code> должен вернуть 823537.
+    testString: 'assert(splitCoconuts(7) === 823537, "<code>splitCoconuts(7)</code> should return 823537.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+// noprotect
+function splitCoconuts(intSailors) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/sedols.russian.md

@@ -0,0 +1,61 @@
+---
+title: SEDOLs
+id: 59d9c6bc214c613ba73ff012
+challengeType: 5
+videoUrl: ''
+localeTitle: SEDOLs
+---
+
+## Description
+<section id="description"> Задача: <p> Для каждого списка номеров 6-значных <a href="https://en.wikipedia.org/wiki/SEDOL" title="wp: SEDOL">SEDOL</a> s вычислите и добавьте цифру контрольной суммы. </p><p> То есть, учитывая входную строку слева, ваша функция должна возвращать соответствующую строку справа: </p><pre> <code>&lt;pre&gt; 710889 =&gt; 7108899 B0YBKJ =&gt; B0YBKJ7 406566 =&gt; 4065663 B0YBLH =&gt; B0YBLH2 228276 =&gt; 2282765 B0YBKL =&gt; B0YBKL9 557910 =&gt; 5579107 B0YBKR =&gt; B0YBKR5 585284 =&gt; 5852842 B0YBKT =&gt; B0YBKT7 B00030 =&gt; B000300 &lt;/pre&gt;</code> </pre><p> Проверьте также, что каждый вход правильно сформирован, особенно в отношении допустимых символов, разрешенных в строке SEDOL. Ваша функция должна возвращать значение <code>null</code> для недопустимого ввода. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>sedol</code> - это функция.
+    testString: 'assert(typeof sedol === "function", "<code>sedol</code> is a function.");'
+  - text: '<code>sedol(&#39;a&#39;)</code> должен возвращать null. &quot;)'
+    testString: 'assert(sedol("a") === null, "<code>sedol("a")</code> should return null.");'
+  - text: '<code>sedol(&#39;710889&#39;)</code> должен возвращать &#39;7108899&#39;. &quot;)'
+    testString: 'assert(sedol("710889") === "7108899", "<code>sedol("710889")</code> should return "7108899".");'
+  - text: '<code>sedol(&#39;BOATER&#39;)</code> должен вернуть null. &quot;)'
+    testString: 'assert(sedol("BOATER") === null, "<code>sedol("BOATER")</code> should return null.");'
+  - text: '<code>sedol(&#39;228276&#39;)</code> должен вернуться &#39;2282765&#39;. &quot;)'
+    testString: 'assert(sedol("228276") === "2282765", "<code>sedol("228276")</code> should return "2282765".");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function sedol (input) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/taxicab-numbers.russian.md

@@ -0,0 +1,71 @@
+---
+title: Taxicab numbers
+id: 594ecc0d9a8cf816e3340187
+challengeType: 5
+videoUrl: ''
+localeTitle: Номера такси
+---
+
+## Description
+<section id="description"> Номер <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: номер Харди-Рамануджана">такси</a> (определение, которое используется здесь) является положительным целым числом, которое может быть выражено как сумма двух положительных кубов более чем одним способом. Первый номер такси составляет 1729, что составляет: 1 <sup>3</sup> + 12 <sup>3</sup> и 9 <sup>3</sup> + 10 <sup>3</sup> . Номера такси также известны как: * номера такси * номера такси-такси * номера такси * номера Hardy-Ramanujan Задача: Напишите функцию, которая возвращает самые низкие номера такси. Для каждого номера такси, укажите номер, а также его составные кубы. См. Также: [http://oeis.org/A001235 A001235 номера такси) в онлайновой энциклопедии целочисленных последовательностей. <a href="http://mathworld.wolfram.com/Hardy-RamanujanNumber.html">Харди-Рамануджан</a> на MathWorld. <a href="http://mathworld.wolfram.com/TaxicabNumber.html">номер такси</a> для MathWorld. <a href="https://en.wikipedia.org/wiki/Taxicab_number">номер такси</a> в Википедии. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>taxicabNumbers</code> - это функция.
+    testString: 'assert(typeof taxicabNumbers === "function", "<code>taxicabNumbers </code> is a function.");'
+  - text: <code>taxicabNumbers</code> должны возвращать массив.
+    testString: 'assert(typeof taxicabNumbers(2) === "object", "<code>taxicabNumbers </code> should return an array.");'
+  - text: <code>taxicabNumbers</code> должен возвращать массив чисел.
+    testString: 'assert(typeof taxicabNumbers(100)[0] === "number", "<code>taxicabNumbers </code> should return an array of numbers.");'
+  - text: '<code>taxicabNumbers(4)</code> должны вернуть [1729, 4104, 13832, 20683].'
+    testString: 'assert.deepEqual(taxicabNumbers(4), res4, "<code>taxicabNumbers(4) </code> must return [1729, 4104, 13832, 20683].");'
+  - text: 'taxicabNumbers (25) должны возвращаться [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264 , 327763, 373464, 402597]'
+    testString: 'assert.deepEqual(taxicabNumbers(25), res25, "taxicabNumbers(25) should return [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597]");'
+  - text: 'taxicabNumbers (39) итоговые цифры от 20 до 29 должны быть [314496,320264,327763,373464,402597,439101,443889,513000,513856].'
+    testString: 'assert.deepEqual(taxicabNumbers(39).slice(20, 29), res39From20To29, "taxicabNumbers(39) resulting numbers from 20 - 29 should be [314496,320264,327763,373464,402597,439101,443889,513000,513856].");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function taxicabNumbers (n) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.russian.md

@@ -0,0 +1,67 @@
+---
+title: Tokenize a string with escaping
+id: 594faaab4e2a8626833e9c3d
+challengeType: 5
+videoUrl: ''
+localeTitle: Токенизировать строку с экранированием
+---
+
+## Description
+<section id="description"><p> Напишите функцию или программу, которые могут разбивать строку на каждое неэкранированное вхождение символа разделителя. </p><p> Он должен принимать три входных параметра: </p> <b>Строка</b> Символ <b>разделителя</b> Управляющий <b>символ</b> <p> Он должен вывести список строк. </p><p> Правила разделения: </p> Поля, разделенные разделителями, становятся элементами выходного списка. Пустые поля должны быть сохранены, даже в начале и в конце. <p> Правила побега: </p> «Escaped» означает, что предшествует появление escape-символа, который еще не сбежал. Когда escape-символ предшествует персонажу, который не имеет особого значения, он по-прежнему считается побегом (но не делает ничего особенного). Каждое появление escape-символа, которое использовалось для выхода из него, не должно становиться частью выхода. <p> Продемонстрируйте, что ваша функция удовлетворяет следующему тестовому сценарию: заданная строка </p><pre> один ^ | у || три ^^^^ | четыре ^^^ | ^ куатро | </pre> и использование <pre> | </pre> как разделитель и <pre> ^ </pre> как escape-символ, ваша функция должна выводить следующий массив: <p></p><pre> [&#39;one | uno&#39;, &quot;, &#39;three ^^&#39;, &#39;four ^ | quatro&#39;,&quot;]
+  </pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>tokenize</code> - это функция.
+    testString: 'assert(typeof tokenize === "function", "<code>tokenize</code> is a function.");'
+  - text: <code>tokenize</code> должен возвращать массив.
+    testString: 'assert(typeof tokenize("a", "b", "c") === "object", "<code>tokenize</code> should return an array.");'
+  - text: '<code>tokenize(&quot;one^|uno||three^^^^|four^^^|^cuatro|&quot;, &quot;|&quot;, &quot;^&quot;)</code> должно возвращать [&quot;one | uno&quot;, &quot;&quot;, &quot;three ^^&quot; , &quot;four ^ | cuatro&quot;, &quot;&quot;] &quot;)'
+    testString: 'assert.deepEqual(tokenize(testStr1, "|", "^"), res1, "<code>tokenize("one^|uno||three^^^^|four^^^|^cuatro|", "|", "^") </code> should return ["one|uno", "", "three^^", "four^|cuatro", ""]");'
+  - text: '<code>tokenize(&quot;a@&amp;bcd&amp;ef&amp;&amp;@@hi&quot;, &quot;&amp;&quot;, &quot;@&quot;)</code> должны возвращать <code>[&quot;a&amp;bcd&quot;, &quot;ef&quot;, &quot;&quot;, &quot;@hi&quot;]</code>'
+    testString: 'assert.deepEqual(tokenize(testStr2, "&", "@"), res2, "<code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> should return <code>["a&bcd", "ef", "", "@hi"]</code>");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function tokenize(str, esc, sep) {
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/top-rank-per-group.russian.md

@@ -0,0 +1,95 @@
+---
+title: Top rank per group
+id: 595011cba5a81735713873bd
+challengeType: 5
+videoUrl: ''
+localeTitle: Высший разряд на группу
+---
+
+## Description
+<section id="description"> Задача: <p> Найдите верхние N ранжированных данных в каждой группе, где N предоставляется в качестве параметра. В качестве параметра также указывается имя ранга и группы. </p> Учитывая следующие данные: <pre> [
+  {имя: &#39;Tyler Bennett&#39;, id: &#39;E10297&#39;, зарплата: 32000, отдел: &#39;D101&#39;},
+  {name: &#39;John Rappl&#39;, id: &#39;E21437&#39;, зарплата: 47000, отдел: &#39;D050&#39;},
+  {имя: &#39;George Woltman&#39;, id: &#39;E00127&#39;, зарплата: 53500, отдел: &#39;D101&#39;},
+  {name: &#39;Adam Smith&#39;, id: &#39;E63535&#39;, зарплата: 18000, отдел: &#39;D202&#39;},
+  {имя: &#39;Claire Buckman&#39;, id: &#39;E39876&#39;, зарплата: 27800, отдел: &#39;D202&#39;},
+  {имя: &#39;David McClellan&#39;, id: &#39;E04242&#39;, зарплата: 41500, отдел: &#39;D101&#39;},
+  {name: &#39;Rich Holcomb&#39;, id: &#39;E01234&#39;, зарплата: 49500, отдел: &#39;D202&#39;},
+  {имя: &#39;Nathan Adams&#39;, id: &#39;E41298&#39;, зарплата: 21900, отдел: &#39;D050&#39;},
+  {name: &#39;Richard Potter&#39;, id: &#39;E43128&#39;, зарплата: 15900, отдел: &#39;D101&#39;},
+  {имя: &#39;David Motsinger&#39;, id: &#39;E27002&#39;, зарплата: 19250, отдел: &#39;D202&#39;},
+  {имя: &#39;Tim Sampair&#39;, id: &#39;E03033&#39;, зарплата: 27000, отдел: &#39;D101&#39;},
+  {name: &#39;Kim Arlich&#39;, id: &#39;E10001&#39;, зарплата: 57000, отдел: &#39;D190&#39;},
+  {name: &#39;Timothy Grove&#39;, id: &#39;E16398&#39;, зарплата: 29900, отдел: &#39;D190&#39;}
+];
+</pre> в каждом отделе можно было бы <code>topRankPerGroup(10, data, &#39;dept&#39;, &#39;salary&#39;)</code> лучших сотрудников, позвонив <code>topRankPerGroup(10, data, &#39;dept&#39;, &#39;salary&#39;)</code> Учитывая следующие данные: <pre> [
+  {name: &#39;Friday 13th&#39;, жанр: &#39;horror&#39;, рейтинг: 9.9},
+  {name: «Кошмар на улице Вязов», жанр: «ужас», рейтинг: 5.7},
+  {name: «Титаник», жанр: «драма», рейтинг: 7.3},
+  {name: &#39;Maze Runner&#39;, жанр: &#39;scifi&#39;, рейтинг: 7.1},
+  {name: &#39;Blade runner&#39;, жанр: &#39;scifi&#39;, рейтинг: 8.9}
+];
+</pre> можно <code>topRankPerGroup(1, data, &#39;genre&#39;, &#39;rating&#39;)</code> рейтинг фильма с самым высоким рейтингом в каждом жанре, назвав <code>topRankPerGroup(1, data, &#39;genre&#39;, &#39;rating&#39;)</code> </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>topRankPerGroup</code> - это функция.
+    testString: 'assert(typeof topRankPerGroup === "function", "<code>topRankPerGroup</code> is a function.");'
+  - text: <code>topRankPerGroup</code> возвращает undefined при отрицательных значениях n.
+    testString: 'assert(typeof topRankPerGroup(-1, []) === "undefined", "<code>topRankPerGroup</code> returns undefined on negative n values.");'
+  - text: Первый отдел должен быть D050
+    testString: 'assert.equal(res1[0][0].dept, "D050", "First department must be D050");'
+  - text: Первый отдел должен быть D050
+    testString: 'assert.equal(res1[0][1].salary, 21900, "First department must be D050");'
+  - text: Последний отдел должен быть D202
+    testString: 'assert.equal(res1[3][3].dept, "D202", "The last department must be D202");'
+  - text: '<code>topRankPerGroup(1, ...)</code> должен возвращать только результат высшего рейтинга для каждой группы.'
+    testString: 'assert.equal(res2[2].length, 1, "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
+  - text: '<code>topRankPerGroup(1, ...)</code> должен возвращать только результат высшего рейтинга для каждой группы.'
+    testString: 'assert.equal(res3[2][1].name, "Maze Runner", "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function topRankPerGroup(n, data, groupName, rankName) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/topological-sort.russian.md

@@ -0,0 +1,84 @@
+---
+title: Topological sort
+id: 594fa2746886f41f7d8bf225
+challengeType: 5
+videoUrl: ''
+localeTitle: Топологическая сортировка
+---
+
+## Description
+<section id="description"><p> Учитывая сопоставление между элементами и элементами, на которых они зависят, <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">топологические</a> позиции <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">сортировки сортируются,</a> так что ни один элемент не предшествует элементу, от которого он зависит. </p><p> Компиляция библиотеки на языке <a href="https://en.wikipedia.org/wiki/VHDL" title="wp: VHDL">VHDL</a> имеет ограничение на то, что библиотека должна быть скомпилирована после любой библиотеки, от которой она зависит. </p> Задача: <p> Напишите функцию, которая вернет действительный порядок компиляции библиотек VHDL из их зависимостей. </p> Предположим, что имена библиотек - это одиночные слова. Пункты, упомянутые как только иждивенцы, не имеют собственных иждивенцев, но их порядок компиляции должен быть дан. Любые собственные зависимости следует игнорировать. Любые неустановимые зависимости следует игнорировать. <p> В качестве примера используйте следующие данные: </p><pre> БИБЛИОТЕЧНЫЕ БИОГРАФИЧЕСКИЕ ЗАВИСИМОСТИ
+======= =============================
+des_system_lib std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee
+dw01 ieee dw01 dware gtech
+dw02 ieee dw02 dware
+dw03 std synopsys dware dw03 dw02 dw01 ieee gtech
+dw04 dw04 ieee dw01 dware gtech
+dw05 dw05 ieee dware
+dw06 dw06 ieee dware
+dw07 ieee dware
+dware ieee dware
+gtech ieee gtech
+ramlib std ieee
+std_cell_lib ieee std_cell_lib
+Synopsys
+</pre><p> <small>Примечание: вышеуказанные данные были бы неустановимыми, если, например, <code>dw04</code> добавляется в список зависимостей <code>dw01</code> .</small> </p> Cf: <pre> <code>&lt;a href=&quot;http://rosettacode.org/wiki/Topological sort/Extracted top item&quot; title=&quot;Topological sort/Extracted top item&quot;&gt;Topological sort/Extracted top item&lt;/a&gt;.</code> </pre><p> Существует два популярных алгоритма топологической сортировки: </p><p> Канский топологический сорт 1962 года и поиск по глубине: <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">топологическая сортировка</a> </p><p> Джейсон Сакс: <a href="http://www.embeddedrelated.com/showarticle/799.php" title="ссылка: http://www.embeddedrelated.com/showarticle/799.php">«Десять небольших алгоритмов, часть 4: топологическая сортировка»</a> . </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>topologicalSort</code> функция <code>topologicalSort</code> является функцией.
+    testString: 'assert(typeof topologicalSort === "function", "<code>topologicalSort</code> is a function.");'
+  - text: <code>topologicalSort</code> должен вернуть правильный порядок библиотек.
+    testString: 'assert.deepEqual(topologicalSort(libsSimple), ["bbb", "aaa"], "<code>topologicalSort</code> must return correct library order..");'
+  - text: <code>topologicalSort</code> должен вернуть правильный порядок библиотек.
+    testString: 'assert.deepEqual(topologicalSort(libsVHDL), solutionVHDL, "<code>topologicalSort</code> must return correct library order..");'
+  - text: <code>topologicalSort</code> должен вернуть правильный порядок библиотек.
+    testString: 'assert.deepEqual(topologicalSort(libsCustom), solutionCustom, "<code>topologicalSort</code> must return correct library order..");'
+  - text: <code>topologicalSort</code> должен игнорировать неупорядоченные зависимости.
+    testString: 'assert.deepEqual(topologicalSort(libsUnorderable), solutionUnorderable, "<code>topologicalSort</code> must ignore unorderable dependencies..");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function topologicalSort(libs) {
+  // Good luck!
+  return true;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/towers-of-hanoi.russian.md

@@ -0,0 +1,69 @@
+---
+title: Towers of Hanoi
+id: 5951ed8945deab770972ae56
+challengeType: 5
+videoUrl: ''
+localeTitle: Башни Ханоя
+---
+
+## Description
+<section id="description"> Задача: <p> Решите проблему <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: Towers_of_Hanoi">Башни Ханоя</a> . </p><p> Ваше решение должно принять количество дисков в качестве первых параметров и три строки, используемые для идентификации каждого из трех стеков дисков, например <code>towerOfHanoi(4, &#39;A&#39;, &#39;B&#39;, &#39;C&#39;)</code> . Функция должна возвращать массив массивов, содержащий список ходов, source -&gt; destination. Например, массив <code>[[&#39;A&#39;, &#39;C&#39;], [&#39;B&#39;, &#39;A&#39;]]</code> указывает, что 1-й ход состоял в том, чтобы переместить диск из стека A в C, а второй шаг состоял в том, чтобы переместить диск из стека B в A. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>towerOfHanoi</code> - это функция.
+    testString: 'assert(typeof towerOfHanoi === "function", "<code>towerOfHanoi</code> is a function.");'
+  - text: '<code>towerOfHanoi(3, ...)</code> должен возвращать 7 ходов.'
+    testString: 'assert(res3.length === 7, "<code>towerOfHanoi(3, ...)</code> should return 7 moves.");'
+  - text: '<code>towerOfHanoi(3, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> должны возвращать [[«A», «B»], [«A», «C»], [«B», «C»], [ &quot;А&quot;, &quot;В&quot;], [ &quot;С&quot;, &quot;А&quot;], [ &quot;С&quot;, &quot;В&quot;], [ &quot;А&quot;, &quot;Б&quot;]]. &quot;)'
+    testString: 'assert.deepEqual(towerOfHanoi(3, "A", "B", "C"), res3Moves, "<code>towerOfHanoi(3, "A", "B", "C")</code> should return [["A","B"],["A","C"],["B","C"],["A","B"],["C","A"],["C","B"],["A","B"]].");'
+  - text: '<code>towerOfHanoi(5, &quot;X&quot;, &quot;Y&quot;, &quot;Z&quot;)</code> 10-й ход должен быть Y -&gt; X.'
+    testString: 'assert.deepEqual(res5[9], ["Y", "X"], "<code>towerOfHanoi(5, "X", "Y", "Z")</code> 10th move should be Y -> X.");'
+  - text: '<code>towerOfHanoi(7, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> первые десять ходов - [[«А», «В»], [«А», «С»], [«В», «С»] , [ &quot;А&quot;, &quot;В&quot;], [ &quot;С&quot;, &quot;А&quot;], [ &quot;С&quot;, &quot;В&quot;], [ &quot;А&quot;, &quot;В&quot;], [ &quot;А&quot;, &quot;С&quot;] , [ &quot;В&quot;, &quot;С&quot;], [ &quot;В&quot;, &quot;А&quot;]] &quot;.)'
+    testString: 'assert.deepEqual(towerOfHanoi(7, "A", "B", "C").slice(0, 10), res7First10Moves, "<code>towerOfHanoi(7, "A", "B", "C")</code> first ten moves are [["A","B"],["A","C"],["B","C"],["A","B"],["C","A"],["C","B"],["A","B"],["A","C"],["B","C"],["B","A"]].");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function towerOfHanoi (n, a, b, c) {
+  // Good luck!
+  return [[]];
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/vector-cross-product.russian.md

@@ -0,0 +1,64 @@
+---
+title: Vector cross product
+id: 594810f028c0303b75339ad2
+challengeType: 5
+videoUrl: ''
+localeTitle: Векторный перекрестный продукт
+---
+
+## Description
+<section id="description"> Вектор определяется как имеющий три измерения как представленный упорядоченным набором из трех чисел: (X, Y, Z). <p> Задача: </p><pre> <code>Write a function that takes two vectors (arrays) as input and computes their cross product.</code> </pre><p> Ваша функция должна возвращать значение <code>null</code> на недопустимые входы (т. Е. Векторы разной длины). </p><p></p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: dotProduct должен быть функцией
+    testString: 'assert.equal(typeof crossProduct, "function", "dotProduct must be a function");'
+  - text: dotProduct () должен возвращать значение null
+    testString: 'assert.equal(crossProduct(), null, "dotProduct() must return null");'
+  - text: 'crossProduct ([1, 2, 3], [4, 5, 6]) должен вернуться [-3, 6, -3].'
+    testString: 'assert.deepEqual(res12, exp12, "crossProduct([1, 2, 3], [4, 5, 6]) must return [-3, 6, -3].");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function crossProduct() {
+    // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/vector-dot-product.russian.md

@@ -0,0 +1,62 @@
+---
+title: Vector dot product
+id: 594810f028c0303b75339ad3
+challengeType: 5
+videoUrl: ''
+localeTitle: Векторный точечный продукт
+---
+
+## Description
+<section id="description"><p> Вектор определяется как имеющий три измерения как представленный упорядоченным набором из трех чисел: (X, Y, Z). </p><p> Задача: </p><pre> <code>Write a function that takes any numbers of vectors (arrays) as input and computes their dot product.</code> </pre><p> Ваша функция должна возвращать значение <code>null</code> на недопустимые входы (т. Е. Векторы разной длины). </p><p></p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: dotProduct должен быть функцией
+    testString: 'assert.equal(typeof dotProduct, "function", "dotProduct must be a function");'
+  - text: dotProduct () должен возвращать значение null
+    testString: 'assert.equal(dotProduct(), null, "dotProduct() must return null");'
+  - text: 'dotProduct ([[1], [1]]) должен возвращать 1.'
+    testString: 'assert.equal(dotProduct([1], [1]), 1, "dotProduct([[1], [1]]) must return 1.");'
+  - text: 'dotProduct ([[1], [1, 2]]) должен возвращать null.'
+    testString: 'assert.equal(dotProduct([1], [1, 2]), null, "dotProduct([[1], [1, 2]]) must return null.");'
+  - text: 'dotProduct ([1, 3, -5], [4, -2, -1]) должен вернуть 3.'
+    testString: 'assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3, "dotProduct([1, 3, -5], [4, -2, -1]) must return 3.");'
+  - text: <code>dotProduct(...nVectors)</code> должен возвращать 156000
+    testString: 'assert.equal(dotProduct([ 0, 1, 2, 3, 4 ], [ 0, 2, 4, 6, 8 ], [ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ], [ 0, 5, 10, 15, 20 ]), 156000, "<code>dotProduct(...nVectors)</code> should return 156000");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function dotProduct() {
+    // Good luck!
+}
+
+```
+
+</div>
+
+
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/word-wrap.russian.md

@@ -0,0 +1,78 @@
+---
+title: Word wrap
+id: 594810f028c0303b75339ad4
+challengeType: 5
+videoUrl: ''
+localeTitle: Перенос слова
+---
+
+## Description
+<section id="description"><p> Даже сегодня, с пропорциональными шрифтами и сложными макетами, все еще есть случаи, когда вам нужно обернуть текст в указанном столбце. Основная задача - обтекание абзаца текста простым способом. Пример текста: </p><pre> Оберните текст, используя более сложный алгоритм, такой как алгоритм Knuth и Plass TeX.
+Если ваш язык предоставляет это, вы получаете легкий дополнительный кредит,
+но вы «должны ссылаться на документацию», указывая на то, что алгоритм
+что-то лучше, чем простой алгоритм минимальной длины.
+</pre><p> Задача: </p><pre> <code>Write a function that can wrap this text to any number of characters.</code> </pre><p> Например, текст, состоящий из 80 символов, должен выглядеть следующим образом: </p><p></p><pre> Оберните текст, используя более сложный алгоритм, такой как Knuth и Plass TeX
+алгоритм. Если ваш язык предоставляет это, вы получаете легкий дополнительный кредит, но вы
+должен ссылаться на документацию, указывающую, что алгоритм лучше чем
+чем простой алгоритм минимальной длины.
+</pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: wrap должна быть функцией.
+    testString: 'assert.equal(typeof wrap, "function", "wrap must be a function.");'
+  - text: wrap должен возвращать строку.
+    testString: 'assert.equal(typeof wrap("abc", 10), "string", "wrap must return a string.");'
+  - text: wrap (80) должен возвращать 4 строки.
+    testString: 'assert(wrapped80.split("\n").length === 4, "wrap(80) must return 4 lines.");'
+  - text: Функция <code>wrap</code> должна возвращать ожидаемый текст
+    testString: 'assert.equal(wrapped80.split("\n")[0], firstRow80, "Your <code>wrap</code> function should return our expected text");'
+  - text: wrap (42) должен возвращать 7 строк.
+    testString: 'assert(wrapped42.split("\n").length === 7, "wrap(42) must return 7 lines.");'
+  - text: Функция <code>wrap</code> должна возвращать ожидаемый текст
+    testString: 'assert.equal(wrapped42.split("\n")[0], firstRow42, "Your <code>wrap</code> function should return our expected text");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function wrap (text, limit) {
+  return text;
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/y-combinator.russian.md

@@ -0,0 +1,78 @@
+---
+title: Y combinator
+id: 594810f028c0303b75339ad5
+challengeType: 5
+videoUrl: ''
+localeTitle: И комбинатор
+---
+
+## Description
+<section id="description"><p> В строгом <a href="https://en.wikipedia.org/wiki/Functional programming" title="wp: функциональное программирование">функциональном программировании</a> и <a href="https://en.wikipedia.org/wiki/lambda calculus" title="wp: лямбда-исчисление">исчислении лямбда</a> функции (лямбда-выражения) не имеют состояния и могут быть разрешены только к аргументам включенных функций. Это исключает обычное определение рекурсивной функции, в которой функция связана с состоянием переменной, и состояние этой переменной используется в теле функции. </p><p> <a href="http://mvanier.livejournal.com/2897.html">Комбинатор Y</a> сам по себе является функцией без состояния, которая при применении к другой функции без сохранения возвращает рекурсивную версию функции. Комбинатор Y является простейшим из класса таких функций, называемых <a href="https://en.wikipedia.org/wiki/Fixed-point combinator" title="wp: комбинатор с фиксированной запятой">комбинаторами с фиксированной запятой</a> . </p> Задача: <pre> <code>Define the stateless Y combinator function and use it to compute &lt;a href=&quot;https://en.wikipedia.org/wiki/Factorial&quot; title=&quot;wp: factorial&quot;&gt;factorial&lt;/a&gt;.</code> </pre><p> Функция <code>factorial(N)</code> уже предоставлена ​​вам. См. Также <a href="http://vimeo.com/45140590">Джим Вейрих: Приключения в функциональном программировании</a> . </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: Y должен возвращать функцию
+    testString: 'assert.equal(typeof Y(f => n => n), "function", "Y must return a function");'
+  - text: factorial (1) должен возвращать 1.
+    testString: 'assert.equal(factorial(1), 1, "factorial(1) must return 1.");'
+  - text: factorial (2) должен вернуть 2.
+    testString: 'assert.equal(factorial(2), 2, "factorial(2) must return 2.");'
+  - text: факториал (3) должен возвращать 6.
+    testString: 'assert.equal(factorial(3), 6, "factorial(3) must return 6.");'
+  - text: факториал (4) должен возвращать 24.
+    testString: 'assert.equal(factorial(4), 24, "factorial(4) must return 24.");'
+  - text: factorial (10) должен вернуть 3628800.
+    testString: 'assert.equal(factorial(10), 3628800, "factorial(10) must return 3628800.");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function Y(f) {
+  return function() {
+  // Good luck!
+  };
+}
+
+var factorial = Y(function(f) {
+  return function (n) {
+    return n > 1 ? n * f(n - 1) : 1;
+  };
+});
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/zeckendorf-number-representation.russian.md

@@ -0,0 +1,62 @@
+---
+title: Zeckendorf number representation
+id: 594810f028c0303b75339ad6
+challengeType: 5
+videoUrl: ''
+localeTitle: Отметить номер деревни
+---
+
+## Description
+<section id="description"><p> Подобно тому, как числа могут быть представлены в позиционной нотации как суммы кратных степеням десяти (десятичных) или двух (двоичных); все положительные целые числа могут быть представлены в виде суммы одного или нулевого числа отдельных членов ряда Фибоначчи. </p><p> Напомним, что первые шесть различных чисел Фибоначчи: <code>1, 2, 3, 5, 8, 13</code> . Десятичное число одиннадцать может быть записано как <code>0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1</code> или <code>010100</code> в позиционной нотации, где столбцы представляют собой умножение на определенный член последовательности. Ведущие нули отбрасываются так, что 11 десятичных знаков становятся <code>10100</code> . </p><p> 10100 - не единственный способ сделать 11 из чисел Фибоначчи, однако <code>0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1</code> или 010011 также будет представлять десятичную 11. Для истинного числа Зеекендорфа существует дополнительное ограничение, что «нельзя использовать два последовательных числа Фибоначчи», что приводит к первому уникальному решению. </p><p> Задача: Напишите функцию, которая генерирует и возвращает массив первых чисел N Zeckendorf по порядку. </p></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: zeckendorf должен функционировать
+    testString: 'assert.equal(typeof zeckendorf, "function", "zeckendorf must be function");'
+  - text: Ваша функция <code>zeckendorf</code> должна вернуть правильный ответ
+    testString: 'assert.deepEqual(answer, solution20, "Your <code>zeckendorf</code> function should return the correct answer");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function zeckendorf(n) {
+  // good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.russian.md

@@ -0,0 +1,136 @@
+---
+title: Zhang-Suen thinning algorithm
+id: 594810f028c0303b75339ad7
+challengeType: 5
+videoUrl: ''
+localeTitle: Алгоритм прореживания Чжан-Суен
+---
+
+## Description
+<section id="description"> Это алгоритм, используемый для тонкого черно-белого изображения, т.е. одного бита на пиксель. Например, с входным изображением: <pre> ###############################
+ #####################################
+ #########################################################################
+ ######## ############################
+   ###### ####### ####### ######
+   ###### ####### #######
+   #########################
+   ########################
+   #########################
+   ###### ####### #######
+   ###### ####### #######
+   ###### ####### ####### ######
+ ######## ############################
+ ######## ##################################################################################
+ ############### #############################
+ ######## ####### ###########################
+                                                           </pre> Он производит утонченный выход: <pre>
+<pre> <code># ########## ####### ## # #### # # # ## # # # # # # # # # ############ # # # # # # # # # # # # # # ## # ############ ### ### &lt;/pre&gt;</code> </pre>
+<h2> Алгоритм </h2>
+Предположим, что черные пиксели имеют один и белый пиксели нуль, а входное изображение представляет собой прямоугольный массив N по M из единиц и нулей.
+Алгоритм работает со всеми черными пикселями P1, которые могут иметь восемь соседей. Соседи упорядочены как:
+<table border="1">
+  <tbody><tr><td> P9 </td><td> P2 </td><td> P3 </td></tr>
+  <tr><td> P8 </td><td> <b>P1</b> </td><td> P4 </td></tr>
+  <tr><td> P7 </td><td> P6 </td><td> P5 </td></tr>
+</tbody></table>
+Очевидно, что граничные пиксели изображения не могут иметь всех восьми соседей.
+<pre> <code>Define $A(P1)$ = the number of transitions from white to black, (0 -&gt; 1) in the sequence P2,P3,P4,P5,P6,P7,P8,P9,P2. (Note the extra P2 at the end - it is circular). Define $B(P1)$ = the number of black pixel neighbours of P1. ( = sum(P2 .. P9) )</code> </pre>
+<h3> Шаг 1: </h3>
+Все пиксели тестируются, и пиксели, удовлетворяющие всем следующим условиям (одновременно), просто отмечены на этом этапе.
+  (0) пиксель черный и имеет восемь соседей
+  (1) $ 2 &lt;= B (P1) &lt;= 6 $
+  (2) $ A (P1) = 1 $
+  (3) По крайней мере один из P2 и P4 и P6 является белым
+  (4) По крайней мере один из P4 и P6 и P8 является белым
+После повторения изображения и сбора всех пикселей, удовлетворяющих всем условиям шага 1, все эти условия, удовлетворяющие пикселям, устанавливаются в белый цвет.
+<h3> Шаг 2: </h3>
+Все пиксели снова протестированы, и пиксели, удовлетворяющие всем следующим условиям, просто отмечены на этом этапе.
+  (0) пиксель черный и имеет восемь соседей
+  (1) $ 2 &lt;= B (P1) &lt;= 6 $
+  (2) $ A (P1) = 1 $
+  (3) По меньшей мере один из P2 и P4 и «P8» является белым
+  (4) По крайней мере один из «P2» и P6 и P8 является белым
+После повторения изображения и сбора всех пикселей, удовлетворяющих всем условиям шага 2, все эти условия, удовлетворяющие пикселям, снова устанавливаются в белый цвет.
+Итерация:
+Если в этом раунде любого шага 1 или шага 2 были установлены какие-либо пиксели, все этапы повторяются до тех пор, пока пиксели изображения не будут изменены.
+<p>
+Задача:
+Напишите рутину, чтобы прореживать Чжан-Суен на матрице изображений единиц и нулей.
+</p>
+</pre></section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: <code>thinImage</code> должна быть функцией
+    testString: 'assert.equal(typeof thinImage, "function", "<code>thinImage</code> must be a function");'
+  - text: <code>thinImage</code> должен возвращать массив
+    testString: 'assert(Array.isArray(result), "<code>thinImage</code> must return an array");'
+  - text: <code>thinImage</code> должен возвращать массив строк
+    testString: 'assert.equal(typeof result[0], "string", "<code>thinImage</code> must return an array of strings");'
+  - text: <code>thinImage</code> должен возвращать массив строк
+    testString: 'assert.deepEqual(result, expected, "<code>thinImage</code> must return an array of strings");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+const testImage = [
+  '                                                          ',
+  ' #################                   #############        ',
+  ' ##################               ################        ',
+  ' ###################            ##################        ',
+  ' ########     #######          ###################        ',
+  '   ######     #######         #######       ######        ',
+  '   ######     #######        #######                      ',
+  '   #################         #######                      ',
+  '   ################          #######                      ',
+  '   #################         #######                      ',
+  '   ######     #######        #######                      ',
+  '   ######     #######        #######                      ',
+  '   ######     #######         #######       ######        ',
+  ' ########     #######          ###################        ',
+  ' ########     ####### ######    ################## ###### ',
+  ' ########     ####### ######      ################ ###### ',
+  ' ########     ####### ######         ############# ###### ',
+  '                                                          '];
+
+function thinImage(image) {
+  // Good luck!
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>

curriculum/challenges/russian/08-coding-interview-prep/rosetta-code/zig-zag-matrix.russian.md

@@ -0,0 +1,76 @@
+---
+title: Zig-zag matrix
+id: 594810f028c0303b75339ad8
+challengeType: 5
+videoUrl: ''
+localeTitle: Зигзагообразная матрица
+---
+
+## Description
+<section id="description"> Массив «зиг-зага» квадратное расположение первого $ N ^ 2 $, где целых число увеличения последовательно , как вы зигзагообразный вдоль массива <a href="https://en.wiktionary.org/wiki/antidiagonal">анти-диагоналей</a> . Например, с учетом «5», создайте этот массив: <pre> 0 1 5 6 14
+ 2 4 7 13 15
+ 3 8 12 16 21
+ 9 11 17 20 22
+10 18 19 23 24
+</pre> Напишите функцию, которая принимает размер матрицы зигзага, и возвращает соответствующую матрицу в виде двумерного массива. </section>
+
+## Instructions
+<section id="instructions">
+</section>
+
+## Tests
+<section id='tests'>
+
+```yml
+tests:
+  - text: ZigZagMatrix должна быть функцией
+    testString: 'assert.equal(typeof ZigZagMatrix, "function", "ZigZagMatrix must be a function");'
+  - text: ZigZagMatrix должен возвращать массив
+    testString: 'assert.equal(typeof ZigZagMatrix(1), "object", "ZigZagMatrix should return array");'
+  - text: ZigZagMatrix должен возвращать массив массивов гнезд
+    testString: 'assert.equal(typeof ZigZagMatrix(1)[0], "object", "ZigZagMatrix should return an array of nestes arrays");'
+  - text: 'ZigZagMatrix (1) должен возвращать [[0]]'
+    testString: 'assert.deepEqual(ZigZagMatrix(1), zm1, "ZigZagMatrix(1) should return [[0]]");'
+  - text: 'ZigZagMatrix (2) должен возвращать [[0, 1], [2, 3]]'
+    testString: 'assert.deepEqual(ZigZagMatrix(2), zm2, "ZigZagMatrix(2) should return [[0, 1], [2, 3]]");'
+  - text: ZigZagMatrix (5) должен возвращать заданную матрицу
+    testString: 'assert.deepEqual(ZigZagMatrix(5), zm5, "ZigZagMatrix(5) must return specified matrix");'
+
+```
+
+</section>
+
+## Challenge Seed
+<section id='challengeSeed'>
+
+<div id='js-seed'>
+
+```js
+function ZigZagMatrix(n) {
+  // Good luck!
+  return [[], []];
+}
+
+```
+
+</div>
+
+
+### After Test
+<div id='js-teardown'>
+
+```js
+console.info('after the test');
+```
+
+</div>
+
+</section>
+
+## Solution
+<section id='solution'>
+
+```js
+// solution required
+```
+</section>