Даны два массива одинаковой длины, nums1 и nums2.
Каждый элемент в nums1 был увеличен (или уменьшен в случае отрицательного) на целое число, обозначенное переменной x.
В результате nums1 становится равным nums2. Два массива считаются равными, когда они содержат одинаковые целые числа с одинаковой частотой.
Верните целое число x.

Пример 1:

Ввод: nums1 = [2,6,4], nums2 = [9,7,5]
Вывод: 3
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно 3.

Пример 2:

Ввод: nums1 = [10], nums2 = [5]
Вывод: -5
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно -5.

Пример 3:

Ввод: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Вывод: 0
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно 0.

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

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Тестовые случаи сгенерированы таким образом, что существует целое число x, при котором nums1 может стать равным nums2, добавляя x к каждому элементу nums1.

Вам даны два массива одинаковой длины: nums1 и nums2.
Каждый элемент в nums1 был увеличен (или уменьшен в случае отрицательного значения) на целое число, представленное переменной x.
В результате nums1 становится равным nums2. Два массива считаются равными, если они содержат одинаковые целые числа с одинаковыми частотами.
Вернуть целое число x.

Пример 1:

Ввод: nums1 = [2,6,4], nums2 = [9,7,5]
Вывод: 3
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно 3.

Пример 2:

Ввод: nums1 = [10], nums2 = [5]
Выход: -5
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно -5.

Пример 3:

Ввод: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Вывод: 0
Объяснение:
Целое число, добавленное к каждому элементу nums1, равно 0.

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

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Тестовые случаи генерируются таким образом, что существует целое число x, такое, что nums1 может стать равным nums2 путём добавления x к каждому элементу nums1.


Даны два целых числа n и x. Необходимо создать массив положительных целых чисел nums размера n, где для каждого 0 <= i < n - 1, nums[i + 1] больше, чем nums[i], и результат побитовой операции AND между всеми элементами nums равен x.
Вернуть минимально возможное значение nums[n - 1].

Пример 1:

Ввод: n = 3, x = 4
Вывод: 6
Объяснение:
nums могут быть [4,5,6], и его последний элемент равен 6.

Пример 2:

Ввод: n = 2, x = 7
Вывод: 15
Объяснение:
nums могут быть [7,15], и его последний элемент равен 15.

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

1 <= n, x <= 10^8


Вам дан целочисленный массив nums. Массив уникальности nums — это отсортированный массив, содержащий количество различных элементов всех подмассивов nums. Другими словами, это отсортированный массив, состоящий из distinct(nums[i..j]) для всех 0 <= i <= j < nums.length.
Здесь distinct(nums[i..j]) обозначает количество различных элементов в подмассиве, который начинается с индекса i и заканчивается индексом j.
Верните медиану массива уникальности nums.
Обратите внимание, что медиана массива определяется как средний элемент массива, когда он отсортирован в неубывающем порядке. Если есть два варианта выбора медианы, берется меньшее из двух значений.

Пример 1:

Вход: nums = [1,2,3]
Выход: 1
Пояснение:
Массив уникальности nums — [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])], что равно [1, 1, 1, 2, 2, 3]. Массив уникальности имеет медиану 1. Поэтому ответ 1.

Пример 2:

Вход: nums = [3,4,3,4,5]
Выход: 2
Пояснение:
Массив уникальности nums — [1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Массив уникальности имеет медиану 2. Поэтому ответ 2.

Пример 3:

Вход: nums = [4,3,5,4]
Выход: 2
Пояснение:
Массив уникальности nums — [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Массив уникальности имеет медиану 2. Поэтому ответ 2.

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

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

Вам дан целочисленный массив чисел. Массив уникальности чисел это отсортированный массив, содержащий количество различных элементов всех подмассивов чисел. Другими словами, это отсортированный массив, состоящий из distinct(nums[i..j]), для всех 0 <= i <= j < nums.length.
Здесь distinct(nums[i..j]) обозначает количество различных элементов в подмассиве, который начинается с индекса i и заканчивается индексом j.
Возвращает медиану массива чисел уникальности.
Обратите внимание, что медиана массива определяется как средний элемент массива, когда он отсортирован в неубывающем порядке. Если есть два варианта медианы, выбирается меньшее из двух значений.

Пример 1:

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

Пример 2:

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

Пример 3:

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

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

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

Вам дан целочисленный массив nums. Массив уникальности nums — это отсортированный массив, содержащий количество уникальных элементов всех подмассивов nums. Другими словами, это отсортированный массив, состоящий из distinct(nums[i..j]) для всех 0 <= i <= j < nums.length. Здесь distinct(nums[i..j]) обозначает количество уникальных элементов в подмассиве, который начинается с индекса i и заканчивается индексом j. Верните медиану массива уникальности nums. Обратите внимание, что медиана массива определяется как средний элемент массива, когда он отсортирован в порядке неубывания. Если есть два варианта для медианы, выбирается наименьшее из двух значений.

Пример 1:

Ввод: nums = [1,2,3]
Вывод: 1
Объяснение:
Массив уникальности nums равен [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])], что равно [1, 1, 1, 2, 2, 3]. У массива уникальности медиана равна 1. Поэтому ответ 1.

Пример 2:

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

Пример 3:

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

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

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


Слово считается допустимым, если:

Оно содержит минимум 3 символа.
Оно содержит только цифры (0-9) и английские буквы (заглавные и строчные).
Оно содержит хотя бы одну гласную.
Оно содержит хотя бы одну согласную.

Дана строка word.
Верните true, если word является допустимым, в противном случае верните false.
Примечания:

'a', 'e', 'i', 'o', 'u' и их заглавные версии являются гласными.
Согласная — это английская буква, которая не является гласной.

Пример 1:

Input: word = "234Adas"
Output: true
Explanation:
Это слово удовлетворяет условиям.

Пример 2:

Input: word = "b3"
Output: false
Explanation:
Длина этого слова меньше 3 и в нём нет гласных.

Пример 3:

Input: word = "a3$e"
Output: false
Explanation:
Это слово содержит символ '$' и не имеет согласных.

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

1 <= word.length <= 20
word состоит из английских заглавных и строчных букв, цифр, '@', '#' и '$'.

Слово считается действительным, если:

Оно содержит минимум 3 символа.
Оно содержит только цифры (0–9), и Английские буквы (прописные и строчные).
Оно включает в себя как минимум одну гласную.
Оно включает в себя хотя бы одну согласную.

Вам дано строковое слово.
Верните true, если слово допустимо, в противном случае верните false.
Примечания:

'a', 'e', 'i', 'o', 'u', а их заглавные буквы это гласные.
Согласная это Английская буква, не являющаяся гласной.

Пример 1:

Ввод: word = "234Adas"
Вывод: true
Объяснение:
Это слово удовлетворяет условиям.

Пример 2:

Ввод: word = "b3"
Вывод: false
Объяснение:
Длина этого слова меньше 3 и не имеет гласной.

Пример 3:

Ввод: word = "a3$e"
Вывод: false
Объяснение:
Это слово содержит символ '$' и не имеет согласной.

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

1 <= word.length <= 20
Слово состоит из Английских прописных и строчных букв, цифр, '@', '#', и '$'.

Слово считается допустимым, если:

Оно содержит не менее 3 символов.
Оно содержит только цифры (0–9) и английские буквы (заглавные и строчные).
Оно включает в себя по крайней мере одну гласную.
Оно включает в себя по крайней мере одну согласную.

Вам дана строка word.
Верните true, если word допустим, в противном случае верните false.
Примечания:

'a', 'e', 'i', 'o', 'u' и их заглавные буквы являются гласными.
Согласная — это английская буква, которая не является гласной.

Пример 1:

Входные данные: word = "234Adas"
Выходные данные: true
Пояснение:
Это слово удовлетворяет условиям.

Пример 2:

Входные данные: word = "b3"
Выходные данные: false
Пояснение:
Длина этого слова меньше 3, и в нем нет гласной.

Пример 3:

Вход: word = "a3$e"
Выход: false
Объяснение:
Это слово содержит символ '$' и не имеет согласной.

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

1 <= word.length <= 20
word состоит из английских заглавных и строчных букв, цифр, '@', '#' и '$'.


У вас есть строка word длины n и целое число k, такое, что k делит n.
В одной операции вы можете выбрать любые два индекса i и j, которые делятся на k, затем заменить подстроку длиной k, начинающуюся с i, на подстроку длиной k, начинающуюся с j. То есть заменить подстроку word[i..i + k - 1] на подстроку word[j..j + k - 1].
Верните минимальное количество операций, необходимых для того, чтобы сделать word k-периодической.
Мы говорим, что word является k-периодической, если существует некоторая строка s длины k, такая, что word можно получить путем конкатенации s произвольное количество раз. Например, если word == "ababab", то word является 2-периодической для s = "ab".

Пример 1:

Ввод: word = "leetcodeleet", k = 4
Вывод: 1
Объяснение:
Мы можем получить 4-периодическую строку, выбирая i = 4 и j = 0. После этой операции word становится равной "leetleetleet".

Пример 2:

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

| i | j | word       |
|---|---|------------|
| 0 | 2 | etetcoleet |
| 4 | 0 | etetetleet |
| 6 | 0 | etetetetet |

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

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

Вам дано строковое слово размера n и целое число k такое, что k делит n.
За одну операцию вы можете выбрать любые два индекса i и j, которые делятся на k, а затем заменить подстроку длины k, начинающуюся с i, на подстроку длины k, начинающуюся с j. То есть замените подстроку word[i..i + k - 1] подстрокой word[j..j + k - 1].
Возвращает минимальное количество операций, необходимое для того, чтобы сделать слово k-периодическим.
Мы говорим, что слово является k-периодическим, если существует некоторая строка s длины k такая, что слово можно получить путем объединения s произвольное число раз. Например, если word == “ababab”, то слово 2-периодическое для s = "ab".

Пример 1:

Ввод: word = "leetcodeleet", k = 4
Вывод: 1
Объяснение:
Мы можем получить 4-периодическую строку, выбрав i = 4 и j = 0. После этой операции слово станет равным "leetleetleet".

Пример 2:

Ввод: word = "leetcoleet", k = 2
Вывод: 3
Объяснение:
Мы можем получить 2-периодическую строку, применив операции, описанные в таблице ниже.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

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

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

Вам дана строка word размера n и целое число k, такое, что k делит n.
В одной операции вы можете выбрать любые два индекса i и j, которые делятся на k, затем заменить подстроку длины k, начинающуюся с i, на подстроку длины k, начинающуюся с j. То есть заменить подстроку word[i..i + k - 1] на подстроку word[j..j + k - 1].
Вернуть минимальное количество операций, необходимых для того, чтобы сделать word k-периодическим.
Мы говорим, что word является k-периодическим, если существует некоторая строка s длины k, такая, что word может быть получена путем конкатенации s произвольное количество раз. Например, если word == «ababab», то word является 2-периодическим для s = «ab».

Пример 1:

