Платформа: CodeWars

 Название задачи: Non-even substrings (Нечетные подстроки)

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

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

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

 Тэги:  Strings, Fundamentals

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

Given a string of integers, return the number of odd-numbered substrings that can be formed.

For example, in the case of "1341", they are `1, 1, 3, 13, 41, 341, 1341`, a total of `7` numbers. `solve("1341") = 7`.
See test cases for more examples.
Good luck! 

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

Задача состоит в подсчёте количества всех возможных подстрок-чисел, представляющих собой нечётные числа, в строке, состоящей исключительно из цифр.

Рассмотрим подробнее:
- Строка содержит только цифры.
- Подстрока считается нечётной, если соответствующее ей число является нечётным.
- Необходимо найти количество всех таких подстрок.

Примеры:
- Для строки "1341":
- Возможные подстроки: `1, 3, 4, 1, 13, 34, 41, 134, 341, 1341`
- Из них нечётные: `1, 3, 13, 41, 1341`
- Всего нечётных подстрок: 5

- Для строки "123456789":
- Возможные подстроки: все возможные комбинации цифр
- Нечётные подстроки: "1", "3", "5", "7", "9", "13", "35", "57", "79", "135", "357", "579", "1357", "3579", "13579"
- Всего нечётных подстрок: 15

Алгоритм решения предполагает перебор всех возможных подстрок и проверку каждого числа на чётность или нечётность, используя представление строки как числового значения.

Дополнительное пояснение:
Подстроки могут начинаться с любого символа строки и продолжаться до конца строки или до следующего нечётного символа. Из этого следует: каждая возможная подстрока представляет собой непрерывный участок символов, начинающийся с нечётного символа и заканчивающийся либо последним символом строки, либо первым чётным символом после текущего нечётного символа.
Таким образом, задача сводится к последовательному перебору всех возможных начальных позиций нечётных символов и подсчёту всех допустимых подстрок, соответствующих условиям задачи.

 Платформа: CodeWars

 Название задачи: You only need one - Beginner (Вам нужен только один - новичок)

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

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

 Уже решили (На момент написания статьи): 171 678 из 309 413

 Тэги:  Fundamentals, Strings, Arrays

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

You will be given an array `a` and a value `x`.
All you need to do is check whether the provided array contains the value.
The type of `a` and `x` can be `String` or `Int`. `a` can contain numbers or strings. `x` can be either.
Return `true` if the array contains the value, `false` if not.

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

Требуется написать функцию, проверяющую наличие заданного элемента (`x`) в переданном массиве (`a`).

Основные шаги решения:
- Проверить, содержится ли элемент `x` среди элементов массива `a`.
- Если массив пустой или не содержит указанного элемента, вернуть `false`.
- Если хотя бы один элемент массива совпадает с искомым значением, вернуть `true`.

Примеры:
- Массив `[1, 2, 3, 4, 5]`, значение `3` → возвращает `true`
- Массив `[10, 20, 30]`, значение `40` → возвращает `false`
- Массив `[apple, banana, orange]`, значение `"banana"` → возвращает `true`
- Пустой массив [] и любое значение → возвращает `false`

Важные замечания:
- Тип элементов массива и тип искомого значения могут различаться (например, массив может содержать строки и числа одновременно). Нужно учитывать возможность сравнения разнотипных значений.
- Для строковых типов данных проверка должна проводиться с учётом регистра символов.

 Платформа: CodeWars

 Название задачи: Job Matching #1 (Подбор работы №1)

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

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

 Уже решили (На момент написания статьи): 9 515 из 67 133

 Тэги:  Algorithms

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

Let's build a matchmaking system that helps discover jobs for developers based on a number of factors.

One of the simplest, yet most important factors is compensation.As developers we know how much money we need to support our lifestyle, so we generally have a rough idea of the minimum salary we would be satisfied with.

Let's give this a try. We'll create a function `match` (`job_matching` in Python) which takes a `candidate` and a `job`, which will return a Boolean indicating whether the job is a valid match for the candidate.

A candidate will have a minimum salary, so it will look like this:

candidate = { minSalary: 120000 }

A job will have a maximum salary, so it will look like this:
job = { maxSalary: 140000 }

If either the candidate's minimum salary or the job's maximum salary is not present, throw an error.

For a valid match, the candidate's minimum salary must be less than or equal to the job's maximum salary. However, let's also include 10% wiggle room (deducted from the candidate's minimum salary) in case the candidate is a rockstar who enjoys programming on Codewars in their spare time. The company offering the job may be able to work something out.

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

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

Основные моменты:
- Минимальная зарплата кандидата
Каждый кандидат имеет минимальную сумму зарплаты, ниже которой он не согласится на работу. Эта информация представлена в виде параметра `minSalary`.
- Максимальная зарплата вакансии
Каждая вакансия имеет максимальную зарплату, которую компания готова предложить кандидату.
Это представлено через параметр `maxSalary`.
- Условия соответствия Для того чтобы вакансия считалась подходящей для кандидата, минимальная зарплата кандидата должна быть меньше или равна увеличенной на 10% максимальной зарплате вакансии.
То есть, максимальная зарплата компании корректируется на 10%, и проверяется условие: {minSalary} ≤ {maxSalary} * 1.1 - Обработка ошибок
Если отсутствует хотя бы один из параметров минимальной зарплаты кандидата или максимальной зарплаты вакансии, необходимо выбрасывать ошибку.

