<section id="description">
 Есть 100 дверей подряд, все изначально закрыты. Вы делаете 100 проходов у дверей. В первый раз, зайдите в каждую дверь и «переключите» дверь (если дверь закрыта, откройте ее, если она открыта, закройте ее). Во второй раз заходите только к каждой второй двери (т. Е. К двери №2, №4, №6, ...) и переключите ее. В третий раз посетите каждую 3-ю дверь (т. Е. Дверь № 3, №6, №9, ...) и т. Д., Пока вы не посетите только 100-ю дверь. Внедрите функцию определения состояния дверей после последнего прохода. Верните конечный результат в массив, только если номер двери включен в массив, если он открыт. 
</section>

100 doors

<section id="description">
 Вам предоставляется коллекция блоков ABC (например, блоков алфавита детства). На каждом блоке есть 20 блоков с двумя буквами. На всех сторонах блоков гарантируется полный алфавит. Сбор образцов блоков: (БО) (КСК) (DQ) (CP) (НС) (GT) (RE) (ТГ) (КТ) (ФС) (ДВ) (HU) (VI) (AN) (ОВ) (ЭР) (ФС) (LY) (ПК) (ЗМ) Некоторые правила, которые следует учитывать: 
 Когда используется буква на блоке, этот блок нельзя использовать снова. Функция должна быть нечувствительна к регистру. Реализуйте функцию, которая принимает строку (слово) и определяет, может ли слово быть записано с данным набором блоков. 
</section>

ABC Problem

<section id="description">
 Они определяют три классификации положительных целых чисел на основе их <a href="http://rosettacode.org/wiki/Proper divisors" title="Собственные делители">правильных делителей</a> . Пусть $ P (n) $ - сумма собственных делителей n, где собственные делители - все натуральные n, отличные от n. Если <code>P(n) &#x3C; n</code> то n классифицируется как «несовершенный», Если <code>P(n) === n</code> то n классифицируется как "совершенный" Если <code>P(n) > n</code> то n классифицируется как "обильное" Пример: 6 имеет собственные делители 1, 2 и 3. 1 + 2 + 3 = 6, поэтому 6 классифицируется как совершенное число. Внедрите функцию, которая вычисляет, сколько целых чисел от 1 до 20 000 (включительно) находятся в каждом из трех классов. Выведите результат как массив в следующем формате <code>[deficient, perfect, abundant]</code> . 
</section>

Abundant, deficient and perfect number classifications

<section id="description">
 Создайте функцию, которая принимает один (числовой) аргумент и возвращает другую функцию, которая является аккумулятором. Возвращенная функция аккумулятора, в свою очередь, также принимает один числовой аргумент и возвращает сумму всех числовых значений, переданных до этого аккумулятора (включая начальное значение, переданное при создании аккумулятора). Правила: Не используйте глобальные переменные. Подсказка: Закрытие сохраняет внешнее состояние. 
</section>

Accumulator factory

<section id="description">
 Функция Аккермана является классическим примером рекурсивной функции, особенно потому, что она не является примитивной рекурсивной функцией. Он растет очень быстро в стоимости, равно как и размер его дерева вызовов. Функция Аккермана обычно определяется следующим образом: 
 $$ A (m, n) = \ begin {cases} n + 1 &#x26; \ mbox {if} m = 0 \\ A (m-1, 1) &#x26; \ mbox {if} m> 0 \ mbox {и} n = 0 \\ A (m-1, A (m, n-1)) &#x26; \ mbox {if} m> 0 \ mbox {и} n> 0. \ end {cases} $$ Его аргументы никогда не отрицательны и всегда заканчиваются. Напишите функцию, которая возвращает значение $ A (m, n) $. Произвольная точность предпочтительнее (поскольку функция растет так быстро), но не требуется. 
</section>

Ackermann function

<section id="description">
 Учитывая текстовый файл многих строк, где поля в строке обозначаются одним символом <code>$</code> , напишите программу, которая выравнивает каждый столбец полей, гарантируя, что слова в каждом столбце разделены хотя бы одним пробелом. Кроме того, разрешите каждое слово в столбце быть либо оправданным, либо оправданным, либо оправданным по центру в его столбце. Используйте следующий текст для тестирования своих программ: <pre> Учитывая $ в $ текста $ файл $ из $ многих $ линий
где $ поля $ в $ а $ линия $
составляют $ очерчены $ на $ «доллар» в размере $ одноместный $ символа $
написать $ в $ программе
что $ совпадет $ каждый $ столбец $ из $ полей
от $ обеспечения $, что $ слова $ в $ каждый $
колонка $ являются $ $ разделены на $ по $ мере $ за $ пространство.
Кроме того, $ позволяют $ за $ каждого $ слова $ в $ A $ столбец $ до $ быть $ либо $ остался $
оправданный, $ права $ оправдано
или $ центр $ оправдана $ в $ его $ колонке.
</pre> Обратите внимание, что: 
 Примеры строк ввода текста могут или не могут иметь завершающие символы доллара. Все столбцы должны иметь одинаковое выравнивание. Последовательные символы пробела, создаваемые рядом с концом строк, несущественны для целей задачи. Текст вывода будет отображаться моноширинным шрифтом в текстовом редакторе или базовом терминале. Минимальное пространство между столбцами должно быть вычислено из текста, а не жестко закодировано. Не требуется добавлять разделительные символы между столбцами или вокруг них.</section>

Align columns

<section id="description">
 Счастливое число определяется следующим процессом: Начиная с любого положительного целого числа, замените число на сумму квадратов его цифр и повторите процесс до тех пор, пока число не будет равно 1 (где оно останется), или оно бесконечно завершается в цикле, который не включает в себя 1. Эти цифры для которых этот процесс заканчивается на 1, являются счастливыми номерами, а те, которые не заканчиваются на 1, - это несчастливые цифры. Реализуйте функцию, которая возвращает true, если число счастливое, или false, если нет. 
</section>

Happy numbers

<section id="description">
Вектор определяется как имеющий три измерения как представленный упорядоченным набором из трех чисел: (X, Y, Z). Задача: <pre> <code>Write a function that takes two vectors (arrays) as input and computes their cross product.</code> </pre> Ваша функция должна возвращать значение <code>null</code> на недопустимые входы (т. Е. Векторы разной длины). 
</section>

Vector cross product

<section id="description">
 Вектор определяется как имеющий три измерения как представленный упорядоченным набором из трех чисел: (X, Y, Z). Задача: <pre> <code>Write a function that takes any numbers of vectors (arrays) as input and computes their dot product.</code> </pre> Ваша функция должна возвращать значение <code>null</code> на недопустимые входы (т. Е. Векторы разной длины). 
</section>

Vector dot product

<section id="description">
 Даже сегодня, с пропорциональными шрифтами и сложными макетами, все еще есть случаи, когда вам нужно обернуть текст в указанном столбце. Основная задача - обтекание абзаца текста простым способом. Пример текста: <pre> Оберните текст, используя более сложный алгоритм, такой как алгоритм Knuth и Plass TeX.
Если ваш язык предоставляет это, вы получаете легкий дополнительный кредит,
но вы «должны ссылаться на документацию», указывая на то, что алгоритм
что-то лучше, чем простой алгоритм минимальной длины.
</pre> Задача: <pre> <code>Write a function that can wrap this text to any number of characters.</code> </pre> Например, текст, состоящий из 80 символов, должен выглядеть следующим образом: <pre> Оберните текст, используя более сложный алгоритм, такой как Knuth и Plass TeX
алгоритм. Если ваш язык предоставляет это, вы получаете легкий дополнительный кредит, но вы
должен ссылаться на документацию, указывающую, что алгоритм лучше чем
чем простой алгоритм минимальной длины.
</pre>
</section>

Word wrap

<section id="description">
 В строгом <a href="https://en.wikipedia.org/wiki/Functional programming" title="wp: функциональное программирование">функциональном программировании</a> и <a href="https://en.wikipedia.org/wiki/lambda calculus" title="wp: лямбда-исчисление">исчислении лямбда</a> функции (лямбда-выражения) не имеют состояния и могут быть разрешены только к аргументам включенных функций. Это исключает обычное определение рекурсивной функции, в которой функция связана с состоянием переменной, и состояние этой переменной используется в теле функции. <a href="http://mvanier.livejournal.com/2897.html">Комбинатор Y</a> сам по себе является функцией без состояния, которая при применении к другой функции без сохранения возвращает рекурсивную версию функции. Комбинатор Y является простейшим из класса таких функций, называемых <a href="https://en.wikipedia.org/wiki/Fixed-point combinator" title="wp: комбинатор с фиксированной запятой">комбинаторами с фиксированной запятой</a> . 
 Задача: <pre> <code>Define the stateless Y combinator function and use it to compute &#x3C;a href="https://en.wikipedia.org/wiki/Factorial" title="wp: factorial">factorial&#x3C;/a>.</code> </pre> Функция <code>factorial(N)</code> уже предоставлена ​​вам. См. Также <a href="http://vimeo.com/45140590">Джим Вейрих: Приключения в функциональном программировании</a> . 
</section>

Y combinator

<section id="description">
 Подобно тому, как числа могут быть представлены в позиционной нотации как суммы кратных степеням десяти (десятичных) или двух (двоичных); все положительные целые числа могут быть представлены в виде суммы одного или нулевого числа отдельных членов ряда Фибоначчи. Напомним, что первые шесть различных чисел Фибоначчи: <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> . 10100 - не единственный способ сделать 11 из чисел Фибоначчи, однако <code>0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1</code> или 010011 также будет представлять десятичную 11. Для истинного числа Зеекендорфа существует дополнительное ограничение, что «нельзя использовать два последовательных числа Фибоначчи», что приводит к первому уникальному решению. Задача: Напишите функцию, которая генерирует и возвращает массив первых чисел N Zeckendorf по порядку. 
</section>

Zeckendorf number representation

