Даны два положительных целых числа low и high.
Целое число x, состоящее из 2 * n цифр, является симметричным, если сумма первых n цифр x равна сумме последних n цифр x. Числа с нечетным количеством цифр никогда не бывают симметричными.
Верните количество симметричных целых чисел в диапазоне [low, high].

Пример 1:

Ввод: low = 1, high = 100
Вывод: 9
Объяснение: Существует 9 симметричных целых чисел между 1 и 100: 11, 22, 33, 44, 55, 66, 77, 88 и 99.

Пример 2:

Ввод: low = 1200, high = 1230
Вывод: 4
Объяснение: Существует 4 симметричных целых числа между 1200 и 1230: 1203, 1212, 1221 и 1230.

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

1 <= low <= high <= 10^4

Вам даны два положительных целых числа low и high.
Целое число x, состоящее из 2 * n цифр, является симметричным, если сумма первых n цифр x равна сумме последних n цифр x. Числа с нечетным количеством цифр никогда не являются симметричными.
Верните количество симметричных целых чисел в диапазоне [low, high].

Пример 1:

Вход: low = 1, high = 100
Выход: 9
Пояснение: есть 9 симметричных целых чисел от 1 до 100: 11, 22, 33, 44, 55, 66, 77, 88 и 99.

Пример 2:

Вход: low = 1200, high = 1230
Выход: 4
Пояснение: есть 4 симметричных целых числа от 1200 до 1230: 1203, 1212, 1221 и 1230.

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

1 <= low <= high <= 10^4


У вас есть две строки s1 и s2, обе длиной 4, состоящие из строчных английских букв.
Вы можете применять следующую операцию на любой из двух строк любое количество раз:

Выберите любые два индекса i и j таким образом, чтобы j - i = 2, затем поменяйте местами два символа в строке на этих индексах.

Верните true, если вы можете сделать строки s1 и s2 равными, и false в противном случае.

Пример 1:

Ввод: s1 = "abcd", s2 = "cdab"
Вывод: true
Объяснение: Мы можем проделать следующие операции на s1:
- Выберите индексы i = 0, j = 2. Полученная строка s1 = "cbad".
- Выберите индексы i = 1, j = 3. Полученная строка s1 = "cdab" = s2.

Пример 2:

Ввод: s1 = "abcd", s2 = "dacb"
Вывод: false
Объяснение: Невозможно сделать две строки равными.

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

s1.length == s2.length == 4
s1 и s2 состоят только из строчных английских букв.

Вам даны две строки s1 и s2 длиной 4, состоящие из строчных Английских букв.
Вы можете применить следующую операцию к любой из двух строк любое количество раз:

Выберите любые два индекса i и j такие, что j - i = 2, затем поменяйте местами два символа этих индексов в строке.

Возвращайте true, если строки s1 и s2 можно сделать равными, и false в противном случае.

Пример 1:

Ввод: s1 = "abcd", s2 = "cdab"
Вывод: true
Пояснение: Мы можем выполнить следующие операции над s1:
- Выберите индексы i = 0, j = 2. Получившаяся строка s1 = "cbad".
- Выберите индексы i = 1, j = 3. Полученная строка: s1 = "cdab" = s2.

Пример 2:

Ввод: s1 = "abcd", s2 = "dacb"
Вывод: false
Объяснение: Невозможно сделать две строки равными.

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

s1.length == s2.length == 4
s1 и s2 состоят только из строчных Английских букв.

Вам дают две строки S1 и S2, оба длины 4, состоящие из нижних английских букв.
Вы можете применить следующую операцию на любой из двух строк в любое количество раз:

Выберите любые два индекса i и j, так что j - i = 2, затем поменяйте два символа в этих индексах в строке.

Верните True, если вы можете сделать строки S1 и S2 равными, и в противном случае неверно.

Пример 1:

Ввод: s1 = "abcd", s2 = "cdab"
Вывод: True
Объяснение: Мы можем сделать следующие операции на S1:
- Выберите индексы i = 0, j = 2. Полученная строка s1 = "cbad".
- Выберите индексы i = 1, j = 3. Полученная строка составляет s1 = "cdab" = s2.

Пример 2:

Ввод:s1 = "abcd", s2 = "dacb"
Вывод:false
Объяснение: Невозможно сделать две строки равными.

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

s1.length == s2.length == 4
s1 и s2 состоят только из строчных английских букв.


Вам дан целочисленный массив nums с индексом 0 и целое число x.
Найдите минимальную абсолютную разницу между двумя элементами массива, которые находятся на расстоянии не менее x индексов друг от друга.
Другими словами, найдите два индекса i и j, такие что abs(i - j) >= x и abs(nums[i] - nums[j]) минимизируются.
Верните целое число, обозначающее минимальную абсолютную разницу между двумя элементами, которые находятся на расстоянии не менее x индексов друг от друга.

Пример 1:

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

Пример 2:

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

Пример 3:

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

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

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

Вам дается 0- индексированный целочисленный массив и целое число x.
Найдите минимальную абсолютную разницу между двумя элементами в массиве, которые отличаются друг от друга по крайней мере x индексами.
Другими словами, найти два индекса i и j таким образом, чтобы abs(i - j) >= x и абс(nums[i] - nums[j]) минимальны.
Возвращает целое число, обозначающее минимальную абсолютную разницу между элементами, различающимися по крайней мере на x индексов.

Пример 1:

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

Пример 2:

Ввод: nums = [5,3,2,10,15], x = 1
Выход: 1
Объяснение: мы можем выбрать nums[1] = 3 и nums[2] = 2.
Они отличаются друг от друга по крайней мере на 1 индекс, а их абсолютная разница составляет минимум 1.
Можно показать, что 1 является оптимальным ответом.

Пример 3:

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

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

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

Дан массив целых чисел nums с индексацией от 0 и целое число x.
Найдите минимальную абсолютную разницу между двумя элементами в массиве, которые находятся как минимум на x индексах друг от друга.
Другими словами, найдите два индекса i и j такие, что abs(i - j) >= x и abs(nums[i] - nums[j]) минимальна.
Верните целое число, обозначающее минимальную абсолютную разницу между двумя элементами, которые находятся как минимум на x индексах друг от друга.

Пример 1:

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

Пример 2:

Ввод: nums = [5,3,2,10,15], x = 1
Вывод: 1
Объяснение: Мы можем выбрать nums[1] = 3 и nums[2] = 2.
Они находятся как минимум на 1 индексе друг от друга, и их абсолютная разница минимальна, 1.
Можно показать, что 1 — оптимальный ответ.

Пример 3:

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

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

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


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

Количество четных цифр в числе равно количеству нечетных цифр.
Число делится на k.

Верните количество красивых целых чисел в диапазоне [low, high].

Пример 1:

Входные данные: low = 10, high = 20, k = 3
Выходные данные: 2
Объяснение: В заданном диапазоне есть 2 красивых целых числа: [12,18].
- 12 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
- 18 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
Кроме того, мы видим, что:
- 16 не красиво, потому что не делится на k = 3.
- 15 не красиво, потому что не содержит одинаковое количество четных и нечетных цифр.
Можно показать, что в данном диапазоне есть только 2 красивых целых числа.

Пример 2:

Вход: low = 1, high = 10, k = 1
Выход: 1
Объяснение: в данном диапазоне есть 1 красивое целое число: [10].
- 10 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 1.
Можно показать, что в данном диапазоне есть только 1 красивое целое число.

Пример 3:

Вход: low = 5, high = 5, k = 2
Выход: 0
Объяснение: в заданном диапазоне 0 красивых целых чисел.
- 5 не является красивым, потому что оно не делится на k = 2 и не содержит равных четных и нечетных цифр.

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

0 < low <= high <= 10^9
0 < k <= 20

Вам даны положительные целые числа - небольшое, большое и k.
Число является beautiful, если оно отвечает обоим следующим условиям:

Количество четных цифр в числе равно количеству нечетных цифр.
Число делится на k.

Верните количество целых чисел beautiful в диапазоне [небольшое, большое].

Пример 1:

Input: low = 10, high = 20, k = 3
Output: 2
Объяснение: В заданном диапазоне есть 2 целых числа beautiful: [12,18].
- 12 - beautiful, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
- 18 - beautiful, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
Кроме того, мы видим, что:
- 16 - не является beautiful, потому что не делится на k = 3.
- 15 - не является beautiful, потому что не содержит равного количества четных и нечетных цифр.
Можно показать, что в заданном диапазоне есть только 2 целых числа beautiful.

Пример 2:

Input: low = 1, high = 10, k = 1
Output: 1
Объяснение: В заданном диапазоне есть 1 целое число beautiful: [10].
- 10 - число beautiful, потому что оно содержит 1 нечетную цифру и 1 четную цифру и делится на k = 1.
Можно показать, что в заданном диапазоне есть только 1 целое число beautiful.

Пример 3:

Input: low = 5, high = 5, k = 2
Output: 0
Объяснение: В заданном диапазоне 0 целых чисел beautiful.
- 5 не является beautiful, потому что оно не делится на k = 2 и не содержит равных четных и нечетных цифр.

Constraints:

0 < low <= high <= 10^9
0 < k <= 20

Даны положительные целые числа low, high, и k.
Число является красивым, если оно удовлетворяет обоим следующим условиям:

Количество четных цифр в числе равно количеству нечетных цифр.
Число делится на k.

Верните количество красивых чисел в диапазоне [low, high].

Пример 1:

Input: low = 10, high = 20, k = 3
Output: 2
Пояснение: В указанном диапазоне есть 2 красивых числа: [12,18].
- 12 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
- 18 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 3.
Дополнительно видно, что:
- 16 не красиво, потому что не делится на k = 3.
- 15 не красиво, потому что не содержит равных количеств четных и нечетных цифр.
Можно показать, что в данном диапазоне есть только 2 красивых числа.

Пример 2:

Input: low = 1, high = 10, k = 1
Output: 1
Пояснение: В указанном диапазоне есть 1 красивое число: [10].
- 10 красиво, потому что содержит 1 нечетную цифру и 1 четную цифру, и делится на k = 1.
Можно показать, что в данном диапазоне есть только 1 красивое число.

Пример 3:

Input: low = 5, high = 5, k = 2
Output: 0
Пояснение: В указанном диапазоне нет красивых чисел.
- 5 не красиво, потому что не делится на k = 2 и не содержит равных четных и нечетных цифр.

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

0 < low <= high <= 10^9
0 < k <= 20


