Дан массив arr размера n, состоящий из непустых строк. Найдите строковый массив answer размера n такой, что:

answer[i] — это самая короткая подстрока arr[i], которая не встречается как подстрока в любой другой строке в arr. Если существует несколько таких подстрок, answer[i] должна быть лексикографически наименьшей. Если такой подстроки не существует, answer[i] должна быть пустой строкой.

Верните массив answer.

Пример 1:

Вход: arr = ["cab","ad","bad","c"]
Выход: ["ab","","ba",""]
Объяснение: Мы имеем следующее:
- Для строки "cab" самая короткая подстрока, которая не встречается в другой строке, — это либо "ca", либо "ab", мы выбираем лексикографически меньшую подстроку, которой является "ab".
- Для строки "ad" нет подстроки, которая не встречается в другой строке.
- Для строки "bad" самая короткая подстрока, которая не встречается в другой строке, — это "ba".
- Для строки "c" нет подстроки, которая не встречается в другой строке.

Пример 2:

Вход: arr = ["abc","bcd","abcd"]
Выход: ["","","abcd"]
Объяснение: Мы имеем следующее:
- Для строки "abc" нет подстроки, которая не встречается в другой строке.
- Для строки "bcd" нет подстроки, которая не встречается в другой строке.
- Для строки "abcd" самая короткая подстрока, которая не встречается в другой строке, — это "abcd".

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

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] состоит только из строчных английских букв.

Вам дан массив arr размера n, состоящий из непустых строк.
Найдите ответ массива строк размером n, такой что:

answer[i] — это самая короткая подстрока arr[i], которая не встречается как подстрока ни в одной другой строке в arr. Если существует несколько таких подстрок, answer[i] должен быть лексикографически наименьшим. А если такой подстроки не существует, answer[i] должен быть пустой строкой.

Верните ответ массива.

Пример 1:

Входные данные: arr = ["cab","ad","bad","c"]
Выходные данные: ["ab","","ba",""]
Объяснение: у нас есть следующее:
- Для строки "cab" самая короткая подстрока, которая не встречается ни в одной другой строке, это либо "ca", либо "ab", мы выбираем лексикографически меньшую подстроку, то есть "ab".
- Для строки "ad" нет подстроки, которая не встречается ни в одной другой строке.
- Для строки "bad" самая короткая подстрока, которая не встречается ни в одной другой строке, это "ba".
- Для строки "c" нет подстроки, которая не встречается ни в одной другой строке.

Пример 2:

Вход: arr = ["abc","bcd","abcd"]
Выход: ["","","abcd"]
Пояснение: У нас есть следующее:
- Для строки "abc" нет подстроки, которая не встречается ни в одной другой строке.
- Для строки "bcd" нет подстроки, которая не встречается ни в одной другой строке.
- Для строки "abcd" самая короткая подстрока, которая не встречается ни в одной другой строке, это "abcd".

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

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] состоит только из строчных английских букв.


Вам дан массив целых чисел с нулевым индексом длины n и положительное нечётное целое число k.
Сила подмассивов x определяется как strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, где sum[i] это сумма элементов в i^м подмассиве. Формально сила это сумма (-1)^i+1 * sum[i] * (x - i + 1) по всем i таким, что 1 <= i <= x.
Вам нужно выбрать k непересекающихся подмассивов из nums так, чтобы их сила была максимальной.
Возвращает максимально возможную силу, которую можно получить.
Обратите внимание, что выбранные подмассивы не обязательно должны покрывать весь массив.

Пример 1:

