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

Пример 1:

Вход: s = "egcfe"
Выход: "efcfe"
Пояснение: Минимальное количество операций, чтобы сделать "egcfe" палиндромом, равно 1, а лексикографически наименьшая строка палиндрома, которую мы можем получить, изменив один символ, — это "efcfe", изменив "g".

Пример 2:

Вход: s = "abcd"
Выход: "abba"
Пояснение: Минимальное количество операций, чтобы сделать "abcd" палиндромом, равно 2, а лексикографически наименьшая строка палиндрома, которую мы можем получить, изменив два символа, — это "abba".

Пример 3:

Вход: s = "seven"
Выход: "neven"
Пояснение: Минимальное количество операций, чтобы сделать "seven" палиндромом, равно 1, а лексикографически наименьшая строка палиндрома, которую мы можем получить, изменив один символ, — это "neven".

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

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

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

Пример 1:

Ввод: s = "egcfe"
Выход: "efcfe"
Пояснение: Минимальное количество операций, позволяющих сделать "egcfe" палиндромом, равно 1, а лексикографически наименьшая строка палиндрома, которую мы можем получить, изменив один символ, это "efcfe", изменив 'g'.

Пример 2:

Ввод: s = "abcd"
Вывод: "abba"
Пояснение: Минимальное количество операций, позволяющих сделать "abcd" палиндромом, равно 2, а лексикографически наименьшая строка палиндрома, которую мы можем получить, изменив два символа, это "abba".

Пример 3:

Ввод: s = "seven"
Выход: "neven"
Пояснение: Минимальное количество операций для создания палиндрома "seven" равно 1, а наименьшая с лексикографической точки зрения строка палиндрома, которую мы можем получить, изменив один символ, это "neven".

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

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


Вам дана 0-индексированная двоичная строка s длины n, к которой вы можете применить два типа операций:

Выберите индекс i и инвертируйте все символы от индекса 0 до индекса i (оба включительно) со стоимостью i + 1
Выберите индекс i и инвертируйте все символы от индекса i до индекса n - 1 (оба включительно) со стоимостью n - i

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

Пример 1:

Вход: s = «0011»
Выход: 2
Объяснение: Примените вторую операцию с i = 2, чтобы получить s = «0000» со стоимостью 2. Можно показать, что 2 — это минимальная стоимость, чтобы сделать все символы равными.

Пример 2:

Вход: s = "010101"
Выход: 9
Объяснение: Примените первую операцию с i = 2, чтобы получить s = "101101" за стоимость 3.
Примените первую операцию с i = 1, чтобы получить s = "011101" за стоимость 2.

Примените первую операцию с i = 0, чтобы получить s = "111101" за стоимость 1.

Примените вторую операцию с i = 4, чтобы получить s = "111110" за стоимость 2.
Примените вторую операцию с i = 5, чтобы получить s = "111111" за стоимость 1.
Общая стоимость выравнивания всех символов составляет 9. Можно показать, что 9 — это минимальная стоимость выравнивания всех символов.

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

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

Вам дана двоичная строка s с 0-индексом длины n, к которой вы можете применять два типа операций:

Выберите индекс i и инвертируйте все символы от индекса 0 до индекса i (оба включительно) со стоимостью i + 1
Выберите индекс i и инвертируйте все символы из индекса i в индекс n - 1 (оба включительно) со стоимостью n - i

Возвращает минимальную стоимость, чтобы все символы строки были равными.
Инвертировать символ означает, что если его значение равно '0', он становится '1' и наоборот.

Пример 1:

Ввод: s = "0011"
Вывод: 2
Пояснение: Примените вторую операцию с i = 2, чтобы получить s = "0000" со стоимостью 2. Можно показать, что 2 это минимальная стоимость, позволяющая сделать все символы равными.

Пример 2:

Ввод: s = "010101"
Вывод: 9
Пояснение: Примените первую операцию с i = 2, чтобы получить s = "101101" со стоимостью 3.
Примените первую операцию с i = 1, чтобы получить s = "011101" со стоимостью 2.
Примените первую операцию с i = 0, чтобы получить s = "111101" со стоимостью 1.
Примените вторую операцию с i = 4, чтобы получить s = "111110" со стоимостью 2.
Примените вторую операцию с i = 5, чтобы получить s = "111111" со стоимостью 1.
Общая стоимость уравнивания всех персонажей равна 9. Можно показать, что 9 это минимальная стоимость уравнивания всех персонажей.

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

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

Вам дана 0-индексированная двоичная строка s длины n, к которой вы можете применить два типа операций:

Выберите индекс i и инвертируйте все символы от индекса 0 до индекса i (оба включительно) со стоимостью i + 1
Выберите индекс i и инвертируйте все символы от индекса i до индекса n - 1 (оба включительно) со стоимостью n - i

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

Пример 1:

Вход: s = "0011"
Выход: 2
Объяснение: Примените вторую операцию с i = 2, чтобы получить s = "0000" со стоимостью 2. Можно показать, что 2 — это минимальная стоимость, чтобы сделать все символы равными.

Пример 2:

Вход: s = "010101"
Выход: 9
Объяснение: Примените первую операцию с i = 2, чтобы получить s = "101101" за стоимость 3.
Примените первую операцию с i = 1, чтобы получить s = "011101" за стоимость 2.
Примените первую операцию с i = 0, чтобы получить s = "111101" за стоимость 1.
Примените вторую операцию с i = 4, чтобы получить s = "111110" за стоимость 2.
Примените вторую операцию с i = 5, чтобы получить s = "111111" за стоимость 1.
Общая стоимость выравнивания всех символов составляет 9. Можно показать, что 9 — это минимальная стоимость выравнивания всех символов.

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

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


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

Пример 1:

Ввод: num = "51230100"
Вывод: "512301"
Объяснение: Целое число "51230100" имеет 2 завершающих нуля, мы их убираем и возвращаем целое число "512301".

Пример 2:

Ввод: num = "123"
Вывод: "123"
Объяснение: Целое число "123" не имеет завершающих нулей, мы возвращаем целое число "123".

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

1 <= num.length <= 1000
num состоит только из цифр.
num не имеет ведущих нулей.

Дано положительное целое число num, представленное в виде строки, вернуть целое число num без конечных нулей в виде строки.

Пример 1:

Вход: num = "51230100"
Выход: "512301"
Пояснение: целое число "51230100" имеет 2 конечных нуля, мы удаляем их и возвращаем целое число "512301".

Пример 2:

Вход: num = "123"
Выход: "123"
Пояснение: целое число "123" не имеет конечных нулей, мы возвращаем целое число "123".

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

1 <= num.length <= 1000
num состоит только из цифр.
num не имеет начальных нулей.


Вам дано целое число n, состоящее ровно из 3 цифр.
Мы называем число n увлекательным, если после следующей модификации полученное число содержит все цифры от 1 до 9 ровно один раз и не содержит нулей:

Объедините n с числами 2 * n и 3 * n.

Верните true, если n увлекательное, или false в противном случае.
Объединение двух чисел означает их объединение. Например, объединение 121 и 371 равно 121371.

Пример 1:

Вход: n = 192
Выход: true
Объяснение: Мы объединяем числа n = 192 и 2 * n = 384 и 3 * n = 576. Полученное число равно 192384576. Это число содержит все цифры от 1 до 9 ровно один раз.

Пример 2:

Вход: n = 100
Выход: false
Объяснение: Мы объединяем числа n = 100 и 2 * n = 200 и 3 * n = 300. Полученное число равно 100200300. Это число не удовлетворяет ни одному из условий.

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

100 <= n <= 999

Вам дано целое число n, состоящее ровно из 3 цифр.
Назовём число n увлекательным, если после следующей модификации полученное число содержит все цифры от 1 до 9 ровно один раз и не содержит ни одного нуля:

Объедините n с числами 2 * n и 3 * n.

Возвращайте true, если n является увлекательным, или false в противном случае.
Объединение двух чисел означает их соединение. Например, объединение 121 и 371 равно 121371.

Пример 1:

Ввод: n = 192
Вывод: true
Пояснение: Соединяем числа n = 192 and 2 * n = 384 и 3 * n = 576. Полученное число 192384576. Это число содержит все цифры от 1 до 9 ровно один раз.

Пример 2:

Ввод: n = 100
Вывод: false
Пояснение: Соединяем числа n = 100 и 2 * n = 200 и 3 * n = 300. В результате получается число 100200300. Это число не удовлетворяет ни одному из условий.

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

100 <= n <= 999

У вас есть целое число n, состоящее ровно из 3 цифр.
Мы называем число n увлекательным, если после следующего изменения полученное число содержит все цифры от 1 до 9 ровно по одному разу и не содержит никаких 0:

Объедините n с числами 2 * n и 3 * n.

Верните true, если n является увлекательным, или false в противном случае.
Объединение двух чисел означает их соединение вместе. Например, объединение 121 и 371 — это 121371.

Пример 1:

Ввод: n = 192
Вывод: true
Объяснение: Мы объединяем числа n = 192 и 2 * n = 384 и 3 * n = 576. Полученное число — 192384576. Это число содержит все цифры от 1 до 9 ровно по одному разу.

Пример 2:

Ввод: n = 100
Вывод: false
Объяснение: Мы объединяем числа n = 100 и 2 * n = 200 и 3 * n = 300. Полученное число — 100200300. Это число не удовлетворяет ни одному из условий.

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

100 <= n <= 999


Дана строка s с индексом 0. Повторно выполните следующее действие любое количество раз:

Выберите индекс i в строке и пусть c будет символом в позиции i. Удалите ближайшее вхождение c слева от i (если есть) и ближайшее вхождение c справа от i (если есть).

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

Пример 1:

Ввод: s = "aaabc"
Вывод: 3
Объяснение: В этом примере s равно "aaabc". Мы можем начать с выбора символа 'a' в индексе 1. Затем удаляем ближайшее 'a' слева от индекса 1, которое находится в индексе 0, и ближайшее 'a' справа от индекса 1, которое находится в индексе 2. После этой операции строка становится "abc". Любая последующая операция не изменит строку. Таким образом, длина минимизированной строки равна 3.