У вас есть две строки с индексами, начинающимися с 0, str1 и str2.
В одной операции вы выбираете набор индексов в str1, и для каждого индекса i из набора инкрементируете str1[i] до следующего символа циклически. То есть 'a' становится 'b', 'b' становится 'c' и так далее, а 'z' становится 'a'.
Верните true, если возможно сделать str2 подпоследовательностью str1, выполняя операцию не более одного раза, и false в противном случае.
Примечание: Подпоследовательность строки — это новая строка, сформированная из исходной строки путем удаления некоторых (возможно, ни одного) символов без нарушения относительных позиций оставшихся символов.

Пример 1:

Ввод: str1 = "abc", str2 = "ad"
Вывод: true
Объяснение: Выберите индекс 2 в str1.
Инкрементируйте str1[2], чтобы он стал 'd'.
Таким образом, str1 становится "abd", и str2 теперь является подпоследовательностью. Поэтому возвращается true.
Пример 2:

Ввод: str1 = "zc", str2 = "ad"
Вывод: true
Объяснение: Выберите индексы 0 и 1 в str1.
Инкрементируйте str1[0], чтобы он стал 'a'.
Инкрементируйте str1[1], чтобы он стал 'd'.
Таким образом, str1 становится "ad", и str2 теперь является подпоследовательностью. Поэтому возвращается true.
Пример 3:

Ввод: str1 = "ab", str2 = "d"
Вывод: false
Объяснение: В этом примере можно показать, что невозможно сделать str2 подпоследовательностью str1, используя операцию не более одного раза.
Поэтому возвращается false.

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

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

Вам даны две строки с индексом 0 str1 и str2.
В операции вы выбираете набор индексов в str1, и для каждого индекса i в наборе циклически увеличиваете str1[i] до следующего символа. То есть 'a' становится 'b', 'b' становится 'c' и т. д., а 'z' становится 'a'.
Возвращает true, если возможно сделать str2 подпоследовательностью str1, выполнив операцию не более одного раза, и false в противном случае.
Примечание: подпоследовательность строки это новая строка, которая образована из исходной строки путем удаления некоторых (возможно, ни одного) символов без нарушения относительного положения оставшихся символов.

Пример 1:

Входные данные: str1 = "abc", str2 = "ad"
Выходные данные: true
Объяснение: выберите индекс 2 в str1.
Увеличьте str1[2], чтобы получить 'd'.
Следовательно, str1 становится "abd", а str2 теперь является подпоследовательностью. Следовательно, возвращается true.
Пример 2:

Вход: str1 = "zc", str2 = "ad"
Выход: true
Пояснение: выберите индексы 0 и 1 в str1.
Увеличьте str1[0], чтобы получить "a".
Увеличьте str1[1], чтобы получить "d".
Поэтому str1 становится "ad", а str2 теперь является подпоследовательностью. Следовательно, возвращается true.
Пример 3:

Вход: str1 = "ab", str2 = "d"
Выход: false
Пояснение: в этом примере можно показать, что невозможно сделать str2 подпоследовательностью str1, используя операцию не более одного раза.
Поэтому возвращается false.

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

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

Вам дают две 0-индексированные строки str1 и str2.
В операции вы выбираете набор индексов в str1, и для каждого индекса I в наборе увеличиваете str1[i] до следующего символа циклически. Это 'a'  становится  'b', 'b' становится  'c'и так далее, а  'z' становится'a'.
Верните true, если можно сделать str2 подпоследовательностью str1, выполнив операцию не более одного раза, и false в противном случае.
Примечание. Подпоследовательность строки — это новая строка, которая образуется из исходной строки, удаляя некоторые (возможно, нет) символов, не нарушая относительные позиции оставшихся символов.

Пример 1:

Ввод: str1 = "abc", str2 = "ad"
Вывод: true
Объяснение: Выберите «Индекс 2» в Str1.
Увеличьте str1[2] до «d» .
Следовательно, str1 становится «abd», а str2 теперь является последующей. Следовательно, верно возвращается.
Пример 2:

Ввод: str1 = "zc", str2 = "ad"
Вывод: true
Объяснение: Выберите индексы 0 и 1 в str1.
Увеличьте str1[0] до 'a'.
Прибавить str1 [1], чтобы стать 'd'.
Следовательно, str1 становится "ad", а str2 теперь является последующей. Следовательно, верно возвращается.
Пример 3:

Ввод: str1 = "ab", str2 = "d"
Вывод: false
Объяснение: В этом примере можно показать, что невозможно сделать STR2 последующей использованием операции не более одного раза.
Поэтому возвращается false.

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

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


Дана строка moves длины n, состоящая только из символов 'L', 'R' и '_'. Эта строка представляет ваше движение по числовой прямой, начиная с точки 0.
На i-м шаге вы можете выбрать одно из следующих направлений:

двигаться влево, если moves[i] = 'L' или moves[i] = '_'
двигаться вправо, если moves[i] = 'R' или moves[i] = '_'

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

Пример 1:

Ввод: moves = "L_RL__R"
Вывод: 3
Объяснение: Самая дальняя точка, которую мы можем достичь от начала 0, это точка -3 через следующую последовательность движений "LLRLLLR".

Пример 2:

Ввод: moves = "_R__LL_"
Вывод: 5
Объяснение: Самая дальняя точка, которую мы можем достичь от начала 0, это точка -5 через следующую последовательность движений "LRLLLLL".

Пример 3:

Ввод: moves = "_______"
Вывод: 7
Объяснение: Самая дальняя точка, которую мы можем достичь от начала 0, это точка 7 через следующую последовательность движений "RRRRRRR".

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

1 <= moves.length == n <= 50
moves состоит только из символов 'L', 'R' и '_'.

Вам дана строка moves длины n, состоящая только из символов 'L', 'R' и '_'. Строка представляет ваше движение по числовой прямой, начинающееся с начала координат 0.
В i^th движении вы можете выбрать одно из следующих направлений:

двигаться влево, если moves[i] = 'L' или moves[i] = '_'
двигаться вправо, если moves[i] = 'R' или moves[i] = '_'

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

Пример 1:

Вход: moves = "L_RL__R"
Выход: 3
Объяснение: самая дальняя точка, до которой мы можем добраться из начала координат 0, это точка -3 с помощью следующей последовательности ходов "LLRLLLR".

Пример 2:

Вход: moves = "_R__LL_"
Выход: 5
Пояснение: Самая дальняя точка, которую мы можем достичь от начала координат 0, это точка -5 с помощью следующей последовательности ходов "LRLLLLL".

Пример 3:

Вход: moves = "_______"
Выход: 7
Пояснение: Самая дальняя точка, которую мы можем достичь от начала координат 0, это точка 7 с помощью следующей последовательности ходов "RRRRRRR".

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

1 <= moves.length == n <= 50
ходы состоят только из символов "L", "R" и "_".


Даны две строки s и t одинаковой длины n. Вы можете выполнять следующую операцию над строкой s:

Удалить суффикс длины l, где 0 < l < n, и добавить его в начало строки s.
	Например, если s = 'abcd', то в одной операции вы можете удалить суффикс 'cd' и добавить его в начало строки s, получая s = 'cdab'.

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

Пример 1:

Ввод: s = "abcd", t = "cdab", k = 2
Вывод: 2
Объяснение:
Первый способ:
В первой операции выберите суффикс с индекса = 3, получая s = "dabc".
Во второй операции выберите суффикс с индекса = 3, получая s = "cdab".

Второй способ:
В первой операции выберите суффикс с индекса = 1, получая s = "bcda".
Во второй операции выберите суффикс с индекса = 1, получая s = "cdab".

Пример 2:

Ввод: s = "ababab", t = "ababab", k = 1
Вывод: 2
Объяснение:
Первый способ:
Выберите суффикс с индекса = 2, получая s = "ababab".

Второй способ:
Выберите суффикс с индекса = 4, получая s = "ababab".

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

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

Вам даны две строки s и t одинаковой длины n. Вы можете выполнить следующую операцию со строкой s:

Удалите суффикс s длины l, где 0 < l < n, и добавьте его в начало s.
	Например, пусть s = 'abcd', тогда за одну операцию вы можете удалить суффикс 'cd' и добавить его перед s, получив s = 'cdab'.

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

Пример 1:

Ввод: s = "abcd", t = "cdab", k = 2
Вывод: 2
Объяснение:
Первый способ:
В первой операции выберите суффикс из index = 3, чтобы в результате получилось s = "dabc".
Во второй операции выберите суффикс из index = 3, чтобы в результате получилось s = "cdab".

Второй способ:
В первой операции выберите суффикс из index = 1, чтобы в результате получилось s = "bcda".
Во второй операции выберите суффикс из index = 1, чтобы в результате получилось s = "cdab".

Пример 2:

Ввод: s = "ababab", t = "ababab", k = 1
Вывод: 2
Объяснение:
Первый способ:
Выберите суффикс из index = 2, чтобы в результате получилось s = "ababab".

Второй способ:
Выберите суффикс из index = 4, чтобы в результате получилось s = "ababab".

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

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s и t состоят только из строчных букв Английского алфавита.

Вам даны две строки s и t одинаковой длины n. Вы можете выполнить следующую операцию над строкой s:

Удалить суффикс из s длины l, где 0 < l < n, и добавить его в начало s.
     Например, пусть s = 'abcd', тогда за одну операцию вы можете удалить суффикс 'cd' и добавить его перед s, сделав s = 'cdab'.

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

Пример 1:

Входные данные: s = "abcd", t = "cdab", k = 2
Выходные данные: 2
Объяснение:
Первый способ:
В первой операции выберите суффикс из индекса = 3, поэтому в результате s = "dabc".
Во второй операции выберите суффикс из индекса = 3, поэтому в результате s = "cdab".

Второй способ:
В первой операции выберите суффикс из индекса = 1, поэтому в результате s = "bcda".
Во второй операции выберите суффикс из индекса = 1, поэтому в результате s = "cdab".

Пример 2:

Входные данные: s = "ababab", t = "ababab", k = 1
Выходные данные: 2
Объяснение:
Первый способ:
Выберите суффикс из индекса = 2, поэтому в результате s = "ababab".

Второй способ:
Выберите суффикс из индекса = 4, поэтому в результате s = "ababab".

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

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


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

Выбрать любой элемент массива nums[i], где nums[i] > 1. Удалить nums[i] из массива. Добавить два вхождения nums[i] / 2 в конец nums.

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

Пример 1:

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

Пример 2:

Ввод: nums = [1,32,1,2], target = 12
Вывод: 2
Пояснение: В первой операции выбираем элемент nums[1]. Массив становится равным nums = [1,1,2,16,16]. Во второй операции выбираем элемент nums[3]. Массив становится равным nums = [1,1,2,16,8,8]. На этом этапе nums содержит подпоследовательность [1,1,2,8], которая в сумме дает 12. Можно доказать, что нет меньшего количества операций, которые приводят к подпоследовательности, которая в сумме дает 12.

Пример 3:

Ввод: nums = [1,32,1], target = 35
Вывод: -1
Пояснение: Можно доказать, что никакая последовательность операций не приводит к подпоследовательности, которая в сумме дает 35.

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

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums состоит только из неотрицательных степеней двойки.
1 <= target < 2^31

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

Выберите любой элемент массива nums[i] такой, что nums[i] > 1.
Удалите nums[i] из массива.
Добавьте два вхождения nums[i] / 2 в конец nums.

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

Пример 1:

Входные данные: nums = [1,2,8], target = 7
Выходные данные: 1
Пояснение: В первой операции мы выбираем элемент nums[2]. Массив становится равным nums = [1,2,4,4].
На этом этапе nums содержит подпоследовательность [1,2,4], которая в сумме дает 7.
Можно показать, что не существует более короткой последовательности операций, которая приводит к подпоследовательности, которая в сумме дает 7.

Пример 2:

Вход: nums = [1,32,1,2], target = 12
Выход: 2
Пояснение: в первой операции мы выбираем элемент nums[1]. Массив становится равным nums = [1,1,2,16,16].
Во второй операции мы выбираем элемент nums[3]. Массив становится равным nums = [1,1,2,16,8,8]
На этом этапе nums содержит подпоследовательность [1,1,2,8], которая в сумме дает 12.
Можно показать, что не существует более короткой последовательности операций, которая приводит к подпоследовательности, которая в сумме дает 12.
Пример 3:

Вход: nums = [1,32,1], target = 35
Выход: -1
Пояснение: можно показать, что ни одна последовательность операций не приводит к подпоследовательности, которая в сумме дает 35.

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

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums состоит только из неотрицательных степеней двойки.
1 <= target < 2^31

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

Выберите любой элемент массива nums[i], такой что nums[i] > 1. Удалите nums[i] из массива. Добавьте два вхождения nums[i] / 2 в конец nums.

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

Пример 1:

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

Пример 2:

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

Пример 3:

Ввод: nums = [1,32,1], target = 35
Вывод: -1
Объяснение: Можно показать, что никакая последовательность операций не приводит к подпоследовательности, сумма которой равна 35.

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

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums состоит только из неотрицательных степеней двойки.
1 <= target < 2^31


Дана 0-индексированная двумерная целочисленная матрица grid размером n * m. Мы определяем 0-индексированную 2D матрицу p размером n * m как произведение элементов матрицы grid, если выполняется следующее условие:

Каждый элемент p[i][j] рассчитывается как произведение всех элементов grid, за исключением элемента grid[i][j]. Это произведение затем берется по модулю 12345.

Верни матрицу произведений grid.

Пример 1:

Ввод: grid = [[1,2],[3,4]]
Вывод: [[24,12],[8,6]]
Пояснение: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Таким образом, ответ [[24,12],[8,6]].
Пример 2:

Ввод: grid = [[12345],[2],[1]]
Вывод: [[2],[0],[0]]
Пояснение: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Поэтому p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Поэтому p[0][2] = 0.
Таким образом, ответ [[2],[0],[0]].

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

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Дана 0-индексированная 2D матрица целых чисел grid размером n * m. Мы определяем 0-индексированную 2D матрицу p размером n * m как произведение элементов матрицы grid, если выполняется следующее условие:

Каждый элемент p[i][j] рассчитывается как произведение всех элементов в grid, за исключением элемента grid[i][j]. Это произведение затем берется по модулю 12345.

Верните матрицу произведений grid.

Пример 1:

Ввод: grid = [[1,2],[3,4]]
Вывод: [[24,12],[8,6]]
Объяснение: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Таким образом, ответ [[24,12],[8,6]].
Пример 2:

Ввод: grid = [[12345],[2],[1]]
Вывод: [[2],[0],[0]]
Объяснение: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Поэтому p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Поэтому p[0][2] = 0.
Таким образом, ответ [[2],[0],[0]].

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

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Учитывая 2D-целочисленную матрицу с индексом 0 размером n * m, мы определяем 2D-матрицу p с 0-индексом размера n * m как матрицу произведения сетки, если выполняется следующее условие:

Каждый элемент p[i][j] рассчитывается как произведение всех элементов в сетке, за исключением элемента сетка[i][j]. Затем это произведение вычисляется по модулю 12345.

Верните матрицу продуктов сетки.

Пример 1:

Ввод: сетка = [[1,2],[3,4]]
Вывод: [[24,12],[8,6]]
Пояснение: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Таким образом, ответ [[24,12],[8,6]].
Пример 2:

Ввод: сетка = [[12345],[2],[1]]
Вывод: [[2],[0],[0]]
Пояснение: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Поэтому p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Поэтому p[0][2] = 0.
Таким образом, ответ [[2],[0],[0]].

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

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


Вам дан целочисленный массив receiver с нулевой индексацией длины n и целое число k.
Существует n игроков с уникальными идентификаторами в диапазоне [0, n - 1], которые будут играть в игру с передачей мяча. При этом receiver[i] — это id игрока, который получает передачи от игрока с id i. Игроки могут передавать мяч самим себе, то есть возможно, что receiver[i] равен i.
Вам нужно выбрать одного из n игроков в качестве начального игрока для игры, и мяч будет передан ровно k раз, начиная с выбранного игрока.
Для выбранного начального игрока с id x, определим функцию f(x), которая обозначает сумму x и id всех игроков, которые получают мяч в процессе k передач, включая повторения. Другими словами, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Ваша задача — выбрать начального игрока с id x, чтобы максимизировать значение f(x).
Верните целое число, обозначающее максимальное значение функции.
Примечание: receiver может содержать дублирующиеся значения.

Пример 1:

Номер передачи
ID отправителя
ID получателя
x + ID получателей

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Вход: receiver = [2,0,1], k = 4
Выход: 6
Объяснение: Таблица выше показывает симуляцию игры, начиная с игрока с id x = 2.
Из таблицы видно, что f(2) равно 6.
Можно показать, что 6 — это максимальное достижимое значение функции.
Таким образом, ответ 6.

Пример 2:

Номер передачи
ID отправителя
ID получателя
x + ID получателей

4

1
4
3
7

2
3
2
9

3
2
1
10

Вход: receiver = [1,1,1,2,3], k = 3
Выход: 10
Объяснение: Таблица выше показывает симуляцию игры, начиная с игрока с id x = 4.
Из таблицы видно, что f(4) равно 10.
Можно показать, что 10 — это максимальное достижимое значение функции.
Таким образом, ответ 10.

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

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Вам дан целочисленный массив с индексом 0 длиной n и целое число k.
Есть n игроков с уникальным идентификатором в диапазоне [0, n - 1], которые будут играть в пасовую игру, а receiver[i] — это идентификатор игрока, который получает пас от игрока с идентификатором i. Игроки могут передавать сами себе, т. е. receive[i] может быть равен i.
Вы должны выбрать одного из n игроков в качестве стартового игрока для игры, и мяч будет передан ровно k раз, начиная с выбранного игрока.
Для выбранного стартового игрока с идентификатором x мы определяем функцию f(x), которая обозначает сумму x и идентификаторов всех игроков, которые получают мяч во время k передач, включая повторения. Другими словами, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receive^(k)[x].
Ваша задача — выбрать стартового игрока с идентификатором x, который максимизирует значение f(x).
Верните целое число, обозначающее максимальное значение функции.
Примечание: получатель может содержать дубликаты.

Пример 1:

Номер прохода
ID отправителя
ID получателя
x + ID получателей

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Вход: receiver = [2,0,1], k = 4
Выход: 6
Пояснение: в таблице выше показана симуляция игры, начинающейся с игрока с идентификатором x = 2.
Из таблицы f(2) равно 6.
Можно показать, что 6 — это максимально достижимое значение функции.
Следовательно, выход равен 6.

Пример 2:

Номер прохода
ID отправителя
ID получателя
x + ID получателей

4

1
4
3
7

2
3
2
9

3
2
1
10

Вход: receiver = [1,1,1,2,3], k = 3
Выход: 10
Пояснение: В таблице выше показана симуляция игры, начинающейся с игрока с идентификатором x = 4.
Из таблицы f(4) равно 10.
Можно показать, что 10 — максимально достижимое значение функции.
Следовательно, выход равен 10.

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

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10


Вам даны два двоичных строки с нулевой индексацией s1 и s2, обе длиной n, и положительное целое число x.
Вы можете выполнять любое из следующих операций на строке s1 любое количество раз:

Выберите два индекса i и j и переверните оба s1[i] и s1[j]. Стоимость этой операции - x.
Выберите индекс i так, чтобы i < n - 1, и переверните оба s1[i] и s1[i + 1]. Стоимость этой операции - 1.

Верните минимальную стоимость, необходимую для того, чтобы строки s1 и s2 стали равными, или верните -1, если это невозможно.
Заметьте, что переворачивание символа означает изменение его с 0 на 1 или наоборот.

Пример 1:

Ввод: s1 = "1100011000", s2 = "0101001010", x = 2
Вывод: 4
Объяснение: Мы можем выполнить следующие операции:
- Выберите i = 3 и примените вторую операцию. Полученная строка будет s1 = "1101111000".
- Выберите i = 4 и примените вторую операцию. Полученная строка будет s1 = "1101001000".
- Выберите i = 0 и j = 8 и примените первую операцию. Полученная строка будет s1 = "0101001010" = s2.
Общая стоимость - 1 + 1 + 2 = 4. Можно показать, что это минимально возможная стоимость.

Пример 2:

Ввод: s1 = "10110", s2 = "00011", x = 4
Вывод: -1
Объяснение: Невозможно сделать две строки равными.

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

n == s1.length == s2.length
1 <= n, x <= 500
s1 и s2 состоят только из символов '0' и '1'.

Вам даны два двоичных строки с нулевой индексацией s1 и s2, обе длиной n, и положительное целое число x. Вы можете выполнять любое из следующих операций на строке s1 любое количество раз:

Выберите два индекса i и j и переверните оба s1[i] и s1[j]. Стоимость этой операции - x.
Выберите индекс i так, чтобы i < n - 1, и переверните оба s1[i] и s1[i + 1]. Стоимость этой операции - 1.