Ввод: nums = [1,2,3,-1,2], k = 3
Вывод: 22
Объяснение: Наилучший способ выбрать 3 подмассива: nums[0..2], nums[3..3], и nums[4..4]. Сила равна (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Пример 2:

Ввод: nums = [12,-2,-2,-2,-2], k = 5
Вывод: 64
Объяснение: Единственный возможный способ выбрать 5 непересекающихся подмассивов: nums[0..0], nums[1..1], nums[2..2], nums[3..3], и nums[4..4]. Сила равна 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Пример 3:

Ввод: nums = [-1,-2,-3], k = 1
Вывод: -1
Объяснение: Лучший способ выбрать 1 подмассив: nums[0..0]. Сила -1.

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

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k нечётно.

You are given a 0-indexed array of integers nums of length n, and a positive odd integer k.
The strength of x subarrays is defined as strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 where sum[i] is the sum of the elements in the i^th subarray. Formally, strength is sum of (-1)^i+1 * sum[i] * (x - i + 1) over all i's such that 1 <= i <= x.
You need to select k disjoint subarrays from nums, such that their strength is maximum.
Return the maximum possible strength that can be obtained.
Note that the selected subarrays don't need to cover the entire array.

Example 1:

Input: nums = [1,2,3,-1,2], k = 3
Output: 22
Explanation: The best possible way to select 3 subarrays is: nums[0..2], nums[3..3], and nums[4..4]. The strength is (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Example 2:

Input: nums = [12,-2,-2,-2,-2], k = 5
Output: 64
Explanation: The only possible way to select 5 disjoint subarrays is: nums[0..0], nums[1..1], nums[2..2], nums[3..3], and nums[4..4]. The strength is 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Example 3:

Input: nums = [-1,-2,-3], k = 1
Output: -1
Explanation: The best possible way to select 1 subarray is: nums[0..0]. The strength is -1.

Constraints:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k is odd.

Вам дан массив целых чисел nums с индексами от 0 до n-1 и положительное нечетное число k.
Сила x подмассивов определяется как strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, где sum[i] — сумма элементов i-го подмассива. Формально, сила определяется как сумма (-1)^i+1 * sum[i] * (x - i + 1) по всем i, таким что 1 <= i <= x.
Необходимо выбрать k непересекающихся подмассивов из nums так, чтобы их сила была максимальной. Верните максимальную возможную силу.
Верните максимальную возможную силу.
Заметьте, что выбранные подмассивы не обязательно должны покрывать весь массив.

Пример 1:

Вход: nums = [1,2,3,-1,2], k = 3
Выход: 22
Объяснение: Наилучший способ выбрать 3 подмассива: nums[0..2], nums[3..3] и nums[4..4]. Сила равна (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Пример 2:

Вход: nums = [12,-2,-2,-2,-2], k = 5
Выход: 64
Объяснение: Единственный возможный способ выбрать 5 непересекающихся подмассивов: nums[0..0], nums[1..1], nums[2..2], nums[3..3] и nums[4..4]. Сила равна 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Пример 3:

Вход: nums = [-1,-2,-3], k = 1
Выход: -1
Объяснение: Наилучший способ выбрать 1 подмассив: nums[0..0]. Сила равна -1.

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

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k - нечетное.


Дана строка s, найдите любую подстроку длиной 2, которая также присутствует в перевёрнутой строке s.
Верните true, если такая подстрока существует, и false в противном случае.

Пример 1:

Ввод: s = "leetcode"
Вывод: true
Объяснение: Подстрока "ee" имеет длину 2 и также присутствует в reverse(s) == "edocteel".

Пример 2:

Ввод: s = "abcba"
Вывод: true
Объяснение: Все подстроки длиной 2 "ab", "bc", "cb", "ba" также присутствуют в reverse(s) == "abcba".

Пример 3:

Ввод: s = "abcd"
Вывод: false
Объяснение: Нет подстроки длиной 2 в s, которая также присутствует в перевёрнутой строке s.

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

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

Дана строка s, найди любую подстроку длиной 2, которая также присутствует в перевёрнутой строке s.
Выведи true, если такая подстрока существует, и false в противном случае.

Пример 1:

Ввод: s = "leetcode"
Вывод: true
Пояснение: Подстрока "ee" имеет длину 2, которая также присутствует в reverse(s) == "edocteel".

Пример 2:

Ввод: s = "abcba"
Вывод: true
Пояснение: Все подстроки длиной 2 "ab", "bc", "cb", "ba" также присутствуют в reverse(s) == "abcba".

Пример 3:

Ввод: s = "abcd"
Вывод: false
Пояснение: В s нет подстроки длиной 2, которая также присутствует в перевёрнутой строке s.

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

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

Учитывая строку s, найдите любую подстроку длины 2, которая также присутствует в обратной строке s
Верните true, если такая подстрока существует, и false в противном случае.

Пример 1:

Вход: s = "leetcode"
Выход: true
Пояснение: подстрочка "ee" имеет длину 2, которая также присутствует в обратной строке == "edocteel".

Пример 2:

Вход: s = "abcba"
Выход: true
пояснение: все подстроки длины 2 "ab", "bc", "cb", "ba" также присутствуют в обратном (s) == "abcba".

Пример 3:

Вход: s = "abcd"
Выход: false
Explanation: нет подстроки длины 2 в s, которая также присутствует в обратной строке s.

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

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


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

Пример 1:

Вход: s = "abada", c = "a"
Выход: 6
Пояснение: Подстроки, начинающиеся и заканчивающиеся на "a": "abada", "abada", "abada", "abada", "abada", "abada".

Пример 2:

Вход: s = "zzz", c = "z"
Выход: 6
Пояснение: Всего в s 6 подстрок, и все они начинаются и заканчиваются на "z".

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

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

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

Пример 1:

Input: s = "abada", c = "a"
Output: 6
Explanation: Substrings starting and ending with "a" are: "abada", "abada", "abada", "abada", "abada", "abada".

Example 2:

Input: s = "zzz", c = "z"
Output: 6
Explanation: There are a total of 6 substrings in s and all start and end with "z".

Constraints:

1 <= s.length <= 10^5
s and c consist only of lowercase English letters.

Дана строка s и символ c. Верните общее количество подстрок строки s, которые начинаются и заканчиваются на символ c.

Пример 1:

Ввод: s = "abada", c = "a"
Вывод: 6
Объяснение: Подстроки, начинающиеся и заканчивающиеся на "a": "a", "aba", "abada", "ada", "a", "a".

Пример 2:

Ввод: s = "zzz", c = "z"
Вывод: 6
Объяснение: Всего в строке s 6 подстрок, и все они начинаются и заканчиваются на "z".

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

1 <= s.length <= 10^5
s и c состоят только из прописных английских букв.


Вам дана строка word и целое число k.
Мы считаем строку word k-особенной, если |freq(word[i]) - freq(word[j])| <= k для всех индексов i и j в строке.
Здесь freq(x) обозначает частоту символа x в word, а |y| обозначает абсолютное значение y.
Верните минимальное количество символов, которые нужно удалить, чтобы сделать строку word k-особенной.

Пример 1:

Ввод: word = "aabcaba", k = 0
Вывод: 3
Объяснение: Мы можем сделать строку 0-особенной, удалив 2 символа "a" и 1 символ "c". Таким образом, строка становится равной "baba", где freq('a') == freq('b') == 2.

Пример 2:

Ввод: word = "dabdcbdcdcd", k = 2
Вывод: 2
Объяснение: Мы можем сделать строку 2-особенной, удалив 1 символ "a" и 1 символ "d". Таким образом, строка становится равной "bdcbdcdcd", где freq('b') == 2, freq('c') == 3 и freq('d') == 4.

Пример 3:

Ввод: word = "aaabaaa", k = 2
Вывод: 1
Объяснение: Мы можем сделать строку 2-особенной, удалив 1 символ "b". Таким образом, строка становится равной "aaaaaa", где частота каждого символа равномерно 6.

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

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

Вам дана строка word и целое число k.
Мы считаем word k-специальным, если |freq(word[i]) - freq(word[j])| <= k для всех индексов i и j в строке.
Здесь freq(x) обозначает частоту символа x в word, а |y| обозначает абсолютное значение y.
Возвращает минимальное количество символов, которые необходимо удалить, чтобы сделать word k-специальным.

Пример 1:

Входные данные: word = "aabcaba", k = 0
Выходные данные: 3
Пояснение: мы можем сделать word 0-специальным, удалив 2 вхождения "a" и 1 вхождение "c". Поэтому word становится равным "baba", где freq('a') == freq('b') == 2.

Пример 2:

Вход: word = "dabdcbdcdcd", k = 2
Выход: 2
Пояснение: мы можем сделать word 2-special, удалив 1 вхождение "a" и 1 вхождение "d". Поэтому word становится равным "bdcbdcdcd", где freq('b') == 2, freq('c') == 3 и freq('d') == 4.

Пример 3:

Вход: word = "aaabaaa", k = 2
Выход: 1
Пояснение: мы можем сделать word 2-special, удалив 1 вхождение "b". Таким образом, слово становится равным «aaaaaa», где частота каждой буквы теперь равномерно равна 6.

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

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

Вам дана строка word и целое число k.
Мы считаем word k-специальным, если |freq(word[i]) - freq(word[j])| <= k для всех индексов i и j в строке.
Здесь freq(x) обозначает частоту символа x в word, а |y| обозначает абсолютное значение y.
Возвращает минимальное количество символов, которые необходимо удалить, чтобы сделать word k-специальным.

Пример 1:

Входные данные: word = "aabcaba", k = 0
Выходные данные: 3
Пояснение: мы можем сделать word 0-специальным, удалив 2 вхождения "a" и 1 вхождение "c". Поэтому word становится равным "baba", где freq('a') == freq('b') == 2.

Пример 2:

Вход: word = "dabdcbdcdcd", k = 2
Выход: 2
Пояснение: мы можем сделать word 2-special, удалив 1 вхождение "a" и 1 вхождение "d". Поэтому word становится равным "bdcbdcdcd", где freq('b') == 2, freq('c') == 3 и freq('d') == 4.

Пример 3:

Вход: word = "aaabaaa", k = 2
Выход: 1
Пояснение: мы можем сделать word 2-special, удалив 1 вхождение "b". Таким образом, слово становится равным «aaaaaa», где частота каждой буквы теперь равномерно равна 6.

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

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


Дан бинарный массив nums длиной n, целое положительное число k и целое неотрицательное число maxChanges.
Алиса играет в игру, цель которой — выбрать k единиц из nums, используя минимальное количество ходов. Когда начинается игра, Алиса выбирает любой индекс aliceIndex в диапазоне [0, n - 1] и встает там. Если nums[aliceIndex] == 1, Алиса берет единицу, и nums[aliceIndex] становится 0 (это не считается ходом). После этого Алиса может делать любое количество ходов (включая ноль). На каждом ходу Алиса должна выполнить только одно из следующих действий:

Выбрать любой индекс j != aliceIndex, такой что nums[j] == 0, и установить nums[j] = 1. Это действие можно выполнять не более maxChanges раз.
Выбрать любые два соседних индекса x и y (|x - y| == 1) такие, что nums[x] == 1, nums[y] == 0, затем поменять их значения местами (установить nums[y] = 1 и nums[x] = 0). Если y == aliceIndex, Алиса выбирает единицу после этого хода и nums[y] становится 0.

Верни минимальное количество ходов, необходимых Алисе, чтобы взять ровно k единиц.

Пример 1:

Ввод: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Вывод: 3
Пояснение: Алиса может взять 3 единицы за 3 хода, если выполнит следующие действия на каждом ходу, когда стоит на aliceIndex == 1:

В начале игры Алиса берет единицу и nums[1] становится 0. nums становится [1,1,1,0,0,1,1,0,0,1].
Выбрать j == 2 и выполнить действие первого типа. nums становится [1,0,1,0,0,1,1,0,0,1].
Выбрать x == 2 и y == 1, выполнить действие второго типа. nums становится [1,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу и nums становится [1,0,0,0,0,1,1,0,0,1].
Выбрать x == 0 и y == 1, выполнить действие второго типа. nums становится [0,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0,0,1,1,0,0,1].

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

Пример 2:

Ввод: nums = [0,0,0,0], k = 2, maxChanges = 3
Вывод: 4
Пояснение: Алиса может взять 2 единицы за 4 хода, если выполнит следующие действия на каждом ходу, стоя на aliceIndex == 0:

Выбрать j == 1 и выполнить действие первого типа. nums становится [0,1,0,0].
Выбрать x == 1 и y == 0, выполнить действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0].
Снова выбрать j == 1 и выполнить действие первого типа. nums становится [0,1,0,0].
Снова выбрать x == 1 и y == 0, выполнить действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0].

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

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Вам дан двоичный массив nums длины n, положительное целое число k и неотрицательное целое число maxChanges.
Алиса играет в игру, где цель Алисы — выбрать k единиц из nums, используя минимальное количество ходов. Когда игра начинается, Алиса выбирает любой индекс aliceIndex в диапазоне [0, n - 1] и стоит там. Если nums[aliceIndex] == 1, Алиса выбирает единицу, и nums[aliceIndex] становится равным 0 (это не считается ходом). После этого Алиса может сделать любое количество ходов (включая ноль), где на каждом ходу Алиса должна выполнить ровно одно из следующих действий:

Выберите любой индекс j != aliceIndex такой, что nums[j] == 0, и установите nums[j] = 1. Это действие может быть выполнено не более maxChanges раз.
Выберите любые два соседних индекса x и y (|x - y| == 1) так, чтобы nums[x] == 1, nums[y] == 0, затем поменяйте их значения (установите nums[y] = 1 и nums[x] = 0). Если y == aliceIndex, Алиса выбирает тот, который находится после этого хода, и nums[y] становится равным 0.

Верните минимальное количество ходов, необходимых Алисе, чтобы выбрать ровно k ходов.

Пример 1:

Вход: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Выход: 3
Объяснение: Алиса может подобрать 3 единицы за 3 хода, если Алиса выполнит следующие действия на каждом ходу, стоя в aliceIndex == 1:

В начале игры Алиса подбирает единицу, и nums[1] становится 0. nums становится [1,1,1,0,0,1,1,0,0,1].
Выберите j == 2 и выполните действие первого типа. nums становится [1,0,1,0,0,1,1,0,0,1]
Выберите x == 2 и y == 1 и выполните действие второго типа. nums становится [1,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу, и nums становится [1,0,0,0,0,1,1,0,0,1].
Выберите x == 0 и y == 1 и выполните действие второго типа. nums становится [0,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу, и nums становится [0,0,0,0,0,1,1,0,0,1].

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

Пример 2:

Вход: nums = [0,0,0,0], k = 2, maxChanges = 3
Выход: 4
Объяснение: Алиса может подобрать 2 единицы за 4 хода, если Алиса выполнит следующие действия на каждом ходу, стоя в aliceIndex == 0:

Выберите j == 1 и выполните действие первого типа. nums становится [0,1,0,0].
Выберите x == 1 и y == 0 и выполните действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса подбирает единицу, и nums становится [0,0,0,0].
Выберите j == 1 еще раз и выполните действие первого типа. nums становится [0,1,0,0].
Выберите x == 1 и y == 0 еще раз и выполните действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса выбирает единицу, и nums становится [0,0,0,0].

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

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Дан бинарный массив nums длины n, положительное число k и неотрицательное число maxChanges.
Алиса играет в игру, где цель — выбрать k единиц из nums, используя минимальное количество ходов. Когда начинается игра, Алиса выбирает любой индекс aliceIndex в диапазоне [0, n - 1] и встает там. Если nums[aliceIndex] == 1, Алиса берет единицу, и nums[aliceIndex] становится 0 (это не считается ходом). После этого Алиса может совершать любое количество ходов (включая ноль), где в каждом ходе Алиса должна выполнить ровно одно из следующих действий:

Выбрать любой индекс j != aliceIndex, такой что nums[j] == 0, и установить nums[j] = 1. Это действие можно выполнять не более maxChanges раз.
Выбрать любые два соседних индекса x и y (|x - y| == 1) такие, что nums[x] == 1, nums[y] == 0, затем поменять их значения местами (установить nums[y] = 1 и nums[x] = 0). Если y == aliceIndex, Алиса берет единицу после этого хода и nums[y] становится 0.

Верните минимальное количество ходов, необходимых Алисе для выбора ровно k единиц.

Пример 1:

Ввод: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Вывод: 3
Объяснение: Алиса может подобрать 3 единицы за 3 хода, если Алиса выполнит следующие действия на каждом ходу, когда стоит на aliceIndex == 1:

В начале игры Алиса берет единицу и nums[1] становится 0. nums становится [1,1,1,0,0,1,1,0,0,1].
Выберите j == 2 и выполните действие первого типа. nums становится [1,0,1,0,0,1,1,0,0,1].
Выберите x == 2 и y == 1, и выполните действие второго типа. nums становится [1,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу и nums становится [1,0,0,0,0,1,1,0,0,1].
Выберите x == 0 и y == 1, и выполните действие второго типа. nums становится [0,1,0,0,0,1,1,0,0,1]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0,0,1,1,0,0,1].

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

Пример 2:

Ввод: nums = [0,0,0,0], k = 2, maxChanges = 3
Вывод: 4
Объяснение: Алиса может подобрать 2 единицы за 4 хода, если Алиса выполнит следующие действия на каждом ходу, стоя на aliceIndex == 0:

Выберите j == 1 и выполните действие первого типа. nums становится [0,1,0,0].
Выберите x == 1 и y == 0, и выполните действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0].
Снова выберите j == 1 и выполните действие первого типа. nums становится [0,1,0,0].
Снова выберите x == 1 и y == 0 и выполните действие второго типа. nums становится [1,0,0,0]. Так как y == aliceIndex, Алиса берет единицу и nums становится [0,0,0,0].

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

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k


Дана строка s, верните максимальную длину подстроки, содержащей не более двух вхождений каждого символа.

Пример 1:

Вход: s = "bcbbbcba"
Выход: 4
Explanation:
Следующая подстрока имеет длину 4 и содержит не более двух вхождений каждого символа: "bcbbbcba".

Пример 2:

Вход: s = "aaaa"
Выход: 2
Explanation:
Следующая подстрока имеет длину 2 и содержит не более двух вхождений каждого символа: "aaaa".

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

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

Дана строка s, вернуть максимальную длину подстроки, которая содержит не более двух вхождений каждого символа.

Пример 1:

Вход: s = "bcbbbcba"
Выход: 4
Пояснение:
Следующая подстрока имеет длину 4 и содержит не более двух вхождений каждого символа: "bcbbbcba".
Пример 2:

Вход: s = "aaaa"
Выход: 2
Пояснение:
Следующая подстрока имеет длину 2 и содержит не более двух вхождений каждого символа: "aaaa".

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

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

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

Пример 1:

Входные данные: s = "bcbbbcba"
Выход: 4
Объяснение:
Следующая подстрока имеет длину 4 и содержит не более двух вхождений каждого символа: "bcbbbcba".
Пример 2:

Входные данные: s = "aaaa"
Выход: 2
Объяснение:
Следующая подстрока имеет длину 2 и содержит не более двух вхождений каждого символа: "aaaa".

Ограничения целостности:

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


Вам дается положительное целое число k. Изначально у вас есть массив nums = [1].
Вы можете выполнять любые из следующих операций с массивом любое количество раз (возможно, ноль раз):

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

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

Пример 1:

Ввод: k = 11
Вывод: 5
Объяснение:
Можно выполнить следующие операции с массивом nums = [1]:

Увеличьте элемент на 1 трижды. Полученный массив: nums = [4].
Дублируйте элемент дважды. Полученный массив: nums = [4,4,4].

Сумма финального массива равна 4 + 4 + 4 = 12, что больше или равно k = 11.
Общее количество выполненных операций: 3 + 2 = 5.

Пример 2:

Ввод: k = 1
Вывод: 0
Объяснение:
Сумма оригинального массива уже больше или равна 1, поэтому операции не требуются.

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

1 <= k <= 10^5

Вам дается положительное целое число k. Изначально у вас есть массив nums = [1].
Вы можете выполнять любые из следующих операций с массивом любое количество раз (возможно, ноль раз):

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

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

Пример 1:

Ввод: k = 11
Вывод: 5
Объяснение:
Можно выполнить следующие операции с массивом nums = [1]:

Увеличьте элемент на 1 трижды. Полученный массив: nums = [4].
Дублируйте элемент дважды. Полученный массив nums = [4,4,4].

Сумма финального массива равна 4 + 4 + 4 = 12, что больше или равно k = 11.
Общее количество выполненных операций 3 + 2 = 5.

Пример 2:

Ввод: k = 1
Вывод: 0
Объяснение:
Сумма оригинального массива уже больше или равна 1, поэтому операции не требуются.

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

1 <= k <= 10^5

Вам дано положительное целое число k. Изначально у вас есть массив nums = [1].
Вы можете выполнить любую из следующих операций над массивом любое количество раз (возможно, ноль):

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

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

Пример 1:

Вход: k = 11
Выход: 5
Пояснение:
Мы можем выполнить следующие операции над массивом nums = [1]:

Увеличить элемент на 1 три раза. Результирующий массив — nums = [4].
Дублировать элемент два раза. Результирующий массив — nums = [4,4,4].

Сумма конечного массива равна 4 + 4 + 4 = 12, что больше или равно k = 11.
Общее количество выполненных операций равно 3 + 2 = 5.

Пример 2:

Вход: k = 1
Выход: 0
Пояснение:
Сумма исходного массива уже больше или равна 1, поэтому никаких операций не требуется.

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

1 <= k <= 10^5


Проблема заключается в отслеживании частоты ID в коллекции, которая меняется со временем. У вас есть два целочисленных массива, nums и freq, одинаковой длины n. Каждый элемент в nums представляет ID, а соответствующий элемент в freq указывает, сколько раз этот ID следует добавлять в коллекцию или удалять из неё на каждом этапе.

Добавление ID: Если значение freq[i] положительное, это означает, что ID freq[i] со значением nums[i] добавляются в коллекцию на шаге i.
Удаление ID: Если значение freq[i] отрицательное, это означает, что ID -freq[i] со значением nums[i] удаляются из коллекции на шаге i.

Возвращает массив ans длины n, где ans[i] представляет собой количество наиболее часто встречающихся ID в коллекции после i^го шага. Если на каком-либо шаге коллекция пуста, то для этого шага значение ans[i] должно быть равно 0.

Пример 1:

Ввод: nums = [2,3,2,1], freq = [3,2,-3,1]
Вывод: [3,3,2,2]
Объяснение:
После шага 0, у нас есть 3 ID со значением 2. Итак, ans[0] = 3.
После шага 1, у нас есть 3 ID со значением 2 и 2 ID со значением 3. Итак, ans[1] = 3.
После шага 2, у нас есть 2 ID со значением 3. Итак, ans[2] = 2.
После шага 3, у нас есть 2 ID со значением 3 и 1 ID со значением 1. Итак, ans[3] = 2.

Пример 2:

Ввод: nums = [5,5,3], freq = [2,-2,1]
Вывод: [2,0,1]
Объяснение:
После шага 0 у нас есть 2 ID со значением 5. Итак, ans[0] = 2.
После шага 1, ID нет. Итак, ans[1] = 0.
После шага 2, у нас есть 1 ID со значением 3. Итак, ans[2] = 1.

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

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Входные данные генерируются таким образом, чтобы ни на одном шаге вхождения ID не были отрицательными.

Задача заключается в отслеживании частоты идентификаторов в коллекции, которая меняется со временем. У вас есть два целочисленных массива, nums и freq, одинаковой длины n. Каждый элемент в nums представляет идентификатор, а соответствующий элемент в freq указывает, сколько раз этот идентификатор должен быть добавлен или удален из коллекции на каждом шаге.

Добавление идентификаторов: если freq[i] положительное, это означает, что freq[i] идентификаторов со значением nums[i] добавляются в коллекцию на шаге i.

Удаление идентификаторов: если freq[i] отрицательное, это означает, что -freq[i] идентификаторов со значением nums[i] удаляются из коллекции на шаге i.

Возврат массива ans длины n, где ans[i] представляет количество наиболее частых идентификаторов в коллекции после i^th шага. Если коллекция пуста на любом шаге, ans[i] должно быть равно 0 для этого шага.

Пример 1:

Вход: nums = [2,3,2,1], freq = [3,2,-3,1]
Выход: [3,3,2,2]
Пояснение:
После шага 0 у нас есть 3 идентификатора со значением 2. Поэтому ans[0] = 3.
После шага 1 у нас есть 3 идентификатора со значением 2 и 2 идентификатора со значением 3. Поэтому ans[1] = 3.
После шага 2 у нас есть 2 идентификатора со значением 3. Поэтому ans[2] = 2.
После шага 3 у нас есть 2 идентификатора со значением 3 и 1 идентификатор со значением 1. Поэтому ans[3] = 2.

Пример 2:

Вход: nums = [5,5,3], freq = [2,-2,1]
Выход: [2,0,1]
Пояснение:
После шага 0 у нас есть 2 идентификатора со значением 5. Поэтому ans[0] = 2.
После шага 1 идентификаторов нет. Поэтому ans[1] = 0.
После шага 2 у нас есть 1 идентификатор со значением 3. Поэтому ans[2] = 1.

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

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Входные данные генерируются таким образом, что вхождения идентификатора не будут отрицательными ни на одном шаге.

Задача заключается в отслеживании частоты идентификаторов в коллекции, которая изменяется со временем. У вас есть два целочисленных массива, nums и freq, одинаковой длины n. Каждый элемент в nums представляет идентификатор, а соответствующий элемент в freq указывает, сколько раз этот идентификатор должен быть добавлен в коллекцию или удалён из неё на каждом шаге.

Добавление идентификаторов: Если freq[i] положительно, это означает, что freq[i] идентификаторов с значением nums[i] добавляются в коллекцию на шаге i.
Удаление идентификаторов: Если freq[i] отрицательно, это означает, что -freq[i] идентификаторов с значением nums[i] удаляются из коллекции на шаге i.

Верните массив ans длины n, где ans[i] представляет количество наиболее частого идентификатора в коллекции после i-го шага. Если коллекция пуста на каком-либо шаге, ans[i] должен быть 0 для этого шага.

Пример 1:

Входные данные: nums = [2,3,2,1], freq = [3,2,-3,1]
Выходные данные: [3,3,2,2]
Объяснение:
После шага 0, у нас есть 3 идентификатора со значением 2. Поэтому ans[0] = 3.
После шага 1, у нас есть 3 идентификатора со значением 2 и 2 идентификатора со значением 3. Поэтому ans[1] = 3.
После шага 2, у нас есть 2 идентификатора со значением 3. Поэтому ans[2] = 2.
После шага 3, у нас есть 2 идентификатора со значением 3 и 1 идентификатор со значением 1. Поэтому ans[3] = 2.

Пример 2:

Входные данные: nums = [5,5,3], freq = [2,-2,1]
Выходные данные: [2,0,1]
Объяснение:
После шага 0, у нас есть 2 идентификатора со значением 5. Поэтому ans[0] = 2.
После шага 1, идентификаторов нет. Поэтому ans[1] = 0.
После шага 2, у нас есть 1 идентификатор со значением 3. Поэтому ans[2] = 1.

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

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Входные данные сгенерированы так, что количество вхождений идентификатора не будет отрицательным на любом шаге.


Вам даны два массива строк: wordsContainer и wordsQuery.
Для каждого wordsQuery[i] вам нужно найти строку из wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i]. Если в wordsContainer есть две или более строк с самым длинным общим суффиксом, найдите строку с наименьшей длиной. Если есть две или более таких строк одинаковой наименьшей длины, найдите ту, которая встречалась ранее в wordsContainer.
Возвращаем массив целых чисел ans, где ans[i] — индекс строки в wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i].

Пример 1:

Ввод: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Выход: [1,1,1]
Объяснение:
Давайте рассмотрим каждый wordsQuery[i] отдельно:

Для wordsQuery[0] = "cd", строки из wordsContainer, которые имеют самый длинный общий суффикс "cd", имеют индексы 0, 1 и 2. Среди них ответом является строка с индексом 1, потому что она имеет самую короткую длину 3.
Для wordsQuery[1] = "bcd", строки из wordsContainer, которые имеют самый длинный общий суффикс "bcd", имеют индексы 0, 1 и 2. Среди них ответом является строка с индексом 1, потому что она имеет самую короткую длину 3.
Для wordsQuery[2] = "xyz" нет строки из wordsContainer, которая имела бы общий суффикс. Следовательно, самым длинным распространенным суффиксом является "", который является общим со строками с индексами 0, 1 и 2. Среди них ответом является строка с индексом 1, потому что она имеет самую короткую длину 3.

Пример 2:

Входные данные: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Выход: [2,0,2]
Объяснение:
Давайте рассмотрим каждый wordsQuery[i] отдельно:

Для wordsQuery[0] = "gh", строки из wordsContainer, которые имеют самый длинный общий суффикс "gh", имеют индексы 0, 1 и 2. Среди них ответом является строка с индексом 2, потому что она имеет самую короткую длину 6.
Для wordsQuery[1] = "acbfgh", только строка с индексом 0 имеет самый длинный общий суффикс "fgh". Следовательно, это ответ, даже если строка с индексом 2 короче.
Для wordsQuery[2] = "acbfegh" строки из wordsContainer, которые имеют самый длинный общий суффикс "gh", имеют индексы 0, 1 и 2. Среди них ответом является строка с индексом 2, потому что она имеет самую короткую длину 6.

Ограничения целостности:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] состоит только из строчных английских букв.
wordsQuery[i] состоит только из строчных английских букв.
Сумма wordsContainer[i].length составляет не более 5 * 10^5.
Сумма wordsQuery[i].length составляет не более 5 * 10^5.