Вход: word = "leetcodeleet", k = 4
Выход: 1
Пояснение:
Мы можем получить 4-периодическую строку, выбрав i = 4 и j = 0. После этой операции word станет равным "leetleetleet".

Пример 2:

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

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

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

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


Дана строка s, которая является конкатенацией анаграмм некоторой строки t.
Верните минимальную возможную длину строки t.
Анаграмма образуется путем перестановки букв строки. Например, "aab", "aba" и "baa" являются анаграммами строки "aab".

Пример 1:

Ввод: s = "abba"
Вывод: 2
Объяснение:
Одна из возможных строк t может быть "ba".

Пример 2:

Ввод: s = "cdef"
Вывод: 4
Объяснение:
Одна из возможных строк t может быть "cdef", обратите внимание, что t может быть равна s.

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

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

Вам дана строка, которая, как известно, является объединением анаграмм некоторой строки t.
Вернуть минимальную возможную длину строки t.
Анаграмма образуется путем перестройки букв строки. Например, «aab», «aba» и «baa» являются анаграммами  "aab".

Пример 1:

Ввод: S = "abba"
Вывод: 2
Объяснение:
Одной из возможных строк t может быть "ba".

Пример 2:

Ввод: s = "cdef"
Вывод: 4
Объяснение:
Одной из возможных строки  t может быть "cdef",  Обратите внимание, что t может быть равен s.

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

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


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

Выбрать индекс i из nums и увеличить nums[i] на 1 с затратами cost1.
Выбрать два разных индекса i, j из nums и увеличить nums[i] и nums[j] на 1 с затратами cost2.

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

Пример 1:

Ввод: nums = [4,1], cost1 = 5, cost2 = 2
Вывод: 15
Пояснение:
Следующие операции могут быть выполнены, чтобы сделать значения равными:

Увеличить nums[1] на 1 с затратами 5. nums становится [4,2].
Увеличить nums[1] на 1 с затратами 5. nums становится [4,3].
Увеличить nums[1] на 1 с затратами 5. nums становится [4,4].

Общая стоимость составляет 15.

Пример 2:

Ввод: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Вывод: 6
Пояснение:
Следующие операции могут быть выполнены, чтобы сделать значения равными:

Увеличить nums[0] и nums[1] на 1 с затратами 1. nums становится [3,4,3,3,5].
Увеличить nums[0] и nums[2] на 1 с затратами 1. nums становится [4,4,4,3,5].
Увеличить nums[0] и nums[3] на 1 с затратами 1. nums становится [5,4,4,4,5].
Увеличить nums[1] и nums[2] на 1 с затратами 1. nums становится [5,5,5,4,5].
Увеличить nums[3] на 1 с затратами 2. nums становится [5,5,5,5,5].

Общая стоимость составляет 6.

Пример 3:

Ввод: nums = [3,5,3], cost1 = 1, cost2 = 3
Вывод: 4
Пояснение:
Следующие операции могут быть выполнены, чтобы сделать значения равными:

Увеличить nums[0] на 1 с затратами 1. nums становится [4,5,3].
Увеличить nums[0] на 1 с затратами 1. nums становится [5,5,3].
Увеличить nums[2] на 1 с затратами 1. nums становится [5,5,4].
Увеличить nums[2] на 1 с затратами 1. nums становится [5,5,5].

Общая стоимость составляет 4.

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

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

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

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

Выберите два разных индекса i, j из nums и увеличьте nums[i] и nums[j] на 1 для стоимости cost2.

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

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

Пример 1:

Входные данные: nums = [4,1], cost1 = 5, cost2 = 2
Выходные данные: 15
Пояснение:

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

Увеличьте nums[1] на 1 для стоимости 5. nums становится [4,2].
Увеличьте nums[1] на 1 для стоимости 5. nums становится [4,3].
Увеличьте nums[1] на 1 для стоимости 5. nums становится [4,4].

Общая стоимость составляет 15.

Пример 2:

Вход: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Выход: 6
Пояснение:

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

Увеличьте nums[0] и nums[1] на 1 для стоимости 1. nums становится [3,4,3,3,5].
Увеличьте nums[0] и nums[2] на 1 для стоимости 1. nums становится [4,4,4,3,5].
Увеличьте nums[0] и nums[3] на 1 для стоимости 1. nums становится [5,4,4,4,5].
Увеличьте nums[1] и nums[2] на 1 для стоимости 1. nums становится [5,5,5,4,5].
Увеличьте nums[3] на 1 для стоимости 2. nums становится [5,5,5,5,5].

Общая стоимость составляет 6.

Пример 3:

Входные данные: nums = [3,5,3], cost1 = 1, cost2 = 3
Выходные данные: 4
Пояснение:
Следующие операции можно выполнить, чтобы сделать значения равными:

Увеличьте nums[0] на 1 для стоимости 1. nums становится [4,5,3].
Увеличьте nums[0] на 1 для стоимости 1. nums становится [5,5,3].
Увеличьте nums[2] на 1 для стоимости 1. nums становится [5,5,4].
Увеличьте nums[2] на 1 для стоимости 1. nums становится [5,5,5].

Общая стоимость составляет 4.

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

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


Дана двумерная матрица grid размером 3 x 3, состоящая только из символов 'B' и 'W'. Символ 'W' представляет белый цвет, а символ 'B' представляет черный цвет.
Ваша задача — изменить цвет не более чем одной ячейки так, чтобы в матрице появился квадрат 2 x 2, в котором все ячейки одного цвета.
Верните true, если возможно создать квадрат 2 x 2 одного цвета, в противном случае верните false.

Пример 1:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Вывод: true
Объяснение:
Это можно сделать, изменив цвет grid[0][2].

Пример 2:

Ввод: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Вывод: false
Объяснение:
Это невозможно сделать, изменив не более одной ячейки.

Пример 3:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Вывод: true
Объяснение:
Матрица уже содержит квадрат 2 x 2 одного цвета.

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

grid.length == 3
grid[i].length == 3
grid[i][j] может быть либо 'W', либо 'B'.

Вам предоставляется 2D матричная сетка размером 3 х 3, состоящая только из символов 'B' и 'W'. Символ «W» обозначает белый цвет, а символ «B» — черный.
Ваша задача состоит в том, чтобы изменить цвет не более чем одной ячейки так, чтобы матрица имела квадрат 2 х 2, где все ячейки имеют одинаковый цвет.
Возвращает true, если возможно создать квадрат 2 x 2 того же цвета, в противном случае возвращает false.

Пример 1:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Вывод: true
Объяснение:
Это можно сделать, изменив цвет сетки[0][2].

Пример 2:

Вход: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Вывод: false
Объяснение:
Это невозможно сделать, изменив не более чем одну клетку.

Пример 3:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Вывод: true
Объяснение:
Сетка уже содержит квадрат 2 х 2 того же цвета.

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

grid.length == 3
grid[i].length == 3
grid[i][j] — это либо 'W', либо 'B'.

Вам дана двумерная матричная сетка размером 3 x 3, состоящая только из символов 'B' и 'W'. Символ 'W' представляет белый цвет, а символ 'B' представляет чёрный цвет.
Ваша задача — изменить цвет не более одной ячейки так, чтобы в матрице появился квадрат 2 x 2, в котором все ячейки были одного цвета.
Верните true, если можно создать квадрат 2 x 2 того же цвета, в противном случае верните false.

Пример 1:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Вывод: true
Объяснение:
Это можно сделать, изменив цвет сетки[0][2].

Пример 2:

Ввод: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Вывод: false
Объяснение:
Этого нельзя сделать, изменив не более одной ячейки.

Пример 3:

Ввод: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Вывод: true
Объяснение:
В сетке уже есть квадрат 2 x 2 того же цвета.

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

grid.length == 3
grid[i].length == 3
grid[i][j] имеет значение 'W' или 'B'.


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

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

Пример 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

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

Пример 2:

1
0
0
0

0
1
0
1

1
0
0
0

Вход: grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Выход: 0
Объяснение:
Нет прямоугольных треугольников.

Пример 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

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

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

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

Вам дана 2D сетка булевой матрицы.
Выведете целое число, которое является количеством прямоугольных треугольников, образованных 3 элементами сетки так, что все треугольники имеют значение 1.
Примечание:

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

Example 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Input: grid = [[0,1,0],[0,1,1],[0,1,0]]
Output: 2
Explanation:
Здесь есть 2 прямоугольных треугольника.

Example 2:

1
0
0
0

0
1
0
1

1
0
0
0

Input: grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Output: 0
Explanation:
Здесь нет прямоугольных треугольников.

Example 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Input: grid = [[1,0,1],[1,0,0],[1,0,0]]
Output: 2
Explanation:
Здесь есть два прямоугольных треугольника.

Constraints:

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

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

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

Пример 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Ввод: grid = [[0,1,0], [0,1,1], [0,1,0]]]
Вывод: 2
Объяснение:
Есть два правых треугольника.

Пример 2:

1
0
0
0

0
1
0
1

1
0
0
0

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

Пример 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Вход: grid = [[0,1,0],[0,1,1],[0,1,0]]
Вывод: 2
Объяснение:
Есть два правых треугольника.

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

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1


Даны 3 положительных целых числа zero, one и limit.
Бинарный массив arr называется стабильным, если:

Количество вхождений 0 в arr равно zero.
Количество вхождений 1 в arr равно one.
Каждый подмассив arr размером больше limit должен содержать как 0, так и 1.

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

Пример 1:

Ввод: zero = 1, one = 1, limit = 2
Вывод: 2
Пояснение:
Два возможных стабильных бинарных массива — [1,0] и [0,1], так как оба массива содержат один 0 и один 1, и ни один подмассив не имеет длину больше 2.

Пример 2:

Ввод: zero = 1, one = 2, limit = 1
Вывод: 1
Пояснение:
Единственный возможный стабильный бинарный массив — [1,0,1].
Обратите внимание, что бинарные массивы [1,1,0] и [0,1,1] имеют подмассивы длиной 2 с одинаковыми элементами, следовательно, они не стабильны.

Пример 3:

Ввод: zero = 3, one = 3, limit = 2
Вывод: 14
Explanation:
Пояснение:
Все возможные стабильные бинарные массивы: [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0], и [1,1,0,1,0,0].

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

1 <= zero, one, limit <= 200

Вам даны 3 положительных целых числа: ноль, один и предел.
Двоичный массив arr называется стабильным, если:

Количество вхождений 0 в arr равно нулю.
Количество вхождений 1 в arr равно одному.
Каждый подмассив arr с размером больше предела должен содержать как 0, так и 1.

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

Пример 1:

Входные данные: zero = 1, one = 1, limit = 2
Выходные данные: 2
Пояснение:
Два возможных устойчивых двоичных массива — [1,0] и [0,1], поскольку оба массива содержат один 0 и одну 1, и ни один подмассив не имеет длину больше 2.

Пример 2:

Входные данные: zero = 1, one = 2, limit = 1
Выходные данные: 1
Пояснение:
Единственный возможный устойчивый двоичный массив — [1,0,1].
Обратите внимание, что двоичные массивы [1,1,0] и [0,1,1] содержат подмассивы длины 2 с идентичными элементами, поэтому они не являются устойчивыми.

