Вам дан массив mountain с индексом 0. Ваша задача — найти все вершины в массиве mountain.
Верните массив, состоящий из индексов вершин в заданном массиве в любом порядке.
Примечания:

Вершина определяется как элемент, который строго больше соседних элементов.
Первый и последний элементы массива не являются вершиной.

Пример 1:

Входные данные: mountain = [2,4,4]
Выходные данные: []
Пояснение: mountain[0] и mountain[2] не могут быть вершиной, поскольку они являются первым и последним элементами массива.
mountain[1] также не может быть вершиной, поскольку она не строго больше mountain[2].
Поэтому ответ — [].

Пример 2:

Входные данные: mountain = [1,4,3,8,5]
Выходные данные: [1,3]
Пояснение: mountain[0] и mountain[4] не могут быть вершиной, поскольку они являются первым и последним элементами массива.
mountain[2] также не может быть вершиной, поскольку она не строго больше, чем mountain[3] и mountain[1].
Но mountain[1] и mountain[3] строго больше, чем их соседние элементы.
Поэтому ответ [1,3].

Ограничения:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Дан массив mountain с индексом 0. Ваша задача — найти все вершины в массиве mountain. Верните массив, состоящий из индексов вершин в данном массиве в любом порядке.
Примечания:

Вершина определяется как элемент, который строго больше своих соседних элементов.
Первый и последний элементы массива не являются вершинами.

Пример 1:

Вход: mountain = [2,4,4]
Выход: []
Объяснение: mountain[0] и mountain[2] не могут быть вершинами, так как они являются первыми и последними элементами массива.
mountain[1] также не может быть вершиной, так как он не строго больше mountain[2].
Таким образом, ответ — [].

Пример 2:

Вход: mountain = [1,4,3,8,5]
Выход: [1,3]
Объяснение: mountain[0] и mountain[4] не могут быть вершинами, так как они являются первыми и последними элементами массива.
mountain[2] также не может быть вершиной, так как он не строго больше mountain[3] и mountain[1].
Но mountain[1] и mountain[3] строго больше своих соседних элементов.
Таким образом, ответ — [1,3].

Ограничения:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Дан массив mountain с индексом 0. Ваша задача — найти все вершины в массиве mountain.
Верните массив, состоящий из индексов вершин в данном массиве в любом порядке.
Примечания:

Вершина определяется как элемент, который строго больше своих соседних элементов.
Первый и последний элементы массива не являются вершинами.

Пример 1:

Ввод: mountain = [2,4,4]
Вывод: []
Объяснение: mountain[0] и mountain[2] не могут быть вершинами, так как они являются первыми и последними элементами массива.
mountain[1] также не может быть вершиной, так как он не строго больше mountain[2].
Таким образом, ответ — [].

Пример 2:

Ввод: mountain = [1,4,3,8,5]
Вывод: [1,3]
EОбъяснение: mountain[0] и mountain[4] не могут быть вершинами, так как они являются первыми и последними элементами массива.
mountain[2] также не может быть вершиной, так как он не строго больше mountain[3] и mountain[1].
Но mountain[1] и mountain[3] строго больше своих соседних элементов.
Таким образом, ответ — [1,3].

Ограничения:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


Дана строка word и целое число k.
Подстрока s строки word называется полной, если:

Каждый символ в s встречается ровно k раз.
Разница между двумя соседними символами не более 2. То есть для любых двух соседних символов c1 и c2 в s абсолютная разница в их позициях в алфавите не превышает 2.

Верните количество полных подстрок строки word.
Подстрока — это непустая непрерывная последовательность символов в строке.

Пример 1:

Ввод: word = "igigee", k = 2
Вывод: 3
Объяснение: Полные подстроки, в которых каждый символ появляется ровно дважды и разница между соседними символами не более 2: igigee, igigee, igigee.

Пример 2:

Ввод: word = "aaabbbccc", k = 3
Вывод: 6
Объяснение: Полные подстроки, в которых каждый символ появляется ровно трижды и разница между соседними символами не более 2: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Ограничения:

1 <= word.length <= 10^5
word состоит только из строчных английских букв.
1 <= k <= word.length

Дана строка word и целое число k.
Подстрока s строки word является полной, если:

Каждый символ в s встречается ровно k раз.
Разница между двумя соседними символами не превышает 2. То есть для любых двух соседних символов c1 и c2 в s абсолютная разница в их позициях в алфавите не превышает 2.

Верни количество полных подстрок строки word.
Подстрока — это непустая непрерывная последовательность символов в строке.

Пример 1:

Input: word = "igigee", k = 2
Output: 3
Объяснение: Полные подстроки, в которых каждый символ встречается ровно дважды и разница между соседними символами не превышает 2: igigee, igigee, igigee.

Пример 2:

Input: word = "aaabbbccc", k = 3
Output: 6
Объяснение: Полные подстроки, в которых каждый символ втречается ровно трижды и разница между соседними символами не превышает 2: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Constraints:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= k <= word.length

Вам дана строка word и целое число k.
Подстрока s слова word является полной, если:

Каждый символ в s встречается ровно k раз.
Разница между двумя соседними символами не превышает 2. То есть для любых двух соседних символов c1 и c2 в s абсолютная разность их позиций в алфавите не превышает 2.

Верните количество полных подстрок word.
Подстрока — это непустая непрерывная последовательность символов в строке.

Пример 1:

Входные данные: word = "igigee", k = 2
Выходные данные: 3
Объяснение: Полные подстроки, в которых каждый символ встречается ровно дважды, а разница между соседними символами не превышает 2: igig, igee, gige.

Пример 2:

Вход: word = "aaabbbccc", k = 3
Выход: 6
Пояснение: Полные подстроки, в которых каждый символ встречается ровно три раза, а разница между соседними символами не превышает 2: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Ограничения:

1 <= word.length <= 10^5
word состоит только из строчных английских букв.
1 <= k <= word.length


Дано целое число n и 0-индексированный массив sick, отсортированный в возрастающем порядке. В очереди стоят n детей с позициями от 0 до n - 1, назначенными им. Массив sick содержит позиции детей, которые заражены инфекционным заболеванием. Зараженный ребенок на позиции i может распространить болезнь на любого из его ближайших соседей на позициях i - 1 и i + 1, если они существуют и в настоящее время не заражены. За одну секунду может заразиться не более одного ребенка, который ранее не был инфицирован.

Доказано, что после некоторого конечного числа секунд все дети в очереди заразятся болезнью. Последовательность заражения — это последовательный порядок позиций, в котором все незараженные дети получают инфекцию. Вернуть общее количество возможных последовательностей заражения. Поскольку ответ может быть большим, вернуть его по модулю 10^9 + 7.

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

Пример 1:

Ввод: n = 5, sick = [0,4]
Вывод: 4
Пояснение: Дети на позициях 1, 2 и 3 вначале не заражены. Существует 4 возможных последовательности заражения:
- Дети на позициях 1 и 3 могут заразиться, так как их позиции соприкасаются с зараженными детьми 0 и 4. Ребенок на позиции 1 заражается первым.
Теперь ребенок на позиции 2 находится рядом с ребенком на позиции 1, который заражен, и ребенок на позиции 3 находится рядом с ребенком на позиции 4, который заражен, поэтому любой из них может заразиться. Ребенок на позиции 2 заражается.
Наконец, ребенок на позиции 3 заражается, так как он находится рядом с детьми на позициях 2 и 4, которые заражены. Последовательность заражения — [1,2,3].

- Дети на позициях 1 и 3 могут заразиться, так как их позиции соприкасаются с зараженными детьми 0 и 4. Ребенок на позиции 1 заражается первым.
Теперь ребенок на позиции 2 находится рядом с ребенком на позиции 1, который заражен, и ребенок на позиции 3 находится рядом с ребенком на позиции 4, который заражен, поэтому любой из них может заразиться. Ребенок на позиции 3 заражается.
Наконец, ребенок на позиции 2 заражается, так как он находится рядом с детьми на позициях 1 и 3, которые заражены. Последовательность заражения — [1,3,2].

- Последовательность заражения — [3,1,2]. Порядок заражения болезнью среди детей можно представить как: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

- Последовательность заражения — [3,2,1]. Порядок заражения болезнью среди детей можно представить как: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Ввод: n = 4, sick = [1]
Вывод: 3
Пояснение: Дети на позициях 0, 2 и 3 вначале не заражены. Существует 3 возможных последовательности заражения:
- Последовательность заражения — [0,2,3]. Порядок заражения болезнью среди детей можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

- Последовательность заражения — [2,0,3]. Порядок заражения болезнью среди детей можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

- Последовательность заражения — [2,3,0]. Порядок заражения болезнью среди детей можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничения:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick отсортирован в возрастающем порядке.

Вам дается целое n и 0-индексированный целочисленный массив больных, который сортируется в порядке возрастания.
В очереди стоят n детей с назначенными им позициями от 0 до n - 1. Массив больных содержит позиции детей, инфицированных инфекционным заболеванием. Инфицированный ребенок в положении i могу распространить болезнь на любой из его ближайших соседей детей в положении i - 1 и i + 1, если они существуют и в настоящее время не инфицированы. Не более одного ребенка, который ранее не был инфицирован, может заразиться болезнью в одну секунду.
Можно показать, что через определенное количество секунд все дети в очереди будут инфицированы болезнью. Последовательность инфекций — это последовательность позиций, в которых все неинфицированные дети инфицируются болезнью. Вернуть общее количество возможных последовательностей инфекции.
Так как ответ может быть большим, верните его по модулю 10^9 + 7.
Обратите внимание, что последовательность инфекций не содержит положения детей, которые уже были инфицированы болезнью в начале.

Пример 1:

Вход: n = 5, sick = [0,4]
Выход: 4
Объяснение: дети на позициях 1, 2 и 3 изначально не инфицированы. Существует 4 возможных последовательности инфекций:
- дети на позициях 1 и 3 могут заразиться, так как их позиции находятся рядом с инфицированными детьми 0 и 4. Ребенок на позиции 1 сначала заражается.
Теперь ребенок на позиции 2 находится рядом с инфицированным ребенком на позиции 1, а ребенок на позиции 3 - рядом с инфицированным ребенком на позиции 4, поэтому любой из них может заразиться. Ребенок на второй позиции заражается.
Наконец, ребенок на позиции 3 инфицируется, поскольку он находится рядом с инфицированными детьми на позициях 2 и 4. Последовательность инфекций [1,2,3].
- дети на позициях 1 и 3 могут заразиться, потому что их позиции находятся рядом с инфицированными детьми 0 и 4. Ребенок на первой позиции сначала заражается.
Теперь ребенок на позиции 2 находится рядом с инфицированным ребенком на позиции 1, а ребенок на позиции 3 - рядом с инфицированным ребенком на позиции 4, поэтому любой из них может заразиться. Ребенок на третьей позиции заражается.
Наконец, ребенок на позиции 2 инфицируется, поскольку он находится рядом с инфицированными детьми на позициях 1 и 3. Последовательность инфекций [1,3,2].
- последовательность инфекций [3,1,2]. Порядок распространения заболевания у детей может быть следующим: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- последовательность инфекций [3,2,1]. Порядок распространения заболевания у детей может быть следующим: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Вход: n = 4, sick = [1]
Выход: 3
Объяснение: дети на позициях 0, 2 и 3 изначально не инфицированы. Есть 3 возможных последовательности инфекций:
- последовательность инфекций [0,2,3]. Порядок передачи заболевания детям можно рассматривать как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- последовательность инфекций [2,0,3]. Порядок передачи заболевания детям можно рассматривать как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- последовательность инфекций [2,3,0]. Порядок передачи заболевания детям можно рассматривать как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничения:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick is sorted in increasing order.

Дано целое число n и 0-индексированный целочисленный массив sick, отсортированный по возрастанию. В очереди стоят n детей, которым назначены позиции от 0 до n - 1. Массив sick содержит позиции детей, которые заражены инфекционным заболеванием. Инфицированный ребенок на позиции i может распространить болезнь на любого из его ближайших соседей на позициях i - 1 и i + 1, если они существуют и в настоящее время не инфицированы. За одну секунду может заразиться не более одного ребенка, который ранее не был инфицирован.