Вам даны два массива строк wordsContainer и wordsQuery.
Для каждого wordsQuery[i] вам нужно найти строку из wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i]. Если в wordsContainer есть две или более строк с самым длинным общим суффиксом, найдите строку с наименьшей длиной. Если есть две или более таких строк с одинаковой наименьшей длиной, найдите ту, которая встречалась раньше в wordsContainer.
Верните массив целых чисел ans, где ans[i] — это индекс строки в wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i].

Пример 1:

Входные данные: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Выходные данные: [1,1,1]
Пояснение:
Давайте рассмотрим каждый wordsQuery[i] отдельно:

Для wordsQuery[0] = "cd" строки из wordsContainer, которые имеют самый длинный общий суффикс "cd", находятся под индексами 0, 1 и 2. Среди них ответом является строка с индексом 1, поскольку ее самая короткая длина равна 3.
Для wordsQuery[1] = "bcd" строки из wordsContainer, которые имеют самый длинный общий суффикс "bcd", находятся под индексами 0, 1 и 2. Среди них ответом является строка с индексом 1, поскольку ее самая короткая длина равна 3.
Для wordsQuery[2] = "xyz" нет ни одной строки из wordsContainer, которая имеет общий суффикс. Следовательно, самый длинный общий суффикс — "", который есть у строк с индексом 0, 1 и 2. Среди них ответом будет строка с индексом 1, поскольку она имеет самую короткую длину — 3.

Пример 2:

Входные данные: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Выходные данные: [2,0,2]
Пояснение:
Давайте рассмотрим каждый wordsQuery[i] отдельно:

Для wordsQuery[0] = "gh" строки из wordsContainer, которые имеют самый длинный общий суффикс "gh", находятся в индексах 0, 1 и 2. Среди них ответом будет строка с индексом 2, поскольку она имеет самую короткую длину — 6.
Для wordsQuery[1] = "acbfgh" только строка с индексом 0 имеет самый длинный общий суффикс "fgh". Следовательно, это ответ, хотя строка с индексом 2 короче.
Для wordsQuery[2] = "acbfegh" строки из wordsContainer, которые имеют самый длинный общий суффикс "gh", находятся на индексах 0, 1 и 2. Среди них ответом является строка с индексом 2, поскольку она имеет самую короткую длину 6.

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

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] состоит только из строчных английских букв.
wordsQuery[i] состоит только из строчных английских букв.
Сумма wordsContainer[i].length не более 5 * 10^5.
Сумма wordsQuery[i].length не более 5 * 10^5.