Пример 3:

Вход: zero = 3, one = 3, limit = 2
Выход: 14
Пояснение:
Все возможные устойчивые двоичные массивы: [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] и [1,1,0,1,0,0].

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

1 <= zero, one, limit <= 200

Вам даны 3 целых положительных числа: ноль, единица и предел.
Двоичный массив arr называется стабильным, если:

Количество вхождений 0 в arr равно нулю.
Число вхождений 1 в arr равно одному.
Каждый подмассив arr размером больше предела должен содержать как 0, так и 1.

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

Пример 1:

Ввод: zero = 1, one = 1, limit = 2
Вывод: 2
Объяснение:
Двумя возможными стабильными двоичными массивами являются [1,0] и [0,1], поскольку оба массива имеют один 0 и одну 1, и ни один подмассив не имеет длину больше 2.

Пример 2:

Ввод: zero = 1, one = 2, limit = 1
Вывод: 1
Объяснение:
Единственный возможный стабильный двоичный массив это [1,0,1].
Обратите внимание, что двоичные массивы [1,1,0] и [0,1,1] имеют подмассивы длины 2 с одинаковыми элементами, следовательно, они не стабильны.

Пример 3:

Ввод: zero = 3, one = 3, limit = 2
Вывод: 14
Объяснение:
Все возможные стабильные двоичные массивы: [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0], и [1,1,0,1,0,0].

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

1 <= zero, one, limit <= 200


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

Пример 1:

Ввод: s = "abc", t = "bac"
Вывод: 2
Объяснение:
Для s = "abc" и t = "bac" разница перестановок s и t равна сумме:

Абсолютная разница между индексом вхождения "a" в s и индексом вхождения "a" в t.
Абсолютная разница между индексом вхождения "b" в s и индексом вхождения "b" в t.
Абсолютная разница между индексом вхождения "c" в s и индексом вхождения "c" в t.

То есть разница перестановок между s и t равна |0 - 1| + |2 - 2| + |1 - 0| = 2.

Пример 2:

Ввод: s = "abcde", t = "edbac"
Выход: 12
Пояснение: Разница перестановок между s и t равна |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

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

1 <= s.length <= 26
Каждый символ встречается в s не более одного раза.
t является перестановкой s.
s состоит только из строчных Английских букв.

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

Пример 1:

Ввод: s = "abc", t = "bac"
Вывод: 2
Объяснение:
Для s = "abc" и t = "bac" разница перестановки между s и t равна сумме:

Абсолютная разница между индексом вхождения "a" в s и индексом вхождения "a" в t.
Абсолютная разница между индексом вхождения "b" в s и индексом вхождения "b" в t.
Абсолютная разница между индексом вхождения "c" в s и индексом вхождения "c" в t.

То есть, разница перестановки между s и t равна |0 - 1| + |2 - 2| + |1 - 0| = 2.

Пример 2:

Ввод: s = "abcde", t = "edbac"
Вывод: 12
Объяснение: Разница перестановки между s и t равна |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

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

1 <= s.length <= 26
Каждый символ встречается не более одного раза в s.
t является перестановкой s.
s состоит только из строчных английских букв.

Вам дают две строки S и T, так что каждый персонаж встречается не более одного раза в S, а T - перестановка S.
Разница перестановки между S и T определяется как сумма абсолютной разницы между индексом возникновения каждого символа в S и индексом возникновения одного и того же символа в t.
Вернуть разницу перестановки между S и T.

Пример 1:

Ввод: s = "abc", t = "bac"
Вывод: 2
Объяснение:
Для s = "abc" и t = "bac" разница перестановки между s и t равна сумме:

Абсолютная разница между индексом возникновения  "a" в s и индексом возникновения "a" в t.
Абсолютная разница между индексом возникновения"b" в s и индексом возникновения"b" в t.
Абсолютная разница между индексом возникновения "c" в s и индексом возникновения "c" в t.

То есть разница перестановки между s и t равен | 0 - 1 | + | 2 - 2 | + | 1 - 0 | = 2.

Пример 2:

Ввод: s = "abcde", t = "edbac"
Вывод: 12
Объяснение: Разница перестановки между S и T равен | 0 - 3 | + | 1 - 2 | + | 2 - 4 | + | 3 - 1 | + | 4 - 0 | = 12.

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

1 <=s.Length <= 26
Каждый персонаж встречается не более одного раза в с.
t - перестановка с.
S состоит только из нижних английских букв.


В мистическом подземелье в ряд стоят n магов. У каждого мага есть атрибут, дающий вам энергию. Некоторые маги могут дать вам отрицательную энергию, а значит, забрать у вас энергию.
Вы были прокляты таким образом, что после поглощения энергии мага i вы мгновенно перенесетесь к магу (i + k). Этот процесс будет повторяться до тех пор, пока вы не дойдете до мага, где (i + k) не существует.
Другими словами, вы выберете отправную точку, а затем телепортируетесь с помощью k прыжков, пока не дойдете до конца последовательности магов, поглощая всю энергию во время путешествия.
Вам даны энергия массива и целое число k. Верните максимально возможную энергию, которую вы можете получить.

Пример 1:

Ввод: energy = [5,2,-10,-5,1], k = 3
Вывод: 3
Пояснение: Мы можем получить общую энергию 3, начиная с мага 1 и поглощая 2 + 1 = 3.

Пример 2:

Ввод: energy = [-2,-3,-1], k = 2
Вывод: -1
Пояснение: Мы можем получить общую энергию -1, начиная с мага 2.

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

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

В мистическом подземелье n магов стоят в линию. У каждого мага есть атрибут, который дает вам энергию. Некоторые маги могут давать вам негативную энергию, то есть забирать энергию у вас.
Вы были прокляты таким образом, что после поглощения энергии от мага i, вы мгновенно перенесетесь к магу (i+k). Этот процесс будет повторяться до тех пор, пока вы не дойдете до мага, где (i + k) не существует.
Другими словами, вы выберете начальную точку, а затем телепортируетесь с помощью k прыжков, пока не дойдете до конца последовательности магов, поглощая всю энергию во время путешествия.
Вам дана энергия массива и целое число k. Возвращайте максимально возможную энергию, которую вы можете получить.

Пример 1:

Input:  energy = [5,2,-10,-5,1], k = 3
Output: 3
Объяснение: Мы можем получить общую энергию 3, начав с мага 1, поглощая 2 + 1 = 3.

Пример 2:

Input: energy = [-2,-3,-1], k = 2
Output: -1
Объяснение: Мы можем получить общую энергию -1, начав с мага 2.

Constraints:

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

В мистической темнице n магов стоят в линии. У каждого мага есть атрибут, который дает вам энергию. Некоторые маги могут дать вам негативную энергию, что означает получение энергии от вас.
Вы были прокляты таким образом, что после поглощения энергии от мага i вы будете мгновенно транспортироваться в мага (i + k). Этот процесс будет повторяться, пока вы не достигнете мага, где (i + k) не существует.
Другими словами, вы выберете отправную точку, а затем телепортируются с k прыжками, пока не достигнете конца последовательности магов, поглощая всю энергию во время путешествия.
Вам дают энергию массива и целое число k. Вернуть максимально возможную энергию, которую вы можете получить.

Пример 1:

Ввод: energy = [5,2,-10,-5,1], k = 3
Вывод: 3
Объяснение: Мы можем получить общую энергию 3, начиная с мага 1, поглощая 2 + 1 = 3.

Пример 2:

Ввод:  energy = [-2,-3,-1], k = 2
Вывод: -1
Объяснение: Мы можем получить общую энергию -1, начиная с мага 2.

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

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1


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

Пример 1:

Ввод: nums = [1]
Вывод: true
Пояснение:
Есть только один элемент. Поэтому ответ true.

Пример 2:

Ввод: nums = [2,1,4]
Вывод: true
Пояснение:
Есть две пары: (2,1) и (1,4). Обе пары содержат числа с разной четностью. Поэтому ответ true.

Пример 3:

Ввод: nums = [4,3,1,6]
Вывод: false
Пояснение:
nums[1] и nums[2] оба нечетные. Поэтому ответ false.

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

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

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

Пример 1:

Входные данные: nums = [1]
Выходные данные: true
Пояснение:
Есть только один элемент. Поэтому ответ true.

Пример 2:

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

Пример 3:

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

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

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

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

Пример 1:

Input: nums = [1]
Output: true
Пояснение:
Есть только один элемент. Поэтому ответ - true.

Пример 2:

Input: nums = [2,1,4]
Output: true
Пояснение:
Есть две пары: (2,1) и (1,4), и обе пары содержат числа с разной четностью. Поэтому ответ - true.

Пример 3:

Input: nums = [4,3,1,6]
Output: false
Пояснение:
nums[1] и nums[2] оба нечетные. Поэтому ответ - false.

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

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


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

Пример 1:

Ввод: nums = [13,23,12]
Вывод: 4
Объяснение:
У нас есть следующее:
- Цифровая разница между 13 и 23 составляет 1.
- Цифровая разница между 13 и 12 составляет 1.
- Цифровая разница между 23 и 12 составляет 2.
Таким образом, общая сумма цифровых различий между всеми парами чисел равна 1 + 1 + 2 = 4.

Пример 2:

Ввод: nums = [10,10,10,10]
Вывод: 0
Объяснение:
Все числа в массиве одинаковые. Таким образом, общая сумма цифровых различий между всеми парами чисел будет равна 0.

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

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Все числа в nums имеют одинаковое количество цифр.

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

Пример 1:

Вход: nums = [13,23,12]
Выход: 4
Пояснение:
У нас есть следующее:
- Разница цифр между 13 и 23 равна 1.
- Разница цифр между 13 и 12 равна 1.
- Разница цифр между 23 и 12 равна 2.
Таким образом, общая сумма разностей цифр между всеми парами целых чисел равна 1 + 1 + 2 = 4.

Пример 2:

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

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

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Все целые числа в nums имеют одинаковое количество цифр.

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

Пример 1:

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

Пример 2:

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

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

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Все целые числа в nums имеют одинаковое количество цифр.


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

Спуститься на ступеньку i - 1. Эта операция не может быть использована последовательно или на ступеньке 0.
Подняться на ступеньку i + 2^jump. И тогда прыжок превращается в jump + 1.

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

Пример 1:

Ввод: k = 0
Вывод: 2
Пояснение:
Есть 2 возможных способа добраться до ступеньки 0:

Алиса начинает с 1 ступеньки.

Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 0.

Алиса начинает с 1 ступеньки.

Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 0.
Используя операцию второго типа, она поднимается на 2^0 ступенек, чтобы достичь ступеньки 1.
Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 0.

Пример 2:

Ввод: k = 1
Вывод: 4
Пояснения:
Существует 4 возможных способа добраться до ступеньки 1:

Алиса начинает со ступеньки 1. Алиса находится на ступеньке 1.
Алиса начинает с 1 ступеньки.

