Платформа: CodeWars

 Название задачи: Chain me (Закуйте меня в цепи)

 Ссылка на задачу: https://www.codewars.com/kata/54fb853b2c8785dd5e000957

 Сложность: 7 kyu

 Уже решили (На момент написания статьи): 8 384 из 25 362

 Тэги:  Fundamentals

 Оригинальное описание задачи:

Write a generic function chainer

Write a generic function chainer that takes a starting value, and an array of functions to execute on it (array of symbols for Ruby).

The input for each function is the output of the previous function (except the first function, which takes the starting value as its input). Return the final value after execution is complete.

def add10(x): return x + 10
def mul30(x): return x * 30

chain(50, [add10, mul30])
# returns 1800

Пояснение задачи:

Задача состоит в создании универсальной функции (или предиката в случае Prolog), позволяющей последовательно применять цепочку функций (атомов в Prolog) к начальному значению.
Функция принимает:
- Начальное значение.
- Массив функций (или атомов в Prolog), каждая из которых будет применяться к результату предыдущей функции.

Работа происходит следующим образом:
1. Первая функция получает начальное значение и возвращает промежуточный результат.
2. Вторая функция принимает результат первой и возвращает новый промежуточный результат.
3. Процесс продолжается до конца списка функций, пока не будет выполнен последний элемент.
4. Итоговый результат после выполнения последней функции возвращается как итог работы всей цепочки.
Например:
- Исходное значение: `2`.
- Последовательность функций: `[add, mult]`.
- Результат: сначала прибавляем единицу (`add`), получаем `3`, затем умножаем на 30 (`mult`) и получаем конечный результат `90`.

Для разных языков программирования задача решается аналогично:
- В JavaScript и Ruby используется передача функций через массив и вызов их по очереди.
- В Haskell и Factor применяется функциональная композиция.
- В C#, Rust и других языках с поддержкой лямбда-функций или делегатов используются анонимные функции или методы.
- В Prolog используется последовательное выполнение атомарных операций над переменными.

Таким образом, функция позволяет гибко комбинировать различные операции, применяя их последовательно к исходному значению.

 Платформа: CodeWars

 Название задачи: Toggle, Set, and Clear Bits (Bit Manipulation Basics) (Переключение, установка и очистка битов (основы работы с битами))

 Ссылка на задачу: https://www.codewars.com/kata/696eacb39271f8aa43b61841

 Сложность: 7 kyu

 Уже решили (На момент написания статьи): 713 из 3 009

 Тэги:  Bits

 Оригинальное описание задачи:

Toggle, Set, and Clear Bits

Your task is to implement a collection of utility functions that perform common bitwise operations on integers.All bit positions are zero-based, meaning position 0 refers to the least significant bit.

Toggles (flips) the bit at the given position. If the bit is 0, it becomes 1; if it is 1, it becomes 0.

toggleBit(5, 1) => 7

Sets the bit at the given position to 1, without modifying other bits.

setBit(5, 1) => 7

Clears (sets to 0) the bit at the given position, leaving all other bits unchanged.

clearBit(7, 1) => 5

Checks whether the bit at the given position is set to 1.

Returns `true` if it is set, otherwise `false`.

isBitSet(5, 0) => true

Sets all bits to 1 wherever the mask has 1s.

setMultipleBits(5, 3) => 7

Clears all bits wherever the mask has 1s.

clearMultipleBits(7, 2) => 5

Toggles all bits wherever the mask has 1s.

toggleMultipleBits(5, 3) => 6

Notes  All functions should return the resulting number (or a boolean for `isBitSet`).

Пояснение задачи:

Необходимо реализовать набор функций для выполнения базовых битовых операций над целыми числами.
Все позиции битов нумеруются с нуля (нулевой бит — младший значащий), что соответствует стандартному представлению целых чисел в двоичной форме.

Описание каждой функции:
1. toggleBit(int num, int pos) Функция меняет состояние бита на противоположное (если бит был 0, то становится 1, и наоборот).

Пример: toggleBit(5, 1) → 7 (0101 → 1111)
2. setBit(int num, int pos) Устанавливает бит на заданной позиции в значение 1, оставляя остальные биты неизменными.

Пример: setBit(5, 1) → 7 (0101 → 1111)
3. clearBit(int num, int pos) Сбрасывает бит на заданной позиции в значение 0, сохраняя остальные биты без изменений.

Пример: clearBit(7, 1) → 5 (111 → 101)
4. isBitSet(int num, int pos) Проверяет, установлен ли бит на указанной позиции. Возвращает `true`, если бит установлен, иначе `false`.

Пример: isBitSet(5, 0) → true (бит 0 равен 1)
5. setMultipleBits(int num, int mask) Устанавливает все биты, где в маске стоит 1.

