Дан массив строк words с индексом 0, где words[i] — либо положительное целое число, представленное в виде строки, либо строка "prev". Начни итерацию с начала массива; для каждой строки "prev" в words найди последнее встреченное число в words, которое определяется следующим образом:

Пусть k — количество последовательных строк "prev", встреченных до сих пор (включая текущую строку). Пусть nums — массив целых чисел с индексом 0, встреченных до сих пор, а nums_reverse — обратный массив nums, тогда число на индексе (k - 1) в nums_reverse будет последним встреченным числом для данной"prev". Если k больше общего числа встреченных целых чисел, то последнее встреченное целое число будет -1.

Верни массив целых чисел, содержащий последние встреченные целые числа.

Пример 1:

Ввод: words = ["1","2","prev","prev","prev"]
Вывод: [2,1,-1]
Пояснение:
Для "prev" с индексом = 2, последнее встреченное целое число будет 2, так как количество последовательных строк "prev" равно 1, и в массиве reverse_nums 2 будет первым элементом.
Для "prev" с индексом = 3, последнее встреченное целое число будет 1, так как здесь две последовательные строки "prev", включая эту, и 1 является вторым последним встреченным целым числом.
Для "prev" с индексом = 4, последнее встреченное целое число будет -1, так как здесь три последовательные строки "prev", включая эту, но общее количество встреченных целых чисел равно двум.

Пример 2:

Ввод: words = ["1","prev","2","prev","prev"]
Вывод: [1,2,1]
Пояснение:
Для "prev" с индексом = 1, последнее встреченное целое число будет 1.
Для "prev" с индексом = 3, последнее встреченное целое число будет 2.
Для "prev" с индексом = 4, последнее встреченное целое число будет 1, так как здесь две последовательные строки "prev", включая эту, и 1 является вторым последним встреченным целым числом.

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

1 <= words.length <= 100
words[i] == "prev" или 1 <= int(words[i]) <= 100

Дан массив строк words с нулевой индексацией, где words[i] — либо положительное целое число, представленное в виде строки, либо строка "prev". Начните итерацию с начала массива; для каждой строки "prev" в words найдите последнее посещенное число в words, которое определяется следующим образом:

Пусть k — количество последовательных строк "prev", встреченных до сих пор (включая текущую строку). Пусть nums — массив целых чисел с нулевой индексацией, которые видели до сих пор, а nums_reverse — обратный массив nums, тогда число на индексе (k - 1) в nums_reverse будет последним посещенным числом для этой "prev". Если k больше общего числа посещенных чисел, то последнее посещенное число будет -1.

Возвращайте массив целых чисел, содержащий последние посещенные числа.

Пример 1:

Input: words = ["1","2","prev","prev","prev"]
Output: [2,1,-1]
Пояснение:
Для "prev" на индексе = 2, последнее посещенное число будет 2, так как количество последовательных строк "prev" равно 1, и в массиве reverse_nums, 2 будет первым элементом.
Для "prev" на индексе = 3, последнее посещенное число будет 1, так как здесь две последовательные строки "prev", включая эту, и 1 является вторым последним посещенным числом.
Для "prev" на индексе = 4, последнее посещенное число будет -1, так как здесь три последовательные строки "prev", включая эту, но общее количество посещенных чисел равно двум.

Пример 2:

Input: words = ["1","prev","2","prev","prev"]
Output: [1,2,1]
Пояснение:
Для "prev" на индексе = 1, последнее посещенное число будет 1.
Для "prev" на индексе = 3, последнее посещенное число будет 2.
Для "prev" на индексе = 4, последнее посещенное число будет 1, так как здесь две последовательные строки "prev", включая эту, и 1 является вторым последним посещенным числом.

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

1 <= words.length <= 100
words[i] == "prev" или 1 <= int(words[i]) <= 100


Вам дан целочисленный массив nums с нулевой индексацией длины n.
Мы хотим сгруппировать индексы так, чтобы каждый индекс i в диапазоне [0, n - 1] был назначен ровно в одну группу.
Назначение в группу является допустимым, если выполняются следующие условия:

Для каждой группы g все индексы i, назначенные группе g, имеют одно и то же значение в nums.
Для любых двух групп g_1 и g_2 разница между количеством индексов, назначенных g_1 и g_2, не должна превышать 1.

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

Пример 1:

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

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

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

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

Дан целочисленный массив nums с нулевой индексацией длиной n.
Мы хотим сгруппировать индексы так, чтобы каждый индекс i в диапазоне [0, n - 1] был назначен только одной группе.
Назначение допустимо, если выполняются следующие условия:

Для каждой группы g все индексы i, назначенные группе g, имеют одинаковое значение в nums.
Для любых двух групп g_1 и g_2 разница между количеством индексов, назначенных g_1 и g_2, не должна превышать 1.

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

Пример 1:

Ввод: nums = [3,2,3,2,3]
Вывод: 2
Пояснение: Один из способов назначения индексов 2 группам следующий (значения в квадратных скобках являются индексами):
группа 1 -> [0,2,4]
группа 2 -> [1,3]
Каждый индекс назначен одной группе.
В группе 1 nums[0] == nums[2] == nums[4], поэтому все индексы имеют одинаковое значение.
В группе 2 nums[1] == nums[3], поэтому все индексы имеют одинаковое значение.
Количество индексов, назначенных группе 1, составляет 3, а количество индексов, назначенных группе 2, составляет 2.
Их разница не превышает 1.
Невозможно использовать менее 2 групп, поскольку, чтобы использовать только 1 группу, все индексы, назначенные этой группе, должны иметь одинаковое значение.
Следовательно, ответ 2.

Пример 2:

Ввод: nums = [10,10,10,3,1,1]
Вывод: 4
Пояснение: Один из способов назначения индексов 4 группам следующий (значения в квадратных скобках являются индексами):
группа 1 -> [0]
группа 2 -> [1,2]
группа 3 -> [3]
группа 4 -> [4,5]
Приведенное назначение удовлетворяет обоим условиям.
Можно доказать, что невозможно создать допустимое назначение, используя менее 4 групп.
Следовательно, ответ 4.

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

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

Вам дан 0-индексированный целочисленный массив nums длины n.
Мы хотим сгруппировать индексы так, чтобы каждый индекс i в диапазоне [0, n - 1] был назначен ровно одной группе.
Назначение группы допустимо, если выполняются следующие условия:

Для каждой группы g все индексы i, назначенные группе g, имеют одинаковое значение в nums.
Для любых двух групп g_1 и g_2 разница между количеством индексов, назначенных g_1 и g_2, не должна превышать 1.

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

Пример 1:

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

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

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

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


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

Пример 1:

Ввод: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Вывод: 12
Объяснение: Мы можем заменить 0 следующим образом:
- Заменим два 0 в nums1 на значения 2 и 4. Результирующий массив nums1 = [3,2,2,1,4].
- Заменим 0 в nums2 на значение 1. Результирующий массив nums2 = [6,5,1].
Оба массива имеют равную сумму 12. Можно показать, что это минимальная сумма, которую мы можем получить.

Пример 2:

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

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

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

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

Пример 1:

Ввод: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Выход: 12
Объяснение: мы можем заменить 0's следующим образом:
-заменить два значения 0 в nums1 значениями 2 и 4. Результирующий массив nums1 = [3,2,2,1,4].
- заменить 0 в nums2 значением 1. Результирующий массив nums2 = [6,5,1].
Обе сети имеют одинаковую сумму в 12 единиц. Можно показать, что это минимальная сумма, которую мы можем получить.

Пример 2:

Ввод: nums1 = [2,0,2,0], nums2 = [1,4]
Выход: -1
Объяснение: невозможно сделать сумму обеих массивов равной.

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

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

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

Пример 1:

Ввод: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Вывод: 12
Пояснение: Мы можем заменить 0 следующим образом:
- Замените два нуля в nums1 значениями 2 и 4. В результате получится массив nums1 = [3,2,2,1,4].
- Замените 0 в nums2 на значение 1. В результате получится массив nums2 = [6,5,1].
Оба массива имеют одинаковую сумму 12. Можно показать, что это минимальная сумма, которую мы можем получить.

Пример 2:

Ввод: nums1 = [2,0,2,0], nums2 = [1,4]
Вывод: -1
Пояснение: Невозможно сделать сумму обоих массивов равной.

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

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


Вам даны положительные целые числа n и m.
Определите два целых числа, num1 и num2, следующим образом:

num1: сумма всех целых чисел в диапазоне [1, n], которые не делятся на m.
num2: сумма всех целых чисел в диапазоне [1, n], которые делятся на m.

Верните целое число num1 - num2.

Пример 1:

Вход: n = 10, m = 3
Выход: 19
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 10], которые не делятся на 3, это [1,2,4,5,7,8,10], num1 — сумма этих целых чисел = 37.
- Целые числа в диапазоне [1, 10], которые делятся на 3, это [3,6,9], num2 — сумма этих целых чисел = 18.
Мы возвращаем 37 - 18 = 19 в качестве ответа.

Пример 2:

Вход: n = 5, m = 6
Выход: 15
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 6, это [1,2,3,4,5], num1 — сумма этих целых чисел = 15.
- Целые числа в диапазоне [1, 5], которые делятся на 6, это [], num2 — сумма этих целых чисел = 0.
Мы возвращаем 15 - 0 = 15 в качестве ответа.

Пример 3:

Вход: n = 5, m = 1
Выход: -15
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 1, равны [], num1 — сумма этих целых чисел = 0.
- Целые числа в диапазоне [1, 5], которые делятся на 1, равны [1,2,3,4,5], num2 — сумма этих целых чисел = 15.
Мы возвращаем 0 - 15 = -15 в качестве ответа.

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

1 <= n, m <= 1000

Даны положительные целые числа n и m.
Определите два целых числа, num1 и num2, следующим образом:

num1: Сумма всех целых чисел в диапазоне [1, n], которые не делятся на m.
num2: Сумма всех целых чисел в диапазоне [1, n], которые делятся на m.

Верните целое число num1 - num2.

Пример 1:

Ввод: n = 10, m = 3
Вывод: 19
Объяснение: В данном примере:
- Целые числа в диапазоне [1, 10], которые не делятся на 3: [1,2,4,5,7,8,10], num1 — сумма этих чисел = 37.
- Целые числа в диапазоне [1, 10], которые делятся на 3: [3,6,9], num2 — сумма этих чисел = 18.
Мы возвращаем 37 - 18 = 19 как ответ.