Используя операцию первого типа, она спускается на 1 ступеньку и достигает ступеньки 0.
Используя операцию второго типа, она поднимается на 2^0 ступенек и достигает ступеньки 1.

Алиса начинает с 1 ступеньки.

Используя операцию второго типа, она поднимается на 2^0 ступенек и достигает ступеньки 2.
Используя операцию первого типа, она спускается на 1 ступеньку и достигает ступеньки 1.

Алиса начинает с 1 ступеньки.

Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 0.
Используя операцию второго типа, она поднимается на 2^0 ступенек, чтобы достичь ступеньки 1.
Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 0.
Используя операцию второго типа, она поднимается на 2^1 ступенек, чтобы достичь ступеньки 2.
Используя операцию первого типа, она спускается на 1 ступеньку, чтобы достичь ступеньки 1.

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

0 <= k <= 10^9

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

Спуститься на лестницу i - 1. Эта операция не может быть использована последовательно или на ступеньке 0.
Подняться на ступеньку i + 2^jump. И затем jump становится jump + 1.

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

Пример 1:

Input: k = 0
Output: 2
Explanation:
The 2 possible ways of reaching stair 0 are:

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.
Using an operation of the first type, she goes down 1 stair to reach stair 0.

Пример 2:

Input: k = 1
Output: 4
Explanation:
The 4 possible ways of reaching stair 1 are:

Alice starts at stair 1. Alice is at stair 1.
Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.

Alice starts at stair 1.

Using an operation of the second type, she goes up 2^0 stairs to reach stair 2.
Using an operation of the first type, she goes down 1 stair to reach stair 1.

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.
Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^1 stairs to reach stair 2.
Using an operation of the first type, she goes down 1 stair to reach stair 1.

Constraints:

0 <= k <= 10^9

У вас есть неотрицательное целое число k. Существует лестница с бесконечным числом ступенек, где самая нижняя ступенька пронумерована 0.
У Алисы есть целое число jump, с начальным значением 0. Она начинает на ступеньке 1 и хочет достичь ступеньки k, используя любое количество операций. Если она находится на ступеньке i, за одну операцию она может:

Спуститься на ступеньку i - 1. Эту операцию нельзя использовать дважды подряд или на ступеньке 0.
Подняться на ступеньку i + 2^jump. При этом jump становится jump + 1.

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

Пример 1:

Input: k = 0
Output: 2
Explanation:
The 2 possible ways of reaching stair 0 are:

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.
Using an operation of the first type, she goes down 1 stair to reach stair 0.

Пример 2:

Input: k = 1
Output: 4
Explanation:
The 4 possible ways of reaching stair 1 are:

Alice starts at stair 1. Alice is at stair 1.
Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.

Alice starts at stair 1.

Using an operation of the second type, she goes up 2^0 stairs to reach stair 2.
Using an operation of the first type, she goes down 1 stair to reach stair 1.

Alice starts at stair 1.

Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^0 stairs to reach stair 1.
Using an operation of the first type, she goes down 1 stair to reach stair 0.
Using an operation of the second type, she goes up 2^1 stairs to reach stair 2.
Using an operation of the first type, she goes down 1 stair to reach stair 1.

Constraints:

0 <= k <= 10^9


Даны два массива целых чисел nums1 и nums2 длины n и m соответственно. Также задано положительное целое число k. Пара (i, j) называется хорошей, если nums1[i] делится на nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1). Вернуть общее количество хороших пар.

Пример 1:

Входные данные: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Выходные данные: 5
Объяснение:
5 хороших пар - это (0, 0), (1, 0), (1, 1), (2, 0) и (2, 2).

Пример 2:

Входные данные: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Выходные данные: 2
Объяснение:
2 хорошие пары - это (3, 0) и (3, 1).

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

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50

Вам даны 2 целочисленных массива nums1 и nums2 длиной n и m соответственно. Вам также дано положительное целое число k.
Пара (i, j) называется хорошей, если nums1[i] делится на nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Вернуть общее количество хороших пар.

Пример 1:

Входные данные: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Выходные данные: 5
Объяснение:
5 хороших пар: (0, 0), (1, 0), (1, 1), (2, 0) и (2, 2).
Пример 2:

Вход: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Выход: 2
Объяснение:
2 хорошие пары: (3, 0) и (3, 1).

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

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50

Вам даны 2 целочисленных массива nums1 и nums2 длиной n и m соответственно. Вам также дано положительное целое число k.
Пара (i, j) называется хорошей, если nums1[i] делится на nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Вернуть общее количество хороших пар.

Пример 1:

Входные данные: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Выходные данные: 5
Объяснение:
5 хороших пар: (0, 0), (1, 0), (1, 1), (2, 0), и (2, 2).
Пример 2:

Вход: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Выход: 2
Объяснение:
2 хорошие пары: (3, 0) и (3, 1).

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

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50


Дана строка word, сжать её, используя следующий алгоритм:

Начните с пустой строки comp. Пока word не пуста, используйте следующую операцию:

Удалите максимальный префикс word, состоящий из одного символа c, повторяющегося не более 9 раз.
Добавьте длину префикса, за которой следует c, к comp.

Верните строку comp.

Пример 1:

Input: word = "abcde"
Output: "1a1b1c1d1e"
Объяснение:
Изначально comp = "". Примените операцию 5 раз, выбирая "a", "b", "c", "d" и "e" в качестве префикса в каждой операции.
Для каждого префикса добавьте "1", а затем символ в comp.

Пример 2:

Input: word = "aaaaaaaaaaaaaabb"
Output: "9a5a2b"
Объяснение:
Изначально comp = "". Примените операцию 3 раза, выбирая "aaaaaaaaa", "aaaaa" и "bb" в качестве префикса в каждой операции.

Для префикса "aaaaaaaaa" добавьте "9", а затем "a" в comp.
Для префикса "aaaaa" добавьте "5", а затем "a" в comp.
Для префикса "bb" добавьте "2", а затем "b" в comp.

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

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

Учитывая строковое слово, сжимаем его, используя следующий алгоритм:

Начните с пустой строки comp. Пока слово не пусто, используйте следующую операцию:

Удалить префикс максимальной длины слова, состоящего из одного символа c, повторяющегося не более 9 раз.
Добавьте длину префикса, за которым следует c к comp.

Верните строку comp.

Пример 1:

Ввод: word = "abcde"
Вывод: "1a1b1c1d1e"
Объяснение:
Изначально, comp = "". Примените операцию 5 раз, выбирая префиксы "a", "b", "c", "d", и "e" в каждой операции.
К каждому префиксу добавьте "1", а затем символ для comp.

Пример 2:

Ввод: word = "aaaaaaaaaaaaaabb"
Вывод: "9a5a2b"
Объяснение:
Изначально comp = "". Примените операцию 3 раза, выбирая "aaaaaaaaa", "aaaaa", и "bb" в качестве префикса для каждой операции.

Для префикса "aaaaaaaaa", добавьте "9", а затем "a" к comp.
Для префикса "aaaaa", добавьте "5", а затем "a" к comp.
Для префикса "bb", добавьте "2", а затем "b" к comp.

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

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

Дана строка word, сожмите ее, используя следующий алгоритм:

Начните с пустой строки comp. Пока word не пусто, используйте следующую операцию:

Удалите префикс максимальной длины word, состоящий из одного символа c, повторяющегося не более 9 раз.
Добавьте длину префикса, за которым следует c, к comp.

Верните строку comp.

Пример 1:

Вход: word = "abcde"
Выход: "1a1b1c1d1e"
Пояснение:
Изначально comp = "". Примените операцию 5 раз, выбрав "a", "b", "c", "d" и "e" в качестве префикса в каждой операции.
Для каждого префикса добавьте "1", за которым следует символ comp.

Пример 2:

Вход: word = "aaaaaaaaaaaaabb"
Выход: "9a5a2b"
Пояснение:
Изначально comp = "". Примените операцию 3 раза, выбрав «aaaaaaaaa», «aaaaa» и «bb» в качестве префикса в каждой операции.

Для префикса «aaaaaaaaa» добавьте «9» и «a» к comp.
Для префикса «aaaaa» добавьте «5» и «a» к comp.
Для префикса «bb» добавьте «2» и «b» к comp.

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

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


Вам дан массив nums, состоящий из целых чисел. Вам также дан 2D массив queries, где queries[i] = [pos_i, x_i].
Для запроса i мы сначала устанавливаем nums[pos_i] равным x_i, затем вычисляем ответ на запрос i, который является максимальной суммой подпоследовательности nums, в которой не выбраны два соседних элемента.
Верните сумму ответов на все запросы.
Поскольку окончательный ответ может быть очень большим, верните его по модулю 10^9 + 7.
Подпоследовательность — это массив, который можно получить из другого массива, удалив некоторые или никакие элементы, не изменяя порядок оставшихся элементов.

Пример 1:

Ввод: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Вывод: 21
Объяснение:
После первого запроса, nums = [3,-2,9] и максимальная сумма подпоследовательности с несмежными элементами равна 3 + 9 = 12.
После второго запроса nums = [-3,-2,9] и максимальная сумма подпоследовательности с несмежными элементами равна 9.

Пример 2:

Ввод: nums = [0,-1], queries = [[0,-5]]
Вывод: 0
Объяснение:
После первого запроса nums = [-5,-1] и максимальная сумма подпоследовательности с несмежными элементами равна 0 (выбор пустой подпоследовательности).

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

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

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

Пример 1:

Ввод: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Вывод: 21
Объяснение:
После 1-го запроса nums = [3,-2,9] и максимальная сумма подпоследовательности с не соседними элементами равна 3 + 9 = 12.
После 2-го запроса nums = [-3,-2,9] и максимальная сумма подпоследовательности с не соседними элементами равна 9.

Пример 2:

Ввод: nums = [0,-1], queries = [[0,-5]]
Вывод: 0
Объяснение:
После 1-го запроса nums = [-5,-1] и максимальная сумма подпоследовательности с не соседними элементами равна 0 (выбор пустой подпоследовательности).

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

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

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

Пример 1:

Вход: nums = [3,5,9], requests = [[1,-2],[0,-3]]
Выход: 21
Пояснение:
После 1-го запроса nums = [3,-2,9] и максимальная сумма подпоследовательности с несмежными элементами равна 3 + 9 = 12.
После 2-го запроса nums = [-3,-2,9] и максимальная сумма подпоследовательности с несмежными элементами равна 9.

Пример 2:

Вход: nums = [0,-1], requests = [[0,-5]]
Выход: 0
Пояснение:
После 1-го запроса nums = [-5,-1] и максимальная сумма подпоследовательности с несмежными элементами равна 0 (выбор пустой подпоследовательности).

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

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= requests.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5


Дана строка s, вам нужно разбить её на одну или более сбалансированных подстрок. Например, если s == "ababcc", то ("abab", "c", "c"), ("ab", "abc", "c") и ("ababcc") — все это допустимые разбиения, но ("a", "bab", "cc"), ("aba", "bc", "c") и ("ab", "abcc") — нет. Несбалансированные подстроки выделены жирным шрифтом.
Верните минимальное количество подстрок, на которые можно разбить s.
Примечание: Сбалансированная строка — это строка, в которой каждый символ встречается одинаковое количество раз.