Вам даны два массива строк wordsContainer и wordsQuery.
Для каждого wordsQuery[i] необходимо найти строку из wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i]. Если две или более строки в wordsContainer имеют одинаковый самый длинный общий суффикс, найдите строку, которая имеет наименьшую длину. Если таких строк с одинаковой наименьшей длиной две или более, найдите ту, которая появилась раньше в wordsContainer.
Верните массив целых чисел ans, где ans[i] - это индекс строки в wordsContainer, которая имеет самый длинный общий суффикс с wordsQuery[i].

Пример 1:

Ввод: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Вывод: [1,1,1]
Объяснение:
Рассмотрим каждую wordsQuery[i] отдельно:

Для wordsQuery[0] = "cd" строки из wordsContainer, которые имеют общий суффикс "cd", находятся на индексах 0, 1 и 2. Среди них ответ - строка на индексе 1, так как она имеет меньшую длину равную 3.
Для wordsQuery[1] = "bcd" строки из wordsContainer, которые имеют общий суффикс "bcd", находятся на индексах 0, 1 и 2. Среди них ответ - строка на индексе 1, так как она имеет меньшую длину равную 3.
Для wordsQuery[2] = "xyz" ни одна строка из wordsContainer не имеет общего суффикса. Поэтому самый длинный общий суффикс - это "", который общий со строками на индексах 0, 1 и 2. Среди них ответ - строка на индексе 1, так как она имеет меньшую длину равную 3.

Пример 2:

Ввод: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Вывод: [2,0,2]
Объяснение:
Рассмотрим каждую wordsQuery[i] отдельно:

Для wordsQuery[0] = "gh" строки из wordsContainer, которые имеют общий суффикс "gh", находятся на индексах 0, 1 и 2. Среди них ответ - строка на индексе 2, так как она имеет меньшую длину равную 6.
Для wordsQuery[1] = "acbfgh" только строка на индексе 0 имеет общий суффикс "fgh". Поэтому это и есть ответ, даже несмотря на то, что строка на индексе 2 короче.
Для wordsQuery[2] = "acbfegh" строки из wordsContainer, которые имеют общий суффикс "gh", находятся на индексах 0, 1 и 2. Среди них ответ - строка на индексе 2, так как она имеет меньшую длину равную 6.

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

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] consists only of lowercase English letters.
wordsQuery[i] consists only of lowercase English letters.
Sum of wordsContainer[i].length is at most 5 * 10^5.
Sum of wordsQuery[i].length is at most 5 * 10^5.


Целое число, делящееся на сумму своих цифр, называется числом Харшада. Вам дано целое число x. Верните сумму цифр x, если x является числом Харшада, в противном случае верните -1.

Пример 1:

Вход: x = 18
Выход: 9
Объяснение:
Сумма цифр x равна 9. 18 делится на 9. Следовательно, 18 — это число Харшада, и ответ 9.

Пример 2:

Вход: x = 23
Выход: -1
Объяснение:
Сумма цифр x равна 5. 23 не делится на 5. Следовательно, 23 не является числом Харшада, и ответ -1.

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

1 <= x <= 100

Целое число, делящееся на сумму своих цифр, называется числом Харшада. Вам дано целое число x. Верните сумму цифр x, если x это число Харшада, в противном случае верните -1.

Пример 1:

Ввод: х = 18
Вывод: 9
Объяснение:
Сумма цифр x равна 9. 18 делится на 9. Итак, 18 это число Харшада, а ответ 9.

Пример 2:

Ввод: х = 23
Вывод: -1
Объяснение:
Сумма цифр x равна 5. 23 не делится на 5. Таким образом, 23 не является числом Харшада, и ответ равен -1.

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

1 <= x <= 100

Целое число, делящееся на сумму своих цифр, называется числом Харшада. Вам дано целое число x. Верните сумму цифр x, если x является числом Харшада, в противном случае верните -1.

Пример 1:

Input: x = 18
Output: 9
Объяснение:
Сумма цифр x равна 9. 18 делится на 9. Следовательно, 18 — это число Харшада, и ответ 9.

Пример 2:

Input: x = 23
Output: -1
Объяснение:
Сумма цифр x равна 5. 23 не делится на 5. Следовательно, 23 не является числом Харшада, и ответ -1.

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

1 <= x <= 100


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

Пример 1:

Ввод: nums = [0,1,1,1]
Вывод: 5
Пояснение:
Следующие подмассивы являются чередующимися: [0], [1], [1], [1], и [0,1].

Пример 2:

Ввод: nums = [1,0,1,0]
Вывод: 10
Пояснение:
Каждый подмассив массива является чередующимся. Существует 10 возможных подмассивов, которые мы можем выбрать.

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

1 <= nums.length <= 10^5
nums[i] является либо 0, либо 1.

Вам дан двоичный массив чисел.
Мы называем подмассив чередующимся, если никакие два соседних элемента в подмассиве не имеют одинакового значения.
Возвращает количество чередующихся подмассивов в числах.

Пример 1:

Ввод: nums = [0,1,1,1]
Вывод: 5
Объяснение:
Следующие подмассивы чередуются: [0], [1], [1], [1], и [0,1].

Пример 2:

Ввод: nums = [1,0,1,0]
Вывод: 10
Объяснение:
Каждый подмассив массива чередуется. Мы можем выбрать 10 возможных подмассивов.

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

1 <= nums.length <= 10^5
nums[i] is either 0 or 1.

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

Пример 1:

Вход: nums = [0,1,1,1]
Выход: 5
Пояснение:
Следующие подмассивы являются чередующимися: [0], [1], [1], [1] и [0,1].

Пример 2:

Вход: nums = [1,0,1,0]
Выход: 10
Пояснение:
Каждый подмассив массива является чередующимся. Существует 10 возможных подмассивов, которые мы можем выбрать.

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

1 <= nums.length <= 10^5
nums[i] равно 0 или 1.


Дан массив points, представляющий целочисленные координаты некоторых точек на 2D плоскости, где points[i] = [x_i, y_i]. Расстояние между двумя точками определяется как их манхэттенское расстояние. Верните минимально возможное значение максимального расстояния между любыми двумя точками, удалив ровно одну точку.

Пример 1:

Ввод: points = [[3,10],[5,15],[10,2],[4,4]]
Вывод: 12
Пояснение:
Максимальное расстояние после удаления каждой точки следующее:

После удаления 0-й точки максимальное расстояние между точками (5, 15) и (10, 2), что равно |5 - 10| + |15 - 2| = 18.
После удаления 1-й точки максимальное расстояние между точками (3, 10) и (10, 2), что равно |3 - 10| + |10 - 2| = 15.
После удаления 2-й точки максимальное расстояние между точками (5, 15) и (4, 4), что равно |5 - 4| + |15 - 4| = 12.
После удаления 3-й точки максимальное расстояние между точками (5, 15) и (10, 2), что равно |5 - 10| + |15 - 2| = 18.

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

Пример 2:

Ввод: points = [[1,1],[1,1],[1,1]]
Вывод: 0
Пояснение:
Удаление любой из точек приводит к максимальному расстоянию между любыми двумя точками, равному 0.

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

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Вам дан массив точек, представляющий целочисленные координаты некоторых точек на 2D плоскости, где points[i] = [x_i, y_i].
Расстояние между двумя точками определяется как их Манхэттенское расстояние.
Верните минимально возможное значение максимального расстояния между любыми двумя точками, удалив ровно одну точку.

Пример 1:

Ввод: points = [[3,10],[5,15],[10,2],[4,4]]
Вывод: 12
Объяснение:
Максимальное расстояние после удаления каждой точки следующее:

После удаления 0^й точки максимальное расстояние составляет между точками (5, 15) и (10, 2), что составляет |5 - 10| + |15 - 2| = 18.
После удаления 1^й точки максимальное расстояние составляет между точками (3, 10) и (10, 2), что составляет |3 - 10| + |10 - 2| = 15.
После удаления 2^й точки максимальное расстояние составляет между точками (5, 15) и (4, 4), что составляет |5 - 4| + |15 - 4| = 12.
После удаления 3^й точки максимальное расстояние составляет между точками (5, 15) и (10, 2), что составляет |5 - 10| + |15 - 2| = 18.

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

Пример 2:

Ввод: points = [[1,1],[1,1],[1,1]]
Вывод: 0
Объяснение:
Удаление любой из точек приводит к тому, что максимальное расстояние между любыми двумя точками становится равным 0.

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

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8


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

Пример 1:

Ввод: nums = [1,4,3,3,2]
Вывод: 2
Объяснение:
Строго возрастающими подмассивами nums являются [1], [2], [3], [3], [4] и [1,4].
Строго убывающими подмассивами nums являются [1], [2], [3], [3], [4], [3,2] и [4,3].
Следовательно, мы возвращаем 2.

Пример 2:

Ввод: nums = [3,3,3,3]
Вывод: 1
Объяснение:
Строго возрастающими подмассивами nums являются [3], [3], [3] и [3].
Строго убывающими подмассивами nums являются [3], [3], [3] и [3].
Следовательно, мы возвращаем 1.

Пример 3:

Ввод: nums = [3,2,1]
Вывод: 3
Объяснение:
Строго возрастающими подмассивами nums являются [3], [2] и [1].
Строго убывающими подмассивами nums являются [3], [2], [1], [3,2], [2,1] и [3,2,1].
Следовательно, мы возвращаем 3.

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

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

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

Пример 1:

Вход: nums = [1,4,3,3,2]
Выход: 2
Пояснение:
Строго возрастающие подмассивы nums — это [1], [2], [3], [3], [4] и [1,4].
Строго убывающие подмассивы nums — это [1], [2], [3], [3], [4], [3,2] и [4,3].
Следовательно, мы возвращаем 2.

Пример 2:

Вход: nums = [3,3,3,3]
Выход: 1
Пояснение:
Строго возрастающие подмассивы nums — это [3], [3], [3] и [3].
Строго убывающие подмассивы nums — [3], [3], [3] и [3].
Следовательно, мы возвращаем 1.

Пример 3:

Вход: nums = [3,2,1]
Выход: 3
Пояснение:
Строго возрастающие подмассивы nums — [3], [2] и [1].
Строго убывающие подмассивы nums — [3], [2], [1], [3,2], [2,1] и [3,2,1].
Следовательно, мы возвращаем 3.

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

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


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

Сумма минимального расстояния между s_1[i] и s_2[i], когда символы от 'a' до 'z' расположены по циклу, для всех i в диапазоне [0, n - 1].

Например, distance("ab", "cd") == 4, и distance("a", "z") == 1.
Вы можете изменить любую букву s на любую другую строчную английскую букву любое количество раз.
Верните строку, обозначающую лексикографически наименьшую строку t, которую вы можете получить после некоторых изменений, так что distance(s, t) <= k.

Пример 1:

Ввод: s = "zbbz", k = 3
Вывод: "aaaz"
Объяснение:
Измените s на "aaaz". Расстояние между "zbbz" и "aaaz" равно k = 3.

Пример 2:

Ввод: s = "xaxcd", k = 4
Вывод: "aawcd"
Объяснение:
Расстояние между "xaxcd" и "aawcd" равно k = 4.

Пример 3:

Ввод: s = "lol", k = 0
Вывод: "lol"
Объяснение:
Невозможно изменить какой-либо символ, так как k = 0.

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

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

Вам дана строка s и целое число k.
Определите функцию distance(s_1, s_2) между двумя строками s_1 и s_2 одинаковой длины n как:

Сумма минимального расстояния между s_1[i] и s_2[i], когда символы от 'a' до 'z' размещены в циклическом порядке, для всех i в диапазоне [0, n - 1].

Например, distance("ab", "cd") == 4 и distance("a", "z") == 1.
Вы можете изменить любую букву s на любую другую строчную английскую букву любое количество раз.
Вернуть строку, обозначающую лексикографически наименьшую строку t, которую вы можете получить после некоторых изменений, так что distance(s, t) <= k.