Доказано, что после некоторого конечного числа секунд все дети в очереди заразятся болезнью. Последовательность заражения — последовательный порядок позиций, в котором все неинфицированные дети заражаются заболеванием. Выведи общее количество возможных последовательностей заражения. Поскольку ответ может быть большим, выведи его по модулю 10^9 + 7.

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

Пример 1:

Ввод: n = 5, sick = [0,4]
Вывод: 4
Пояснение: Дети на позициях 1, 2 и 3 вначале не заражены. Существует 4 возможных последовательности заражения:
- Дети на позициях 1 и 3 могут заразиться, поскольку их позиции соприкасаются с инфицированными детьми 0 и 4. Ребенок на позиции 1 заражается первым.
Теперь ребенок на позиции 2 находится рядом с инфицированным ребенком на позиции 1, а ребенок на позиции 3 находится рядом с инфицированным ребенком на позиции 4, поэтому любой из них может заразиться. Ребенок на позиции 2 заражается.
Наконец, ребенок на позиции 3 заражается, поскольку он находится рядом с инфицированными детьми на позициях 2 и 4. Последовательность заражения — [1,2,3].

- Дети на позициях 1 и 3 могут заразиться, поскольку их позиции соприкасаются с инфицированными детьми 0 и 4. Ребенок на позиции 1 заражается первым.
Теперь ребенок на позиции 2 находится рядом с инфицированным ребенком на позиции 1, а ребенок на позиции 3 находится рядом с инфицированным ребенком на позиции 4, поэтому любой из них может заразиться. Ребенок на позиции 3 заражается.
Наконец, ребенок на позиции 2 заражается, поскольку он находится рядом с инфицированными детьми на позициях 1 и 3. Последовательность заражения — [1,3,2].

- Последовательность заражения — [3,1,2]. Порядок заражения болезнью можно представить как: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

- Последовательность заражения — [3,2,1]. Порядок заражения болезнью можно представить как: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Ввод: n = 4, sick = [1]
Вывод: 3
Пояснение: Дети на позициях 0, 2 и 3 вначале не инфицированы. Существует 3 возможных последовательности заражения:
- Последовательность заражения — [0,2,3]. Порядок заражения болезнью можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

- Последовательность заражения — [2,0,3]. Порядок заражения болезнью можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

- Последовательность заражения — [2,3,0]. Порядок заражения болезнью можно представить как: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничения:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick отсортирован по возрастанию.


Вам дан целочисленный массив nums и целое число k.
Частота элемента x — это количество раз, которое он встречается в массиве.
Массив называется хорошим, если частота каждого элемента в этом массиве меньше или равна k.
Возвращает длину самого длинного хорошего подмассива nums.
Подмассив — это непрерывная непустая последовательность элементов в массиве.

Пример 1:

Входные данные: nums = [1,2,3,1,2,3,1,2], k = 2
Выходные данные: 6
Пояснение: Самый длинный возможный хороший подмассив — [1,2,3,1,2,3], поскольку значения 1, 2 и 3 встречаются в этом подмассиве не более двух раз. Обратите внимание, что подмассивы [2,3,1,2,3,1] и [3,1,2,3,1,2] также являются хорошими.
Можно показать, что нет хороших подмассивов с длиной больше 6.

Пример 2:

Вход: nums = [1,2,1,2,1,2,1,2], k = 1
Выход: 2
Пояснение: Самый длинный возможный хороший подмассив — [1,2], так как значения 1 и 2 встречаются в этом подмассиве не чаще одного раза. Обратите внимание, что подмассив [2,1] также является хорошим.
Можно показать, что нет хороших подмассивов с длиной больше 2.

Пример 3:

Вход: nums = [5,5,5,5,5,5,5], k = 4
Выход: 4
Пояснение: Самый длинный возможный хороший подмассив — [5,5,5,5], так как значение 5 встречается в этом подмассиве 4 раза.
Можно показать, что нет хороших подмассивов с длиной больше 4.

Ограничения:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
1 <= k <= nums.length

У вас есть массив целых чисел nums и целое число k. Частота элемента x — это количество раз, которое он встречается в массиве. Массив называется хорошим, если частота каждого элемента в этом массиве меньше или равна k. Верните длину самого длинного хорошего подмассива из nums. Подмассив — это непрерывная непустая последовательность элементов внутри массива.

Пример 1:

Входные данные: nums = [1,2,3,1,2,3,1,2], k = 2 Выходные данные: 6 Объяснение: Самый длинный возможный хороший подмассив — это [1,2,3,1,2,3], так как значения 1, 2 и 3 встречаются не более двух раз в этом подмассиве. Обратите внимание, что подмассивы [2,3,1,2,3,1] и [3,1,2,3,1,2] также хороши. Можно показать, что нет хороших подмассивов длиной более 6.

Пример 2:

Входные данные: nums = [1,2,1,2,1,2,1,2], k = 1 Выходные данные: 2 Объяснение: Самый длинный возможный хороший подмассив — это [1,2], так как значения 1 и 2 встречаются не более одного раза в этом подмассиве. Обратите внимание, что подмассив [2,1] также хорош. Можно показать, что нет хороших подмассивов длиной более 2.

Пример 3:

Входные данные: nums = [5,5,5,5,5,5,5], k = 4 Выходные данные: 4 Объяснение: Самый длинный возможный хороший подмассив — это [5,5,5,5], так как значение 5 встречается 4 раза в этом подмассиве. Можно показать, что нет хороших подмассивов длиной более 4.

Ограничения:

1 <= nums.length <= 10^5 1 <= nums[i] <= 10^9 1 <= k <= nums.length


Дан целочисленный массив nums с индексом 0 четной длины, а также пустой массив arr. Алиса и Боб решили сыграть в игру, в которой в каждом раунде они делают по одному ходу. Правила игры следующие:

В каждом раунде сначала Алиса удаляет минимальный элемент из nums, затем Боб делает то же самое.
Потом Боб добавляет удаленный элемент в массив arr, а затем Алиса делает то же самое.
Игра продолжается, пока nums не станет пустым.

Выведи полученный массив arr.

Пример 1:

Ввод: nums = [5,4,2,3]
Вывод: [3,2,5,4]
Пояснение: В первом раунде сначала Алиса удаляет 2, потом Боб удаляет 3. Затем в arr сначала Боб добавляет 3, а потом Алиса добавляет 2. Таким образом, arr = [3,2].
В начале второго раунда nums = [5,4]. Теперь сначала Алиса удаляет 4, потом Боб удаляет 5. Затем оба добавляют в arr, и он становится [3,2,5,4].

Пример 2:

Ввод: nums = [2,5]
Вывод: [5,2]
Пояснение: В первом раунде сначала Алиса удаляет 2, затем Боб удаляет 5. Затем Боб добавляет в arr, потом Алиса. Таким образом, arr = [5,2].

Ограничения:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

Вам дан целочисленный массив nums с индексом 0 чётной длины, а также есть пустой массив arr. Алиса и Боб решили сыграть в игру, в которой в каждом раунде Алиса и Боб будут делать один ход. Правила игры следующие:

В каждом раунде сначала Алиса удаляет минимальный элемент из nums, а затем то же самое делает Боб.
Теперь сначала Боб добавляет удалённый элемент в массив arr, а затем то же самое делает Алиса.
Игра продолжается до тех пор, пока nums не станет пустым.

Верните полученный массив arr.

Пример 1:

Вход: nums = [5,4,2,3]
Выход: [3,2,5,4]
Объяснение: В первом раунде сначала Алиса удаляет 2, а затем Боб удаляет 3. Затем в arr сначала Боб добавляет 3, а затем Алиса добавляет 2. Таким образом, arr = [3,2].
В начале второго раунда nums = [5,4]. Теперь сначала Алиса удаляет 4, а затем Боб удаляет 5. Затем оба добавляют в arr, что становится [3,2,5,4].

Пример 2:

Вход: nums = [2,5]
Выход: [5,2]
Пояснение: В первом раунде сначала Алиса удаляет 2, а затем Боб удаляет 5. Затем в arr сначала добавляет Боб, а затем добавляет Алиса. Таким образом, arr = [5,2].

Ограничения:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

Вам дан 0-индексированный целочисленный массив четной длины а также пустой массив arr. Алиса и Боб решили сыграть в игру, где в каждом раунде Алиса и Боб сделают Один ход. Правила игры таковы:

Каждый раунд, сначала Алиса удалит минимальный элемент из nums, а затем Боб делает то же самое.
Сначала Боб добавит удаленный элемент в массив arr, а затем Алиса сделает то же самое.
Игра продолжается до тех пор, пока nums не станет пустым.

Вернуть результирующий массив arr.

Пример 1:

Ввод: nums = [5,4,2,3]
Выход: [3,2,5,4]
Объяснение: в первом раунде сначала Алиса удаляет 2, а потом Боб удаляет 3. Затем в arr сначала Боб добавляет 3, а затем Алиса добавляет 2. Так arr = [3,2].
В начале второго раунда nums = [5,4]. Сначала Алиса удаляет 4, а потом Боб удаляет 5. Затем оба добавляют свои элементы в arr который становится [3,2,5,4].

Пример 2:

Ввод: nums = [2,5]
Выход: [5,2]
Объяснение: в первом раунде сначала Алиса удаляет 2, а потом Боб удаляет 5. Затем в arr сначала Боб добавляет, а затем Алиса добавляет. Так arr = [5,2].

Ограничения:

1 <= длина чисел <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0


Дана 0-индексированная двумерная целочисленная матрица grid размером n * n со значениями в диапазоне [1, n^2]. Каждое число встречается только один раз, кроме числа a, которое встречается дважды, и числа b, которое отсутствует. Задача состоит в том, чтобы найти повторяющееся и отсутствующее числа a и b. Верни 0-индексированный целочисленный массив ans размером 2, где ans[0] равно a, а ans[1] равно b.

Пример 1:

Ввод: grid = [[1,3],[2,2]]
Вывод: [2,4]
Пояснение: Число 2 повторяется, а число 4 отсутствует, поэтому ответ [2,4].

Пример 2:

Ввод: grid = [[9,1,7],[8,9,2],[3,4,6]]
Вывод: [9,5]
Пояснение: Число 9 повторяется, а число 5 отсутствует, поэтому ответ [9,5].

Ограничения:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Для всех x, где 1 <= x <= n * n, существует только один x, который не равен ни одному элементу grid.
Для всех x, где 1 <= x <= n * n, существует только один x, который равен ровно двум элементам grid.
Для всех x, где 1 <= x <= n * n, кроме двух из них, существует ровно одна пара i, j, где 0 <= i, j <= n - 1 и grid[i][j] == x.

Дана матрица целых чисел grid размером n * n с индексами с нуля, содержащая значения в диапазоне [1, n^2]. Каждое число встречается ровно один раз, кроме числа a, которое встречается дважды, и числа b, которое отсутствует. Задача состоит в том, чтобы найти повторяющееся и отсутствующее числа a и b. Верните целочисленный массив ans размером 2 с индексами с нуля, где ans[0] равно a, а ans[1] равно b.

Пример 1:

Input: grid = [[1,3],[2,2]]
Output: [2,4]
Объяснение: Число 2 повторяется, а число 4 отсутствует, поэтому ответ [2,4].

Пример 2:

Input: grid = [[9,1,7],[8,9,2],[3,4,6]]
Output: [9,5]
Объяснение: Число 9 повторяется, а число 5 отсутствует, поэтому ответ [9,5].

Ограничения:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Для всех x таких, что 1 <= x <= n * n, существует ровно один x, который не равен ни одному из членов grid.
Для всех x таких, что 1 <= x <= n * n, существует ровно один x, который равен ровно двум из членов grid.
Для всех x таких, что 1 <= x <= n * n, кроме двух из них, существует ровно одна пара i, j, такая что 0 <= i, j <= n - 1 и grid[i][j] == x.

Дана матрица целых чисел grid размером n * n с индексами с нуля, содержащая значения в диапазоне [1, n^2]. Каждое число встречается ровно один раз, кроме числа a, которое встречается дважды, и числа b, которое отсутствует. Задача состоит в том, чтобы найти повторяющееся и отсутствующее числа a и b.
Верните целочисленный массив ans размером 2 с индексами с нуля, где ans[0] равно a, а ans[1] равно b.

Пример 1:

Ввод: grid = [[1,3],[2,2]]
Вывод: [2,4]
Объяснение: Число 2 повторяется, а число 4 отсутствует, поэтому ответ [2,4].