Пример 1:

Ввод: s = "fabccddg"
Вывод: 3
Объяснение:
Мы можем разбить строку s на 3 подстроки одним из следующих способов: ("fab, "ccdd", "g") или ("fabc", "cd", "dg").

Пример 2:

Ввод: s = "abababaccddb"
Вывод: 2
Объяснение:
Мы можем разбить строку s на 2 подстроки следующим образом: ("abab", "abaccddb").

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

1 <= s.length <= 1000
s consists only of English lowercase letters.

Дана строка s, вам нужно разбить её на одну или более сбалансированных подстрок. Например, если s == "ababcc", то ("abab", "c", "c"), ("ab", "abc", "c") и ("ababcc") — все это допустимые разбиения, но ("a", "bab", "cc"), ("aba", "bc", "c") и ("ab", "abcc") — нет. Несбалансированные подстроки выделены жирным шрифтом.
Верните минимальное количество подстрок, на которые можно разбить s.
Примечание: Сбалансированная строка — это строка, в которой каждый символ встречается одинаковое количество раз.

Пример 1:

Ввод: s = "fabccddg"
Вывод: 3
Объяснение:
Мы можем разбить строку s на 3 подстроки одним из следующих способов: ("fab, "ccdd", "g") или ("fabc", "cd", "dg").

Пример 2:

Ввод: s = "abababaccddb"
Вывод: 2
Объяснение:
Мы можем разбить строку s на 2 подстроки следующим образом: ("abab", "abaccddb").

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

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


Мощный массив для целого числа x — это самый короткий отсортированный массив степеней двойки, который в сумме дает x. Например, мощный массив для 11 это [1, 2, 8].
Массив big_nums создается путем конкатенации мощных массивов для каждого положительного целого числа i в порядке возрастания: 1, 2, 3 и так далее. Таким образом, big_nums начинается как [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
Вам дана двумерная матрица целых чисел queries, где для queries[i] = [from_i, to_i, mod_i] вы должны вычислить (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Верните массив целых чисел answer, такой что answer[i] это ответ на i-й запрос.

Пример 1:

Ввод: queries = [[1,3,7]]
Вывод: [4]
Объяснение:
Есть один запрос.
big_nums[1..3] = [2,1,2]. Их произведение равно 4. Остаток от деления 4 на 7 равен 4.

Пример 2:

Ввод: queries = [[2,5,3],[7,7,4]]
Вывод: [2,2]
Объяснение:
Есть два запроса.
Первый запрос: big_nums[2..5] = [1,2,4,1]. Их произведение равно 8. Остаток от деления 8 на 3 равен 2.
Второй запрос: big_nums[7] = 2. Остаток от деления 2 на 4 равен 2.

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

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5

Мощный массив для целого числа x — это кратчайший отсортированный массив степеней двойки, которые в сумме дают x. Например, мощный массив для 11 — это [1, 2, 8].
Массив big_nums создается путем конкатенации мощных массивов для каждого положительного целого числа i в порядке возрастания: 1, 2, 3 и т. д. Таким образом, big_nums начинается как [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
Вам дана двумерная целочисленная матрица requests, где для requests[i] = [from_i, to_i, mod_i] вы должны вычислить (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Верните ответ в виде целочисленного массива, такой что answer[i] является ответом на i^th запрос.

Пример 1:

Вход: queries = [[1,3,7]]
Выход: [4]
Пояснение:
Есть один запрос.
big_nums[1..3] = [2,1,2]. Их произведение равно 4. Остаток от 4 под 7 равен 4.

Пример 2:

Вход: queries = [[2,5,3],[7,7,4]]
Выход: [2,2]
Пояснение:
Есть два запроса.
Первый запрос: big_nums[2..5] = [1,2,4,1]. Их произведение равно 8. Остаток от 8 под 3 равен 2.
Второй запрос: big_nums[7] = 2. Остаток от 2 под 4 равен 2.

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

1 <= requests.length <= 500
queries[i].length == 3
0 <= requests[i][0] <= requests[i][1] <= 10^15
1 <= requests[i][2] <= 10^5

Мощный массив для целого числа x — это кратчайший отсортированный массив степеней двойки, которые в сумме дают x. Например, мощный массив для 11 — это [1, 2, 8].
Массив big_nums создается путем конкатенации мощных массивов для каждого положительного целого числа i в порядке возрастания: 1, 2, 3 и т. д. Таким образом, big_nums начинается как [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
Вам дана двумерная целочисленная матрица requests, где для requests[i] = [from_i, to_i, mod_i] вы должны вычислить (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Верните ответ в виде целочисленного массива, такой что answer[i] является ответом на i^th запрос.

Пример 1:

Вход: queries = [[1,3,7]]
Выход: [4]
Пояснение:
Есть один запрос.
big_nums[1..3] = [2,1,2]. Их произведение равно 4. Остаток от 4 под 7 равен 4.

Пример 2:

Вход: queries = [[2,5,3],[7,7,4]]
Выход: [2,2]
Пояснение:
Есть два запроса.
Первый запрос: big_nums[2..5] = [1,2,4,1]. Их произведение равно 8. Остаток от 8 под 3 равен 2.
Второй запрос: big_nums[7] = 2. Остаток от 2 под 4 равен 2.

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

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5


Вам дан массив nums, где каждое число в массиве встречается один или два раза.
Верните побитовое XOR всех чисел, которые встречаются в массиве дважды, или 0, если ни одно число не встречается дважды.

Пример 1:

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

Пример 2:

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

Пример 3:

Входные данные: nums = [1,2,2,1]
Выходные данные: 3
Пояснение:
Числа 1 и 2 встречаются дважды. 1 XOR 2 == 3.

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

1 <= nums.length <= 50
1 <= nums[i] <= 50
Каждое число в nums встречается один или два раза.

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

Пример 1:

Ввод: Nums = [1,2,1,3]
Вывод: 1
Объяснение:
Единственное число, которое появляется дважды в nums, — это 1.

Пример 2:

Ввод: nums = [1,2,3]
Вывод: 0
Объяснение:
Никакое число не появляется дважды в nums.

Пример 3:

Ввод: nums = [1,2,2,1]
Вывод: 3
Объяснение:
Числа 1 и 2 появляются дважды. 1 XOR 2 = 3.

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

1 <= nums.length <= 50
1 <= nums [i] <= 50
Каждое число в Nums появляется один или два раза.

Вам дан массив nums, где каждое число в массиве появляется либо один раз, либо дважды.
Верните поразрядное XOR всех чисел, которые появляются дважды в массиве, или 0, если ни одно число не появляется дважды.

Пример 1:

Input: nums = [1,2,1,3]
Output: 1
Пояснение:
Единственное число, которое появляется дважды в nums, это 1.

Пример 2:

Input: nums = [1,2,3]
Output: 0
Пояснение:
Ни одно число не появляется дважды в nums.

Пример 3:

Input: nums = [1,2,2,1]
Output: 3
Пояснение:
Числа 1 и 2 появились дважды. 1 XOR 2 == 3.

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

1 <= nums.length <= 50
1 <= nums[i] <= 50
Каждое число в nums появляется либо один раз, либо дважды.


Вам дан целочисленный массив nums, целочисленный массив queries и целое число x.
Для каждого queries[i] необходимо найти индекс queries[i]-го вхождения x в массив nums. Если вхождений x меньше, чем queries[i], ответом для этого запроса должно быть -1.
Верните целочисленный массив answer, содержащий ответы на все запросы.

Пример 1:

Ввод: nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Вывод: [0,-1,2,-1]
Объяснение:

Для 1-го запроса первое вхождение 1 находится по индексу 0.
Для 2-го запроса в массиве nums только два вхождения 1, поэтому ответ -1.
Для 3-го запроса второе вхождение 1 находится по индексу 2.
Для 4-го запроса в массиве nums только два вхождения 1, поэтому ответ -1.

Пример 2:

Ввод: nums = [1,2,3], queries = [10], x = 5
Вывод: [-1]
Объяснение:

Для 1-го запроса 5 не существует в nums, поэтому ответ -1.

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

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4

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

Пример 1:

Ввод:  nums= [1,3,1,7], queries= [1,3,2,4], x = 1
Вывод: [0, -1,2, -1]
Объяснение:

Для первого запроса первое вхождение 1 находится в индексе 0.
Для второго запроса есть только два вхождения 1 в nums, поэтому ответ составляет -1.
Для третьего запроса второе вхождение 1 находится в индексе 2.
Для четвертого запроса есть только два вхождения 1 в nums, поэтому ответ составляет -1.

Пример 2:

Ввод: nums = [1,2,3], queries = [10], x = 5
Вывод: [-1]
Объяснение:

Для запроса 1^ST 5 не существует в nums поэтому ответ составляет -1

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

1 <= nums.length,queries.length <= 10^5
1 <= queries [i] <= 10^5
1 <= nums [i], x <= 10^4

Вам даны целочисленный массив nums, массив запросов queries и целое число x.
Для каждого запроса queries[i], вы должны найти индекс i-того вхождения x в массиве nums.Если в массиве nums меньше queries[i] вхождений числа x, то ответ на этот запрос должен быть -1.
Вернуть ответ массива integer, содержащий ответы на все запросы.

Пример 1:

Ввод: nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Вывод: [0,-1,2,-1]
Пояснение:

Для первого запроса, первое появление 1 находится в индексе 0.
Для второго запроса, есть только два случая 1 в nums, так что ответ -1.
Для запроса третьего второе появление 1 находится в индексе 2.
Для четвертого запроса, есть только два случая 1 в nums, так что ответ -1.

Пример 2:

Ввод: nums = [1,2,3], queries = [10], x = 5
Вывод: [-1]
Пояснение:

Для первого запроса, 5 не существует в nums, так что ответ -1.

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

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4


Даны положительные целые числа N, L и R.
Для последовательности A = (1, 2, \dots, N) длины N была выполнена операция реверса элементов с L-го по R-й один раз.
Выведите последовательность после этой операции.

Ввод

Вводится из стандартного ввода в следующем формате:
N L R

Вывод

Пусть A' = (A'_1, A'_2, \dots, A'_N) — последовательность после операции. Выведите ее в следующем формате:
A'_1 A'_2 \dots A'_N

Ограничения

- Все входные значения являются целыми числами.
- 1 \leq L \leq R \leq N \leq 100

Пример ввода 1

5 2 3

Пример вывода 1

1 3 2 4 5

Изначально A = (1, 2, 3, 4, 5).
После реверса элементов со второго по третий, последовательность становится (1, 3, 2, 4, 5), что и следует вывести.

Пример ввода 2

7 1 1

Пример вывода 2

1 2 3 4 5 6 7

Возможно, что L = R.

Пример ввода 3

10 1 10

Пример вывода 3

10 9 8 7 6 5 4 3 2 1

Возможно, что L = 1 или R = N.

Вам даны положительные целые числа N, L и R.
Для последовательности A = (1, 2, \dots, N) длины N была выполнена операция обращения элементов с L-го по R-й один раз.
Выведите последовательность после этой операции.

Ввод

Ввод дается из стандартного ввода в следующем формате:
N L R

Вывод

Пусть A' = (A'_1, A'_2, \dots, A'_N) будет последовательностью после операции. Выведите ее в следующем формате:
A'_1 A'_2 \dots A'_N

Ограничения

- Все входные значения являются целыми числами.
- 1 \leq L \leq R \leq N \leq 100

Пример ввода 1

5 2 3

Пример вывода 1

1 3 2 4 5

Изначально A = (1, 2, 3, 4, 5).
После перестановки второго по третий элементы последовательность становится (1, 3, 2, 4, 5), что и следует напечатать.

Пример ввода 2

7 1 1

Пример вывода 2

1 2 3 4 5 6 7

Возможно, L = R.

Пример ввода 3

10 1 10

Пример вывода 3

10 9 8 7 6 5 4 3 2 1

Возможно, L = 1 или R = N.


Даны целые числа N и M. Вычислите сумму \displaystyle \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M) по модулю 998244353.
Здесь \mathbin{\&} представляет операцию побитового \rm{AND}.
Что такое побитовое \rm{AND}?
Результат x = a \mathbin{\&} b операции побитового \rm{AND} между неотрицательными целыми числами a и b определяется следующим образом:

- x — это единственное неотрицательное целое число, удовлетворяющее следующим условиям для всех неотрицательных целых чисел k:

- Если разряд 2^k в двоичном представлении a и разряд 2^k в двоичном представлении b оба равны 1, то разряд 2^k в двоичном представлении x равен 1.
- В противном случае, разряд 2^k в двоичном представлении x равен 0.

Например, 3=11_{(2)} и 5=101_{(2)}, поэтому 3 \mathbin{\&} 5 = 1.

Что такое \rm{popcount}?
\rm{popcount}(x) представляет количество 1 в двоичном представлении x.
Например, 13=1101_{(2)}, поэтому \rm{popcount}(13) = 3.

Вход

Входные данные поступают из стандартного ввода в следующем формате:
N M

Выход

Выведите ответ как целое число.

Ограничения

- N — целое число от 0 до 2^{60} - 1 включительно.
- M — целое число от 0 до 2^{60} - 1 включительно.

Пример входных данных 1

4 3

Пример выходных данных 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

Сумма этих значений равна 4.

Пример входных данных 2

0 0

Пример выходных данных 2

0

Возможно, что N = 0 или M = 0.

Пример входных данных 3

1152921504606846975 1152921504606846975

Пример выходных данных 3

499791890

Не забудьте вычислить результат по модулю 998244353.

Даны целые числа N и M, вычислите сумму \displaystyle \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M) по модулю 998244353.
Здесь \mathbin{\&} представляет собой побитовую операцию \rm{AND}.
Что такое побитовая операция \rm{AND}?
Результат x = a \mathbin{\&} b побитовой операции \rm{AND} между неотрицательными целыми числами a и b определяется следующим образом:

- x — это уникальное неотрицательное целое число, которое удовлетворяет следующим условиям для всех неотрицательных целых чисел k:

- Если 2^k место в двоичном представлении a и 2^k место в двоичном представлении b оба равны 1, то 2^k место в двоичном представлении x равно 1.
- В противном случае 2^k место в двоичном представлении x равно 0.

Например, 3=11_{(2)} и 5=101_{(2)}, поэтому 3 \mathbin{\&} 5 = 1.

Что такое \rm{popcount}?
\rm{popcount}(x) представляет количество единиц в двоичном представлении x.
Например, 13=1101_{(2)}, поэтому \rm{popcount}(13) = 3.

Входные данные

Входные данные даются из стандартного ввода в следующем формате:
N M

Выходные данные

Выведите ответ как целое число.

Ограничения

- N — целое число от 0 до 2^{60} - 1 включительно.
- M — целое число от 0 до 2^{60} - 1 включительно.

Пример ввода 1

4 3

Пример вывода 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

Сумма этих значений равна 4.

Пример ввода 2

0 0

Пример вывода 2

0

Возможно, N = 0 или M = 0.

Пример ввода 3

1152921504606846975 1152921504606846975

Пример вывода 3

499791890

Не забудьте вычислить результат по модулю 998244353.

Учитывая целые числа N и M, вычислите sum \displaystyle \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M), modulo 998244353.
Here, \mathbin{\&} представляет побитовую операцию \rm{AND}.
Что такое побитовая операция \rm{И}?
Результат x = a \mathbin{\&} b побитовой операции \rm{AND} между неотрицательными целыми числами a и b определяется следующим образом:

- x это уникальное неотрицательное целое число, которое удовлетворяет следующим условиям для всех неотрицательных целых чисел k:

- Если место 2^k в двоичном представлении a и место 2^k в двоичном представлении b равны 1, то место 2^k в двоичном представлении x равно 1.
- В противном случае место 2^k в двоичном представлении x равно 0.

Например, 3=11_{(2)} and 5=101_{(2)}, so 3 \mathbin{\&} 5 = 1.

Что такое \rm{popcount}?
\rm{popcount}(x) представляет количество единиц в двоичном представлении x.
Например, 13=1101_{(2)}, поэтому \rm{popcount}(13) = 3.

Ввод

Вводные данные передаются из стандартного ввода в следующем формате:
N M

Вывод

Выведите ответ в виде целого числа.

Ограничения

- N представляет собой целое число от 0 до 2^{60} - 1, включительно.
- M представляет собой целое число от 0 до 2^{60} - 1, включительно.

Пример ввода 1

4 3

Пример вывода 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

Сумма этих значений равна 4.

Пример ввода 2

0 0

Пример вывода 2

0

Возможно, что N = 0 или M = 0.

Пример ввода 3

1152921504606846975 1152921504606846975

Пример вывода 3

499791890

Не забудьте вычислить результат по модулю 998244353.


Дана последовательность A=(A_1,\ldots,A_N) длины N.
Найдите \displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^{N}\left\lfloor\frac{\max(A_i,A_j)}{\min(A_i,A_j)}\right\rfloor.
Здесь \lfloor x \rfloor обозначает наибольшее целое число, не превосходящее x. Например, \lfloor 3.14 \rfloor=3 и \lfloor 2 \rfloor=2.

Ввод

Вводится из стандартного ввода в следующем формате:
N
A_1 \ldots A_N

Вывод

Выведите ответ.

Ограничения

- 2 \leq N \leq 2\times 10^5
- 1 \leq A_i \leq 10^6
- Все входные значения - целые числа.

Пример ввода 1

3
3 1 4

Пример вывода 1

8

Искомое значение:
\left\lfloor\frac{\max(3,1)}{\min(3,1)}\right\rfloor + \left\lfloor\frac{\max(3,4)}{\min(3,4)}\right\rfloor + \left\lfloor\frac{\max(1,4)}{\min(1,4)}\right\rfloor\\ =\left\lfloor\frac{3}{1}\right\rfloor + \left\lfloor\frac{4}{3}\right\rfloor + \left\lfloor\frac{4}{1}\right\rfloor\\ =3+1+4\\ =8.

Пример ввода 2

6
2 7 1 8 2 8

Пример вывода 2

53

Пример ввода 3

12
3 31 314 3141 31415 314159 2 27 271 2718 27182 271828

Пример вывода 3

592622

Вам дана последовательность A=(A_1,\ldots,A_N) длины N.
Найдите \displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^{N}\left\lfloor\frac{\max(A_i,A_j)}{\min(A_i,A_j)}\right\rfloor.
Здесь \lfloor x \rfloor представляет наибольшее целое число, не большее x. Например, \lfloor 3.14 \rfloor=3 и \lfloor 2 \rfloor=2.

Входные данные

Входные данные даются из стандартного ввода в следующем формате:
N
A_1 \ldots A_N

Выходные данные

Выведите ответ.

Ограничения

- 2 \leq N \leq 2\times 10^5
- 1 \leq A_i \leq 10^6
- Все входные значения являются целыми числами.

Пример ввода 1

3
3 1 4

Пример вывода 1

8

Искомое значение равно
\left\lfloor\frac{\max(3,1)}{\min(3,1)}\right\rfloor + \left\lfloor\frac{\max(3,4)}{\min(3,4)}\right\rfloor + \left\lfloor\frac{\max(1,4)}{\min(1,4)}\right\rfloor\\ =\left\lfloor\frac{3}{1}\right\rfloor + \left\lfloor\frac{4}{3}\right\rfloor + \left\lfloor\frac{4}{1}\right\rfloor\\ =3+1+4\\ =8.

Пример ввода 2

6
2 7 1 8 2 8

Пример вывода 2

53

Пример ввода 3

12
3 31 314 3141 31415 314159 2 27 271 2718 27182 271828

Пример вывода 3

592622


У вас есть N ключей с номерами 1, 2, \dots, N.
Некоторые из них настоящие, а другие — фиктивные.
Есть дверь, Дверь X, в которую вы можете вставить любое количество ключей. Дверь X откроется, если и только если вставлено не менее K настоящих ключей.
Вы провели M тестов с этими ключами. i-й тест прошел следующим образом:

- Вы вставили C_i ключей A_{i,1}, A_{i,2}, \dots, A_{i,C_i} в Дверь X.
- Результат теста представлен одной английской буквой R_i.
- R_i = o означает, что Дверь X открылась в i-м тесте.
- R_i = x означает, что Дверь X не открылась в i-м тесте.

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

Входные данные

Входные данные даются из стандартного ввода в следующем формате:
N M K
C_1 A_{1,1} A_{1,2} \dots A_{1,C_1} R_1
C_2 A_{2,1} A_{2,2} \dots A_{2,C_2} R_2
\vdots
C_M A_{M,1} A_{M,2} \dots A_{M,C_M} R_M

Выходные данные

Выведите ответ в виде целого числа.

Ограничения

- N, M, K, C_i и A_{i,j} являются целыми числами.
- 1 \le K \le N \le 15
- 1 \le M \le 100
- 1 \le C_i \le N
- 1 \le A_{i,j} \le N
- A_{i,j} \neq A_{i,k} если j \neq k.
- R_i равно o или x.

Пример ввода 1

3 2 2
3 1 2 3 o
2 2 3 x

Пример вывода 1

2

В этом вводе есть три ключа, и было проведено два теста.
Для открытия Двери X требуются два правильных ключа.

- В первом тесте были использованы ключи 1, 2, 3, и Дверь X открылась.
- Во втором тесте были использованы ключи 2, 3, и Дверь X не открылась.

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

- Ключ 1 настоящий, ключ 2 - фиктивный, а ключ 3 - настоящий.
- Ключ 1 настоящий, ключ 2 - настоящий, а ключ 3 - фиктивный.

Пример ввода 2

4 5 3
3 1 2 3 o
3 2 3 4 o
3 3 4 1 o
3 4 1 2 o
4 1 2 3 4 x

Пример вывода 2

0

Как указано в условии задачи, ответ может быть 0.

Пример ввода 3

11 4 9
10 1 2 3 4 5 6 7 8 9 10 o
11 1 2 3 4 5 6 7 8 9 10 11 o
10 11 10 9 8 7 6 5 4 3 2 x
10 11 9 1 4 3 7 5 6 2 10 x

Пример вывода 3

8

У вас есть N ключей с номерами 1, 2, \dots, N.
Некоторые из них — настоящие ключи, а остальные — муляжи.
Есть дверь, Дверь X, в которую можно вставить любое количество ключей. Дверь X откроется тогда и только тогда, когда вставлено не менее K настоящих ключей.
Вы провели M тестов с этими ключами. i-й тест проводился следующим образом:

- Вы вставили C_i ключей A_{i,1}, A_{i,2}, \dots, A_{i,C_i} в Дверь X.
- Результат теста представлен одной английской буквой R_i.
- R_i = o означает, что Дверь X открылась в i-м тесте.
- R_i = x означает, что Дверь X не открылась в i-м тесте.

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

Ввод

Ввод поступает со стандартного ввода в следующем формате:
N M K
C_1 A_{1,1} A_{1,2} \dots A_{1,C_1} R_1
C_2 A_{2,1} A_{2,2} \dots A_{2,C_2} R_2
\vdots
C_M A_{M,1} A_{M,2} \dots A_{M,C_M} R_M

Вывод

Выведите ответ в виде целого числа.

Ограничения

- N, M, K, C_i, и A_{i,j} — целые числа.
- 1 \le K \le N \le 15
- 1 \le M \le 100
- 1 \le C_i \le N
- 1 \le A_{i,j} \le N
- A_{i,j} \neq A_{i,k} если j \neq k.
- R_i является o или x.

Пример ввода 1

3 2 2
3 1 2 3 o
2 2 3 x

Пример вывода 1

2

В этом вводе имеется три ключа и было проведено два теста.
Для открытия Двери X требуется два настоящих ключа.

- В первом тесте использовались ключи 1, 2, 3, и Дверь X открылась.
- Во втором тесте использовались ключи 2, 3, и Дверь X не открылась.

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

- Ключ 1 настоящий, ключ 2 — муляж, и ключ 3 настоящий.
- Ключ 1 настоящий, ключ 2 настоящий, и ключ 3 — муляж.

Пример ввода 2

4 5 3
3 1 2 3 o
3 2 3 4 o
3 3 4 1 o
3 4 1 2 o
4 1 2 3 4 x

Пример вывода 2

0

Как указано в условии задачи, ответ может быть 0.

Пример ввода 3

11 4 9
10 1 2 3 4 5 6 7 8 9 10 o
11 1 2 3 4 5 6 7 8 9 10 11 o
10 11 10 9 8 7 6 5 4 3 2 x
10 11 9 1 4 3 7 5 6 2 10 x

Пример вывода 3

8


Такахаши заботится о своем здоровье и обеспокоен тем, получает ли он достаточно M типов питательных веществ из своего рациона.
Для i-го питательного вещества его цель — принимать не менее A_i единиц в день.
Сегодня он съел N продуктов, и из i-го продукта он принял X_{i,j} единиц питательного вещества j.
Определите, достиг ли он цели по всем M типам питательных веществ.

Ввод

Вводные данные даются из стандартного ввода в следующем формате:
N M
A_1 \ldots A_M
X_{1,1} \ldots X_{1,M}
\vdots
X_{N,1} \ldots X_{N,M}

Вывод

Выведите Yes, если цель достигнута по всем M типам питательных веществ, и No в противном случае.

Ограничения

- 1 \leq N \leq 100
- 1 \leq M \leq 100
- 0 \leq A_i, X_{i,j} \leq 10^7
- Все входные значения являются целыми числами.

Пример ввода 1

2 3
10 20 30
20 0 10
0 100 100

Пример вывода 1

Yes

Для питательного вещества 1 Такахаши взял 20 единиц из 1-й пищи и 0 единиц из 2-й пищи, что в сумме составляет 20 единиц, таким образом достигнув цели взять не менее 10 единиц.
Аналогично он достигает цели по питательным веществам 2 и 3.

Пример ввода 2

2 4
10 20 30 40
20 0 10 30
0 100 100 0

Пример вывода 2

No

Цель не достигнута по питательному веществу 4.

Такахаси заботится о здоровье и беспокоится о том, получает ли он достаточно M видов питательных веществ из своего рациона.
Для i-го питательного вещества его цель — потреблять минимум A_i единиц в день.
Сегодня он съел N продуктов, и из i-го продукта он получил X_{i,j} единиц питательного вещества j.
Определите, достиг ли он цели для всех M видов питательных веществ.

Ввод

Ввод предоставляется через стандартный ввод в следующем формате:
N M
A_1 \ldots A_M
X_{1,1} \ldots X_{1,M}
\vdots
X_{N,1} \ldots X_{N,M}

Вывод

Выведите Yes, если цель достигнута для всех M видов питательных веществ, и No в противном случае.

Ограничения

- 1 \leq N \leq 100
- 1 \leq M \leq 100
- 0 \leq A_i, X_{i,j} \leq 10^7
- Все значения ввода являются целыми числами.

Пример ввода 1

2 3
10 20 30
20 0 10
0 100 100

Пример вывода 1

Yes

Для питательного вещества 1 Такахаси получил 20 единиц из 1-го продукта и 0 единиц из 2-го продукта, в сумме 20 единиц, что соответствует цели минимум 10 единиц.
Аналогично, он достигает цели для питательных веществ 2 и 3.

Пример ввода 2

2 4
10 20 30 40
20 0 10 30
0 100 100 0

Пример вывода 2

No

Цель не достигнута для питательного вещества 4.


Для неотрицательного целого числа K мы определяем ковёр уровня K следующим образом:

- Ковёр уровня 0 — это сетка размером 1 \times 1, состоящая из одной чёрной ячейки.
- Для K > 0 ковёр уровня K представляет собой сетку размером 3^K \times 3^K. Когда эта сетка делится на девять блоков размером 3^{K-1} \times 3^{K-1}:
- Центральный блок состоит полностью из белых ячеек.
- Остальные восемь блоков — это ковры уровня (K-1).

Вам дано неотрицательное целое число N.
Выведите ковёр уровня N в указанном формате.

Входные данные

Входные данные подаются из стандартного ввода в следующем формате:
N

Выходные данные

Выведите 3^N строк.
i-я строка (1 \leq i \leq 3^N) должна содержать строку S_i длиной 3^N, состоящую из . и #.
j-й символ S_i (1 \leq j \leq 3^N) должен быть #, если ячейка в i-й строке сверху и j-м столбце слева ковра уровня N чёрная, и . если белая.

Ограничения

- 0 \leq N \leq 6
- N является целым числом.

Пример входных данных 1

1

Пример выходных данных 1

###
#.#
###

Ковёр уровня 1 — это сетка размером 3 \times 3 следующего вида:

Когда выводится в указанном формате, он выглядит как пример вывода.

Пример входных данных 2

2

Пример выходных данных 2

#########
#.##.##.#
#########
###...###
#.#...#.#
###...###
#########
#.##.##.#
#########

Ковёр уровня 2 — это сетка размером 9 \times 9.

Для неотрицательного целого числа K мы определяем ковёр уровня K следующим образом:

- Ковёр уровня 0 — это сетка размером 1 \times 1, состоящая из одной чёрной ячейки.
- Для K > 0 ковёр уровня K представляет собой сетку размером 3^K \times 3^K. Когда эта сетка делится на девять блоков размером 3^{K-1} \times 3^{K-1}:
- Центральный блок состоит полностью из белых ячеек.
- Остальные восемь блоков — это ковры уровня (K-1).

Вам дано неотрицательное целое число N.
Выведите ковёр уровня N в указанном формате.

Вход

Входные данные подаются из стандартного ввода в следующем формате:
N

Выход

Выведите 3^N строк.
i-я строка (1 \leq i \leq 3^N) должна содержать строку S_i длиной 3^N, состоящую из . и #.
j-й символ S_i (1 \leq j \leq 3^N) должен быть #, если ячейка в i-й строке сверху и j-м столбце слева ковра уровня N чёрная, и . если белая.

Ограничения

- 0 \leq N \leq 6
- N является целым числом.

Пример входных данных 1

1

Пример выходных данных 1

###
#.#
###

Ковёр уровня 1 — это сетка размером 3 \times 3 следующего вида:

Когда выводится в указанном формате, он выглядит как пример вывода.

Пример входных данных 2

2

Пример выходных данных 2

#########
#.##.##.#
#########
###...###
#.#...#.#
###...###
#########
#.##.##.#
#########

Ковёр уровня 2 — это сетка размером 9 \times 9.

Для неотрицательного целого числа K мы определяем ковер уровня K следующим образом:

- Ковер уровня 0 — это сетка 1 \times 1, состоящая из одной черной ячейки.
- При K > 0 ковер уровня K — это сетка 3^K \times 3^K. Когда эта сетка разделена на девять блоков 3^{K-1} \times 3^{K-1}:
- Центральный блок состоит полностью из белых ячеек.
- Остальные восемь блоков — это ковры уровня (K-1).

Вам дано неотрицательное целое число N.
Выведите ковер уровня N в соответствии с указанным форматом.

Ввод

Ввод дается из стандартного ввода в следующем формате:
N

Вывод

Выведите 3^N строк.
i-я строка (1 \leq i \leq 3^N) должна содержать строку S_i длины 3^N, состоящую из . и #.
j-й символ S_i (1 \leq j \leq 3^N) должен быть #, если ячейка в i-й строке сверху и j-м столбце слева ковра уровня N черная, и ., если она белая.

Ограничения

- 0 \leq N \leq 6
- N — целое число.

Пример ввода 1

1

Пример вывода 1

###
#.#
###

Ковер уровня 1 — это сетка 3 \times 3 следующим образом:

При выводе в соответствии с указанным форматом он выглядит как пример вывода.

Пример ввода 2

2

Пример вывода 2

#########
#.##.##.#
#########
###...###
#.#...#.#
###...###
#########
#.##.#.#
##########
#.##.#.#
#########

Ковер 2-го уровня — это сетка 9 \x 9.


Есть бутылка дезинфицирующего средства, которая может продезинфицировать ровно M рук.
N пришельцев приходят один за другим, чтобы продезинфицировать свои руки.
У i-го пришельца (1 \leq i \leq N) H_i рук, и он хочет продезинфицировать все свои руки один раз.
Определите, сколько пришельцев могут продезинфицировать все свои руки.
Здесь, даже если у пришельца не осталось достаточно дезинфицирующего средства, чтобы продезинфицировать все свои руки, когда они начнут, они израсходуют оставшееся дезинфицирующее средство.

Ввод

Вводные данные даются из стандартного ввода в следующем формате:
N M
H_1 H_2 \ldots H_N

Вывод

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

Ограничения

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- Все входные значения являются целыми числами.

Пример ввода 1

5 10
2 3 2 5 3

Пример вывода 1

3

Пришельцы дезинфицируют свои руки следующим образом:

- Первый инопланетянин дезинфицирует свои две руки. Оставшегося дезинфицирующего средства хватит на 10-2=8 рук.
- Второй инопланетянин дезинфицирует свои три руки. Оставшегося дезинфицирующего средства хватит на 8-3=5 рук.
- Третий инопланетянин дезинфицирует свои две руки. Оставшегося дезинфицирующего средства хватит на 5-2=3 руки.
- У четвертого инопланетянина пять рук, но дезинфицирующего средства хватит только на три руки, поэтому они используют дезинфицирующее средство, не продезинфицировав все руки.

Таким образом, первые три пришельца могут продезинфицировать все свои руки, поэтому выведите 3.

Пример ввода 2

5 10
2 3 2 3 5

Пример вывода 2

4

Пример ввода 3

1 5
1

Пример вывода 3

1

Все инопланетяне могут продезинфицировать свои руки.

Есть бутылка дезинфицирующего средства, которая может продезинфицировать ровно M рук.
N инопланетян приходят один за другим, чтобы продезинфицировать свои руки.
У i-го инопланетянина (1 \leq i \leq N) H_i рук, и он хочет продезинфицировать все свои руки один раз.
Определите, сколько инопланетян могут продезинфицировать все свои руки.
Здесь, даже если у инопланетян не осталось достаточно дезинфицирующего средства, чтобы продезинфицировать все свои руки, когда они начнут, они израсходуют оставшееся дезинфицирующее средство.

Input

The input is given from Standard Input in the following format:
N M
H_1 H_2 \ldots H_N

Output

Print the number of aliens who can disinfect all of their hands.

Constraints

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- All input values are integers.

Sample Input 1

5 10
2 3 2 5 3

Sample Output 1

3

The aliens disinfect their hands in the following steps:

- The first alien disinfects their two hands. The remaining disinfectant can disinfect 10-2=8 hands.
- The second alien disinfects their three hands. The remaining disinfectant can disinfect 8-3=5 hands.
- The third alien disinfects their two hands. The remaining disinfectant can disinfect 5-2=3 hands.
- The fourth alien has five hands, but there is only enough disinfectant for three hands, so they use up the disinfectant without disinfecting all of their hands.

Thus, the first three aliens can disinfect all of their hands, so print 3.

Sample Input 2

5 10
2 3 2 3 5

Sample Output 2

4

Sample Input 3

1 5
1

Sample Output 3

1

All aliens can disinfect their hands.

Есть флакон с дезинфицирующим средством, которым можно продезинфицировать ровно М рук.
N инопланетян приходят один за другим, чтобы продезинфицировать свои руки.
i-й инопланетянин (1 \leq i \leq N) имеет H_i рук и хочет продезинфицировать все свои руки по одному разу.
Определите, сколько инопланетян могут продезинфицировать все свои руки.
Здесь, даже если у инопланетянина не останется достаточного количества дезинфицирующего средства, чтобы продезинфицировать все руки, он израсходует оставшееся дезинфицирующее средство.

Input

The input is given from Standard Input in the following format:
N M
H_1 H_2 \ldots H_N

Output

Print the number of aliens who can disinfect all of their hands.

Constraints

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- All input values are integers.

Sample Input 1

5 10
2 3 2 5 3

Sample Output 1

3

The aliens disinfect their hands in the following steps:

- The first alien disinfects their two hands. The remaining disinfectant can disinfect 10-2=8 hands.
- The second alien disinfects their three hands. The remaining disinfectant can disinfect 8-3=5 hands.
- The third alien disinfects their two hands. The remaining disinfectant can disinfect 5-2=3 hands.
- The fourth alien has five hands, but there is only enough disinfectant for three hands, so they use up the disinfectant without disinfecting all of their hands.

Thus, the first three aliens can disinfect all of their hands, so print 3.

Sample Input 2

5 10
2 3 2 3 5

Sample Output 2

4

Sample Input 3

1 5
1

Sample Output 3

1

All aliens can disinfect their hands.


Для положительного целого числа N пусть V_N будет целым числом, сформированным путем конкатенации N ровно N раз.
Рассмотрим N как строку, конкатенируем N копий этой строки и обработаем результат как целое число, чтобы получить V_N.
Например, V_3=333 и V_{10}=10101010101010101010.
Найди остаток от деления V_N на 998244353.

Ввод

Ввод осуществляется посредством стандартного ввода в следующем формате:
N

Вывод

Выведи остаток от деления V_N на 998244353.

Ограничения

- 1 \leq N \leq 10^{18}
- N является целым числом.

Пример ввода 1

5

Пример вывода 1

55555

Остаток от деления V_5=55555 на 998244353 равен 55555.

Пример ввода 2

9

Пример вывода 2

1755646

Остаток от деления V_9=999999999 на 998244353 равен 1755646.

Пример ввода 3

10000000000

Пример вывода 3

468086693

Обрати внимание, что ввод может не соответствовать 32-битному целочисленному типу.

Для положительного целого числа N пусть V_N будет целым числом, сформированным путем конкатенации N равное N раз.
Более точно, рассматривайте N как строку, конкатенируйте N копий этой строки и считайте результат целым числом, чтобы получить V_N.
Например, V_3=333 и V_{10}=10101010101010101010.
Найдите остаток от деления V_N на 998244353.

Ввод

Ввод поступает из стандартного ввода в следующем формате:
N

Вывод

Выведите остаток от деления V_N на 998244353.

Ограничения

- 1 \leq N \leq 10^{18}
- N является целым числом.

Пример ввода 1

5

Пример вывода 1

55555

Остаток от деления V_5=55555 на 998244353 равен 55555.

Пример ввода 2

9

Пример вывода 2

1755646

Остаток от деления V_9=999999999 на 998244353 равен 1755646.

Пример ввода 3

10000000000

Пример вывода 3

468086693

Заметьте, что ввод может не поместиться в 32-битный целочисленный тип.

Для положительного целого числа N пусть V_N будет целым числом, сформированным путем конкатенации N равное N раз.
Более точно, рассматривайте N как строку, конкатенируйте N копий этой строки и считайте результат целым числом, чтобы получить V_N.
Например, V_3=333 and V_{10}=10101010101010101010.
Найдите остаток от деления V_N на 998244353.

Ввод

Ввод поступает из стандартного ввода в следующем формате:
N

Вывод

Выведите остаток от деления V_N на 998244353.

Ограничения

- 1 \leq N \leq 10^{18}
- N является целым числом.

Пример ввода 1

5

Пример вывода 1

55555

Остаток от деления V_5=55555 на 998244353 равен 55555.

Пример ввода 2

9

Пример вывода 2

1755646

Остаток от деления V_9=999999999 на 998244353 равен 1755646.

Пример ввода 3

10000000000

Пример вывода 3

468086693

Заметьте, что ввод может не поместиться в 32-битный целочисленный тип.


Дана строка S, состоящая из строчных и прописных английских букв. Длина S является нечетной.
Если количество прописных букв в S больше, чем количество строчных букв, преобразуйте все строчные буквы в S в прописные.
В противном случае преобразуйте все прописные буквы в S в строчные.

Ввод

Ввод предоставляется из стандартного ввода в следующем формате:
S

Вывод

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

Ограничения

- S — строка, состоящая из строчных и прописных английских букв.
- Длина S — нечетное число от 1 до 99 включительно.

Пример ввода 1

AtCoder

Пример вывода 1

atcoder

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

Пример ввода 2

SunTORY

Пример вывода 2

SUNTORY

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

Пример ввода 3

a

Пример вывода 3

a

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

Ввод

Вводные данные даются из стандартного ввода в следующем формате:
S

Вывод

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

Ограничения

- S — это строка, состоящая из строчных и прописных английских букв.
- Длина S — нечетное число от 1 до 99 включительно.

Пример ввода 1

AtCoder

Пример вывода 1

atcoder

Строка AtCoder содержит пять строчных букв и две заглавные буквы. Таким образом, преобразуйте все заглавные буквы в AtCoder в строчные, что даст atcoder.

Пример ввода 2

SunTORY

Пример вывода 2

SUNTORY

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

Пример ввода 3

a

Пример вывода 3

a


Имеется направленный граф с N вершинами, пронумерованными от 1 до N, и N ребрами.
Исходящая степень каждой вершины равна 1, а ребро из вершины i указывает на вершину a_i.
Подсчитайте количество пар вершин (u, v) таких, что вершина v достижима из вершины u.
Здесь вершина v достижима из вершины u, если существует последовательность вершин w_0, w_1, \dots, w_K длины K+1, которая удовлетворяет следующим условиям. В частности, если u = v, она всегда достижима.

- w_0 = u.
- w_K = v.
- Для каждого 0 \leq i \lt K существует ребро из вершины w_i в вершину w_{i+1}.

Ввод

Вводные данные задаются из стандартного ввода в следующем формате:
N
a_1 a_2 \dots a_N

Вывод

Выведите количество пар вершин (u, v), таких, что вершина v достижима из вершины u.

Ограничения

- 1 \leq N \leq 2 \times 10^5
- 1 \leq a_i \leq N
- Все входные значения являются целыми числами.

Пример ввода 1

4
2 1 1 4

Пример вывода 1

8

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

Пример ввода 2

5
2 4 3 1 2

Пример вывода 2

14

Пример ввода 3

10
6 10 4 1 5 9 8 6 5 1

Пример вывода 3

41

Дан ориентированный граф с N вершинами, пронумерованными от 1 до N, и N рёбер.
Степень исхода каждой вершины равна 1, и ребро из вершины i указывает на вершину a_i.
Посчитайте количество пар вершин (u, v) таких, что из вершины u достижима вершина v.
Здесь вершина v достижима из вершины u, если существует последовательность вершин w_0, w_1, \dots, w_K длиной K+1, удовлетворяющая следующим условиям. В частности, если u = v, то она всегда достижима.

- w_0 = u.
- w_K = v.
- Для каждого 0 \leq i \lt K существует ребро из вершины w_i в вершину w_{i+1}.

Ввод

Ввод дается из стандартного ввода в следующем формате:
N
a_1 a_2 \dots a_N

Вывод

Выведите количество пар вершин (u, v) таких, что из вершины u достижима вершина v.

Ограничения

- 1 \leq N \leq 2 \times 10^5
- 1 \leq a_i \leq N
- Все входные значения целые числа..

Пример ввода 1

4
2 1 1 4

Пример вывода 1

8

Вершины, достижимые из вершины 1, это вершины 1, 2.
Вершины, достижимые из вершины 2, это вершины 1, 2.
Вершины, достижимые из вершины 3, это вершины 1, 2, 3.
Вершина, достижимая из вершины 4, это вершина 4.
Таким образом, количество пар вершин (u, v) таких, что из вершины u достижима вершина v, равно 8.
Заметьте, что ребро из вершины 4 — это самопетля, то есть оно указывает на саму вершину 4.

Пример ввода 2

5
2 4 3 1 2

Пример вывода 2

14

Пример ввода 3

10
6 10 4 1 5 9 8 6 5 1

Пример вывода 3

41