Пример 1:

Вход: s = "zbbz", k = 3
Выход: "aaaz"
Пояснение:
Измените s на "aaaz". Расстояние между "zbbz" и "aaaz" равно k = 3.

Пример 2:

Вход: s = "xaxcd", k = 4
Выход: "aawcd"
Пояснение:
Расстояние между "xaxcd" и "aawcd" равно k = 4.

Пример 3:

Вход: s = "lol", k = 0
Выход: "lol"
Пояснение:
Невозможно изменить ни один символ, так как k = 0.

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

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


Дан целочисленный массив nums и неотрицательное целое число k. За одну операцию вы можете увеличить или уменьшить любой элемент на 1.
Верните минимальное количество операций, необходимых для того, чтобы медиана nums была равна k.
Медиана массива определяется как средний элемент массива, когда он отсортирован в порядке неубывания. Если есть два варианта для медианы, выбирается большее из двух значений.

Пример 1:

Ввод: nums = [2,5,6,8,5], k = 4
Вывод: 2
Объяснение:
Можно вычесть единицу из nums[1] и nums[4], чтобы получить [2, 4, 6, 8, 4]. Медиана полученного массива равна k.

Пример 2:

Ввод: nums = [2,5,6,8,5], k = 7
Вывод: 3
Объяснение:
Можно дважды добавить единицу к nums[1] и один раз добавить единицу к nums[2], чтобы получить [2, 7, 7, 8, 5].

Пример 3:

Ввод: nums = [1,2,3,4,5,6], k = 4
Вывод: 0
Объяснение:
Медиана массива уже равна k.

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

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

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

Пример 1:

Входные данные: nums = [2,5,6,8,5], k = 4
Выход: 2
Объяснение:
Мы можем вычесть единицу из чисел[1] и чисел[4], чтобы получить [2, 4, 6, 8, 4]. Медиана результирующего массива равна k.

Пример 2:

Входные данные: nums = [2,5,6,8,5], k = 7
Выход: 3
Объяснение:
Мы можем прибавить единицу к числам[1] дважды и прибавить единицу к числам[2] один раз, чтобы получить [2, 7, 7, 8, 5].

Пример 3:

Входные данные: nums = [1,2,3,4,5,6], k = 4
Выход: 0
Объяснение:
Медиана массива уже равна k.

Ограничения целостности:

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

Дан целочисленный массив nums и неотрицательное целое число k. За одну операцию можно увеличить или уменьшить любой элемент на 1.
Выведи минимальное количество операций, необходимых для того, чтобы медиана nums была равна k.
Медиана массива определяется как средний элемент массива, когда он отсортирован в неубывающем порядке. Если есть два варианта для медианы, берется большее из двух значений.

Пример 1:

Ввод: nums = [2,5,6,8,5], k = 4
Вывод: 2
Пояснение:
Можно вычесть единицу из nums[1] и nums[4], чтобы получить [2, 4, 6, 8, 4]. Медиана полученного массива равна k.

Пример 2:

Ввод: nums = [2,5,6,8,5], k = 7
Вывод: 3
Пояснение:
Можно дважды добавить единицу к nums[1] и один раз добавить единицу к nums[2], чтобы получить [2, 7, 7, 8, 5].

Пример 3:

Ввод: nums = [1,2,3,4,5,6], k = 4
Вывод: 0
Пояснение:
Медиана массива уже равна k.

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

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


Вам дана строка s, представляющая время в 12-часовом формате, в которой некоторые цифры (возможно, ни одна) заменены знаком "?".
12-часовое время форматируется как "ЧЧ:ММ", где ЧЧ это от 00 до 11, а ММ это от 00 до 59. Самое раннее 12-часовое время это 00:00, а самое позднее это 11:59.
Нужно заменить все символы "?" в s на цифры так, чтобы время, которое мы получим в результирующей строке, было правильным временем в 12-часовом формате и было самым поздним из возможных.
Верните полученную строку.

Пример 1:

Ввод: s = "1?:?4"
Вывод: "11:54"
Пояснения: Самое позднее время в 12-часовом формате, которое мы можем получить, заменив символы "?", это "11:54".

Пример 2:

Ввод: s = "0?:5?"
Вывод: "09:59"
Пояснения: Самое позднее время в 12-часовом формате, которое мы можем получить, заменив символы "?", это "09:59".

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

s.length == 5
s[2] равен символу ":".
Все символы, кроме s[2], являются цифрами или символами "?".
Вводные данные генерируются таким образом, чтобы между "00:00" и "11:59" существовало хотя бы одно время, которое можно получить после замены символов "?".

Вам дана строка s, представляющая время в 12-часовом формате, где некоторые цифры (возможно, ни одной) заменены символом "?".
Время в 12-часовом формате записывается как "HH:MM", где HH находится в диапазоне от 00 до 11, а MM — от 00 до 59. Самое раннее время — 00:00, а самое позднее — 11:59.
Вы должны заменить все символы "?" на цифры таким образом, чтобы полученное время соответствовало допустимому 12-часовому формату и было максимально поздним.
Верните получившуюся строку.

Пример 1:

Ввод: s = "1?:?4"
Вывод: "11:54"
Объяснение: Самое позднее время в 12-часовом формате, которое мы можем получить, заменяя символы "?", — "11:54".

Пример 2:

Ввод: s = "0?:5?"
Вывод: "09:59"
Объяснение: Самое позднее время в 12-часовом формате, которое можно получить, заменяя символы "?", — "09:59".

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

s.length == 5
s[2] равен символу ":".
Все символы, кроме s[2], являются цифрами или символами "?".
Ввод устроен так, что существует хотя бы одно время между "00:00" и "11:59", которое можно получить после замены символов "?".

Вам дана строка s, представляющая время в 12-часовом формате, где некоторые цифры (возможно, ни одной) заменены на "?".
12-часовое время форматируется как "HH:MM", где ЧЧ находится в диапазоне от 00 до 11, а ММ находится в диапазоне от 00 до 59. Самое раннее 12-часовое время — 00:00, а самое позднее — 11:59.
Вам нужно заменить все символы "?" вs цифрами так, чтобы время, которое мы получим с помощью результирующей строки, было допустимым временем в 12-часовом формате и было самым поздним из возможных.
Верните результирующую строку.

Пример 1:

Входные данные: s = "1?:?4"
Выходные данные: "11:54"
Пояснение: самое позднее время в 12-часовом формате, которого мы можем достичь, заменив символы "?", —  "11:54".

Пример 2:

Входные данные: s = "0?:5?"
Вывод: "09:59"
Пояснение: Самое позднее время в 12-часовом формате, которого мы можем достичь, заменив символы "?", — "09:59".

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

s.length == 5
s[2] равно символу ":".
Все символы, кроме s[2], являются цифрами или символами "?".
Ввод генерируется таким образом, что есть по крайней мере одно время между "00:00" и "11:59", которое можно получить заменив символы "?".


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

Пример 1:

Вход: nums = [4,2,9,5,3]
Выход: 3
Пояснение: nums[1], nums[3] и nums[4] являются простыми числами. Поэтому ответ |4 - 1| = 3.

Пример 2:

Вход: nums = [4,8,2,8]
Выход: 0
Пояснение: nums[2] является простым числом. Поскольку существует только одно простое число, ответ |2 - 2| = 0.

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

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Входные данные генерируются таким образом, чтобы количество простых чисел в nums было не менее одного.

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

Пример 1:

Вход: nums = [4,2,9,5,3]
Выход: 3
Пояснение: nums[1], nums[3] и nums[4] являются простыми числами. Поэтому ответ |4 - 1| = 3.

Пример 2:

Вход: nums = [4,8,2,8]
Выход: 0
Пояснение: nums[2] является простым числом. Поскольку существует только одно простое число, ответ |2 - 2| = 0.

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

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Ввод сгенерирован таким образом, что хотя бы одно простое число присутствует в nums.

Дан целочисленный массив nums.
Верните целое число, которое является максимальным расстоянием между показателями двух (не обязательно разных) простыми числами в nums.

Пример 1:

Ввод: nums = [4,2,9,5,3]
Вывод: 3
Пояснение: nums[1], nums[3] и nums[4] — простые. Таким образом, ответ |4 - 1| = 3.

Пример 2:

Вход: nums = [4,8,2,8]
Вывод: 0
Объяснение: nums[2] — простое число. Поскольку есть только один простой число, ответ | 2 - 2 | = 0.

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

1 <= nums.length <= 3 * 10^5
1 <= nums [i] <= 100
Ввод генерируется таким образом, что количество простых чисел в Nums - по крайней мере одно.


Вам дан целочисленный массив coins, представляющий монеты разных номиналов, и целое число k.
У вас есть бесконечное количество монет каждого номинала. Однако, вам не разрешается объединять монеты разных номиналов.
Верните k-ую наименьшую сумму, которую можно составить с помощью этих монет.

Пример 1:

Ввод: coins = [3,6,9], k = 3
Вывод:  9
Объяснение: Данные монеты могут составить следующие суммы:
Монета 3 дает кратные 3: 3, 6, 9, 12, 15 и т.д.
Монета 6 дает кратные 6: 6, 12, 18, 24 и т.д.
Монета 9 дает кратные 9: 9, 18, 27, 36 и т.д.
Все монеты вместе дают: 3, 6, 9, 12, 15 и т.д.

Пример 2:

Ввод: coins = [5,2], k = 7
Вывод: 12
Объяснение: Данные монеты могут составить следующие суммы:
Монета 5 дает кратные 5: 5, 10, 15, 20 и т.д.
Монета 2 дает кратные 2: 2, 4, 6, 8, 10, 12 и т.д.
Все монеты вместе дают: 2, 4, 5, 6, 8, 10, 12, 14, 15 и т.д.

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

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins содержит попарно различные целые числа.

Вам дан целочисленный массив coins, представляющий монеты разного достоинства, и целое число k.
У вас есть бесконечное количество монет каждого достоинства. Однако вам не разрешено объединять монеты разного достоинства.
Верните k^-ю наименьшую сумму, которую можно получить с помощью этих монет.

Пример 1:

Вход: coins = [3,6,9], k = 3
Выход: 9
Пояснение: данные монеты могут составлять следующие суммы:
Монета 3 производит кратные 3: 3, 6, 9, 12, 15 и т. д.
Монета 6 производит кратные 6: 6, 12, 18, 24 и т. д.
Монета 9 производит кратные 9: 9, 18, 27, 36 и т. д.
Все монеты вместе производят: 3, 6, 9, 12, 15 и т. д.

Пример 2:

Вход: coins = [5,2], k = 7
Выход: 12
Пояснение: данные монеты могут составлять следующие суммы:
Монета 5 производит кратные 5: 5, 10, 15, 20 и т. д.
Монета 2 производит кратные из 2: 2, 4, 6, 8, 10, 12 и т. д.
Все монеты вместе дают: 2, 4, 5, 6, 8, 10, 12, 14, 15 и т. д.

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

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins содержит попарно различные целые числа.

Вам дан целочисленный массив coins, представляющий монеты разных номиналов, и целое число k. У вас есть бесконечное количество монет каждого номинала. Однако, вам не разрешается объединять монеты разных номиналов. Верните k-ую наименьшую сумму, которую можно составить с помощью этих монет.

Пример 1:

Input: coins = [3,6,9], k = 3
Output: 9
Explanation: Данные монеты могут составить следующие суммы:
Монета 3 дает кратные 3: 3, 6, 9, 12, 15 и т.д.
Монета 6 дает кратные 6: 6, 12, 18, 24 и т.д.
Монета 9 дает кратные 9: 9, 18, 27, 36 и т.д.
Все монеты вместе дают: 3, 6, 9, 12, 15 и т.д.

Пример 2:

Input: coins = [5,2], k = 7
Output: 12
Explanation: Данные монеты могут составить следующие суммы:
Монета 5 дает кратные 5: 5, 10, 15, 20 и т.д.
Монета 2 дает кратные 2: 2, 4, 6, 8, 10, 12 и т.д.
Все монеты вместе дают: 2, 4, 5, 6, 8, 10, 12, 14, 15 и т.д.

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

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins содержит попарно различные целые числа.