Примеры:
Пример 1:
Кандидат: { minSalary: 120000 }
Вакансия: { maxSalary: 140000 }
Проверка: 120000 ≤ 140000 × 1.1 = 154000 → соответствует

Пример 2: Кандидат: { minSalary: 150000 }
Вакансия: { maxSalary: 140000 }
Проверка: 150000 > 140000 × 1.1 = 154000 → не соответствует

Алгоритм реализации:
1. Проверяем наличие обоих параметров (минимальной зарплаты кандидата и максимальной зарплаты вакансии).
2. Если параметры отсутствуют, выбрасываем ошибку.
3. Вычисляем скорректированную максимальную зарплату вакансии (увеличиваем её на 10%).
4. Сравниваем минимальную зарплату кандидата с скорректированной зарплатой вакансии.
5. Возвращаем true, если кандидат подходит, иначе false.

 Платформа: CodeWars

 Название задачи: The Jumbler (Неумеха)

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

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

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

 Тэги:  Fundamentals, Algorithms, Data Structures

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

Situation

One day Alice was at the casino on her favorite slot machine ("The Jumbler") when she noticed a set of numbers occasionally flashing in one corner of the screen. She found that by treating them as indices, reordering them according to a pattern, and counting the reorderings, she could know how many spins to make before the machine would finally hit a big jackpot payout!

Reordering

The pattern Alice discovers goes as follows:
select the value at index `zero`
(if the value is `0` do not continue)
elsewise, the value is our search index  
go to new value found at the search index  
remove this new value from its place in order 
reposition this new value onto the front of the list 
(if the new value is `zero`, the reorderings will cease)
elsewise, repeat all instructions with this new ordering

Task

Write a function to help Alice find out the count of times the given integers have to be reordered and thus know how many Jumbler spins to make before betting large and getting a huge payout!!

Input A(n) `array / list / tuple / vector` of unsigned integers.

values represent the indices of the collection itself 
thus the values are all distinct from one another 
and all indices guaranteed to be present 
the values will be randomly shuffled

Output

An unsigned integer of the count of times the given numbers must be reordered according to Alice's Reordering Pattern before the value at index `zero` actually becomes `0` itself.

Example

Step 1
Given the numbers `2, 0, 3, 1`, we select `2` as the search index.
The value `3` is found at that index, so `3` is moved to the front.

Step 2 Now with numbers `3, 2, 0, 1`, we select `3` as the search index.
The value `1` is found at that index, so `1` is moved to the front.

Step 3 Now with numbers `1, 3, 2, 0`, we select `1` as the search index.
The value `3` is found at that index, so `3` is moved to the front.

Step 4 Now with numbers `3, 1, 2, 0`, we select `3` as the search index.
The value `0` is found at that index, so `0` is moved to the front.

Conclusion
With `zero` now finally at the front of the order: `0, 3, 1, 2` the reordering comes to a close, and we have our answer.

In this case, it took `4` steps of reordering to jumble zero to the front. Enjoy!

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

Задача состоит в том, чтобы разработать функцию, моделирующую процесс перестановок элементов массива согласно заданному правилу:
- Извлечь элемент по индексу, равному первому числу в массиве.
- Если извлечённый элемент равен нулю — прекратить выполнение.
- Иначе переместить найденный элемент на первое место в массиве и удалить его исходное положение.
- Повторять до тех пор, пока первый элемент массива не станет нулём.
Таким образом, задача сводится к подсчёту количества шагов, необходимых для перемещения первого элемента массива на первую позицию, после чего он становится равным нулю.

Примеры работы функции:
- Для входного массива `[2, 0, 3, 1]`:
 Исходный массив: [2, 0, 3, 1] → выбираем элемент по индексу 2 (значение 3), перемещаем его на начало: [3, 2, 0, 1] 2. Новый массив: [3, 2, 0, 1] → выбираем элемент по индексу 3 (значение 1), перемещаем его на начало: [1, 3, 2, 0] 3.
Новый массив: [1, 3, 2, 0] → выбираем элемент по индексу 1 (значение 3), перемещаем его на начало: [3, 1, 2, 0] 4.
Новый массив: [3, 1, 2, 0] → выбираем элемент по индексу 3 (значение 0), перемещаем его на начало: [0, 3, 1, 2]
Итоговое количество шагов: 4.

- Для входного массива `[1, 0, 2]`: 
Исходный массив: [1, 0, 2] → выбираем элемент по индексу 1 (значение 0), перемещаем его на начало: [0, 1, 2]
" Итоговое количество шагов: 1.