Пример: setMultipleBits(5, 3) → 7 (0101 → 1111)
6. clearMultipleBits(int num, int mask) Сбрасывает все биты, где в маске стоит 1.

Пример: clearMultipleBits(7, 2) → 5 (111 → 101)
7. toggleMultipleBits(int num, int mask) Меняет состояние всех битов, где в маске стоят единицы.
 

 Платформа: CodeWars

 Название задачи: Experimenting with a sequence of complex numbers (Экспериментируя с последовательностью комплексных чисел)

 Ссылка на задачу: https://www.codewars.com/kata/5b06c990908b7eea73000069

 Сложность: 6 kyu

 Уже решили (На момент написания статьи): 579 из 2 127

 Тэги:  Fundamentals, Puzzles

 Оригинальное описание задачи:

Consider the sequence S(n, z) = (1 - z)(z + z**2 + z**3 + ... + z**n) where z is a complex number and n a positive integer (n > 0).

When n goes to infinity and z has a correct value (ie z is in its domain of convergence D), S(n, z) goes to a finite limit lim depending on z.

Experiment with S(n, z) to guess the domain of convergence Dof S and lim value when z is in D.

Then determine the smallest integer n such that abs(S(n, z) - lim) < eps where eps is a given small real number and abs(Z) is the modulus or norm of the complex number Z.

Call f the function f(z, eps) which returns n. If z is such that S(n, z) has no finite limit (when z is outside of D) f will return -1.

Examples:
I is a complex number such as I * I = -1 (sometimes written i or j).
f(0.3 + 0.5 * I, 1e-4) returns 17
f(30 + 5 * I, 1e-4) returns -1

Remark:
For languages that don't have complex numbers or "easy" complex numbers, a complex number z is represented by two real numbers x (real part) and y (imaginary part).
f(0.3, 0.5, 1e-4) returns 17
f(30, 5, 1e-4) returns -1

Note: You pass the tests if abs(actual - expected) <= 1

Пояснение задачи:

Задача состоит в следующем:
Необходимо реализовать функцию, принимающую два аргумента:
- Комплексное число z (представленное двумя действительными числами — действительной и мнимой частями)
- Малое положительное число ε, определяющее точность приближения Функция должна определить наименьшее натуральное число n, при котором разность между суммой ряда S(n, z) и её пределом S(∞, z) меньше заданной точности ε.

Основные шаги решения:
1. Определение области сходимости Ряд S(n, z) сходится абсолютно при |z| < 1. Это значит, что функция f(z, ε) вернёт корректный результат только для комплексных чисел z, удовлетворяющих условию |z| < 1. Если z выходит за пределы этой области, функция возвращает -1.

2. Вычисление суммы ряда S(n, z) Для конечного n сумма ряда S(n, z) равна (1-z)...(z+z^2+...+z^n). Необходимо аккуратно вычислять эту сумму, учитывая возможное переполнение и потерю точности при больших значениях n и z.

3. Оценка предела S(∞, z) Предел ряда $S(∞, z) равен ½ {z}{1-z}, если z принадлежит области сходимости. При выходе за область сходимости предел не существует, и функция возвращает -1.

4. Поиск минимального n, обеспечивающего требуемую точность Начинаем с n=1 и увеличиваем n до тех пор, пока разница между текущей суммой S(n, z) и пределом S(∞, z) не станет меньше заданной точности ε.

Примеры:
Пример 1: z = 0.3 + 0.5i, ε = 10^{-4} - Сумма ряда быстро сходится, и уже при n = 17 достигается требуемая точность. -  Пример 2: z = 30 + 5i, ε = 10^{-4} - Здесь z находится вне области сходимости, поэтому функция возвращает -1.

Замечания:
- В языках программирования, где нет встроенной поддержки комплексных чисел, комплексное число представляется пар

 Платформа: CodeWars

 Название задачи: How Green Is My Valley? (Насколько Зелена Моя Долина?)

 Ссылка на задачу: https://www.codewars.com/kata/56e3cd1d93c3d940e50006a4

 Сложность: 7 kyu

 Уже решили (На момент написания статьи): 5 822 из 22 739

 Тэги:  Fundamentals

 Оригинальное описание задачи:

Input : an array of integers.

Output : this array, but sorted in such a way that there are two wings:

the left wing with numbers decreasing, the right wing with numbers increasing.

the two wings have the same length.

If the length of the array is odd the wings are around the bottom, if the length is even the bottom is considered to be part of the right wing.

each integer l of the left wing must be greater or equal to its counterpart r in the right wing,

the difference l - r being as small as possible. In other words the right wing must be nearly as steep as the left wing.

The function is make_valley or makeValley or make-valley.