Вам даны два массива nums и andValues длины n и m соответственно.
Значение массива равно его последнему элементу.
Необходимо разделить nums на m непересекающихся смежных подмассивов так, чтобы для i-го подмассива [l_i, r_i] побитовая операция AND элементов подмассива равнялась andValues[i], другими словами, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] для всех 1 <= i <= m, где & обозначает побитовую операцию AND.
Верните минимально возможную сумму значений m подмассивов, на которые nums разделен. Если невозможно разделить nums на m подмассивов, удовлетворяющих этим условиям, верните -1.

Пример 1:

Ввод: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Вывод: 12
Пояснение:
Единственный возможный способ разделить nums:

[1,4] так как 1 & 4 == 0.
[3] так как побитовая операция AND для подмассива из одного элемента равна самому элементу.
[3] так как побитовая операция AND для подмассива из одного элемента равна самому элементу.
[2] так как побитовая операция AND для подмассива из одного элемента равна самому элементу.

Сумма значений для этих подмассивов равна 4 + 3 + 3 + 2 = 12.

Пример 2:

Ввод: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Вывод: 17
Пояснение:
Есть три способа разделить nums:

[[2,3,5],[7,7,7],[5]] с суммой значений 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] с суммой значений 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] с суммой значений 7 + 7 + 5 == 19.

Минимально возможная сумма значений — 17.

Пример 3:

Ввод: nums = [1,2,3,4], andValues = [2]
Вывод: -1
Пояснение:
Побитовая операция AND для всего массива nums равна 0. Так как невозможно разделить nums на один подмассив с побитовой операцией AND равной 2, верните -1.

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

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Вам даны два массива nums и andValues длиной n и m соответственно.
Значение массива равно последнему элементу этого массива.
Вам нужно разделить nums на m непересекающихся смежных подмассивов таким образом, чтобы для i^th подмассива [l_i, r_i] побитовое И элементов подмассива было равно andValues[i], другими словами, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] для всех 1 <= i <= m, где & представляет собой оператор побитового И.
Вернуть минимально возможную сумму значений m подмассивов, на которые разделен nums. Если невозможно разделить nums на m подмассивов, удовлетворяющих этим условиям, вернуть -1.

Пример 1:

Вход: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Выход: 12
Пояснение:
Единственный возможный способ разделить nums:

[1,4] как 1 & 4 == 0.
[3] как побитовое И подмассива с одним элементом — это сам этот элемент.
[3] как побитовое И подмассива с одним элементом — это сам этот элемент.
[2] как побитовое И подмассива с одним элементом — это сам этот элемент.

Сумма значений для этих подмассивов составляет 4 + 3 + 3 + 2 = 12.

Пример 2:

Входные данные: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Выходные данные: 17
Пояснение:
Есть три способа деления nums:

[[2,3,5],[7,7,7],[5]] с суммой значений 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] с суммой значений 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] с суммой значений 7 + 7 + 5 == 19.

Минимально возможная сумма значений составляет 17.

Пример 3:

Вход: nums = [1,2,3,4], andValues = [2]
Выход: -1
Объяснение:
Побитовое И всего массива nums равно 0. Поскольку нет возможности разделить nums на один подмассив, чтобы получить побитовое И элементов 2, вернуть -1.

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

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Вам даны два массива nums и andValues длиной n и m соответственно.
Значение массива равно последнему элементу этого массива.
Вам нужно разделить nums на m непересекающихся смежных подмассивов так, чтобы для i^-го подмассива [l_i, r_i] побитовое AND элементов подмассива было равно andValues[i], другими словами, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] for all 1 <= i <= m, где & представляет побитовый оператор AND.
Верните минимально возможную сумму значений m подмассивов, на которые делятся числа. Если невозможно разделить числа на m подмассивов, удовлетворяющих этим условиям, верните -1.

Пример 1:

Ввод: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Вывод: 12
Объяснение:
Единственный возможный способ разделить числа:

[1,4] как 1 & 4 == 0.
[3] поскольку побитовое AND для подмассива из одного элемента является самим этим элементом.
[3] поскольку побитовое AND для подмассива из одного элемента является самим этим элементом.
[2] поскольку побитовое AND для подмассива из одного элемента является самим этим элементом.

Сумма значений этих подмассивов равна 4 + 3 + 3 + 2 = 12.

Пример 2:

Ввод: nums = [2,3,5,7,7,7,5] andValues = [0,7,5]
Вывод: 17
Объяснение:
Существует три способа деления чисел:

[[2,3,5],[7,7,7],[5]] с суммой значений 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] с суммой значений 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] с суммой значений 7 + 7 + 5 == 19.

Минимально возможная сумма значений равна 17.

Пример 3:

Ввод: nums = [1,2,3,4] andValues = [2]
Вывод: -1
Объяснение:
Побитовое AND для всего массива nums равно 0. Поскольку невозможно разделить числа на один подмассив, чтобы получить побитовое AND для элементов 2, верните -1.

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

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Вам дан целочисленный массив nums, содержащий положительные целые числа. Мы определяем функцию encrypt таким образом, что encrypt(x) заменяет каждую цифру в x на самую большую цифру в x. Например, encrypt(523) = 555 и encrypt(213) = 333.
Вернуть сумму зашифрованных элементов.

Пример 1:

Вход: nums = [1,2,3]
Выход: 6
Пояснение: зашифрованные элементы — [1,2,3]. Сумма зашифрованных элементов — 1 + 2 + 3 == 6.

Пример 2:

Вход: nums = [10,21,31]
Выход: 66
Пояснение: зашифрованные элементы — [11,22,33]. Сумма зашифрованных элементов составляет 11 + 22 + 33 == 66.

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

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

Вам дан целочисленный массив nums, содержащий положительные целые числа. Мы определяем функцию encrypt таким образом, что encrypt(x) заменяет каждую цифру в x на самую большую цифру в x. Например, encrypt(523) = 555 и encrypt(213) = 333.
Возвращает сумму зашифрованных элементов.

Пример 1:

Входные данные: nums = [1,2,3]
Выход: 6
Пояснение: Зашифрованные элементы - [1,2,3]. Сумма зашифрованных элементов равна 1 + 2 + 3 == 6.

Пример 2:

Входные данные: nums = [10,21,31]
Выход: 66
Пояснение: Зашифрованные элементы [11,22,33]. Сумма зашифрованных элементов равна 11 + 22 + 33 == 66.

Ограничения целостности:

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

Дан целочисленный массив nums, содержащий положительные числа. Определим функцию encrypt, такую что encrypt(x) заменяет каждую цифру в x на наибольшую цифру в x. Например, encrypt(523) = 555 и encrypt(213) = 333.
Верните сумму зашифрованных элементов.

Пример 1:

Input: nums = [1,2,3]
Output: 6
Explanation: Зашифрованные элементы [1,2,3]. Сумма зашифрованных элементов 1 + 2 + 3 == 6.

Пример 2:

Input: nums = [10,21,31]
Output: 66
Explanation: Зашифрованные элементы [11,22,33]. Сумма зашифрованных элементов 11 + 22 + 33 == 66.

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

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


Вам дан 0-индексированный массив nums размера n, состоящий из положительных целых чисел.
Вам также дан двумерный массив queries размера m, где queries[i] = [index_i, k_i].
Изначально все элементы массива не отмечены.
Вам нужно выполнить m запросов на массив по порядку, где в i-м запросе вы делаете следующее:

Отмечаете элемент в позиции index_i, если он еще не отмечен.
Затем отмечаете k_i неотмеченных элементов в массиве с наименьшими значениями. Если таких элементов несколько, отмечаете те, у которых наименьшие индексы. И если существует менее k_i неотмеченных элементов, то отмечаете все из них.

Верните массив answer размера m, где answer[i] является суммой неотмеченных элементов в массиве после i-го запроса.

Пример 1:

Ввод: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Вывод: [8,3,0]
Объяснение:
Мы выполняем следующие запросы на массив:

Отмечаем элемент в позиции 1, и 2 наименьших неотмеченных элементов с наименьшими индексами, если они существуют, отмеченные элементы сейчас nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов 2 + 2 + 3 + 1 = 8.
Отмечаем элемент в позиции 3, так как он уже отмечен, мы его пропускаем. Затем отмечаем 3 наименьших неотмеченных элемента с наименьшими индексами, отмеченные элементы сейчас nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов 3.
Отмечаем элемент в позиции 4, так как он уже отмечен, мы его пропускаем. Затем отмечаем 2 наименьших неотмеченных элемента с наименьшими индексами, если они существуют, отмеченные элементы сейчас nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов 0.

Пример 2:

Ввод: nums = [1,4,2,3], queries = [[0,1]]
Вывод: [7]
Объяснение: Мы выполняем один запрос, чтобы отметить элемент в позиции 0 и отметить наименьший элемент среди неотмеченных элементов. Отмеченные элементы будут nums = [1,4,2,3], и сумма неотмеченных элементов 4 + 3 = 7.

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

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Вам дан 0-индексированный массив nums размера n, состоящий из положительных целых чисел.
Вам также дан 2D-массив запросов размера m, где queries[i] = [index_i, k_i].
Изначально все элементы массива не помечены.
Вам нужно применить m запросов к массиву по порядку, где на i^-м запросе вы делаете следующее:

Пометьте элемент по индексу index_i, если он еще не помечен.
Затем отметьте k_i неотмеченные элементы в массиве наименьшими значениями. Если таких элементов несколько, отметьте те, у которых наименьшие индексы. А если существует менее k_i немаркированных элементов, то отметьте их все.

Возвращает массив answer размера m, где answer[i] — сумма немаркированных элементов в массиве после i^-го запроса.

Пример 1:

Входные данные: nums = [1,2,2,1,2,3,1], запросы = [[1,2],[3,3],[4,2]]
Выход: [8,3,0]
Объяснение:
Мы выполняем следующие запросы к массиву:

Отметьте элемент по индексу 1, а 2 из наименьших неотмеченных элементов с наименьшими индексами, если они существуют, помеченные элементы теперь будут иметь значение nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов равна 2 + 2 + 3 + 1 = 8.
Отмечаем элемент по индексу 3, так как он уже отмечен, мы его пропускаем. Затем мы отмечаем 3 самых маленьких неотмеченных элемента наименьшими индексами, отмеченные элементы теперь имеют значение nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов равна 3.
Отмечаем элемент по индексу 4, так как он уже отмечен, мы его пропускаем. Затем мы отмечаем 2 самых маленьких неотмеченных элемента наименьшими индексами, если они есть, помеченные элементы теперь имеют значение nums = [1,2,2,1,2,3,1]. Сумма неотмеченных элементов равна 0.

Пример 2:

Входные данные: nums = [1,4,2,3], queries = [[0,1]]
Вывод: [7]
Пояснение: Мы выполняем один запрос, который помечает элемент по индексу 0 и отмечает наименьший элемент среди неотмеченных элементов. Отмеченные элементы будут иметь значение nums = [1,4,2,3], а сумма неотмеченных элементов будет равна 4 + 3 = 7.

Ограничения целостности:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1


У вас есть строка s. s[i] — это либо строчная английская буква, либо '?'.
Для строки t длиной m, содержащей только строчные английские буквы, мы определяем функцию cost(i) для индекса i как количество символов, равных t[i], которые появились перед ним, то есть в диапазоне [0, i - 1].
Значение t — это сумма cost(i) для всех индексов i.
Например, для строки t = "aab":

cost(0) = 0
cost(1) = 1
cost(2) = 0
Таким образом, значение "aab" равно 0 + 1 + 0 = 1.

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

Пример 1:

Ввод:   s = "???"
Вывод:   "abc"
Объяснение:  В этом примере мы можем заменить вхождения '?' так, чтобы s стало равно "abc".
Для "abc", cost(0) = 0, cost(1) = 0 и cost(2) = 0.
Значение "abc" равно 0.
Некоторые другие модификации s, имеющие значение 0: "cba", "abz" и "hey".
Среди всех них мы выбираем лексикографически наименьшую.