Функция должна эффективно обрабатывать случайные входные данные, проверяя корректность индексов и останавливаясь при достижении нуля.

 Платформа: CodeWars

 Название задачи: Fix string case (Исправлен регистр строк)

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

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

 Уже решили (На момент написания статьи): 36 473 из 83 543

 Тэги:  Fundamentals

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

In this Kata, you will be given a string that may have mixed uppercase and lowercase letters and your task is to convert that string to either lowercase only or uppercase only based on:

make as few changes as possible.
if the string contains equal number of uppercase and lowercase letters, convert the string to lowercase.

For example:
solve("coDe") = "code". Lowercase characters > uppercase. Change only the "D" to lowercase.
solve("CODe") = "CODE". Uppercase characters > lowecase.Change only the "e" to uppercase.
solve("coDE") = "code". Upper == lowercase. Change all to lowercase. More examples in test cases. Good luck!

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

Задача состоит в преобразовании строки таким образом, чтобы она содержала либо только строчные, либо только заглавные буквы, минимизируя изменения символов.

Основные правила:
- Если количество строчных букв больше количества заглавных, строка должна быть переведена в нижний регистр.
- Если количество заглавных букв больше строчных, строка переводится в верхний регистр.
- Если количество строчных и заглавных букв одинаково, строка преобразуется в нижний регистр.

Пример: - `solve("coDe")` → "code"
— перевели заглавную букву «D» в строчную, так как строчных букв больше.
- `solve("CODe")` → "CODE"
— перевели строчную букву «е» в заглавную, поскольку заглавных букв больше.
- `solve("coDE")` → "code" — равное количество заглавных и строчных букв, поэтому результат в нижнем регистре.

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

Примеры:
- Вход: "HelloWorld"
- Заглавных букв: 2 («H», «W»),Строчных: 5 («e», «l», «l», «o», «r», «d»).
- Поскольку строчных букв больше, итоговый результат будет `"helloworld"`.

- Вход: "HELLOworld"
- Заглавных букв: 5 («H», «E», «L», «L», «O»), Строчных: 1 («w»).
- Итоговый результат: `"HELLOWORLD"`.

- Вход: `"HeLLoWoRLd"`
- Заглавных букв: 3 («H», «L», «L»), Строчных: 4 («e», «o», «w», «r», «d»).
- Равное количество заглавных и строчных букв, значит результат в нижнем регистре: "helloworld".

 Платформа: CodeWars

 Название задачи: Well efficiency calculator (Калькулятор эффективности скважины)

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

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

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

 Тэги:  Arrays, Fundamentals

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

In this kata you have a `20` x `20` preloaded array of oil saturation in some region.Your task is to answer whether it is efficient to place the well at the given point.A well is efficient if its efficiency is bigger or equal to given threshold.

Input parameters in that function are:

`x` and `y` integer coordinates of the well (indexes of 2D array, using `x` for rows, `y` for columns)
efficiency threshold (float or integer)

The preloaded `FIELD` contains values from `0.00` to `0.99` inclusive, such as:
0.98, 0.65, 0.23, 0.39, 0.99...

(In Python and Ruby each value is stored as a `float`. In C each value is stored as a `double`)

Examples of usage:
x = 10
y = 10
threshold = 3.5
expected result => True / true

x = 7
y = 3
threshold = 4.5
expected result => False / false

To calculate the current efficiency of a well, you should sum up all saturations of cells adjacent to the specified cell plus the saturation of the specified cell itself.
The efficiency of the marked point with `0.43` is `5.3` (sum of all cells in square).
If you need to calculate the efficiency at the edge of the field, you should just take in account only cells in the field.

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

Задача заключается в определении эффективности бурения нефтяной скважины в заданной точке двумерного массива насыщенности нефти.

Описание входных данных и условий:
- Дано двумерный массив размером 20 * 20, содержащий значения насыщенности нефти от 0.00 до 0.99.
- Координаты точки, где планируется разместить скважину, представлены целыми числами `(x, y)` — индексами строк и столбцов массива.
- Указан порог эффективности (целое число или вещественное число).
- Эффективность скважины определяется суммой значений насыщенности нефти в соседних ячейках (восемь ближайших ячеек: сверху, снизу, слева, справа, а также диагонали) плюс значение самой ячейки.

Примеры:
- Если координаты скважины `(10, 10)` и порог эффективности 3.5, то эффективность скважины будет больше порога, поскольку сумма насыщенности в квадрате 3 * 3 (включая саму точку) даст значение больше порога.
- Если скважина расположена в позиции `(7, 3)` и порог равен 4.5, то суммарная эффективность меньше порога, следовательно, скважина неэффективна.

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

Пример вычисления эффективности:

Для точки с координатами `(10, 10)` и значением насыщенности `0.43`, эффективность рассчитывается следующим образом:

| | 9 | 10 | 11 |
|---|---|----|---|
| 9 | | 0.43 |    |
| 10 | 0.65 | 0.98 | 0.23 |
| 11 |    | 0.39 |    |
Суммируются значения соседних ячеек (по горизонтали, вертикали и диагоналям):
0.43 + 0.65 + 0.98 + 0.23 + 0.39 = 2.68