a = [79, 35, 54, 19, 35, 25]
make_valley(a) --> [79, 35, 25, *19*, 35, 54]
The bottom is 19, left wing is [79, 35, 25], right wing is [*19*, 35, 54].
79..................54
   35..........35
       25.
             ..19

a = [67, 93, 100, -16, 65, 97, 92]
make_valley(a) --> [100, 93, 67, *-16*, 65, 92, 97]
The bottom is -16, left wing [100, 93, 67] and right wing [65, 92, 97] have same length.
100.........................97
93..........
              .........92
     67......
              .....65
          -16

a = [66, 55, 100, 68, 46, -82, 12, 72, 12, 38]
make_valley(a) --> [100, 68, 55, 38, 12, *-82*, 12, 46, 66, 72] The bottom is -82, left wing is[100, 68, 55, 38, 12]],right wing is
[*-82*, 12, 46, 66, 72].

a = [14,14,14,14,7,14]
make_valley(a) => [14, 14, 14, *7*, 14, 14]

a = [14,14,14,14,14] make_valley(a) =>
[14, 14, *14*, 14, 14]

A counter-example:
a = [17, 17, 15, 14, 8, 7, 7, 5, 4, 4, 1]
A solution could be [17, 17, 15, 14, 8, 1, 4, 4, 5, 7, 7]
but the right wing [4, 4, 5, 7, 7] is much flatter than the left one
[17, 17, 15, 14, 8].

Summing the differences between left and right wing:
(17-7)+(17-7)+(15-5)+(14-4)+(8-4) = 44

Consider the following solution: [17, 15, 8, 7, 4, 1, 4, 5, 7, 14, 17]
Summing the differences between left and right wing:
(17-17)+(15-14)+(8-7)+(7-5)+(4-4) = 4
The right wing is nearly as steep as the right one.

Пояснение задачи:

Задача состоит в преобразовании исходного массива целых чисел таким образом, чтобы получить два симметричных «крыла», расположенных вокруг центральной точки — так называемого «дна».  

Основные требования:
- Левое и правое крылья должны иметь одинаковую длину.
- Левое крыло строится от максимального элемента слева направо, уменьшая значение последовательно, а правое — от минимального справа налево, также уменьшая значения.
- Элементы левого крыла должны быть больше или равны соответствующим элементам правого крыла.
- Разница между элементами одного уровня левого и правого крыла должна быть минимальной.
- Если длина массива нечётная, центральная точка (дно) располагается посередине, иначе дно считается частью правого крыла.

Примеры:
Пример 1:
Исходный массив: `[79, 35, 54, 19, 35, 25]` Результат: `[79, 35, 25, *19*, 35, 54]`
Левое крыло: `[79, 35, 25]`, правое крыло: `[19, 35, 54]`.

Пример 2:

Исходный массив: `[67, 93, 100, -16, 65, 97, 92]` Результат: `[100, 93, 67, *-16*, 65, 92, 97]`
Левое крыло: `[100, 93, 67]`, правое крыло: `[65, 92, 97]`.

Пример 3:

Исходный массив: `[66, 55, 100, 68, 46, -82, 12, 72, 12, 38]` Результат: `[100, 68, 55, 38, 12, *-82*, 12, 46, 66, 72]`
Левое крыло: `[100, 68, 55, 38, 12]`, правое крыло: `[–82, 12,]

 Платформа: CodeWars

 Название задачи: Scaling Squared Strings (Масштабирование прямоугольных строк)

 Ссылка на задачу: https://www.codewars.com/kata/56ed20a2c4e5d69155000301

 Сложность: 7 kyu

 Уже решили (На момент написания статьи): 6 436 из 24 236

 Тэги:  Fundamentals, Strings

 Оригинальное описание задачи:

You are given a string of n lines, each substring being n characters long. For example:

s = "abcd\nefgh\nijkl\nmnop"

We will study the "horizontal" and the "vertical" scaling of this square of strings.

A k-horizontal scaling of a string consists of replicating k times each character of the string (except '\n').

Example: 2-horizontal scaling of s: => "aabbccdd\neeffgghh\niijjkkll\nmmnnoopp"

A v-vertical scaling of a string consists of replicating v times each part of the squared string.

Example:2-vertical scaling of s: => "abcd\nabcd\nefgh\nefgh\nijkl\nijkl\nmnop\nmnop"

Function scale(strng, k, v) will perform a k-horizontal scaling and a v-vertical scaling.

Example:
a = "abcd\nefgh\nijkl\nmnop"
scale(a, 2, 3) --> "aabbccdd\naabbccdd\naabbccdd\neeffgghh\neeffgghh\neeffgghh\niijjkkll\niijjkkll\niijjkkll\nmmnnoopp\nmmnnoopp\nmmnnoopp" Printed:
abcd -----> aabbccdd
efgh aabbccdd
ijkl aabbccdd
mnop eeffgghh
          eeffgghh
          eeffgghh
          iijjkkll
          iijjkkll
          iijjkkll
          mmnnoopp
          mmnnoopp
          mmnnoopp

Task: Write function scale(strng, k, v) k and v will be positive integers. If strng == return.

Пояснение задачи:

Задача заключается в реализации функции `scale(strng, k, v)`, принимающей строку `strng`, состоящую из строковых блоков фиксированной длины, и параметры горизонтального (`k`) и вертикального (`v`) масштабирования.

Пояснение:
Функция должна выполнить следующие шаги:
1. Разделить входную строку `strng` на строки (блоки длиной n символов каждая).
2. Выполнить горизонтальное масштабирование: каждую строку нужно повторить `k` раз подряд, исключая символы новой строки (`\n`).
3. Выполнить вертикальное масштабирование: весь полученный набор строк (результат горизонтального масштабирования) нужно повторить `v` раз.

Пример работы функции:
Для входной строки: s = "abcd\nefgh\nijkl\nmnop"

- Горизонтальное масштабирование (k=2):

Исходная строка:
abcd
efgh
ijkl
mnop

После горизонтального масштабирования (каждая строка повторяется дважды):
aabbccddeeffghhhiijjkkllmmnnoopp aabbccddeeffghhhiijjkkllmmnnoopp

- Затем выполняется вертикальное масштабирование (v=3):

Результат после вертикального масштабирования:
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp
aabbccddeeffghhhiijjkkllmmnnoopp

Алгоритм решения: 1. Сначала разбиваем входную строку на блоки фиксированной длины (по количеству символов в строке минус символ новой строки). 2. Для каждого блока выполняем горизонтальное масштабирование, дублируя каждый символ строки `k` раз. 3. Собираем получившиеся строки и выполняем вертикальное масштабирование, повторяя полученный

 Платформа: CodeWars

 Название задачи: Find the unique number (Найти уникальный номер)

 Ссылка на задачу: https://www.codewars.com/kata/55f81f9aa51f9b72a200002f

 Сложность: 6 kyu

 Уже решили (На момент написания статьи): 2 333 из 8 495

 Тэги:  Arrays, Performance, Fundamentals

 Оригинальное описание задачи:

Complete the function which returns the only unique number from an array.
All numbers in the unsorted array are present twice, except the one you have to find.
The numbers are always valid integer values between 1 and 2147483647, so no need for type and error checking.
The array contains at least one number and may contain millions of numbers.

So make sure your solution is optimized for speed. Example [ 1, 8, 4, 4, 6, 1, 8 ] --> 6

Пояснение задачи:

Задача состоит в поиске единственного уникального числа в массиве, где все остальные числа встречаются ровно два раза. Массив содержит целые числа от 1 до 2^{31}-1 (включительно), каждое число встречается дважды, кроме одного — искомого уникального элемента.

Для решения задачи важно учесть несколько ключевых моментов:
- Все числа в диапазоне от 1 до 2^{31}-1, значит, допустимы любые стандартные целочисленные типы данных.
- Массив может содержать миллионы элементов, поэтому решение должно быть оптимизировано по скорости.
- Не нужно проверять корректность ввода, предполагается, что массив содержит хотя бы один элемент и массив гарантированно содержит уникальное число.

Оптимальное решение этой задачи основано на свойствах XOR (`^`) операций:
- XOR любого числа самого с собой даёт ноль (a^a = 0)
- XOR нуля с любым числом возвращает само число (0^a = a)
- XOR ассоциативен и коммутативен, что позволяет последовательно применять операцию XOR ко всем элементам массива.
Таким образом, мы можем применить операцию XOR ко всем элементам массива, результатом будет именно уникальный элемент, так как пары чисел взаимно уничтожатся друг друга.

Пример работы алгоритма:
Массив `[1, 8, 4, 4, 6, 1, 8]`: 1. 1 ⊕ 8 ⊕ 4 ⊕ 4 ⊕ 6 ⊕ 1 ⊕ 8 2. (1 ⊕ 1) ⊕ (8 ⊕ 8) ⊕ (4 ⊕ 4) ⊕ 6 = 0 ⊕ 0 ⊕ 0 ⊕ 6 = 6

Результат: `6`

Пояснение:
- Операция XOR ассоциативна и коммутативна, поэтому порядок элементов не важен.
- Каждый элемент, встречающийся дважды, взаимно уничтожается, оставляя только одно уникальное число.

Важные моменты:
- Эффективность решения зависит от минимизации количества операций и объема памяти, что достигается использованием операции XOR, выполняемой за линейное время относительно размера массива.
- Так как диапазон значений ограничен, использование стандартного типа данных для целых чисел вполне достаточно.