Пример 2:

Ввод: n = 5, m = 6
Вывод: 15
Объяснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 6: [1,2,3,4,5], num1 — сумма этих чисел = 15.
- Целые числа в диапазоне [1, 5], которые делятся на 6: [], num2 — сумма этих чисел = 0.
Мы возвращаем 15 - 0 = 15 как ответ.

Пример 3:

Ввод: n = 5, m = 1
Вывод: -15
Объяснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 1: [], num1 — сумма этих чисел = 0.
- Целые числа в диапазоне [1, 5], которые делятся на 1: [1,2,3,4,5], num2 — сумма этих чисел = 15.
Мы возвращаем 0 - 15 = -15 как ответ.

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

1 <= n, m <= 1000

Вам даны целые положительные числа n и m.
Определите два целых числа, num1 и num2, следующим образом:

num1: сумма всех целых чисел в диапазоне [1, n], которые не делятся на m.
num2: сумма всех целых чисел в диапазоне [1, n], которые делятся на m.

Верните целое число num1 - num2.

Пример 1:

Ввод: n = 10, m = 3
Вывод: 19
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 10], которые не делятся на 3 это [1,2,4,5,7,8,10], число1 это сумма этих целых чисел = 37.
- Целые числа в диапазоне [1, 10], которые делятся на 3 это [3,6,9], num2 это сумма этих целых чисел = 18.
В качестве ответа возвращаем 37 - 18 = 19.

Пример 2:

Ввод: n = 5, m = 6
Вывод: 15
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 6 это [1,2,3,4,5], num1 это сумма этих целых чисел = 15.
- Целые числа в диапазоне [1, 5], которые делятся на 6 равны [], num2 это сумма этих целых чисел = 0.
В качестве ответа мы возвращаем 15 - 0 = 15.

Пример 3:

Ввод: n = 5, m = 1
Вывод: -15
Пояснение: В данном примере:
- Целые числа в диапазоне [1, 5], которые не делятся на 1 равны [], num1 это сумма этих целых чисел = 0.
- Целые числа в диапазоне [1, 5], которые делятся на 1 это [1,2,3,4,5], num2 это сумма этих целых чисел = 15.
В качестве ответа мы возвращаем 0 - 15 = -15.

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

1 <= n, m <= 1000


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

Каждая подстрока имеет четную длину.
Каждая подстрока содержит только 1 или только 0.

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

Пример 1:

Вход: s = "1001"
Выход: 2
Объяснение: мы меняем s[1] на 1 и s[3] на 0, чтобы получить строку "1100".
Можно увидеть, что строка "1100" красива, потому что мы можем разбить ее на "11|00".
Можно доказать, что 2 — это минимальное количество изменений, необходимых для того, чтобы сделать строку красивой.

Пример 2:

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

Пример 3:

Вход: s = "0000"
Выход: 0
Пояснение: нам не нужно вносить никаких изменений, так как строка "0000" уже красива.

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

2 <= s.length <= 10^5
s имеет четную длину.
s[i] — это либо '0', либо '1'.

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

Каждая подстрока имеет чётную длину.
Каждая подстрока содержит только 1 или только 0.

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

Пример 1:

Input: s = "1001"
Output: 2
Объяснение: Мы меняем s[1] на 1 и s[3] на 0, чтобы получить строку "1100".
Видно, что строка "1100" красива, потому что мы можем разделить её на "11|00".
Можно доказать, что 2 это минимальное количество изменений, необходимых для того, чтобы сделать строку красивой.

Пример 2:

Input: s = "10"
Output: 1
Объяснение: Мы меняем s[1] на 1, чтобы получить строку "11".
Можно видеть, что строка "11" красива, потому что мы можем разделить её на "11".
Можно доказать, что 1 это минимальное количество изменений, необходимых для того, чтобы сделать струну красивой.

Пример 3:

Input: s = "0000"
Output: 0
Объяснение: Нам не нужно делать никаких изменений, так как строка "0000" уже красива.

Constraints:

2 <= s.length <= 10^5
s has an even length.
s[i] is either '0' or '1'.

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

Каждая подстрока имеет четную длину.
Каждая подстрока содержит только 1 или только 0.

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

Пример 1:

Ввод: s = "1001"
Вывод: 2
Объяснение: Мы изменяем s[1] на 1 и s[3] на 0, получая строку "1100".
Видно, что строка "1100" красивая, так как мы можем разделить ее на "11|00".
Можно доказать, что 2 — это минимальное количество изменений, необходимых для того, чтобы сделать строку красивой.

Example 2:

Пример 2:

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

Пример 3:

Ввод: s = "0000"
Вывод: 0
Объяснение: Нам не нужно вносить изменения, так как строка "0000" уже красивая.

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

2 <= s.length <= 10^5
s has an even length.
s[i] is either '0' or '1'.


Дан массив целых чисел nums с 0-индексацией. Триплет индексов (i, j, k) является горой, если:

i < j < k
nums[i] < nums[j] и nums[k] < nums[j]

Верните минимально возможную сумму триплета горы из nums. Если такого триплета не существует, верните -1.

Пример 1:

Input: nums = [8,6,1,5,3]
Output: 9
Пояснение: Триплет (2, 3, 4) является триплетом горы с суммой 9, поскольку:
- 2 < 3 < 4
- nums[2] < nums[3] и nums[4] < nums[3]
И сумма этого триплета равна nums[2] + nums[3] + nums[4] = 9. Можно показать, что нет триплетов гор с суммой меньше 9.

Пример 2:

Input: nums = [5,4,8,7,10,2]
Output: 13
Пояснение: Триплет (1, 3, 5) является триплетом горы с суммой 13, поскольку:
- 1 < 3 < 5
- nums[1] < nums[3] и nums[5] < nums[3]
И сумма этого триплета равна nums[1] + nums[3] + nums[5] = 13. Можно показать, что нет триплетов гор с суммой меньше 13.

Пример 3:

Input: nums = [6,5,4,3,4,5]
Output: -1
Пояснение: Можно показать, что в nums нет триплетов гор.

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

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

Вам дан массив целых чисел с 0-индексом.
Тройка индексов (i, j, k) является горой, если:

i < j < k
nums[i] < nums[j] и nums[k] < nums[j]

Вернуть минимально возможную сумму горной тройки чисел. Если такой тройки не существует, верните -1.

Пример 1:

Ввод: числа = [8,6,1,5,3]
Вывод: 9
Пояснение: Тройка (2, 3, 4) является горной тройкой суммы 9 поскольку:
- 2 < 3 < 4
- nums[2] < nums[3] и nums[4] < nums[3]
А сумма этой тройки равна nums[2] + nums[3] + nums[4] = 9. Можно показать, что не существует горных троек с суммой меньше 9.

Пример 2:

Ввод: nums = [5,4,8,7,10,2]
Вывод: 13
Пояснение: Тройка (1, 3, 5) является горной тройкой суммы 13 поскольку:
- 1 < 3 < 5
- nums[1] < nums[3] и nums[5] < nums[3]
А сумма этой тройки равна nums[1] + nums[3] + nums[5] = 13. Можно показать, что не существует горных троек с суммой меньше 13.

Пример 3:

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

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

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

Вам дан 0-индексированный массив nums целых чисел.
Триплет индексов (i, j, k) является горой, если:

i < j < k
nums[i] < nums[j] и nums[k] < nums[j]

Вернуть минимально возможную сумму триплета гор nums. Если такого триплета не существует, вернуть -1.

Пример 1:

Вход: nums = [8,6,1,5,3]
Выход: 9
Объяснение: Триплет (2, 3, 4) — это триплет гор с суммой 9, так как:
- 2 < 3 < 4
- nums[2] < nums[3] и nums[4] < nums[3]
И сумма этого триплета равна nums[2] + nums[3] + nums[4] = 9. Можно показать, что нет триплетов гор с суммой меньше 9.

Пример 2:

Вход: nums = [5,4,8,7,10,2]
Выход: 13
Объяснение: Триплет (1, 3, 5) — это триплет гор с суммой 13, так как:
- 1 < 3 < 5
- nums[1] < nums[3] и nums[5] < nums[3]
И сумма этого триплета равна nums[1] + nums[3] + nums[5] = 13. Можно показать, что нет триплетов гор с суммой меньше 13.

Пример 3:

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

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

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


Дан целочисленный массив nums с индексацией от 0 и целое число k.
K-or от nums — это неотрицательное целое число, удовлетворяющее следующему условию:

i-й бит установлен в K-or, если и только если есть как минимум k элементов в nums, в которых установлен бит i.

Верните K-or от nums.
Заметьте, что бит i установлен в x, если (2^i И x) == 2^i, где И — это побитовое И.

Пример 1:

Ввод: nums = [7,12,9,8,9,15], k = 4
Вывод: 9
Объяснение: Бит 0 установлен в nums[0], nums[2], nums[4] и nums[5].
Бит 1 установлен в nums[0] и nums[5].
Бит 2 установлен в nums[0], nums[1] и nums[5].
Бит 3 установлен в nums[1], nums[2], nums[3], nums[4] и nums[5].
Только биты 0 и 3 установлены в как минимум k элементах массива, и биты i >= 4 не установлены ни в одном из элементов массива. Следовательно, ответ — это 2^0 + 2^3 = 9.

Пример 2:

Ввод: nums = [2,12,1,11,4,5], k = 6
Вывод: 0
Объяснение: Поскольку k == 6 == nums.length, 6-ор массива равен побитовому И всех его элементов. Следовательно, ответ — 2 И 12 И 1 И 11 И 4 И 5 = 0.

Пример 3:

Ввод: nums = [10,8,5,9,11,6,8], k = 1
Вывод: 15
Объяснение: Поскольку k == 1, 1-ор массива равен побитовому ИЛИ всех его элементов. Следовательно, ответ — 10 ИЛИ 8 ИЛИ 5 ИЛИ 9 ИЛИ 11 ИЛИ 6 ИЛИ 8 = 15.

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

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Дан целочисленный массив nums с индексацией от 0 и целое число k.
K-or от nums — это неотрицательное целое число, удовлетворяющее следующему условию:

i-й бит установлен в K-or, если и только если есть как минимум k элементов в nums, в которых установлен бит i.

Верните K-or от nums.
Заметьте, что бит i установлен в x, если (2^i И x) == 2^i, где И — это побитовое И.