Пример 2:

Ввод: grid = [[9,1,7],[8,9,2],[3,4,6]]
Вывод: [9,5]
Объяснение: Число 9 повторяется, а число 5 отсутствует, поэтому ответ [9,5].

Ограничения:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Для всех x таких, что 1 <= x <= n * n, существует ровно один x, который не равен ни одному из членов grid.
Для всех x таких, что 1 <= x <= n * n, существует ровно один x, который равен ровно двум из членов grid.
Для всех x таких, что 1 <= x <= n * n, кроме двух из них, существует ровно одна пара i, j, такая что 0 <= i, j <= n - 1 и grid[i][j] == x.


Вам даны два целочисленных массива с индексами, начинающимися с 0: nums1 и nums2, длиной n, которая является четной.
Вы должны удалить n / 2 элементов из nums1 и n / 2 элементов из nums2. После удаления вставьте оставшиеся элементы nums1 и nums2 в множество s.
Верните максимально возможный размер множества s.

Пример 1:

Ввод: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Вывод: 2
Объяснение: Удаляем два вхождения 1 из nums1 и nums2. После удаления массивы становятся равными nums1 = [2,2] и nums2 = [1,1]. Таким образом, s = {1,2}.
Можно показать, что 2 является максимально возможным размером множества s после удаления.

Пример 2:

Ввод: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Вывод: 5
Объяснение: Удаляем 2, 3 и 6 из nums1, а также 2 и два вхождения 3 из nums2. После удаления массивы становятся равными nums1 = [1,4,5] и nums2 = [2,3,2]. Таким образом, s = {1,2,3,4,5}.
Можно показать, что 5 является максимально возможным размером множества s после удаления.

Пример 3:

Ввод: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Вывод: 6
Объяснение: Удаляем 1, 2 и 3 из nums1, а также 4, 5 и 6 из nums2. После удаления массивы становятся равными nums1 = [1,2,3] и nums2 = [4,5,6]. Таким образом, s = {1,2,3,4,5,6}.
Можно показать, что 6 является максимально возможным размером множества s после удаления.

Ограничения:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n четно.
1 <= nums1[i], nums2[i] <= 10^9

Вам даны два целочисленных массива nums1 и nums2 с индексом 0 и четной длиной n.
Вы должны удалить n / 2 элементов из nums1 и n / 2 элементов из nums2. После удалений вы вставляете оставшиеся элементы nums1 и nums2 в множество s.
Верните максимально возможный размер множества s.

Пример 1:

Входные данные: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Выходные данные: 2
Пояснение: Мы удаляем два вхождения 1 из nums1 и nums2. После удалений массивы становятся равными nums1 = [2,2] и nums2 = [1,1]. Следовательно, s = {1,2}.
Можно показать, что 2 — это максимально возможный размер множества s после удалений.

Пример 2:

Вход: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Выход: 5
Пояснение: Удаляем 2, 3 и 6 из nums1, а также 2 и два вхождения 3 из nums2. После удалений массивы становятся равными nums1 = [1,4,5] и nums2 = [2,3,2]. Следовательно, s = {1,2,3,4,5}.
Можно показать, что 5 — это максимально возможный размер множества s после удалений.

Пример 3:

Вход: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Выход: 6
Пояснение: Удаляем 1, 2 и 3 из nums1, а также 4, 5 и 6 из nums2. После удалений массивы становятся равными nums1 = [1,2,3] и nums2 = [4,5,6]. Следовательно, s = {1,2,3,4,5,6}.
Можно показать, что 6 — это максимально возможный размер множества s после удалений.

Ограничения:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n четное.
1 <= nums1[i], nums2[i] <= 10^9

Вам даны два целочисленных массива nums1 и nums2 с 0-индексом чётной длины n.
Вы должны удалить  n / 2 элемента из nums1 и  n / 2 элементов из nums2. После удаления вы вставляете оставшиеся элементы nums1 и nums2 в набор s.
Возвращает максимально возможный размер набора s.

Пример 1:

Ввод: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Вывод: 2
Объяснение: Мы удаляем два вхождения 1 из nums1 и nums2. После удалений массивы становятся равными nums1 = [2,2] и nums2 = [1,1]. Следовательно, s = {1,2}.
Можно показать, что 2 — максимально возможный размер множества s после удалений.

Пример 2:

Ввод: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Вывод: 5
Объяснение: Мы удаляем 2, 3 и 6 из nums1, а также 2 и два вхождения 3 из nums2. После удалений массивы становятся равными nums1 = [1,4,5] и nums2 = [2,3,2]. Следовательно, s = {1,2,3,4,5}.
Можно показать, что 5 — максимально возможный размер множества s после удалений.

Пример 3:

Ввод: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Вывод: 6
Пояснение: Мы удаляем 1, 2, и 3 из nums1, а также 4, 5, и 6 из nums2. После удалений массивы становятся равными nums1 = [1,2,3] и nums2 = [4,5,6]. Следовательно, s = {1,2,3,4,5,6}.
Можно показать, что 6 это максимально возможный размер множества s после удалений.

Ограничения:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n чётное.
1 <= nums1[i], nums2[i] <= 10^9


Вам дан целочисленный массив nums, 0-индексированный, длиной n.
Вам разрешено выполнять специальный ход любое количество раз (включая ноль) с nums. В одном специальном ходе вы выполняете следующие шаги в порядке:

Выберите индекс i в диапазоне [0, n - 1], и положительное целое число x.
Добавьте |nums[i] - x| к общей стоимости.
Измените значение nums[i] на x.

Палиндромное число — это положительное целое число, которое остается таким же, если его цифры перевернуть. Например, 121, 2552 и 65756 являются палиндромными числами, тогда как 24, 46, 235 не являются палиндромными числами.
Массив считается равнопалиндромным, если все элементы в массиве равны целому числу y, где y — палиндромное число, меньшее чем 10^9.
Верните целое число, обозначающее минимально возможную общую стоимость, чтобы сделать nums равнопалиндромным, выполняя любое количество специальных ходов.

Пример 1:

Ввод: nums = [1,2,3,4,5]
Вывод: 6
Объяснение: Мы можем сделать массив равнопалиндромным, изменив все элементы на 3, что является палиндромным числом. Стоимость изменения массива на [3,3,3,3,3], используя 4 специальных хода, равна |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 3, не может быть достигнуто с меньшими затратами.

Example 2:

Ввод: nums = [10,12,13,14,15]
Вывод: 11
Объяснение: Мы можем сделать массив равнопалиндромным, изменив все элементы на 11, что является палиндромным числом. Стоимость изменения массива на [11,11,11,11,11], используя 5 специальных ходов, равна |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 11, не может быть достигнуто с меньшими затратами.

Example 3:

Ввод: nums = [22,33,22,33,22]
Вывод: 22
Объяснение: Мы можем сделать массив равнопалиндромным, изменив все элементы на 22, что является палиндромным числом. Стоимость изменения массива на [22,22,22,22,22], используя 2 специальных хода, равна |33 - 22| + |33 - 22| = 22.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 22, не может быть достигнуто с меньшими затратами.

Ограничения:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

Вам дан целочисленный массив nums, 0-индексированный, длиной n.
Вам разрешено выполнять специальный ход любое количество раз (включая ноль) с nums. В одном специальном ходе вы выполняете следующие шаги в порядке:

Выберите индекс i в диапазоне [0, n - 1], и положительное целое число x.
Добавьте |nums[i] - x| к общей стоимости.
Измените значение nums[i] на x.

Палиндромное число — это положительное целое число, которое остается таким же, если его цифры перевернуть. Например, 121, 2552 и 65756 являются палиндромными числами, тогда как 24, 46, 235 не являются палиндромными числами.
Массив считается равнопалиндромным, если все элементы в массиве равны целому числу y, где y — палиндромное число, меньшее чем 10^9.
Верните целое число, обозначающее минимально возможную общую стоимость, чтобы сделать nums равнопалиндромным, выполняя любое количество специальных ходов.

Пример 1:

Input: nums = [1,2,3,4,5]
Output: 6
Explanation: Мы можем сделать массив равнопалиндромным, изменив все элементы на 3, что является палиндромным числом. Стоимость изменения массива на [3,3,3,3,3], используя 4 специальных хода, равна |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 3, не может быть достигнуто с меньшими затратами.

Пример 2:

Input: nums = [10,12,13,14,15]
Output: 11
Explanation: Мы можем сделать массив равнопалиндромным, изменив все элементы на 11, что является палиндромным числом. Стоимость изменения массива на [11,11,11,11,11], используя 5 специальных ходов, равна |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 11, не может быть достигнуто с меньшими затратами.

Пример 3:

Input: nums = [22,33,22,33,22]
Output: 22
Explanation: Мы можем сделать массив равнопалиндромным, изменив все элементы на 22, что является палиндромным числом. Стоимость изменения массива на [22,22,22,22,22], используя 2 специальных хода, равна |33 - 22| + |33 - 22| = 22.
Можно показать, что изменение всех элементов на любое палиндромное число, кроме 22, не может быть достигнуто с меньшими затратами.

Ограничения:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

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

Выберите индекс i в диапазоне [0, n - 1], и целое положительное число x.
Добавьте |nums[i] - x| к общей стоимости.
Измените значение nums[i] на x.

Палиндромное число это целое положительное число, которое остаётся неизменным, когда его цифры меняются местами. Например, 121, 2552 и 6575 являются числами-палиндромами, тогда как 24, 46, 235 не являются числами-палиндромами.
Массив считается равноиндромным, если все элементы массива равны целому числу y, где y это палиндромное число меньше 10^9.
Возвращает целое число, обозначающее минимально возможную общую стоимость, чтобы сделать числа равными индексным, выполнив любое количество специальных ходов.

Пример 1:

Ввод: nums = [1,2,3,4,5]
Вывод: 6
Пояснение: Мы можем сделать массив равноиндромным, заменив все его элементы на 3, что является палиндромным числом. Стоимость изменения массива на [3,3,3,3,3] с помощью 4 специальных ходов равна |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Можно показать, что замену всех элементов на любое палиндромное число, отличное от 3, невозможно достичь с меньшими затратами.

Пример 2:

Ввод: nums = [10,12,13,14,15]
Вывод: 11
Пояснение: Мы можем сделать массив равноиндромным, заменив все его элементы на 11, что является палиндромным числом. Стоимость изменения массива на [11,11,11,11,11] с помощью 5 специальных ходов равна |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Можно показать, что замену всех элементов на любое палиндромное число, отличное от 11, невозможно достичь с меньшими затратами.

Пример 3:

Ввод: nums = [22,33,22,33,22]
Вывод: 22
Пояснение: Мы можем сделать массив равноиндромным, заменив все его элементы на 22, что является палиндромным числом. Стоимость изменения массива на [22,22,22,22,22] с помощью двух специальных ходов равна |33 - 22| + |33 - 22| = 22.
Можно показать, что замену всех элементов на любое палиндромное число, кроме 22, невозможно достичь с меньшими затратами.

Ограничения:

1 <= n <= 10^5
1 <= nums[i] <= 10^9


Вам дана строка word с 0-индексацией.
За одну операцию вы можете выбрать любой индекс i из word и изменить word[i] на любую строчную букву английского алфавита.
Верните минимальное количество операций, необходимых для удаления всех почти-равных соседних символов из word.
Два символа a и b почти-равны, если a == b или a и b находятся рядом в алфавите.

Пример 1:

Ввод: word = "aaaaa"
Вывод: 2
Объяснение: Мы можем изменить слово на "acaca", в котором нет соседних почти-равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти-равных символов из слова, равно 2.

Пример 2:

Ввод: word = "abddez"
Вывод: 2
Объяснение: Мы можем изменить слово на "ybdoez", в котором нет соседних почти-равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти-равных символов из слова, равно 2.

Пример 3:

Ввод: word = "zyxyxyz"
Вывод: 3
Объяснение: Мы можем изменить слово на "zaxaxaz", в котором нет соседних почти-равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти-равных символов из слова, равно 3.

Ограничения:

1 <= word.length <= 100
word состоит только из строчных английских букв.

Вам дано строковое слово с 0-индексом.
За одну операцию вы можете выбрать любой индекс i слова и заменить word[i] на любую строчную Английскую букву.
Возвращает минимальное количество операций, необходимое для удаления из слова всех соседних почти равных символов.
Два символа a и b почти равны, если a == b или a и b соседние в алфавите.