<section id="description">
Это алгоритм, используемый для тонкого черно-белого изображения, т.е. одного бита на пиксель. Например, с входным изображением: <pre> ###############################
 #####################################
 #########################################################################
 ######## ############################
 ###### ####### ####### ######
 ###### ####### #######
 #########################
 ########################
 #########################
 ###### ####### #######
 ###### ####### #######
 ###### ####### ####### ######
 ######## ############################
 ######## ##################################################################################
 ############### #############################
 ######## ####### ###########################
 </pre> Он производит утонченный выход: <pre><pre> <code># ########## ####### ## # #### # # # ## # # # # # # # # # ############ # # # # # # # # # # # # # # ## # ############ ### ### &#x3C;/pre></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> P1 </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 -> 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 &#x3C;= B (P1) &#x3C;= 6 $
 (2) $ A (P1) = 1 $
 (3) По крайней мере один из P2 и P4 и P6 является белым
 (4) По крайней мере один из P4 и P6 и P8 является белым
После повторения изображения и сбора всех пикселей, удовлетворяющих всем условиям шага 1, все эти условия, удовлетворяющие пикселям, устанавливаются в белый цвет.
<h3> Шаг 2: </h3>
Все пиксели снова протестированы, и пиксели, удовлетворяющие всем следующим условиям, просто отмечены на этом этапе.
 (0) пиксель черный и имеет восемь соседей
 (1) $ 2 &#x3C;= B (P1) &#x3C;= 6 $
 (2) $ A (P1) = 1 $
 (3) По меньшей мере один из P2 и P4 и «P8» является белым
 (4) По крайней мере один из «P2» и P6 и P8 является белым
После повторения изображения и сбора всех пикселей, удовлетворяющих всем условиям шага 2, все эти условия, удовлетворяющие пикселям, снова устанавливаются в белый цвет.
Итерация:
Если в этом раунде любого шага 1 или шага 2 были установлены какие-либо пиксели, все этапы повторяются до тех пор, пока пиксели изображения не будут изменены.

Задача:
Напишите рутину, чтобы прореживать Чжан-Суен на матрице изображений единиц и нулей.

</pre>
</section>

Zhang-Suen thinning algorithm

<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>

Zig-zag matrix

<section id="description">
 Эта задача - вариация <a href="https://en.wikipedia.org/wiki/The Nine Billion Names of God#Plot_summary" title="wp: Девять миллиардов имен Бога # Plot_summary">рассказа Артура Кларка</a> . (Решители должны знать о последствиях выполнения этой задачи.) Подробно, чтобы указать, что подразумевается под «именем»: Целое число 1 имеет 1 имя «1». Целое число 2 имеет 2 имени «1 + 1» и «2». Целое число 3 имеет 3 имени «1 + 1 + 1», «2 + 1» и «3». Целое число 4 имеет 5 имен «1 + 1 + 1 + 1», «2 + 1 + 1», «2 + 2», «3 + 1», «4». Целое число 5 имеет 7 имен «1 + 1 + 1 + 1 + 1», «2 + 1 + 1 + 1», «2 + 2 + 1», «3 + 1 + 1», «3 + 2», «4 + 1», «5». Это можно визуализировать в следующем виде: <pre> 1
 1 1
 1 1 1
 1 2 1 1
 1 2 2 1 1
1 3 3 2 1 1
</pre> Где строка $ n $ соответствует целому числу $ n $, а каждый столбец $ C $ в строке $ m $ слева направо соответствует числу имен, начинающихся с $ C $. Необязательно заметим, что сумма $ n $ -ой строки $ P (n) $ является <a href="http://mathworld.wolfram.com/PartitionFunctionP.html" title="ссылка: http://mathworld.wolfram.com/PartitionFunctionP.html">целочисленной статистикой</a> . 
 задача Реализуйте функцию, которая возвращает сумму $ n $ -ой строки. 
</section>

9 billion names of God the integer

<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>

Amicable pairs

<section id="description">
 Напишите программу , чтобы найти <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: Режим (статистика)">режим</a> значение коллекции. Случай, когда коллекция пуст, может быть проигнорирован. Необходимо следить за тем, чтобы режим не был уникальным. Если это не подходит или возможно поддерживать общую коллекцию, используйте вектор (массив), если это возможно. Если это не подходит или возможно поддерживать неопределенный тип значения, используйте целые числа. 
</section>

Averages/Mode

<section id="description">
 Вычислите все три <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/Pythagorean means" title="wp: Пифагорейский означает">пифагорейских средства</a> набора целых чисел от <big>1</big> до <big>10</big> (включительно). Покажите, что для этого набора натуральных чисел <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> . 
 Наиболее распространенным из трех означает <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> Предположим, что вход представляет собой упорядоченный массив всех включенных чисел. Для ответа, пожалуйста, выведите объект в следующем формате: <pre class="rosetta__pre"> {
 значения: {
 Арифметика: 5.5,
 Геометрический: 4.528728688116765,
 Гармонический: 3.414171521474055
 },
 test: 'является A> = G> = H? да'
}
</pre>
</section>

Averages/Pythagorean means

<section id="description">
 Вычислите <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: средний квадрат корня">средний квадрат корня</a> чисел от 1 до 10 включительно. Корневой средний квадрат также известен по его инициалам RMS (или rms) и как квадратичное среднее. RMS рассчитывается как среднее из квадратов чисел, с квадратным корнем: <big>$$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $$</big> 
</section>

Averages/Root mean square

<section id="description">
 <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Чарльз Бэббидж</a> , смотрящий вперед на те проблемы, которые мог бы решить его аналитический движок, привел этот пример: <blockquote> Какое наименьшее положительное целое число, квадрат которого заканчивается цифрами 269 696? </blockquote> - Бэббидж, письмо лорду Боудену, 1837 год; см. Hollingdale and Tootill, Electronic Computers , второе издание, 1970, с. 125. Он думал, что ответ может быть 99 736, чья площадь составляет 9 947 269 696; но он не мог быть уверен. Задача состоит в том, чтобы выяснить, есть ли у Бэббиджа правильный ответ. Реализуйте функцию, чтобы вернуть наименьшее целое число, удовлетворяющее задаче Бэббиджа. Если Бэббидж был прав, верните номер Бэббиджа. 
</section>

Babbage problem