Пример 2:

Ввод: s = "cbbd"
Вывод: 3
Объяснение: Здесь мы можем начать с символа 'b' в индексе 1. Вхождения 'b' слева от индекса 1 нет, но есть справа в индексе 2, поэтому мы удаляем 'b' в индексе 2. Строка становится "cbd", и дальнейшие операции не изменят её. Следовательно, минимизированная длина равна 3.

Пример 3:

Ввод: s = "dddaaa"
Вывод: 2
Объяснение: Здесь мы можем начать с символа 'd' в индексе 1. Ближайшее вхождение 'd' слева находится в индексе 0, а ближайшее вхождение 'd' справа находится в индексе 2. Мы удаляем оба индекса 0 и 2, строка становится "daaa". В новой строке мы можем выбрать символ 'a' в индексе 2. Ближайшее вхождение 'a' слева находится в индексе 1, а ближайшее вхождение 'a' справа находится в индексе 3. Мы удаляем их обоих, и строка становится "da". Мы не можем минимизировать её дальше, поэтому минимизированная длина равна 2.

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

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

Учитывая 0-индексированную строку S, многократно выполняйте следующую операцию в любое количество раз:

Выберите индекс I в строке, и пусть C будет символом в положении i. Удалите ближайшее вхождение C слева от I (если есть) и ближайшее вхождение C справа от i (если есть).

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

Пример 1:

Ввод: s = "aaabc"
Вывод: 3
Объяснение: В этом примере s равно "aaabc". Мы можем начать с выбора символа 'a' в индексе 1. Затем удаляем ближайшее 'a' слева от индекса 1, которое находится в индексе 0, и ближайшее 'a' справа от индекса 1, которое находится в индексе 2. После этой операции строка становится "abc". Любая последующая операция не изменит строку. Таким образом, длина минимизированной строки равна 3.
Пример 2:

Ввод:  s = "cbbd"
Вывод: 3
Объяснение: Здесь мы можем начать с символа 'b' в индексе 1. Вхождения 'b' слева от индекса 1 нет, но есть справа в индексе 2, поэтому мы удаляем 'b' в индексе 2. Строка становится "cbd", и дальнейшие операции не изменят её. Следовательно, минимизированная длина равна 3.

Пример 3:

Пример 3:

Ввод: s = "dddaaa"
Вывод: 2
Объяснение: Здесь мы можем начать с символа 'd' в индексе 1. Ближайшее вхождение 'd' слева находится в индексе 0, а ближайшее вхождение 'd' справа находится в индексе 2. Мы удаляем оба индекса 0 и 2, строка становится "daaa". В новой строке мы можем выбрать символ 'a' в индексе 2. Ближайшее вхождение 'a' слева находится в индексе 1, а ближайшее вхождение 'a' справа находится в индексе 3. Мы удаляем их обоих, и строка становится "da". Мы не можем минимизировать её дальше, поэтому минимизированная длина равна 2.

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

1 <=s.Length <= 100
s содержит только строчные английские буквы

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

Выбери индекс i в строке. Пусть c будет символом в позиции i. Удали ближайшее вхождение c слева от i (если есть) и ближайшее вхождение c справа от i (если есть).

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

Пример 1:

Ввод: s = "aaabc"
Вывод: 3
Пояснение: В этом примере s равно "aaabc". Мы можем начать с выбора символа 'a' в индексе 1. Затем удаляем ближайшее 'a' слева от индекса 1, которое находится в индексе 0, и ближайшее 'a' справа от индекса 1, которое находится в индексе 2. После этой операции строка становится "abc". Любая последующая операция не изменит строку. Таким образом, длина минимизированной строки равна 3.

Пример 2:

Ввод: s = "cbbd"
Вывод: 3
Пояснение: Здесь мы можем начать с символа 'b' в индексе 1. Вхождения 'b' слева от индекса 1 нет, но есть справа в индексе 2, поэтому мы удаляем 'b' в индексе 2. Строка становится "cbd", и дальнейшие операции не изменят её. Следовательно, минимизированная длина равна 3.

Пример 3:

Ввод: s = "dddaaa"
Вывод: 2
Пояснение: Здесь мы можем начать с символа 'd' в индексе 1. Ближайшее вхождение 'd' слева находится в индексе 0, а ближайшее вхождение 'd' справа находится в индексе 2. Мы удаляем оба индекса 0 и 2, строка становится "daaa". В новой строке мы можем выбрать символ 'a' в индексе 2. Ближайшее вхождение 'a' слева находится в индексе 1, а ближайшее вхождение 'a' справа находится в индексе 3. Мы удаляем их, и строка становится "da". Мы не можем минимизировать её дальше, поэтому минимизированная длина равна 2.

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

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


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

Пример 1:

Input: nums = [2,3,6]
Output: true
Объяснение: В этом примере есть 3 возможные пары индексов: (0, 1), (0, 2) и (1, 2).
Чтобы перейти от индекса 0 к индексу 1, мы можем использовать последовательность перемещений 0 -> 2 -> 1, где мы перемещаемся от индекса 0 к индексу 2, потому что gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, и затем перемещаемся от индекса 2 к индексу 1, потому что gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Чтобы перейти от индекса 0 к индексу 2, мы можем сделать это напрямую, потому что gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Аналогично, чтобы перейти от индекса 1 к индексу 2, мы можем сделать это напрямую, потому что gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Пример 2:

Input: nums = [3,9,5]
Output: false
Объяснение: В этом примере нет последовательности перемещений, которая позволила бы нам перейти от индекса 0 к индексу 2. Поэтому мы возвращаем false.

Пример 3:

Input: nums = [4,3,12,8]
Output: true
Объяснение: Существует 6 возможных пар индексов для перемещения: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) и (2, 3). Существует допустимая последовательность перемещений для каждой пары, поэтому мы возвращаем true.

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

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

Вам дан целочисленный массив чисел с 0-индексом, и вам разрешено перемещаться между его индексами. Вы можете перемещаться между индексом i и индексом j, i != j, тогда и только тогда, когда gcd(nums[i], nums[j]) > 1, где gcd это наибольший общий делитель.
Ваша задача это определить, существует ли для каждой пары индексов i и j в nums, где i < j, последовательность обходов, которая может привести нас от i к j.
Возвращайте true, если можно перемещаться между всеми такими парами индексов, или false в противном случае.

Пример 1:

Ввод: nums = [2,3,6]
Вывод: true
Объяснение: В этом примере возможны 3 пары индексов: (0, 1), (0, 2) и (1, 2).
Чтобы перейти от индекса 0 к индексу 1, мы можем использовать последовательность обходов 0 -> 2 -> 1, где мы переходим от индекса 0 к индексу 2, потому что gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, а затем перейти от индекса 2 к индексу 1, поскольку gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Чтобы перейти от индекса 0 к индексу 2, мы можем просто перейти напрямую, потому что gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Аналогично, чтобы перейти от индекса 1 к индексу 2, мы можем просто пойти напрямую, потому что gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Пример 2:

Ввод: nums = [3,9,5]
Вывод: false
Пояснение: В этом примере никакая последовательность обходов не может привести нас от индекса 0 к индексу 2. Итак, мы возвращаем false.

Пример 3:

Ввод: nums = [4,3,12,8]
Вывод: true
Объяснение: Существует 6 возможных пар индексов для перемещения между ними: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), и (2, 3). Для каждой пары существует допустимая последовательность обходов, поэтому мы возвращаем true.

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

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


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

Выберите любую непустую подстроку s, возможно всю строку, затем замените каждый из её символов на предыдущий символ английского алфавита. Например, 'b' превращается в 'a', а 'a' превращается в 'z'.

Верните лексикографически наименьшую строку, которую вы можете получить, выполнив вышеописанную операцию ровно один раз.
Подстрока — это непрерывная последовательность символов в строке.
Строка x лексикографически меньше строки y той же длины, если x[i] стоит перед y[i] в алфавитном порядке для первой позиции i, такой, что x[i] != y[i].

Пример 1:

Ввод: s = "cbabc"
Вывод: "baabc"
Объяснение: Мы применяем операцию к подстроке, начиная с индекса 0 и заканчивая индексом 1 включительно.
Можно доказать, что полученная строка является лексикографически наименьшей.

Пример 2:

Ввод: s = "acbbc"
Вывод: "abaab"
Объяснение: Мы применяем операцию к подстроке, начиная с индекса 1 и заканчивая индексом 4 включительно.
Можно доказать, что полученная строка является лексикографически наименьшей.

Пример 3:

Ввод: s = "leetcode"
Вывод: "kddsbncd"
Объяснение: Мы применяем операцию к всей строке.
Можно доказать, что полученная строка является лексикографически наименьшей.

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

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

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

Выберите любую непустую подстроку s, возможно, всю строку, затем замените каждый из ее символов предыдущим символом английского алфавита. Например, 'b' преобразуется в 'a', а 'a' преобразуется в 'z'.

Возвращаете лексикографически наименьшую строку, которую вы можете получить после выполнения вышеуказанной операции ровно один раз.
Подстрока, это непрерывная последовательность символов в строке.
Строка x лексикографически меньше строки y той же длины, если x[i] стоит перед y[i] в алфавитном порядке для первой позиции i, так что x[i] != y[i].

Пример 1:

Ввод: s = "cbabc"
Вывод: "baabc"
Объяснение: Мы применяем операцию к подстроке, начиная с индекса 0 и заканчивая индексом 1 включительно.
Можно доказать, что полученная строка является наименьшей с лексикографической точки зрения.

Пример 2:

Ввод: s = "acbbc"
Вывод: "abaab"
Объяснение: Мы применяем операцию к подстроке, начиная с индекса 1 и заканчивая индексом 4 включительно.
Можно доказать, что полученная строка является наименьшей с лексикографической точки зрения.

Пример 3:

Ввод: s = "leetcode"
Вывод: "kddsbncd"
Объяснение: Мы применяем операцию ко всей строке.
Можно доказать, что полученная строка является наименьшей с лексикографической точки зрения.

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

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


Вам предоставлен целочисленный массив с индексами, начинающимися с 0, nums. Пара индексов i, j, где 0 <= i < j < nums.length, называется красивой, если первая цифра nums[i] и последняя цифра nums[j] взаимно просты.

Верните общее количество красивых пар в nums.

Два целых числа x и y являются взаимно простыми, если не существует целого числа больше 1, которое делит их оба. Иными словами, x и y являются взаимно простыми, если gcd(x, y) == 1, где gcd(x, y) — это наибольший общий делитель x и y.

Пример 1:

Input: nums = [2,5,1,4]
Output: 5
Пояснение: В nums есть 5 красивых пар:
Когда i = 0 и j = 1: первая цифра nums[0] равна 2, а последняя цифра nums[1] равна 5. Мы можем подтвердить, что 2 и 5 взаимно просты, так как gcd(2,5) == 1.
Когда i = 0 и j = 2: первая цифра nums[0] равна 2, а последняя цифра nums[2] равна 1. Действительно, gcd(2,1) == 1.
Когда i = 1 и j = 2: первая цифра nums[1] равна 5, а последняя цифра nums[2] равна 1. Действительно, gcd(5,1) == 1.
Когда i = 1 и j = 3: первая цифра nums[1] равна 5, а последняя цифра nums[3] равна 4. Действительно, gcd(5,4) == 1.
Когда i = 2 и j = 3: первая цифра nums[2] равна 1, а последняя цифра nums[3] равна 4. Действительно, gcd(1,4) == 1.
Таким образом, мы возвращаем 5.

Пример 2:

Input: nums = [11,21,12]
Output: 2
Пояснение: Есть 2 красивые пары:
Когда i = 0 и j = 1: первая цифра nums[0] равна 1, а последняя цифра nums[1] равна 1. Действительно, gcd(1,1) == 1.
Когда i = 0 и j = 2: первая цифра nums[0] равна 1, а последняя цифра nums[2] равна 2. Действительно, gcd(1,2) == 1.
Таким образом, мы возвращаем 2.

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

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0

Вам дан целочисленный массив чисел с 0-индексом. Пара индексов i, j, где 0 <= i < j < nums.length называется красивой, если первая цифра nums[i] и последняя цифра nums[j] взаимно простые.
Верните общее количество красивых пар в числах.
Два целых числа x и y являются взаимно простыми, если не существует целого числа больше 1, делящего их оба. Другими словами, x и y взаимно просты, если gcd(x, y) == 1, where gcd(x, y) это наибольший общий делитель x и y.

Пример 1:

Ввод: nums = [2,5,1,4]
Вывод: 5
Пояснение: В цифрах есть 5 красивых пар:
Когда i = 0 и j = 1: первая цифра nums[0] равна 2, а последняя цифра nums[1] равна 5. Мы можем подтвердить, что 2 и 5 взаимно просты, поскольку gcd(2,5) = = 1.
Когда i = 0 и j = 2: первая цифра nums[0] равна 2, а последняя цифра nums[2] равна 1. Действительно, gcd(2,1) == 1.
Когда i = 1 и j = 2: первая цифра nums[1] равна 5, а последняя цифра nums[2] равна 1. Действительно, gcd(5,1) == 1.
Когда i = 1 и j = 3: первая цифра nums[1] равна 5, а последняя цифра nums[3] равна 4. Действительно, gcd(5,4) == 1.
Когда i = 2 и j = 3: первая цифра nums[2] равна 1, а последняя цифра nums[3] равна 4. Действительно, gcd(1,4) == 1.
Таким образом, мы возвращаем 5.

Пример 2:

Ввод: nums = [11,21,12]
Вывод: 2
Пояснение: Есть 2 красивые пары:
Когда i = 0 и j = 1: первая цифра nums[0] равна 1, а последняя цифра nums[1] равна 1. Действительно, gcd(1,1) == 1.
Когда i = 0 и j = 2: первая цифра nums[0] равна 1, а последняя цифра nums[2] равна 2. Действительно, gcd(1,2) == 1.
Таким образом, мы возвращаем 2.

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

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0

Вам дан 0-индексированный целочисленный массив nums. Пара индексов i, j, где 0 <= i < j < nums.length называется красивой, если первая цифра nums [i] и последняя цифра nums [j] - взаимно простые.
Верните общее количество красивых пар в nums.
Два целых числа x и y являются взаимно простыми., если нет целого числа, превышающего 1, которое делит их обоих. Другими словами, X и Y являются Bзаимно простые, если НОД (x, y) = 1, где gcd (x, y) является наибольшим распространенным делителем x и y.

Пример 1:

Ввод: nums = [2,5,1,4]
Вывод: 5
Объяснение: В nums есть 5 красивых пар:
Когда i = 0 и j = 1: первая цифра nums[0] равна 2, а последняя цифра nums[1] равна 5. Мы можем подтвердить, что 2 и 5 - Coprime, поскольку GCD (2,5) = = 1.
Когда i = 0 и j = 2: первая цифра Nums [0] равна 2, а последняя цифра Nums [2] - 1. Действительно, НОД(2, 1) = 1.
Когда i = 1 и j = 2: первая цифра Nums [1] составляет 5, а последняя цифра Nums [2] - 1. Действительно, gcd (5,1) = 1.
Когда i = 1 и j = 3: первая цифра Nums [1] составляет 5, а последняя цифра Nums [3] - 4. Действительно, gcd (5,4) = 1.
Когда i = 2 и j = 3: первая цифра Nums [2] равна 1, а последняя цифра Nums [3] - 4. Действительно, gcd (1,4) = 1.
Таким образом, мы возвращаем 5.

Пример 2:

Ввод: nums = [11,21,12]
Вывод: 2
Объяснение: Есть две красивые пары:
Когда i = 0 и j = 1: первая цифра Nums [0] равно 1, а последняя цифра nums [1] является1. Действительно, gcd (1,1) = 1.
Когда i = 0 и j = 2: первая цифра Nums [0] равна 1, а последняя цифра nums [2] является2. Действительно, gcd (1,2) = 1.
Таким образом, мы возвращаем 2.

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

2<= nums.length<= 100
1<= nums[i]<= 9999
nums[i]%10!= 0


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

Пример 1:

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

Пример 2:

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

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

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

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

Пример 1:

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

Пример 2:

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

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

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


Вам дано целое число n, обозначающее общее количество серверов, и 2D массив целых чисел logs с 0-индексацией, где logs[i] = [server_id, time] обозначает, что сервер с id server_id получил запрос в момент времени time.
Вам также даны целое число x и массив целых чисел queries с 0-индексацией.
Верните массив целых чисел arr с 0-индексацией длины queries.length, где arr[i] представляет количество серверов, которые не получили ни одного запроса в течение временного интервала [queries[i] - x, queries[i]].
Обратите внимание, что временные интервалы включительны.

Пример 1:

Ввод: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Вывод: [1,2]
Пояснение:
Для queries[0]: Серверы с id 1 и 2 получают запросы в течение [5, 10]. Таким образом, только сервер 3 не получает запросов.
Для queries[1]: Только сервер с id 2 получает запрос в течение [6,11]. Таким образом, серверы с id 1 и 3 не получают запросов в это время.

Пример 2:

Ввод: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Вывод: [0,1]
Пояснение:
Для queries[0]: Все серверы получают по крайней мере один запрос в течение [1, 3].
Для queries[1]: Только сервер с id 3 не получает запросов в течение [2,4].

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

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Вам дано целое число n, обозначающее общее количество серверов, и 2D 0-индексированный целочисленный массив logs, где logs[i] = [server_id, time] обозначает, что сервер с идентификатором server_id получил запрос в момент времени time..
Вам также дано целое число x и 0-индексированный целочисленный массив queries.
Верните целочисленный массив arr с 0-индексом длиной queries.length где arr[i] представляет количество серверов, которые не получили ни одного запроса в течение временного интервала [queries[i] - x, queries[i]].
Обратите внимание, что временные интервалы указаны включительно.

Пример 1:

Вводные данные: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Вывод: [1,2]
Объяснение:
Для запросов[0]: Серверы с идентификаторами 1 и 2 получают запросы в интервале [5, 10]. Следовательно, только сервер 3 получает нулевые запросы.
Для запросов[1]: Только сервер с идентификатором 2 получает запрос длительностью [6,11]. Следовательно, серверы с идентификаторами 1 и 3 являются единственными серверами, которые не получают никаких запросов в течение этого периода времени.

Пример 2:

Вводные данные: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Вывод: [0,1]
Объяснение:
Для запросов[0]: Все серверы получили хотя бы один запрос в интервале [1, 3].
Для запросов[1]: Только сервер с идентификатором 3 не получает ни одного запроса за время [2,4].

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

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Вам дано целое число n, обозначающее общее количество серверов, и 2D целочисленный массив logs с индексом 0, где logs[i] = [server_id, time] означает, что сервер с идентификатором server_id получил запрос в определенное время.
Вам также даются запросы целого числа x и целочисленного массива с индексом 0.
Возвращает целочисленный массив arr с нулевым индексом длиной  queries.length где arr[i] представляет количество серверов, которые не получили никаких запросов в течение интервала времени [queries[i] - x, queries[i]].
Обратите внимание, что временные интервалы указаны включительно.

Пример 1:

Входные данные: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Выход: [1,2]
Объяснение:
Для queries[0]: серверы с идентификаторами 1 и 2 получают запросы в течение [5, 10]. Следовательно, только сервер 3 получает ноль запросов.
Для queries[1]: только сервер с идентификатором 2 получает запрос длительностью [6,11]. Следовательно, серверы с идентификаторами 1 и 3 являются единственными серверами, которые не получают никаких запросов в течение этого периода времени.

Пример 2:

Входные данные: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Выход: [0,1]
Объяснение:
Для queries[0]: все серверы получают хотя бы один запрос в течение [1, 3].
Для queries[1]: только сервер с идентификатором 3 не получает запросов в течение времени [2,4].

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

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6


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

В течение `moveFrom.length` шагов вы будете изменять позиции шариков. На `i`-м шаге вы перенесёте все шарики с позиции `moveFrom[i]` на позицию `moveTo[i]`.

После выполнения всех шагов верните отсортированный список занятых позиций.

Примечания:

Мы называем позицию занятой, если в ней находится хотя бы один шарик. В одной позиции может находиться несколько шариков.

Пример 1:

Ввод: `nums = [1,6,7,8]`, `moveFrom = [1,7,2]`, `moveTo = [2,9,5]`
Вывод: `[5,6,8,9]`
Объяснение: Изначально шарики находятся в позициях 1,6,7,8.
На `i = 0` шаге мы перемещаем шарики из позиции 1 в позицию 2. Тогда позиции 2,6,7,8 заняты.
На `i = 1` шаге мы перемещаем шарики из позиции 7 в позицию 9. Тогда позиции 2,6,8,9 заняты.
На `i = 2` шаге мы перемещаем шарики из позиции 2 в позицию 5. Тогда позиции 5,6,8,9 заняты.
В конце, финальные позиции, содержащие хотя бы один шарик, — это [5,6,8,9].

Пример 2:

Ввод: `nums = [1,1,3,3]`, `moveFrom = [1,3]`, `moveTo = [2,2]`
Вывод: `[2]`
Объяснение: Изначально шарики находятся в позициях [1,1,3,3].
На `i = 0` шаге мы перемещаем все шарики из позиции 1 в позицию 2. Тогда шарики находятся в позициях [2,2,3,3].
На `i = 1` шаге мы перемещаем все шарики из позиции 3 в позицию 2. Тогда шарики находятся в позициях [2,2,2,2].
Так как 2 — единственная занятая позиция, мы возвращаем [2].

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

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Тестовые случаи сгенерированы таким образом, что в `moveFrom[i]` всегда есть хотя бы один шарик в момент, когда мы хотим применить `i`-е перемещение.

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

Мы можем назвать позицию занятой, если там находится по крайней мере один шарик.
Одну позицию могут занимать несколько шариков.

Пример 1:

Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Output: [5,6,8,9]
Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Output: [5,6,8,9]
Explanation: Initially, the marbles are at positions 1,6,7,8.
At the i = 0th step, we move the marbles at position 1 to position 2. Then, positions 2,6,7,8 are occupied.
At the i = 1st step, we move the marbles at position 7 to position 9. Then, positions 2,6,8,9 are occupied.
At the i = 2nd step, we move the marbles at position 2 to position 5. Then, positions 5,6,8,9 are occupied.
At the end, the final positions containing at least one marbles are [5,6,8,9].
Пример 2:

Input: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Output: [2]
Explanation: Initially, the marbles are at positions [1,1,3,3].
At the i = 0th step, we move all the marbles at position 1 to position 2. Then, the marbles are at positions [2,2,3,3].
At the i = 1st step, we move all the marbles at position 3 to position 2. Then, the marbles are at positions [2,2,2,2].
Since 2 is the only occupied position, we return [2].

Constraints:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
The test cases are generated such that there is at least a marble in moveFrom[i] at the moment we want to apply the i^th move.


Даны два целых числа num1 и num2.
За одну операцию вы можете выбрать целое число i в диапазоне [0, 60] и вычесть 2^i + num2 из num1.
Верните целое число, обозначающее минимальное количество операций, необходимых, чтобы сделать num1 равным 0.
Если сделать num1 равным 0 невозможно, верните -1.

Пример 1:

Ввод: num1 = 3, num2 = -2
Вывод: 3
Объяснение: Мы можем сделать 3 равным 0 с помощью следующих операций:
- Выбираем i = 2 и вычитаем 2^2 + (-2) из 3, 3 - (4 + (-2)) = 1.
- Выбираем i = 2 и вычитаем 2^2 + (-2) из 1, 1 - (4 + (-2)) = -1.
- Выбираем i = 0 и вычитаем 2^0 + (-2) из -1, (-1) - (1 + (-2)) = 0.
Можно доказать, что 3 — это минимальное количество операций, которые нам нужно выполнить.

Пример 2:

Ввод: num1 = 5, num2 = 7
Вывод: -1
Объяснение: Можно доказать, что невозможно сделать 5 равным 0 с помощью данной операции.

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

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Вам дают два целых числа num1 и num2.
В одной операции вы можете выбрать целое число I в диапазоне [0, 60] и вычесть 2^i + num2 из num1.
Верните целое число, обозначающее минимальное количество операций, необходимых для того, чтобы сделать num1 равным 0.
Если невозможно сделать num1 равным 0, верните -1.

Пример 1:

Ввод: num1 = 3, num2 = -2
Вывод: 3
Объяснение: Мы можем сделать 3 равным 0 со следующими операциями:
- Мы выбираем i = 2 и вычесть 2^2 + (-2) из 3, 3- (4 + (-2)) = 1.
-Мы выбираем i = 2 и вычесть 2^2 + (-2) из 1, 1 -(4 + (-2)) = -1.
-Мы выбираем i = 0 и вычесть 2^0 + (-2) из -1, (-1)-(1 + (-2)) = 0.
Можно доказано, что 3 - минимальное количество операций, которые нам нужно выполнить.

Пример 2:

Ввод: num1 = 5, num2 = 7
Вывод: -1
Объяснение: Можно доказано, что невозможно сделать 5 равным 0 с данной операцией.

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

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


Даны два массива целых чисел с 0-индексацией nums1 и nums2, каждый длины n, и двумерный массив с 1-индексацией queries, где queries[i] = [x_i, y_i].
Для i-го запроса найдите максимальное значение nums1[j] + nums2[j] среди всех индексов j (0 <= j < n), где nums1[j] >= x_i и nums2[j] >= y_i, или -1, если нет ни одного j, удовлетворяющего условиям.
Верните массив answer, где answer[i] — это ответ на i-й запрос.

Пример 1:

Ввод: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Вывод: [6,10,7]
Пояснение:
Для 1-го запроса x_i = 4 и y_i = 1, мы можем выбрать индекс j = 0, так как nums1[j] >= 4 и nums2[j] >= 1. Сумма nums1[j] + nums2[j] равна 6, и можно показать, что 6 — это максимум, который можно получить.

Для 2-го запроса x_i = 1 и y_i = 3, мы можем выбрать индекс j = 2, так как nums1[j] >= 1 и nums2[j] >= 3. Сумма nums1[j] + nums2[j] равна 10, и можно показать, что 10 — это максимум, который можно получить.

Для 3-го запроса x_i = 2 и y_i = 5, мы можем выбрать индекс j = 3, так как nums1[j] >= 2 и nums2[j] >= 5. Сумма nums1[j] + nums2[j] равна 7, и можно показать, что 7 — это максимум, который можно получить.

Таким образом, мы возвращаем [6,10,7].

Пример 2:

Ввод: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Вывод: [9,9,9]
Пояснение: В этом примере можно использовать индекс j = 2 для всех запросов, так как он удовлетворяет условиям каждого запроса.

Пример 3:

Ввод: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Вывод: [-1]
Пояснение: В этом примере один запрос с x_i = 3 и y_i = 3. Для каждого индекса j или nums1[j] < x_i или nums2[j] < y_i. Следовательно, решения нет.

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

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9


Дан целочисленный массив nums с 1-индексацией и длиной n.
Элемент nums[i] считается специальным, если i делит n, т.е. n % i == 0.
Верни сумму квадратов всех специальных элементов nums.

Пример 1:

Ввод: nums = [1,2,3,4]
Вывод: 21
Пояснение: В nums ровно 3 специальных элемента: nums[1], поскольку 1 делит 4, nums[2], поскольку 2 делит 4, и nums[4], поскольку 4 делит 4.
Таким образом, сумма квадратов всех специальных элементов nums равна nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Пример 2:

Ввод: nums = [2,7,1,19,18,3]
Вывод: 63
Пояснение: В nums ровно 4 особенных элемента: nums[1], поскольку 1 делит 6, nums[2], поскольку 2 делит 6, nums[3], поскольку 3 делит 6, и nums[6], поскольку 6 делит 6.
Таким образом, сумма квадратов всех специальных элементов nums равна nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

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

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

Вам дан массив целых чисел с 1-индексацией nums длины n.
Элемент nums[i] называется особенным, если i делит n, т.е. n % i == 0.
Верните сумму квадратов всех особенных элементов nums.

Пример 1:

Input: nums = [1,2,3,4]
Output: 21
Объяснение: В nums ровно 3 особенных элемента: nums[1], так как 1 делит 4, nums[2], так как 2 делит 4, и nums[4], так как 4 делит 4.
Таким образом, сумма квадратов всех особенных элементов nums равна nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Пример 2:

Input: nums = [2,7,1,19,18,3]
Output: 63
Объяснение: В nums ровно 4 особенных элемента: nums[1], так как 1 делит 6, nums[2], так как 2 делит 6, nums[3], так как 3 делит 6, и nums[6], так как 6 делит 6.
Таким образом, сумма квадратов всех особенных элементов nums равна nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

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

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


Дан массив положительных целых чисел nums.
Разбей nums на два массива, nums1 и nums2, так чтобы:

Каждый элемент массива nums принадлежал либо массиву nums1, либо массиву nums2.
Оба массива были непустыми.
Значение разбиения было минимизировано.

Значение разбиения |max(nums1) - min(nums2)|.
Здесь max(nums1) обозначает максимальный элемент массива nums1, а min(nums2) обозначает минимальный элемент массива nums2.
Верни целое число, обозначающее значение такого разбиения.

Пример 1:

Ввод: nums = [1,3,2,4]
Вывод: 1
Пояснение: Массив nums можно разбить на nums1 = [1,2] и nums2 = [3,4].
- Максимальный элемент массива nums1 равен 2.
- Минимальный элемент массива nums2 равен 3.
Значение разбиения |2 - 3| = 1.
Можно доказать, что 1 является минимальным значением среди всех разбиений.

Пример 2:

Ввод: nums = [100,1,10]
Вывод: 9
Пояснение: Массив nums можно разбить на nums1 = [10] и nums2 = [100,1].
- Максимальный элемент массива nums1 равен 10.
- Минимальный элемент массива nums2 равен 1.
Значение разбиения |10 - 1| = 9.
Можно доказать, что 9 является минимальным значением среди всех разбиений.

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

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

Дан массив положительных целых чисел nums.
Разделите nums на два массива, nums1 и nums2, так чтобы:

Каждый элемент массива nums принадлежал либо массиву nums1, либо массиву nums2.
Оба массива не пустые.
Значение разбиения минимизировано.

Значение разбиения |max(nums1) - min(nums2)|.
Здесь max(nums1) обозначает максимальный элемент массива nums1, а min(nums2) обозначает минимальный элемент массива nums2.
Верните целое число, обозначающее значение такого разбиения.

Пример 1:

Input: nums = [1,3,2,4]
Output: 1
Explanation: Мы можем разделить массив nums на nums1 = [1,2] и nums2 = [3,4].
- Максимальный элемент массива nums1 равен 2.
- Минимальный элемент массива nums2 равен 3.
Значение разбиения |2 - 3| = 1.
Можно доказать, что 1 является минимальным значением среди всех разбиений.

Пример 2:

Input: nums = [100,1,10]
Output: 9
Explanation: Мы можем разделить массив nums на nums1 = [10] и nums2 = [100,1].
- Максимальный элемент массива nums1 равен 10.
- Минимальный элемент массива nums2 равен 1.
Значение разбиения |10 - 1| = 9.
Можно доказать, что 9 является минимальным значением среди всех разбиений.

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

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

Вам дан массив положительных целых чисел.
Разделите числа на два массива, nums1 и nums2, так что:

Каждый элемент массива nums принадлежит либо массиву nums1, либо массиву nums2.
Оба массива непусты.
Значение раздела сведено к минимуму.

Значение раздела равно |max(nums1) - min(nums2)|.
Здесь max(nums1) обозначает максимальный элемент массива nums1, а min(nums2) обозначает минимальный элемент массива nums2.
Верните целое число, обозначающее значение такого раздела.

Пример 1:

Ввод: nums = [1,3,2,4]
Вывод: 1
Объяснение: Мы можем разделить массив nums на nums1 = [1,2] и nums2 = [3,4].
- Максимальный элемент массива nums1 равен 2.
- Минимальный элемент массива nums2 равен 3.
Значение раздела |2 - 3| = 1.
Можно доказать, что 1 это минимальное значение из всех разделов.

Пример 2:

Ввод: nums = [100,1,10]
Вывод: 9
Объяснение: Мы можем разделить массив nums на nums1 = [10] и nums2 = [100,1].
- Максимальный элемент массива nums1 равен 10.
- Минимальный элемент массива nums2 равен 1.
Значение раздела |10 - 1| = 9.
Можно доказать, что 9 это минимальное значение из всех разделов.

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

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


Дан 0-индексированный массив words, состоящий из уникальных строк.
Строка words[i] может быть объединена с строкой words[j], если:

Строка words[i] равна перевёрнутой строке words[j].
0 <= i < j < words.length.

Верните максимальное количество пар, которые можно сформировать из массива words.
Отметим, что каждая строка может принадлежать не более чем одной паре.

Пример 1:

Input: words = ["cd","ac","dc","ca","zz"]
Output: 2
Пояснение: В этом примере мы можем сформировать 2 пары строк следующим образом:
- Мы объединяем строку 0 с строкой 2, так как перевёрнутая строка word[0] это "dc" и она равна words[2].
- Мы объединяем строку 1 с строкой 3, так как перевёрнутая строка word[1] это "ca" и она равна words[3].
Можно доказать, что 2 — это максимальное количество пар, которые можно сформировать.

Пример 2:

Input: words = ["ab","ba","cc"]
Output: 1
Пояснение: В этом примере мы можем сформировать 1 пару строк следующим образом:
- Мы объединяем строку 0 с строкой 1, так как перевёрнутая строка words[1] это "ab" и она равна words[0].
Можно доказать, что 1 — это максимальное количество пар, которые можно сформировать.

Пример 3:

Input: words = ["aa","ab"]
Output: 0
Пояснение: В этом примере мы не можем сформировать ни одной пары строк.

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

1 <= words.length <= 50
words[i].length == 2
words состоит из уникальных строк.
words[i] содержит только строчные английские буквы.

Вам дан массив слов с индексом 0, состоящий из различных строк.
Строка words[i] может быть объединена со строкой words[j], если:

Строка word[i] равна перевернутой строке words[j].
0 <= i < j < words.length.

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

Пример 1:

Ввод: words = ["cd","ac","dc","ca","zz"]
Вывод: 2
Пояснение: В этом примере мы можем сформировать 2 пары строк следующим образом:
- Мы соединяем 0^ю строку со 2^й строкой, поскольку перевернутая строка word[0] это "dc" и равна words[2].
- Мы соединяем 1^ю строку с 3^й строкой, поскольку перевернутая строка word[1] равна "ca" и равна words[3].
Можно доказать, что 2 это максимальное количество пар, которое можно образовать.
Пример 2:

Ввод: words = ["ab","ba","cc"]
Вывод: 1
Пояснение: В этом примере мы можем сформировать 1 пару строк следующим образом:
- Мы соединяем 0^ю строку с 1^й строкой, поскольку перевернутая строка words[1] равна "ab" и равна words[0].
Можно доказать, что 1 это максимальное количество пар, которое можно образовать.

Пример 3:

Ввод: words = ["aa","ab"]
Вывод: 0
Объяснение: В этом примере мы не можем сформировать ни одну пару строк.

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

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

Вам даны 0-индексированные массив слов, состоящие из различных строк.
Строка Words[i] может быть спарена со строкой Words[j], если:

Строка word[i] равна перевернутой строке word[j].

0 <= i < j <words.length.

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

Пример 1:

Вход: words = ["cd","ac","dc","ca","zz"]
Выход: 2
Пояснение: в этом примере мы можем образовать 2 пары строк следующим образом:
- Мы спариваем 0-ю строку с 2-й строкой так как перевернутая строка word[0] равна "dc" и равна словам[2].
- Мы спариваем 1^-ю текст с 3^-й строкой, так как перевернутая строка word[1] - это "ca" и одинаково слова[3].
Можно доказать, что 2 — это максимальное количество пар, которые могут быть образованы
Пример 2:

Вход: words = ["ab","ba","cc"]
Выход: 1
Пояснение: в этом примере мы можем образовать 1 пару строк следующим образом:
- Мы спариваем 0^-й текст с 1^-й строкой, так как перевернутая строкаwords[1] - это "ab" и равноwords[0].
Можно найти, что 1 — это максимальное количество пар, которые могут быть образованы.

Пример 3:

Вход: words = ["aa","ab"]
Выход: 0
Пояснение: в этом примере мы не можем образовать ни одну пару строк.

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

1 <= words.length <= 50
words[i].length == 2
words состоит из уникальных строк.
words[i] содержит только строчные английские буквы.


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

Для всех индексов 0 <= i < n - 1, либо nums[i] % nums[i+1] == 0, либо nums[i+1] % nums[i] == 0.

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

Пример 1:

Вход: nums = [2,3,6]
Выход: 2
Объяснение: [3,6,2] и [2,6,3] — две специальные перестановки nums.

Пример 2:

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

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

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

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

Для всех индексов 0 <= i < n - 1 выполнено либо nums[i] % nums[i+1] == 0, либо nums[i+1] % nums[i] == 0.

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

Пример 1:

Вход: nums = [2,3,6]
Выход: 2
Пояснение: [3,6,2] и [2,6,3] — две особые перестановки nums.

Пример 2:

Вход: nums = [1,4,3]
Выход: 2
Пояснение: [3,1,4] и [4,1,3] — две особые перестановки nums.

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

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


Номер дисбаланса 0-индексированного целочисленного массива arr длины n определяется как количество индексов в sarr = sorted(arr) таких что:

0 <= i < n - 1, и
sarr[i+1] - sarr[i] > 1

Здесь sorted(arr) — это функция, возвращающая отсортированную версию arr.
Дан 0-индексированный целочисленный массив nums, вернуть сумму номеров дисбаланса всех его подмассивов.
Подмассив — это непрерывная непустая последовательность элементов внутри массива.

Пример 1:

Ввод: nums = [2,3,1,4]
Вывод: 3
Объяснение: Существует 3 подмассива с ненулевыми номерами дисбаланса:
- Подмассив [3, 1] с номером дисбаланса 1.
- Подмассив [3, 1, 4] с номером дисбаланса 1.
- Подмассив [1, 4] с номером дисбаланса 1.
Номер дисбаланса всех остальных подмассивов равен 0. Таким образом, сумма номеров дисбаланса всех подмассивов nums равна 3.

Пример 2:

Ввод: nums = [1,3,3,3,5]
Вывод: 8
Объяснение: Существует 7 подмассивов с ненулевыми номерами дисбаланса:
- Подмассив [1, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3, 3, 5] с номером дисбаланса 2.
- Подмассив [3, 3, 3, 5] с номером дисбаланса 1.
- Подмассив [3, 3, 5] с номером дисбаланса 1.
- Подмассив [3, 5] с номером дисбаланса 1.
Номер дисбаланса всех остальных подмассивов равен 0. Таким образом, сумма номеров дисбаланса всех подмассивов nums равна 8.

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

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

Число дисбаланса целочисленного массива с нулевым индексом arr длины n определяется как количество индексов в sarr = sorted(arr) таких, что:

0 <= i < n - 1, и
sarr[i+1] - sarr[i] > 1