Пример 1:

Ввод: word = "aaaaa"
Вывод: 2
Пояснение: Мы можем заменить слово на "acaca", в котором нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимое для удаления из слова всех соседних почти одинаковых символов, равно 2.

Пример 2:

Ввод: word = "abddez"
Вывод: 2
Пояснение: Мы можем заменить слово на "ybdoez", в котором нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимое для удаления из слова всех соседних почти одинаковых символов, равно 2.
Пример 3:

Ввод: word = "zyxyxyz"
Вывод: 3
Пояснение: Мы можем заменить слово на "zaxaxaz", в котором нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимое для удаления из слова всех соседних почти одинаковых символов, равно 3.

Ограничения:

1 <= word.length <= 100
word состоит только из строчных Английских букв.

Вам дают 0-индексированное строковое слово.
В одной операции вы можете выбрать любой индекс i слова и изменить слово[i] на любую строчную английскую букву.
Верните минимальное количество операций, необходимых для удаления всех соседних почти равных символов из word.
Два символа a и b  почти равны, еслиa == b или  a и b прилегают к алфавиту.

Пример 1:

Ввод: word = "aaaaa"
Вывод: 2
Объяснение: Мы можем изменить слово на «акаку», у которого нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти равных символов из слова, составляет 2.

Пример 2:

Ввод: word = "abddez"
Вывод: 2
Объяснение: Мы можем изменить слово на "ybdoez", у которого нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти равных символов из слова, составляет 2.
Пример 3:

Ввод: word = "zyxyxyz"
Вывод: 3
Объяснение: Мы можем изменить слово на «zaxaxaz», у которого нет соседних почти равных символов.
Можно показать, что минимальное количество операций, необходимых для удаления всех соседних почти равных символов из слова, составляет 3.

Ограничения:

1 <= word.length <= 100
Слово состоит только из нижних английских букв.


Вам дан массив целых чисел coins с индексами, начиная с 0, представляющий значения доступных монет, и целое число target. Целое число x считается достижимым, если существует подпоследовательность coins, сумма которой равна x. Верните минимальное количество монет любого достоинства, которые необходимо добавить в массив, чтобы каждое целое число в диапазоне [1, target] было достижимо. Подпоследовательность массива — это новый непустой массив, который получается из оригинального массива путем удаления некоторых (возможных ни одной) элементов без нарушения относительных позиций оставшихся элементов.

Пример 1:

Ввод: coins = [1,4,10], target = 19
Вывод: 2
Объяснение: Нам нужно добавить монеты 2 и 8. Получившийся массив будет [1,2,4,8,10].
Можно показать, что все числа от 1 до 19 достижимы из полученного массива, и 2 — это минимальное количество монет, которые нужно добавить.

Пример 2:

Ввод: coins = [1,4,10,5,7,19], target = 19
Вывод: 1
Объяснение: Нам нужно добавить только монету 2. Получившийся массив будет [1,2,4,5,7,10,19].
Можно показать, что все числа от 1 до 19 достижимы из полученного массива, и 1 — это минимальное количество монет, которое нужно добавить.

Пример 3:

Ввод: coins = [1,1,1], target = 20
Вывод: 3
Объяснение: Нам нужно добавить монеты 4, 8 и 16. Получившийся массив будет [1,1,1,4,8,16].
Можно показать, что все числа от 1 до 20 достижимы из полученного массива, и 3 — это минимальное количество монет, которые нужно добавить.

Ограничения:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

Вам дан целочисленный массив coin с индексом 0, представляющий стоимость доступных монет, и целочисленная цель.
Целое число x может быть получено, если существует подпоследовательность coin, которая в сумме дает x.
Верните минимальное количество монет любой стоимости, которые необходимо добавить в массив, чтобы получить каждое целое число в диапазоне [1, target].
Подпоследовательность массива — это новый непустой массив, который формируется из исходного массива путем удаления некоторых (возможно, ни одного) элементов без нарушения относительного положения оставшихся элементов.

Пример 1:

Входные данные: coins = [1,4,10], target = 19
Выходные данные: 2
Объяснение: нам нужно сложить монеты 2 и 8. Результирующий массив будет [1,2,4,8,10].
Можно показать, что все целые числа от 1 до 19 можно получить из результирующего массива, и что 2 — это минимальное количество монет, которые нужно добавить в массив.

Пример 2:

Входные данные: coins = [1,4,10,5,7,19], target = 19
Выходные данные: 1
Пояснение: нам нужно добавить только монету 2. Результирующий массив будет [1,2,4,5,7,10,19].
Можно показать, что все целые числа от 1 до 19 можно получить из результирующего массива, и что 1 — это минимальное количество монет, которые нужно добавить в массив.

Пример 3:

Входные coins = [1,1,1], target = 20
Выходные данные: 3
Пояснение: нам нужно добавить монеты 4, 8 и 16. Результирующий массив будет [1,1,1,4,8,16].
Можно показать, что все целые числа от 1 до 20 можно получить из результирующего массива, и что 3 — это минимальное количество монет, которое нужно добавить в массив.

Ограничения:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target


Вам дана строка s с 0-индексацией и целое число k.
Необходимо выполнить следующие операции разбиения, пока строка s не станет пустой:

Выберите самый длинный префикс s, содержащий не более k различных символов.
Удалите этот префикс из s и увеличьте количество разбиений на один. Оставшиеся символы (если есть) в s сохраняют их первоначальный порядок.

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

Пример 1:

Вход: s = "accca", k = 2
Выход: 3
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно изменить s[2] на 'b'.
Строка s становится "acbca".
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "acbca".
- Удалите префикс, и s станет "bca". Количество разбиений теперь 1.
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "bca".
- Удалите префикс, и s станет "a". Количество разбиений теперь 2.
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "a".
- Удалите префикс, и s станет пустой. Количество разбиений теперь 3.
Таким образом, ответ 3.
Можно показать, что невозможно получить более 3 разбиений.

Пример 2:

Вход: s = "aabaab", k = 3
Выход: 1
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно оставить s как есть.
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 3 различных символов, "aabaab".
- Удалите префикс, и s станет пустой. Количество разбиений становится 1.
Таким образом, ответ 1.
Можно показать, что невозможно получить более 1 разбиения.

Пример 3:

Вход: s = "xxyz", k = 1
Выход: 4
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно изменить s[1] на 'a'.
Строка s становится "xayz".
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "xayz".
- Удалите префикс, и s станет "ayz". Количество разбиений теперь 1.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "ayz".
- Удалите префикс, и s станет "yz". Количество разбиений теперь 2.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "yz".
- Удалите префикс, и s станет "z". Количество разбиений теперь 3.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "z".
- Удалите префикс, и s станет пустой. Количество разбиений теперь 4.
Таким образом, ответ 4.
Можно показать, что невозможно получить более 4 разбиений.

Ограничения:

1 <= s.length <= 10^4
s состоит только из строчных английских букв.
1 <= k <= 26

Вам дана строка s с 0-индексацией и целое число k.
Необходимо выполнить следующие операции разбиения, пока строка s не станет пустой:

Выберите самый длинный префикс s, содержащий не более k различных символов.
Удалите этот префикс из s и увеличьте количество разбиений на один. Оставшиеся символы (если есть) в s сохраняют их первоначальный порядок.

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

Пример 1:

Input: s = "accca", k = 2
Output: 3
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно изменить s[2] на 'b'.
Строка s становится "acbca".
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "acbca".
- Удалите префикс, и s станет "bca". Количество разбиений теперь 1.
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "bca".
- Удалите префикс, и s станет "a". Количество разбиений теперь 2.
- Выберите самый длинный префикс, содержащий не более 2 различных символов, "a".
- Удалите префикс, и s станет пустой. Количество разбиений теперь 3.
Таким образом, ответ 3.
Можно показать, что невозможно получить более 3 разбиений.

Пример 2:

Input: s = "aabaab", k = 3
Output: 1
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно оставить s как есть.
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 3 различных символов, "aabaab".
- Удалите префикс, и s станет пустой. Количество разбиений становится 1.
Таким образом, ответ 1.
Можно показать, что невозможно получить более 1 разбиения.

Пример 3:

Input: s = "xxyz", k = 1
Output: 4
Объяснение: В этом примере, чтобы максимизировать количество получаемых разбиений, можно изменить s[1] на 'a'.
Строка s становится "xayz".
Теперь операции можно выполнять следующим образом, пока s не станет пустой:
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "xayz".
- Удалите префикс, и s станет "ayz". Количество разбиений теперь 1.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "ayz".
- Удалите префикс, и s станет "yz". Количество разбиений теперь 2.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "yz".
- Удалите префикс, и s станет "z". Количество разбиений теперь 3.
- Выберите самый длинный префикс, содержащий не более 1 различного символа, "z".
- Удалите префикс, и s станет пустой. Количество разбиений теперь 4.
Таким образом, ответ 4.
Можно показать, что невозможно получить более 4 разбиений.

Ограничения:

1 <= s.length <= 10^4
s состоит только из строчных английских букв.
1 <= k <= 26

Вам дана строка s с индексом 0 и целое число k.
Вы должны выполнить следующие операции разделения, пока s не станет пустым:

Выберите самый длинный префикс s, содержащий не более k различных символов.
Удалите префикс из s и увеличьте количество разделов на один. Остальные символы (если они есть) в s сохраняют свой первоначальный порядок.

Перед выполнением операций разрешено изменить не более одного индекса в s на другую строчную английскую букву.
Верните целое число, обозначающее максимальное количество результирующих разделов после операций, оптимально выбирая не более одного индекса для изменения.

Пример 1:

Input: s = "accca", k = 2
Output: 3
Explanation: In this example, to maximize the number of resulting partitions, s[2] can be changed to 'b'.
s becomes "acbca".
The operations can now be performed as follows until s becomes empty:
- Choose the longest prefix containing at most 2 distinct characters, "acbca".
- Delete the prefix, and s becomes "bca". The number of partitions is now 1.
- Choose the longest prefix containing at most 2 distinct characters, "bca".
- Delete the prefix, and s becomes "a". The number of partitions is now 2.
- Choose the longest prefix containing at most 2 distinct characters, "a".
- Delete the prefix, and s becomes empty. The number of partitions is now 3.
Hence, the answer is 3.
It can be shown that it is not possible to obtain more than 3 partitions.
Пример 2:

Input: s = "aabaab", k = 3
Output: 1
Explanation: In this example, to maximize the number of resulting partitions we can leave s as it is.
The operations can now be performed as follows until s becomes empty:
- Choose the longest prefix containing at most 3 distinct characters, "aabaab".
- Delete the prefix, and s becomes empty. The number of partitions becomes 1.
Hence, the answer is 1.
It can be shown that it is not possible to obtain more than 1 partition.

Пример 3:

Input: s = "xxyz", k = 1
Output: 4
Explanation: In this example, to maximize the number of resulting partitions, s[1] can be changed to 'a'.
s becomes "xayz".
The operations can now be performed as follows until s becomes empty:
- Choose the longest prefix containing at most 1 distinct character, "xayz".
- Delete the prefix, and s becomes "ayz". The number of partitions is now 1.
- Choose the longest prefix containing at most 1 distinct character, "ayz".
- Delete the prefix, and s becomes "yz". The number of partitions is now 2.
- Choose the longest prefix containing at most 1 distinct character, "yz".
- Delete the prefix, and s becomes "z". The number of partitions is now 3.
- Choose the longest prefix containing at most 1 distinct character, "z".
- Delete the prefix, and s becomes empty. The number of partitions is now 4.
Hence, the answer is 4.
It can be shown that it is not possible to obtain more than 4 partitions.

Constraints:

1 <= s.length <= 10^4
s consists only of lowercase English letters.
1 <= k <= 26


Дан 2D массив `variables` с нулевой индексацией, где `variables[i] = [a_i, b_i, c_i, m_i]`, и целое число `target`.
Индекс `i` считается хорошим, если выполняется следующая формула:

0 <= i < variables.length
\(((a_i^b_i \% 10)^c_i) \% m_i == target\)

Верните массив, состоящий из хороших индексов в любом порядке.

Пример 1:

Вход: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Выход: [0,2]
Объяснение: Для каждого индекса `i` в массиве `variables`:
1) Для индекса 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Для индекса 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Для индекса 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Таким образом, мы возвращаем [0,2] как ответ.

Пример 2:

Вход: variables = [[39,3,1000,1000]], target = 17
Выход: []
Объяснение: Для каждого индекса `i` в массиве `variables`:
1) Для индекса 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Таким образом, мы возвращаем [] как ответ.

Ограничения:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Вам дан 0-индексированный двумерный массив переменных, где variables[i] = [a_i, b_i, c_i, m_i], и целочисленная цель.
Индекс i является хорошим, если выполняется следующая формула:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == цель

Вернуть массив, состоящий из хороших индексов в любом порядке.

Пример 1:

Вход: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Выход: [0,2]
Объяснение: Для каждого индекса i в массиве переменных:
1) Для индекса 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Для индекса 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Для индекса 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Поэтому мы возвращаем [0,2] в качестве ответа.

Пример 2:

Вход: variables = [[39,3,1000,1000]], target = 17
Выход: []
Объяснение: Для каждого индекса i в массиве переменных:
1) Для индекса 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Поэтому мы возвращаем [] в качестве ответа.

Ограничения:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Дан двумерный массив variables с нулевой индексацией, где variables[i] = [a_i, b_i, c_i, m_i], и целое число target.
Индекс i считается подходящим, если выполняется следующая формула:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Верни массив, состоящий из подходящих индексов в любом порядке.

Пример 1:

Ввод: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Вывод: [0,2]
Пояснение: Для каждого индекса i в массиве variables:
1) Для индекса 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Для индекса 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Для индекса 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Таким образом, в ответе возвращаем [0,2].

Пример 2:

Ввод: variables = [[39,3,1000,1000]], target = 17
Вывод: []
Пояснение: Для каждого индекса i в массиве variables:
1) Для индекса 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Таким образом, в ответе возвращаем [].

Ограничения:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


Даны две строки, индексированные с 0: `source` и `target`, обе длины n и состоящие из строчных английских букв. Также даны два массива символов с индексами, начиная с 0: `original` и `changed`, и целочисленный массив `cost`, где `cost[i]` представляет стоимость замены символа `original[i]` на символ `changed[i]`.

Вы начинаете с строки `source`. За одну операцию вы можете выбрать символ x из строки и заменить его на символ y с затратами z, если существует индекс j такой, что `cost[j] == z`, `original[j] == x` и `changed[j] == y`.

Верните минимальную стоимость превращения строки `source` в строку `target` с использованием любого количества операций. Если невозможно преобразовать `source` в `target`, верните -1.

Учтите, что может существовать такой индекс i, j, что `original[j] == original[i]` и `changed[j] == changed[i]`.

Пример 1:

Вход: `source = "abcd"`, `target = "acbe"`, `original = ["a","b","c","c","e","d"]`, `changed = ["b","c","b","e","b","e"]`, `cost = [2,5,5,1,2,20]`
Выход: 28

Объяснение: Чтобы преобразовать строку "abcd" в строку "acbe":
- Измените значение по индексу 1 с 'b' на 'c' стоимостью 5.
- Измените значение по индексу 2 с 'c' на 'e' стоимостью 1.
- Измените значение по индексу 2 с 'e' на 'b' стоимостью 2.
- Измените значение по индексу 3 с 'd' на 'e' стоимостью 20.
Общая затраченная стоимость составляет 5 + 1 + 2 + 20 = 28.
Можно показать, что это минимально возможная стоимость.

Пример 2:

Вход: `source = "aaaa"`, `target = "bbbb"`, `original = ["a","c"]`, `changed = ["c","b"]`, `cost = [1,2]`
Выход: 12

Объяснение: Чтобы заменить символ 'a' на 'b', замените символ 'a' на 'c' стоимостью 1, затем замените символ 'c' на 'b' стоимостью 2, с общей стоимостью 1 + 2 = 3. Чтобы заменить все вхождения 'a' на 'b', общая стоимость составит 3 * 4 = 12.

Пример 3:

Вход: `source = "abcd"`, `target = "abce"`, `original = ["a"]`, `changed = ["e"]`, `cost = [10000]`
Выход: -1

Объяснение: Невозможно преобразовать `source` в `target`, потому что значение по индексу 3 нельзя изменить с 'd' на 'e'.

Ограничения:

1 <= `source.length` == `target.length` <= 10^5
`source`, `target` состоят из строчных английских букв.
1 <= `cost.length` == `original.length` == `changed.length` <= 2000
`original[i]`, `changed[i]` — строчные английские буквы.
1 <= `cost[i]` <= 10^6
`original[i]` != `changed[i]`

Вам даны две строки с индексом 0, source и target, обе длиной n, состоящие из строчных английских букв. Вам также даны два 0-индексированных массива символов, original и changed, а также массив целых чисел cost, где cost[i] представляет стоимость изменения символа original[i] на символ changed[i].
Вы начинаете со строки source. За одну операцию вы можете выбрать символ x из строки и изменить его на символ y по цене z, если существует индекс j, такой, что cost[j] == z, original[j] == x и changed[j] == y.
Выведите минимальную стоимость преобразования строки source в строку target с использованием любого количества операций. Если невозможно преобразовать source в target, выведите -1.
Обратите внимание, что могут существовать индексы i, j такие, что original[j] == original[i] и changed[j] == changed[i].

Пример 1:

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
Объяснение: Чтобы преобразовать строку "abcd" в строку "acbe":
- Измените значение индекса 1 с «b» на «c» по цене 5.
- Измените значение индекса 2 с 'c' на 'e' по цене 1.
- Измените значение индекса 2 с 'e' на 'b' по цене 2.
- Измените значение индекса 3 с 'd' на 'e' стоимостью 20.
Общая понесенная стоимость составляет 5 + 1 + 2 + 20 = 28.
Можно показать, что это минимально возможная стоимость.

Пример 2:
Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
Объяснение: Чтобы изменить символ 'a' на 'b', измените символ 'a' на 'c' за 1, а затем измените символ 'c' на 'b' за 2, что в сумме составит 1 + 2 = 3. Чтобы изменить все вхождения 'a' на 'b', общая стоимость составляет 3 * 4 = 12.

Пример 3:

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
Объяснение: Невозможно преобразовать источник в цель, потому что значение индекса 3 не может быть изменено с 'd' на 'e'.

Constraints:

1 <= source.length == target.length <= 10^5
source, target consist of lowercase English letters.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] are lowercase English letters.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Вам даны две 0-индексированные строки source и target, обе длиной n и состоящие из строчных английских букв. Вам также даны два 0-индексированных массива символов original и changed, и целочисленный массив cost, где cost[i] представляет стоимость изменения символа original[i] на символ changed[i].
Вы начинаете со строки source. За одну операцию вы можете выбрать символ x из строки и изменить его на символ y по стоимости z, если существует любой индекс j такой, что cost[j] == z, original[j] == x и changed[j] == y.
Возвращает минимальную стоимость преобразования строки source в строку target с использованием любого количества операций. Если невозможно преобразовать source в target, возвращает -1.
Обратите внимание, что могут существовать индексы i, j такие, что original[j] == original[i] и changed[j] == changed[i].

Пример 1:

Входные данные: source = "abcd", цель = "acbe", target = ["a","b","c","c","e","d"], original = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Выходные данные: 28
Пояснение: Чтобы преобразовать строку "abcd" в строку "acbe":
- Измените значение в индексе 1 с "b" на "c" за 5.
- Измените значение в индексе 2 с "c" на "e" за 1.
- Измените значение в индексе 2 с "e" на "b" за 2.
- Измените значение в индексе 3 с "d" на "e" за 20.
Общая стоимость составит 5 + 1 + 2 + 20 = 28.
Можно показать, что это минимально возможная стоимость.

Пример 2:

Входные данные: source = "aaaa", target = "bbbb", исходный = ["a","c"], original = ["c","b"], cost = [1,2]
Выходные данные: 12
Пояснение: чтобы изменить символ 'a' на 'b', измените символ 'a' на 'c' по стоимости 1, а затем измените символ 'c' на 'b' по стоимости 2, общая стоимость составит 1 + 2 = 3. Чтобы изменить все вхождения 'a' на 'b', общая стоимость составит 3 * 4 = 12.

Пример 3:

Входные данные: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Выходные данные: -1
Пояснение: невозможно преобразовать source в target, поскольку значение в индексе 3 не может быть изменено с 'd' на 'e'.

Ограничения:

1 <= source.length == target.length <= 10^5
source, target состоят из строчных английских букв.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] — строчные английские буквы.
1 <= cost[i] <= 10^6
original[i] != changed[i]


Вам дан массив целых чисел `nums` с индексами, начинающимися с 0.
Префикс `nums[0..i]` является последовательным, если для всех `1 <= j <= i` выполняется условие `nums[j] = nums[j - 1] + 1`. В частности, префикс, состоящий только из `nums[0]`, является последовательным.
Верните наименьшее целое число `x`, которого не хватает в `nums`, такое что `x` больше или равно сумме самого длинного последовательного префикса.

Пример 1:

Ввод: nums = [1,2,3,2,5]
Вывод: 6
Объяснение: Самый длинный последовательный префикс `nums` это [1,2,3] с суммой 6. 6 отсутствует в массиве, следовательно, 6 является наименьшим отсутствующим целым числом, больше или равным сумме самого длинного последовательного префикса.

Пример 2:

Ввод: nums = [3,4,5,1,12,14,13]
Вывод: 15
Объяснение: Самый длинный последовательный префикс `nums` это [3,4,5] с суммой 12. 12, 13 и 14 находятся в массиве, а 15 отсутствует. Следовательно, 15 является наименьшим отсутствующим целым числом, больше или равным сумме самого длинного последовательного префикса.

Ограничения:

1 <= nums.length <= 50
1 <= nums[i] <= 50

Вам дан 0-индексированный массив целых чисел nums.
Префикс nums[0..i] является последовательным, если для всех 1 <= j <= i, nums[j] = nums[j - 1] + 1. В частности, префикс, состоящий только из nums[0], является последовательным.
Верните наименьшее целое число x, отсутствующее в nums, такое, что x больше или равно сумме самого длинного последовательного префикса.

Пример 1:

Вход: nums = [1,2,3,2,5]
Выход: 6
Объяснение: Самый длинный последовательный префикс nums — [1,2,3] с суммой 6. 6 нет в массиве, поэтому 6 — наименьшее отсутствующее целое число, больше или равно сумме самого длинного последовательного префикса.

Пример 2:

Вход: nums = [3,4,5,1,12,14,13]
Выход: 15
Объяснение: Самый длинный последовательный префикс nums — [3,4,5] с суммой 12. 12, 13 и 14 принадлежат массиву, а 15 — нет. Поэтому 15 — наименьшее отсутствующее целое число, большее или равное сумме самого длинного последовательного префикса.

Ограничения:

1 <= nums.length <= 50
1 <= nums[i] <= 50

Вам дан массив целых чисел с 0-индексом.
Префикс nums[0..i] является последовательным, если для всех 1 <= j <= i, nums[j] = nums[j - 1] + 1. В частности, префикс, состоящий только из nums[0], имеет последовательный вид.
Возвращает наименьшее целое число x, отсутствующее в nums, такое, что x больше или равно сумме самого длинного последовательного префикса.

Пример 1:

Ввод: nums = [1,2,3,2,5]
Вывод: 6
Объяснение: Самый длинный последовательный префикс чисел это [1,2,3] с суммой 6. Число 6 отсутствует в массиве, поэтому 6 это наименьшее пропущенное целое число, большее или равное сумме самого длинного последовательного префикса.

Пример 2:

Ввод: nums = [3,4,5,1,12,14,13]
Вывод: 15
Объяснение: Самый длинный последовательный префикс чисел это [3,4,5] с суммой 12. 12, 13, и 14 принадлежат массиву, а 15 нет. Следовательно, 15 это наименьшее недостающее целое число, большее или равное сумме самого длинного последовательного префикса.

Ограничения:

1 <= nums.length <= 50
1 <= nums[i] <= 50


Даны два положительных целых числа x и y.
За одну операцию можно выполнить одну из следующих четырех операций:

Разделить x на 11, если x кратно 11.
Разделить x на 5, если x кратно 5.
Уменьшить x на 1.
Увеличить x на 1.