Пример 1:

Input: nums = [7,12,9,8,9,15], k = 4
Output: 9
Объяснение: Бит 0 установлен в nums[0], nums[2], nums[4] и nums[5].
Бит 1 установлен в nums[0] и nums[5].
Бит 2 установлен в nums[0], nums[1] и nums[5].
Бит 3 установлен в nums[1], nums[2], nums[3], nums[4] и nums[5].
Только биты 0 и 3 установлены в как минимум k элементах массива, и биты i >= 4 не установлены ни в одном из элементов массива. Следовательно, ответ — это 2^0 + 2^3 = 9.

Пример 2:

Input: nums = [2,12,1,11,4,5], k = 6
Output: 0
Объяснение: Поскольку k == 6 == nums.length, 6-ор массива равен побитовому И всех его элементов. Следовательно, ответ — 2 И 12 И 1 И 11 И 4 И 5 = 0.

Пример 3:

Input: nums = [10,8,5,9,11,6,8], k = 1
Output: 15
Объяснение: Поскольку k == 1, 1-ор массива равен побитовому ИЛИ всех его элементов. Следовательно, ответ — 10 ИЛИ 8 ИЛИ 5 ИЛИ 9 ИЛИ 11 ИЛИ 6 ИЛИ 8 = 15.

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

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Вам дан 0-индексированный целочисленный массив nums и целое число k.
K-or для nums — это неотрицательное целое число, которое удовлетворяет следующему:

i^th бит устанавливается в K-or тогда и только тогда, когда есть по крайней мере k элементов nums, в которых установлен бит i.

Верните K-or для nums.
Обратите внимание, что бит i устанавливается в x, если (2^i AND x) == 2^i, где AND — побитовый оператор AND.

Пример 1:

Вход: nums = [7,12,9,8,9,15], k = 4
Выход: 9
Объяснение: Бит 0 устанавливается в nums[0], nums[2], nums[4] и nums[5].
Бит 1 устанавливается в nums[0] и nums[5].
Бит 2 установлен в nums[0], nums[1] и nums[5].
Бит 3 установлен в nums[1], nums[2], nums[3], nums[4] и nums[5].
Только биты 0 и 3 установлены как минимум в k элементах массива, а биты i >= 4 не установлены ни в одном из элементов массива. Следовательно, ответ 2^0 + 2^3 = 9.

Пример 2:

Вход: nums = [2,12,1,11,4,5], k = 6
Выход: 0
Пояснение: Поскольку k == 6 == nums.length, 6-ИЛИ массива равно побитовому И всех его элементов. Следовательно, ответ 2 И 12 И 1 И 11 И 4 И 5 = 0.

Пример 3:

Вход: nums = [10,8,5,9,11,6,8], k = 1
Выход: 15
Пояснение: Поскольку k == 1, 1-ИЛИ массива равно побитовому ИЛИ всех его элементов. Следовательно, ответ 10 ИЛИ 8 ИЛИ 5 ИЛИ 9 ИЛИ 11 ИЛИ 6 ИЛИ 8 = 15.

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

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length


Дан массив целых чисел nums с 0-й индексацией.
Подпоследовательность nums длины k, состоящая из индексов i_0 < i_1 < ... < i_k-1 является сбалансированной, если выполняется следующее:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, для каждого j в диапазоне [1, k - 1].

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

Пример 1:

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

Вход: nums = [5,-1,-3,8]
Выход: 13
Explanation: Объяснение: В этом примере можно выбрать подпоследовательность [5,8], состоящую из индексов 0 и 3.
nums[3] - nums[0] >= 3 - 0.
Следовательно, это сбалансированная подпоследовательность, и ее сумма является максимальной среди сбалансированных подпоследовательностей nums.
Можно показать, что создать сбалансированную подпоследовательность с суммой больше 13 невозможно.

Пример 3:

Вход: nums = [-2,-1]
Выход: -1
Объяснение: В этом примере можно выбрать подпоследовательность [-1].
Это сбалансированная подпоследовательность, и ее сумма является максимальной среди сбалансированных подпоследовательностей nums.

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

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

Дан массив целых чисел nums с 0-й индексацией.
Подпоследовательность nums длины k, состоящая из индексов i_0 < i_1 < ... < i_k-1, является сбалансированной, если выполняется следующее:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, для каждого j в диапазоне [1, k - 1].

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

Пример 1:

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

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

Пример 3:

Вход: nums = [-2,-1] Выход: -1 Объяснение: В этом примере можно выбрать подпоследовательность [-1]. Это сбалансированная подпоследовательность, и ее сумма является максимальной среди сбалансированных подпоследовательностей nums.

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

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


В турнире участвуют n команд, пронумерованных от 0 до n - 1.
Дана 0-индексированная булева матрица grid размером n * n. Для всех i, j, где 0 <= i, j <= n - 1 и i != j, команда i сильнее команды j, если grid[i][j] == 1, в противном случае, команда j сильнее команды i.
Команда a станет чемпионом турнира, если не существует команды b, которая сильнее команды a.
Верните команду, которая станет чемпионом турнира.

Пример 1:

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

Пример 2:

Ввод: grid = [[0,0,1],[1,0,1],[0,0,0]]
Вывод: 1
Объяснение: В этом турнире три команды.
grid[1][0] == 1 означает, что команда 1 сильнее команды 0.
grid[1][2] == 1 означает, что команда 1 сильнее команды 2.
Поэтому команда 1 станет чемпионом.

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

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] является либо 0, либо 1.
Для всех i grid[i][i] равен 0.
Для всех i, j, где i != j, grid[i][j] != grid[j][i].
Входные данные генерируются так, что если команда a сильнее команды b и команда b сильнее команды c, тогда команда a сильнее команды c.

В турнире есть n команд с номерами от 0 до n - 1.
Дана 0-индексированная 2D булевская матричная сетка размером n * n. Для всех i, j что 0 <= i, j <= n - 1 и i != j команда i сильнее команды j if grid[i][j] == 1, в противном случае команда j сильнее команды i.
Команда А станет чемпионом турнира, если в ней нет команды Б, которая сильнее команды А.
Выведите команду, которая станет чемпионом турнира.

Пример 1:

Input: grid = [[0,1],[0,0]]
Output: 0
Объяснение: В этом турнире участвуют две команды.
grid[0][1] == 1 означает, что команда 0 сильнее команды 1. Таким образом, команда 0 станет чемпионом.

Пример 2:

Input: grid = [[0,0,1],[1,0,1],[0,0,0]]
Output: 1
Объяснение: В этом турнире участвуют три команды.
grid[1][0] == 1 означает, что команда 1 сильнее команды 0.
grid[1][2] == 1 означает, что команда 1 сильнее команды 2.
Таким образом, команда 1 станет чемпионом.

Constraints:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] is either 0 or 1.
For all i grid[i][i] is 0.
For all i, j that i != j, grid[i][j] != grid[j][i].
The input is generated such that if team a is stronger than team b and team b is stronger than team c, then team a is stronger than team c.


Даны два целочисленных массива с нулевой индексацией, nums1 и nums2, оба длины n. Вам разрешено выполнить серию операций (возможно, никаких). В одной операции вы выбираете индекс i в диапазоне [0, n - 1] и меняете местами значения nums1[i] и nums2[i]. Ваша задача — найти минимальное количество операций, необходимых для выполнения следующих условий:

nums1[n - 1] равен максимальному значению среди всех элементов nums1, т.е., nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] равен максимальному значению среди всех элементов nums2, т.е., nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

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

Пример 1:

Input: nums1 = [1,2,7], nums2 = [4,5,3]
Output: 1
Пояснение: В этом примере можно выполнить операцию, используя индекс i = 2.
Когда nums1[2] и nums2[2] меняются местами, nums1 становится [1,2,3], а nums2 становится [4,5,7].
Оба условия теперь выполнены.
Показывается, что минимальное количество операций необходимо 1.
Так что ответ - 1.

Пример 2:

Input: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Output: 2
Пояснение: В этом примере можно выполнить следующие операции:
Первая операция с использованием индекса i = 4.
Когда nums1[4] и nums2[4] меняются местами, nums1 становится [2,3,4,5,4], а nums2 становится [8,8,4,4,9].
Еще одна операция с использованием индекса i = 3.
Когда nums1[3] и nums2[3] меняются местами, nums1 становится [2,3,4,4,4], а nums2 становится [8,8,4,5,9].
Оба условия теперь выполнены.
Показывается, что минимальное количество операций необходимо 2.
Так что ответ - 2.

Пример 3:

Input: nums1 = [1,5,4], nums2 = [2,5,3]
Output: -1
Пояснение: В этом примере невозможно выполнить оба условия.
Так что ответ - -1.

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

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Вам даны два целочисленных массива с нулевым индексом, nums1 и nums2, оба имеют длину n.
Вам разрешено выполнить ряд операций (возможно, ни одной).
В операции вы выбираете индекс i в диапазоне [0, n - 1] и меняете местами значения nums1[i] и nums2[i].
Ваша задача — найти минимальное количество операций, необходимое для выполнения следующих условий:

nums1[n - 1] равно максимальному значению среди всех элементов nums1, т.е. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] равно максимальному значению среди всех элементов nums2, т.е. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

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

Пример 1:

Ввод: nums1 = [1,2,7], nums2 = [4,5,3]
Выход: 1
Объяснение: В этом примере операцию можно выполнить с индексом i = 2.
Когда nums1[2] и nums2[2] меняются местами, nums1 становится [1,2,3], а nums2 становится [4,5,7].
Оба условия теперь удовлетворены.
Можно показать, что минимальное количество операций, которые необходимо выполнить, равно 1.
Итак, ответ 1.

Пример 2:

Ввод: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Выход: 2
Объяснение: В этом примере можно выполнить следующие операции:
Первая операция с индексом i = 4.
Когда nums1[4] и nums2[4] меняются местами, nums1 становится [2,3,4,5,4], а nums2 становится [8,8,4,4,9].
Еще одна операция с индексом i = 3.
Когда nums1[3] и nums2[3] меняются местами, nums1 становится [2,3,4,4,4], а nums2 становится [8,8,4,5,9].
Оба условия теперь удовлетворены.
Можно показать, что минимальное количество операций, которые необходимо выполнить, равно 2.
Итак, ответ 2.

Пример 3:

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

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

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10%9
1 <= nums2[i] <= 10%9