Верните минимальную стоимость, необходимую для того, чтобы строки s1 и s2 стали равными, или верните -1, если это невозможно.
Заметьте, что переворачивание символа означает изменение его с 0 на 1 или наоборот.

Пример 1:

Input: s1 = "1100011000", s2 = "0101001010", x = 2
Output: 4
Explanation: Мы можем выполнить следующие операции:
- Выберите i = 3 и примените вторую операцию. Полученная строка будет s1 = "1101111000".
- Выберите i = 4 и примените вторую операцию. Полученная строка будет s1 = "1101001000".
- Выберите i = 0 и j = 8 и примените первую операцию. Полученная строка будет s1 = "0101001010" = s2.
Общая стоимость - 1 + 1 + 2 = 4. Можно показать, что это минимально возможная стоимость.

Пример 2:

Input: s1 = "10110", s2 = "00011", x = 4
Output: -1
Explanation: Невозможно сделать две строки равными.

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

n == s1.length == s2.length
1 <= n, x <= 500
s1 и s2 состоят только из символов '0' и '1'.


Вам дан 2D-массив чисел с индексом 0, представляющий координаты автомобилей, припаркованных на числовой линии. Для любого индекса i, nums[i] = [start_i, end_i], где start_i — начальная точка i^-го автомобиля, а end_i — конечная точка i^-го автомобиля.
Выведите количество целых точек на линии, которые покрыты любой частью автомобиля.

Пример 1:

Input: nums = [[3,6],[1,5],[4,7]]
Output: 7
Объяснение: Все точки от 1 до 7 пересекают по крайней мере один автомобиль, поэтому ответ будет 7.

Пример 2:

Input: nums = [[1,3],[5,8]]
Output: 7
Объяснение: Точки, пересекающие хотя бы одну машину: 1, 2, 3, 5, 6, 7, 8. Всего их 7, следовательно, ответ будет 7.

Constraints:

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

Вам дан 2D-целочисленный массив nums с индексом 0, представляющий координаты автомобилей, припаркованных на числовой прямой. Для любого индекса i, nums[i] = [start_i, end_i], где start_i — начальная точка i^th автомобиля, а end_i — конечная точка i^th автомобиля.
Вернуть количество целых точек на прямой, покрытых любой частью автомобиля.

Пример 1:

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

Пример 2:

Вход: nums = [[1,3],[5,8]]
Выход: 7
Пояснение: Точки, пересекающие хотя бы один автомобиль, — это 1, 2, 3, 5, 6, 7, 8. Всего точек 7, поэтому ответ будет 7.

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

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

Вам дан 2D целочисленный массив чисел с 0-индексом, представляющий координаты парковочных автомобилей на числовой прямой. Для любого индекса i nums[i] = [start_i, end_i], где start_i это начальная точка i^го автомобиля, а end_i это конечная точка i^го автомобиля.
Верните количество целочисленных точек на линии, покрытых любой частью автомобиля.

Пример 1:

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

Пример 2:

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

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

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


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

Пример 1:

Ввод: nums = [3,1,5,4,2], k = 2
Вывод: 4
Объяснение: После 4 операций мы собираем элементы 2, 4, 5 и 1 в этом порядке. Наша коллекция содержит элементы 1 и 2. Следовательно, ответ — 4.

Пример 2:

Ввод: nums = [3,1,5,4,2], k = 5
Вывод: 5
Объяснение: После 5 операций мы собираем элементы 2, 4, 5, 1 и 3 в этом порядке. Наша коллекция содержит элементы от 1 до 5. Следовательно, ответ — 5.

Пример 3:

Ввод: nums = [3,2,5,3,1], k = 3
Вывод: 4
Объяснение: После 4 операций мы собираем элементы 1, 3, 5 и 2 в этом порядке. Наша коллекция содержит элементы от 1 до 3. Следовательно, ответ — 4.

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

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
Гарантировано, что вы сможете собрать элементы 1, 2, ..., k.

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

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

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
Входные данные генерируются таким образом, что вы можете собирать элементы 1, 2, ..., k.


Дан массив nums длины n с 0-индексацией, содержащий различные положительные целые числа. Верните минимальное количество сдвигов вправо, необходимых для сортировки nums, и -1, если это невозможно.
Сдвиг вправо определяется как перемещение элемента с индекса i на индекс (i + 1) % n для всех индексов.

Пример 1:

Ввод: nums = [3,4,5,1,2]
Вывод: 2
Объяснение:
После первого сдвига вправо, nums = [2,3,4,5,1].
После второго сдвига вправо, nums = [1,2,3,4,5].
Теперь nums отсортирован; следовательно, ответ - 2.

Пример 2:

Ввод: nums = [1,3,5]
Вывод: 0
Объяснение: nums уже отсортирован, следовательно, ответ - 0.
Пример 3:

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

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

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums содержит различные целые числа.


Вам дана строка num с индексом 0, представляющая неотрицательное целое число.
За одну операцию вы можете выбрать любую цифру из num и удалить её. Обратите внимание: если удалить все цифры из num, num станет 0.
Возвращаем минимальное количество операций, необходимых, чтобы сделать num специальным.
Целое число x считается специальным, если оно делится на 25.

Пример 1:

Вход: num = "2245047"
Выход: 2
Объяснение: Удаляем цифры num[5] и num[6]. Полученное число "22450" является специальным, так как делится на 25.
Можно показать, что 2 — это минимальное количество операций, необходимых для получения специального числа.

Пример 2:

Вход: num = "2908305"
Выход: 3
Объяснение: Удаляем цифры num[3], num[4] и num[6]. Полученное число "2900" является специальным, так как делится на 25.
Можно показать, что 3 — это минимальное количество операций, необходимых для получения специального числа.

Пример 3:

Вход: num = "10"
Выход: 1
Объяснение: Удаляем цифру num[0]. Полученное число "0" является специальным, так как делится на 25.
Можно показать, что 1 — это минимальное количество операций, необходимых для получения специального числа.

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

1 <= num.length <= 100
num состоит только из цифр от '0' до '9'.
num не содержит никаких ведущих нулей.

Вам дана строка num с индексом 0, представляющая неотрицательное целое число.
За одну операцию вы можете выбрать любую цифру num и удалить ее. Обратите внимание, что если удалить все цифры num, num станет 0.
Верните минимальное количество операций, необходимых для того, чтобы сделать num специальным.
Целое число x считается специальным, если оно делится на 25.

Пример 1:

Вход: num = "2245047"
Выход: 2
Пояснение: Удалите цифры num[5] и num[6]. Полученное число — "22450", которое является специальным, так как делится на 25.
Можно показать, что 2 — минимальное количество операций, необходимых для получения специального числа.
Пример 2:

Вход: num = "2908305"
Выход: 3
Пояснение: Удалить цифры num[3], num[4] и num[6]. Полученное число — "2900", которое является особым, так как делится на 25.
Можно показать, что 3 — это минимальное количество операций, необходимых для получения особого числа.
Пример 3:

Вход: num = "10"
Выход: 1
Пояснение: Удалить цифру num[0]. Полученное число — "0", которое является особым, так как делится на 25.
Можно показать, что 1 — это минимальное количество операций, необходимых для получения особого числа.

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

1 <= num.length <= 100
num состоит только из цифр от '0' до '9'.
num не содержит начальных нулей.

Вам дана строка num с индексом 0, представляющая неотрицательное целое число.
За одну операцию вы можете выбрать любую цифру num и удалить ее. Обратите внимание, что если удалить все цифры num, num станет 0.
Верните минимальное количество операций, необходимых для того, чтобы сделать num специальным.
Целое число x считается специальным, если оно делится на 25.

Пример 1:

Вход: num = "2245047"
Выход: 2
Пояснение: Удалите цифры num[5] и num[6]. Полученное число "22450", которое является специальным, так как делится на 25.
Можно показать, что 2 это минимальное количество операций, необходимых для получения специального числа.
Пример 2:

Вход: num = "2908305"
Выход: 3
Пояснение: Удалить цифры num[3], num[4] и num[6]. Полученное число "2900", которое является особым, так как делится на 25.
Можно показать, что 3 это минимальное количество операций, необходимых для получения особого числа.
Пример 3:

Вход: num = "10"
Выход: 1
Пояснение: Удалить цифру num[0]. Полученное число "0", которое является особым, так как делится на 25.
Можно показать, что 1 это минимальное количество операций, необходимых для получения особого числа.

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

1 <= num.length <= 100
num состоит только из цифр от '0' до '9'.
num не содержит начальных нулей.


Дан 1-индексированный массив nums из n целых чисел.

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

Для подмножества множества индексов {1, 2, ..., n}, представленного как {i_1, i_2, ..., i_k}, определяем сумму его элементов как: nums[i_1] + nums[i_2] + ... + nums[i_k].

Выведи максимальную сумму элементов полного подмножества множества индексов {1, 2, ..., n}.

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

Пример 1:

Ввод: nums = [8,7,3,5,7,2,4,9]
Вывод: 16
Пояснение: Помимо подмножеств, состоящих из одного индекса, есть два других полных подмножества индексов: {1,4} и {2,8}.
Сумма элементов, соответствующих индексам 1 и 4, равна nums[1] + nums[4] = 8 + 5 = 13.
Сумма элементов, соответствующих индексам 2 и 8, равна nums[2] + nums[8] = 7 + 9 = 16.
Таким образом, максимальная сумма элементов полного подмножества индексов равна 16.

Пример 2:

Ввод: nums = [5,10,3,10,1,13,7,9,4]
Вывод: 19
Пояснение: Помимо подмножеств, состоящих из одного индекса, есть четыре других полных подмножества индексов: {1,4}, {1,9}, {2,8}, {4,9} и {1,4,9}.

Сумма элементов, соответствующих индексам 1 и 4, равна nums[1] + nums[4] = 5 + 10 = 15.
Сумма элементов, соответствующих индексам 1 и 9, равна nums[1] + nums[9] = 5 + 4 = 9.
Сумма элементов, соответствующих индексам 2 и 8, равна nums[2] + nums[8] = 10 + 9 = 19.
Сумма элементов, соответствующих индексам 4 и 9, равна nums[4] + nums[9] = 10 + 4 = 14.
Сумма элементов, соответствующих индексам 1, 4 и 9, равна nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Таким образом, максимальная сумма элементов полного подмножества индексов равна 19.

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

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