Верните минимальное количество операций, необходимых для того, чтобы x и y стали равными.

Пример 1:

Ввод: x = 26, y = 1
Вывод: 3
Объяснение: Можно сделать 26 равным 1, выполняя следующие операции:
1. Уменьшить x на 1
2. Разделить x на 5
3. Разделить x на 5
Можно показать, что 3 — минимальное количество операций, необходимых для того, чтобы сделать 26 равным 1.

Пример 2:

Ввод: x = 54, y = 2
Вывод: 4
Объяснение: Можно сделать 54 равным 2, выполняя следующие операции:
1. Увеличить x на 1
2. Разделить x на 11
3. Разделить x на 5
4. Увеличить x на 1
Можно показать, что 4 — минимальное количество операций, необходимых для того, чтобы сделать 54 равным 2.

Пример 3:

Ввод: x = 25, y = 30
Вывод: 5
Объяснение: Можно сделать 25 равным 30, выполняя следующие операции:
1. Увеличить x на 1
2. Увеличить x на 1
3. Увеличить x на 1
4. Увеличить x на 1
5. Увеличить x на 1
Можно показать, что 5 — минимальное количество операций, необходимых для того, чтобы сделать 25 равным 30.

Ограничения:

1 <= x, y <= 10^4

Вам даны два положительных целых числа x и y.
За одну операцию вы можете выполнить одну из четырех следующих операций:

Разделить x на 11, если x кратно 11.
Разделить x на 5, если x кратно 5.
Уменьшить x на 1.
Увеличить x на 1.

Вернуть минимальное количество операций, необходимых для того, чтобы сделать x и y равными.

Пример 1:

Вход: x = 26, y = 1
Выход: 3
Пояснение: Мы можем сделать 26 равным 1, применив следующие операции:
1. Уменьшить x на 1
2. Разделить x на 5
3. Разделить x на 5
Можно показать, что 3 — это минимальное количество операций, необходимых для того, чтобы сделать 26 равным 1.

Пример 2:

Вход: x = 54, y = 2
Выход: 4
Пояснение: Мы можем сделать 54 равным 2, применив следующие операции:
1. Увеличить x на 1
2. Разделить x на 11
3. Разделить x на 5
4. Увеличить x на 1
Можно показать, что 4 — это минимальное количество операций, необходимых для того, чтобы сделать 54 равным 2.

Пример 3:

Вход: x = 25, y = 30
Выход: 5
Объяснение: Мы можем сделать 25 равным 30, применив следующие операции:
1. Увеличить x на 1
2. Увеличить x на 1
3. Увеличить x на 1
4. Увеличить x на 1
5. Увеличить x на 1
Можно показать, что 5 — это минимальное количество операций, необходимое для того, чтобы сделать 25 равным 30.

Ограничения:

1 <= x, y <= 10^4

Вам даны два положительных целых числа x и y.
За одну операцию вы можете выполнить одну из четырех следующих операций:

Разделить x на 11, если x кратно 11.
Разделить x на 5, если x кратно 5.
Уменьшить x на 1.
Увеличить x на 1.

Вернуть минимальное количество операций, необходимых для того, чтобы сделать x и y равными.

Пример 1:

Вход: x = 26, y = 1
Выход: 3
Пояснение: Мы можем сделать 26 равным 1, применив следующие операции:
1. Уменьшить x на 1
2. Разделить x на 5
3. Разделить x на 5
Можно показать, что 3 — это минимальное количество операций, необходимых для того, чтобы сделать 26 равным 1.

Пример 2:

Вход: x = 54, y = 2
Выход: 4
Пояснение: Мы можем сделать 54 равным 2, применив следующие операции:
1. Увеличить x на 1
2. Разделить x на 11
3. Разделить x на 5
4. Увеличить x на 1
Можно показать, что 4 — это минимальное количество операций, необходимых для того, чтобы сделать 54 равным 2.

Пример 3:

Вход: x = 25, y = 30
Выход: 5
Объяснение: Мы можем сделать 25 равным 30, применив следующие операции:
1. Увеличить x на 1
2. Увеличить x на 1
3. Увеличить x на 1
4. Увеличить x на 1
5. Увеличить x на 1
Можно показать, что 5 — это минимальное количество операций, необходимых для того, чтобы сделать 25 равным 30.

Ограничения:

1 <= x, y <= 10^4


Вам даны целое число k и целое число x.
Рассмотрим, что s — это 1-индексированное двоичное представление целого числа num. Цена числа num — это количество i, таких что i % x == 0 и s[i] — это установленный бит.
Верните наибольшее целое число num, такое что сумма цен всех чисел от 1 до num меньше или равна k.
Примечание:

В двоичном представлении числа установленный бит — это бит со значением 1.
Двоичное представление числа будет индексироваться справа налево. Например, если s == 11100, то s[4] == 1 и s[2] == 0.

Пример 1:

Ввод: k = 9, x = 1
Вывод: 6
Пояснение: Числа 1, 2, 3, 4, 5 и 6 могут быть записаны в двоичном представлении как «1», «10», «11», «100», «101» и «110» соответственно.
Так как x равен 1, цена каждого числа равна количеству его установленных битов.
Количество установленных битов в этих числах равно 9.
Таким образом ответ равен 6.
Пример 2:

Ввод: k = 7, x = 2
Вывод: 9
Пояснение: Так как x равен 2, мы должны только проверить четные биты.
Второй бит двоичного представления чисел 2 и 3 является установленным битом. Поэтому сумма их цен равна 2.
Второй бит двоичного представления чисел 6 и 7 является установленным битом. Поэтому сумма их цен равна 2.
Четвертый бит двоичного представления чисел 8 и 9 является установленным битом, но их второй бит не является. Поэтому сумма их цен равна 2.
Числа 1, 4 и 5 не имеют установленных битов на четных позициях в их двоичном представлении. Поэтому сумма их цен равна 0.
Второй и четвертый бит двоичного представления числа 10 является установленным битом. Поэтому его цена равна 2.
Сумма цен первых 9 чисел равна 6.
Потому что сумма цен первых 10 чисел равна 8, ответ — 9.

Ограничения:

1 <= k <= 10^15
1 <= x <= 8

Вам даны целое число k и целое число x.
Рассмотрим s — это 1-индексированное бинарное представление целого числа. Цена числа num - это число i, такое, что i % x == 0, а s[i] — это заданный бит.
Выведите наибольшее целое число num, такое, что сумма цен всех чисел от 1 до num меньше или равна k.
Примечание:

В бинарном представлении числового множества бит является битом значения 1.
Бинарное представление числа будет индексироваться справа налево. Например, если s == 11100, s[4] == 1 и s[2] == 0.

Пример 1:

Input: k = 9, x = 1
Output: 6
Объяснение: Числа 1, 2, 3, 4, 5 и 6 могут быть записаны в двоичном представлении как "1", "10", "11", "100", "101" и "110" соответственно.
Так как x равно 1, то цена каждого числа равна количеству его заданных битов.
Количество установленных битов в этих числах равно 9. Таким образом, сумма цен первых 6 номеров равна 9.
Итак, ответ 6.
Пример 2:

Input: k = 7, x = 2
Output: 9
Объяснение: Поскольку x равно 2, мы должны проверить четные биты.
Второй бит двоичного представления чисел 2 и 3 является заданным битом. Таким образом, сумма их цен равна 2.
Второй бит двоичного представления чисел 6 и 7 является заданным битом. Таким образом, сумма их цен равна 2.
Четвертый бит двоичного представления чисел 8 и 9 является заданным битом, а их второй бит - нет. Таким образом, сумма их цен равна 2.
Числа 1, 4 и 5 не имеют установленных битов в своих четных^-х битах в двоичном представлении. Таким образом, сумма их цен равна 0.
Второй и четвертый биты двоичного представления числа 10 являются заданными битами. Так что его цена равна 2.
Сумма цен первых 9 номеров равна 6.
Поскольку сумма цен первых 10 чисел равна 8, ответ - 9.

Constraints:

1 <= k <= 10^15
1 <= x <= 8

Вам дано целое число k и целое число x.
Рассмотрим, что s — это 1-индексированное двоичное представление целого числа num. Цена числа num — это количество i, таких что i % x == 0, а s[i] — это установленный бит.
Вернуть наибольшее целое число num, такое что сумма цен всех чисел от 1 до num меньше или равна k.
Примечание:

В двоичном представлении числа установленный бит — это бит со значением 1.
Двоичное представление числа будет индексироваться справа налево. Например, если s == 11100, s[4] == 1 и s[2] == 0.

Пример 1:

Вход: k = 9, x = 1
Выход: 6
Пояснение: Числа 1, 2, 3, 4, 5 и 6 можно записать в двоичном представлении как «1», «10», «11», «100», «101» и «110» соответственно.
Поскольку x равен 1, цена каждого числа равна количеству его установленных битов.
Количество установленных битов в этих числах равно 9. Таким образом, сумма цен первых 6 чисел равна 9.
Поэтому ответ равен 6.
Пример 2:

Вход: k = 7, x = 2
Выход: 9
Пояснение: Поскольку x равен 2, мы должны просто проверить четные биты.
Второй бит двоичного представления чисел 2 и 3 — это установленный бит. Поэтому сумма их цен равна 2.
Второй бит двоичного представления чисел 6 и 7 — это установленный бит. Поэтому сумма их цен равна 2.
Четвертый бит двоичного представления чисел 8 и 9 — это установленный бит, но их второй бит — нет. Поэтому сумма их цен равна 2.
Числа 1, 4 и 5 не имеют установленных битов в своих четных битах в их двоичном представлении. Поэтому сумма их цен равна 0.
Второй и четвертый бит двоичного представления числа 10 — это установленный бит. Поэтому его цена равна 2.
Сумма цен первых 9 чисел равна 6.
Поскольку сумма цен первых 10 чисел равна 8, ответ — 9.

Ограничения:

1 <= k <= 10^15
1 <= x <= 8


Дан массив nums, состоящий из положительных целых чисел.
Верните суммарные частоты элементов в nums, таких что эти элементы все имеют максимальную частоту.
Частота элемента — это количество вхождений этого элемента в массив.

Пример 1:

Ввод: nums = [1,2,2,3,1,4]
Вывод: 4
Объяснение: Элементы 1 и 2 имеют частоту 2, которая является максимальной частотой в массиве.
Таким образом, количество элементов в массиве с максимальной частотой равно 4.

Пример 2:

Ввод: nums = [1,2,3,4,5]
Вывод: 5
Объяснение: Все элементы массива имеют частоту 1, которая является максимальной.
Таким образом, количество элементов в массиве с максимальной частотой равно 5.

Ограничения:

1 <= nums.length <= 100
1 <= nums[i] <= 100

Вам дан массив nums, состоящий из положительных целых чисел.
Верните общие частоты элементов в nums, такие, что все эти элементы имеют максимальную частоту.
Частота элемента — это количество вхождений этого элемента в массив.

Пример 1:

Вход: nums = [1,2,2,3,1,4]
Выход: 4
Пояснение: Элементы 1 и 2 имеют частоту 2, что является максимальной частотой в массиве.
Таким образом, количество элементов в массиве с максимальной частотой равно 4.

Пример 2:

Вход: nums = [1,2,3,4,5]
Выход: 5
Пояснение: Все элементы массива имеют частоту 1, что является максимальной.
Таким образом, количество элементов в массиве с максимальной частотой равно 5.

Ограничения:

1 <= nums.length <= 100
1 <= nums[i] <= 100


Вам даны три целых числа start, finish, и limit. Вам также дана строка s с индексом 0, представляющая положительное целое число.
Положительное целое число x называется мощным, если оно заканчивается на s (другими словами, s является суффиксом x), и каждая цифра в x не превышает limit.
Верните общее количество мощных целых чисел в диапазоне [start..finish].
Строка x является суффиксом строки y тогда и только тогда, когда x является подстрокой y, которая начинается с некоторого индекса (включая 0) в y и продолжается до индекса y.length - 1. Например, 25 является суффиксом 5125, тогда как 512 нет.

Пример 1:

Вход: start = 1, end = 6000, limit = 4, s = "124"
Выход: 5
Пояснение: мощные целые числа в диапазоне [1..6000] это 124, 1124, 2124, 3124, и 4124. Все эти целые числа имеют каждую цифру <= 4 и "124" в качестве суффикса. Обратите внимание, что 5124 не является мощным целым числом, поскольку первая цифра 5, которая больше 4.
Можно показать, что в этом диапазоне есть только 5 мощных целых чисел.