Пример 2:

Ввод:  s = "a?a?"
Вывод:  "abac"
Объяснение:  В этом примере вхождения '?' могут быть заменены так, чтобы s стало равно "abac".
Для "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1 и cost(3) = 0.
Значение "abac" равно 1.

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

1 <= s.length <= 10^5
s[i] — это либо строчная английская буква, либо '?'.

Вам дана строка s. s[i] — это либо строчная английская буква, либо '?'.
Для строки t длиной m, содержащей только строчные английские буквы, мы определяем функцию cost(i) для индекса i как количество символов, равных t[i], которые появились перед ним, т. е. в диапазоне [0, i - 1].
Значение t равно сумме cost(i) для всех индексов i.
Например, для строки t = "aab":

cost(0) = 0
cost(1) = 1
cost(2) = 0
Следовательно, значение "aab" равно 0 + 1 + 0 = 1.

Ваша задача — заменить все вхождения '?' в s на любую строчную английскую букву так, чтобы значение s было минимальным.
Верните строку, обозначающую измененную строку с замененными вхождениями «?». Если есть несколько строк, дающих минимальное значение, вернуть лексикографически наименьшее.

Пример 1:

Вход: s = "???"

Выход: "abc"
Пояснение: в этом примере мы можем заменить вхождения "?", чтобы сделать s равным "abc".
Для "abc" cost(0) = 0, cost(1) = 0 и cost(2) = 0.
Значение "abc" равно 0.
Некоторые другие модификации s, которые имеют значение 0, — это "cba", "abz" и "hey".
Из всех них мы выбираем лексикографически наименьшее.

Пример 2:

Вход: s = "a?a?"
Выход: "abac"
Пояснение: в этом примере вхождения "?" можно заменить, чтобы сделать s равным "abac".
Для "abac" cost(0) = 0, cost(1) = 0, cost(2) = 1 и cost(3) = 0.
Значение "abac" равно 1.

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

1 <= s.length <= 10^5
s[i] — это либо строчная английская буква, либо «?».

Вам дана строка s. s[i] — это либо строчная английская буква, либо «?».
Для строки t длиной m, содержащей только строчные английские буквы, мы определяем функцию cost(i) для индекса i как количество символов, равных t[i], которые появились перед ним, т. е. в диапазоне [0, i - 1].
Значение t равно сумме cost(i) для всех индексов i.
Например, для строки t = «aab»:

cost(0) = 0
cost(1) = 1
cost(2) = 0
Следовательно, значение «aab» равно 0 + 1 + 0 = 1.

Ваша задача — заменить все вхождения «?» в s на любую строчную английскую букву так, чтобы значение s было минимальным.
Верните строку, обозначающую измененную строку с замененными вхождениями «?». Если есть несколько строк, дающих минимальное значение, вернуть лексикографически наименьшее.

Пример 1:

Вход: s = "???"

Выход: "abc"
Пояснение: в этом примере мы можем заменить вхождения "?", чтобы сделать s равным "abc".
Для "abc" cost(0) = 0, cost(1) = 0 и cost(2) = 0.
Значение "abc" равно 0.
Некоторые другие модификации s, которые имеют значение 0, — это "cba", "abz" и "hey".
Из всех них мы выбираем лексикографически наименьшее.

Пример 2:

Вход: s = "a?a?"
Выход: "abac"
Пояснение: в этом примере вхождения "?" можно заменить, чтобы сделать s равным "abac".
Для "abac" cost(0) = 0, cost(1) = 0, cost(2) = 1 и cost(3) = 0.
Значение "abac" равно 1.

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

1 <= s.length <= 10^5
s[i] — это либо строчная английская буква, либо «?».


Вам дан целочисленный массив nums длины n и положительное число k.

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

Пример 1:

Ввод:   nums = [1,2,3], k = 3
Вывод:   6
Объяснение:
Существует 5 подпоследовательностей nums с ненулевой мощностью:

Подпоследовательность [1,2,3] имеет 2 подпоследовательности с суммой == 3: [1,2,3] и [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].

Поэтому ответ 2 + 1 + 1 + 1 + 1 = 6.

Пример 2:

Ввод:   nums = [2,3,3], k = 5
Вывод:   4
Объяснение:
Существует 3 подпоследовательности nums с ненулевой мощностью:

Подпоследовательность [2,3,3] имеет 2 подпоследовательности с суммой == 5: [2,3,3] и [2,3,3].
Подпоследовательность [2,3,3] имеет 1 подпоследовательность с суммой == 5: [2,3,3].
Подпоследовательность [2,3,3] имеет 1 подпоследовательность с суммой == 5: [2,3,3].

Поэтому ответ 2 + 1 + 1 = 4.

Пример 3:

Ввод:   nums = [1,2,3], k = 7
Вывод:   0
Объяснение: Не существует подпоследовательности с суммой 7. Поэтому все подпоследовательности nums имеют мощность = 0.

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

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

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

Пример 1:

Ввод: nums = [1,2,3], k = 3
Вывод: 6
Объяснение:
Существует 5 подпоследовательностей чисел ненулевой степени:

Подпоследовательность [1,2,3] имеет 2 подпоследовательности с суммой == 3: [1,2,3] и [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].
Подпоследовательность [1,2,3] имеет 1 подпоследовательность с суммой == 3: [1,2,3].

Следовательно, ответ: 2 + 1 + 1 + 1 + 1 = 6.

Пример 2:

Ввод: nums = [2,3,3], k = 5
Вывод: 4
Объяснение:
Существует 3 подпоследовательности чисел ненулевой степени:

Подпоследовательность [2,3,3] имеет 2 подпоследовательности с суммой == 5: [2,3,3] и [2,3,3].
Подпоследовательность [2,3,3] имеет 1 подпоследовательность с суммой == 5: [2,3,3].
Подпоследовательность [2,3,3] имеет 1 подпоследовательность с суммой == 5: [2,3,3].

Следовательно, ответ: 2 + 1 + 1 = 4.

Пример 3:

Ввод: nums = [1,2,3], k = 7
Вывод: 0
Пояснение: Не существует подпоследовательности с суммой 7. Следовательно, все подпоследовательности чисел имеют степень = 0.

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

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

Вам дан массив целых чисел nums длины n и положительное число k.

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

Пример 1:

Input:   nums = [1,2,3], k = 3
Output:   6
Explanation:
There are 5 subsequences of nums with non-zero power:

The subsequence [1,2,3] has 2 subsequences with sum == 3: [1,2,3] and [1,2,3].
The subsequence [1,2,3] has 1 subsequence with sum == 3: [1,2,3].
The subsequence [1,2,3] has 1 subsequence with sum == 3: [1,2,3].
The subsequence [1,2,3] has 1 subsequence with sum == 3: [1,2,3].
The subsequence [1,2,3] has 1 subsequence with sum == 3: [1,2,3].

Hence the answer is 2 + 1 + 1 + 1 + 1 = 6.

Пример 2:

Input:   nums = [2,3,3], k = 5
Output:   4
Explanation:
There are 3 subsequences of nums with non-zero power:

The subsequence [2,3,3] has 2 subsequences with sum == 5: [2,3,3] and [2,3,3].
The subsequence [2,3,3] has 1 subsequence with sum == 5: [2,3,3].
The subsequence [2,3,3] has 1 subsequence with sum == 5: [2,3,3].

Hence the answer is 2 + 1 + 1 = 4.

Пример 3:

Input:   nums = [1,2,3], k = 7
Output:   0
Explanation: There exists no subsequence with sum 7. Hence all subsequences of nums have power = 0.

Constraints:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100


Вам дан массив nums из неотрицательных целых чисел и целое число k.
Массив называется специальным, если побитовое OR всех его элементов не меньше k.
Верните длину самого короткого специального непустого подмассива из nums или верните -1, если специальный подмассив не существует.

Пример 1:

Input: nums = [1,2,3], k = 2
Output: 1
Пояснение:
Подмассив [3] имеет OR значение 3. Следовательно, мы возвращаем 1.

Пример 2:

Input: nums = [2,1,8], k = 10
Output: 3
Пояснение:
Подмассив [2,1,8] имеет OR значение 11. Следовательно, мы возвращаем 3.

Пример 3:

Input: nums = [1,2], k = 0
Output: 1
Пояснение:
Подмассив [1] имеет OR значение 1. Следовательно, мы возвращаем 1.

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

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Дан массив nums из неотрицательных целых чисел и целое число k.
Массив называется специальным, если побитовое OR всех его элементов равно не менее k.
Верни длину самого короткого специального непустого подмассива массива nums или верни -1, если специального подмассива не существует.

Пример 1:

Ввод: nums = [1,2,3], k = 2
Вывод: 1
Пояснение:
Подмассив [3] имеет значение OR, равное 3. Следовательно, возвращаем 1.

Пример 2:

Ввод: nums = [2,1,8], k = 10
Вывод: 3
Пояснение:
Подмассив [2,1,8] имеет значение OR, равное 11. Следовательно, возвращаем 3.

Пример 3:

Ввод: nums = [1,2], k = 0
Вывод: 1
Пояснение:
Подмассив [1] имеет значение OR, равное 1. Следовательно, возвращаем 1.

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

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64


Вам дан бинарный массив possible длины n.
Алиса и Боб играют в игру, состоящую из n уровней. Некоторые уровни в игре невозможно пройти, в то время как другие всегда можно пройти. В частности, если possible[i] == 0, то i-й уровень невозможно пройти ни одному из игроков. Игрок получает 1 очко за прохождение уровня и теряет 1 очко, если уровень не пройден.
В начале игры Алиса будет проходить некоторые уровни в заданном порядке, начиная с 0-го уровня, после чего Боб будет играть оставшиеся уровни. Алисе нужно знать минимальное количество уровней, которые ей следует пройти, чтобы набрать больше очков, чем Боб, если оба игрока играют оптимально, чтобы максимально увеличить свои очки.
Верните минимальное количество уровней, которые Алиса должна пройти, чтобы набрать больше очков. Если это невозможно, верните -1.
Каждый игрок должен сыграть как минимум 1 уровень.

Пример 1:

Вход: possible = [1,0,1,0]
Выход: 1
Объяснение:
Рассмотрим все уровни, которые может пройти Алиса:

Если Алиса проходит только уровень 0, а Боб - остальные уровни, у Алисы 1 очко, а у Боба -1 + 1 - 1 = -1 очко.
Если Алиса проходит до уровня 1, а Боб - остальные уровни, у Алисы 1 - 1 = 0 очков, а у Боба 1 - 1 = 0 очков.
Если Алиса проходит до уровня 2, а Боб - остальные уровни, у Алисы 1 - 1 + 1 = 1 очко, а у Боба -1 очко.

Алиса должна пройти минимум 1 уровень, чтобы набрать больше очков.

Пример 2:

Вход: possible = [1,1,1,1,1]
Выход: 3
Объяснение:
Рассмотрим все уровни, которые может пройти Алиса:

Если Алиса проходит только уровень 0, а Боб - остальные уровни, у Алисы 1 очко, а у Боба 4 очка.
Если Алиса проходит до уровня 1, а Боб - остальные уровни, у Алисы 2 очка, а у Боба 3 очка.
Если Алиса проходит до уровня 2, а Боб - остальные уровни, у Алисы 3 очка, а у Боба 2 очка.
Если Алиса проходит до уровня 3, а Боб - остальные уровни, у Алисы 4 очка, а у Боба 1 очко.

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

Пример 3:

Вход: possible = [0,0]
Выход: -1
Объяснение:
Единственный возможный способ - каждому игроку сыграть по 1 уровню. Алиса проходит уровень 0 и теряет 1 очко. Боб проходит уровень 1 и теряет 1 очко. Так как у обоих игроков очки равны, Алиса не может набрать больше очков, чем Боб.

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

2 <= n == possible.length <= 10^5
possible[i] это либо 0, либо 1.