Даны три целых числа a, b и n. Вернуть максимальное значение (a XOR x) * (b XOR x), где 0 <= x < 2^n.
Поскольку ответ может быть слишком большим, вернуть его по модулю 10^9 + 7.
Обратите внимание, что XOR — это побитовая операция XOR.

Пример 1:

Ввод: a = 12, b = 5, n = 4
Вывод: 98
Пояснение: Для x = 2, (a XOR x) = 14 и (b XOR x) = 7. Таким образом, (a XOR x) * (b XOR x) = 98.
Можно показать, что 98 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

Пример 2:

Ввод: a = 6, b = 7 , n = 5
Вывод: 930
Пояснение: Для x = 25, (a XOR x) = 31 и (b XOR x) = 30. Таким образом, (a XOR x) * (b XOR x) = 930.
Можно показать, что 930 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.
Пример 3:

Ввод: a = 1, b = 6, n = 3
Вывод: 12
Пояснение: Для x = 5, (a XOR x) = 4 и (b XOR x) = 3. Таким образом, (a XOR x) * (b XOR x) = 12.
Можно показать, что 12 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

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

0 <= a, b < 2^50
0 <= n <= 50

Учитывая три целых числа a, b, и n, верните максимальное значение (a XOR x) * (b XOR x) where 0 <= x < 2^n.
Поскольку ответ может быть слишком большим, верните его по модулю 10^9 + 7.
Обратите внимание, что XOR это побитовая операция XOR.

Пример 1:

Ввод: a = 12, b = 5, n = 4
Вывод: 98
Пояснение: Для x = 2, (a XOR x) = 14 и (b XOR x) = 7. Следовательно, (a XOR x) * (b XOR x) = 98.
Можно показать, что 98 — это максимальное значение (a XOR x) * (b XOR x) для всехl 0 <= x < 2^n

Пример 2:

Ввод: a = 6, b = 7 , n = 5
Вывод: 930
Пояснение: Для x = 25, (a XOR x) = 31 и (b XOR x) = 30. Следовательно, (a XOR x) * (b XOR x) = 930.
Можно показать, что 930 это максимальное значение (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.
Пример 3:

Ввод: a = 1, b = 6, n = 3
Вывод: 12
Пояснение: Для x = 5, (a XOR x) = 4 и (b XOR x) = 3. Следовательно, (a XOR x) * (b XOR x) = 12.
Можно показать, что 12 — это максимальное значение (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

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

0 <= a, b < 2^50
0 <= n <= 50

Даны три целых числа a, b и n. Вернуть максимальное значение (a XOR x) * (b XOR x), где 0 <= x < 2^n.
Поскольку ответ может быть слишком большим, вернуть его по модулю 10^9 + 7.
Обратите внимание, что XOR — это побитовая операция XOR.

Пример 1:

Input: a = 12, b = 5, n = 4
Output: 98
Пояснение: Для x = 2, (a XOR x) = 14 и (b XOR x) = 7. Таким образом, (a XOR x) * (b XOR x) = 98.
Можно показать, что 98 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

Пример 2:

Input: a = 6, b = 7, n = 5
Output: 930
Пояснение: Для x = 25, (a XOR x) = 31 и (b XOR x) = 30. Таким образом, (a XOR x) * (b XOR x) = 930.
Можно показать, что 930 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

Пример 3:

Input: a = 1, b = 6, n = 3
Output: 12
Пояснение: Для x = 5, (a XOR x) = 4 и (b XOR x) = 3. Таким образом, (a XOR x) * (b XOR x) = 12.
Можно показать, что 12 является максимальным значением (a XOR x) * (b XOR x) для всех 0 <= x < 2^n.

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

0 <= a, b < 2^50
0 <= n <= 50


Дан целочисленный массив nums с индексированием с нуля. Пара чисел x и y называется сильной парой, если выполняется условие:

|x - y| <= min(x, y)

Вам нужно выбрать два числа из nums так, чтобы они образовали сильную пару и их побитовое XOR было максимальным среди всех сильных пар в массиве.
Верните максимальное значение XOR из всех возможных сильных пар в массиве nums.
Обратите внимание, что вы можете выбрать одно и то же число дважды, чтобы сформировать пару.

Пример 1:

Ввод: nums = [1,2,3,4,5]
Вывод: 7
Объяснение: Есть 11 сильных пар в массиве nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) и (5, 5).
Максимальный возможный XOR из этих пар — 3 XOR 4 = 7.

Пример 2:

Ввод: nums = [10,100]
Вывод: 0
Объяснение: Есть 2 сильные пары в массиве nums: (10, 10) и (100, 100).
Максимальный возможный XOR из этих пар — 10 XOR 10 = 0, поскольку пара (100, 100) также дает 100 XOR 100 = 0.

Пример 3:

Ввод: nums = [5,6,25,30]
Вывод: 7
Объяснение: Есть 6 сильных пар в массиве nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) и (30, 30).
Максимальный возможный XOR из этих пар — 25 XOR 30 = 7, поскольку другой единственный ненулевой XOR равен 5 XOR 6 = 3.

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

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

Вам дают 0-индексированный целочисленный массив. Пара целых чисел x и y называется сильной парой, если она удовлетворяет условию:

|x - y| <= min(x, y)

Вам необходимо выбрать два целых числа из массива nums, чтобы они образовали сильную пару, их побитовое XOR - максимум среди всех сильных пар в массиве.
Верните максимальное значение XOR из всех возможных сильных пар в массивах.
Обратите внимание, что вы можете выбрать одно и то же целое число дважды, чтобы сформировать пару.

Пример 1:

Ввод: nums = [1,2,3,4,5]
Вывод: 7
Объяснение: В массиве есть 11 сильных пар: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3 , 4), (3, 5), (4, 4), (4, 5) и (5, 5).
Максимальный XOR, возможный из этих пар, составляет 3 XOR 4 = 7.

Пример 2:

Ввод: nums = [10,100]
Вывод: 0
Объяснение: В массиве есть 2 сильные nums: (10, 10) и (100, 100).
Максимальный XOR, возможный из этих пар, составляет 10 XOR 10 = 0, поскольку пара (100, 100) также дает 100 XOR 100 = 0.

Пример 3:

Ввод: nums = [5,6,25,30]
Вывод: 7
Объяснение: В массиве есть 6 сильных пар: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) и (30, 30).
Максимальный XOR, возможный из этих пар, составляет 25 XOR 30 = 7, поскольку единственное другое ненулевое значение XOR составляет 5 XOR 6 = 3.

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

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

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

|x - y| <= min(x, y)

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

Пример 1:

Вход: nums = [1,2,3,4,5]
Выход: 7
Пояснение: В массиве nums 11 сильных пар: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) и (5, 5).
Максимально возможный XOR из этих пар — 3 XOR 4 = 7.

Пример 2:

Вход: nums = [10,100]
Выход: 0
Пояснение: В массиве nums 2 сильные пары: (10, 10) и (100, 100).
Максимально возможное XOR из этих пар — 10 XOR 10 = 0, так как пара (100, 100) также дает 100 XOR 100 = 0.

Пример 3:

Вход: nums = [5,6,25,30]
Выход: 7
Пояснение: в массиве nums есть 6 сильных пар: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) и (30, 30).
Максимально возможное XOR из этих пар — 25 XOR 30 = 7, так как единственное другое ненулевое значение XOR — 5 XOR 6 = 3.

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

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


Вам дан 0-индексированный массив строк words и символ x.
Верните массив индексов, представляющих слова, содержащие символ x.
Обратите внимание, что возвращаемый массив может быть в любом порядке.

Пример 1:

Входные данные: words = ["leet","code"], x = "e"
Выходные данные: [0,1]
Пояснение: "e" встречается в обоих словах: "leet" и "code". Следовательно, мы возвращаем индексы 0 и 1.

Пример 2:

Входные данные: words = ["abc","bcd","aaaa","cbc"], x = "a"
Выходные данные: [0,2]
Пояснение: "a" встречается в "abc" и "aaaa". Следовательно, мы возвращаем индексы 0 и 2.

Пример 3:

Вход: words = ["abc","bcd","aaaa","cbc"], x = "z"
Выход: []
Пояснение: "z" не встречается ни в одном из слов. Следовательно, мы возвращаем пустой массив.

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

1 <= words.length <= 50
1 <= words[i].length <= 50
x — строчная Английская буква.
words[i] состоит только из строчных Английских букв.

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

Пример 1:

Ввод: слова = ["leet","code"], x = "e"
Выход: [0,1]
Пояснение: "e" означает как "leet", так и "code". Таким образом, мы возвращаем индексы 0 и 1.

Пример 2:

Ввод: words = ["abc","bcd","aaaa","cbc"], x = "a"
Выход: [0,2]
Объяснение: "a" встречается в "abc" и "aaaa". Таким образом, мы возвращаем индексы 0 и 2.

Пример 3:

Ввод: words = ["abc","bcd","aaaa","cbc"], x = "z"
Выход: []
Объяснение: "z" не встречается ни в одном из слов. Таким образом, мы возвращаем пустой массив.

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

1 <= words.length <= 50
1 <= words[i].length <= 50
x — это строчная английская буква.
Слова [i] состоят только из строчных английских букв.

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

Пример 1:

Ввод: words = ["leet", "code"], x = "e"
Вывод: [0,1]
Объяснение: «e» встречается в обоих словах: «Leet» и «Code». Следовательно, мы возвращаем индексы 0 и 1.

Пример 2:

Ввод:words = ["abc","bcd","aaaa","cbc"], x = "a"
Вывод: [0,2]
Объяснение: "a" встречается в "abc" и "aaaa". Поэтому мы возвращаем индексы 0 и 2.

Пример 3:

Ввод: words = ["abc","bcd","aaaa","cbc"], x = "z"
Вывод: []
Объяснение: "z" не происходит ни в одном из слов. Следовательно, мы возвращаем пустой массив.

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

1 <= words.length <= 50
1 <= words[i].length <= 50
x — это строчная буква английского алфавита.
words[i] состоят только из строчных английских букв.


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

Пример 1:

Вход: s = "101"
Выход: 1
Пояснение: Мы можем сгруппировать все черные шары справа следующим образом:
- Поменять местами s[0] и s[1], s = "011".
Изначально единицы не сгруппированы вместе, требуется как минимум 1 шаг, чтобы сгруппировать их справа.
Пример 2:

Вход: s = "100"
Выход: 2
Пояснение: Мы можем сгруппировать все черные шары справа следующим образом:
- Поменять местами s[0] и s[1], s = "010".
- Поменять местами s[1] и s[2], s = "001".
Можно доказать, что минимальное количество необходимых шагов равно 2.

Пример 3:

Вход: s = "0111"
Выход: 0
Пояснение: Все черные шары уже сгруппированы справа.

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

1 <= n == s.length <= 10^5
s[i] равно либо '0', либо '1'.

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

Пример 1:

Ввод: s = "101"
Вывод: 1
Пояснение: Мы можем сгруппировать все черные шары справа следующим образом:
- Поменять местами s[0] и s[1], s = "011".
Изначально 1 были не сгруппированы вместе, требуется как минимум 1 шаг, чтобы сгруппировать их справа.

Пример 2:

Ввод: s = "100"
Вывод: 2
Пояснение: Мы можем сгруппировать все черные шары справа следующим образом:
- Поменять местами s[0] и s[1], s = "010".
- Поменять местами s[1] и s[2], s = "001".
Можно доказать, что минимальное количество необходимых шагов равно 2.

Пример 3:

Ввод: s = "0111"
Вывод: 0
Пояснение: Все черные шары уже сгруппированы справа.

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

1 <= n == s.length <= 10^5
s[i] либо '0', либо '1'.

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

Пример 1:

Ввод: с = "101"
Вывод: 1
Пояснение: Мы можем сгруппировать все черные шары вправо следующим образом:
- Поменяйте местами s[0] и s[1], s = "011".
Изначально единицы не группируются, поэтому для их группировки вправо требуется как минимум 1 шаг.
Пример 2:

Ввод: с = "100"
Вывод: 2
Пояснение: Мы можем сгруппировать все чёрные шары вправо следующим образом:
- Поменяйте местами s[0] и s[1], s = "010".
- Поменяйте местами s[1] и s[2], s = "001".
Можно доказать, что минимально необходимое количество шагов равно 2.

Пример 3:

Ввод: s = "0111"
Вывод: 0
Пояснение: Все чёрные шары уже сгруппированы справа.

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

1 <= n == s.length <= 10^5
s[i] is either '0' или '1'.


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

Выберите любой индекс i из массива и увеличьте или уменьшите nums[i] на 1.

Очки финального массива — это частота самого часто встречаемого элемента в массиве.
Верните максимальные очки, которые вы можете получить.
Частота элемента — это количество его вхождений в массив.

Пример 1:

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

Пример 2:

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

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

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

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

Выберите любой индекс i из массива и увеличьте или уменьшите nums[i] на 1.

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

Пример 1:

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

Пример 2:

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

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

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

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

Выберите любой индекс i из массива и увеличьте или уменьшите nums[i] на 1.

Очки финального массива — это частота самого часто встречаемого элемента в массиве.
Верните максимальные очки, которые вы можете получить.
Частота элемента — это количество его вхождений в массив.

Пример1:

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

Пример 2:

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

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

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


Даны два положительных целых числа n и limit. Верните общее количество способов распределить n конфет между 3 детьми так, чтобы ни один из детей не получил больше чем limit конфет.

Пример 1:

Ввод: n = 5, limit = 2
Вывод: 3
Объяснение: Существует 3 способа распределить 5 конфет так, чтобы ни один ребенок не получил больше чем 2 конфеты: (1, 2, 2), (2, 1, 2) и (2, 2, 1).

Пример 2:

Ввод: n = 3, limit = 3
Вывод: 10
Объяснение: Существует 10 способов распределить 3 конфеты так, чтобы ни один ребенок не получил больше чем 3 конфеты: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) и (3, 0, 0).

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

1 <= n <= 50
1 <= limit <= 50

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

Пример 1:

Ввод: n = 5, предел = 2
Вывод: 3
Объяснение: Есть 3 способа распределения 5 конфет, так что ни один ребенок не получает более 2 конфет: (1, 2, 2), (2, 1, 2) и (2, 2, 1).

Пример 2:

Ввод: n = 3, предел = 3
Вывод: 10
Объяснение: Есть 10 способов распределения 3 конфет, так что ни один ребенок не получает более 3 конфет: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0 ), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) и (3, 0, 0).

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

1 <= n <= 50
1 <= limit  <= 50

Вам даны два положительных целых числа n и limit.
Верните общее количество способов распределить n конфет среди 3 детей так, чтобы ни один ребенок не получил больше limit конфет.

Пример 1:

Вход: n = 5, limit = 2
Выход: 3
Объяснение: Существует 3 способа распределить 5 конфет так, чтобы ни один ребенок не получил больше 2 конфет: (1, 2, 2), (2, 1, 2) и (2, 2, 1).

Пример 2:

Вход: n = 3, limit = 3
Выход: 10
Объяснение: существует 10 способов распределить 3 конфеты так, чтобы ни один ребенок не получил больше 3 конфет: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) и (3, 0, 0).

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

1 <= n <= 50
1 <= limit <= 50


Вам дано целое число n.
Строка s называется хорошей, если она содержит только строчные английские буквы и можно переставить символы s так, чтобы новая строка содержала "leet" как подстроку.
Например:

Строка "lteer" является хорошей, потому что её можно переставить, чтобы сформировать "leetr".
"letl" не является хорошей, так как её нельзя переставить, чтобы она содержала "leet" как подстроку.

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

Пример 1:

Ввод: n = 4
Вывод: 12
Объяснение: 12 строк, которые можно переставить, чтобы иметь "leet" в качестве подстроки: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" и "tlee".

Пример 2:

Ввод: n = 10
Вывод: 83943898
Объяснение: Количество строк длины 10, которые можно переставить, чтобы иметь "leet" в качестве подстроки, составляет 526083947580. Следовательно, ответ равен 526083947580 % (10^9 + 7) = 83943898.

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

1 <= n <= 10^5

Вам дано целое число n.
Строка s называется хорошей, если она содержит только строчные английские символы и возможно переставить символы s так, чтобы новая строка содержала «leet» в качестве подстроки.
Например:

Строка «lteer» хороша, потому что мы можем переставить ее так, чтобы она образовала «leetr».
«letl» не хороша, потому что мы не можем переставить ее так, чтобы она содержала «leet» в качестве подстроки.

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

Пример 1:

Вход: n = 4
Выход: 12
Пояснение: 12 строк, которые можно переставить так, чтобы в качестве подстроки было "leet": "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" и "tlee".

Пример 2:

Вход: n = 10
Выход: 83943898
Пояснение: Количество строк длиной 10, которые можно переставить так, чтобы в качестве подстроки было "leet", составляет 526083947580. Следовательно, ответ: 526083947580 % (10^9 + 7) = 83943898.

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

1 <= n <= 10^5

Вам дано целое число n.
Строка s называется хорошей, если она содержит только строчные Английские символы и можно переставить символы s так, чтобы новая строка содержала слово "leet" в качестве подстроки.
Например:

Строка "lteer" хороша тем, что мы можем преобразовать ее в "leetr".
"letl" не подходит, потому что мы не можем переставить его так, чтобы он содержал "leet" в качестве подстроки.

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

Пример 1:

Вход: n = 4
Выход: 12
Пояснение: 12 строк, которые можно переставить так, чтобы в качестве подстроки было слово: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele", и "tlee".

Пример 2:

Ввод: n = 10
Выход: 83943898
Пояснение: Число строк длиной 10, которые можно переставить так, чтобы в качестве подстроки было слово "leet", равно 526083947580. Следовательно, ответ: 526083947580 % (10^9 + 7) = 83943898.

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

1 <= п <= 10^5


Дана строка `s` с нулевой индексацией и четной длиной `n`.
Также дан 2D целочисленный массив `queries` с нулевой индексацией, где `queries[i] = [a_i, b_i, c_i, d_i]`.
Для каждого запроса `i` вам разрешено выполнять следующие операции:

- Переставлять символы в подстроке `s[a_i:b_i]`, где `0 <= a_i <= b_i < n / 2`.
- Переставлять символы в подстроке `s[c_i:d_i]`, где `n / 2 <= c_i <= d_i < n`.

Для каждого запроса ваша задача - определить, возможно ли сделать `s` палиндромом, выполняя данные операции.
Каждый запрос обрабатывается независимо от других.
Верните массив `answer` с нулевой индексацией, где `answer[i] == true`, если возможно сделать `s` палиндромом, выполняя операции, указанные в `i`-м запросе, и `false` в противном случае.

Подстрока - это непрерывная последовательность символов в строке.
`s[x:y]` представляет подстроку, состоящую из символов от индекса `x` до индекса `y` в `s`, оба включительно.

Пример 1:

Ввод: `s = "abcabc"`, `queries = [[1,1,3,5],[0,2,5,5]]`
Вывод: `[true,true]`
Объяснение: В этом примере есть два запроса:
В первом запросе:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Таким образом, вам разрешено переставлять `s[1:1]` => `abcabc` и `s[3:5]` => `abcabc`.
- Чтобы сделать `s` палиндромом, `s[3:5]` можно переставить, чтобы получить => `abccba`.
- Теперь `s` - это палиндром. Поэтому, `answer[0] = true`.
Во втором запросе:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Таким образом, вам разрешено переставлять `s[0:2]` => `abcabc` и `s[5:5]` => `abcabc`.
- Чтобы сделать `s` палиндромом, `s[0:2]` можно переставить, чтобы получить => `cbaabc`.
- Теперь `s` - это палиндром. Поэтому, `answer[1] = true`.

Пример 2:

Ввод: `s = "abbcdecbba"`, `queries = [[0,2,7,9]]`
Вывод: `[false]`
Объяснение: В этом примере только один запрос.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Таким образом, вам разрешено переставлять `s[0:2]` => `abbcdecbba` и `s[7:9]` => `abbcdecbba`.
Невозможно сделать `s` палиндромом, переставляя эти подстроки, потому что `s[3:6]` не является палиндромом.
Поэтому, `answer[0] = false`.

Пример 3:

Ввод: `s = "acbcab"`, `queries = [[1,2,4,5]]`
Вывод: `[true]`
Объяснение: В этом примере только один запрос.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Таким образом, вам разрешено переставлять `s[1:2]` => `acbcab` и `s[4:5]` => `acbcab`.
Чтобы сделать `s` палиндромом, `s[1:2]` можно переставить, чтобы получить `abccab`.
Затем, `s[4:5]` можно переставить, чтобы получить `abccba`.
Теперь `s` - это палиндром. Поэтому, `answer[0] = true`.

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

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n четное.
`s` состоит только из строчных английских букв.