Пример 2:

Входные данные: start = 15, end = 215, limit = 6, s = "10"
Выходные данные: 2
Пояснение: мощные целые числа в диапазоне [15..215] это 110 и 210. Все эти целые числа имеют каждую цифру <= 6 и "10" в качестве суффикса.
Можно показать, что в этом диапазоне есть только 2 мощных целых числа.

Пример 3:

Входные данные: start = 1000, end = 2000, limit = 4, s = "3000"
Выходные данные: 0
Пояснение: все целые числа в диапазоне [1000..2000] меньше 3000, поэтому "3000" не может быть суффиксом любого целого числа в этом диапазоне.

Ограничения:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s состоит только из числовых цифр, которые не превышают предел.
s не имеет начальных нулей.

Вам даны три целых числа: начало, окончание и предел. Вам также дается строка s с индексом 0, представляющая положительное целое число.
Положительное целое число x называется сильным, если оно оканчивается на s (другими словами s является суффиксом x) и каждая цифра в x является не более чем предельной.
Верните общее количество сильных целых чисел в диапазоне [старт.. финиш].
Строка x является суффиксом строки y тогда и только тогда, когда x является подстрокой y, которая начинается с некоторого индекса (включая 0) в y и продолжается до индекса y.length - 1. Например, 25 — это суффикс 5125, а 512 — нет.

Пример 1:

Input: start = 1, finish = 6000, limit = 4, s = "124"
Output: 5
Объяснение: Сильные целые числа в диапазоне [1..6000] равны 124, 1124, 2124, 3124 и 4124. Все эти целые числа имеют каждую цифру <= 4, а в качестве суффикса - «124». Обратите внимание, что 5124 не является сильным целым числом, потому что первая цифра — 5, которая больше 4.
Можно показать, что в этом диапазоне есть только 5 сильных целых чисел.

Пример 2:

Input: start = 15, finish = 215, limit = 6, s = "10"
Output: 2
Объяснение: Сильные целые числа в диапазоне [15..215] равны 110 и 210. Все эти целые числа имеют каждую цифру <= 6 и "10" в качестве суффикса.
Можно показать, что в этом диапазоне есть только 2 сильных целых числа.

Пример 3:

Input: start = 1000, finish = 2000, limit = 4, s = "3000"
Output: 0
Объяснение: Все целые числа в диапазоне [1000..2000] меньше 3000, следовательно, "3000" не может быть суффиксом любого целого числа в этом диапазоне.

Constraints:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s only consists of numeric digits which are at most limit.
s does not have leading zeros.

Вам даны три целых числа: начало, конец и предел. Вам также дается 0- индексированная строка, представляющая положительное целое число.
Положительное целое число x называется мощным, если оно заканчивается на s (другими словами, s является суффиксом x) и каждая цифра в x не превышает предела.
Верните общее количество мощных целых чисел в диапазоне [start..finish].
Строка x является суффиксом строки y, если и только если x является подстрокой y, которая начинается от некоторого индекса (включая 0) в y и распространяется на индекс y.length - 1. Например, 25 - это суффикс 5125, в то время как 512 - нет.

Пример 1:

Вход: start = 1, finish = 6000, limit = 4, s = "124"
Выход: 5
Объяснение: мощные целые числа в диапазоне [1.. 6000] из них 124, 1124, 2124, 3124 и 4124. Все эти целые числа имеют каждую цифру <= 4, и "124" в качестве суффикса. Обратите внимание, что 5124 не является мощным целым числом, потому что первая цифра 5, который больше, чем 4.
Это может быть показано, что есть только 5 мощных целых чисел в этом диапазоне.

Пример 2:

Вход: start = 15, finish = 215, limit = 6, s = "10"
Выход: 2
Объяснение: мощные целые числа в диапазоне [15.. 215] 110 и 210. Все эти целые числа имеют каждую цифру <= 6, и "10" в качестве суффикса.
Это может быть показано, что есть только 2 мощных целых чисел в этом диапазоне.

Пример 3:

Вход: start = 1000, finish = 2000, limit = 4, s = "3000"
Выход: 0
Объяснение: все целые числа в диапазоне [1000.. 2000] меньше 3000, поэтому "3000" не может быть суффиксом любого целого числа в этом диапазоне.

Ограничения:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
S состоит только из цифр, не превышающих предел.
S не имеет ведущих нулей.


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

Выберите два различных индекса i и j из nums, так чтобы nums[i] > 0 и nums[j] > 0.
Вставьте результат nums[i] % nums[j] в конец nums.
Удалите элементы с индексами i и j из nums.

Верните целое число, обозначающее минимальную длину nums, после выполнения операции любое количество раз.

Пример 1:

Вход: nums = [1,4,3,1]
Выход: 1
Объяснение: Один из способов минимизировать длину массива выглядит следующим образом:
Операция 1: Выберите индексы 2 и 1, вставьте nums[2] % nums[1] в конец, и он станет [1,4,3,1,3], затем удалите элементы с индексами 2 и 1.
nums станет [1,1,3].
Операция 2: Выберите индексы 1 и 2, вставьте nums[1] % nums[2] в конец, и он станет [1,1,3,1], затем удалите элементы с индексами 1 и 2.
nums станет [1,1].
Операция 3: Выберите индексы 1 и 0, вставьте nums[1] % nums[0] в конец, и он станет [1,1,0], затем удалите элементы с индексами 1 и 0.
nums станет [0].
Длина nums не может быть уменьшена еще больше. Следовательно, ответ — 1.
Можно показать, что 1 — это минимально достижимая длина.
Пример 2:

Вход: nums = [5,5,5,10,5]
Выход: 2
Пояснение: Один из способов минимизировать длину массива следующий:
Операция 1: выбрать индексы 0 и 3, вставить nums[0] % nums[3] в конец, и он станет [5,5,5,10,5,5], затем удалить элементы с индексами 0 и 3.
nums станет [5,5,5,5].
Операция 2: выбрать индексы 2 и 3, вставить nums[2] % nums[3] в конец, и он станет [5,5,5,5,0], затем удалить элементы с индексами 2 и 3.
nums станет [5,5,0].
Операция 3: Выберите индексы 0 и 1, вставьте nums[0] % nums[1] в конец, и он станет [5,5,0,0], затем удалите элементы с индексами 0 и 1.
nums становится [0,0].
Длина nums не может быть уменьшена дальше. Следовательно, ответ 2.
Можно показать, что 2 — это минимально достижимая длина.
Пример 3:

Вход: nums = [2,3,4]
Выход: 1
Объяснение: Один из способов минимизировать длину массива выглядит следующим образом:
Операция 1: Выберите индексы 1 и 2, вставьте nums[1] % nums[2] в конец, и он станет [2,3,4,3], затем удалите элементы с индексами 1 и 2.
nums становится [2,3].
Операция 2: Выберите индексы 1 и 0, вставьте nums[1] % nums[0] в конец, и он станет [2,3,1], затем удалите элементы с индексами 1 и 0.
nums станет [1].
Длина nums не может быть уменьшена дальше. Следовательно, ответ 1.
Можно показать, что 1 — это минимально достижимая длина.

Ограничения:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9

Вам дают 0-индексированные целочисленные массивы, содержащие положительные целые числа.
Ваша задача состоит в том, чтобы минимизировать длину NUM, выполняя следующие операции в любое количество раз (включая ноль):

Выберите два различных индекса i и j из nums, такие, что nums [i]> 0 и Nums [j]> 0.
вставьте в конец результат nums [i] % nums [j]
Удалить элементы в индексах i и j из nums

Верните целое число, обозначающее минимальную длину nums после выполнения операции в любое количество раз.

Пример 1:

Ввод: nums = [1,4,3,1]
Вывод: 1
Объяснение: Один из способов минимизировать длину массива заключается в следующем:
Операция 1: Выберите индексы 2 и 1, вставьте nums [2] % nums [1] в конце, и он становится [1,4,3,1,3], затем удаляйте элементы в индексах 2 и 1.
nums становится [1,1,3].
Операция 2: Выберите индексы 1 и 2, вставьте nums [1] % nums [2] в конце, и он становится [1,1,3,1], затем удалите элементы в индексах 1 и 2.
nums становится [1,1].
Операция 3: Выберите индексы 1 и 0, вставьте nums [1] % nums [0] в конце, и он становится [1,1,0], затем удалите элементы в индексах 1 и 0.
nums становится [0].
Длина nums не может быть уменьшена дальше. Следовательно, ответ 1.
Можно показать, что 1 является минимальной достижимой длиной.
Пример 2:

Вход: nums= [5,5,5,10,5]
Вывод: 2
Объяснение: Один из способов минимизировать длину массива заключается в следующем:
Операция 1: Выберите индексы 0 и 3, вставьте nums [0] % nums [3] в конце, и он становится [5,5,5,10,5,5], затем удалите элементы в индексах 0 и 3.
nums становится [5,5,5,5].
Операция 2: выберите Индексы 2 и 3, вставьте nums [2] % nums [3] в конце, и он становится [5,5,5,5,0], затем удаляйте элементы в индексах 2 и 3.
nums становится [5,5,0].
Операция 3: Выберите индексы 0 и 1, вставьте nums [0] % nums [1] в конце, и он становится [5,5,0,0], затем удалите элементы в индексах 0 и 1.
numss становится [0,0].
Длина nums не может быть уменьшена дальше. Следовательно, ответ 2.
Можно показать, что 2 - минимальная достижимая длина.
Пример 3:

Ввод: nums = [2,3,4]
Вывод: 1
Объяснение: Один из способов минимизировать длину массива заключается в следующем:
Операция 1: Выберите индексы 1 и 2, вставьте nums [1] % nums [2] в конце, и он становится [2,3,4,3], затем удалите элементы в индексах 1 и 2.
nums становится [2,3].
Операция 2: Выберите Индексы 1 и 0, вставьте nums [1] % nums [0] в конце, и он становится [2,3,1], затем удаляйте элементы в индексах 1 и 0.
nums становится [1].
Длина nums не может быть уменьшена дальше. Следовательно, ответ 1.
Можно показать, что 1 является минимальной достижимой длиной.

Ограничения:

1 <= nums.length <= 10^5
1 <= nums [i] <= 10^9

Дан целочисленный массив nums с индексом 0, содержащий положительные целые числа.
Задача — минимизировать длину nums, выполняя следующие операции любое количество раз (включая ноль):

Выбрать два различных индекса i и j из nums, где nums[i] > 0 и nums[j] > 0.
Вставить результат nums[i] % nums[j] в конец nums.
Удалить элементы с индексами i и j из nums.

Выведи целое число, обозначающее минимальную длину nums после выполнения операций любое количество раз.

Пример 1:

Ввод: nums = [1,4,3,1]
Вывод: 1
Пояснение: Один из способов минимизировать длину массива выглядит следующим образом:
Операция 1: Выбрать индексы 2 и 1, вставить nums[2] % nums[1] в конец, массив станет[1,4,3,1,3], затем удалить элементы с индексами 2 и 1.
nums станет [1,1,3].
Операция 2: Выбрать индексы 1 и 2, вставить nums[1] % nums[2] в конец, массив станет [1,1,3,1], затем удалить элементы с индексами 1 и 2.
nums станет [1,1].
Операция 3: Выбрать индексы 1 и 0, вставить nums[1] % nums[0] в конец, массив станет [1,1,0], затем удалить элементы с индексами 1 и 0.
nums станет [0].
Длина nums дальше не может быть уменьшена. Следовательно, ответ — 1.
Можно доказать, что 1 — минимально достижимая длина.

Пример 2:

Ввод: nums = [5,5,5,10,5]
Вывод: 2
Пояснение: Один из способов минимизировать длину массива следующий:
Операция 1: Выбрать индексы 0 и 3, вставить nums[0] % nums[3] в конец, массив станет [5,5,5,10,5,5], затем удалить элементы с индексами 0 и 3.
nums станет [5,5,5,5].
Операция 2: Выбрать индексы 2 и 3, вставьте nums[2] % nums[3] в конец, массив станет [5,5,5,5,0], затем удалить элементы с индексами 2 и 3.
nums станет [5,5,0].
Операция 3: Выбрать индексы 0 и 1, вставить nums[0] % nums[1] в конец, массив станет [5,5,0,0], затем удалить элементы с индексами 0 и 1.
nums станет [0,0].
Длина nums дальше не может быть уменьшена. Следовательно, ответ — 2.
Можно доказать, что 2 — минимально достижимая длина.