Вам дан массив из n целых чисел с 1 индексом.
Набор чисел является полным, если произведение каждой пары его элементов представляет собой полный квадрат.
Для подмножества набора индексов {1, 2, ..., n} представленного как {i_1, i_2, ..., i_k}, мы определяем его сумму элементов как: nums[i_1] + nums[i_2] + ... + nums[i_k].
Возвращает максимальную сумму элементов полного подмножества набора индексов {1, 2,..., n}.
Совершенный квадрат это число, которое можно выразить как произведение целого числа само на себя.

Пример 1:

Ввод: nums = [8,7,3,5,7,2,4,9]
Вывод: 16
Пояснение: Помимо подмножеств, состоящих из одного индекса, существуют ещё два полных подмножества индексов: {1,4} и {2,8}.
Сумма элементов, соответствующих индексам 1 и 4, равна nums[1] + nums[4] = 8 + 5 = 13.
Сумма элементов, соответствующих индексам 2 и 8, равна nums[2] + nums[8] = 7 + 9 = 16.
Следовательно, максимальная сумма элементов полного подмножества индексов равна 16.

Пример 2:

Ввод: nums = [5,10,3,10,1,13,7,9,4]
Вывод: 19
Пояснение: Помимо подмножеств, состоящих из одного индекса, существует еще четыре полных подмножества индексов: {1,4}, {1,9}, {2,8}, {4,9}, and {1,4,9}.
Сумма элементов, соответствующих индексам 1 и 4 равна nums[1] + nums[4] = 5 + 10 = 15.
Сумма элементов, соответствующих индексам 1 и 9 равна nums[1] + nums[9] = 5 + 4 = 9.
Сумма элементов, соответствующих индексам 2 и 8 равна nums[2] + nums[8] = 10 + 9 = 19.
Сумма элементов, соответствующих индексам 4 и 9 равна nums[4] + nums[9] = 10 + 4 = 14.
Сумма элементов, соответствующих индексам 1, 4 и 9 равна nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Следовательно, максимальная сумма элементов полного подмножества индексов равна 19.

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

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

Вам дан 1-индексированный массив nums из n целых чисел.
Множество чисел является полным, если произведение каждой пары его элементов является полным квадратом.
Для подмножества набора индексов {1, 2, ..., n}, представленного как {i_1, i_2, ..., i_k}, мы определяем его сумму элементов как: nums[i_1] + nums[i_2] + ... + nums[i_k].
Возвращает максимальную сумму элементов полного подмножества набора индексов {1, 2, ..., n}.
Полный квадрат — это число, которое может быть выражено как произведение целого числа на само себя.

Пример 1:

Вход: nums = [8,7,3,5,7,2,4,9]
Выход: 16
Объяснение: Помимо подмножеств, состоящих из одного индекса, есть два других полных подмножества индексов: {1,4} и {2,8}.
Сумма элементов, соответствующих индексам 1 и 4, равна nums[1] + nums[4] = 8 + 5 = 13.
Сумма элементов, соответствующих индексам 2 и 8, равна nums[2] + nums[8] = 7 + 9 = 16.
Следовательно, максимальная сумма элементов полного подмножества индексов равна 16.

Пример 2:

Вход: nums = [5,10,3,10,1,13,7,9,4]
Выход: 19
Пояснение: Помимо подмножеств, состоящих из одного индекса, есть еще четыре полных подмножества индексов: {1,4}, {1,9}, {2,8}, {4,9} и {1,4,9}.
Сумма элементов, соответствующих индексам 1 и 4, равна nums[1] + nums[4] = 5 + 10 = 15.
Сумма элементов, соответствующих индексам 1 и 9, равна nums[1] + nums[9] = 5 + 4 = 9.
Сумма элементов, соответствующих индексам 2 и 8, равна nums[2] + nums[8] = 10 + 9 = 19.
Сумма элементов, соответствующих индексам 4 и 9, равна nums[4] + nums[9] = 10 + 4 = 14.
Сумма элементов, соответствующих индексам 1, 4 и 9, равна nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Следовательно, максимальная сумма элементов полного подмножества индексов равна 19.

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

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


Дана двоичная строка s, содержащая как минимум одну '1'.
Вам нужно переставить биты таким образом, чтобы получившееся двоичное число стало максимальным нечетным двоичным числом, которое можно создать из этой комбинации.
Верните строку, представляющую максимальное нечетное двоичное число, которое можно создать из данной комбинации.
Обратите внимание, что результирующая строка может иметь ведущие нули.

Пример 1:

Ввод: s = "010"
Вывод: "001"
Объяснение: Поскольку имеется только одна '1', она должна быть на последней позиции. Так что ответ "001".

Пример 2:

Ввод: s = "0101"
Вывод: "1001"
Объяснение: Одна из '1' должна быть на последней позиции. Максимальное число, которое можно сделать с оставшимися цифрами, это "100". Так что ответ "1001".

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

1 <= s.length <= 100
s состоит только из '0' и '1'.
s содержит как минимум одну '1'.

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

Пример 1:

Ввод: s = "010"
Вывод: "001"
Пояснение: Поскольку существует только одна цифра '1', она должна находиться в последней позиции. Итак, ответ "001".

Пример 2:

Ввод: s = "0101"
Вывод: "1001"
Пояснение: Одна из  '1' должна находиться в последней позиции. Максимальное число, которое можно составить из оставшихся цифр,"100".
Итак, ответ: "1001".

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

1 <= s.length <= 100
s состоит только из '0' и '1'.
s содержит хотя бы одну '1'.


Вам дан массив nums, состоящий из целых неотрицательных чисел.
Мы определяем оценку подмассива nums[l..r] такого, что l <= r as nums[l] AND nums[l + 1] AND ... AND nums[r] where AND это побитовая операция AND.
Рассмотрите возможность разделения массива на один или несколько подмассивов так, чтобы были выполнены следующие условия:

Каждый элемент массива принадлежит ровно одному подмассиву.
Сумма баллов подмассивов является минимально возможной.

Верните максимальное количество подмассивов в разбиении, которое удовлетворяет условиям выше.
Подмассив это непрерывная часть массива.

Пример 1:

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

Пример 2:

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

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

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

Дан массив nums, состоящий из неотрицательных целых чисел. Мы определяем балл подмассива nums[l..r] так, что l <= r как nums[l] AND nums[l + 1] AND ... AND nums[r], где AND — это побитовая операция И. Рассмотрим разбиение массива на один или несколько подмассивов, таких что выполняются следующие условия:

Каждый элемент массива принадлежит ровно одному подмассиву. Сумма баллов подмассивов минимально возможная.

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

Пример 1:

Input: nums = [1,0,2,0,1,2] Output: 3 Explanation: Мы можем разбить массив на следующие подмассивы: - [1,0]. Балл этого подмассива равен 1 AND 0 = 0. - [2,0]. Балл этого подмассива равен 2 AND 0 = 0. - [1,2]. Балл этого подмассива равен 1 AND 2 = 0. Сумма баллов равна 0 + 0 + 0 = 0, что является минимально возможным баллом, который мы можем получить. Можно показать, что невозможно разбить массив на более чем 3 подмассива с общей суммой баллов 0. Поэтому мы возвращаем 3.

Пример 2:

Input: nums = [5,7,1,3] Output: 1 Explanation: Мы можем разбить массив на один подмассив: [5,7,1,3] с баллом 1, который является минимально возможным баллом, который мы можем получить. Можно показать, что невозможно разбить массив на более чем 1 подмассив с общей суммой баллов 1. Поэтому мы возвращаем 1.

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

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


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

Выберите два индекса, i и j, где i < j, такие что nums[i] < nums[j].
Затем удалите элементы с индексами i и j из nums. Оставшиеся элементы сохраняют свой исходный порядок, и массив перевыставляется заново.

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

Пример 1:

Ввод: nums = [1,3,4,9]
Вывод: 0
Объяснение: Изначально nums = [1, 3, 4, 9].
В первой операции мы можем выбрать индексы 0 и 1, потому что nums[0] < nums[1] <=> 1 < 3.
Удалите индексы 0 и 1, и nums становится [4, 9].
Для следующей операции мы можем выбрать индексы 0 и 1, потому что nums[0] < nums[1] <=> 4 < 9.
Удалите индексы 0 и 1, и nums становится пустым массивом [].
Таким образом, минимальная достижимая длина равна 0.
Пример 2:

Ввод: nums = [2,3,6,9]
Вывод: 0
Объяснение: Изначально nums = [2, 3, 6, 9].
В первой операции мы можем выбрать индексы 0 и 2, потому что nums[0] < nums[2] <=> 2 < 6.
Удалите индексы 0 и 2, и nums становится [3, 9].
Для следующей операции мы можем выбрать индексы 0 и 1, потому что nums[0] < nums[1] <=> 3 < 9.
Удалите индексы 0 и 1, и nums становится пустым массивом [].
Таким образом, минимальная достижимая длина равна 0.

Пример 3:

Ввод: nums = [1,1,2]
Вывод: 1
Объяснение: Изначально nums = [1, 1, 2].
В операции мы можем выбрать индексы 0 и 2, потому что nums[0] < nums[2] <=> 1 < 2.
Удалите индексы 0 и 2, и nums становится [1].
Невозможно больше выполнять операции на массиве.
Таким образом, минимальная достижимая длина равна 1.

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

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums отсортирован в неубывающем порядке.

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

Выберите два индекса, i и j, где i < j, такие, что nums[i] < nums[j].
Затем удалите элементы с индексами i и j из nums. Остальные элементы сохраняют свой первоначальный порядок, а массив переиндексируется.

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

Пример 1:

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

Ввод: nums = [2,3,6,9]
Вывод: 0
Объяснение: Изначально, nums = [2, 3, 6, 9].
В первой операции мы можем выбрать индексы 0 и 2, потому что nums[0] < nums[2] <=> 2 < 6.
Удалите индексы 0 и 2, и nums станет [3, 9].
Для следующей операции мы можем выбрать индексы 0 и 1, потому что nums[0] < nums[1] <=> 3 < 9.
Удалите индексы 0 и 1, и nums станет пустым массивом [].
Следовательно, минимальная достижимая длина равна 0.

Пример 3:

Ввод: nums = [1,1,2]
Вывод: 1
Объяснение: Изначально, nums = [1, 1, 2].
В операции мы можем выбрать индексы 0 и 2, потому что nums[0] < nums[2] <=> 1 < 2.
Удалите индексы 0 и 2, и nums станет [1].
Больше невозможно выполнить операцию с массивом.
Следовательно, минимально достижимая длина равна 1.

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

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums сортируется в неубывающем порядке.


