Вам дан массив целых чисел start и целое число d, представляющее n интервалов [start[i], start[i] + d].
Вам нужно выбрать n целых чисел, где i-е число должно принадлежать i-му интервалу. Оценка выбранных чисел определяется как минимальная абсолютная разница между любыми двумя выбранными числами.
Верните максимальную возможную оценку выбранных чисел.

Пример 1:

Ввод: start = [6,0,3], d = 2
Вывод: 4
Объяснение:
Максимальная возможная оценка может быть получена, если выбрать числа: 8, 0 и 4. Оценка этих выбранных чисел равна min(|8 - 0|, |8 - 4|, |0 - 4|), что равно 4.

Пример 2:

Ввод: start = [2,6,13,13], d = 5
Вывод: 5
Объяснение:
Максимальная возможная оценка может быть получена, если выбрать числа: 2, 7, 13 и 18. Оценка этих выбранных чисел равна min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), что равно 5.

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

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Вам дан массив целых чисел start и целое число d, представляющее n интервалов [start[i], start[i] + d].
Вам предлагается выбрать n целых чисел, где i%-е целое число должно принадлежать i%-му интервалу. Количество выбранных целых чисел определяется как минимальная абсолютная разница между любыми двумя выбранными целыми числами.
Выведите максимально возможное количество выбранных целых чисел.

Пример 1:

Input: start = [6,0,3], d = 2
Output: 4
Explanation:
The maximum possible score can be obtained by choosing integers: 8, 0, and 4. The score of these chosen integers is min(|8 - 0|, |8 - 4|, |0 - 4|) which equals 4.

Пример 2:

Input: start = [2,6,13,13], d = 5
Output: 5
Explanation:
The maximum possible score can be obtained by choosing integers: 2, 7, 13, and 18. The score of these chosen integers is min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) which equals 5.

Constraints:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


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

Пример 1:

Входные данные: nums = [1,3,1,5]
Выходные данные: 7
Объяснение:
Сначала прыгните на индекс 1, а затем прыгните на последний индекс. Итоговое количество очков 1 * 1 + 2 * 3 = 7.

Пример 2:

Входные данные: nums = [4,3,1,3,2]
Выходные данные: 16
Объяснение:
Прыгните напрямую на последний индекс. Итоговое количество очков 4 * 4 = 16.

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

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

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

Пример 1:

Input: nums = [1,3,1,5]
Output: 7
Объяснение:
Сначала прыгните на индекс 1, а затем прыгните на последний индекс. Итоговое количество очков: 1 * 1 + 2 * 3 = 7.

Пример 2:

Input: nums = [4,3,1,3,2]
Output: 16
Объяснение:
Прыгните напрямую на последний индекс. Итоговое количество очков: 4 * 4 = 16.

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

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

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

Пример 1:

Входные данные: nums = [1,3,1,5]
Выходные данные: 7
Пояснение:
Сначала перейдите к индексу 1, а затем к последнему индексу. Окончательный счет: 1 * 1 + 2 * 3 = 7.

Пример 2:

Входные данные: nums = [4,3,1,3,2]
Выходные данные: 16
Пояснение:
Перейдите непосредственно к последнему индексу. Окончательный счет: 4 * 4 = 16.

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

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


На шахматной доске размером 50 x 50 находятся один конь и несколько пешек. Даны два целых числа kx и ky, где (kx, ky) обозначает позицию коня, и двумерный массив positions, где positions[i] = [x_i, y_i] обозначает позиции пешек на шахматной доске. Алиса и Боб играют в игру по очереди, Алиса ходит первой. В свой ход:

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

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

Пример 1:

Ввод: kx = 1, ky = 1, positions = [[0,0]]
Вывод: 4
Пояснение:

Конь делает 4 хода, чтобы достичь пешки на (0, 0).

Пример 2:

Ввод: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Вывод: 8
Пояснение:

Алиса выбирает пешку на (2, 2) и захватывает её за два хода: (0, 2) -> (1, 4) -> (2, 2).
Боб выбирает пешку на (3, 3) и захватывает её за два хода: (2, 2) -> (4, 1) -> (3, 3).
Алиса выбирает пешку на (1, 1) и захватывает её за четыре хода: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Ввод: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Вывод: 3
Пояснение:

Алиса выбирает пешку на (2, 4) и захватывает её за два хода: (0, 0) -> (1, 2) -> (2, 4). Обрати внимание, что пешка на (1, 2) не захватывается.
Боб выбирает пешку на (1, 2) и захватывает её за один ход: (2, 4) -> (1, 2).

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

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Все positions[i] уникальны.
Входные данные сгенерированы так, что positions[i] != [kx, ky] для всех 0 <= i < positions.length.

Есть шахматная доска 50 x 50 с одним конем и несколькими пешками на ней. Вам даны два целых числа kx и ky, где (kx, ky) обозначает позицию коня, и двумерный массив позиций, где positions[i] = [x_i, y_i] обозначает позицию пешек на шахматной доске.
Алиса и Боб играют в пошаговую игру, где Алиса ходит первой. В ход каждого игрока:

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

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

Пример 1:

Вход: kx = 1, ky = 1, positions = [[0,0]]
Выход: 4
Пояснение:

Коню требуется 4 хода, чтобы достичь пешки в точке (0, 0).

Пример 2:

Вход: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Выход: 8
Пояснение:

Алиса выбирает пешку в точке (2, 2) и захватывает ее за два хода: (0, 2) -> (1, 4) -> (2, 2).
Боб выбирает пешку в (3, 3) и берет ее за два хода: (2, 2) -> (4, 1) -> (3, 3).
Алиса выбирает пешку в (1, 1) и берет ее за четыре хода: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Вход: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Выход: 3
Объяснение:

Алиса выбирает пешку в (2, 4) и берет ее за два хода: (0, 0) -> (1, 2) -> (2, 4). Обратите внимание, что пешка в (1, 2) не берется.
Боб выбирает пешку в (1, 2) и берет ее за один ход: (2, 4) -> (1, 2).

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

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Все positions[i] уникальны.
Входные данные генерируются таким образом, что positions[i] != [kx, ky] для всех 0 <= i < positions.length.

Есть шахматная доска 50 x 50 с одним конем и несколькими пешками на ней. Вам даны два целых числа kx и ky, где (kx, ky) обозначает позицию коня, и двумерный массив позиций, где positions[i] = [x_i, y_i] обозначает позицию пешек на шахматной доске.
Алиса и Боб играют в пошаговую игру, где Алиса ходит первой. В ход каждого игрока:

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

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

Пример 1:

Вход: kx = 1, ky = 1, positions = [[0,0]]
Выход: 4
Пояснение:

Коню требуется 4 хода, чтобы достичь пешки в точке (0, 0).

Пример 2:

Вход: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Выход: 8
Пояснение:

Алиса выбирает пешку в точке (2, 2) и захватывает ее за два хода: (0, 2) -> (1, 4) -> (2, 2).
Боб выбирает пешку в (3, 3) и берет ее за два хода: (2, 2) -> (4, 1) -> (3, 3).
Алиса выбирает пешку в (1, 1) и берет ее за четыре хода: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Вход: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Выход: 3
Объяснение:

Алиса выбирает пешку в (2, 4) и берет ее за два хода: (0, 0) -> (1, 2) -> (2, 4). Обратите внимание, что пешка в (1, 2) не берется.
Боб выбирает пешку в (1, 2) и берет ее за один ход: (2, 4) -> (1, 2).

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

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Все positions[i] уникальны.
Входные данные генерируются таким образом, что positions[i] != [kx, ky] для всех 0 <= i < positions.length.


Вам дан целочисленный массив a размером 4 и другой целочисленный массив b размером не менее 4.
Вам нужно выбрать 4 индекса i_0, i_1, i_2 и i_3 из массива b таким образом, что i_0 < i_1 < i_2 < i_3. Ваш счет будет равен значению a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Верните максимальный счет, который вы можете получить.

Пример 1:

Вход: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Выход: 26
Пояснение:
Мы можем выбрать индексы 0, 1, 2 и 5. Результат будет 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Вход: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Выход: -1
Пояснение:
Мы можем выбрать индексы 0, 1, 3 и 4. Результат будет (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

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

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Вам дан целочисленный массив a размером 4 и другой целочисленный массив b размером не менее 4.
Вам нужно выбрать 4 индекса i_0, i_1, i_2, и i_3 из массива b таким образом, что i_0 < i_1 < i_2 < i_3. Ваш счёт будет равен значению a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Верните максимальный счёт, который вы можете получить.

Пример 1:

Вход: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Выход: 26
Пояснение:
Мы можем выбрать индексы 0, 1, 2, и 5. Результат будет 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Вход: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Выход: -1
Пояснение:
Мы можем выбрать индексы 0, 1, 3, и 4. Результат будет (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

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

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Вам дается целочисленный массив a размером 4 и другой целочисленный массив b размером не менее 4.
Необходимо выбрать 4 индекса i_0, i_1, i_2 и i_3 из массива b так, чтобы i_0 < i_1 < i_2 < i_3. Ваша оценка будет равна значению a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Верните максимальную оценку, которую вы можете получить.

Пример 1:

Ввод: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Вывод: 26
Объяснение:
Мы можем выбрать индексы 0, 1, 2 и 5. Оценка будет равна 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Ввод: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Вывод: -1
Объяснение:
Мы можем выбрать индексы 0, 1, 3 и 4. Оценка будет равна (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

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

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


У вас есть массив строк words и строка target.
Строка x называется допустимой, если x является префиксом любой строки в words.
Верните минимальное количество допустимых строк, которые могут быть объединены, чтобы сформировать target. Если невозможно сформировать target, верните -1.

Пример 1:

Ввод: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Вывод: 3
Объяснение:
Строка target может быть сформирована объединением:

Префикс длины 2 от words[1], т.е. "aa".
Префикс длины 3 от words[2], т.е. "bcd".
Префикс длины 3 от words[0], т.е. "abc".

Пример 2:

Ввод: words = ["abababab","ab"], target = "ababaababa"
Вывод: 2
Объяснение:
Строка target может быть сформирована объединением:

Префикс длины 5 от words[0], т.е. "ababa".
Префикс длины 5 от words[0], т.е. "ababa".

Пример 3:

Ввод: words = ["abcdef"], target = "xyz"
Вывод: -1

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

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
Входные данные сформированы так, чтобы sum(words[i].length) <= 10^5.
words[i] состоит только из строчных английских букв.
1 <= target.length <= 5 * 10^3
target состоит только из строчных английских букв.

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

Пример 1:

Ввод: words = ["abc", "aaaaa", "bcdef"], target = "aabcdabc"
Вывод: 3
Объяснение:
Целевая строка может быть сформирована путем объединения:

Префикс длины 2 слов [1], то есть «аа».
Префикс длины 3 слов [2], то есть "bcd".
Префикс длины 3 слов [0], то есть "abc".

Пример 2:

Ввод: words = ["abababab","ab"], target = "ababaababa"
Вывод: 2
Объяснение:
Целевая строка может быть сформирована путем объединения:

Префикс длины 5 слов [0], то есть "ababa".
Префикс длины 5 слов [0], то есть"ababa".

Пример 3:

Ввод: words = ["abcdef"], target = "xyz"
Вывод: -1

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

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

Вам дан массив строк words и строка target.
Строка x называется допустимой, если x является префиксом любой строки в words.
Верните минимальное количество допустимых строк, которые можно объединить для формирования target. Если невозможно сформировать target, верните -1.

Пример 1:

Входные данные: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Выходные данные: 3
Пояснение:
Целевая строка может быть образована путем объединения:

Префикса длиной 2 слова[1], т. е. "aa".
Префикса длиной 3 слова[2], т. е. "bcd".
Префикса длиной 3 слова[0], т. е. "abc".

Пример 2:

Входные данные: words = ["abababab","ab"], target = "ababaababa"
Выходные данные: 2
Пояснение:
Целевая строка может быть сформирована путем конкатенации:

Префикса длины 5 из words[0], т. е. "ababa".
Префикса длины 5 из words[0], т. е. "ababa".

Пример 3:

Входные данные: words = ["abcdef"], target = "xyz"
Выходные данные: -1

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

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


Дан массив целых чисел nums длины n и положительное целое число k. Мощность массива определяется как:

Его максимальный элемент, если все его элементы являются последовательными и упорядочены по возрастанию.
-1 в противном случае.

Необходимо найти мощность всех подмассивов nums размера k.
Верните целочисленный массив results размера n - k + 1, где results[i] — это мощность nums[i..(i + k - 1)].

Пример 1:

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

[1, 2, 3] с максимальным элементом 3.
[2, 3, 4] с максимальным элементом 4.
[3, 4, 3] элементы не являются последовательными.
[4, 3, 2] элементы не упорядочены.
[3, 2, 5] элементы не являются последовательными.

Пример 2:

Ввод: nums = [2,2,2,2,2], k = 4
Вывод: [-1,-1]

Пример 3:

Ввод: nums = [3,2,3,2,3,2], k = 2
Вывод: [-1,3,-1,3,-1]

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

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

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

Мощность массива определяется следующим образом:
Это его максимальный элемент, если все элементы массива последовательны и упорядочены по возрастанию.
В противном случае — -1.

Необходимо найти мощность всех подмассивов массива nums размера k.
Верните целочисленный массив results размера n - k + 1, где results[i] — это мощность подмассива nums[i..(i + k - 1)].

Пример 1:

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

Есть 5 подмассивов массива nums размера 3:

[1, 2, 3] с максимальным элементом 3.
[2, 3, 4] с максимальным элементом 4.
[3, 4, 3], элементы которого не являются последовательными.
[4, 3, 2], элементы которого не отсортированы.
[3, 2, 5], элементы которого не являются последовательными.

Пример 2:

Ввод: nums = [2,2,2,2,2], k = 4
Вывод: [-1,-1]

Пример 3:

Ввод: nums = [3,2,3,2,3,2], k = 2
Вывод: [-1,3,-1,3,-1]

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

1 <= n == nums.length <= 500
1 <= nums[i] <= 10⁵
1 <= k <= n

Вам дается Массив целых чисел длины n и положительного целого числа k.
Сила массива определяется как:

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

Вам нужно найти силу всех подмассив числа размера k.
Верните целочисленный массив результатов размера n - k + 1, где результаты [i] являются силой nums [i .. (i + k - 1)].

Пример 1:

Ввод:  nums= [1,2,3,4,3,2,5], k = 3
Вывод: [3,4, -1, -1, -1]
Объяснение:
Есть 5 Подмассив числа размера 3:

[1, 2, 3] с максимальным элементом 3.
[2, 3, 4] с максимальным элементом 4.
[3, 4, 3] чьи элементы не являются последовательными.
[4, 3, 2] чьи элементы не отсортированы.
[3, 2, 5] чьи элементы не являются последовательными.

Пример 2:

Ввод: nums = [2,2,2,2,2], k = 4
Вывод: [-1, -1]

Пример 3:

Ввод: nums = [3,2,3,2,3,2], k = 2
Вывод: [-1,3, -1,3, -1]

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

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


Дана двумерная m x n матрица board, представляющая шахматную доску, где board[i][j] обозначает значение клетки (i, j). Ладьи, находящиеся в одном ряду или столбце, атакуют друг друга. Нужно разместить три ладьи на шахматной доске так, чтобы они не атаковали друг друга. Верните максимальную сумму значений клеток, на которых размещены ладьи.

Пример 1:

Входные данные: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Выходные данные: 4
Объяснение:

Мы можем разместить ладьи в клетках (0, 2), (1, 3), и (2, 1) для получения суммы 1 + 1 + 2 = 4.

Пример 2:

Входные данные: board = [[1,2,3],[4,5,6],[7,8,9]]
Выходные данные: 15
Объяснение:
Мы можем разместить ладьи в клетках (0, 0), (1, 1), и (2, 2) для получения суммы 1 + 5 + 9 = 15.

Пример 3:

Входные данные: board = [[1,1,1],[1,1,1],[1,1,1]]
Выходные данные: 3
Объяснение:
Мы можем разместить ладьи в клетках (0, 2), (1, 1), и (2, 0) для получения суммы 1 + 1 + 1 = 3.

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

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Вам дан двумерный массив m x n board, представляющий шахматную доску, где board[i][j] представляет значение клетки (i, j).
Ладьи в одной строке или столбце атакуют друг друга. Вам нужно разместить три ладьи на шахматной доске так, чтобы ладьи не атаковали друг друга.

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

Пример 1:

Вход: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Выход: 4
Пояснение:

Мы можем разместить ладьи в клетках (0, 2), (1, 3) и (2, 1) для суммы 1 + 1 + 2 = 4.

Пример 2:

Вход: board = [[1,2,3],[4,5,6],[7,8,9]]
Выход: 15
Пояснение:
Мы можем разместить ладьи в клетках (0, 0), (1, 1) и (2, 2) для суммы 1 + 5 + 9 = 15.

Пример 3:

Вход: board = [[1,1,1],[1,1,1],[1,1,1]]
Выход: 3
Пояснение:
Мы можем разместить ладьи в клетках (0, 2), (1, 1) и (2, 0) для суммы 1 + 1 + 1 = 3.

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

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


Даны три положительных целых числа num1, num2 и num3.
Ключ num1, num2 и num3 определяется как четырехзначное число, такое что:

Если какое-либо число имеет менее четырех цифр, оно дополняется ведущими нулями.
i-ая цифра (1 <= i <= 4) ключа генерируется путем взятия наименьшей цифры среди i-х цифр num1, num2 и num3.

Вернуть ключ трех чисел без ведущих нулей (если есть).

Пример 1:

Ввод: num1 = 1, num2 = 10, num3 = 1000
Вывод: 0
Объяснение:
После дополнения num1 становится "0001", num2 становится "0010", а num3 остается "1000".

1-ая цифра ключа — min(0, 0, 1).
2-ая цифра ключа — min(0, 0, 0).
3-я цифра ключа — min(0, 1, 0).
4-я цифра ключа — min(1, 0, 0).

Следовательно, ключ — "0000", т.е. 0.

Пример 2:

Ввод: num1 = 987, num2 = 879, num3 = 798
Вывод: 777

Пример 3:

Ввод: num1 = 1, num2 = 2, num3 = 3
Вывод: 1

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

1 <= num1, num2, num3 <= 9999

Вам даны три целых положительных числа num1, num2, и num3.
Ключ num1, num2, и num3 определяется как четырёхзначное число, такое, что:

Первоначально, если какое-либо число содержит менее четырёх цифр, оно дополняется ведущими нулями.
i^я цифра (1 <= i <= 4) ключа генерируется путем взятия наименьшей цифры среди i^х цифр чисел num1, num2, и num3.

Вернуть ключ трёх чисел без ведущих нулей (если есть).

Пример 1:

Ввод: num1 = 1, num2 = 10, num3 = 1000
Вывод: 0
Объяснение:
При заполнении num1 становится "0001", num2 становится "0010", и num3 остается "1000".

1^я цифра ключа это min(0, 0, 1).
2^я цифра ключа это min(0, 0, 0).
3^я цифра ключа это min(0, 1, 0).
4^я цифра ключа это min(1, 0, 0).

Следовательно, ключ это "0000", то есть 0.

Пример 2:

Ввод: num1 = 987, num2 = 879, num3 = 798
Вывод: 777

Пример 3:

Ввод: num1 = 1, num2 = 2, num3 = 3
Вывод: 1

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

1 <= num1, num2, num3 <= 9999


Вам дана строка s длины n и целое число k, где n кратно k. Ваша задача — хешировать строку s в новую строку с именем result, которая имеет длину n / k.
Сначала разделите s на n / k подстрок, каждая с длиной k. Затем инициализируйте result как пустую строку.
Для каждой подстроки по порядку с самого начала:

Хеш-значение символа — это индекс этого символа в английском алфавите (например, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Вычислите сумму всех хеш-значений символов в подстроке.
Найдите остаток этой суммы при делении на 26, который называется hashedChar.
Определите символ в английском алфавите в нижнем регистре, который соответствует hashedChar.
Добавьте этот символ в конец result.

Верните result.

Пример 1:

Вход: s = "abcd", k = 2
Выход: "bf"
Пояснение:
Первая подстрока: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Вторая подстрока: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Пример 2:

Вход: s = "mxz", k = 3
Выход: "i"
Пояснение:
Единственная подстрока: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

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

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

Дана строка s длиной n и целое число k, где n кратно k. Задача — хешировать строку s в новую строку с именем result, которая имеет длину n / k.

Сначала раздели s на n / k подстрок, каждая длиной k. Затем инициализируй result как пустую строку.

Для каждой подстроки, начиная с начала:

Хэш-значение символа — индекс этого символа в английском алфавите (например, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Вычисли сумму всех хэш-значений символов в подстроке.
Найди остаток от этой суммы при делении на 26, который называется hashedChar.
Определи символ в английском строчном алфавите, соответствующий hashedChar.
Добавь этот символ в конец result.

Выведи result.

Пример 1:

Ввод: s = "abcd", k = 2
Вывод: "bf"
Пояснение:
Первая подстрока: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Вторая подстрока: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Пример 2:

Ввод: s = "mxz", k = 3
Вывод: "i"
Пояснение:
Единственная подстрока: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

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

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

Дана строка s длиной n и целое число k, где n кратно k. Ваша задача — захешировать строку s в новую строку, называемую result, которая имеет длину n / k.

Сначала разделите s на n / k подстрок, каждая длиной k. Затем инициализируйте result как пустую строку.

Для каждой подстроки, начиная с начала:

Хэш-значение символа — это индекс этого символа в английском алфавите (например, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Вычислите сумму всех хэш-значений символов в подстроке.
Найдите остаток от этой суммы при делении на 26, который называется hashedChar.
Определите символ в английском строчном алфавите, который соответствует hashedChar.
Добавьте этот символ в конец result.

Верните result.

Пример 1:

Input: s = "abcd", k = 2
Output: "bf"
Объяснение:
Первая подстрока: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Вторая подстрока: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Пример 2:

Input: s = "mxz", k = 3
Output: "i"
Объяснение:
Единственная подстрока: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

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

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


Вам даны два положительных целых числа n и k. Целое число x называется k-палиндромом, если:

x является палиндромом.
x делится на k.

Целое число называется хорошим, если его цифры могут быть переставлены так, чтобы получился k-палиндром. Например, для k = 2, 2020 можно переставить, чтобы получить k-палиндром 2002, тогда как 1010 нельзя переставить, чтобы получить k-палиндром.
Верните количество хороших чисел, содержащих n цифр.
Обратите внимание, что любое число не должно иметь ведущих нулей, как до, так и после перестановки. Например, 1010 нельзя переставить, чтобы получить 101.

Пример 1:

Ввод: n = 3, k = 5
Вывод: 27
Объяснение:
Некоторые из хороших чисел:

551, потому что его можно переставить, чтобы получить 515.
525, потому что оно уже является k-палиндромом.

Пример 2:

Ввод: n = 1, k = 4
Вывод: 2
Объяснение:
Два хороших числа - это 4 и 8.

Пример 3:

Ввод: n = 5, k = 6
Вывод: 2468

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

1 <= n <= 10
1 <= k <= 9

Вам дается два положительных целых числа n и k.
Целое число x называется k- палиндромик, если:

X-это палиндром.
X делится на k.

Целое число называется хорошим, если его цифры могут быть перестроены, чтобы сформировать k- палиндромическое целое. Например, для k = 2, 2020 может быть перестроено, чтобы сформировать k- палиндромическое целое 2002, в то время как 1010 не может быть перестроено, чтобы сформировать k- палиндромическое целое.
Вернуть количество хороших чисел, содержащих n цифр.
Обратите внимание, что любое целое не должно иметь ведущих нулей, ни до, ни после перегруппировки. Например, 1010 не может быть преобразован в 101.

Пример 1:

Вход: n = 3, k = 5
Выход: 27
Пояснение:
Некоторые из хороших чисел:

551 потому что он может быть преобразован в 515.
525 потому что он уже к-палиндромический.

Пример 2:

Вход: n = 1, k = 4
Выход: 2
Пояснение:
Два хороших чисел 4 и 8.

Пример 3:

Вход: n = 5, k = 6
Выход: 2468

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

1 <= n <= 10
1 <= k <= 9


У вас есть целое число power и два целочисленных массива damage и health, оба длиной n.
У Боба есть n врагов, где враг i нанесет Бобу damage[i] единиц урона в секунду, пока они живы (то есть health[i] > 0).
Каждую секунду, после того как враги нанесут урон Бобу, он выбирает одного из все еще живых врагов и наносит ему power единиц урона.
Определите минимальное общее количество очков урона, которое будет нанесено Бобу, прежде чем все n врагов будут убиты.

Пример 1:

Ввод: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Вывод: 39
Объяснение:

Атакуем врага 3 в первые две секунды, после чего враг 3 будет повержен, количество очков урона, нанесенных Бобу, составит 10 + 10 = 20 очков.
Атакуем врага 2 в следующие две секунды, после чего враг 2 будет повержен, количество очков урона, нанесенных Бобу, составит 6 + 6 = 12 очков.
Атакуем врага 0 в следующую секунду, после чего враг 0 будет повержен, количество очков урона, нанесенных Бобу, составит 3 очка.
Атакуем врага 1 в следующие две секунды, после чего враг 1 будет повержен, количество очков урона, нанесенных Бобу, составит 2 + 2 = 4 очка.

Пример 2:

Ввод: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Вывод: 20
Объяснение:

Атакуем врага 0 в первую секунду, после чего враг 0 будет повержен, количество очков урона, нанесенных Бобу, составит 4 очка.
Атакуем врага 1 в следующие две секунды, после чего враг 1 будет повержен, количество очков урона, нанесенных Бобу, составит 3 + 3 = 6 очков.
Атакуем врага 2 в следующие три секунды, после чего враг 2 будет повержен, количество очков урона, нанесенных Бобу, составит 2 + 2 + 2 = 6 очков.
Атакуем врага 3 в следующие четыре секунды, после чего враг 3 будет повержен, количество очков урона, нанесенных Бобу, составит 1 + 1 + 1 + 1 = 4 очка.

Пример 3:

Ввод: power = 8, damage = [40], health = [59]
Вывод: 320

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

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Вам дана целочисленная мощность и два целочисленных массива урона и здоровья, оба имеют длину n.
У Боба n врагов, где враг i будет наносить Бобу урон[i] очков урона в секунду, пока они живы (т. е. здоровье[i] > 0).
Каждую секунду после того, как враги наносят урон Бобу, он выбирает одного из врагов, который еще жив, и наносит ему очки урона.
Определите минимальное общее количество очков урона, которое будет нанесено Бобу, прежде чем все n врагов умрут.

Пример 1:

Вход: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Выход: 39
Объяснение:

Атакуйте врага 3 в первые две секунды, после чего враг 3 падет, количество очков урона, нанесенных Бобу, составит 10 + 10 = 20 очков.
Атакуйте врага 2 в течение следующих двух секунд, после чего враг 2 упадет, количество очков урона, нанесенных Бобу, составит 6 + 6 = 12 очков.
Атакуйте врага 0 в течение следующих двух секунд, после чего враг 0 упадет, количество очков урона, нанесенного Бобу, составит 3 очка.
Атакуйте врага 1 в течение следующих двух секунд, после чего враг 1 упадет, количество очков урона, нанесенного Бобу, составит 2 + 2 = 4 очка.

Пример 2:

Ввод: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Вывод: 20
Объяснение:

Атакуйте врага 0 в течение первой секунды, после чего враг 0 упадет, количество очков урона, нанесенного Бобу, составит 4 очка.
Атакуйте врага 1 в течение следующих двух секунд, после чего враг 1 упадет, количество очков урона, нанесенного Бобу, составит 3 + 3 = 6 очков.
Атакуйте врага 2 в течение следующих трех секунд, после чего враг 2 падет, количество очков урона, нанесенных Бобу, составит 2 + 2 + 2 = 6 очков.
Атакуйте врага 3 в течение следующих четырех секунд, после чего враг 3 падет, количество очков урона, нанесенных Бобу, составит 1 + 1 + 1 + 1 = 4 очка.

Пример 3:

Вход: power = 8, damage = [40], health = [59]
Выход: 320

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

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Вам даны целочисленная степень и два целочисленных массива урона и здоровья, оба имеют длину n.
У Боба n врагов, причем враг i будет наносить Бобу единиц урона damage[i] в секунду, пока он жив (т. е. health[i] > 0).
Каждую секунду, после того как враги наносят урон Бобу, он выбирает одного из врагов, который ещё жив, и наносит ему очки силы.
Определите минимальную общую сумму очков урона, которая будет нанесена Бобу до того, как все n врагов будут мертвы.

Пример 1:

Ввод: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Вывод: 39
Объяснение:

Атакуйте врага 3 в первые две секунды, после чего враг 3 упадёт, количество очков урона, нанесённых Бобу, равно 10 + 10 = 20 очков.
Атакуйте врага 2 в течение следующих двух секунд, после чего враг 2 упадёт, количество очков урона, нанесённых Бобу, равно 6 + 6 = 12 очков.
Атакуйте врага 0 в следующую секунду, после чего враг 0 упадёт, количество очков урона, нанесённых Бобу, равно 3 очкам.
Атакуйте врага 1 в течение следующих двух секунд, после чего враг 1 упадёт, количество очков урона, нанесённых Бобу, равно 2 + 2 = 4 очка.

Пример 2:

Ввод: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Вывод: 20
Объяснение:

Атакуйте врага 0 в первую секунду, после чего враг 0 упадёт, количество очков урона, нанесённых Бобу, равно 4 очкам.
Атакуйте врага 1 в течение следующих двух секунд, после чего враг 1 упадёт, количество очков урона, нанесённых Бобу, равно 3 + 3 = 6 очков.
Атакуйте врага 2 в течение следующих трёх секунд, после чего враг 2 упадёт, количество очков урона, нанесённых Бобу, равно 2 + 2 + 2 = 6 очков.
Атакуйте врага 3 в течение следующих четырёх секунд, после чего враг 3 упадёт, количество очков урона, нанесённых Бобу, равно 1 + 1 + 1 + 1 = 4 очка.

Пример 3:

Ввод: power = 8, damage = [40], health = [59]
Вывод: 320

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

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


Вам дана двоичная матрица размером m x n и целое число здоровья (health).
Вы начинаете в верхнем левом углу (0, 0) и хотите добраться до нижнего правого угла (m - 1, n - 1).
Вы можете перемещаться вверх, вниз, влево или вправо из одной ячейки в другую смежную ячейку, пока ваше здоровье остаётся положительным.
Ячейки (i, j) с grid[i][j] = 1 считаются небезопасными и уменьшают ваше здоровье на 1.
Верните true, если вы можете добраться до конечной ячейки со значением здоровья 1 или более, и false в противном случае.

Пример 1:

Ввод: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Вывод: true
Объяснение:
Конечная ячейка может быть достигнута безопасно, перемещаясь вдоль серых ячеек, показанных ниже.

Пример 2:

Ввод: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Вывод: false
Объяснение:
Необходимо минимум 4 очка здоровья, чтобы безопасно добраться до конечной ячейки.

Пример 3:

Ввод: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Вывод: true
Объяснение:
Конечная ячейка может быть достигнута безопасно, перемещаясь вдоль серых ячеек, показанных ниже.

Любой путь, который не проходит через ячейку (1, 1), небезопасен, так как ваше здоровье упадёт до 0 при достижении конечной ячейки.

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

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] является либо 0, либо 1.

Вам дается бинарная матричная сетка m x n и состояние здоровья в целых числах.
Вы начинаете с верхнего левого угла (0, 0) и хотите добраться до нижнего правого угла (m - 1, n - 1).
Вы можете перемещаться вверх, вниз, влево или вправо из одной клетки в другую, соседнюю клетку, если ваше здоровье остается положительным.
Клетки (i, j) с сеткой[i][j] = 1 считаются небезопасными и уменьшают ваше здоровье на 1.
Выведите true, если вы можете добраться до последней ячейки со значением здоровья 1 или более, и false в противном случае.

Пример 1:

Input: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Output: true
Объяснение:
До последней ячейки можно безопасно добраться, пройдя по серым ячейкам внизу.

Пример 2:

Input: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Output: false
Объяснение:
Чтобы безопасно добраться до последней камеры, необходимо минимум 4 очка здоровья.

Пример 3:

Input: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Output: true
Объяснение:
До последней ячейки можно безопасно добраться, пройдя по серым ячейкам внизу.

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

Constraints:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] is either 0 or 1.

Вам дана двоичная матричная сетка m x n и целое число здоровья.
Вы начинаете в верхнем левом углу (0, 0) и хотите добраться до нижнего правого угла (m - 1, n - 1).
Вы можете двигаться вверх, вниз, влево или вправо от одной ячейки к другой соседней ячейке, пока ваше здоровье остается положительным.
Ячейки (i, j) с grid[i][j] = 1 считаются небезопасными и уменьшают ваше здоровье на 1.
Возвращает true, если вы можете достичь последней ячейки со значением здоровья 1 или больше, и false в противном случае.

Пример 1:

Входные данные: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Выходные данные: true
Объяснение:
До последней ячейки можно безопасно добраться, пройдя по серым ячейкам ниже.

Пример 2:

Вход: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Выход: false
Пояснение:
Для безопасного достижения последней ячейки необходимо минимум 4 очка здоровья.

Пример 3:

Вход: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Выход: true
Пояснение:
До последней ячейки можно безопасно добраться, пройдя по серым ячейкам ниже.

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

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

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] равно 0 или 1.


Дан целочисленный массив `nums` и положительное целое число `k`.
Значение последовательности `seq` размера `2 * x` определяется как:

\((seq[0] \text{ OR } seq[1] \text{ OR } \ldots \text{ OR } seq[x - 1]) \text{ XOR } (seq[x] \text{ OR } seq[x + 1] \text{ OR } \ldots \text{ OR } seq[2 * x - 1])\).

Верните максимальное значение любой подпоследовательности `nums` размера `2 * k`.

Пример 1:

Ввод: nums = [2,6,7], k = 1
Вывод: 5
Объяснение:
Подпоследовательность `[2, 7]` имеет максимальное значение 2 XOR 7 = 5.

Пример 2:

Ввод: nums = [4,2,5,6,7], k = 2
Вывод: 2
Объяснение:
Подпоследовательность `[4, 5, 6, 7]` имеет максимальное значение (4 OR 5) XOR (6 OR 7) = 2.

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

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Дан целочисленный массив nums и положительное целое число k.
Значение последовательности seq размераe 2 * x определяется как:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Верните максимальное значение любой подпоследовательности nums размера 2 * k.

Пример 1:

Ввод: nums = [2,6,7], k = 1
Вывод: 5
Объяснение:
Подпоследовательность [2, 7] имеет максимальное значение 2 XOR 7 = 5.

Пример 2:

Ввод: nums = [4,2,5,6,7], k = 2
Вывод: 2
Объяснение:
Подпоследовательность [4, 5, 6, 7] имеет максимальное значение (4 OR 5) XOR (6 OR 7) = 2.

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

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Вам дан целочисленный массив nums и положительное целое число k.
Значение последовательности seq размером 2 * x определяется как:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Вернуть максимальное значение любой подпоследовательности nums размером 2 * k.

Пример 1:

Вход: nums = [2,6,7], k = 1
Выход: 5
Пояснение:
Подпоследовательность [2, 7] имеет максимальное значение 2 XOR 7 = 5.

Пример 2:

Вход: nums = [4,2,5,6,7], k = 2
Выход: 2
Пояснение:
Подпоследовательность [4, 5, 6, 7] имеет максимальное значение (4 OR 5) XOR (6 OR 7) = 2.

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

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


Вам дан двумерный массив целых чисел coordinates длины n и целое число k, где 0 <= k < n.
coordinates[i] = [x_i, y_i] указывает на точку (x_i, y_i) на двумерной плоскости.
Увеличивающийся путь длины m определяется как список точек (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m), такой что:

x_i < x_i + 1 и y_i < y_i + 1 для всех i, где 1 <= i < m.
(x_i, y_i) находится в заданных координатах для всех i, где 1 <= i <= m.

Верните максимальную длину увеличивающегося пути, который содержит coordinates[k].

Пример 1:

Ввод: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Вывод: 3
Объяснение:
(0, 0), (2, 2), (5, 3) — это самый длинный увеличивающийся путь, который содержит (2, 2).

Пример 2:

Ввод: coordinates = [[2,1],[7,0],[5,6]], k = 2
Вывод: 2
Объяснение:
(2, 1), (5, 6) — это самый длинный увеличивающийся путь, который содержит (5, 6).

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

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Все элементы в coordinates различны.
0 <= k <= n - 1

Вам дан 2D массив целых чисел координат длины n и целые числа k, где 0 <= k < n.
координата [i] = [x_i, y_i] указывает точку (x_i, y_i) на 2D плоскости.
Увеличивающийся путь длины m определяется как список точек (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) таким образом, что:

x_i < x_i + 1 и y_i < y_i + 1 для всех i где 1 <= i < m.
(x_i, y_i) находится в данных координатах для всех i где 1 <= i <= m.

Выведете максимальную длину увеличивающегося пути, содержащего координаты [k].

Пример 1:

Input: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Output: 3
Объяснение:
(0, 0), (2, 2), (5, 3) является самым длинным путем, содержащим (2, 2).

Пример 2:

Input: coordinates = [[2,1],[7,0],[5,6]], k = 2
Output: 2
Объяснения:
(2, 1), (5, 6) является самым длинным путем, содержащим (5, 6).

Constraints:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
All elements in coordinates are distinct.
0 <= k <= n - 1

Вам дан двумерный массив целых координат длины n и целое число k, где 0 <= k < n.
coordinates[i] = [x_i, y_i] указывает точку (x_i, y_i) на двумерной плоскости.
возрастающий путь длины m определяется как список точек (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) таких, что:

x_i < x_i + 1 и y_i < y_i + 1 для всех i, где 1 <= i < m.
(x_i, y_i) находится в заданных координатах для всех i, где 1 <= i <= m.

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

Пример 1:

Вход: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Выход: 3
Пояснение:
(0, 0), (2, 2), (5, 3) — самый длинный возрастающий путь, содержащий (2, 2).

Пример 2:

Вход: coordinates = [[2,1],[7,0],[5,6]], k = 2
Выход: 2
Пояснение:
(2, 1), (5, 6) — самый длинный возрастающий путь, содержащий (5, 6).

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

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Все элементы в координатах различны.
0 <= k <= n - 1


Вам дан массив строк message и массив строк bannedWords.
Массив слов считается спамом, если в нем есть как минимум два слова, которые точно совпадают с любым из слов в bannedWords.
Верните true, если массив message является спамом, и false в противном случае.

Пример 1:

Ввод: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Вывод: true
Объяснение:
Слова "hello" и "world" из массива message оба появляются в массиве bannedWords.

Пример 2:

Ввод: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Вывод: false
Объяснение:
Только одно слово из массива message ("programming") появляется в массиве bannedWords.

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

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] и bannedWords[i] состоят только из строчных английских букв.

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

Пример 1:

Ввод: сообщение = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Вывод: true
Объяснение:
Слова «hello» и «world» из массива сообщений появляются в массиве запрещенных слов.

Пример 2:

Ввод: message =  ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Вывод: false
Объяснение:
Только одно слово из массива сообщений («programming») появляется в массиве запрещенных слов.

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

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
Сообщение [i] и запрещенные слова [i] состоят только из строчных английских букв.


Вам дано целое число mountainHeight, обозначающее высоту горы.
Вам также дан целочисленный массив workerTimes, представляющий время работы рабочих в секундах.
Рабочие работают одновременно, чтобы уменьшить высоту горы. Для работника i:

Чтобы уменьшить высоту горы на x, требуется workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x секунд. Например:

Чтобы уменьшить высоту горы на 1, требуется workerTimes[i] секунд.
Чтобы уменьшить высоту горы на 2, требуется workerTimes[i] + workerTimes[i] * 2 секунды и т. д.

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

Пример 1:

Вход: mountainHeight = 4, workerTimes = [2,1,1]
Выход: 3
Пояснение:
Один из способов уменьшить высоту горы до 0:

Рабочий 0 уменьшает высоту на 1, затрачивая workerTimes[0] = 2 секунды.
Рабочий 1 уменьшает высоту на 2, затрачивая workerTimes[1] + workerTimes[1] * 2 = 3 секунды.
Рабочий 2 уменьшает высоту на 1, затрачивая workerTimes[2] = 1 секунду.

Поскольку они работают одновременно, минимально необходимое время составляет max(2, 3, 1) = 3 секунды.

Пример 2:

Входные данные: mountainHeight = 10, workerTimes = [3,2,2,4]
Выходные данные: 12
Объяснение:

Рабочий 0 уменьшает высоту на 2, затрачивая workerTimes[0] + workerTimes[0] * 2 = 9 секунд.
Рабочий 1 уменьшает высоту на 3, затрачивая workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 секунд.
Рабочий 2 уменьшает высоту на 3, затрачивая workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 секунд.
Рабочий 3 уменьшает высоту на 2, затрачивая workerTimes[3] + workerTimes[3] * 2 = 12 секунд.

Количество необходимых секунд равно max(9, 12, 12, 12) = 12 секунд.

Пример 3:

Входные данные: mountainHeight = 5, workerTimes = [1]
Выходные данные: 15
Пояснение:
В этом примере только один работник, поэтому ответ: workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

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

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Вам дано целое число mountainHeight, обозначающее высоту горы. Также вам дан целочисленный массив workerTimes, представляющий время работы работников в секундах. Работники работают одновременно, чтобы уменьшить высоту горы. Для работника i:

Чтобы уменьшить высоту горы на x, требуется workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x секунд. Например:

Чтобы уменьшить высоту горы на 1, требуется workerTimes[i] секунд.
Чтобы уменьшить высоту горы на 2, требуется workerTimes[i] + workerTimes[i] * 2 секунд и так далее.

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

Пример 1:

Input: mountainHeight = 4, workerTimes = [2,1,1]
Output: 3
Объяснение:
Один из способов уменьшить высоту горы до 0:

Работник 0 уменьшает высоту на 1, затрачивая workerTimes[0] = 2 секунды.
Работник 1 уменьшает высоту на 2, затрачивая workerTimes[1] + workerTimes[1] * 2 = 3 секунды.
Работник 2 уменьшает высоту на 1, затрачивая workerTimes[2] = 1 секунду.

Так как они работают одновременно, минимальное необходимое время — max(2, 3, 1) = 3 секунды.

Пример 2:

Input: mountainHeight = 10, workerTimes = [3,2,2,4]
Output: 12
Объяснение:

Работник 0 уменьшает высоту на 2, затрачивая workerTimes[0] + workerTimes[0] * 2 = 9 секунд.
Работник 1 уменьшает высоту на 3, затрачивая workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 секунд.
Работник 2 уменьшает высоту на 3, затрачивая workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 секунд.
Работник 3 уменьшает высоту на 2, затрачивая workerTimes[3] + workerTimes[3] * 2 = 12 секунд.

Количество необходимых секунд — max(9, 12, 12, 12) = 12 секунд.

Пример 3:

Input: mountainHeight = 5, workerTimes = [1]
Output: 15
Объяснение:
В этом примере есть только один работник, поэтому ответ — workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

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

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6


Даны две строки word1 и word2.
Строка x называется допустимой, если ее можно переставить так, чтобы слово word2 было префиксом.
Верните общее количество допустимых подстрок word1.

Пример 1:

Вход: word1 = "bcca", word2 = "abc"
Выход: 1
Пояснение:
Единственная допустимая подстрока — "bcca", которую можно переставить в "abcc", имея "abc" в качестве префикса.

Пример 2:

Вход: word1 = "abcabc", word2 = "abc"
Выход: 10
Пояснение:
Все подстроки, кроме подстрок размера 1 и 2, допустимы.

Пример 3:

Вход: word1 = "abcabc", word2 = "aaabc"
Выход: 0

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

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

Вам даны две строки word1 и word2.
Строка x называется допустимой, если x можно переставить так, чтобы word2 был префиксом.
Возвращает общее количество допустимых подстрок word1.

Пример 1:

Входные данные: word1 = "bcca", word2 = "abc"
Выходные данные: 1
Пояснение:
Единственная допустимая подстрока — это "bcca", которую можно переставить в "abcc", имея префикс "abc".

Пример 2:

Входные данные: word1 = "abcabc", word2 = "abc"
Выходные данные: 10
Пояснение:
Все подстроки, кроме подстрок размера 1 и размера 2, допустимы.

Пример 3:

Вход: word1 = "abcabc", word2 = "aaabc"
Выход: 0

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

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

Вам даны две строки word1 и word2.
Строка x называется действительной, если x можно переставить так, чтобы иметь слово word2 в качестве префикса.
Возвращает общее количество допустимых подстрок word1.

Пример 1:

Входные данные: word1 = "bcca", word2 = "abc"
Выход: 1
Объяснение:
Единственной допустимой подстрокой является "bcca", которую можно переставить в "abcc" с префиксом "abc".

Пример 2:

Входные данные: word1 = "abcabc", word2 = "abc"
Выход: 10
Объяснение:
Допустимы все подстроки, кроме подстрок размера 1 и размера 2.

Пример 3:

Входные данные: word1 = "abcabc", word2 = "aaabc"
Выход: 0

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

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


Алиса и Боб играют в игру. Изначально у Алисы есть строка word = "a".
Вам дано положительное целое число k.
Теперь Боб будет просить Алису выполнять следующую операцию бесконечно:

Создавать новую строку, изменяя каждый символ в word на следующий символ в английском алфавите, и добавлять её к оригинальной word.

Например, выполнение операции на "c" генерирует "cd", а выполнение операции на "zb" генерирует "zbac".
Верните значение k^го символа в word после того, как выполнено достаточное количество операций, чтобы word имела как минимум k символов.
Заметьте, что символ 'z' может быть изменён на 'a' в этой операции.

Пример 1:

Ввод: k = 5
Вывод: "b"
Объяснение:
Изначально, word = "a". Нам нужно выполнить операцию три раза:

Сгенерированная строка "b", word становится "ab".
Сгенерированная строка "bc", word становится "abbc".
Сгенерированная строка "bccd", word становится "abbcbccd".

Пример 2:

Ввод: k = 10
Вывод: "c"

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

1 <= k <= 500

Алиса и Боб играют в игру. Изначально у Алисы есть строка word = "a".
Дано положительное целое число k.
Теперь Боб попросит Алису выполнять следующую операцию бесконечно:

Создавать новую строку, изменяя каждый символ в word на следующий символ в английском алфавите, и добавлять её к word.

Например, выполнение операции над "c" генерирует "cd", а выполнение операции над "zb" генерирует "zbac".
Верни значение k^го символа в word после того, как выполнено достаточное количество операций, чтобы word содержала как минимум k символов.
Необходимо учесть, что символ 'z' может быть изменён на 'a' в ходе этой операции.

Пример 1:

Ввод: k = 5
Вывод: "b"
Пояснение:
Изначально, word = "a". Необходимо выполнить операцию три раза:

Сгенерирована строка "b", word становится "ab".
Сгенерирована строка "bc", word становится "abbc".
Сгенерирована строка "bccd", word становится "abbcbccd".

Пример 2:

Ввод: k = 10
Вывод: "c"

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

1 <= k <= 500


Дана строка word и неотрицательное целое число k.
Верни общее количество подстрок word, содержащих каждую гласную ('a', 'e', 'i', 'o' и 'u') как минимум один раз и ровно k согласных.

Пример 1:

Ввод: word = "aeioqq", k = 1
Вывод: 0
Пояснение:
Нет подстроки, содержащей все гласные.

Пример 2:

Ввод: word = "aeiou", k = 0
Вывод: 1
Пояснение:
Единственная подстрока, содержащая все гласные и ноль согласных, это word[0..4], что равно "aeiou".

Пример 3:

Ввод: word = "ieaouqqieaouqq", k = 1
Вывод: 3
Пояснение:
Подстроки, содержащие все гласные и одну согласную:

word[0..5], что равно "ieaouq".
word[6..11], что равно "qieaou".
word[7..12], что равно "ieaouq".

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

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

Вам дана строка word и неотрицательное целое число k.
Верните общее количество подстрок word, которые содержат каждую гласную ('a', 'e', 'i', 'o' и 'u') как минимум один раз и ровно k согласных.

Пример 1:

Ввод: word = "aeioqq", k = 1
Вывод: 0
Пояснение:
Нет подстроки, содержащей все гласные.

Пример 2:

Ввод: word = "aeiou", k = 0
Вывод: 1
Пояснение:
Единственная подстрока, содержащая все гласные и ноль согласных, это word[0..4], что равно "aeiou".

Пример 3:

Ввод: word = "ieaouqqieaouqq", k = 1
Вывод: 3
Пояснение:
Подстроки, содержащие все гласные и одну согласную, это:

word[0..5], which is "ieaouq".
word[6..11], which is "qieaou".
word[7..12], which is "ieaouq".

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

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

Вам дана строковое слово и неотрицательное целое число k.
Выведите общее количество подстроковых слов, которые содержат каждую гласную ('a', 'e', 'i', 'o' и 'u') хотя бы один раз и ровно k согласных.

Пример 1:

Input: word = "aeioqq", k = 1
Output: 0
Explanation:
There is no substring with every vowel.

Пример 2:

Input: word = "aeiou", k = 0
Output: 1
Explanation:
The only substring with every vowel and zero consonants is word[0..4], which is "aeiou".

Пример 3:

Input: word = "ieaouqqieaouqq", k = 1
Output: 3
Explanation:
The substrings with every vowel and one consonant are:

word[0..5], which is "ieaouq".
word[6..11], which is "qieaou".
word[7..12], which is "ieaouq".

Constraints:

5 <= word.length <= 250
word consists only of lowercase English letters.
0 <= k <= word.length - 5


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

Пример 1:

Вход: nums = [1,2,3]
Выход: 30
Пояснение:
Объедините числа в порядке [3, 1, 2], чтобы получить результат "11110", который является двоичным представлением числа 30.

Пример 2:

Вход: nums = [2,8,16]
Выход: 1296
Пояснение:
Объедините числа в порядке [2, 8, 16], чтобы получить результат "10100010000", который является двоичным представлением числа 1296.

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

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

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

Пример 1:

Input: nums = [1,2,3]
Output: 30
Пояснение:
Объедините числа в порядке [3, 1, 2], чтобы получить результат "11110", который является двоичным представлением числа 30.

Пример 2:

Input: nums = [2,8,16]
Output: 1296
Пояснение:
Объедините числа в порядке [2, 8, 16], чтобы получить результат "10100010000", который является двоичным представлением числа 1296.

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

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

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

Пример 1:

Ввод: nums = [1,2,3]
Вывод: 30
Объяснение:
Объедините числа в порядке [3, 1, 2], чтобы получить результат "11110", который является двоичным представлением числа 30.

Пример 2:

Ввод: nums = [2,8,16]
Вывод: 1296
Объяснение:
Объедините числа в порядке [2, 8, 16], чтобы получить результат "10100010000", который является двоичным представлением 1296.

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

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


У вас есть целочисленный массив nums длиной n и целочисленный массив queries. Пусть gcdPairs обозначает массив, полученный вычислением НОД всех возможных пар (nums[i], nums[j]), где 0 <= i < j < n, и затем сортировкой этих значений по возрастанию. Для каждого запроса queries[i], вам нужно найти элемент с индексом queries[i] в gcdPairs. Верните целочисленный массив answer, где answer[i] — значение gcdPairs[queries[i]] для каждого запроса. Термин gcd(a, b) обозначает наибольший общий делитель a и b.

Пример 1:

Input: nums = [2,3,4], queries = [0,2,2]
Output: [1,2,2]
Объяснение:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
После сортировки по возрастанию, gcdPairs = [1, 1, 2].
Таким образом, ответ [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Пример 2:

Input: nums = [4,4,2,1], queries = [5,3,1,0]
Output: [4,2,1,1]
Объяснение:
gcdPairs, отсортированные по возрастанию, — это [1, 1, 1, 2, 2, 4].

Пример 3:

Input: nums = [2,2], queries = [0,0]
Output: [2,2]
Объяснение:
gcdPairs = [2].

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

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Вам дан целочисленный массив nums длины n и целочисленный массив запросов.
Пусть gcdPairs обозначает массив, полученный путем вычисления GCD всех возможных пар (nums[i], nums[j]), где 0 <= i < j < n, а затем сортировки этих значений в порядке возрастания.
Для каждого запроса query[i] вам нужно найти элемент в индексе queries[i] в gcdPairs.
Возвращает целочисленный массив answer, где answer[i] — значение в gcdPairs[queries[i]] для каждого запроса.
Термин gcd(a, b) обозначает наибольший общий делитель a и b.

Пример 1:

Входные данные: nums = [2,3,4], queries = [0,2,2]
Выход: [1,2,2]
Объяснение:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
После сортировки в порядке возрастания, gcdPairs = [1, 1, 2].
Итак, ответ таков: [gcdPairs[запросы[0]], gcdPairs[запросы[1]], gcdPairs[запросы[2]]] = [1, 2, 2].

Пример 2:

Входные данные: nums = [4,4,2,1], запросы = [5,3,1,0]
Выход: [4,2,1,1]
Объяснение:
gcdPairs отсортирован в порядке возрастания: [1, 1, 1, 2, 2, 4].

Пример 3:

Входные данные: nums = [2,2], queries = [0,0]
Выход: [2,2]
Объяснение:
gcdPairs = [2].

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

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Вам дан целочисленный массив nums длины n и целочисленный массив requests.
Пусть gcdPairs обозначает массив, полученный путем вычисления НОД всех возможных пар (nums[i], nums[j]), где 0 <= i < j < n, а затем сортировки этих значений в порядке возрастания.
Для каждого запроса requests[i] вам нужно найти элемент с индексом requests[i] в gcdPairs.
Верните целочисленный массив answer, где answer[i] — это значение в gcdPairs[queries[i]] для каждого запроса.
Термин gcd(a, b) обозначает наибольший общий делитель a и b.

Пример 1:

Вход: nums = [2,3,4], requests = [0,2,2]
Выход: [1,2,2]
Объяснение:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
После сортировки по возрастанию gcdPairs = [1, 1, 2].
Таким образом, ответ: [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Пример 2:

Входные данные: nums = [4,4,2,1], requests = [5,3,1,0]
Выходные данные: [4,2,1,1]
Пояснение:
gcdPairs, отсортированные по возрастанию, равны [1, 1, 1, 2, 2, 4].

Пример 3:

Входные данные: nums = [2,2], requests = [0,0]
Выходные данные: [2,2]
Пояснение:
gcdPairs = [2].

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

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= requests.length <= 10^5
0 <= requests[i] < n * (n - 1) / 2


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

Пример 1:

Вход: nums = [10,12,13,14]
Выход: 1
Пояснение:
nums становится [1, 3, 4, 5] после всех замен, с минимальным элементом 1.

Пример 2:

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

Пример 3:

Вход: nums = [999,19,199]
Выход: 10
Пояснение:
nums становится [27, 10, 19] после всех замен, с минимальным элементом 10.

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

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

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

Пример 1:

Ввод: nums = [10,12,13,14]
Вывод: 1
Объяснение:
nums становится [1, 3, 4, 5] после всех замен с минимальным элементом 1.

Пример 2:

Ввод: nums = [1,2,3,4]
Вывод: 1
Объяснение:
nums становится [1, 2, 3, 4] после всех замен с минимальным элементом 1.

Пример 3:

Ввод: nums = [999,19,199]
Вывод: 10
Объяснение:
nums становится [27, 10, 19] после всех замен с минимальным элементом 10.

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

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

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

Пример 1:

Input: nums = [10,12,13,14]
Output: 1
Explanation:
nums становится [1, 3, 4, 5] после всех замен, минимальный элемент 1.

Пример 2:

Input: nums = [1,2,3,4]
Output: 1
Explanation:
nums становится [1, 2, 3, 4] после всех замен, минимальный элемент 1.

Пример 3:

Input: nums = [999,19,199]
Output: 10
Explanation:
nums становится [27, 10, 19] после всех замен, минимальный элемент 10.

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

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


Вам задан массив maximumHeight, где maximumHeight[i] обозначает максимальную высоту, которую можно назначить i-й башне.
Ваша задача - назначить высоту каждой башне так, чтобы:

Высота i-й башни была положительным целым числом и не превышала maximumHeight[i].
Две башни не имели одинаковую высоту.

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

Пример 1:

Ввод: maximumHeight = [2,3,4,3]
Вывод: 10
Объяснение:
Мы можем назначить высоты следующим образом: [1, 2, 4, 3].

Пример 2:

Ввод: maximumHeight = [15,10]
Вывод: 25
Объяснение:
Мы можем назначить высоты следующим образом: [15, 10].

Пример 3:

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

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

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

Вам даётся массив maximumHeight, где maximumHeight[i] обозначает максимальную высоту, которую может быть присвоена i^-я башня.
Ваша задача - назначить высоту каждой башни, чтобы:

Высота i^-й башни является положительным целым числом и не превышает maximumHeight[i].
Ни одна из башен не имеет одинаковой высоты.

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

Пример 1:

Вход: maximumHeight = [2,3,4,3]
Выход: 10
Пояснение:
Мы можем распределить высоты следующим образом: [1, 2, 4, 3].

Пример 2:

Вход: maximumHeight = [15,10]
Выход: 25
Пояснение:
Мы можем распределить высоты следующим образом: [15, 10].

Пример З:

Вход: maximumHeight = [2,2,1]
Выход: -1
Пояснение:
Невозможно назначить положительные высоты для каждого индекса, чтобы ни одна башня не имела одинаковую высоту.

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

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

Вам дан массив maximumHeight, где maximumHeight[i] обозначает максимальную высоту, которую может быть назначена i^th башне.
Ваша задача — назначить высоту каждой башне так, чтобы:

Высота i^th башни была положительным целым числом и не превышала maximumHeight[i].
Никакие две башни не имели одинаковой высоты.

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

Пример 1:

Входные данные: maximumHeight = [2,3,4,3]
Выходные данные: 10
Пояснение:
Мы можем назначить высоты следующим образом: [1, 2, 4, 3].

Пример 2:

Входные данные: maximumHeight = [15,10]
Выходные данные: 25
Пояснение:
Мы можем назначить высоты следующим образом: [15, 10].

Пример 3:

Вход: maximumHeight = [2,2,1]
Выход: -1
Пояснение:
Невозможно присвоить положительные высоты каждому индексу, чтобы никакие две башни не имели одинаковую высоту.

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

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


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

Индексы отсортированы в порядке возрастания.
Конкатенация символов на этих индексах в word1 в том же порядке приводит к строке, которая почти равна word2.

Верните массив размера word2.length, представляющий лексикографически наименьшую допустимую последовательность индексов. Если такой последовательности индексов не существует, верните пустой массив.
Обратите внимание, что ответ должен представлять лексикографически наименьший массив, а не соответствующую строку, образованную этими индексами.

Пример 1:

Ввод: word1 = "vbcca", word2 = "abc"
Вывод: [0,1,2]
Объяснение:
Лексикографически наименьшая допустимая последовательность индексов — [0, 1, 2]:

Замените word1[0] на 'a'.
word1[1] уже 'b'.
word1[2] уже 'c'.

Пример 2:

Ввод: word1 = "bacdc", word2 = "abc"
Вывод: [1,2,4]
Объяснение:
Лексикографически наименьшая допустимая последовательность индексов — [1, 2, 4]:

word1[1] уже 'a'.
Замените word1[2] на 'b'.
word1[4] уже 'c'.

Пример 3:

Ввод: word1 = "aaaaaa", word2 = "aaabc"
Вывод: []
Объяснение:
Нет допустимой последовательности индексов.

Пример 4:

Ввод: word1 = "abc", word2 = "ab"
Вывод: [0,1]

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

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

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

Индексы отсортированы по возрастанию.
Объединение символов по этим индексам в word1 в одном и том же порядке приводит к получению строки, почти равной word2.

Верните массив размером word2.length, представляющий наименьшую лексикографически действительную последовательность индексов. Если такой последовательности индексов не существует, верните пустой массив.
Обратите внимание, что ответ должен представлять собой лексикографически наименьший массив, а не соответствующую строку, образованную этими индексами.

Пример 1:

Ввод: word1 = "vbcca", word2 = "abc"
Вывод: [0,1,2]
Объяснение:
Лексикографически наименьшая допустимая последовательность индексов это [0, 1, 2]:

Замените word1[0] на 'a'.
word1[1] уже равно 'b'.
word1[2] уже равно 'c'.

Пример 2:

Ввод: word1 = "bacdc", word2 = "abc"
Выход: [1,2,4]
Объяснение:
Лексикографически наименьшая допустимая последовательность индексов это [1, 2, 4]:

word1[1] уже равно 'a'.
Замените слово 1[2] на 'b'.
word1[4] уже равен 'c'.

Пример 3:

Ввод: word1 = "aaaaaa", word2 = "aaabc"
Вывод: []
Объяснение:
Не существует допустимой последовательности индексов.

Пример 4:

Ввод: word1 = "abc", word2 = "ab"
Вывод: [0,1]

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

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


Вам даны две строки s и pattern.
Строка x называется почти равной y, если можно изменить не более одного символа в x, чтобы она стала идентичной y.
Верните наименьший начальный индекс подстроки в s, которая почти равна pattern. Если такого индекса не существует, возвращается -1.
Подстрока — это непрерывная непустая последовательность символов в строке.

Пример 1:

Ввод: s = "abcdefg", pattern = "bcdffg"
Вывод: 1
Объяснение:
Подстроку s[1..6] == "bcdefg" можно преобразовать в "bcdffg", заменив s[4] на "f".

Пример 2:

Ввод: s = "ababbababa", pattern = "bacaba"
Вывод: 4
Объяснение:
Подстроку s[4..9] == "bababa" можно преобразовать в "bacaba", заменив s[6] на "c".

Пример 3:

Ввод: s = "abcd", pattern = "dba"
Вывод: -1

Пример 4:

Ввод: s = "dde", pattern = "d"
Вывод: 0

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

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

Послесловие: Можете ли вы решить проблему, если можно изменить не более k последовательных символов?

Вам даны две строки: s и шаблон.
Строка x называется почти равной Y, если вы можете изменить не более одного символа в X, чтобы сделать ее идентичной y.
Верните наименьший начальный индекс подстроения в S, который почти равен шаблону. Если такой индекс не существует, верните -1.
Подстрока — это смежная непустая последовательность символов в строке.

Пример 1:

Ввод: S = "abcdefg", pattern = "bcdffg"
Вывод: 1
Объяснение:
Подстроение s [1..6] == "bcdefg"  может быть преобразована в  "bcdffg" путем изменения s [4] на "f".

Пример 2:

Ввод: s= "ababbababa", pattern = "bacaba"
Вывод: 4
Объяснение:
Подстроение s [4..9] == "bababa" может быть преобразована в "bacaba", изменив s[6] на "c".

Пример 3:

Ввод: s= "abcd", pattern = "dba"
Вывод: -1

Пример 4:

Ввод: s = "dde", pattern = "d"
Вывод: 0

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

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

Дополнительный вопрос: могли бы вы решить задачу, если бы можно было изменить не более k последовательных символов?

Вам даны две строки s и pattern.
Строка x называется почти равной y, если вы можете изменить не более одного символа в x, чтобы сделать ее идентичной y.
Возвращает наименьший начальный индекс подстроки в s, которая почти равна pattern. Если такого индекса не существует, возвращает -1.
Подстрока — это непрерывная непустая последовательность символов в строке.

Пример 1:

Входные данные: s = "abcdefg", pattern = "bcdffg"
Выходные данные: 1
Пояснение:
Подстроку s[1..6] == "bcdefg" можно преобразовать в "bcdffg", изменив s[4] на "f".

Пример 2:

Входные данные: s = "ababbababa", шаблон = "bacaba"
Выходные данные: 4
Пояснение:
Подстроку s[4..9] == "bababa" можно преобразовать в "bacaba", изменив s[6] на "c".

Пример 3:

Входные данные: s = "abcd", шаблон = "dba"
Выходные данные: -1

Пример 4:

Входные данные: s = "dde", шаблон = "d"
Выходные данные: 0

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

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

Продолжение: Можете ли вы решить задачу, если можно изменить не более k последовательных символов?