Пример 3:

Ввод: nums = [2,3,4]
Вывод: 1
Пояснение: Один из способов минимизировать длину массива следующий:
Операция 1: Выбрать индексы 1 и 2, вставить nums[1] % nums[2] в конец, массив станет [2,3,4,3], затем удалить элементы с индексами 1 и 2.
nums станет [2,3].
Операция 2: Выбрать индексы 1 и 0, вставить nums[1] % nums[0] в конец, массив станет [2,3,1], затем удалить элементы с индексами 1 и 0.
nums станет [1].
Длина nums дальше не может быть уменьшена. Следовательно, ответ — 1.
Можно доказать, что 1 — минимально достижимая длина.

Ограничения:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9


Дана строка с индексом 0, строка a, строка b и целое число k.
Индекс i является красивым, если:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Существует индекс j такой, что:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Вернуть массив, содержащий красивые индексы в отсортированном порядке от меньшего к большему.

Пример 1:

Ввод: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Вывод: [16,33]
Пояснение: Есть 2 красивых индекса: [16,33].
- Индекс 16 красивый, так как s[16..17] == "my" и существует индекс 4 с s[4..11] == "squirrel" и |16 - 4| <= 15.
- Индекс 33 красивый, так как s[33..34] == "my" и существует индекс 18 с s[18..25] == "squirrel" и |33 - 18| <= 15.
Таким образом, мы возвращаем [16,33] как результат.

Пример 2:

Ввод: s = "abcd", a = "a", b = "a", k = 4
Вывод: [0]
Пояснение: Есть 1 красивый индекс: [0].
- Индекс 0 красивый, так как s[0..0] == "a" и существует индекс 0 с s[0..0] == "a" и |0 - 0| <= 4.
Таким образом, мы возвращаем [0] как результат.

Ограничения:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, и b содержат только строчные английские буквы.

Дана строка с индексом 0, строка a, строка b и целое число k.
Индекс i является красивым, если:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Существует индекс j такой, что:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Вернуть массив, содержащий красивые индексы в отсортированном порядке от меньшего к большему.

Пример 1:

Вход: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Выход: [16,33]
Пояснение: Есть 2 красивых индекса: [16,33].
- Индекс 16 красивый, так как s[16..17] == "my" и существует индекс 4 с s[4..11] == "squirrel" и |16 - 4| <= 15.
- Индекс 33 красивый, так как s[33..34] == "my" и существует индекс 18 с s[18..25] == "squirrel" и |33 - 18| <= 15.
Таким образом, мы возвращаем [16,33] как результат.

Пример 2:

Вход: s = "abcd", a = "a", b = "a", k = 4
Выход: [0]
Пояснение: Есть 1 красивый индекс: [0].
- Индекс 0 красивый, так как s[0..0] == "a" и существует индекс 0 с s[0..0] == "a" и |0 - 0| <= 4.
Таким образом, мы возвращаем [0] как результат.

Ограничения:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, и b содержат только строчные английские буквы.

Вам дана строка s с индексом 0, строка a, строка b и целое число k.
Индекс i является красивым, если:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Существует индекс j, такой что:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Верните массив, содержащий красивые индексы в отсортированном порядке от наименьшего к наибольшему.

Пример 1:

Входные данные: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Выходные данные: [16,33]
Объяснение: есть 2 красивых индекса: [16,33].
- Индекс 16 прекрасен, так как s[16..17] == "my" и существует индекс 4 с s[4..11] == "squirrel" и |16 - 4| <= 15.
- Индекс 33 прекрасен, так как s[33..34] == "my" и существует индекс 18 с s[18..25] == "squirrel" и |33 - 18| <= 15.
Таким образом, мы возвращаем [16,33] в качестве результата.

Пример 2:

Входные данные: s = "abcd", a = "a", b = "a", k = 4
Выходные данные: [0]
Объяснение: существует 1 прекрасный индекс: [0].
- Индекс 0 прекрасен, так как s[0..0] == "a" и существует индекс 0 с s[0..0] == "a" и |0 - 0| <= 4.
Таким образом, мы возвращаем [0] в качестве результата.

Ограничения:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a и b содержат только строчные английские буквы.


У вас есть массив положительных целых чисел nums.
Необходимо проверить, возможно ли выбрать два или более элемента в массиве так, чтобы поразрядное ИЛИ выбранных элементов имело хотя бы один завершающий ноль в двоичной записи.
Например, двоичное представление числа 5, которое "101", не имеет завершающих нулей, тогда как двоичное представление числа 4, которое "100", имеет два завершающих нуля.
Верните true, если возможно выбрать два или более элемента, поразрядное ИЛИ которых имеет завершающие нули, иначе верните false.

Пример 1:

Входные данные: nums = [1,2,3,4,5]
Выходные данные: true
Объяснение: Если мы выберем элементы 2 и 4, их поразрядное ИЛИ равно 6, что имеет двоичное представление "110" с одним завершающим нулем.

Пример 2:

Входные данные: nums = [2,4,8,16]
Выходные данные: true
Объяснение: Если мы выберем элементы 2 и 4, их поразрядное ИЛИ равно 6, что имеет двоичное представление "110" с одним завершающим нулем.
Другие возможные способы выбрать элементы для получения завершающих нулей в двоичном представлении их поразрядного ИЛИ: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) и (2, 4, 8, 16).

Пример 3:

Входные данные: nums = [1,3,5,7,9]
Выходные данные: false
Объяснение: Нет возможности выбрать два или более элемента так, чтобы поразрядное ИЛИ их двоичного представления имело завершающие нули.

Ограничения:

2 <= nums.length <= 100
1 <= nums[i] <= 100

Вам дан массив положительных целых чисел nums.
Вы должны проверить, возможно ли выбрать два или более элементов в массиве так, чтобы побитовое ИЛИ выбранных элементов имело хотя бы один конечный ноль в своем двоичном представлении.
Например, двоичное представление 5, которое равно «101», не имеет конечных нулей, тогда как двоичное представление 4, которое равно «100», имеет два конечных нуля.
Возвращает true, если возможно выбрать два или более элементов, побитовое ИЛИ которых имеет конечные нули, в противном случае возвращает false.

Пример 1:

Входные данные: nums = [1,2,3,4,5]
Выходные данные: true
Объяснение: если мы выберем элементы 2 и 4, их побитовое ИЛИ равно 6, что имеет двоичное представление «110» с одним конечным нулем.

Пример 2:

Вход: nums = [2,4,8,16]
Выход: true
Пояснение: если мы выберем элементы 2 и 4, их побитовое ИЛИ будет равно 6, что имеет двоичное представление "110" с одним конечным нулем.
Другие возможные способы выбора элементов, которые будут иметь конечные нули в двоичном представлении их побитового ИЛИ: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) и (2, 4, 8, 16).

Пример 3:

Вход: nums = [1,3,5,7,9]
Выход: false
Объяснение: нет возможности выбрать два или более элементов, которые имели бы конечные нули в двоичном представлении их побитового ИЛИ.

Ограничения:

2 <= nums.length <= 100
1 <= nums[i] <= 100


Вам дан целочисленный массив nums с индексом 0 и положительное целое число k.
Вы можете применить следующую операцию к массиву любое количество раз:

Выберите любой элемент массива и переверните бит в его двоичном представлении. Переворот бита означает изменение 0 на 1 или наоборот.

Верните минимальное количество операций, необходимых для того, чтобы сделать побитовое XOR всех элементов конечного массива равным k.
Обратите внимание, что вы можете перевернуть начальные нулевые биты в двоичном представлении элементов. Например, для числа (101)_2 вы можете перевернуть четвертый бит и получить (1101)_2.

Пример 1:

Вход: nums = [2,1,3,4], k = 1
Выход: 2
Объяснение: Мы можем выполнить следующие операции:
- Выбираем элемент 2, который равен 3 == (011)_2, мы инвертируем первый бит и получаем (010)_2 == 2. nums становится [2,1,2,4].
- Выбираем элемент 0, который равен 2 == (010)_2, мы инвертируем третий бит и получаем (110)_2 = 6. nums становится [6,1,2,4].
Исключающее ИЛИ элементов конечного массива равно (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Можно показать, что мы не можем сделать XOR равным k менее чем за 2 операции.

Пример 2:

Вход: nums = [2,0,2,0], k = 0
Выход: 0
Пояснение: XOR элементов массива — (2 XOR 0 XOR 2 XOR 0) == 0 == k. Поэтому операция не требуется.

Ограничения:

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^6
0 <= k <= 10^6

Дан целочисленный массив nums с индексами, начинающимися с 0, и положительное целое число k.
Вы можете применять следующую операцию к массиву любое количество раз:

Выберите любой элемент массива и переверните бит в его двоичной записи. Перевернуть бит означает изменить 0 на 1 или наоборот.

Верните минимальное количество операций, необходимых, чтобы сделать побитовый XOR всех элементов итогового массива равным k.
Обратите внимание, что вы можете переворачивать ведущие нулевые биты в двоичной записи элементов. Например, для числа (101)_2 вы можете перевернуть четвертый бит и получить (1101)_2.

Пример 1:

Ввод: nums = [2,1,3,4], k = 1
Вывод: 2
Объяснение: Мы можем выполнить следующие операции:
- Выберите элемент 2, который равен 3 == (011)_2, переворачиваем первый бит и получаем (010)_2 == 2. nums становится [2,1,2,4].
- Выберите элемент 0, который равен 2 == (010)_2, переворачиваем третий бит и получаем (110)_2 = 6. nums становится [6,1,2,4].
XOR элементов итогового массива равен (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Можно показать, что невозможно сделать XOR равным k менее чем за 2 операции.

Пример 2:

Ввод: nums = [2,0,2,0], k = 0
Вывод: 0
Объяснение: XOR элементов массива равен (2 XOR 0 XOR 2 XOR 0) == 0 == k. Таким образом, операции не требуются.

Ограничения:

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^6
0 <= k <= 10^6


Вам дан двумерный массив целых чисел с 0-индексацией dimensions.
Для всех индексов i, 0 <= i < dimensions.length, dimensions[i][0] представляет длину, а dimensions[i][1] представляет ширину прямоугольника i.
Верните площадь прямоугольника с самой длинной диагональю. Если существует несколько прямоугольников с самой длинной диагональю, верните площадь прямоугольника с максимальной площадью.

Пример 1:

Ввод: dimensions = [[9,3],[8,6]]
Вывод: 48
Пояснение:
Для индекса = 0, длина = 9 и ширина = 3. Длина диагонали = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Для индекса = 1, длина = 8 и ширина = 6. Длина диагонали = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Таким образом, у прямоугольника с индексом 1 большая длина диагонали, поэтому мы возвращаем площадь = 8 * 6 = 48.

Пример 2:

Ввод: dimensions = [[3,4],[4,3]]
Вывод: 12
Пояснение: Длина диагонали одинакова для обоих и равна 5, поэтому максимальная площадь = 12.

Ограничения:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Вам дан двумерный целочисленный массив dimensions с индексом 0.
Для всех индексов i, 0 <= i < dimensions.length, dimensions[i][0] представляет длину, а dimensions[i][1] представляет ширину прямоугольника i.
Вернуть площадь прямоугольника с самой длинной диагональю. Если есть несколько прямоугольников с самой длинной диагональю, вернуть площадь прямоугольника с максимальной площадью.

Пример 1:

Входные данные: dimensions = [[9,3],[8,6]]
Выходные данные: 48
Объяснение:
Для index = 0, length = 9 и width = 3. Длина диагонали = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9,487.
Для индекса = 1, длина = 8 и ширина = 6. Длина диагонали = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Таким образом, прямоугольник с индексом 1 имеет большую длину диагонали, поэтому мы возвращаем площадь = 8 * 6 = 48.

Пример 2:

Входные данные: dimensions = [[3,4],[4,3]]
Выходные данные: 12
Пояснение: Длина диагонали одинакова для обоих, то есть 5, поэтому максимальная площадь = 12.

Ограничения:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100