Вам дан 0-индексированный массив nums неотрицательных целых чисел и два целых числа l и r.
Верните количество подмультимножеств в пределах nums, где сумма элементов в каждом подмножестве попадает в инклюзивный диапазон [l, r].
Поскольку ответ может быть большим, верните его по модулю 10^9 + 7.
Подмультимножество — это неупорядоченная коллекция элементов массива, в которой заданное значение x может встречаться 0, 1, ..., occ[x] раз, где occ[x] — это количество вхождений x в массив.
Обратите внимание, что:

Два подмультимножества одинаковы, если сортировка обоих подмультимножеств приводит к идентичным мультимножествам.
Сумма пустого мультимножества равна 0.

Пример 1:

Вход: nums = [1,2,2,3], l = 6, r = 6
Выход: 1
Пояснение: Единственное подмножество nums, сумма которого равна 6, — это {1, 2, 3}.

Пример 2:

Вход: nums = [2,1,4,2,7], l = 1, r = 5
Выход: 7
Пояснение: Подмножества nums, сумма которых находится в диапазоне [1, 5], — это {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} и {1, 2, 2}.

Пример 3:

Вход: nums = [1,2,1,3,5,2], l = 3, r = 5
Выход: 9
Пояснение: Подмножества nums, сумма которых находится в диапазоне [3, 5], — это {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} и {1, 2, 2}.

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

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
Сумма nums не превышает 2 * 10^4.
0 <= l <= r <= 2 * 10^4

Дан массив nums из неотрицательных целых чисел с индексами, начинающимися с 0, и два целых числа l и r. Верните количество подмультимножеств в nums, где сумма элементов каждого подмножества попадает в включающий диапазон [l, r]. Так как ответ может быть большим, верните его по модулю 10^9 + 7. Подмультимножество — это неупорядоченное множество элементов массива, в котором заданное значение x может встречаться 0, 1, ..., occ[x] раз, где occ[x] — количество вхождений x в массив. Заметьте:

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

Пример 1:

Input: nums = [1,2,2,3], l = 6, r = 6
Output: 1
Explanation: Единственное подмножество nums, сумма которого равна 6, это {1, 2, 3}.

Пример 2:

Input: nums = [2,1,4,2,7], l = 1, r = 5
Output: 7
Explanation: Подмножества nums, сумма которых входит в диапазон [1, 5], это {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4}, и {1, 2, 2}.

Пример 3:

Input: nums = [1,2,1,3,5,2], l = 3, r = 5
Output: 9
Explanation: Подмножества nums, сумма которых входит в диапазон [3, 5], это {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3}, и {1, 2, 2}.

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

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
Сумма nums не превышает 2 * 10^4.
0 <= l <= r <= 2 * 10^4


Вам дан 0-индексированный массив целых чисел nums и целое число k. Верните целое число, обозначающее сумму элементов в nums, чьи соответствующие индексы имеют ровно k установленных битов в их двоичном представлении. Установленные биты в целом числе — это единицы, присутствующие при записи в двоичной форме.

Например, двоичное представление 21 — это 10101, которое имеет 3 установленных бита.

Пример 1:

Ввод: nums = [5,10,1,5,2], k = 1
Вывод: 13
Объяснение: Двоичное представление индексов:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индексы 1, 2 и 4 имеют k = 1 установленных бит в их двоичном представлении.
Таким образом, ответ будет nums[1] + nums[2] + nums[4] = 13.

Пример 2:

Ввод: nums = [4,3,2,1], k = 2
Вывод: 1
Объяснение: Двоичное представление индексов:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Только индекс 3 имеет k = 2 установленных бита в своем двоичном представлении.
Таким образом, ответ будет nums[3] = 1.

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

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

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

Например, двоичное представление числа 21 — это 10101, имеющее 3 установленных бита.

Пример 1:

Ввод: nums = [5,10,1,5,2], k = 1
Выход: 13
Объяснение: Двоичное представление индексов:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индексы 1, 2 и 4 имеют k = 1 набор битов в двоичном представлении.
Следовательно, ответ: nums[1] + nums[2] + nums[4] = 13.
Пример 2:

Ввод: nums = [4,3,2,1], k = 2
Выход: 1
Объяснение: Двоичное представление индексов:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Только индекс 3 имеет k = 2 установленных бита в двоичном представлении.
Следовательно, ответ: nums[3] = 1.

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

1 <= nums.length <= 1000
1 <= числа[i] <= 10^5
0 <= к <= 10

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

Например, двоичное представление числа 21 — это 10101, которое имеет 3 установленных бита.

Пример 1:

Вход: nums = [5,10,1,5,2], k = 1
Выход: 13
Пояснение: Двоичное представление индексов:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индексы 1, 2 и 4 имеют k = 1 установленных битов в своем двоичном представлении.
Следовательно, ответ nums[1] + nums[2] + nums[4] = 13.
Пример 2:

Вход: nums = [4,3,2,1], k = 2
Выход: 1
Пояснение: Двоичное представление индексов:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Только индекс 3 имеет k = 2 установленных бита в своем двоичном представлении.
Следовательно, ответ nums[3] = 1.

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

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


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

Выберите два элемента с одинаковыми значениями и удалите их из массива.

Выберите три элемента с одинаковыми значениями и удалите их из массива.

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

Пример 1:

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

Пример 2:

Вход: nums = [2,1,2,2,3,3]
Выход: -1
Объяснение: Невозможно очистить массив.

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

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

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

Выбрать два элемента с одинаковыми значениями и удалить их из массива.

Выбрать три элемента с одинаковыми значениями и удалить их из массива.

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

Пример 1:

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

Example 2:

Input: nums = [2,1,2,2,3,3]
Output: -1
Объяснение: Невозможно сделать массив пустым.

Constraints:

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

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

Выберите два элемента с одинаковыми значениями и удалите их из массива.

Выберите три элемента с одинаковыми значениями и удалите их из массива.

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

Пример 1:

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

Пример 2:

Вход: nums = [2,1,2,2,3,3]
Выход: -1
Объяснение: Невозможно очистить массив.

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

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


Дан 0-индексированный целочисленный массив nums длиной n, где n — общее количество учеников в классе. Классный руководитель пытается выбрать группу учеников так, чтобы все остались довольны.
i-й ученик будет доволен, если выполнится одно из двух условий:

Ученик выбран, и общее количество выбранных учеников строго больше, чем nums[i].
Ученик не выбран, и общее количество выбранных учеников строго меньше, чем nums[i].

Выведи количество способов выбрать группу учеников так, чтобы все остались довольны.

Пример 1:

Ввод: nums = [1,1]
Вывод: 2
Пояснение:
Два возможных способа:
Классный руководитель не выбирает ни одного ученика.
Классный руководитель выбирает обоих учеников для формирования группы.
Если классный руководитель выберет только одного ученика для формирования группы, то оба ученика будут недовольны. Таким образом, существует только два возможных способа.

Пример 2:

Ввод: nums = [6,0,3,3,6,7,2,7]
Вывод: 3
Пояснение:
Три возможных способа:
Классный руководитель выбирает ученика с индексом = 1 для формирования группы.
Классный руководитель выбирает учеников с индексами = 1, 2, 3, 6 для формирования группы.
Классный руководитель выбирает всех учеников для формирования группы.

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

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

Вам дается 0-индексированный целочисленный массив nums длины n, где n — общее количество студентов в классе. Классный руководитель старается подобрать группу учеников так, чтобы все ученики остались довольны.
i^-й студент станет счастливым, если будет выполнено одно из этих двух условий:

Студент отбирается, и общее количество отобранных студентов строго превышает nums[i].
Студент не отбирается, и общее количество отобранных студентов строго меньше nums[i].

Верните количество способов выбора группы учеников, чтобы все остались довольны.

Пример 1:

Входные данные: nums = [1,1]
Выход: 2
Объяснение:
Возможны два способа:
Классный руководитель не выбирает ни одного ученика.
Классный руководитель отбирает обоих учеников для формирования группы.
Если классный руководитель выберет только одного ученика для формирования группы, то оба ученика не будут счастливы. Поэтому есть только два возможных способа.

Пример 2:

Входные данные: nums = [6,0,3,3,6,7,2,7]
Выход: 3
Объяснение:
Возможны три способа:
Классный руководитель отбирает ученика с индексом = 1 для формирования группы.
Классный руководитель отбирает учеников с индексом = 1, 2, 3, 6 для формирования группы.
Классный руководитель отбирает всех учеников для формирования группы.

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

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

Вам дан 0-индексированный целочисленный массив nums длины n, где n — общее количество учеников в классе. Классный руководитель пытается выбрать группу учеников так, чтобы все ученики остались довольны.
i^th ученик станет счастливым, если будет выполнено одно из этих двух условий:

Ученик выбран, и общее количество выбранных учеников строго больше nums[i].
Ученик не выбран, и общее количество выбранных учеников строго меньше nums[i].

Верните количество способов выбрать группу учеников так, чтобы все остались довольны.

Пример 1:

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

Пример 2:

Вход: nums = [6,0,3,3,6,7,2,7]
Выход: 3
Объяснение:
Три возможных способа:
Классный руководитель выбирает ученика с индексом = 1 для формирования группы.
Классный руководитель выбирает учеников с индексом = 1, 2, 3, 6 для формирования группы.
Классный руководитель выбирает всех учеников для формирования группы.

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

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


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

Пример 1:

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

Пример 2:

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

Пример 3:

Ввод: nums = [1,1,5,4,5], target = 3
Вывод: -1
Объяснение: Можно показать, что в nums нет подпоследовательности с суммой, равной 3.

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

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

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

Пример 1:

Входные данные: nums = [1,2,3,4,5], target = 9
Выходные данные: 3
Объяснение: есть 3 подпоследовательности с суммой, равной 9: [4,5], [1,3,5] и [2,3,4]. Самые длинные подпоследовательности — [1,3,5] и [2,3,4]. Следовательно, ответ — 3.

Пример 2:

Вход: nums = [4,1,3,2,1,5], target = 7
Выход: 4
Пояснение: есть 5 подпоследовательностей с суммой, равной 7: [4,3], [4,1,2], [4,2,1], [1,1,5] и [1,3,2,1]. Самая длинная подпоследовательность — [1,3,2,1]. Следовательно, ответ 4.

Пример 3:

Вход: nums = [1,1,5,4,5], target = 3
Выход: -1
Пояснение: можно показать, что nums не имеет подпоследовательности, которая в сумме дает 3.

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

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