Вам дан бинарный массив длиной n.
Алиса и Боб играют в игру, которая состоит из n уровня. Некоторые уровни невозможно пройти, а другие всегда можно успешно пройти. В частности, если possible[i] == 0, то i-й уровень невозможно пройти для обоих игроков. Игрок набирает 1 балл при очистке уровня и теряет 1 балл, если игрок не сможет его очистить.
В начале игры Алиса будет играть на некоторых уровнях в данном порядке, начиная с уровня 0^, после чего Боб будет играть для остальных уровней.
Алиса хочет знать минимальное количество уровней, которые она должна играть, чтобы получить больше очков, чем Боб, если оба игрока играют оптимально, чтобы максимизировать свои очки.
Вернуть минимальное количество уровней, которые Алиса должна играть, чтобы получить больше очков. Если это невозможно, вернуть -1.
Обратите внимание, что каждый игрок должен играть не менее 1 уровня.

Пример 1:

Вход: possible = [1,0,1,0]
Вывод: 1
Объяснение:
Давайте посмотрим на все уровни, на которые Алиса может поднять:

Если Алиса играет только на уровне 0, а Боб играет остальные уровни, у Алисы есть 1 балл, в то время как у Боба есть -1 + 1 -1 = -1 балл.
Если Алиса играет до уровня 1, а Боб играет остальные уровни, Алиса имеет 1 - 1 = 0 баллов, в то время как Боб имеет 1 - 1 = 0 баллов.
Если Алиса играет до уровня 2, а Боб играет остальные уровни, у Алисы 1 - 1 + 1 = 1 балл, в то время как у Боба -1 балл.

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

Пример 2:

Вход: возможно = [1,1,1,1,1]
Вывод: 3
Объяснение:
Давайте посмотрим на все уровни, на которые Алиса может поднять:

Если Алиса играет только на уровне 0, а Боб играет остальные уровни, у Алисы есть 1 балл, а у Боба - 4 очка.
Если Алиса играет до уровня 1, а Боб играет остальные уровни, Алиса имеет 2 очка, а Боб - 3 очка.
Если Алиса играет до уровня 2, а Боб играет остальные уровни, Алиса имеет 3 очка, а Боб - 2 очка.
Если Алиса играет до уровня 3, а Боб играет остальные уровни, у Алисы 4 балла, а у Боба 1 балл.

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

Пример 3:

Ввод:  possible = [0,0]
Вывод: -1
Объяснение:
Единственный возможный способ — это когда каждый игрок играет по одному уровню. Алиса играет уровень 0 и теряет 1 очко. Боб играет 1 и теряет 1 очко. Поскольку оба игрока имеют равные очки, Алиса не может набрать больше очков, чем Боб.

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

2 <= n == possible.length.<= 10^5
possible[i] — это либо 0, либо 1.


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

Пример 1:

Вход: nums = [1,2,3,4], k = 3
Выход: 4
Объяснение:
Существует 4 подпоследовательности в nums длиной 3: [1,2,3], [1,3,4], [1,2,4] и [2,3,4]. Сумма мощностей равна |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Пример 2:

Вход: nums = [2,2], k = 2
Выход: 0
Объяснение:
Единственная подпоследовательность в nums длиной 2 — это [2,2]. Сумма мощностей равна |2 - 2| = 0.

Пример 3:

Вход: nums = [4,3,-1], k = 2
Выход: 10
Объяснение:
Существует 3 подпоследовательности в nums длиной 2: [4,3], [4,-1] и [3,-1]. Сумма мощностей равна |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

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

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

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

Пример 1:

Входные данные: nums = [1,2,3,4], k = 3
Выходные данные: 4
Пояснение:
В nums есть 4 подпоследовательности, длина которых равна 3: [1,2,3], [1,3,4], [1,2,4], и [2,3,4]. Сумма степеней равна |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Пример 2:

Вход: nums = [2,2], k = 2
Выход: 0
Пояснение:
Единственная подпоследовательность в nums, имеющая длину 2 это [2,2]. Сумма степеней равна |2 - 2| = 0.

Пример 3:

Вход: nums = [4,3,-1], k = 2
Выход: 10
Пояснение:
В nums есть 3 подпоследовательности, имеющие длину 2: [4,3], [4,-1], и [3,-1]. Сумма степеней равна |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

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

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

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

Пример 1:

Ввод: Nums = [1,2,3,4], k = 3
Вывод: 4
Объяснение:
В nums есть 4 подпоследовательности, которые имеют длину 3: [1,2,3], [1,3,4], [1,2,4] и [2,3,4]. Сумма сил  | 2 - 3 | + | 3 - 4 | + | 2 - 1 | + | 3 - 4 | = 4.

Пример 2:

Ввод: nums = [2,2], k = 2
Вывод: 0
Объяснение:
Единственная подпоследовательность в nums длиной 2 — это [2,2]. Сумма мощностей равна |2 - 2| = 0.

Пример 3:

Ввод: nums = [4,3, -1], k = 2
Вывод: 10
Объяснение:
В nums есть 3 подпоследовательности, которые имеют длину 2: [4,3], [4, -1] и [3, -1]. Сумма сил | 4 - 3 | + | 4 - (-1) | + | 3 - (-1) | = 10.

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

2 <= n == nums.length <= 50
-10^8 <= nums [i] <= 10^8
2 <= k <= n


Дана строка s. Оценка строки определяется как сумма абсолютных разностей между ASCII значениями соседних символов.
Верните оценку строки s.

Пример 1:

Input: s = "hello"
Output: 13
Объяснение:
ASCII значения символов в s: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Таким образом, оценка s будет |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Пример 2:

Input: s = "zaz"
Output: 50
Объяснение:
ASCII значения символов в s: 'z' = 122, 'a' = 97. Таким образом, оценка s будет |122 - 97| + |97 - 122| = 25 + 25 = 50.

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

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

Дана строка s. Оценка строки определяется как сумма абсолютных разностей между ASCII значениями соседних символов.
Верните оценку строки s.

Пример 1:

Входные данные: s = "hello"
Выходные данные: 13
Объяснение:
ASCII значения символов в s: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Таким образом, оценка s будет |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Пример 2:

Входные данные: s = "zaz"
Выходные данныеt: 50
Объяснение:
ASCII значения символов в s: 'z' = 122, 'a' = 97. Таким образом, оценка s будет |122 - 97| + |97 - 122| = 25 + 25 = 50.

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

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

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

Пример 1:

Вход: s = "hello"
Выход: 13
Пояснение:
Значения ASCII символов в s: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Таким образом, оценка s будет |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Пример 2:

Вход: s = "zaz"
Выход: 50
Пояснение:
Значения ASCII символов в s: 'z' = 122, 'a' = 97. Таким образом, оценка s будет |122 - 97| + |97 - 122| = 25 + 25 = 50.

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

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


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

Пример 1:

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

subarray [1,4,3,3,2] с наибольшим элементом равным 1. Первый элемент равен 1, а последний элемент также равен 1.
subarray [1,4,3,3,2] с наибольшим элементом равным 4. Первый элемент равен 4, а последний элемент также равен 4.
subarray [1,4,3,3,2] с наибольшим элементом равным 3. Первый элемент равен 3, а последний элемент также равен 3.
subarray [1,4,3,3,2] с наибольшим элементом равным 3. Первый элемент равен 3, а последний элемент также равен 3.
subarray [1,4,3,3,2] с наибольшим элементом равным 2. Первый элемент равен 2, а последний элемент также 2.
subarray [1,4,3,3,2], с наибольшим элементом равным 3. Первый и последний элементы равны 3.

Следовательно, мы возвращаем 6.

Пример 2:

Вход: nums = [3,3,3]
Выход: 6
Объяснение:
Имеется 6 подмассивов, у которых первый и последний элементы равны наибольшему элементу подмассива:

subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент 3, а последний элемент также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент 3, а последний элемент также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент 3, а последний элемент также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент 3, а последний элемент также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент 3, а последний элемент также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент — 3, а последний элемент — также 3.
subarray [3,3,3] с наибольшим элементом равным 3. Первый элемент — 3, а последний элемент — также 3.

Следовательно, мы возвращаем 6.

Пример 3:

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

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

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

Вам дан массив положительных целых чисел nums.
Верните количество подмассивов nums, в которых первый и последний элементы подмассива равны наибольшему элементу в подмассиве.

Пример 1:

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

подмассив [1,4,3,3,2], с наибольшим элементом 1. Первый элемент 1 и последний элемент тоже 1.
подмассив [1,4,3,3,2], с наибольшим элементом 4. Первый элемент 4 и последний элемент тоже 4.
подмассив [1,4,3,3,2], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [1,4,3,3,2], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [1,4,3,3,2], с наибольшим элементом 2. Первый элемент 2 и последний элемент тоже 2.
подмассив [1,4,3,3,2], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.

Таким образом, выводим 6.

Пример 2:

Ввод: nums = [3,3,3]
Вывод: 6
Объяснение:
Существует 6 подмассивов, в которых первый и последний элементы равны наибольшему элементу подмассива:

подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.
подмассив [3,3,3], с наибольшим элементом 3. Первый элемент 3 и последний элемент тоже 3.

Таким образом, выводим 6.

Пример 3:

Ввод: nums = [1]
Вывод: 1
Объяснение:
Существует один подмассив nums, который равен [1], с наибольшим элементом 1. Первый элемент 1 и последний элемент тоже 1.
Таким образом, выводим 1.

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

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

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

Пример 1:

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

подмассив [1,4,3,3,2], с самым большим элементом 1. Первый элемент — 1, и последний элемент — тоже 1.
подмассив [1,4,3,3,2], с самым большим элементом 4. Первый элемент — 4, и последний элемент — тоже 4.
подмассив [1,4,3,3,2], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [1,4,3,3,2], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [1,4,3,3,2] с самым большим элементом 2. Первый элемент — 2, и последний элемент — тоже 2.
подмассив [1,4,3,3,2], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.

Следовательно, мы возвращаем 6.

Пример 2:

Входные данные: nums = [3,3,3]
Выход: 6
Объяснение:
Существует 6 подмассивов, в которых первый и последний элементы равны наибольшему элементу подмассива:

подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.
подмассив [3,3,3], с его самым большим элементом 3. Первый элемент — 3, и последний элемент — тоже 3.

Следовательно, мы возвращаем 6.

Пример 3:

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

Ограничения целостности:

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


Вам дана строка word. Буква называется особенной, если она присутствует как в нижнем, так и в верхнем регистре в word.
Верните количество особенных букв в word.

Пример 1:

Ввод: word = "aaAbcBC"
Вывод: 3
Пояснение: Особенные символы в word — 'a', 'b' и 'c'.

Пример 2:

Ввод: word = "abc"
Вывод: 0
Пояснение: Ни один символ в word не присутствует в верхнем регистре.

Пример 3:

Ввод: word = "abBCab"
Вывод: 1
Пояснение: Единственный особенный символ в word — 'b'.

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

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

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

Пример 1:

Вход: word = "aaAbcBC"
Выход: 3
Пояснение:
Специальные символы в word — это 'a', 'b' и 'c'.

Пример 2:

Вход: word = "abc"
Выход: 0
Пояснение:
Ни один символ в word не встречается в верхнем регистре.

Пример 3:

Вход: word = "abBCab"
Выход: 1
Пояснение:
Единственный специальный символ в word — это 'b'.

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

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

Вам дана строка word. Буква называется особенной, если она присутствует как в нижнем, так и в верхнем регистре в word.
Верните количество особенных букв в word.

Пример 1:

Пример 1:

Ввод: word = "aaAbcBC"
Вывод: 3
Пояснение:
Особенные символы в word — 'a', 'b' и 'c'.

Пример 2:

Ввод: word = "abc"
Вывод: 0
Пояснение:
Ни один символ в word не присутствует в верхнем регистре.

Пример 3:

Ввод: word = "abBCab"
Вывод: 1
Пояснение:
Единственный особенный символ в word — 'b'.

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

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