<section id="description">
 Определите, сбалансирована ли сгенерированная строка скобок; то есть, состоит ли он целиком из пар открывающих / закрывающих скобок (в этом порядке), ни одно из которых не выполняется. 
 Примеры: (пусто) true <code>[]</code> true <code>][</code> false <code>[][]</code> true <code>][][</code> false <code>[]][[]</code> false <code>[[[[]]]]</code> true 
</section>

Balanced brackets

<section id="description">
Номер <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: номер Харди-Рамануджана">такси</a> (определение, которое используется здесь) является положительным целым числом, которое может быть выражено как сумма двух положительных кубов более чем одним способом. Первый номер такси составляет 1729, что составляет: 1 3 + 12 3 и 9 3 + 10 3 . Номера такси также известны как: * номера такси * номера такси-такси * номера такси * номера 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>

Taxicab numbers

<section id="description">
 Учитывая сопоставление между элементами и элементами, на которых они зависят, <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">топологические</a> позиции <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">сортировки сортируются,</a> так что ни один элемент не предшествует элементу, от которого он зависит. Компиляция библиотеки на языке <a href="https://en.wikipedia.org/wiki/VHDL" title="wp: VHDL">VHDL</a> имеет ограничение на то, что библиотека должна быть скомпилирована после любой библиотеки, от которой она зависит. 
 Задача: Напишите функцию, которая вернет действительный порядок компиляции библиотек VHDL из их зависимостей. 
 Предположим, что имена библиотек - это одиночные слова. Пункты, упомянутые как только иждивенцы, не имеют собственных иждивенцев, но их порядок компиляции должен быть дан. Любые собственные зависимости следует игнорировать. Любые неустановимые зависимости следует игнорировать. В качестве примера используйте следующие данные: <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> Примечание: вышеуказанные данные были бы неустановимыми, если, например, <code>dw04</code> добавляется в список зависимостей <code>dw01</code> . 
 Cf: <pre> <code>&#x3C;a href="http://rosettacode.org/wiki/Topological sort/Extracted top item" title="Topological sort/Extracted top item">Topological sort/Extracted top item&#x3C;/a>.</code> </pre> Существует два популярных алгоритма топологической сортировки: Канский топологический сорт 1962 года и поиск по глубине: <a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: топологическая сортировка">топологическая сортировка</a> Джейсон Сакс: <a href="http://www.embeddedrelated.com/showarticle/799.php" title="ссылка: http://www.embeddedrelated.com/showarticle/799.php">«Десять небольших алгоритмов, часть 4: топологическая сортировка»</a> . 
</section>

Topological sort

<section id="description">
 Напишите функцию или программу, которые могут разбивать строку на каждое неэкранированное вхождение символа разделителя. Он должен принимать три входных параметра: 
 Строка Символ разделителя Управляющий символ Он должен вывести список строк. Правила разделения: 
 Поля, разделенные разделителями, становятся элементами выходного списка. Пустые поля должны быть сохранены, даже в начале и в конце. Правила побега: 
 «Escaped» означает, что предшествует появление escape-символа, который еще не сбежал. Когда escape-символ предшествует персонажу, который не имеет особого значения, он по-прежнему считается побегом (но не делает ничего особенного). Каждое появление escape-символа, которое использовалось для выхода из него, не должно становиться частью выхода. Продемонстрируйте, что ваша функция удовлетворяет следующему тестовому сценарию: заданная строка <pre> один ^ | у || три ^^^^ | четыре ^^^ | ^ куатро | </pre> и использование <pre> | </pre> как разделитель и <pre> ^ </pre> как escape-символ, ваша функция должна выводить следующий массив: <pre> ['one | uno', ", 'three ^^', 'four ^ | quatro',"]
 </pre>
</section>

Tokenize a string with escaping

<section id="description">
Задача: Найдите верхние N ранжированных данных в каждой группе, где N предоставляется в качестве параметра. В качестве параметра также указывается имя ранга и группы. 
 Учитывая следующие данные: <pre> [
 {имя: 'Tyler Bennett', id: 'E10297', зарплата: 32000, отдел: 'D101'},
 {name: 'John Rappl', id: 'E21437', зарплата: 47000, отдел: 'D050'},
 {имя: 'George Woltman', id: 'E00127', зарплата: 53500, отдел: 'D101'},
 {name: 'Adam Smith', id: 'E63535', зарплата: 18000, отдел: 'D202'},
 {имя: 'Claire Buckman', id: 'E39876', зарплата: 27800, отдел: 'D202'},
 {имя: 'David McClellan', id: 'E04242', зарплата: 41500, отдел: 'D101'},
 {name: 'Rich Holcomb', id: 'E01234', зарплата: 49500, отдел: 'D202'},
 {имя: 'Nathan Adams', id: 'E41298', зарплата: 21900, отдел: 'D050'},
 {name: 'Richard Potter', id: 'E43128', зарплата: 15900, отдел: 'D101'},
 {имя: 'David Motsinger', id: 'E27002', зарплата: 19250, отдел: 'D202'},
 {имя: 'Tim Sampair', id: 'E03033', зарплата: 27000, отдел: 'D101'},
 {name: 'Kim Arlich', id: 'E10001', зарплата: 57000, отдел: 'D190'},
 {name: 'Timothy Grove', id: 'E16398', зарплата: 29900, отдел: 'D190'}
];
</pre> в каждом отделе можно было бы <code>topRankPerGroup(10, data, 'dept', 'salary')</code> лучших сотрудников, позвонив <code>topRankPerGroup(10, data, 'dept', 'salary')</code> Учитывая следующие данные: <pre> [
 {name: 'Friday 13th', жанр: 'horror', рейтинг: 9.9},
 {name: «Кошмар на улице Вязов», жанр: «ужас», рейтинг: 5.7},
 {name: «Титаник», жанр: «драма», рейтинг: 7.3},
 {name: 'Maze Runner', жанр: 'scifi', рейтинг: 7.1},
 {name: 'Blade runner', жанр: 'scifi', рейтинг: 8.9}
];
</pre> можно <code>topRankPerGroup(1, data, 'genre', 'rating')</code> рейтинг фильма с самым высоким рейтингом в каждом жанре, назвав <code>topRankPerGroup(1, data, 'genre', 'rating')</code>
</section>

Top rank per group

<section id="description">
 Учитывая две точки на плоскости и радиус, обычно через две точки могут быть проведены два круга заданного радиуса. 
 Исключения: радиус нуля должен рассматриваться как никогда не описывающий круги (за исключением случая, когда точки совпадают). Если точки совпадают, то может быть проведено бесконечное число кругов с точкой на их окружности, если радиус не равен нулю, а затем сворачивает круги в точку. Если точки образуют диаметр, верните один круг. Если точки слишком далеки друг от друга, круги не могут быть нарисованы. Задача: выполнить функцию, которая принимает две точки и радиус и возвращает два круга через эти точки. Для каждого результирующего круга укажите координаты для центра каждого круга, округленного до четырех десятичных цифр. Возвращает каждую координату в виде массива и координирует ее как массив массивов. Для краевых случаев возвращайте следующее: если точки находятся на диаметре, верните одну точку. Если радиус также равен нулю, верните <code>"Radius Zero"</code> . Если точки совпадают, верните <code>"Coincident point. Infinite solutions"</code> . Если точки находятся дальше друг от друга, чем диаметр, верните <code>"No intersection. Points further apart than circle diameter"</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>

Circles of given radius through two points

<section id="description">
Задача: Предоставить функцию для поиска ближайших двух точек среди множества заданных точек в двух измерениях, т. <a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: Ближайшая проблема с двумя точками">Е. Решить задачу Ближайшей пары точек</a> в плоском случае. Прямым решением является алгоритм O (n 2 ) (который мы можем назвать алгоритмом грубой силы); псевдокод (с использованием индексов) может быть простым: <pre> bruteForceClosestPair из P (1), P (2), ... P (N)
если N &#x3C;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) | &#x3C;minDistance тогда
 minDistance ← | P (i) - P (j) |
 minPoints ← {P (i), P (j)}
 ENDIF
 ENDFOR
 ENDFOR
 return minDistance, minPoints
ENDIF
</pre> Лучший алгоритм основан на подходе рекурсивного разделения и покорения, как это объясняется также в <a href="https://en.wikipedia.org/wiki/Closest pair of points problem#Planar_case" title="wp: Ближайшая проблема с двумя точками # Planar_case">самой близкой проблеме точек Википедии</a> , которая является O (n log n); псевдокод может быть: <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⌉) x
 yL ← {p ∈ yP: p x ≤ xm}
 yR ← {p ∈ yP: p x > xm}
 (dL, pairL) ← ближайшая пара (xL, yL)
 (dR, pairR) ← ближайшая пара (xR, yR)
 (dmin, pairMin) ← (dR, pairR)
 если dL &#x3C;dR, тогда
 (dmin, pairMin) ← (dL, pairL)
 ENDIF
 yS ← {p ∈ yP: | xm - p x | &#x3C;dmin}
 nS ← число точек в yS
 (ближайший, ближайший) ← (dmin, pairMin)
 для i от 1 до nS - 1
 k ← i + 1
 в то время как k ≤ nS и yS (k) y - yS (i) y &#x3C;dmin
 если | yS (k) - yS (i) | &#x3C;ближе
 (ближайший ближайший 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> Для ввода предположим, что аргумент представляет собой массив объектов (точек) с элементами <code>x</code> и <code>y</code> установленными в числа. Для вывода возвращаем объект, содержащий пары ключ: значение для <code>distance</code> и <code>pair</code> (т. Е. Пару из двух ближайших точек). 
</section>

Closest-pair problem

<section id="description">
 Реализуйте функцию, которая принимает в качестве аргумента строку из четырех цифр: каждая цифра от 1 ──► 9 (включительно) с разрешенными повторениями и возвращает арифметическое выражение, которое оценивается с номером 24. Если такого решения не существует, не существует никакого решения ». Правила: 
 Допускаются только следующие операторы / функции: умножение, деление, сложение, вычитание. Отдел должен использовать с плавающей точкой или рациональную арифметику и т. Д. Для сохранения остатков. Формирование нескольких цифр из предоставленных цифр не разрешено. (Таким образом, ответ 12 + 12 при наличии 1, 2, 2 и 1 неверен). Порядок цифр, когда они указаны, не обязательно сохраняется. Пример ввода: 
 <code>solve24("4878");</code> <code>solve24("1234");</code> <code>solve24("6789");</code> <code>solve24("1127");</code> Пример выходов (строк): 
 <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>

24 game

<section id="description">
Задача: Решите проблему <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: Towers_of_Hanoi">Башни Ханоя</a> . Ваше решение должно принять количество дисков в качестве первых параметров и три строки, используемые для идентификации каждого из трех стеков дисков, например <code>towerOfHanoi(4, 'A', 'B', 'C')</code> . Функция должна возвращать массив массивов, содержащий список ходов, source -> destination. Например, массив <code>[['A', 'C'], ['B', 'A']]</code> указывает, что 1-й ход состоял в том, чтобы переместить диск из стека A в C, а второй шаг состоял в том, чтобы переместить диск из стека B в A. 
</section>

Towers of Hanoi

<section id="description">
 Последовательность чисел Hailstone может быть сгенерирована из начального положительного целого числа, n: 
 Если n равно 1, последовательность заканчивается. Если n четно, то следующее n последовательности <code>= n/2</code> Если n нечетно, то следующее n последовательности <code>= (3 * n) + 1</code> (Неподтвержденная) <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: гипотеза Collatz">гипотеза Collatz</a> заключается в том, что последовательность градиентов для любого начального числа всегда заканчивается. Последовательность градиента также известна как номера градиента (поскольку значения обычно подвержены нескольким спуску и восхождениям, таким как град в облаке) или как последовательность Collatz. 
 Задача: создать процедуру для генерации последовательности градиента для числа. Используйте процедуру, чтобы показать, что последовательность градиента для числа 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>

Hailstone sequence

<section id="description">
 Номера <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="ссылка: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> или Niven представляют собой целые положительные числа ≥ 1, которые делятся на сумму их цифр. Например, 42 является <a href="http://rosettacode.org/wiki/oeis:A005349" title="OEIS: A005349">числом Харшада,</a> поскольку 42 делится на (4 + 2) без остатка. 
 Предположим, что ряд определяется как числа в порядке возрастания. Задача: Реализуйте функцию для генерации последовательных членов последовательности Harshad. Используйте его, чтобы перечислить первые двадцать членов последовательности и перечислите первое число Harshad, превышающее 1000. 
</section>

Harshad or Niven series

<section id="description">
Задача: Используя два массива равной длины, создайте объект Hash, в котором элементы из одного массива (ключи) связаны с элементами другого (значения) 
 Связанная задача: <a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Ассоциативные массивы / Создание">Ассоциативные массивы / Создание</a>
</section>

Hash from two arrays

<section id="description">
 <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> . Внедрите алгоритм «хеш-соединения» и продемонстрируйте, что он проходит тестовый сценарий, указанный ниже. Вы должны представлять таблицы как структуры данных, которые кажутся естественными на вашем языке программирования. Алгоритм «хеш-соединения» состоит из двух шагов: 
 Хэш-фаза. Создайте <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">мультимап</a> из одной из двух таблиц, сопоставляя их со всеми значениями столбца объединения со всеми строками, которые его содержат. Мультимап должен поддерживать хэш-ориентированный поиск, который масштабируется лучше, чем простой линейный поиск, потому что в этом весь смысл этого алгоритма. В идеале мы должны создать мультимап для меньшей таблицы, таким образом минимизируя время его создания и размер памяти. Фаза присоединения. Сканируйте другую таблицу и найдите соответствующие строки, просмотрев созданный ранее мультимап. В псевдокоде алгоритм может быть выражен следующим образом: <pre> пусть A = первая входная таблица (или, в идеале, большая)
пусть B = вторая входная таблица (или, в идеале, меньшая)
пусть j A = идентификатор столбца соединения таблицы A
пусть j B = идентификатор столбца соединения таблицы B
пусть M B = мультимап для отображения из отдельных значений в несколько строк таблицы B (начинается пустым)
пусть C = выходная таблица (начинается пустая)
для каждой строки b в таблице B:
 место b в multimap M B под клавишей b (j B )
для каждой строки a в таблице A:
 для каждой строки b в мультимадре M B под ключом a (j A ):
 пусть c = конкатенация строки a и строки b
 поместите строку c в таблицу C 
</pre> Прецедент вход <table><tbody><tr><td style="padding: 4px; margin: 5px;"><table style="border:none; border-collapse:collapse;"><tbody><tr><td style="border:none"> A = </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"> B = </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"> j A = </td><td style="border:none"> <code>Name</code> (т.е. столбец 1) </td><td style="border:none"> j B = </td><td style="border:none"> <code>Character</code> (т.е. столбец 0) </td></tr></tbody></table></td><td style="padding: 4px; margin: 5px;"></td></tr></tbody></table> Вывод <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> Порядок строк в выходной таблице не имеет значения. Если вы используете численные индексированные массивы для представления строк таблицы (вместо обращения к столбцам по имени), вы можете представить выходные строки в форме <code style="white-space:nowrap">[[27, "Jonah"], ["Jonah", "Whales"]]</code> , <hr>
</section>

Hash join

<section id="description">
Задача: Учитывая неотрицательные целые числа <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> в отсортированном порядке (каждая комбинация сортируется и вся таблица сортируется). 
 Пример: <big>3</big> гребня <big>5</big> : <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>

Combinations

<section id="description">
 <a href="https://en.wikipedia.org/wiki/Heron&#x27;s formula" title="wp: формула Герона">Формула Героя</a> для области треугольника с учетом длины трех ее сторон <big>a,</big> <big>b</big> и <big>c</big> определяется следующим образом: <big>$$ A = \ sqrt {s (sa) (sb) (sc)}, $$</big> где <big>s</big> - половина периметра треугольника; то есть, <big>$$ з = \ гидроразрыва {а + B + C} {2} $$.</big> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="ссылка: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Херонические треугольники</a> - это треугольники, стороны и области которых являются целыми числами. Примером может служить треугольник со сторонами 3, 4, 5, площадь которых равна 6 (а по периметру - 12). Заметим, что любой треугольник, чьи стороны все целые кратные 3, 4, 5; такие как 6, 8, 10, также будут иероническим треугольником. Определите примитивный херонийский треугольник как хернийский треугольник, где наибольший общий делитель всех трех сторон 1 (единство). Это исключает, например, треугольник 6, 8, 10. 
 Задача: Реализуйте функцию, основанную на формуле Героя, которая возвращает первые <code>n th</code> упорядоченные треугольники в массиве массивов. 
</section>

Heronian triangles

<section id="description">
 Эти две последовательности положительных целых чисел определяются как: <big>$$ R (1) = 1 \; \ S (1) = 2 \\ R (n) = R (n-1) + S (n-1), \ quad n> 1. $$</big> Последовательность <big>$ S (n) $</big> дополнительно определяется как последовательность положительных целых чисел, не присутствующих в <big>$ R (n) $</big> . Последовательность <big>$ R $</big> начинается: 1, 3, 7, 12, 18, ... Последовательность <big>$ S $</big> начинается: 2, 4, 5, 6, 8, ... 
 Задача: создать две функции с именем 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>

Hofstadter Figure-Figure sequences

<section id="description">
 Последовательность <a href="https://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Q_sequence" title="wp: Hofstadter_sequence # Hofstadter_Q_sequence">Hofstadter Q</a> определяется как: $ Q (1) = Q (2) = 1, \\ Q (n) = Q \ big (nQ (n-1) \ big) + Q \ big (nQ (n-2)), \ quad n> 2. $ Он определен как <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Последовательность Фибоначчи">последовательность Фибоначчи</a> , но в то время как следующий член в последовательности Фибоначчи представляет собой сумму двух предыдущих членов, в последовательности Q предыдущие два члена говорят вам, как далеко вернуться в последовательность Q, чтобы найти два числа суммировать, чтобы сделать следующий член последовательности. 
 Задача: Внедрить уравнение Хоффстадтера Q Sequence в JavaScript</section>

Hofstadter Q sequence

<section id="description">
 <a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-выражение">S-выражения</a> - один из удобных способов анализа и хранения данных. 
 Задача: Напишите простой читатель / парсер для S-Expressions, который обрабатывает строки с кавычками и без кавычек, целые числа и поплавки. Функция должна читать одно, но вложенное S-выражение из строки и возвращать его как (вложенный) массив. Новые строки и другие пробелы могут игнорироваться, если они не содержатся в цитируемой строке. " <tt>()</tt> " Внутри цитируемых строк не интерпретируются, а рассматриваются как часть строки. Обработка скрытых кавычек внутри строки необязательна; таким образом " <tt>(foo" bar)</tt> "может рассматриваться как строка" <tt>foo "bar</tt> " или как ошибка. Для этого читатель не должен распознавать « <tt>\</tt> » для экранирования, но должен, кроме того, распознавать номера, если язык имеет соответствующие типы данных. Обратите внимание, что за исключением « <tt>(» «</tt> » (« <tt>\</tt> », если поддерживается escaping) и пробелов нет специальных символов. Все остальное разрешено без кавычек. Читатель должен уметь читать следующий ввод <pre> ((данные «котируемые данные» 123 4.5)
 (данные (! @ # (4.5) "(более" "данные)")))
</pre> и превратить его в родную структуру данных. (см. реализации <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> для примеров встроенных структур данных.) 
</section>

S-Expressions

<section id="description">
Задача: Возвращает массив с текущей датой в форматах: - 2007-11-23 и - Воскресенье, 23 ноября 2007 г. Пример вывода: <code>['2007-11-23', 'Sunday, November 23, 2007']</code> 
</section>

Date format

<section id="description">
Задача: Учитывая строку даты в EST, выведите указанную дату в виде строки с добавлением 12 часов к времени. Часовой пояс должен быть сохранен. Пример ввода: <code>"March 7 2009 7:30pm EST"</code> 
 Пример вывода: <code>"March 8 2009 7:30am EST"</code> 
</section>

Date manipulation

<section id="description">
 Компания решает, что всякий раз, когда Xmas падает на воскресенье, они отдают своим работникам все дополнительные оплачиваемые отпуска, так что вместе с любыми праздничными днями работникам не придется работать на следующей неделе (с 25 декабря по 1 января). Задача: Напишите функцию, которая запускает год начала и конец года и возвращает массив всех лет, в которые 25 декабря будет воскресенье. 
</section>

Day of the week

<section id="description">
 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> . В этой версии реализовано 32000 номеров. ( <a href="http://www.solitairelaboratory.com/fcfaq.html" title="ссылка: http://www.solitairelaboratory.com/fcfaq.html">Часто задаваемые вопросы FreeCell</a> рассказывают об этой истории.) Когда игра стала популярной, Джим Хорн раскрыл <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="ссылка: http://www.solitairelaboratory.com/mshuffle.txt">алгоритм</a> , а другие реализации FreeCell начали воспроизводить сделки Microsoft. Эти сделки пронумерованы от 1 до 32000. Более новые версии от Microsoft имеют 1 миллион сделок, пронумерованных от 1 до 1000000; некоторые реализации позволяют использовать номера за пределами этого диапазона. Алгоритм использует этот <a href="http://rosettacode.org/wiki/linear congruential generator" title="линейный конгруэнтный генератор">линейный конгруэнтный генератор</a> от Microsoft C: 
 $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $ $ rand_n = state_n \ div 2 ^ {16} $ $ rand_n $ находится в диапазоне от 0 до 32767. Алгоритм: 
 Выделите 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 карт и так далее. Пример: Заказать карты <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> Игра №1 <pre> [
['JD', '2D', '9H', 'JC', '5D', '7H', '7C', '5H'],
['KD', 'KC', '9S', '5S', 'AD', 'QC', 'KH', '3H'],
['2S', 'KS', '9D', 'QD', 'JS', 'AS', 'AH', '3C'],
['4C', '5C', 'TS', 'QH', '4H', 'AC', '4D', '7S'],
[3S, TD, 4S, TH, 8H, 2C, JH, 7D,
[6D, 8S, 8D, QS, 6C, 3D, 8C,
['6S', '9C', '2H', '6H']
] </pre> Игра № 617 <pre> [
['7D', 'AD', '5C', '3S', '5S', '8C', '2D', 'AH'],
['TD', '7S', 'QD', 'AC', '6D', '8H', 'AS', 'KH'],
['TH', 'QC', '3H', '9D', '6S', '8D', '3D', 'TC'],
['KD', '5H', '9S', '3C', '8S', '7H', '4D', 'JS'],
[4C, QS, 9C, 9H, 7C,
['4S', 'TS', '2H', '5D', 'JC', '6C', 'JH', 'QH'],
['JD', 'KS', 'KC', '4H']
] </pre>
 Задача: Напишите функцию, чтобы взять номер сделки и раздавать карты в том же порядке, что и этот алгоритм. Функция должна возвращать двухмерный массив, представляющий плату FreeCell. Сделки можно также проверить на <a href="http://freecellgamesolutions.com/" title="ссылка: http://freecellgamesolutions.com/">решения FreeCell для 1000000 игр</a> . (Вызов видео решения, и он отображает первоначальную сделку.) 
</section>

Deal cards for FreeCell

<section id="description">
Задача: Напишите функцию, которая возвращает глубокую копию данного объекта. Копия не должна быть тем же самым объектом, который был дан. Эта задача не будет проверяться: 
 Объекты со свойствами, которые являются функциями. Объекты Date или объект со свойствами, которые являются объектами Date. RegEx или объект со свойствами, которые являются объектами RegEx. Прототипирование копий</section>

Deepcopy

<section id="description">
 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> . 
 Задача: Напишите функцию для генерации вывода строки, которая представляет собой конкатенацию входных слов из списка / последовательности, где: 
 Ввод без слов выводит строку вывода только двух символов скобок «{}». Ввод только одного слова, например ["ABC"], выводит строку вывода слова внутри двух фигурных скобок, например, "{ABC}". Ввод двух слов, например ["ABC", "DEF"], выдает строку вывода двух слов внутри двух фигурных скобок словами, разделенными строкой "и", например "{ABC и DEF}". Ввод трех или более слов, например ["ABC", "DEF", "G", "H"], выводит строку вывода всего, кроме последнего слова, разделенного символом "," с последним словом, разделенным символом "и" «и все в фигурных скобках; например, «{ABC, DEF, G и H}». Протестируйте свою функцию со следующей серией входов, показывающей ваш вывод здесь, на этой странице: 
 [] # (Нет входных слов). ["ABC"] ["ABC", "DEF"] ["ABC", "DEF", "G", "H"] Примечание. Предположим, что для этой задачи слова являются непустыми строками символов верхнего регистра. 
</section>

Comma quibbling

<section id="description">
 Учитывая <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">список</a> произвольно многих строк, реализуйте функцию для каждого из следующих условий: 
 если все они лексически равны, если каждая строка лексически меньше, чем одна после нее (т. е. является ли список в строгом порядке)</section>

Compare a list of strings

<section id="description">
Задача: Внедрите функцию, которая: 
 принимает положительное целое число, представляющее продолжительность в секундах в качестве входных данных (например, <code>100</code> ), и возвращает строку, которая показывает ту же самую длительность, разложенную на недели, дни, часы, минуты и секунды, как описано ниже (например, « <code>1 min, 40 sec</code> «). Продемонстрируйте, что он проходит следующие три теста: Испытательные случаи <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> Детали 
 Следует использовать следующие пять единиц: <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> ). Обозначьте форматирование, показанное в тестовых сценариях (количества, отсортированные от наибольшего до наименьшего и разделенные запятой + пробелом, значение и единица каждая величина разделяется пробелом). <hr style="margin:1em 0;">
</section>

Convert seconds to compound duration

<section id="description">
Задача: Создайте функцию или покажите встроенную функцию, чтобы подсчитать количество неперекрывающихся вхождений подстроки внутри строки. Функция должна принимать два аргумента: 
 первый аргумент - строка для поиска, а вторая - подстрока, которую нужно искать. Он должен возвращать целочисленное число. Соответствие должно давать наибольшее количество совпадающих совпадений. В общем, это по существу означает совмещение слева направо или справа налево. 
</section>

Count occurrences of a substring

<section id="description">
Задача: Определите тип, который ведет себя как целое число, но имеет наименьшее допустимое значение 1 и самое высокое допустимое значение 10. 
 Ошибки. Если вы попытаетесь создать экземпляр <code>Num</code> со значением за пределами 1 - 10, он должен выбросить <code>TypeError</code> с сообщением об ошибке <code>'Out of range'</code> . Если вы попытаетесь создать экземпляр <code>Num</code> со значением, которое не является числом, оно должно <code>TypeError</code> с сообщением об ошибке <code>'Not a Number'</code> .</section>

Define a primitive data type

<section id="description">
 В <a href="https://en.wikipedia.org/wiki/United_States" title="ссылка: https://en.wikipedia.org/wiki/United_States">американской</a> валюте существует четыре типа обычных монет: 
 кварталы (25 центов), десять центов (10 центов), никель (5 центов) и пенни (1 цент) Существует шесть способов внести изменения в 15 центов: 
 Копейка и никель Копейка и 5 пенни 3 никеля 2 никеля и 5 пенни Никель и 10 пенни 15 пенни Задача: Внедрить функцию, чтобы определить, сколько способов внести изменения в доллар, используя эти общие монеты? (1 доллар = 100 центов). 
 Ссылка: <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>

Count the coins

<section id="description">
 В <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> с таким количеством уравнений, как неизвестные, действительные всякий раз, когда система имеет единственное решение. Он выражает решение в терминах детерминантов матрицы (квадратного) коэффициента и полученных из нее матриц путем замены одного столбца на вектор правых частей уравнений. Данный <big></big> <big>$ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z &#x26; = {\ color {red} d_1} \\ a_2x + b_2y + c_2z &#x26; = {\ color {red} d_2} \\ a_3x + b_3y + c_3z &#x26; = {\ цвет {красный} D_3} \ конец {матрица} \ правом. $</big> который в матричном формате <big></big> <big>$ \ begin {bmatrix} a_1 &#x26; b_1 &#x26; c_1 \\ a_2 &#x26; b_2 &#x26; c_2 \\ a_3 &#x26; b_3 &#x26; 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> Тогда значения $ x, y $ и $ z $ можно найти следующим образом: <big></big> <big>$ x = \ frac {\ begin {vmatrix} {\ color {red} d_1} &#x26; b_1 &#x26; c_1 \\ {\ color {red} d_2} &#x26; b_2 &#x26; c_2 \\ {\ color {red} d_3} &#x26; b_3 &#x26; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &#x26; b_1 &#x26; c_1 \\ a_2 &#x26; b_2 &#x26; c_2 \\ a_3 &#x26; b_3 &#x26; c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix} } a_1 &#x26; {\ color {red} d_1} &#x26; c_1 \\ a_2 &#x26; {\ color {red} d_2} &#x26; c_2 \\ a_3 &#x26; {\ color {red} d_3} &#x26; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &#x26; b_1 &#x26; c_1 \\ a_2 &#x26; b_2 &#x26; c_2 \\ a_3 &#x26; b_3 &#x26; c_3 \ end {vmatrix}}, \ text {и} z = \ frac {\ begin {vmatrix} a_1 &#x26; b_1 &#x26; {\ color {red} d_1} \\ a_2 &#x26; b_2 &#x26; {\ color {red} d_2} \\ a_3 &#x26; b_3 &#x26; {\ color {red} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 &#x26; b_1 &#x26; c_1 \\ a_2 &#x26; b_2 &#x26; c_2 \\ a_3 &#x26; b_3 &#x26; c_3 \ end {vmatrix}}. $</big> 
 задача Учитывая следующую систему уравнений: <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> решаем для <big>$ w $, $ x $, $ y $</big> и <big>$ z $</big> , используя правило Крамера. 
</section>

Cramer's rule

<section id="description">
 Напишите функцию для возврата факториала числа. Факториал числа определяется: 
 п! = n * (n-1) * (n-2) * ..... * 1 Например: 3! = 3 * 2 * 1 = 6 4! = 4 * 3 * 2 * 1 = 24 Примечание: 0! = 1 
</section>

Factorial

<section id="description">
 Напишите функцию, возвращающую множители положительного целого числа. Этими факторами являются положительные целые числа, по которым число, подлежащее учету, можно разделить, чтобы получить положительный целочисленный результат. 
 ///</section>

Factors of an integer

<section id="description">
 Напишите функцию для генерации <big>n- го</big> числа Фибоначчи. 
 /// <big>N- е</big> число Фибоначчи дается: /// F n = F n-1 + F n-2 
 /// Первые два члена серии - 0, 1. 
 /// Следовательно, ряд равен: 0, 1, 1, 2, 3, 5, 8, 13 ... 
 ///</section>

Fibonacci sequence

<section id="description">
 Равновесный индекс последовательности является индексом в такой последовательности, что сумма элементов при более низких индексах равна сумме элементов с более высокими индексами. Например, в последовательности <big>$ A $</big> : :::: <big>$ A_0 = -7 $</big> :::: <big>$ A_1 = 1 $</big> :::: <big>$ A_2 = 5 $</big> :::: <big>$ A_3 = 2 $</big> :::: <big>$ A_4 = -4 $</big> :::: <big>$ A_5 = 3 $</big> :::: <big>$ A_6 = 0 $</big> 3 - показатель равновесия, поскольку: :::: <big>$ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> 6 также является показателем равновесия, поскольку: :::: <big>$ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> (сумма нулевых элементов равна нулю) 7 не является индексом равновесия, поскольку он не является допустимым индексом последовательности <big>$ A $</big> . Напишите функцию, которая, учитывая последовательность, возвращает свои равновесные индексы (если они есть). Предположим, что последовательность может быть очень длинной. 
</section>

Equilibrium index

<section id="description">
 Метод Эйлера численно аппроксимирует решения обыкновенных дифференциальных уравнений первого порядка (ОДУ) с заданным начальным значением. Это явный метод решения начальных задач (IVP), как описано <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: метод Эйлера">на странице wikipedia</a> . ОДУ должно быть представлено в следующем виде: :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> с начальным значением :: <big>$ y (t_0) = y_0 $</big> Чтобы получить числовое решение, мы заменим производную на LHS с помощью разностной аппроксимации: :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> затем решить для $ y (t + h) $: :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> который является таким же, как :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> Итеративное правило решения: :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> где <big>$ h $</big> - размер шага, наиболее важный параметр для точности решения. Чем меньше размер шага, тем выше точность, но также и стоимость вычислений, поэтому его всегда нужно выбирать вручную в зависимости от проблемы. Пример: закон охлаждения Ньютона Закон охлаждения Ньютона описывает, как объект начальной температуры <big>$ T (t_0) = T_0 $</big> остывает в среде с температурой <big>$ T_R $</big> : :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> или :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> В нем говорится, что скорость охлаждения <big>$ \ frac {dT (t)} {dt} $</big> объекта пропорциональна текущей разности температур <big>$ \ Delta T = (T (t) - T_R) $</big> в окружающую среду. Аналитическое решение, которое мы будем сравнивать с численным приближением, :: <big>$ T (t) = T_R + (T_0 - T_R) \; е ^ {-} $ кт</big> 
 Задача: Внедрить рутину метода Эйлера, а затем использовать его для решения данного примера закона охлаждения Ньютона с ним для трех разных размеров шага: :: * 2 с :: * 5 с и :: * 10 с и сравнить с аналитическим решением. 
 Начальные значения: :: * начальная температура <big>$ T_0 $</big> должна быть 100 ° C :: * комнатная температура <big>$ T_R $</big> должна составлять 20 ° C :: * постоянная охлаждения <big>$ k $</big> должна составлять 0,07 :: * интервал времени для вычисления должен составлять от 0 с ──► 100 с 
</section>

Euler method

<section id="description">
 Напишите функцию для вычисления биномиального коэффициента при заданном значении n и k. Эта формула рекомендуется: 
 $ \ 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>

Evaluate binomial coefficients

<section id="description">
 Напишите генератор простых чисел, чтобы он автоматически регулировался для генерации любого разумно высокого премьер. 
 Генератор должен иметь возможность: Показывать первые n простых чисел. Показывать простые числа в диапазоне. Показывать количество простых чисел в диапазоне. Показывать n- е простое число. Функция должна иметь два параметра. Первый получит n или диапазон в виде массива. Вторая будет получать логическое значение, которое указывает, возвращает ли функция числа простых чисел в виде массива или одного числа (числа простых чисел в диапазоне или n- го числа). В соответствии с параметрами функция должна возвращать массив. 
</section>

Extensible prime generator

<section id="description">
 Число Мерсенна - это число в виде 2 P -1. Если P является простым, число Мерсенна может быть простым числом Мерсенна (если P не является простым, число Мерсенна также не является простым). При поиске простых чисел Мерсенна выгодно исключить экспоненты путем нахождения небольшого коэффициента перед началом потенциально длительного <a href="http://rosettacode.org/wiki/Lucas-Lehmer test" title="Тест Лукаса-Лемера">теста Lucas-Lehmer</a> . Существуют очень эффективные алгоритмы для определения того, делит ли число 2 P -1 (или, что то же самое, если 2 P mod (число) = 1). Некоторые языки уже имеют встроенные реализации этой операции экспонента и мода (называемые modPow или аналогичные). Ниже описано, как реализовать этот modPow самостоятельно: Например, давайте вычислим 2 23 mod 47. Преобразуйте экспонента 23 в двоичный код, вы получите 10111. Начиная с <tt>квадрата</tt> = 1, многократно меняйте его. Удалите верхний бит экспоненты, и если это 1 умножить <tt>квадрат</tt> на основание экспоненции (2), тогда вычислите <tt>квадрат</tt> по модулю 47. Используйте результат модуляции с последнего шага в качестве начального значения <tt>квадрата</tt> на следующем шаге: Удалить необязательный квадратный верхний бит умножается на 2 mod 47 ------------ ------- ------------- ------ 1 * 1 = 1 1 0111 1 * 2 = 2 2 2 * 2 = 4 0 111 нет 4 4 * 4 = 16 1 11 16 * 2 = 32 32 32 * 32 = 1024 1 1 1024 * 2 = 2048 27 27 * 27 = 729 1 729 * 2 = 1458 1 Так как 2 23 mod 47 = 1, 47 является фактором 2 P -1. (Чтобы увидеть это, вычтите 1 с обеих сторон: 2 23 -1 = 0 mod 47.) Поскольку мы показали, что 47 является фактором, 2 23 -1 не является простым. Дальнейшие свойства чисел Мерсенна позволяют нам еще больше усовершенствовать процесс. Любой фактор q из 2 P -1 должен иметь вид 2kP + 1, k - положительное целое число или ноль. Кроме того, q должно быть 1 или 7 mod 8. Наконец, любой потенциальный фактор q должен быть <a href="http://rosettacode.org/wiki/Primality by Trial Division" title="Приоритет Судебного отдела">простым</a> . Как и в других алгоритмах пробного деления, алгоритм останавливается, когда 2kP + 1> sqrt (N). Эти тесты на примитивность работают только на числа Мерсенна, где P является простым. Например, M 4 = 15 не дает никаких факторов, использующих эти методы, но факторы в 3 и 5, ни один из которых не соответствует 2kP + 1. 
 Задача: Используя приведенный выше метод, найдите коэффициент 2 929 -1 (ака M929) 
 Задачи, связанные с данной темой: <a href="http://rosettacode.org/wiki/count in factors" title="считать в факторах">подсчет в факторах</a> <a href="http://rosettacode.org/wiki/prime decomposition" title="простое разложение">простых</a> <a href="http://rosettacode.org/wiki/count in factors" title="считать в факторах">коэффициентов</a> <a href="http://rosettacode.org/wiki/prime decomposition" title="простое разложение">декомпозиции</a> <a href="http://rosettacode.org/wiki/factors of an integer" title="факторы целого числа">целочисленного</a> <a href="http://rosettacode.org/wiki/Sieve of Eratosthenes" title="Сито Эратосфена">сита</a> <a href="http://rosettacode.org/wiki/primality by trial division" title="примитивность путем пробного разделения">примитивности</a> <a href="http://rosettacode.org/wiki/Sieve of Eratosthenes" title="Сито Эратосфена">Эратосфена</a> <a href="http://rosettacode.org/wiki/primality by trial division" title="примитивность путем пробного разделения">методом пробного деления</a> <a href="http://rosettacode.org/wiki/trial factoring of a Mersenne number" title="пробный факторинг числа Мерсенны">пробного факторинга числа</a> <a href="http://rosettacode.org/wiki/partition an integer X into N primes" title="перечислим целое число X в N простых чисел">чисел</a> <a href="http://rosettacode.org/wiki/trial factoring of a Mersenne number" title="пробный факторинг числа Мерсенны">Мерсенна</a> <a href="http://rosettacode.org/wiki/partition an integer X into N primes" title="перечислим целое число X в N простых чисел">- целое число X в N простых</a> <a href="http://rosettacode.org/wiki/sequence of primes by Trial Division" title="последовательность простых чисел в Судебном отделе">порядков простых чисел с помощью Trial Division</a> <a href="https://www.youtube.com/watch?v=SNwvJ7psoow" title="link: https://www.youtube.com/watch?v=SNwvJ7psoow">Computers в 1948 году: 2¹²⁷-1</a>
</section>

Factors of a Mersenne number

<section id="description">
 Напишите функцию для генерации последовательности n-шаговых последовательностей Фибоначчи и последовательностей Лукаса. Первым параметром будет n. Второй параметр будет состоять из числа возвращаемых элементов. Третий параметр будет определять, следует ли выводить последовательность Фибоначчи или последовательность Лукаса. Если параметр «f», то верните последовательность Фибоначчи, и если это «l», верните последовательность Лукаса. Последовательности должны быть возвращены как массив. Более подробная информация приведена ниже: Эти ряды чисел являются расширением обычной <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Последовательность Фибоначчи">последовательности Фибоначчи,</a> где: 
 При $ 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> 2 $ мы имеем последовательность $ n $ -последовательности Фибоначчи - $ F_k ^ n $; с начальными значениями первых $ n $ значений $ (n-1) $ 'th Fibonacci $ n $ -ступенчатой ​​последовательности $ F_k ^ {n-1} $; и $ k $ -ное значение этой $ n $ -ой последовательности является $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $ При малых значениях $ n $ <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Префикс номера # Greek_series">греческие числовые префиксы</a> иногда используются для индивидуального обозначения каждой серии. {| style = "text-align: left;" border = "4" cellpadding = "2" cellspacing = "2" | + Последовательности Фибоначчи $ n $ -ступят | - style = "background-color: rgb (255, 204, 255);" ! $ n $ !! Название серии !! Значения | - | 2 || Фибоначчи || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... | - | 3 || Трибоначчи || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... | - | 4 || тетранацци || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... | - | 5 || пентаначчи || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... | - | 6 || гексаначчи || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... | - | 7 || Гептаначи || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... | - | 8 || октоначчи || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... | - | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... | - | 10 || деканаци || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... |} Последовательности союзников могут быть сгенерированы при изменении начальных значений: Серия <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: номер Лукаса">Lucas</a> суммирует два предыдущих значения, такие как ряд фибоначчи для $ n = 2 $, но использует начальные значения $ [2, 1] $. 
</section>

Fibonacci n-step number sequences

<section id="description">
 Напишите функцию для возврата слов Фибоначчи до N. N будет предоставлена ​​в качестве параметра функции. Функция должна возвращать массив объектов. Объекты должны иметь вид: {N: 1, Length: 1, Entropy: 0, Word: '1'}. Более подробная информация приведена ниже: Слово Фибоначчи может быть создано способом, аналогичным последовательности Фибоначчи, <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> : Определите F_Word 1 как 1 Определить F_Word 2 как 0 Форма F_Word 3 как F_Word 2, объединенная с F_Word 1, то есть: 01 Форма F_Word n как F_Word n-1, связанная с F_word n-2 
</section>

Fibonacci word

<section id="description">
 Реализуйте основные матричные матричные и скалярно-матричные операции. Воплощать в жизнь: :: * дополнение :: * вычитание :: * умножение :: * раздел :: * возведение в степень Первым параметром будет операция, которая должна быть выполнена, например: «m_add» для добавления матрицы и «s_add» для скалярного добавления. Второй и третий параметры будут представлять собой матрицы, на которых должны выполняться операции. 
</section>

Element-wise operations

<section id="description">
 Эмирп (первичный, записанный в обратном порядке) - это простые числа, которые при обратном (в их десятичном представлении) являются разными штрихами. Напишите функцию, которая должна быть способна: Показывать первые числа n номеров. Покажите числа eprimes в диапазоне. Покажите количество eprimes в диапазоне. Покажите номер n th eprimes. Функция должна иметь два параметра. Первый получит n или диапазон в виде массива. Вторая будет получать логическое значение, которое указывает, возвращает ли функция eprimes в виде массива или одного числа (количество простых чисел в диапазоне или n- го числа). В соответствии с параметрами функция должна возвращать массив или число. 
</section>

Emirp primes

<section id="description">
Задача: Вычислите энтропию Шеннона H данной входной строки. Учитывая выборочную случайную переменную $ X $, которая представляет собой строку из $ N $ "символов" (всего символов), состоящую из $ n $ различных символов (n = 2 для двоичных), энтропия Шеннона X в битах / символе: $ H_2 (X) = - \ sum_ {i = 1} ^ n \ frac {count_i} {N} \ log_2 \ left (\ frac {count_i} {N} \ right) $ где $ count_i $ - количество символов $ n_i $. 
</section>

Entropy

<section id="description">
 Эфиопское умножение - это метод умножения целых чисел, использующий только добавление, удвоение и уменьшение пополам. Метод: 
 Возьмите два числа, чтобы их умножить и записать их в верхней части двух столбцов. В левом столбце повторите половину последнего номера, отбрасывая любые остатки и записывая результат ниже последнего в том же столбце, пока не напишите значение 1. В правом столбце многократно удвоите последнее число и запишите результат ниже. остановитесь, когда вы добавите результат в ту же строку, что и в столбце слева. 1. Изучите созданную таблицу и отбросьте любую строку, где значение в левом столбце четное. Суммируйте значения в правой колонке, которые останутся для получения результата умножения исходных двух чисел вместе Например: 17 × 34 17 34 Половина первого столбца: 17 34 8 4 2 1 Удвоение второй колонки: 17 34 8 68 4 136 2 272 1 544 Stratch-out rows, чья первая ячейка четная: 17 34 8 <strike>68</strike> 4 <strike>136</strike> 2 <strike>272</strike> 1 544 Суммируйте оставшиеся числа в правом столбце: 17 34 8 - 4 --- 2 --- 1 544 ==== 578 Так 17, умноженное на 34, по эфиопскому методу - 578. 
 Задача: Задача состоит в том, чтобы определить три названные функции / методы / процедуры / подпрограммы: 
 один на половину целого числа, один для двойного целого числа, и один, чтобы указать, является ли целое четным. Используйте эти функции для создания функции, которая делает эфиопское умножение. 
</section>

Ethiopian multiplication

<section id="description">
 Напишите функцию, которая возвращает последовательность Farey порядка n. Функция должна иметь один параметр, который равен n. Он должен возвращать последовательность в виде массива. Подробнее читайте ниже: Последовательность <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: последовательность Farey">Farey</a> F n порядка n представляет собой последовательность полностью восстановленных фракций между 0 и 1, которые, если в младших членах, имеют знаменатели, меньшие или равные n, упорядоченные в порядке возрастания. Последовательность Farey иногда некорректно называется серией Farey. Каждая последовательность Farey: :: * начинается со значения 0, обозначаемого дробью $ \ frac {0} {1} $ :: * заканчивается значением 1, обозначаемым дробью $ \ frac {1} {1} $. Последовательности Farey от 1 до 5: $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ $ {\ 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} $ $ {\ 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} $ 
</section>

Farey sequence

<section id="description">
Задача: Для каждого списка номеров 6-значных <a href="https://en.wikipedia.org/wiki/SEDOL" title="wp: SEDOL">SEDOL</a> s вычислите и добавьте цифру контрольной суммы. То есть, учитывая входную строку слева, ваша функция должна возвращать соответствующую строку справа: <pre> <code>&#x3C;pre> 710889 => 7108899 B0YBKJ => B0YBKJ7 406566 => 4065663 B0YBLH => B0YBLH2 228276 => 2282765 B0YBKL => B0YBKL9 557910 => 5579107 B0YBKR => B0YBKR5 585284 => 5852842 B0YBKT => B0YBKT7 B00030 => B000300 &#x3C;/pre></code> </pre> Проверьте также, что каждый вход правильно сформирован, особенно в отношении допустимых символов, разрешенных в строке SEDOL. Ваша функция должна возвращать значение <code>null</code> для недопустимого ввода. 
</section>

SEDOLs

<section id="description">
 Пять матросов потерпели кораблекрушение на острове и собирают большую кучу кокосовых орехов в течение дня. В эту ночь первый моряк просыпается и решает взять свою первую долю раньше, поэтому пытается разделить кучу кокосов одинаково на пять кучек, но обнаруживает, что остался один кокос, поэтому он бросает его обезьяне, а затем прячет «свою», одну из пяти одинаковых по размеру груды кокосов и подталкивает еще четыре свай вместе, чтобы снова сформировать одну видимую груду кокосов и ложиться спать. Короче говоря, каждый из моряков, в свою очередь, встает один раз ночью и выполняет те же действия, что и разделение кокосовой кучи на пять, и обнаруживает, что один кокос оставлен и дает кокосовому кокосовому ореху обезьяне. Утром (после тайного и раздельного действия каждого из пяти матросов в ночное время) оставшиеся кокосы делятся на пять равных свай для каждого из моряков, после чего обнаруживается, что куча кокосовых орехов одинаково делится среди моряков без остатка. (Ничего для обезьяны утром). Задание: <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> Заметка: <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> Cf: <a href="https://www.youtube.com/watch?v=U9qU20VmvaU" title="ссылка: https://www.youtube.com/watch?v=U9qU20VmvaU">Обезьяны и кокосы - Numberphile</a> (видео) Аналитическое решение. <pre> <code> &#x3C;a href="http://oeis.org/A002021" title="link: http://oeis.org/A002021">A002021 Pile of coconuts problem&#x3C;/a> The On-Line Encyclopedia of Integer Sequences. (Although some of its references may use the alternate form of the tale).</code> </pre>
</section>

Sailors, coconuts and a monkey problem

<section id="description">
Задача: Создайте интерпретатор для <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: алгоритм Маркова">алгоритма Маркова</a> . Правила имеют синтаксис: <ruleset> знак равно <comment> | <rule> ) <newline> +) * </newline></rule></comment></ruleset><comment> знак равно <any character=""> } </any></comment><rule> знак равно <pattern><whitespace> -> <whitespace> [.] <replacement></replacement></whitespace></whitespace></pattern></rule><whitespace> знак равно <tab> | <space> ) [ <whitespace> ] </whitespace></space></tab></whitespace> В каждой строке есть одно правило. Если есть . (период), присутствующий до <replacement> , то это правило окончания, в этом случае интерпретатор должен остановить выполнение. </replacement> Набор правил состоит из последовательности правил с необязательными комментариями. <big><big>Rulesets</big></big> Используйте следующие тесты для записей: 
 Правила 1: <pre> Этот файл правил извлекается из Википедии:
http://en.wikipedia.org/wiki/Markov_AlgorithmA -> яблоко
B -> сумка
S -> магазин
T ->
магазин -> мой брат
никогда не использовалось -> .terminating rule
</pre> Пример текста: <code>I bought a B of As from T S.</code> 
 Должен генерировать вывод: <code>I bought a bag of apples from my brother.</code> 
 Правила 2: Проверка правила завершения <pre> Немного изменен из правил на WikipediaA -> apple
B -> сумка
S -> .shop
T ->
магазин -> мой брат
никогда не использовалось -> .terminating rule </pre> Пример текста: <code>I bought a B of As from T S.</code> 
 Должна генерировать: <code>I bought a bag of apples from T shop.</code> 
 Правила 3: Это проверяет правильный порядок замещения и может задерживать простые подпрограммы на основе регулярного выражения, если специальные символы регулярного выражения не экранируются. <pre> BNF Синтаксические правила тестированияA -> apple
WWWW -> с
Багаж -> ->. *
B -> сумка
->. * -> деньги
W -> WW
S -> .shop
T ->
магазин -> мой брат
никогда не использовалось -> .terminating rule
</pre> Пример текста: <code>I bought a B of As W my Bgage from T S.</code> 
 Должна генерировать: <code>I bought a bag of apples with my money from T shop.</code> 
 Правила 4: Это проверяет правильность порядка сканирования правил и может задерживать процедуры замены, которые сканируются в неправильном порядке. Он реализует общий механизм унарного умножения. (Обратите внимание, что входное выражение должно быть помещено в символы подчеркивания в этой реализации.) <pre> ## Unary Multiplication Engine, для тестирования алгоритмов Алгоритма Маркова
## Донал Стипендиаты.
Унарное сложение engine_ + 1 -> _1 +
1 + 1 -> 11+
Переход для преобразования из расщепления умножения в обычный
addition1! -> 1
,! ->! +
_! -> _
Унарное умножение путем дублирования левой стороны, правое время 1 * 1 -> x, @ y
1x -> xX
X, -> 1,1
X1 -> 1X
_x -> _X
, х ->, X
y1 -> 1y
y_ -> _
Следующая фаза применения 1 @ 1 -> x, @ y
1 @ _ -> @_
, @ _ ​​->! _
++ -> +
Очистка выводов для добавления_1 -> 1
1 + _ -> 1
_ + _ ->
</pre> Пример текста: <code>_1111*11111_</code> 
 должен генерировать вывод: <code>11111111111111111111</code> 
 Правила 5: Простая <a href="http://en.wikipedia.org/wiki/Turing_machine" title="ссылка: http://en.wikipedia.org/wiki/Turing_machine">машина Тьюринга</a> , реализуя <a href="http://en.wikipedia.org/wiki/Busy_beaver" title="ссылка: http://ru.wikipedia.org/wiki/Busy_beaver">трехгосударственный бобр</a> . Лента состоит из 0s и 1s, состояния A, B, C и H (для Halt), а положение головы указывается путем записи буквы состояния перед символом, где находится голова. Все части исходной ленты, на которой работает машина, должны быть указаны на входе. Кроме того, демонстрируя, что алгоритм Маркова является Turing-полным, он также заставил меня поймать ошибку в реализации C ++, которая не была захвачена первыми четырьмя наборами правил. <pre> Машина Тьюринга: бобер с тремя состояниями
# состояние A, символ 0 => запись 1, перемещение вправо, новое состояние BA0 -> 1B
состояние A, символ 1 => запись 1, перемещение влево, новое состояние C0A1 -> C01
1A1 -> C11
состояние B, символ 0 => запись 1, перемещение влево, новое состояние A0B0 -> A01
1B0 -> A11
состояние B, символ 1 => записать 1, двигаться вправо, новое состояние BB1 -> 1B
состояние C, символ 0 => запись 1, перемещение влево, новое состояние B0C0 -> B01
1C0 -> B11
состояние C, символ 1 => запись 1, перемещение влево, halt0C1 -> H01
1C1 -> H11
</pre> Этот набор правил должен <code>000000A000000</code> 
 в <code>00011H1111000</code> 
</section>

Execute a Markov algorithm

<section id="description">
 Напишите функцию для реализации интерпретатора Brain ****. Функция примет строку как параметр и должна вернуть строку в качестве вывода. Более подробная информация приведена ниже: RCBF представляет собой набор компиляторов и интерпретаторов <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***,</a> написанных для Rosetta Code на разных языках. Ниже приведены ссылки на каждую из версий RCBF. Для реализации необходимо только правильно выполнить следующие инструкции: {| ! Command !Описание | - | стиль = «выравнивание текста: центр» | <code>></code> || Переместите указатель вправо | - | стиль = «выравнивание текста: центр» | <code>&#x3C;</code> || Переместите указатель влево | - | стиль = «выравнивание текста: центр» | <code>+</code> || Увеличение ячейки памяти под указателем | - | стиль = «выравнивание текста: центр» | <code>-</code> || Уменьшить ячейку памяти под указателем | - | стиль = «выравнивание текста: центр» | <code>.</code> || Вывести символ, обозначенный ячейкой указателем | - | стиль = «выравнивание текста: центр» | <code>,</code> || Введите символ и сохраните его в ячейке указателя | - | стиль = «выравнивание текста: центр» | <code>[</code> || Перейти мимо соответствия <code>]</code> если ячейка под указателем равна 0 | - | стиль = «выравнивание текста: центр» | <code>]</code> || Вернитесь к совпадению <code>[</code> если ячейка под указателем отлична от нуля |} Любой размер ячейки разрешен, поддержка EOF ( E nd- O- F ile) необязательна, равно как и ограниченная или неограниченная память. 
</section>

Execute Brain****

<section id="description">
 Существует высоко организованный город, который решил присвоить номер каждому из своих отделов: 
 Отдел полиции Отдел санитарии Отдел пожарной охраны Каждый отдел может иметь число от 1 до 7 (включительно). Три номера отделов должны быть уникальными (отличными друг от друга) и должны содержать до 12. Начальник полиции не любит странные цифры и хочет иметь четное число для своего отдела. 
 Задача: Напишите программу, которая выводит все допустимые комбинации: [2, 3, 7] [2, 4, 6] [2, 6, 4] [2, 7, 3] [4, 1, 7] [4, 2, 6] [4, 3, 5] [4, 5, 3] [4, 6, 2] [4, 7, 1] [6, 1, 5] [6, 2, 4] [6, 4, 2] [6, 5, 1] 
</section>

Department Numbers

<section id="description">
Задача: Преобразуйте заданную дату из <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: григорианский календарь">григорианского календаря</a> в <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: Дискордианский календарь">Дискордианский календарь</a> . 
</section>

Discordian date

<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>

Gamma function

<section id="description">
Напишите функцию для решения \ (Ax = b \), используя гауссово исключение, затем обратную замену. \ (A \) является матрицей \ (n \ times n \). Кроме того, \ (x \) и \ (b \) являются \ (n \) на 1 векторы. Чтобы повысить точность, используйте частичный поворот и масштабирование.</section>

Gaussian elimination

<section id="description">
Напишите обобщенную версию <a href="http://rosettacode.org/wiki/FizzBuzz">FizzBuzz,</a> которая работает для любого списка факторов вместе со своими словами. Это в основном реализация «fizzbuzz», где правила игры предоставляются пользователю. Создайте функцию для ее реализации. Функция должна принимать два параметра. Первым будет массив с правилами FizzBuzz. Например: <code>[ [3,"Fizz"] , [5,"Buzz"] ]</code> . Это указывает на то, что <code>Fizz</code> следует печатать, если число кратно 3 и <code>Buzz</code> если оно кратно 5. Если оно кратно, то строки должны быть объединены в порядке, указанном в массиве. В этом случае <code>FizzBuzz</code> если число кратно 3 и 5. Второй параметр - это номер, для которого функция должна возвращать строку, как указано выше.</section>

General FizzBuzz

<section id="description">
Напишите функцию для генерации массива символов ASCII нижнего регистра для заданного диапазона. Например: для диапазона от 1 до 4 функция должна возвращать <code>['a','b','c','d']</code> .</section>

Generate lower case ASCII alphabet

<section id="description">
Генератор - это исполняемый объект (например, функция или процедура), который содержит код, который дает последовательность значений по одному, так что каждый раз, когда вы вызываете генератор, предоставляется следующее значение в последовательности. Генераторы часто строятся поверх сопрограмм или объектов, так что внутреннее состояние объекта обрабатывается «естественно». Генераторы часто используются в ситуациях, когда последовательность потенциально бесконечна и где можно построить следующее значение последовательности с минимальным состоянием. Напишите функцию, которая использует генераторы для генерации квадратов и кубов. Создайте новый генератор, который фильтрует все кубы из генератора квадратов. Функция должна возвращать значение \ (n ^ {th} \) отфильтрованного генератора. Например, для \ (n = 7 \) функция должна возвращать 81, так как последовательность будет 4,9,16,25,36,49,81. Здесь 64 отфильтровывается, так как это куб.</section>

GeneratorExponential

<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 не нужно). Существует много возможных кодов Грея. Следующее кодирует так называемый «двоичный отраженный серый код». Кодирование (MSB - бит 0, b - двоичный, g - код Grey): <code> if b[i-1] = 1 g[i] = not b[i] else g[i] = b[i] </code> Или: <code>g = b xor (b logically right shifted 1 time)</code> Декодирование (MSB - бит 0, b - двоичный, g - код Grey): <code>b[0] = g[0] for other bits: b[i] = g[i] xor b[i-1] </code>
</section>

Gray code

<section id="description">
Напишите функцию, которая возвращает наибольший общий делитель двух целых чисел.</section>

Greatest common divisor

<section id="description">
Если задана последовательность целых чисел, найдите непрерывную подпоследовательность, которая максимизирует сумму ее элементов, т. Е. Элементы ни одной отдельной подпоследовательности не прибавляют к значению, большему, чем это. Считается, что пустая подпоследовательность имеет сумму \ (0 \); таким образом, если все элементы отрицательны, результат должен быть пустой.</section>

Greatest subsequential sum

<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>

IBAN

<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;"> «Я до E, когда не предшествует C». </li><li> «E до I, когда предшествует C». </li></ol> Если обе подфразы правдоподобны, то исходную фразу можно назвать правдоподобной. Напишите функцию, которая принимает слово и проверяет, соответствует ли это слово этому правилу. Функция должна возвращать true, если она соответствует правилу, в противном случае false.</section>

I before E except after C

<section id="description">
Единичная матрица является квадратной матрицей размера \ (n \ times n \), где диагональные элементы - все 1 s (одни), а все остальные элементы - все 0 s (нули). \ begin {bmatrix} 1 &#x26; 0 &#x26; 0 \ cr 0 &#x26; 1 &#x26; 0 \ cr 0 &#x26; 0 &#x26; 1 \ cr \ end {bmatrix} Напишите функцию, которая принимает число «n» в качестве параметра и возвращает единичную матрицу порядок nx n.</section>

Identity matrix

<section id="description">
Если вы добавите квадрат цифр натурального числа (целое число больше нуля), вы всегда заканчиваете либо 1, либо 89: <pre> 15 -> 26 -> 40 -> 16 -> 37 -> 58 -> 89
7 -> 49 -> 97 -> 130 -> 10 -> 1 </pre> Напишите функцию, которая принимает число как параметр и возвращает 1 или 89 после выполнения указанного процесса.</section>

Iterated digits squaring

<section id="description">
Расстояние Jaro является мерой сходства между двумя строками. Чем выше расстояние Jaro для двух строк, тем более похожи строки. Оценка нормализуется так, что 0 не приравнивается к подобию, а 1 - точное совпадение. Определение Расстояние Jaro \ (d_j \) двух заданных строк \ (s_1 \) и \ (s_2 \) - это \ begin {align} d_j = \ begin {cases} 0 &#x26; &#x26; \ text {if} m = 0 \\\ \ {\ frac {1} {3}} \ left ({\ frac {m} {| s_ {1} |}} + {\ frac {m} {| s_ {2} |}} + {\ frac { mt} {m}} \ right) &#x26; &#x26; \ text {other} \ end {cases} \ end {align} Где: <ul><li> \ (m \) - количество совпадающих символов ; </li><li> \ (t \) - половина числа транспозиций . </li></ul> Два символа из \ (s_1 \) и \ (s_2 \) соответственно, считаются совпадающими, только если они одинаковы, а не дальше \ (\ left \ lfloor \ frac {\ max (| s_1 |, | s_2 |)} {2} \ право \ rfloor-1 \). Каждый символ \ (s_1 \) сравнивается со всеми его совпадающими символами в \ (s_2 \). Количество совпадающих (но разных порядковых порядков) символов, деленное на 2, определяет количество транспозиций . Пример. С учетом строк \ (s_1 \) DWAYNE и \ (s_2 \) DUANE находим: <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>

Jaro distance

<section id="description">
jortSort - это набор инструментов сортировки, который заставляет пользователя выполнять работу и гарантирует эффективность, потому что вам больше не нужно сортировать. Первоначально он был представлен Jenn «Moneydollars» Шиффер на престижном <a href="https://www.youtube.com/watch?v=pj4U_W0OFoE">JSConf</a> . jortSort - это функция, которая принимает один массив сопоставимых объектов в качестве аргумента. Затем он сортирует массив в порядке возрастания и сравнивает отсортированный массив с первоначально предоставленным массивом. Если массивы совпадают (т. Е. Исходный массив уже был отсортирован), функция возвращает true. Если массивы не совпадают (т. Е. Исходный массив не был отсортирован), функция возвращает false.</section>

JortSort

<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> 0 $</big> , выясните, кто из заключенных будет последним выжившим. В одном из таких инцидентов было 41 заключенный, и каждый 3- й заключенный был убит ( <big>$ k = 3 $</big> ). Среди них было умное имя Джофа, который разработал проблему, стоял в выжившем положении и продолжал рассказывать историю. Каким он был? Напишите функцию, которая берет начальное число заключенных и «k» в качестве параметра и возвращает число заключенного, который выживает.</section>

Josephus problem

<section id="description">
<div class="rosetta"> <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a> - полный эзотерический язык программирования Тьюринга, изобретенный математиком <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: Джон Хортон Конвей">Джоном Хортоном Конвеем</a> . Программа FRACTRAN представляет собой упорядоченный список положительных дробей $ P = (f_1, f_2, \ ldots, f_m) $ вместе с начальным положительным целым числом $ n $. Программа запускается путем обновления целого числа $ n $ следующим образом: <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> Конвей дал программу для простых чисел в FRACTRAN: 17 долл. США, долл. США, долл. США, долл. США / $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $ Начиная с $ n = 2 $, эта программа FRACTRAN изменит $ n $ на $ 15 = 2 \ times (15/2) $, затем $ 825 = 15 \ times (55/1) $, генерируя следующую последовательность целых чисел: $ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $ После 2 эта последовательность содержит следующие степени 2: $ 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 $ которые являются главными полномочиями 2. <dl class="rosetta__description-list"><dt class="rosetta__description-title"> Задача: </dt></dl> Напишите функцию, которая принимает программу fractran как строковый параметр и возвращает первые 10 номеров программы в виде массива. Если результат не содержит 10 чисел, тогда возвращаем числа как есть. </div>
</section>