Вам дан массив целых чисел с индексом 0 и целочисленная цель.
Верните длину самой длинной подпоследовательности чисел, которая в сумме достигает целевого значения. Если такой подпоследовательности не существует, верните -1.
Подпоследовательность это массив, который можно получить из другого массива путём удаления некоторых элементов или их отсутствия без изменения порядка остальных элементов.

Пример 1:

Ввод: nums = [1,2,3,4,5], target = 9
Вывод: 3
Пояснение: Есть 3 подпоследовательности с суммой, равной 9: [4,5], [1,3,5], и [2,3,4]. Самые длинные подпоследовательности это [1,3,5] и [2,3,4]. Следовательно, ответ 3.

Пример 2:

Ввод: nums = [4,1,3,2,1,5], target = 7
Вывод: 4
Пояснение: Имеется 5 подпоследовательностей с суммой, равной 7: [4,3], [4,1,2], [4,2,1], [1,1,5], и [1,3,2,1]. Самая длинная подпоследовательность это [1,3,2,1]. Следовательно, ответ 4.

Пример 3:

Ввод: nums = [1,1,5,4,5], target = 3
Вывод: -1
Пояснение: Можно показать, что у nums нет подпоследовательности, сумма которой равна 3.

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

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


Дан массив maxHeights из n целых чисел с 0-индексацией.
Вам нужно построить n башен на числовой прямой. i-ая башня строится в координате i и имеет высоту heights[i].
Конфигурация башен является красивой, если выполняются следующие условия:

1 <= heights[i] <= maxHeights[i]
heights — это горный массив.

Массив heights является горным, если существует индекс i, такой что:

Для всех 0 < j <= i, heights[j - 1] <= heights[j]
Для всех i <= k < n - 1, heights[k + 1] <= heights[k]

Верните максимальную возможную сумму высот красивой конфигурации башен.

Пример 1:

Ввод: maxHeights = [5,3,4,1,1]
Вывод: 13
Объяснение: Одна красивая конфигурация с максимальной суммой — heights = [5,3,3,1,1]. Эта конфигурация является красивой, так как:
- 1 <= heights[i] <= maxHeights[i]
- heights является горой с пиком в i = 0.
Можно показать, что не существует другой красивой конфигурации с суммой высот, превышающей 13.
Пример 2:

Ввод: maxHeights = [6,5,3,9,2,7]
Вывод: 22
Объяснение: Одна красивая конфигурация с максимальной суммой — heights = [3,3,3,9,2,2]. Эта конфигурация является красивой, так как:
- 1 <= heights[i] <= maxHeights[i]
- heights является горой с пиком в i = 3.
Можно показать, что не существует другой красивой конфигурации с суммой высот, превышающей 22.
Пример 3:

Ввод: maxHeights = [3,2,5,5,2,3]
Вывод: 18
Объяснение: Одна красивая конфигурация с максимальной суммой — heights = [2,2,5,5,2,2]. Эта конфигурация является красивой, так как:
- 1 <= heights[i] <= maxHeights[i]
- heights является горой с пиком в i = 2.
Также для этой конфигурации i = 3 может считаться пиком.
Можно показать, что не существует другой красивой конфигурации с суммой высот, превышающей 18.

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

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Вам дается 0- индексированный массив maxHeights n целых чисел.
Вам поручено построить башни n на линии координат. i-я башня построена в координате i и имеет высоту heights[i].
Конфигурация башен прекрасна, если выполняются следующие условия:

1 <= heights[i] <= maxHeights[i]
Массив высот — это горный массив.

Array heights-это гора, если существует индекс i такой, что:

Для всех 0 < j <= i, heights[j - 1] <= heights[j]
Для всех i <= k < n - 1, heights[k + 1] <= heights[k]

Верните максимально возможную сумму высот прекрасной конфигурации башен.

Пример 1:

Вход: maxHeights = [5,3,4,1,1]
Выход: 13
Объяснение: одна красивая конфигурация с максимальной суммой высоты = [5,3,3,1,1]. Эта конфигурация прекрасна, так как:
- 1 <= heights[i] <= maxHeights[i]
- Массив высот представляет собой гору с вершиной i = 0.
Можно показать, что нет другой более красивой конфигурации с большей суммой высот.
Пример 2:

Вход: maxHeights = [6,5,3,9,2,7]
Выход: 22
Объяснение: одна красивая конфигурация с максимальной суммой высоты = [3,3,3,9,2,2]. Эта конфигурация прекрасна, так как:
- 1 <= heights[i] <= maxHeights[i]
- массив высот-это гора вершины i = 3.
Можно показать, что нет никакой другой прекрасной конфигурации с суммой высот больше 22.
Пример 3:

Вход: maxHeights = [3,2,5,5,2,3]
Выход: 18
Объяснение: одна красивая конфигурация с максимальной суммой высоты = [2,2,5,5,2,2]. Эта конфигурация прекрасна, так как:
- 1 <= heights[i] <= maxHeights[i]
- массив высот-это гора вершины i = 2.
Обратите внимание, что для этой конфигурации i = 3 также может считаться пиком.
Можно показать, что нет никакой другой прекрасной конфигурации с суммой высот больше 18.

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

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9


Вам дан 0-индексированный массив nums и целочисленный target.
0-индексированный массив infinite_nums генерируется путем бесконечного добавления элементов nums к себе.
Верните длину самого короткого подмассива массива infinite_nums с суммой, равной target. Если такого подмассива нет, верните -1.

Пример 1:

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

Пример 2:

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

Пример 3:

Вход: nums = [2,4,6,8], target = 3
Выход: -1
Пояснение: в этом примере infinite_nums = [2,4,6,8,2,4,6,8,...].
Можно доказать, что нет подмассива с суммой, равной target = 3.

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

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

Дан массив с 0-индексацией nums и целое число target.
Массив с 0-индексацией infinite_nums генерируется путем бесконечного добавления элементов из nums к самому себе.
Верните длину самой короткой подмассивы массива infinite_nums с суммой, равной target. Если такой подмассивы нет, верните -1.

Пример 1:

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

Пример 2:

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

Пример 3:

Входные данные: nums = [2,4,6,8], target = 3
Выходные данные: -1
Объяснение: В этом примере infinite_nums = [2,4,6,8,2,4,6,8,...].
Можно доказать, что подмассивы с суммой, равной target = 3, не существует.

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

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


Вам дана двоичная строка s и положительное целое число k.
Подстрока s является красивой, если количество единиц в ней равно k.
Пусть len будет длиной самой короткой красивой подстроки.
Верните лексикографически наименьшую красивую подстроку строки s с длиной, равной len. Если s не содержит красивой подстроки, верните пустую строку.
Строка a лексикографически больше строки b (той же длины), если в первой позиции, где a и b различаются, a имеет символ, строго больший, чем соответствующий символ в b.

Например, «abcd» лексикографически больше, чем «abcc», потому что первая позиция, в которой они различаются, находится на четвертом символе, а d больше, чем c.

Пример 1:

Вход: s = "100011001", k = 3
Выход: "11001"
Пояснение: В этом примере 7 красивых подстрок:
1. Подстрока "100011001".
2. Подстрока "100011001".
3. Подстрока "100011001".
4. Подстрока "100011001".
5. Подстрока "100011001".
6. Подстрока "100011001".
7. Подстрока "100011001".
Длина самой короткой красивой подстроки равна 5.
Лексикографически наименьшая красивая подстрока с длиной 5 — это подстрока "11001".

Пример 2:

Вход: s = "1011", k = 2
Выход: "11"
Пояснение: В этом примере есть 3 красивые подстроки:
1. Подстрока "1011".
2. Подстрока "1011".
3. Подстрока "1011".
Длина самой короткой красивой подстроки равна 2.
Лексикографически наименьшая красивая подстрока с длиной 2 — это подстрока "11".

Пример 3:

Вход: s = "000", k = 1
Выход: ""
Пояснение: В этом примере нет красивых подстрок.

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

1 <= s.length <= 100
1 <= k <= s.length

Вам дана двоичная строка s и целое положительное число k.
Подстрока s является красивой, если количество 1 в ней равно ровно k.
Пусть len — длина самой короткой красивой подстроки.
Верните лексикографически наименьшую красивую подстроку строки s с длиной, равной len. Если s не содержит красивой подстроки, верните пустую строку.
Строка a лексикографически больше строки b (той же длины), если в первой позиции, где a и b различаются, a имеет символ, строго больший, чем соответствующий символ в b.

Например, "abcd" лексикографически больше, чем «abcc», потому что в первой позиции, где они различаются, находится четвертый символ, а d больше, чем c.

Пример 1:

Ввод: s = "100011001", k = 3
Вывод: "11001"
Пояснение: В этом примере 7 красивых подстрок:
1. Подстрока "100011001".
2. Подстрока "100011001".
3. Подстрока "100011001".
4. Подстрока "100011001".
5. Подстрока "100011001".
6. Подстрока "100011001".
7. Подстрока "100011001".
Длина самой короткой красивой подстроки равна 5.
Лексикографически наименьшая красивая подстрока длиной 5 — это подстрока "11001".

Пример 2:

Ввод: s = "1011", k = 2
Вывод: "11"
Пояснение: В этом примере есть три красивые подстроки:
1. Подстрока "1011".
2. Подстрока "1011".
3. Подстрока "1011".
Длина самой короткой красивой подстроки равна 2.
Лексикографически наименьшая красивая подстрока длиной 2 — это подстрока "11".

Пример 3:

Ввод: s = "000", k = 1
Вывод: ""
Пояснения: В этом примере нет красивых подстрок.

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

1 <= s.length <= 100
1 <= k <= s.length

Вам дано двоичное строку s и положительное целое число k.
Подстрока строки s является прекрасной, если количество единиц в ней ровно k.
Пусть len будет длиной самой короткой прекрасной подстроки.
Верните лексикографически наименьшую прекрасную подстроку строки s с длиной, равной len. Если s не содержит прекрасную подстроку, верните пустую строку.
Строка a лексикографически больше строки b (той же длины), если в первой позиции, где a и b различаются, a имеет символ, строго больший соответствующего символа в b.

Например, "abcd" лексикографически больше, чем "abcc", потому что первая позиция, где они различаются, — это четвертый символ, и d больше, чем c.

Пример 1:

Входные данные: s = "100011001", k = 3
Выходные данные: "11001"
Объяснение: В этом примере есть 7 прекрасных подстрок:
1. Подстрока "100011001".
2. Подстрока "100011001".
3. Подстрока "100011001".
4. Подстрока "100011001".
5. Подстрока "100011001".
6. Подстрока "100011001".
7. Подстрока "100011001".
Длина самой короткой прекрасной подстроки — 5.
Лексикографически наименьшая прекрасная подстрока с длиной 5 — подстрока "11001".