Здесь sorted(arr) — это функция, которая возвращает отсортированную версию arr.
Учитывая целочисленный массив nums с нулевым индексом, верните сумму чисел дисбаланса всех его подмассивов.
Подмассив — это непрерывная непустая последовательность элементов массива.

Пример 1:

Ввод: nums = [2,3,1,4]
Вывод: 3
Пояснение: Есть 3 подмассива с ненулевыми числами дисбаланса:
- Подмассив [3, 1] с номером дисбаланса 1.
- Подмассив [3, 1, 4] с номером дисбаланса 1.
- Подмассив [1, 4] с номером дисбаланса 1.
Число дисбаланса всех остальных подмассивов равно 0. Следовательно, сумма чисел дисбаланса всех подмассивов чисел равна 3.

Пример 2:

Ввод: nums = [1,3,3,3,5]
Выход: 8
Пояснение: имеется 7 подмассивов с ненулевыми числами дисбаланса:
- Подмассив [1, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3, 3] с номером дисбаланса 1.
- Подмассив [1, 3, 3, 3, 5] с номером дисбаланса 2.
- Подмассив [3, 3, 3, 5] с номером дисбаланса 1.
- Подмассив [3, 3, 5] с номером дисбаланса 1.
- Подмассив [3, 5] с номером дисбаланса 1.
Число дисбаланса всех остальных подмассивов равно 0. Следовательно, сумма чисел дисбаланса всех подмассивов чисел равна 8.

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

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

число дисбаланса 0- индексированного целого массива arr длины n определяется как число индексов в sarr = отсортированный (arr) таким образом, что:

0 <= i < n - 1 и
sarr[i+1] - sarr[i] > 1

Здесь упорядоченная (arr) функция, которая возвращает упорядоченную версию arr.
Учитывая 0-индексированный целочисленный массив, верните сумму чисел дисбаланса всех его подмассивов.
Подмассив — это смежная непустая последовательность элементов в массиве.

Пример 1:

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

Пример 2:

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

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

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


Вам даны три целых числа x, y и z.
У вас есть x строк, равных "AA", y строк, равных "BB", и z строк, равных "AB". Вы хотите выбрать некоторые (возможно, все или ни одной) из этих строк и объединить их в некотором порядке, чтобы сформировать новую строку. Эта новая строка не должна содержать "AAA" или "BBB" как подстроку.
Верните максимальную возможную длину новой строки.
Подстрока — это непрерывная непустая последовательность символов внутри строки.

Пример 1:

Input: x = 2, y = 5, z = 1
Output: 12
Объяснение: Мы можем объединить строки "BB", "AA", "BB", "AA", "BB" и "AB" в этом порядке. Тогда наша новая строка будет "BBAABBAABBAB".
Эта строка имеет длину 12, и можно показать, что невозможно построить строку большей длины.

Пример 2:

Input: x = 3, y = 2, z = 2
Output: 14
Объяснение: Мы можем объединить строки "AB", "AB", "AA", "BB", "AA", "BB" и "AA" в этом порядке. Тогда наша новая строка будет "ABABAABBAABBAA".
Эта строка имеет длину 14, и можно показать, что невозможно построить строку большей длины.

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

1 <= x, y, z <= 50

Вам даны три целых числа x, y, и z.
У вас есть строки x, равные "AA", строки y, равные "BB", и строки z, равные "AB". Вы хотите выбрать некоторые (возможно, все или ни одну) из этих строк и объединить их в определённом порядке, чтобы сформировать новую строку. Эта новая строка не должна содержать подстроки "AAA" или "BBB"
Верните максимально возможную длину новой строки.
Подстрока это непрерывная непустая последовательность символов внутри строки.

Пример 1:

Ввод: x = 2, y = 5, z = 1
Вывод: 12
Пояснение: Мы можем соединить строки "BB", "AA", "BB", "AA", "BB", и "AB" в указанном порядке. Тогда наша новая строка это "BBAABBAABBAB".
Эта строка имеет длину 12, и мы можем показать, что невозможно построить строку большей длины.

Пример 2:

Ввод: x = 3, y = 2, z = 2
Вывод: 14
Пояснение: Мы можем соединить строки "AB", "AB", "AA", "BB", "AA", "BB", и "AA" в указанном порядке. Затем наша новая строка это "ABABAABBAABBAA".
Эта строка имеет длину 14, и мы можем показать, что невозможно построить строку большей длины.

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

1 <= x, y, z <= 50

Вам даны три целых числа x, y и z.
У вас есть строки x, равные "AA", строки y, равные "BB", и строки z, равные "AB". Вы хотите выбрать некоторые (возможно, все или ни одной) из этих строк и объединить их в некотором порядке, чтобы сформировать новую строку. Эта новая строка не должна содержать "AAA" или "BBB" в качестве подстроки.
Вернуть максимально возможную длину новой строки.
Подстрока — это непрерывная непустая последовательность символов в строке.

Пример 1:

Входные данные: x = 2, y = 5, z = 1
Выходные данные: 12
Объяснение: мы можем объединить строки "BB", "AA", "BB", "AA", "BB" и "AB" в этом порядке. Тогда наша новая строка будет "BBAABBAABBAB".
Эта строка имеет длину 12, и мы можем показать, что невозможно построить строку большей длины.

Пример 2:

Вход: x = 3, y = 2, z = 2
Выход: 14
Пояснение: Мы можем объединить строки "AB", "AB", "AA", "BB", "AA", "BB" и "AA" в этом порядке. Тогда наша новая строка будет "ABABAABBAABBAA".
Эта строка имеет длину 14, и мы можем показать, что невозможно построить строку большей длины.

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

1 <= x, y, z <= 50


Вам дан 0-индексированный массив words, содержащий n строк.
Давайте определим операцию соединения join(x, y) между двумя строками x и y как конкатенацию их в xy. Однако, если последний символ x равен первому символу y, один из них удаляется.
Например, join("ab", "ba") = "aba" и join("ab", "cde") = "abcde".
Вам нужно выполнить n - 1 операций соединения. Пусть str_0 = words[0]. Начиная с i = 1 до i = n - 1, для i^th операции вы можете сделать одно из следующих:

Сделать str_i = join(str_i - 1, words[i])
Сделать str_i = join(words[i], str_i - 1)

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

Пример 1:

Вход: words = ["aa","ab","bc"]
Выход: 4
Пояснение: В этом примере мы можем выполнить операции соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Можно показать, что минимально возможная длина str_2 равна 4.
Пример 2:

Вход: words = ["ab","b"]
Выход: 2
Пояснение: В этом примере str_0 = "ab", есть два способа получить str_1:
join(str_0, "b") = "ab" или join("b", str_0) = "bab".
Первая строка, "ab", имеет минимальную длину. Следовательно, ответ 2.

Пример 3:

Вход: words = ["aaa","c","aba"]
Выход: 6
Пояснение: в этом примере мы можем выполнить операции соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Можно показать, что минимально возможная длина str_2 равна 6.

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

1 <= words.length <= 1000
1 <= words[i].length <= 50
Каждый символ в words[i] является строчной английской буквой

Вам дан 0-индексированный массив words, содержащий n строк.
Давайте определим операцию соединения join(x, y) между двумя строками x и y как конкатенацию их в xy. Однако, если последний символ x равен первому символу y, один из них удаляется.
Например, join("ab", "ba") = "aba" и join("ab", "cde") = "abcde".
Вам нужно выполнить n - 1 операцию соединения. Пусть str_0 = words[0]. Начиная с i = 1 до i = n - 1, для i^th операции вы можете сделать одно из следующих:

Сделать str_i = join(str_i - 1, words[i])
Сделать str_i = join(words[i], str_i - 1)

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

Пример 1:

Вход: words = ["aa","ab","bc"]
Выход: 4
Пояснение: В этом примере мы можем выполнить операции соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Можно показать, что минимально возможная длина str_2 равна 4.
Пример 2:

Вход: words = ["ab","b"]
Выход: 2
Пояснение: В этом примере str_0 = "ab", есть два способа получить str_1:
join(str_0, "b") = "ab" или join("b", str_0) = "bab".
Первая строка, "ab", имеет минимальную длину. Следовательно, ответ 2.

Пример 3:

Вход: words = ["aaa","c","aba"]
Выход: 6
Пояснение: в этом примере мы можем выполнить операции соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Можно показать, что минимально возможная длина str_2 равна 6.

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

1 <= words.length <= 1000
1 <= words[i].length <= 50
Каждый символ в words[i] является строчной английской буквой

Вам дан массив words с n строками, индексированный с нуля.
Определим операцию соединения join(x, y) между двумя строками x и y как их конкатенацию в xy. Однако, если последний символ x равен первому символу y, один из них удаляется.
Например, join("ab", "ba") = "aba" и join("ab", "cde") = "abcde".
Вы должны выполнить n - 1 операцию соединения. Пусть str_0 = words[0]. Начиная с i = 1 до i = n - 1, для i-й операции можно сделать одно из следующего::

Сделать str_i = join(str_i - 1, words[i])
Сделать str_i = join(words[i], str_i - 1)

Ваша задача — минимизировать длину str_n - 1.
Верните целое число, обозначающее минимально возможную длину str_n - 1.

Пример 1:

Ввод: words = ["aa","ab","bc"]
Вывод: 4
Объяснение: В этом примере мы можем выполнить операцию соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Можно показать, что минимально возможная длина str_2 равна 4.
Пример 2:

Ввод: words = ["ab","b"]
Вывод: 2
Объяснение: В этом примере str_0 = "ab", есть два способа получить str_1:
join(str_0, "b") = "ab" или join("b", str_0) = "bab".
Первая строка, "ab", имеет минимальную длину. Следовательно, ответ 2.

Пример 3:

Ввод: words = ["aaa","c","aba"]
Вывод: 6
Объяснение: В этом примере мы можем выполнить операции соединения в следующем порядке, чтобы минимизировать длину str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Можно показать, что минимально возможная длина str_2 равна 6.

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