Вам дана строка s с индексом 0, имеющая четную длину n.
Вам также дан двумерный целочисленный массив с индексом 0, requests, где requests[i] = [a_i, b_i, c_i, d_i].
Для каждого запроса i вам разрешено выполнять следующие операции:

Переставить символы в подстроке s[a_i:b_i], где 0 <= a_i <= b_i < n / 2.
Переставить символы в подстроке s[c_i:d_i], где n / 2 <= c_i <= d_i < n.

Для каждого запроса ваша задача — определить, можно ли сделать s палиндромом, выполнив операции.
Каждый запрос отвечается независимо от других.
Верните ответ в виде индексированного массива 0, где answer[i] == true, если возможно сделать s палиндромом, выполнив операции, указанные в i^th запросе, и false в противном случае.

Подстрока — это непрерывная последовательность символов в строке.
s[x:y] представляет подстроку, состоящую из символов от индекса x до индекса y в s, оба включительно.

Пример 1:

Входные данные: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Выходные данные: [true,true]
Объяснение: в этом примере есть два запроса:
В первом запросе:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Таким образом, вам разрешено переставить s[1:1] => abcabc и s[3:5] => abcabc.
- Чтобы сделать s палиндромом, s[3:5] можно переставить так, чтобы получилось => abccba.
- Теперь s — палиндром. Поэтому answer[0] = true.
Во втором запросе:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Итак, вам разрешено переставить s[0:2] => abcabc и s[5:5] => abcabc.
- Чтобы сделать s палиндромом, s[0:2] можно переставить так, чтобы получилось => cbaabc.
- Теперь s — палиндром. Поэтому answer[1] = true.

Пример 2:

Вход: s = "abbcdecbba", queries = [[0,2,7,9]]
Выход: [false]
Пояснение: в этом примере есть только один запрос.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Таким образом, вам разрешено переставить s[0:2] => abbcdecbba и s[7:9] => abbcdecbba.
Невозможно сделать s палиндромом, переставив эти подстроки, потому что s[3:6] не является палиндромом.
Таким образом, answer[0] = false.
Пример 3:

Вход: s = "acbcab", queries = [[1,2,4,5]]
Выход: [true]
Пояснение: в этом примере есть только один запрос.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Таким образом, вам разрешено переставить s[1:2] => acbcab и s[4:5] => acbcab.
Чтобы сделать s палиндромом, s[1:2] можно переставить так, чтобы получилось abccab.
Затем s[4:5] можно переставить так, чтобы получилось abccba.
Теперь s — палиндром. Поэтому answer[0] = true.

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

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n — четное число.
s состоит только из строчных английских букв.

Вам дана строка s с 0-индексом и чётной длины n.
Вам также предоставляется 2D-целочисленный массив с 0-индексом, запросы, где queries[i] = [a_i, b_i, c_i, d_i].
Для каждого запроса i вам разрешено выполнять следующие операции:

Переставьте символы в подстроке s[a_i:b_i], where 0 <= a_i <= b_i < n / 2.
Переставьте символы в подстроке s[c_i:d_i], where n / 2 <= c_i <= d_i < n.

По каждому запросу ваша задача это определить, можно ли, выполнив операции, сделать s палиндромом.
На каждый запрос даётся ответ независимо от других.
Возвращает ответ массива с 0-индексом, где answer[i] == true, если можно сделать s палиндромом, выполнив операции, указанные i^м запросом, и false в противном случае.

Подстрока это непрерывная последовательность символов внутри строки.
s[x:y] представляет подстроку, состоящую из символов от индекса x до индекса y в s включительно.

Пример 1:

Input: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Output: [true,true]
Explanation: In this example, there are two queries:
In the first query:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- So, you are allowed to rearrange s[1:1] => abcabc and s[3:5] => abcabc.
- To make s a palindrome, s[3:5] can be rearranged to become => abccba.
- Now, s is a palindrome. So, answer[0] = true.
In the second query:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- So, you are allowed to rearrange s[0:2] => abcabc and s[5:5] => abcabc.
- To make s a palindrome, s[0:2] can be rearranged to become => cbaabc.
- Now, s is a palindrome. So, answer[1] = true.

Пример 2:

Input: s = "abbcdecbba", queries = [[0,2,7,9]]
Output: [false]
Explanation: In this example, there is only one query.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
So, you are allowed to rearrange s[0:2] => abbcdecbba and s[7:9] => abbcdecbba.
It is not possible to make s a palindrome by rearranging these substrings because s[3:6] is not a palindrome.
So, answer[0] = false.
Пример 3:

Input: s = "acbcab", queries = [[1,2,4,5]]
Output: [true]
Explanation: In this example, there is only one query.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
So, you are allowed to rearrange s[1:2] => acbcab and s[4:5] => acbcab.
To make s a palindrome s[1:2] can be rearranged to become abccab.
Then, s[4:5] can be rearranged to become abccba.
Now, s is a palindrome. So, answer[0] = true.

Constraints:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n is even.
s consists of only lowercase English letters.


Вам даны два целочисленных массива с 0-индексом nums1 и nums2 размеров n и m соответственно.
Рассмотрим расчёт следующих значений:

Количество индексов i таких, что 0 <= i < n и nums1[i] встречается хотя бы один раз в nums2.
Количество индексов i таких, что 0 <= i < m и nums2[i] встречается хотя бы один раз в nums1.

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

Пример 1:

Ввод:  nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Вывод: [3,4]
Пояснение: Мы вычисляем значения следующим образом:
- Элементы с индексами 1, 2, и 3 в nums1 встречаются хотя бы один раз в nums2. Итак, первое значение равно 3.
- Элементы с индексами 0, 1, 3, и 4 в nums2 встречаются хотя бы один раз в nums1. Итак, второе значение равно 4.

Пример 2:

Ввод: nums1 = [3,4,2,3], nums2 = [1,5]
Вывод: [0,0]
Объяснение: В двух массивах нет общих элементов, поэтому оба значения будут равны 0.

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

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Даны два целочисленных массива с индексами, начинающимися с 0: nums1 и nums2, размером n и m соответственно. Рассмотрим вычисление следующих значений:

Количество индексов i, таких что 0 <= i < n и nums1[i] встречается хотя бы один раз в nums2.
Количество индексов i, таких что 0 <= i < m и nums2[i] встречается хотя бы один раз в nums1.

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

Пример 1:

Input: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Output: [3,4]
Пояснение: Мы вычисляем значения следующим образом:
- Элементы с индексами 1, 2 и 3 в nums1 встречаются хотя бы один раз в nums2. Поэтому первое значение равно 3.
- Элементы с индексами 0, 1, 3 и 4 в nums2 встречаются хотя бы один раз в nums1. Поэтому второе значение равно 4.

Пример 2:

Input: nums1 = [3,4,2,3], nums2 = [1,5]
Output: [0,0]
Пояснение: Нет общих элементов между двумя массивами, поэтому оба значения будут 0.

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

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Вам даны два целочисленных массива с индексом 0 nums1 и nums2 размером n и m соответственно.
Рассмотрите возможность вычисления следующих значений:

Количество индексов i, таких что 0 <= i < n и nums1[i] встречается хотя бы один раз в nums2.
Количество индексов i, таких что 0 <= i < m и nums2[i] встречается хотя бы один раз в nums1.

Верните ответ в виде целочисленного массива размером 2, содержащего два значения в указанном выше порядке.

Пример 1:

Входные данные: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Выходные данные: [3,4]
Объяснение: Мы вычисляем значения следующим образом:
- Элементы с индексами 1, 2 и 3 в nums1 встречаются хотя бы один раз в nums2. Итак, первое значение равно 3.
- Элементы с индексами 0, 1, 3 и 4 в nums2 встречаются в nums1 по крайней мере один раз. Поэтому второе значение равно 4.

Пример 2:

Вход: nums1 = [3,4,2,3], nums2 = [1,5]
Выход: [0,0]
Пояснение: между двумя массивами нет общих элементов, поэтому два значения будут равны 0.

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

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100


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

Пример 1:

Input: s1 = "abc", s2 = "abb", s3 = "ab"
Output: 2
Объяснение: Выполнение операций с s1 и s2 один раз приведет к трем равным строкам. Можно показать, что нет способа сделать их равными с числом операций меньше двух.

Пример 2:

Input: s1 = "dac", s2 = "bac", s3 = "cac"
Output: -1
Объяснение: Поскольку самые левые буквы s1 и s2 не равны, они не могли стать равными после любого количества операций. Поэтому ответ -1.

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

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

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

Пример 1:

Входные данные: s1 = "abc", s2 = "abb", s3 = "ab"
Выходные данные: 2
Объяснение: Выполнение операций с s1 и s2 один раз приведет к трем равным строкам.
Можно показать, что нет способа сделать их равными с числом операций меньше двух.
Пример 2:

Входные данные: s1 = "dac", s2 = "bac", s3 = "cac"
Выходные данные: -1
Объяснение: Поскольку самые левые буквы s1 и s2 не равны, они не могли стать равными после любого количества операций. Поэтому ответ -1.

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

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

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

Пример 1:

Входные данные: s1 = "abc", s2 = "abb", s3 = "ab"
Выходные данные: 2
Объяснение: Выполнение операций над s1 и s2 один раз приведет к трем равным строкам.
Можно показать, что нет способа сделать их равными менее чем за две операции.
Пример 2:

Вход: s1 = "dac", s2 = "bac", s3 = "cac"
Выход: -1
Пояснение: Поскольку самые левые буквы s1 и s2 не равны, они не могут быть равны после любого количества операций. Поэтому ответ -1.

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

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


Вы находитесь на фруктовом рынке, где представлены различные виды экзотических фруктов.
Вам дан массив prices с индексом, начинающимся с 1, где prices[i] обозначает количество монет, необходимых для покупки i-го фрукта.
На фруктовом рынке действует следующее предложение:

Если вы покупаете i-й фрукт за prices[i] монет, вы можете получить следующие i фруктов бесплатно.

Обратите внимание, что даже если вы можете взять фрукт j бесплатно, вы все равно можете купить его за prices[j] монет, чтобы получить новое предложение.
Верните минимальное количество монет, необходимое для приобретения всех фруктов.