Пример 2:

Входные данные: s = "1011", k = 2
Выходные данные: "11"
Объяснение: В этом примере есть 3 прекрасных подстроки:
1. Подстрока "1011".
2. Подстрока "1011".
3. Подстрока "1011".
Длина самой короткой прекрасной подстроки — 2.
Лексикографически наименьшая прекрасная подстрока с длиной 2 — подстрока "11".

Пример 3:

Входные данные: s = "000", k = 1
Выходные данные: ""
Объяснение: В этом примере нет прекрасных подстрок.

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

1 <= s.length <= 100
1 <= k <= s.length


У вас есть n процессоров, каждый из которых имеет 4 ядра, и n * 4 задач, которые необходимо выполнить так, чтобы каждое ядро выполняло только одну задачу.
Дан массив целых чисел с индексами 0 processorTime, представляющий время, когда каждый процессор становится доступным в первый раз, и массив целых чисел с индексами 0 tasks, представляющий время, необходимое для выполнения каждой задачи. Верните минимальное время, когда все задачи выполнены процессорами.
Примечание: каждое ядро выполняет задачу независимо от других.

Пример 1:

Ввод: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Вывод: 16
Объяснение:
Оптимально назначить задачи с индексами 4, 5, 6, 7 первому процессору, который становится доступным во времени = 8, и задачи с индексами 0, 1, 2, 3 второму процессору, который становится доступным во времени = 10.
Время, затраченное первым процессором на выполнение всех задач = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Время, затраченное вторым процессором на выполнение всех задач = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Следовательно, можно показать, что минимальное время выполнения всех задач составляет 16.
Пример 2:

Ввод: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Вывод: 23
Объяснение:
Оптимально назначить задачи с индексами 1, 4, 5, 6 первому процессору, который становится доступным во времени = 10, и задачи с индексами 0, 2, 3, 7 второму процессору, который становится доступным во времени = 20.
Время, затраченное первым процессором на выполнение всех задач = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Время, затраченное вторым процессором на выполнение всех задач = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Следовательно, можно показать, что минимальное время выполнения всех задач составляет 23.

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

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

У вас есть n процессоров, каждый из которых имеет 4 ядра, и n * 4 задач, которые необходимо выполнить, так что каждое ядро должно выполнять только одну задачу.
Дан целочисленный массив с индексом 0, представляющий время, в которое каждый процессор становится доступным в первый раз, и целочисленный массив с индексом 0, представляющий время, необходимое для выполнения каждой задачи, вернуть минимальное время, когда все задачи будут выполнены процессорами.
Примечание: каждое ядро выполняет задачу независимо от других.

Пример 1:

Вход: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Выход: 16
Пояснение:
Оптимально назначить задачи с индексами 4, 5, 6, 7 первому процессору, который станет доступен в момент времени = 8, а задачи с индексами 0, 1, 2, 3 — второму процессору, который станет доступен в момент времени = 10.
Время, необходимое первому процессору для завершения выполнения всех задач = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Время, необходимое второму процессору для завершения выполнения всех задач = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Следовательно, можно показать, что минимальное время, необходимое для выполнения всех задач, равно 16.
Пример 2:

Вход: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Выход: 23
Объяснение:
Оптимально назначить задачи с индексами 1, 4, 5, 6 первому процессору, который станет доступен в момент времени = 10, а задачи с индексами 0, 2, 3, 7 — второму процессору, который станет доступен в момент времени = 20.
Время, необходимое первому процессору для завершения выполнения всех задач = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Время, необходимое второму процессору для завершения выполнения всех задач = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Следовательно, можно показать, что минимальное время, необходимое для выполнения всех задач, равно 23.

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

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


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

Выберите любые два различных индекса i и j и одновременно обновите значения nums[i] до (nums[i] AND nums[j]) и nums[j] до (nums[i] OR nums[j]). Здесь OR обозначает побитовое OR, а AND обозначает побитовое AND.

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

Пример 1:

Ввод: nums = [2,6,5,8], k = 2
Вывод: 261
Объяснение: Мы можем выполнить следующие операции с массивом:
- Выберите i = 0 и j = 3, затем измените nums[0] на (2 AND 8) = 0 и nums[3] на (2 OR 8) = 10. Полученный массив nums = [0,6,5,10].
- Выберите i = 2 и j = 3, затем измените nums[2] на (5 AND 10) = 0 и nums[3] на (5 OR 10) = 15. Полученный массив nums = [0,6,0,15].
Мы можем выбрать элементы 15 и 6 из конечного массива. Сумма квадратов равна 15^2 + 6^2 = 261.
Можно показать, что это максимальное значение, которое мы можем получить.

Пример 2:

Ввод: nums = [4,5,4,7], k = 3
Вывод: 90
Объяснение: Нам не нужно применять какие-либо операции.
Мы можем выбрать элементы 7, 5 и 4 с суммой квадратов: 7^2 + 5^2 + 4^2 = 90.
Можно показать, что это максимальное значение, которое мы можем получить.

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

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


Вам дано целочисленный массив с индексом, начинающимся с 0, nums.
Верните максимальное значение среди всех троек индексов (i, j, k), таких что i < j < k. Если все такие тройки имеют отрицательное значение, верните 0.
Значение тройки индексов (i, j, k) равно (nums[i] - nums[j]) * nums[k].

Пример 1:

Ввод: nums = [12,6,1,2,7]
Вывод: 77
Объяснение: Значение тройки (0, 2, 4) равно (nums[0] - nums[2]) * nums[4] = 77.
Можно показать, что нет других упорядоченных троек индексов со значением больше, чем 77.

Пример 2:

Ввод: nums = [1,10,3,4,19]
Вывод: 133
Объяснение: Значение тройки (1, 2, 4) равно (nums[1] - nums[2]) * nums[4] = 133.
Можно показать, что нет других упорядоченных троек индексов со значением больше, чем 133.

Пример 3:

Ввод: nums = [1,2,3]
Вывод: 0
Объяснение: Единственная упорядоченная тройка индексов (0, 1, 2) имеет отрицательное значение (nums[0] - nums[1]) * nums[2] = -3. Следовательно, ответ будет 0.

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

3 <= nums.length <= 100
1 <= nums[i] <= 10^6

Вам дан целочисленный массив чисел с нулевым индексом.
Верните максимальное значение по всем тройкам индексов (i, j, k), таким что i < j < k. Если все такие тройки имеют отрицательное значение, верните 0.
Значение тройки индексов (i, j, k) равно (nums[i] - nums[j]) * nums[k].

Пример 1:

Ввод: nums = [12,6,1,2,7]
Выход: 77
Объяснение: Значение тройки (0, 2, 4) равно (nums[0] - nums[2]) * nums[4] = 77.
Можно показать, что не существует упорядоченных троек индексов со значением больше 77.

Пример 2:

Ввод: nums = [1,10,3,4,19]
Выход: 133
Объяснение: Значение тройки (1, 2, 4) равно (nums[1] - nums[2]) * nums[4] = 133.
Можно показать, что не существует упорядоченных троек индексов со значением больше 133.

Пример 3:

Ввод: nums = [1,2,3]
Вывод: 0
Объяснение: Единственная упорядоченная тройка индексов (0, 1, 2) имеет отрицательное значение (nums[0] - nums[1]) * nums[2] = -3. Следовательно, ответ будет 0.

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

3 <= nums.length <= 100
1 <= nums[i] <= 10^6

Вам дан целочисленный массив nums с индексом 0.
Верните максимальное значение по всем тройкам индексов (i, j, k) таким, что i < j < k. Если все такие тройки имеют отрицательное значение, верните 0.
Значение тройки индексов (i, j, k) равно (nums[i] - nums[j]) * nums[k].

Пример 1:

Вход: nums = [12,6,1,2,7]
Выход: 77
Пояснение: Значение триплета (0, 2, 4) равно (nums[0] - nums[2]) * nums[4] = 77.
Можно показать, что не существует упорядоченных триплетов индексов со значением больше 77.

Пример 2:

Вход: nums = [1,10,3,4,19]
Выход: 133
Пояснение: Значение триплета (1, 2, 4) равно (nums[1] - nums[2]) * nums[4] = 133.
Можно показать, что не существует упорядоченных триплетов индексов со значением больше 133.

Пример 3:

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

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

3 <= nums.length <= 100
1 <= nums[i] <= 10^6


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

Пусть nums[i..j] — подмассив nums, состоящий из всех индексов от i до j, таких что 0 <= i <= j < nums.length. Тогда количество уникальных значений в nums[i..j] называется уникальным количеством для nums[i..j].

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

Пример 1:

Input: nums = [1,2,1]
Output: 15
Explanation: Шесть возможных подмассивов:
[1]: 1 уникальное значение
[2]: 1 уникальное значение
[1]: 1 уникальное значение
[1,2]: 2 уникальных значения
[2,1]: 2 уникальных значения
[1,2,1]: 2 уникальных значения
Сумма квадратов уникальных количеств во всех подмассивах равна 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Пример 2:

Input: nums = [1,1]
Output: 3
Explanation: Три возможных подмассива:
[1]: 1 уникальное значение
[1]: 1 уникальное значение
[1,1]: 1 уникальное значение
Сумма квадратов уникальных количеств во всех подмассивах равна 1^2 + 1^2 + 1^2 = 3.

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

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

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

Пусть nums[i..j] — подмассив nums, состоящий из всех индексов от i до j, таких что 0 <= i <= j < nums.length. Тогда количество уникальных значений в nums[i..j] называется уникальным количеством для nums[i..j].

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

Пример 1:

Ввод: nums = [1,2,1]
Вывод: 15
Объяснение: Шесть возможных подмассивов:
[1]: 1 уникальное значение
[2]: 1 уникальное значение
[1]: 1 уникальное значение
[1,2]: 2 уникальное значение
[2,1]: 2 уникальное значение
[1,2,1]: 2 уникальное значение
Сумма квадратов уникальных количеств во всех подмассивах равна 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Пример 2:

Ввод: nums = [1,1]
Вывод: 3
Объяснение: Три возможных подмассива:
[1]: 1 уникальное значение
[1]: 1 уникальное значение
[1,1]: 1 уникальное значение
Сумма квадратов уникальных количеств во всех подмассивах равнаo 1^2 + 1^2 + 1^2 = 3.

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

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