1 <= words.length <= 1000
1 <= words[i].length <= 50
Каждый символ в words[i] — это строчная английская буква.


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

0 <= i < j < n
-цель <= nums[j] - nums[i] <= target

Верните максимальное количество прыжков, которое вы можете сделать, чтобы достичь индекса n - 1.
Если нет способа достичь индекса n - 1, верните -1.

Пример 1:

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

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

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

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

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Вам дан массив nums с n целыми числами и целое число target.
Изначально вы находитесь на индексе 0. За один шаг вы можете перепрыгнуть с индекса i на любой индекс j, такой что:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

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

Пример 1:

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

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

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

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

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Вам дан массив из n целых чисел с индексом 0 и целочисленная цель.
Изначально вы находитесь под индексом 0. За один шаг вы можете перейти от индекса i к любому индексу j, при этом:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

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

Пример 1:

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

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

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

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

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9


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

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

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

Пример 1:

Ввод: nums = [1,3,1,2,2]
Вывод: 4
Пояснение: Полные подмассивы следующие: [1,3,1,2], [1,3,1,2,2], [3,1,2] и [3,1,2,2].

Пример 2:

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

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

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

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

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

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

Пример 1:

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

Пример 2:

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

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

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

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

Количество отдельных элементов в подмассиве равно количеству отдельных элементов во всем массиве.

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

Пример 1:

Входные данные: nums = [1,3,1,2,2]
Выходные данные: 4
Пояснение: Полные подмассивы следующие: [1,3,1,2], [1,3,1,2,2], [3,1,2] и [3,1,2,2].

Пример 2:

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

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

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


У грузовика два топливных бака. Вам даны два целых числа, mainTank, представляющее топливо, имеющееся в основном баке в литрах, и additionalTank, представляющее топливо, имеющееся в дополнительном баке в литрах.
Пробег грузовика составляет 10 км на литр. Всякий раз, когда в основном баке израсходуется 5 литров топлива, если в дополнительном баке не менее 1 литра топлива, 1 литр топлива будет перекачиваться из дополнительного бака в основной бак.
Верните максимальное расстояние, которое можно проехать.
Примечание: впрыск из дополнительного бака не является непрерывным. Он происходит внезапно и немедленно для каждых потребленных 5 литров.

Пример 1:

Входные данные: mainTank = 5, additionalTank = 10
Выходные данные: 60
Объяснение:
После расходования 5 литров топлива, остаток топлива составляет (5 - 5 + 1) = 1 литр, а пройденное расстояние составляет 50 км.
После израсходования еще 1 литра топлива, в основной бак не впрыскивается топливо, и основной бак становится пустым.
Общее пройденное расстояние составляет 60 км.

Пример 2:

Входные данные: mainTank = 1, additionalTank = 2
Выходные данные: 10
Объяснение:
После израсходования 1 литра топлива основной бак становится пустым.
Общее пройденное расстояние составляет 10 км.

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

1 <= mainTank, additionalTank <= 100

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

Грузовик расходует 10 км на литр топлива. Каждый раз, когда в основном баке используется 5 литров топлива, если в дополнительном баке есть по крайней мере 1 литр топлива, 1 литр топлива будет перекачан из дополнительного бака в основной.

Верните максимальное расстояние, которое можно проехать.
Примечание: Закачка из дополнительного бака не является непрерывной. Она происходит внезапно и немедленно при каждом расходе 5 литров.

Пример 1:

Входные данные: mainTank = 5, additionalTank = 10
Выход: 60
Объяснение:
После использования 5 литров топлива в баке остается (5 - 5 + 1) = 1 литр, а пройденное расстояние составляет 50 км.
После использования еще 1 литра топлива, топлива в основной бак не закачивается и основной бак становится пустым.
Общее пройденное расстояние составляет 60 км.

Пример 2:

Входные данные: mainTank = 1, additionalTank = 2
Выход: 10
Объяснение:
После использования 1 литра топлива основной бак становится пустым.
Общее пройденное расстояние составляет 10 км.

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

1 <= mainTank, additionalTank <= 100

У грузовика есть два топливных бака. Вам даны два целых числа: mainTank, представляющее количество топлива в основном баке в литрах, и additionalTank, представляющее количество топлива в дополнительном баке в литрах.
Грузовик расходует 10 км на литр топлива. Каждый раз, когда в основном баке используется 5 литров топлива, если в дополнительном баке есть по крайней мере 1 литр топлива, 1 литр топлива будет перекачан из дополнительного бака в основной.
Верните максимальное расстояние, которое можно проехать.
Примечание: Закачка из дополнительного бака не является непрерывной. Она происходит внезапно и немедленно при каждом расходе 5 литров.

Пример 1:

Входные данные: mainTank = 5, additionalTank = 10
Выход: 60
Объяснение:
После использования 5 литров топлива в баке остается (5 - 5 + 1) = 1 литр, а пройденное расстояние составляет 50 км.
После использования еще 1 литра топлива, топлива в основной бак не закачивается и основной бак становится пустым.
Общее пройденное расстояние составляет 60 км.

Пример 2:

Входные данные: mainTank = 1, additionalTank = 2
Выход: 10
Объяснение:
После использования 1 литра топлива основной бак становится пустым.
Общее пройденное расстояние составляет 10 км.

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

1 <= mainTank, additionalTank <= 100


Вам дан 0-индексируемый массив целых чисел nums и целое число threshold.
Найдите длину самого длинного подмассива массива nums, начинающегося с индекса l и заканчивающегося индексом r (0 <= l <= r < nums.length), который удовлетворяет следующим условиям:

nums[l] % 2 == 0
Для всех индексов i в диапазоне [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Для всех индексов i в диапазоне [l, r], nums[i] <= threshold

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

Пример 1:

Ввод: nums = [3,2,5,4], threshold = 5
Вывод: 3
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 1 и заканчивается r = 3 => [2,5,4]. Этот подмассив удовлетворяет условиям.
Следовательно, ответ — это длина подмассива, 3. Можно показать, что 3 — максимальная возможная достижимая длина.

Пример 2:

Ввод: nums = [1,2], threshold = 2
Вывод: 1
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 1 и заканчивается r = 1 => [2].
Он удовлетворяет всем условиям, и можно показать, что 1 — максимальная возможная достижимая длина.

Пример 3:

Ввод: nums = [2,3,4,5], threshold = 4
Вывод: 3
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 0 и заканчивается r = 2 => [2,3,4].
Он удовлетворяет всем условиям.
Следовательно, ответ — это длина подмассива, 3. Можно показать, что 3 — максимальная возможная достижимая длина.

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

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

Вам дается массив целых чисел с индексом 0 nums и пороговое значение целых чисел.
Найдите длину самого длинного подмассива nums, начинающегося с индекса l и заканчивающегося индексом r (0 <= l <= r < nums.length), который удовлетворяет следующим условиям:

nums[l] % 2 == 0
Для всех индексов i в диапазоне [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Для всех индексов i в диапазоне [l, r], nums[i] <= порог

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

Пример 1:

Input: nums = [3,2,5,4], threshold = 5
Output: 3
Объяснение: В этом примере мы можем выбрать подмассив, который начинается с l = 1 и заканчивается на r = 3 = > [2,5,4]. Этот подмассив удовлетворяет условиям.
Следовательно, ответ заключается в длине подмассива, 3. Мы можем показать, что 3 — это максимально возможная достижимая длина.
Пример 2:

Input: nums = [1,2], threshold = 2
Output: 1
Объяснение: В этом примере мы можем выбрать подмассив, который начинается с l = 1 и заканчивается на r = 1 = > [2].
Он удовлетворяет всем условиям, и мы можем показать, что 1 — это максимально возможная достижимая длина.

Пример 3:

Input: nums = [2,3,4,5], threshold = 4
Output: 3
Объяснение: В этом примере мы можем выбрать подмассив, который начинается с l = 0 и заканчивается r = 2 = > [2,3,4].
Он удовлетворяет всем условиям.
Следовательно, ответ заключается в длине подмассива, 3. Мы можем показать, что 3 - это максимально возможная достижимая длина.

Constraints:

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

Вам дан 0-индексируемый массив целых чисел nums и целое число threshold.
Найдите длину самого длинного подмассива массива nums, начинающегося с индекса l и заканчивающегося индексом r (0 <= l <= r < nums.length), который удовлетворяет следующим условиям:

nums[l] % 2 == 0
Для всех индексов i в диапазоне [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Для всех индексов i в диапазоне [l, r], nums[i] <= threshold

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

Пример 1:

Ввод: nums = [3,2,5,4], threshold = 5
Вывод: 3
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 1 и заканчивается r = 3 => [2,5,4]. Этот подмассив удовлетворяет условиям.
Следовательно, ответ — это длина подмассива, 3. Можно показать, что 3 — максимальная возможная достижимая длина.
Пример 2:

Ввод: nums = [1,2], threshold = 2
Вывод: 1
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 1 и заканчивается r = 1 => [2].
Он удовлетворяет всем условиям, и можно показать, что 1 — максимальная возможная достижимая длина.

Пример 3:

Ввод: nums = [2,3,4,5], threshold = 4
Вывод: 3
Объяснение: В этом примере можно выбрать подмассив, который начинается с l = 0 и заканчивается r = 2 => [2,3,4].
Он удовлетворяет всем условиям.
Следовательно, ответ — это длина подмассива, 3. Можно показать, что 3 — максимальная возможная достижимая длина.

Constraints:

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


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

Пример 1:

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

Пример 2:

Ввод: nums = [0,1,0]
Вывод: 1
Пояснение: Существует 1 способ разделить nums на хорошие подмассивы:
- [0,1,0]

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

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

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

Пример 1:

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

Пример 2:

Ввод: nums = [0,1,0]
Вывод: 1
Пояснение: Есть один способ разбить числа на подмассивы:
- [0,1,0]

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

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

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

Пример 1:

Вход: nums = [0,1,0,0,1]
Выход: 3
Пояснение: есть 3 способа разбить nums на хорошие подмассивы:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Пример 2:

Вход: nums = [0,1,0]
Выход: 1
Пояснение: есть 1 способ разбить nums на хорошие подмассивы:
- [0,1,0]

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

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


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

Пусть i, i + 1, ..., j_ — индексы в подмассиве. Тогда для каждой пары индексов i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

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

Пример 1:

Ввод: nums = [5,4,2,4]
Вывод: 8
Пояснение:
Непрерывные подмассивы размера 1: [5], [4], [2], [4].
Непрерывные подмассивы размера 2: [5,4], [4,2], [2,4].
Непрерывный подмассив размера 3: [4,2,4].
Подмассивов размера 4 нет.
Общее количество непрерывных подмассивов = 4 + 3 + 1 = 8.
Можно показать, что больше непрерывных подмассивов нет.

Пример 2:

Ввод: nums = [1,2,3]
Вывод: 6
Пояснение:
Непрерывные подмассивы размера 1: [1], [2], [3].
Непрерывные подмассивы размера 2: [1,2], [2,3].
Непрерывный подмассив размера 3: [1,2,3].
Общее количество непрерывных подмассивов = 3 + 2 + 1 = 6.

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

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

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

Пусть i, i + 1, ..., j_ будут индексами в подмассиве. Тогда для каждой пары индексов i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

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

Пример 1:

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

Пример 2:

Вход: nums = [1,2,3]
Выход: 6
Пояснение:
Непрерывный подмассив размера 1: [1], [2], [3].
Непрерывный подмассив размера 2: [1,2], [2,3].
Непрерывный подмассив размера 3: [1,2,3].
Всего непрерывных подмассивов = 3 + 2 + 1 = 6.

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

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

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

Пусть i, i + 1, ..., j — индексы в подмассиве. Тогда для каждой пары индексов i <= i_1, i_2 <= j выполняется 0 <= |nums[i_1] - nums[i_2]| <= 2.

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

Пример 1:

Вход: nums = [5,4,2,4]
Выход: 8
Пояснение:
Непрерывные подмассивы размера 1: [5], [4], [2], [4].
Непрерывные подмассивы размера 2: [5,4], [4,2], [2,4].
Непрерывный подмассив размера 3: [4,2,4].
Подмассивов размера 4 нет.
Общее количество непрерывных подмассивов = 4 + 3 + 1 = 8.
Можно показать, что больше непрерывных подмассивов нет.

Пример 2:

Вход: nums = [1,2,3]
Выход: 6
Пояснение:
Непрерывные подмассивы размера 1: [1], [2], [3].
Непрерывные подмассивы размера 2: [1,2], [2,3].
Непрерывный подмассив размера 3: [1,2,3].
Общее количество непрерывных подмассивов = 3 + 2 + 1 = 6.

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

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


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

Пример 1:

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

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

Пример 3:

Вход: nums1 = [1,1], nums2 = [2,2]
Выход: 2
Пояснение: Один из способов построения nums3:
nums3 = [nums1[0], nums1[1]] => [1,1].
Весь массив образует неубывающий подмассив длины 2, что делает его максимально достижимой длиной.

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

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

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

Пример 1:

Ввод: nums1 = [2,3,1], nums2 = [1,2,1]
Вывод: 2
Объяснение: Один из способов построить nums3:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Подмассив, начинающийся с индекса 0 и заканчивающийся индексом 1, [2,2], образует неубывающий подмассив длины 2.
Можно показать, что 2 является максимальной достижимой длиной.
Пример 2:

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

Пример 3:

Ввод: nums1 = [1,1], nums2 = [2,2]
Вывод: 2
Объяснение: Один из способов построить nums3:
nums3 = [nums1[0], nums1[1]] => [1,1].
Весь массив образует неубывающий подмассив длины 2, что делает его максимальной достижимой длиной.

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

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


У вас есть целочисленный массив nums с нулевой индексацией. Подмассив s длины m называется чередующимся, если:

m больше 1.
s_1 = s_0 + 1.
Подмассив s с нулевой индексацией выглядит как [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Иными словами, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, и так далее до s[m - 1] - s[m - 2] = (-1)^m.

Верните максимальную длину всех чередующихся подмассивов, присутствующих в nums, или -1, если такого подмассива не существует. Подмассив - это непрерывная непустая последовательность элементов в массиве.

Пример 1:

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

Пример 2:

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

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

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

У вас есть целочисленный массив nums с нулевой индексацией. Подмассив s длины m называется чередующимся, если:

m больше 1.
s_1 = s_0 + 1.
Подмассив s с нулевой индексацией выглядит как [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Иными словами, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, и так далее до s[m - 1] - s[m - 2] = (-1)^m.

Верните максимальную длину всех чередующихся подмассивов, присутствующих в nums, или -1, если такого подмассива не существует. Подмассив - это непрерывная непустая последовательность элементов в массиве.

Пример 1:

Input: nums = [2,3,4,3,4]
Output: 4
Объяснение: Чередующиеся подмассивы: [3,4], [3,4,3], и [3,4,3,4]. Самый длинный из них [3,4,3,4], длиной 4.

Пример 2:

Input: nums = [4,5,6]
Output: 2
Объяснение: [4,5] и [5,6] — единственные два чередующихся подмассива. Оба из них длиной 2.

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

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

Вам дан целочисленный массив чисел с нулевым индексом. Подмассив s длины m называется чередующимся, если:

m больше 1.
s_1 = s_0 + 1.
Подмассив s с индексом 0 выглядит как [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Другими словами, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, и так далее до s[m - 1] - s[m - 2] = (-1)^m.

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

Пример 1:

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

Пример 2:

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

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

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


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

Выберите целое число i, такое что 0 <= i < nums.length - 1 и nums[i] <= nums[i + 1]. Замените элемент nums[i + 1] на nums[i] + nums[i + 1] и удалите элемент nums[i] из массива.

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

Пример 1:

Ввод: nums = [2,3,7,9,3]
Вывод: 21
Объяснение: Мы можем применить следующие операции к массиву:
- Выберите i = 0. Результирующий массив будет nums = [5,7,9,3].
- Выберите i = 1. Результирующий массив будет nums = [5,16,3].
- Выберите i = 0. Результирующий массив будет nums = [21,3].
Наибольший элемент в конечном массиве — 21. Можно показать, что большего элемента получить нельзя.

Пример 2:

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

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

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

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

Выберите целое число i, такое, что 0 <= i < nums.length - 1 и nums[i] <= nums[i + 1]. Замените элемент nums[i + 1] на nums[i] + nums[i + 1] и удалите элемент nums[i] из массива.

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

Пример 1:

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

Пример 2:

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

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

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


Вам дано целое число n. Считается, что два целых числа x и y образуют пару простых чисел, если:

1 <= x <= y <= n
x + y == n
x и y — простые числа

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

Пример 1:

Ввод: n = 10
Вывод: [[3,7],[5,5]]
Объяснение: В этом примере есть две пары простых чисел, удовлетворяющих критериям.
Эти пары [3,7] и [5,5], и мы возвращаем их в отсортированном порядке, как описано в задании.

Пример 2:

Ввод: n = 2
Вывод: []
Объяснение: Можно показать, что нет пары простых чисел, сумма которых равна 2, поэтому мы возвращаем пустой массив.

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

1 <= n <= 10^6

Вам дается целое число n. Мы говорим, что два целых числа x и y образуют пара простых чисел, если:

1 <= x <= y <= n
x + y == n
x и y являются основными числами

Верните 2d сортированный список пар простых чисел [x_i, y_i]. Список должен быть отсортирован в порядке увеличения x_i. Если вообще нет пар простых чисел, верните пустой массив.
Примечание. простое число - это естественное число, больше 1, только с двумя факторами, самими и 1.

Пример 1:

Ввод: n = 10
Вывод: [[3,7], [5,5]]
Объяснение: В этом примере есть две первичные пары, которые удовлетворяют критериям.
Эти пары [3,7] и [5,5], и мы возвращаем их в отсортированном порядке, как описано в задании.

Пример 2:

Ввод: n = 2
Выход: []
Объяснение: Мы можем показать, что нет основной пары чисел, которая дает сумму 2, поэтому мы возвращаем пустой массив.

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

1 <= n <= 10^6


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

Пример 1:

Input: hours = [0,1,2,3,4], target = 2
Output: 3
Пояснение: Компания хочет, чтобы каждый сотрудник отработал как минимум 2 часа.
- Сотрудник 0 отработал 0 часов и не достиг цели.
- Сотрудник 1 отработал 1 час и не достиг цели.
- Сотрудник 2 отработал 2 часа и достиг цели.
- Сотрудник 3 отработал 3 часа и достиг цели.
- Сотрудник 4 отработал 4 часа и достиг цели.
Есть 3 сотрудника, которые достигли цели.

Пример 2:

Input: hours = [5,1,4,2,2], target = 6
Output: 0
Пояснение: Компания хочет, чтобы каждый сотрудник отработал как минимум 6 часов.
Нет сотрудников, которые достигли цели.

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

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

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

Пример 1:

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

Пример 2:

Вход: hours = [5,1,4,2,2], target = 6
Выход: 0
Объяснение: компания хочет, чтобы каждый сотрудник работал не менее 6 часов.
Есть 0 сотрудников, которые достигли цели.

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

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

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

Пример 1:

Input: hours = [0,1,2,3,4], target = 2
Output: 3
Explanation: The company wants each employee to work for at least 2 hours.
- Employee 0 worked for 0 hours and didn't meet the target.
- Employee 1 worked for 1 hours and didn't meet the target.
- Employee 2 worked for 2 hours and met the target.
- Employee 3 worked for 3 hours and met the target.
- Employee 4 worked for 4 hours and met the target.
There are 3 employees who met the target.

Example 2:

Input: hours = [5,1,4,2,2], target = 6
Output: 0
Explanation: The company wants each employee to work for at least 6 hours.
There are 0 employees who met the target.

Constraints:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5