Пример 1:

Input: prices = [3,1,2]
Output: 4
Объяснение: Вы можете приобрести фрукты следующим образом:
- Купите 1-й фрукт за 3 монеты, вы можете взять 2-й фрукт бесплатно.
- Купите 2-й фрукт за 1 монету, вы можете взять 3-й фрукт бесплатно.
- Возьмите 3-й фрукт бесплатно.
Обратите внимание, что даже если вам разрешено взять 2-й фрукт бесплатно, вы купили его, потому что это более оптимально.
Можно доказать, что 4 — это минимальное количество монет, необходимое для приобретения всех фруктов.

Пример 2:

Input: prices = [1,10,1,1]
Output: 2
Объяснение: Вы можете приобрести фрукты следующим образом:
- Купите 1-й фрукт за 1 монету, вы можете взять 2-й фрукт бесплатно.
- Возьмите 2-й фрукт бесплатно.
- Купите 3-й фрукт за 1 монету, вы можете взять 4-й фрукт бесплатно.
- Возьмите 4-й фрукт бесплатно.
Можно доказать, что 2 — это минимальное количество монет, необходимое для приобретения всех фруктов.

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

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Вы находитесь на рынке фруктов, где выставлены различные виды экзотических фруктов.
Вам дан индексированный массив цен 1, где prices[i] обозначает количество монет, необходимых для покупки i^th фрукта.
На рынке фруктов есть следующее предложение:

Если вы купите i^th фрукт за prices[i] монет, вы сможете получить следующие i фруктов бесплатно.

Обратите внимание, что даже если вы можете взять фрукт j бесплатно, вы все равно можете купить его за prices[j] монет, чтобы получить новое предложение.

Верните минимальное количество монет, необходимое для приобретения всех фруктов.

Пример 1:

Вход: prices = [3,1,2]
Выход: 4
Объяснение: Вы можете приобрести фрукты следующим образом:
- Купите 1^й фрукт за 3 монеты, вам разрешено взять 2^й фрукт бесплатно.
- Купите 2^й фрукт за 1 монету, вам разрешено взять 3^й фрукт бесплатно.
- Возьмите 3^й фрукт бесплатно.
Обратите внимание, что хотя вам и разрешили взять 2-й фрукт бесплатно, вы купили его, потому что он более оптимален.
Можно доказать, что 4 — это минимальное количество монет, необходимое для приобретения всех фруктов.

Пример 2:

Вход: prices = [1,10,1,1]
Выход: 2
Объяснение: вы можете приобрести фрукты следующим образом:
- Купите 1-й фрукт за 1 монету, вам разрешено взять 2-й фрукт бесплатно.
- Возьмите 2-й фрукт бесплатно.
- Купите 3-й фрукт за 1 монету, вам разрешено взять 4-й фрукт бесплатно.
- Возьмите 4-й фрукт бесплатно.
Можно доказать, что 2 — это минимальное количество монет, необходимое для приобретения всех фруктов.

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

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


У вас есть строка `s` и положительное целое число `k`.
Пусть vowels и consonants обозначают количество гласных и согласных в строке.
Строка является красивой, если:

vowels == consonants.
(vowels * consonants) % k == 0, другими словами, произведение гласных и согласных делится на `k`.

Верните количество непустых красивых подстрок в заданной строке `s`.
Подстрока — это последовательность символов в строке.
Гласные буквы в английском языке — это 'a', 'e', 'i', 'o' и 'u'.
Согласные буквы в английском языке — это каждая буква, кроме гласных.

Пример 1:

Ввод: s = "baeyh", k = 2
Вывод: 2
Объяснение: В данной строке 2 красивые подстроки.
- Подстрока "baeyh", гласные = 2 (["a","e"]), согласные = 2 (["y","h"]).
Можно заметить, что строка "aeyh" красивая, так как гласные == согласные и vowels * consonants % k == 0.
- Подстрока "baeyh", гласные = 2 (["a","e"]), согласные = 2 (["b","y"]).
Можно заметить, что строка "baey" красивая, так как гласные == согласные и vowels * consonants % k == 0.
Можно показать, что в заданной строке всего 2 красивые подстроки.

Пример 2:

Ввод: s = "abba", k = 1
Вывод: 3
Объяснение: В данной строке 3 красивые подстроки.
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 2 (["a","a"]), согласные = 2 (["b","b"]).
Можно показать, что в заданной строке всего 3 красивые подстроки.

Пример 3:

Ввод: s = "bcdf", k = 1
Вывод: 0
Объяснение: В данной строке нет красивых подстрок.

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

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

Вам дана строка s и положительное целое число k.
Пусть гласные и согласные — это количество гласных и согласных в строке.
Строка красива, если:

гласные == согласные.
(гласные * согласные) % k == 0, другими словами умножение гласных и согласных делится на k.

Возвращает количество непустых красивых подстрок в заданной строке s.
Подстрока — это непрерывная последовательность символов в строке.
Гласные буквы в английском языке: «a», «e», «i», «o» и «u».
Согласные буквы в английском языке — это все буквы, кроме гласных.

Пример 1:

Входные данные: s = "baeyh", k = 2
Выход: 2
Пояснение: В данной строке есть 2 красивые подстроки.
- Подстрока "baeyh", гласные = 2 (["a",e"]), согласные = 2 (["y","h"]).
Вы можете видеть, что строка "aeyh" прекрасна, так как гласные == согласные и гласные * согласные % k == 0.
- Подстрока "baeyh", гласные = 2 (["a",e"]), согласные = 2 (["b","y"]).
Вы можете видеть, что строка "baey" прекрасна, так как гласные == согласные и гласные * согласные % k == 0.
Можно показать, что в данной строке есть только 2 красивые подстроки.

Пример 2:

Входные данные: s = "abba", k = 1
Выход: 3
Пояснение: В данной строке есть 3 красивые подстроки.
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 2 (["a","a"]), согласные = 2 (["b","b"]).
Можно показать, что в данной строке всего 3 красивые подстроки.

Пример 3:

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

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

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

Вам дана строка s и положительное целое число k.
Пусть гласные и согласные будут количеством гласных и согласных в строке.
Строка красива, если:

гласные == согласные.
(гласные * согласные) % k == 0, другими словами, умножение гласных и согласных делится на k.

Возвращает количество непустых красивых подстрок в данной строке s.
Подстрока — это непрерывная последовательность символов в строке.
Гласные буквы в английском языке — это «a», «e», «i», «o» и «u».
Согласные буквы в английском языке — это все буквы, кроме гласных.

Пример 1:

Входные данные: s = "baeyh", k = 2
Выходные данные: 2
Объяснение: в данной строке есть 2 красивые подстроки.
- Подстрока "baeyh", гласные = 2 (["a",e"]), согласные = 2 (["y","h"]).
Вы можете видеть, что строка "aeyh" красива, так как гласные == согласные и гласные * согласные % k == 0.
- Подстрока "baeyh", гласные = 2 (["a",e"]), согласные = 2 (["b","y"]).
Вы можете видеть, что строка "baey" красива, так как гласные == согласные и гласные * согласные % k == 0.
Можно показать, что в данной строке есть только 2 красивые подстроки.

Пример 2:

Вход: s = "abba", k = 1
Выход: 3
Объяснение: В данной строке есть 3 красивые подстроки.
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 1 (["a"]), согласные = 1 (["b"]).
- Подстрока "abba", гласные = 2 (["a","a"]), согласные = 2 (["b","b"]).
Можно показать, что в данной строке есть только 3 красивые подстроки.

Пример 3:

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

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

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


У вас есть целочисленный массив nums с индексацией с 0.
Вы можете выполнять любое количество операций, где каждая операция включает выбор подмассива массива и замену его суммой его элементов. Например, если дан массив [1,3,5,6] и вы выбираете подмассив [3,5], то массив преобразуется в [1,8,6].
Верните максимальную длину неубывающего массива, который можно получить после применения операций.
Подмассив — это непрерывная непустая последовательность элементов в массиве.

Пример 1:

Вход: nums = [5,2,2]
Выход: 1
Объяснение: Этот массив длиной 3 не является неубывающим.
У нас есть два способа сделать длину массива два.
Во-первых, выбрав подмассив [2,2], массив превращается в [5,4].
Во-вторых, выбрав подмассив [5,2], массив превращается в [7,2].
В обоих случаях массив не является неубывающим.
И если мы выберем подмассив [5,2,2] и заменим его на [9], он станет неубывающим.
Поэтому ответ — 1.

Пример 2:

Вход: nums = [1,2,3,4]
Выход: 4
Объяснение: Массив является неубывающим. Поэтому ответ — 4.

Пример 3:

Вход: nums = [4,3,2,6]
Выход: 3
Объяснение: Замена [3,2] на [5] преобразует данный массив в [4,5,6], который является неубывающим.
Поскольку данный массив не является неубывающим, максимальный возможный ответ — 3.

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

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

Вам дан целочисленный массив nums с индексом 0.
Вы можете выполнить любое количество операций, где каждая операция включает выбор подмассива массива и замену его суммой его элементов. Например, если заданный массив равен [1,3,5,6], и вы выбираете подмассив [3,5], массив преобразуется в [1,8,6].
Возвращает максимальную длину неубывающего массива, который может быть создан после применения операций.
Подмассив — это непрерывная непустая последовательность элементов в массиве.

Пример 1:

Входные данные: nums = [5,2,2]
Выходные данные: 1
Объяснение: этот массив длиной 3 не является неубывающим.
У нас есть два способа сделать длину массива равной двум.
Во-первых, выбор подмассива [2,2] преобразует массив в [5,4].
Во-вторых, выбор подмассива [5,2] преобразует массив в [7,2].
В этих двух случаях массив не является неубывающим.
А если мы выберем подмассив [5,2,2] и заменим его на [9], он станет неубывающим.

Так что ответ 1.

Пример 2:

Вход: nums = [1,2,3,4]
Выход: 4
Пояснение: Массив не убывает. Так что ответ 4.

Пример 3:

Вход: nums = [4,3,2,6]
Выход: 3
Пояснение: Замена [3,2] на [5] преобразует данный массив в [4,5,6], который является неубывающим.
Поскольку данный массив не является неубывающим, максимально возможный ответ 3.

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

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


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

Пример 1:

Вход: nums = [1,2,3,4]
Выход: 8
Объяснение: 8 возможных хороших разбиений: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) и ([1,2,3,4]).

Пример 2:

Вход: nums = [1,1,1,1]
Выход: 1
Пояснение: Единственно возможное хорошее разбиение: ([1,1,1,1]).

Пример 3:

Вход: nums = [1,2,1,3]
Выход: 2
Пояснение: 2 возможных хороших разбиения: ([1,2,1], [3]) и ([1,2,1,3]).

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

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

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

Пример 1:

Ввод: nums = [1,2,3,4]
Вывод: 8
Пояснения: Возможны 8 хороших разбиений: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), и ([1,2,3,4]).

Пример 2:

Ввод: nums = [1,1,1,1]
Вывод: 1
Пояснения: Единственное возможное хорошее разбиение: ([1,1,1,1]).

Пример 3:

Ввод: nums = [1,2,1,3]
Вывод: 2
Пояснения: Возможны 2 хороших разбиения: ([1,2,1], [3]) и ([1,2,1,3]).

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

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

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

Пример 1:

Вход: nums = [1,2,3,4]
Выход: 8
Пояснение: 8 возможных хороших разбиений:  ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), и ([1,2,3,4]).

Пример 2:

Вход: nums = [1,1,1,1]
Выход: 1
Пояснение: Единственно возможное хорошее разбиение: ([1,1,1,1]).

Пример 3:

Вход: nums = [1,2,1,3]
Выход: 2
Пояснение: 2 возможных хороших разбиения: ([1,2,1], [3]) и ([1,2,1,3]).

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

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


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

Пример 1:

Input: nums = [1,3,2,3,3], k = 2
Output: 6
Объяснение: Подмассивы, содержащие элемент 3 как минимум 2 раза: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] и [3,3].

Пример 2:

Input: nums = [1,4,2,1], k = 3
Output: 0
Объяснение: Нет подмассива, содержащего элемент 4 как минимум 3 раза.

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

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

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

Пример 1:

Входные данные: nums = [1,3,2,3,3], k = 2
Выходные данные: 6
Пояснение: Подмассивы, которые содержат элемент 3 не менее 2 раз: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] и [3,3].

Пример 2:

Входные данные: nums = [1,4,2,1], k = 3
Выходные данные: 0
Пояснение: Ни один подмассив не содержит элемент 4 не менее 3 раз.

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

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

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

Пример 1:

Ввод: nums = [1,3,2,3,3], k = 2
Вывод: 6
Пояснение: Подмассивы, содержащие элемент 3 как минимум 2 раза: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] и [3,3].

Пример 2:

Ввод: nums = [1,4,2,1], k = 3
Вывод: 0
Пояснение: Ни один подмассив не содержит элемент 4 как минимум 3 раза.

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

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


Вам дан массив положительных целых чисел nums с нумерацией с 0 и положительное целое число limit. В одной операции вы можете выбрать любые два индекса i и j и обменять nums[i] и nums[j], если |nums[i] - nums[j]| <= limit. Верните лексикографически наименьший массив, который можно получить, выполняя операцию любое количество раз. Массив a лексикографически меньше массива b, если в первой позиции, где a и b различаются, массив a имеет элемент, который меньше соответствующего элемента в b. Например, массив [2,10,3] лексикографически меньше массива [10,2,3], потому что они различаются на индексе 0 и 2 < 10.

Пример 1:

Input: nums = [1,5,3,9,8], limit = 2
Output: [1,3,5,8,9]
Explanation: Выполним операцию 2 раза:
- Поменяем местами nums[1] с nums[2]. Массив станет [1,3,5,9,8]
- Поменяем местами nums[3] с nums[4]. Массив станет [1,3,5,8,9]
Мы не можем получить лексикографически меньший массив, выполняя еще операции.
Заметьте, что возможно получить тот же результат, выполняя другие операции.

Пример 2:

Input: nums = [1,7,6,18,2,1], limit = 3
Output: [1,6,7,18,1,2]
Explanation: Выполним операцию 3 раза:
- Поменяем местами nums[1] с nums[2]. Массив станет [1,6,7,18,2,1]
- Поменяем местами nums[0] с nums[4]. Массив станет [2,6,7,18,1,1]
- Поменяем местами nums[0] с nums[5]. Массив станет [1,6,7,18,1,2]
Мы не можем получить лексикографически меньший массив, выполняя еще операции.

Пример 3:

Input: nums = [1,7,28,19,10], limit = 3
Output: [1,7,28,19,10]
Explanation: [1,7,28,19,10] — это лексикографически наименьший массив, который мы можем получить, потому что мы не можем применить операцию к любым двум индексам.

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

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

Вам дан индексированный 0 массив положительных целых чисел nums и положительный целочисленный limit.
За одну операцию вы можете выбрать любые два индекса i и j и поменять местами nums[i] и nums[j], если |nums[i] - nums[j]| <= limit.
Верните лексикографически наименьший массив, который может быть получен путем выполнения операции любое количество раз.
Массив a лексикографически меньше массива b, если в первой позиции, где a и b различаются, массив a имеет элемент, который меньше соответствующего элемента в b. Например, массив [2,10,3] лексикографически меньше массива [10,2,3], потому что они отличаются индексом 0 и 2 < 10.

Пример 1:

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

Пример 2:

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

Пример 3:

Вход: nums = [1,7,28,19,10], limit = 3
Выход: [1,7,28,19,10]
Пояснение: [1,7,28,19,10] — это лексикографически наименьший массив, который мы можем получить, поскольку мы не можем применить операцию к любым двум индексам.

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

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

Вам дан массив положительных целых чисел с 0-индексом и предел положительных целых чисел.
За одну операцию вы можете выбрать любые два индекса i и j и поменять местами nums[i] и nums[j], если |nums[i] - nums[j]| <= limit.
Выведите лексикографически наименьший массив, который можно получить, выполнив операцию любое количество раз.
Массив a лексикографически меньше массива b, если в первой позиции, где a и b различаются, массив a содержит элемент, меньший соответствующего элемента в b. Например, массив [2,10,3] лексикографически меньше массива [10,2,3], поскольку они различаются индексами 0 и 2 < 10.

Пример 1:

Input: nums = [1,5,3,9,8], limit = 2
Output: [1,3,5,8,9]
Explanation: Apply the operation 2 times:
- Swap nums[1] with nums[2]. The array becomes [1,3,5,9,8]
- Swap nums[3] with nums[4]. The array becomes [1,3,5,8,9]
We cannot obtain a lexicographically smaller array by applying any more operations.
Note that it may be possible to get the same result by doing different operations.

Пример 2:

Input: nums = [1,7,6,18,2,1], limit = 3
Output: [1,6,7,18,1,2]
Explanation: Apply the operation 3 times:
- Swap nums[1] with nums[2]. The array becomes [1,6,7,18,2,1]
- Swap nums[0] with nums[4]. The array becomes [2,6,7,18,1,1]
- Swap nums[0] with nums[5]. The array becomes [1,6,7,18,1,2]
We cannot obtain a lexicographically smaller array by applying any more operations.

Пример 3:

Input: nums = [1,7,28,19,10], limit = 3
Output: [1,7,28,19,10]
Explanation: [1,7,28,19,10] is the lexicographically smallest array we can obtain because we cannot apply the operation on any two indices.

Constraints:

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


Вам дан 0-индексированный целочисленный массив batteryPercentages длиной n, обозначающий проценты заряда батареи n 0-индексированных устройств.
Ваша задача — протестировать каждое устройство i в порядке от 0 до n - 1, выполнив следующие тестовые операции:

Если batteryPercentages[i] больше 0:

Увеличьте количество протестированных устройств.
Уменьшите процент заряда батареи всех устройств с индексами j в диапазоне [i + 1, n - 1] на 1, гарантируя, что процент заряда батареи никогда не опустится ниже 0, т. е. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Перейти к следующему устройству.

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

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

Пример 1:

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

Пример 2:

Вход: batteryPercentages = [0,1,2]
Выход: 2
Объяснение: выполнение тестовых операций по порядку, начиная с устройства 0:
На устройстве 0 batteryPercentages[0] == 0, поэтому мы переходим к следующему устройству без тестирования.
На устройстве 1 batteryPercentages[1] > 0, поэтому теперь есть 1 протестированное устройство, и batteryPercentages становится [0,1,1].
На устройстве 2 batteryPercentages[2] > 0, поэтому теперь есть 2 протестированных устройства, и batteryPercentages остается прежним.
Итак, ответ 2.

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

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

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

Если batteryPercentages[i] больше 0:

Увеличьте количество протестированных устройств.
Уменьшите процент заряда батареи всех устройств с индексами j в диапазоне [i + 1, n - 1] на 1, гарантируя, что их процент заряда никогда не будет ниже 0, то есть batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Перейдите к следующему устройству.

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

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

Пример 1:

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

Пример 2:

Вход: batteryPercentages = [0,1,2]
Выход: 2
Пояснение: Выполнение операций тестирования по порядку, начиная с устройства 0:
На устройстве 0, batteryPercentages[0] == 0, поэтому переходим к следующему устройству без тестирования.
На устройстве 1, batteryPercentages[1] > 0, следовательно, тестировано 1 устройство, и batteryPercentages становится [0,1,1].
На устройстве 2, batteryPercentages[2] > 0, следовательно, тестировано 2 устройства, и batteryPercentages остается тем же.
Таким образом, ответ — 2.

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

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

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

Если batteryPercentages[i] больше 0:

Увеличьте количество протестированных устройств.
Уменьшите процент заряда батареи всех устройств с индексами j в диапазоне [i + 1, n - 1] на 1, гарантируя, что процент заряда батареи никогда не опускается ниже 0, т. е. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Переход к следующему устройству.

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

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

Пример 1:

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

Пример 2:

Ввод: batteryPercentages = [0,1,2]
Вывод: 2
Пояснение: Выполнение тестовых операций по порядку, начиная с устройства 0:
На устройстве 0, batteryPercentages[0] == 0, поэтому мы переходим к следующему устройству без тестирования.
На устройстве 1, batteryPercentages[1] > 0, поэтому теперь имеется 1 протестированное устройство, а значение batteryPercentages становится [0,1,1].
На устройстве 2, batteryPercentages[2] > 0, поэтому теперь протестировано 2 устройства, а значение batteryPercentages остаётся прежним.
Итак, ответ 2.

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

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100