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

Примечания

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

Пример 1:

Ввод: a = "abc", b = "bca", c = "aaa"
Вывод: "aaabca"
Объяснение: Показываем, что "aaabca" содержит все данные строки: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Можно показать, что длина полученной строки будет как минимум 6, и "aaabca" лексикографически наименьшая.

Пример 2:

Ввод: a = "ab", b = "ba", c = "aba"
Вывод: "aba"
Объяснение: Показываем, что строка "aba" содержит все данные строки: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Поскольку длина c равна 3, длина полученной строки будет как минимум 3. Можно показать, что "aba" лексикографически наименьшая.

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

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

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

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

Пример 1:

Входные данные: a = "abc", b = "bca", c = "aaa"
Выходные данные: "aaabca"
Объяснение: Мы показываем, что "aaabca" содержит все заданные строки: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Можно показать, что длина полученной строки будет не менее 6, а «aaabca» — лексикографически наименьшая.
Пример 2:

Входные данные: a = "ab", b = "ba", c = "aba"
Выходные данные: "aba"
Пояснение: Мы показываем, что строка «aba» содержит все заданные строки: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Поскольку длина c равна 3, длина полученной строки будет не менее 3. Можно показать, что «aba» — лексикографически наименьшая.

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

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


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

Выберите любой подмассив размером k из массива и уменьшите все его элементы на 1.

Верните true, если вы можете сделать все элементы массива равными 0, или false в противном случае.
Подмассив — это непрерывная непустая часть массива.

Пример 1:

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

Пример 2:

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

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

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

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

Выберите из массива любой подмассив размера k и уменьшите все его элементы на 1.

Верните true, если вы можете сделать все элементы массива равными 0, или false в противном случае.
Подмассив это непрерывная непустая часть массива.

Пример 1:

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

Пример 2:

Ввод: nums = [1,3,1,1], k = 2
Вывод: false
Объяснение: Невозможно сделать все элементы массива равными 0.

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

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

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

Выберите любой подмассив размера k из массива и уменьшите все его элементы на 1.

Верните True, если вы можете сделать все элементы массива равными 0, или иначе верните False.
подмассив — это непрерывная непустая часть массива.

Пример 1:

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

Пример 2:

Ввод: nums = [1,3,1,1], k = 2
Вывод:  false
Объяснение: Невозможно сделать все элементы массива равными 0.

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

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


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

Строка является палиндромом, если ее можно прочитать одинаково слева направо и справа налево.
Строка длиной len считается полу-палиндромом, если существует положительное целое число d, такое что 1 <= d < len и len % d == 0, и если взять индексы, имеющие одинаковый остаток по модулю d, они образуют палиндром. Например, "aa", "aba", "adbgad" и "abab" являются полу-палиндромами, а "a", "ab" и "abca" не являются.
Подстрока — это непрерывная последовательность символов в строке.

Пример 1:

Ввод: s = "abcac", k = 2
Вывод: 1
Объяснение: Мы можем разделить s на подстроки "ab" и "cac". Строка "cac" уже является полу-палиндромом. Если мы изменим "ab" на "aa", она станет полу-палиндромом с d = 1.
Можно показать, что нет способа разделить строку "abcac" на две полу-палиндромные подстроки. Поэтому ответ будет как минимум 1.
Пример 2:

Ввод: s = "abcdef", k = 2
Вывод: 2
Объяснение: Мы можем разделить ее на подстроки "abc" и "def". Каждая из подстрок "abc" и "def" требует одного изменения, чтобы стать полу-палиндромом, поэтому в общей сложности требуется 2 изменения, чтобы все подстроки стали полу-палиндромами.
Можно показать, что мы не можем разделить данную строку на две подстроки так, чтобы это потребовало менее 2 изменений.
Пример 3:

Ввод: s = "aabbaa", k = 3
Вывод: 0
Объяснение: Мы можем разделить ее на подстроки "aa", "bb" и "aa".
Строки "aa" и "bb" уже являются полу-палиндромами. Таким образом, ответ равен нулю.

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

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

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

Строка является палиндромом, если ее можно читать одинаково слева направо и справа налево.
Строка с длиной len считается полупалиндромом, если существует положительное целое число d, такое, что 1 <= d < len и len % d == 0, и если мы возьмем индексы, которые имеют одинаковый модуль по d, они образуют палиндром. Например, "aa", "aba", "adbgad" и "abab" являются полупалиндромами, а "a", "ab" и "abca" - нет.
Подстрока — это непрерывная последовательность символов в строке.

Пример 1:

Входные данные: s = "abcac", k = 2
Выход: 1
Пояснение: Мы можем разделить s на подстроки "ab" и "cac". Строка "cac" - это уже полупалиндром. Если мы заменим "ab" на "aa", он станет полупалиндромом с d = 1.
Можно показать, что нет никакого способа разделить строку "abcac" на две полупалиндромные подстроки. Следовательно, ответ будет как минимум 1.
Пример 2:

Входные данные: s = "abcdef", k = 2
Выход: 2
Пояснение: Мы можем разделить его на подстроки "abc" и "def". Каждая из подстрок "abc" и "def" требует одного изменения, чтобы стать полупалиндромом, поэтому нам нужно всего 2 изменения, чтобы сделать все подстроки полупалиндромными.
Можно показать, что мы не можем разделить данную строку на две подстроки таким образом, чтобы для этого потребовалось менее 2 изменений.
Пример 3:

Входные данные: s = "aabbaa", k = 3
Выход: 0
Пояснение: Мы можем разделить его на подстроки "aa", "bb" и "aa".
Струны "aa" и "bb" уже являются полупалиндромами. Таким образом, ответ – ноль.

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

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

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

Строка является палиндромом, если её можно одинаково читать слева направо и справа налево.
Строка длиной len считается полупалиндромом, если существует целое положительное число d такое, что 1 <= d < len и len % d == 0, и если мы возьмем индексы, которые имеют одинаковый модуль по d, то они образуют палиндром. Например, "aa", "aba", "adbgad", и, "abab" являются полупалиндромами, а "a", "ab", and, "abca" нет.
Подстрока это непрерывная последовательность символов внутри строки.

Пример 1:

Ввод: s = "abcac", k = 2
Вывод: 1
Пояснение: Мы можем разделить s на подстроки "ab" и "cac". Строка "cac" уже является полупалиндромом. Если мы заменим "ab" на "aa", он станет полупалиндромом с d = 1.
Можно показать, что строку «abcac» невозможно разделить на две полупалиндромные подстроки. Следовательно, ответ будет не менее 1.
Пример 2:

Ввод:  s = "abcdef", k = 2
Вывод: 2
Пояснение: Мы можем разделить его на подстроки "abc" и "def". Каждая из подстрок "abc" и "def" требует одного изменения, чтобы стать полупалиндромом, поэтому нам нужно всего 2 изменения, чтобы сделать все подстроки полупалиндромами.
Можно показать, что мы не можем разделить данную строку на две подстроки так, чтобы для этого потребовалось бы менее двух изменений.
Пример 3:

Ввод: s = "aabbaa", k = 3
Вывод: 0
Пояснение: Мы можем разделить его на подстроки "aa", "bb" и "aa".
Строки "aa" и "bb" уже являются полупалиндромами. Таким образом, ответ это ноль.

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

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


Дан массив строк `words` и символ `separator`, разделите каждую строку в `words` по `separator`.
Верните массив строк, содержащий новые строки, образованные после разделения, исключая пустые строки.

Замечания

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

Пример 1:

Ввод: `words = ["one.two.three","four.five","six"]`, `separator = "."`
Вывод: `["one","two","three","four","five","six"]`
Пояснение: В этом примере мы разделяем следующим образом:

`"one.two.three"` делится на `"one"`, `"two"`, `"three"`
`"four.five"` делится на `"four"`, `"five"`
`"six"` делится на `"six"`

Таким образом, результатирующий массив — `["one","two","three","four","five","six"]`.

Пример 2:

Ввод: `words = ["$easy$","$problem$"]`, `separator = "$"`
Вывод: `["easy","problem"]`
Пояснение: В этом примере мы разделяем следующим образом:

`"$easy$"` делится на `"easy"` (исключая пустые строки)
`"$problem$"` делится на `"problem"` (исключая пустые строки)

Таким образом, результатирующий массив — `["easy","problem"]`.

Пример 3:

Ввод: `words = ["|||"]`, `separator = "|"`
Вывод: `[]`
Пояснение: В этом примере результатом разделения `"|||"` будут только пустые строки, поэтому возвращаем пустой массив `[]`.

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

1 <= words.length <= 100
1 <= words[i].length <= 20
символы в words[i] — это либо строчные английские буквы, либо символы из строки ".,|$#@" (исключая кавычки)
separator — это символ из строки ".,|$#@" (исключая кавычки)

Дан массив строк words и символ separator, разделите каждую строку в words по separator.
Верните массив строк, содержащий новые строки, образованные после разделения, исключая пустые строки.
Замечания

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

Пример 1:

Ввод: words = ["one.two.three","four.five","six"], separator = "."
Вывод: ["one","two","three","four","five","six"]
Пояснение: В этом примере мы разделяем следующим образом:

"one.two.three" splits into "one", "two", "three"
"four.five" splits into "four", "five"
"six" splits into "six"

Таким образом, результатирующий массив — ["one","two","three","four","five","six"].
Пример 2:

Ввод: words = ["$easy$","$problem$"], separator = "$"
Вывод: ["easy","problem"]
Пояснение: В этом примере мы разделяем следующим образом:

"$easy$" делится на "easy" (исключая пустые строки)
"$problem$" делится на "problem" (исключая пустые строки)

Таким образом, результатирующий массив — ["easy","problem"].

Пример 3:

Ввод: words = ["|||"], separator = "|"
Вывод: []
Пояснение: В этом примере результатом разделения "|||" будут только пустые строки, поэтому возвращаем пустой массив [].

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

1 <= words.length <= 100
1 <= words[i].length <= 20
символы в words[i] это либо строчные английские буквы, либо символы из строки ".,|$#@" (исключая кавычки)
separator это символ из строки ".,|$#@" (исключая кавычки)

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

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

Пример 1:

Входные данные: words = ["one.two.three","four.five","six"], separator = "."
Вывод: ["one","two","three","four","five","six"]
Пояснение: В этом примере мы разделяем следующим образом:

"one.two.three" разделяется на "one", "two", "three"
"four.five" разделяется на "four", "five"
"six" разделяется на "six"

Следовательно, результирующий массив — ["one","two","three","four","five","six"].
Пример 2:

Ввод: words = ["$easy$","$problem$"], delimiter = "$"
Вывод: ["easy","problem"]
Пояснение: В этом примере мы разделяем следующим образом:

"$easy$" разделяется на "easy" (исключая пустые строки)
"$problem$" разделяется на "problem" (исключая пустые строки)

Следовательно, результирующий массив ["easy","problem"].

Пример 3:

Вход: words = ["|||"], delimiter = "|"
Выход: []
Пояснение: В этом примере результирующее разделение "|||" будет содержать только пустые строки, поэтому мы возвращаем пустой массив [].

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

1 <= words.length <= 100
1 <= words[i].length <= 20
символы в words[i] — это либо строчные английские буквы, либо символы из строки ".,|$#@" (исключая кавычки)
разделитель это символ из строки ".,|$#@" (исключая кавычки)


Даны два положительных целых числа n и x.
Верните количество способов, которыми n может быть выражено как сумма степени x уникальных положительных целых чисел, другими словами, количество наборов уникальных целых чисел [n_1, n_2, ..., n_k], где n = n_1^x + n_2^x + ... + n_k^x.
Поскольку результат может быть очень большим, верните его по модулю 10^9 + 7.
Например, если n = 160 и x = 3, один из способов выразить n — n = 2^3 + 3^3 + 5^3.

Пример 1:

Входные данные: n = 10, x = 2
Выходные данные: 1
Объяснение: Мы можем выразить n следующим образом: n = 3^2 + 1^2 = 10.
Можно показать, что это единственный способ выразить 10 как сумму степени 2 уникальных целых чисел.

Пример 2:

Вход: n = 4, x = 1
Выход: 2
Объяснение: Мы можем выразить n следующими способами:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

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

1 <= n <= 300
1 <= x <= 5

Даны два натуральных числа n и x.
Выведите количество способов, которыми n можно выразить как сумму уникальных положительных целых чисел в x^th степени, другими словами, количество наборов уникальных целых чисел [n_1, n_2, ..., n_k], где n = n_1^x + n_2^x + ... + n_k^x.
Поскольку результат может быть очень большим, верните его по модулю 10^9 + 7.
Например, если n = 160 и x = 3, один из способов выразить n это n = 2^3 + 3^3 + 5^3.

Пример 1:

Input: n = 10, x = 2
Output: 1
Объяснение:  Мы можем выразить n следующим образом: n = 3^2 + 1^2 = 10.
Можно показать, что это единственный способ выразить 10 как сумму 2-й степени уникальных целых чисел.

Пример 2:

Input: n = 4, x = 1
Output: 2
Объяснение: Мы можем выразить n следующим образом:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Constraints:

1 <= n <= 300
1 <= x <= 5

Даны два положительных целых числа n и x.
Вернуть количество способов, которыми n можно представить в виде суммы x-й степени уникальных положительных целых чисел, другими словами, количество наборов уникальных чисел [n_1, n_2, ..., n_k] где n = n_1^x + n_2^x + ... + n_k^x.
Так как результат может быть очень большим, верните его по модулю 10^9 + 7.
Например, если n = 160 и x = 3, один из способов представить n = 2^3 + 3^3 + 5^3.

Пример 1:

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

Пример 2:

Ввод: n = 4, x = 1
Вывод: 2
Объяснение: Мы можем выразить n следующим образом:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

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

1 <= n <= 300
1 <= x <= 5


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

Она не содержит ведущих нулей.
Она является двоичным представлением числа, являющегося степенью 5.

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

Пример 1:

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

Пример 2:

Ввод: s = "111"
Вывод: 3
Объяснение: Мы можем разбить данную строку на ["1", "1", "1"].
- Строка "1" не содержит ведущих нулей и является двоичным представлением целого числа 5^0 = 1.
Можно показать, что 3 — это минимальное количество красивых подстрок, на которое можно разбить s.

Пример 3:

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

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

1 <= s.length <= 15
s[i] это либо '0', либо '1'.

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

Она не содержит начальных нулей.
Это двоичное представление числа, которое является степенью 5.

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

Пример 1:

Вход: s = "1011"
Выход: 2
Объяснение: Мы можем разбить данную строку на ["101", "1"].
- Строка "101" не содержит начальных нулей и является двоичным представлением целого числа 5^1 = 5.
- Строка "1" не содержит начальных нулей и является двоичным представлением целого числа 5^0 = 1.
Можно показать, что 2 — это минимальное количество красивых подстрок, на которые можно разбить s.

Пример 2:

Вход: s = "111"
Выход: 3
Пояснение: Мы можем разбить данную строку на ["1", "1", "1"].
- Строка "1" не содержит начальных нулей и является двоичным представлением целого числа 5^0 = 1.
Можно показать, что 3 — это минимальное количество красивых подстрок, на которые можно разбить s.

Пример 3:

Вход: s = "0"
Выход: -1
Пояснение: Мы не можем разбить данную строку на красивые подстроки.

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

1 <= s.length <= 15
s[i] равно '0' или '1'.


Вам дана строка word и массив строк forbidden.
Строка называется допустимой, если ни одна из её подстрок не присутствует в forbidden.
Верните длину самой длинной допустимой подстроки строки word.
Подстрока — это последовательность символов в строке, возможно пустая.

Пример 1:

Вход: word = "cbaaaabc", forbidden = ["aaa","cb"]
Выход: 4
Объяснение: В word есть 11 допустимых подстрок: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" и "aabc". Длина самой длинной допустимой подстроки — 4.
Можно показать, что все остальные подстроки содержат либо "aaa", либо "cb" в качестве подстроки.

Пример 2:

Вход: word = "leetcode", forbidden = ["de","le","e"]
Выход: 4
Объяснение: В word есть 11 допустимых подстрок: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" и "tcod". Длина самой длинной допустимой подстроки — 4.
Можно показать, что все остальные подстроки содержат либо "de", либо "le", либо "e" в качестве подстроки.

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

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

Вам дано строковое слово и массив запрещённых строк.
Строка называется допустимой, если ни одна из её подстрок не присутствует в запрещённой.
Возвращает длину самой длинной допустимой подстроки строкового слова.
Подстрока это непрерывная последовательность символов в строке, возможно, пустая.

Пример 1:

Ввод: word = "cbaaaabc", forbidden = ["aaa","cb"]
Вывод: 4
Пояснение: В слове 11 допустимых подстрок: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" и "aabc". Длина самой длинной допустимой подстроки равна 4.
Можно показать, что все остальные подстроки содержат в качестве подстроки либо "aaa" или "cb"
Пример 2:

Ввод: word = "leetcode", forbidden = ["de","le","e"]
Вывод: 4
Пояснение: В слове 11 допустимых подстрок: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", и "tcod". Длина самой длинной допустимой подстроки равна 4.
Можно показать, что все остальные подстроки содержат в качестве подстроки "de", "le", или "e"

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

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

Вам даётся строка word и массив строк forbidden.
Строка называется действительной, если ни одна из её подстрок не содержится в forbidden.
Верните длину самой длинной действительной подстроки строки word.
Подстрока — это непрерывная последовательность символов в строке, которая может быть пустой.

Пример 1:

Ввод: word = "cbaaaabc", forbidden = ["aaa", "cb"]
Вывод: 4
Объяснение:
В word есть 11 допустимых подстрок: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" и "aabc". Длина самой длинной действительной подстроки составляет 4.
Можно показать, что все другие подстроки содержат либо "aaa", либо "cb" в качестве подстроки.

Пример 2:

Ввод: word = "leetcode", forbidden = ["de", "le", "e"]
Вывод: 4
Объяснение:
В word есть 11 допустимых подстрок: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" и "tcod". Длина самой длинной действительной подстроки составляет 4.
Можно показать, что все другие подстроки содержат либо "de", либо "le", либо "e" в качестве подстроки.

Ограничения:
1 <= word.length <= 10^5
word состоит только из строчных английских букв.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] состоит только из строчных английских букв.


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

Пример 1:

Ввод: s = "string"
Вывод: "rtsng"
Объяснение:
После набора первого символа текст на экране — "s".
После второго символа текст — "st".
После третьего символа текст — "str".
Так как четвертый символ — 'i', текст переворачивается и становится "rts".
После пятого символа текст — "rtsn".
После шестого символа текст — "rtsng".
Таким образом, мы возвращаем "rtsng".

Пример 2:

Ввод: s = "poiinter"
Вывод: "ponter"
Объяснение:
После первого символа текст на экране — "p".
После второго символа текст — "po".
Так как третий символ, который вы набираете — 'i', текст переворачивается и становится "op".
Так как четвертый символ, который вы набираете — 'i', текст снова переворачивается и становится "po".
После пятого символа текст — "pon".
После шестого символа текст — "pont".
После седьмого символа текст — "ponte".
После восьмого символа текст — "ponter".
Таким образом, мы возвращаем "ponter".

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

1 <= s.length <= 100
s состоит из строчных английских букв.
s[0] != 'i'

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

Пример 1:

Ввод: s = "string"
Вывод: "rtsng"
Объяснение:
После ввода первого символа на экране появится буква "s".
После второго символа текст "st".
После третьего символа текст "str".
Поскольку четвёртый символ это 'i', текст переворачивается и становится "rts".
После пятого символа текст "rtsn".
После шестого символа текст "rtsng".
Поэтому мы возвращаем "rtsng".

Пример 2:

Ввод: s = "poiinter"
Вывод: "ponter"
Объяснение:
После первого символа текст на экране это "p".
После второго символа текст "po".
Поскольку третий вводимый вами символ это 'i', текст переворачивается и становится "op".
Поскольку четвёртый вводимый вами символ это 'i', текст переворачивается и становится "po".
После пятого символа текст "pon".
После шестого символа текст "pont".
После седьмого символа текст "ponte".
После восьмого символа текст "ponter".
Поэтому возвращаем "ponter".

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

1 <= s.length <= 100
s состоит из строчных Английских букв.
s[0] != 'i'

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

Вам дана строка s с индексом 0, и вы набираете каждый символ s с помощью своей неисправной клавиатуры.

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

Пример 1:

Вход: s = "string"
Выход: "rtsng"
Пояснение:
После ввода первого символа на экране отображается текст "s".

После второго символа отображается текст "st".
После третьего символа отображается текст "str".
Поскольку четвертый символ — это "i", текст переворачивается и становится "rts".
После пятого символа отображается текст "rtsn".
После шестого символа отображается текст "rtsng".
Поэтому мы возвращаем "rtsng".

Пример 2:

Вход: s = "poiinter"
Выход: "ponter"
Пояснение:
После первого символа текст на экране - "p".
После второго символа текст - "po".
Поскольку третий введенный вами символ - "i", текст переворачивается и становится "op".
Поскольку четвертый введенный вами символ - "i", текст переворачивается и становится "po".
После пятого символа текст - "pon".
После шестого символа текст - "pont".
После седьмого символа текст - "ponte".
После восьмого символа текст - "ponter".
Поэтому мы возвращаем "ponter".

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

1 <= s.length <= 100
s состоит из строчных английских букв.
s[0] != 'i'


Дана строка s с индексом 0. Измени s, чтобы получить новую строку t, где:

Все согласные остаются на своих первоначальных местах. Если существует индекс i, где 0 <= i < s.length и s[i] — согласная, то t[i] = s[i].
Гласные должны быть отсортированы в неубывающем порядке их ASCII значений. Для пар индексов i, j, где 0 <= i < j < s.length и s[i] и s[j] являются гласными, ASCII значение t[i] не должно превышать значение t[j].

Верни полученную строку.
Гласные — 'a', 'e', 'i', 'o' и 'u'. Они могут быть в нижнем или верхнем регистре. Согласные включают все буквы, которые не являются гласными.

Пример 1:

Ввод: s = "lEetcOde"
Вывод: "lEOtcede"
Пояснение: 'E', 'O' и 'e' — гласные в s; 'l', 't', 'c' и 'd' — согласные. Гласные отсортированы в соответствии с их ASCII-значениями, а согласные остаются на тех же местах.

Пример 2:

Ввод: s = "lYmpH"
Вывод: "lYmpH"
Пояснение: В s нет гласных (все символы в s — согласные), поэтому возвращаем "lYmpH".

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

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

Учитывая строку s с индексом 0, переставьте s, чтобы получить новую строку t такую, что:

Все согласные остаются на своих прежних местах. Более формально, если существует индекс i с 0 <= i < s.length такой, что s[i] является согласной, то t[i] = s[i].
Гласные должны быть отсортированы в порядке неубывания их значений ASCII. Более формально, для пар индексов i, j с 0 <= i < j < s.length, таких, что s[i] и s[j] являются гласными, тогда t[i] не должно иметь более высокое значение ASCII, чем t[j].

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

Пример 1:

Ввод: s = "lEetcOde"
Вывод: "lEOtcede"
Пояснение: 'E', 'O', и 'e' это гласные в букве s; 'l', 't', 'c', и 'd' это все согласные. Гласные сортируются по их значениям ASCII, а согласные остаются на тех же местах.

Пример 2:

Ввод: s = "lYmpH"
Вывод: "lYmpH"
Пояснение: В слове s нет гласных (все символы в s это согласные), поэтому мы возвращаем "lYmpH".

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

1 <= s.length <= 10%5
s состоит только из букв Английского алфавита в верхнем и нижнем регистре.

Дана строка s с индексом 0, переставьте s, чтобы получить новую строку t, такую, что:

Все согласные остаются на своих исходных местах. Более формально, если есть индекс i с 0 <= i < s.length, такой что s[i] является согласной, то t[i] = s[i].
Гласные должны быть отсортированы в неубывающем порядке их значений ASCII. Более формально, для пар индексов i, j с 0 <= i < j < s.length, таких что s[i] и s[j] являются гласными, то t[i] не должно иметь более высокое значение ASCII, чем t[j].

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

Пример 1:

Вход: s = "lEetcOde"
Выход: "lEOtcede"
Пояснение: 'E', 'O' и 'e' — гласные в s; 'l', 't', 'c' и 'd' — все согласные. Гласные сортируются в соответствии с их значениями ASCII, а согласные остаются на тех же местах.

Пример 2:

Вход: s = "lYmpH"
Выход: "lYmpH"
Пояснение: В s нет гласных (все символы в s — согласные), поэтому мы возвращаем "lYmpH".

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

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


Элемент x целочисленного массива arr длины m является доминирующим, если freq(x) * 2 > m, где freq(x) — это количество вхождений x в arr. Обратите внимание, что это определение подразумевает, что arr может иметь не более одного доминирующего элемента.
Вам дан целочисленный массив nums длины n с индексом 0 и одним доминирующим элементом.
Вы можете разделить nums по индексу i на два массива nums[0, ..., i] и nums[i + 1, ..., n - 1], но разделение допустимо только если:

0 <= i < n - 1
nums[0, ..., i] и nums[i + 1, ..., n - 1] имеют один и тот же доминирующий элемент.

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

Пример 1:

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

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

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

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

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums имеет ровно один доминирующий элемент.

Элемент x целочисленного массива arr длины m является доминирующим, если freq(x) * 2 > m, где freq(x) — это количество вхождений x в arr. Обратите внимание, что это определение подразумевает, что arr может иметь не более одного доминирующего элемента.

Вам дан целочисленный массив nums длины n с индексом 0 и одним доминирующим элементом.

Вы можете разделить nums по индексу i на два массива nums[0, ..., i] и nums[i + 1, ..., n - 1], но разделение допустимо только если:

0 <= i < n - 1
nums[0, ..., i] и nums[i + 1, ..., n - 1] имеют один и тот же доминирующий элемент.

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

Пример 1:

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

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

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

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

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums имеет ровно один доминирующий элемент.

Элемент x в массиве целых чисел arr длины m считается доминирующим, если freq(x) * 2 > m, где freq(x) — количество вхождений x в arr. Обратите внимание, что это определение подразумевает, что в arr может быть не более одного доминирующего элемента.
Вам дан целочисленный массив nums с индексом 0 длины n с одним доминирующим элементом.
Вы можете разделить nums на индексе i на два массива nums[0, ..., i] и nums[i + 1, ..., n - 1], но разделение допустимо только если:

0 <= i < n - 1
nums[0, ..., i], и nums[i + 1, ..., n - 1] имеют один и тот же доминирующий элемент.

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

Пример 1:

Input: nums = [1,2,2,2]
Output: 2
Explanation: Мы можем разделить массив на индексе 2, чтобы получить массивы [1,2,2] и [2].
В массиве [1,2,2] элемент 2 доминирует, так как встречается дважды в массиве и 2 * 2 > 3.
В массиве [2] элемент 2 доминирует, так как встречается один раз в массиве и 1 * 2 > 1.
Оба массива [1,2,2] и [2] имеют одинаковый доминирующий элемент, что делает разделение допустимым.
Можно показать, что индекс 2 является минимальным индексом допустимого раздела.

Пример 2:

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

Пример 3:

Input: nums = [3,3,3,3,7,2,2]
Output: -1
Explanation: Можно показать, что допустимого раздела не существует.

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

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
В nums содержится ровно один доминирующий элемент.


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

Выбрать индекс i, который ранее не выбирался из диапазона [0, nums.length - 1].

Заменить nums[i] любым целым числом из диапазона [nums[i] - k, nums[i] + k].

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

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

Пример 1:

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

Пример 2:

Вход: nums = [1,1,1,1], k = 10
Выход: 4
Пояснение: В этом примере нам не нужно применять никаких операций.
Красота массива nums равна 4 (весь массив).

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

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

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

Выбрать индекс i, который ранее не выбирался из диапазона [0, nums.length - 1].

Заменить nums[i] любым целым числом из диапазона [nums[i] - k, nums[i] + k].

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

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

Пример 1:

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

Пример 2:

Вход: nums = [1,1,1,1], k = 10
Выход: 4
Пояснение: В этом примере нам не нужно применять никаких операций.
Красота массива nums равна 4 (весь массив).

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

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

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

Выберите индекс i, который ранее не был выбран, из диапазона [0, nums.length - 1].
Замените nums[i] на любое целое число из диапазона [nums[i] - k, nums[i] + k].

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

Пример 1:

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

Пример 2:

Входные данные: nums = [1,1,1,1], k = 10
Выход: 4
Пояснение: В этом примере нам не нужно применять никаких операций.
Красота массива nums - 4 (весь массив).

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

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


У вас есть целочисленный массив nums. Мы считаем массив хорошим, если он является перестановкой массива base[n].
base[n] = [1, 2, ..., n - 1, n, n] (другими словами, это массив длины n + 1, который содержит числа от 1 до n - 1 ровно по одному разу, плюс два вхождения n). Например, base[1] = [1, 1] и base[3] = [1, 2, 3, 3].
Верните true, если данный массив хорош, иначе верните false.
Заметка: Перестановка чисел представляет собой их перестановку.

Пример 1:

Input: nums = [2, 1, 3]
Output: false
Пояснение: Поскольку максимальный элемент массива равен 3, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 3. Однако base[3] имеет четыре элемента, а массив nums имеет три. Поэтому это не может быть перестановкой base[3] = [1, 2, 3, 3]. Таким образом, ответ false.

Пример 2:

Input: nums = [1, 3, 3, 2]
Output: true
Пояснение: Поскольку максимальный элемент массива равен 3, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 3. Можно увидеть, что nums является перестановкой base[3] = [1, 2, 3, 3] (перестановкой второго и четвертого элементов в nums, мы достигаем base[3]). Поэтому ответ true.

Пример 3:

Input: nums = [1, 1]
Output: true
Пояснение: Поскольку максимальный элемент массива равен 1, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 1. Можно увидеть, что nums является перестановкой base[1] = [1, 1]. Поэтому ответ true.

Пример 4:

Input: nums = [3, 4, 4, 1, 2, 1]
Output: false
Пояснение: Поскольку максимальный элемент массива равен 4, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 4. Однако base[4] имеет пять элементов, а массив nums имеет шесть. Поэтому это не может быть перестановкой base[4] = [1, 2, 3, 4, 4]. Таким образом, ответ false.

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

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

Дан целочисленный массив nums. Массив считается подходящим, если он является перестановкой массива base[n].
base[n] = [1, 2, ..., n - 1, n, n] (другими словами, это массив длиной n + 1, который содержит числа от 1 до n - 1 ровно по одному разу, плюс два вхождения n). Например, base[1] = [1, 1] и base[3] = [1, 2, 3, 3].
Выведи true, если данный массив подходящий, в противном случае выведи false.
Примечание: перестановка целых чисел представляет собой расположение этих чисел.

Пример 1:

Ввод: nums = [2, 1, 3]
Вывод: false
Пояснение: Поскольку максимальный элемент массива равен 3, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 3. Однако в base[3] четыре элемента, а в массиве nums — три. Следовательно, это не может быть перестановкой base[3] = [1, 2, 3, 3]. Поэтому ответ false.

Пример 2:

Ввод: nums = [1, 3, 3, 2]
Вывод: true
Пояснение: Поскольку максимальный элемент массива равен 3, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 3. Видно, что nums является перестановкой base[3] = [1, 2, 3, 3] (поменяв местами второй и четвертый элементы в nums, мы получаем base[3]). Поэтому ответ true.

Пример 3:

Ввод: nums = [1, 1]
Вывод: true
Пояснение: Поскольку максимальный элемент массива равен 1, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 1. Видно, что nums является перестановкой base[1] = [1, 1]. Поэтому ответ true.

Пример 4:

Ввод: nums = [3, 4, 4, 1, 2, 1]
Вывод: false
Пояснение: Поскольку максимальный элемент массива равен 4, единственный кандидат на n, для которого этот массив мог бы быть перестановкой base[n], это n = 4. Однако base[4] состоит из пяти элементов, а nums — из шести. Поэтому это не может быть перестановкой base[4] = [1, 2, 3, 4, 4]. Таким образом, ответ false.

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

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

Вам дан целочисленный массив чисел. Мы считаем массив хорошим, если он является перестановкой массива  base[n].
base[n] = [1, 2, ..., n - 1, n, n] (другими словами, это массив длины n + 1, который содержит от 1 до n - 1 ровно один раз плюс два вхождения н). Например, base[1] = [1, 1] и base[3] = [1, 2, 3, 3].
Верните true, если данный массив хорош, в противном случае верните false.
Примечание. Перестановка целых чисел представляет собой расположение этих чисел.

Пример 1:

Ввод: nums = [2, 1, 3]
Вывод: false
Объяснение: Поскольку максимальный элемент массива равен 3, единственный кандидат n, для которого этот массив может быть перестановкой base[n], это n = 3. Однако в base[3] четыре элемента, а в массиве nums три. Следовательно, это не может быть перестановка base[3] = [1, 2, 3, 3]. Так что ответ неверный.

Пример 2:

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

Ввод: nums = [1, 1]
Вывод: true
Объяснение: Поскольку максимальный элемент массива равен 1, единственный кандидат n, для которого этот массив может быть перестановкой base[n], это n = 1. Можно видеть, что nums это перестановка base[1] = [1, 1]. Следовательно, ответ верный.
Пример 4:

Ввод: nums = [3, 4, 4, 1, 2, 1]
Вывод: false
Объяснение: Поскольку максимальный элемент массива равен 4, единственным кандидатом n, для которого этот массив может быть перестановкой base[n], является n = 4. Однако в base[4] есть пять элементов, а в массиве nums шесть. Следовательно, это не может быть перестановка base[4] = [1, 2, 3, 4, 4]. Так что ответ неверный.

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

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


Вам дан массив целых чисел с индексом 0 `nums` и положительное целое число `x`.
Изначально вы находитесь на позиции 0 в массиве и можете посещать другие позиции по следующим правилам:

Если вы находитесь в позиции `i`, то можете перейти на любую позицию `j`, такую что `i < j`.
За каждую посещенную позицию `i` вы получаете очки, равные `nums[i]`.
Если вы перемещаетесь с позиции `i` на позицию `j` и четность `nums[i]` и `nums[j]` различается, то теряете очки, равные `x`.

Верните максимальное количество очков, которые вы можете получить.
Учтите, что изначально у вас есть `nums[0]` очков.

Пример 1:

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

Пример 2:

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

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

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

Дан целочисленный массив nums с индексом 0 и положительное целое число x.
Изначально ты находишься на позиции 0 в массиве и можешь посещать другие позиции в соответствии со следующими правилами:

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

Выведи максимальное количество очков, которые можешь получить.
Необходимо учесть, что изначально у тебя nums[0] очков.

Пример 1:

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

Пример 2:

Ввод: nums = [2,4,6,8], x = 3
Вывод: 20
Пояснение: У всех числах в массиве одинаковая четность, поэтому можно посетить все из них без потери очков.
Общий счет: 2 + 4 + 6 + 8 = 20.

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

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

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

Если вы в данный момент находитесь на позиции i, то вы можете перейти на любую позицию j, такую, что i < j.
За каждую посещенную вами позицию i вы получаете оценку nums[i].
Если вы переходите с позиции i на позицию j, а четности nums[i] и nums[j] различаются, то вы теряете оценку x.

Верните максимально возможный общий счет.
Обратите внимание, что изначально у вас есть nums[0] очков.

Пример 1:

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

Пример 2:

Вход: nums = [2,4,6,8], x = 3
Выход: 20
Пояснение: Все целые числа в массиве имеют одинаковую четность, поэтому мы можем посетить их все, не теряя ни одного счета.
Общая оценка: 2 + 4 + 6 + 8 = 20.

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

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


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

Пример 1:

Input: nums = [51,71,17,24,42]
Output: 88
Объяснение:
Для i = 1 и j = 2, nums[i] и nums[j] имеют одинаковые максимальные цифры с суммой пары 71 + 17 = 88.
Для i = 3 и j = 4, nums[i] и nums[j] имеют одинаковые максимальные цифры с суммой пары 24 + 42 = 66.
Можно показать, что нет других пар с одинаковыми максимальными цифрами, поэтому ответ 88.

Пример 2:

Input: nums = [1,2,3,4]
Output: -1
Объяснение: В nums не существует пары с одинаковыми максимальными цифрами.

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

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

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

Пример 1:

Input: nums = [51,71,17,24,42]
Output: 88
Explanation:
For i = 1 and j = 2, nums[i] and nums[j] have equal maximum digits with a pair sum of 71 + 17 = 88.
For i = 3 and j = 4, nums[i] and nums[j] have equal maximum digits with a pair sum of 24 + 42 = 66.
It can be shown that there are no other pairs with equal maximum digits, so the answer is 88.
Пример 2:

Input: nums = [1,2,3,4]
Output: -1
Explanation: No pair exists in nums with equal maximum digits.

Constraints:

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

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

Пример 1:

Ввод: nums = [51,71,17,24,42]
Выход: 88
Пояснение:
Для i = 1 и j = 2, nums[i] и nums[j] имеют равные максимальные цифры, и их сумма составляет 71 + 17 = 88.
Для i = 3 и j = 4 nums[i] и nums[j] имеют равные максимальные цифры с парой в 24 + 42 = 66.
Можно показать, что нет других пар с равными максимальными цифрами, поэтому ответ 88.

Пример 2:

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

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

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


Вам дан 0-индексированный массив целых чисел `nums`, целое число `modulo` и целое число `k`.
Ваша задача — найти количество интересных подмассивов.
Подмассив `nums[l..r]` считается интересным, если выполняется следующее условие:

Пусть `cnt` — количество индексов `i` в диапазоне `[l, r]`, таких что `nums[i] % modulo == k`. Тогда `cnt % modulo == k`.

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

Пример 1:

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

Пример 2:

Ввод: `nums = [3,1,9,6]`, `modulo = 3`, `k = 0`
Вывод: `2`
Объяснение: В этом примере интересные подмассивы:
Подмассив `nums[0..3]`, то есть `[3,1,9,6]`.
- Есть три индекса `i = 0, 2, 3` в диапазоне `[0, 3]`, которые удовлетворяют `nums[i] % modulo == k`.
- Следовательно, `cnt = 3` и `cnt % modulo == k`.
Подмассив `nums[1..1]`, то есть `[1]`.
- Нет индекса `i` в диапазоне `[1, 1]`, который удовлетворяет `nums[i] % modulo == k`.
- Следовательно, `cnt = 0` и `cnt % modulo == k`.
Можно показать, что других интересных подмассивов нет. Поэтому ответ — `2`.

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

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

Вам дан целочисленный массив nums с нулевым индексом, целое число по модулю и целое число k.
Ваша задача, найти количество интересных подмассивов.
Подмассив nums[l..r] интересен, если выполняется следующее условие:

Пусть cnt это количество индексов i в диапазоне [l, r] таких, что nums[i] % modulo == k. Тогда cnt % modulo == k.

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

Пример 1:

Ввод: nums = [3,2,4], modulo = 2, k = 1
Вывод: 3
Пояснение: В этом примере интересны следующие подмассивы:
Подмассив nums[0..0] равен [3].
- В диапазоне [0, 0] есть только один индекс, i = 0, который удовлетворяет условию nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Подмассив nums[0..1] равен [3,2].
- В диапазоне [0, 1] существует только один индекс, i = 0, который удовлетворяет условию nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Подмассив nums[0..2] равен [3,2,4].
- В диапазоне [0, 2] существует только один индекс, i = 0, который удовлетворяет условию nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Можно показать, что других интересных подмассивов нет. Итак, ответ 3.
Пример 2:

Ввод: nums = [3,1,9,6], modulo = 3, k = 0
Вывод: 2
Пояснение: В этом примере интересны следующие подмассивы:
Подмассив nums[0..3] равен [3,1,9,6].
- В диапазоне [0, 3] есть три индекса, i = 0, 2, 3, которые удовлетворяют условиям nums[i] % modulo == k.
- Следовательно, cnt = 3 и cnt % modulo == k.
Подмассив nums[1..1] равен [1].
- В диапазоне [1, 1] нет индекса i, удовлетворяющего условию nums[i] % modulo == k.
- Следовательно, cnt = 0 и cnt % modulo == k.
Можно показать, что других интересных подмассивов нет. Итак, ответ 2.

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

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

Вам дан целочисленный массив nums с индексом 0, целое число по модулю и целое число k.
Ваша задача — найти количество подмассивов, которые интересны.
Подмассив nums[l..r] интересен, если выполняется следующее условие:

Пусть cnt будет количеством индексов i в диапазоне [l, r], таких, что nums[i] % modulo == k. Тогда cnt % modulo == k.

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

Пример 1:

Входные данные: nums = [3,2,4], modulo = 2, k = 1
Выходные данные: 3
Пояснение: В этом примере интересными подмассивами являются:
Подмассив nums[0..0], который равен [3].
- В диапазоне [0, 0] есть только один индекс i = 0, который удовлетворяет nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Подмассив nums[0..1], который равен [3,2].
- В диапазоне [0, 1] есть только один индекс i = 0, который удовлетворяет nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Подмассив nums[0..2], который равен [3,2,4].
- В диапазоне [0, 2] есть только один индекс i = 0, который удовлетворяет nums[i] % modulo == k.
- Следовательно, cnt = 1 и cnt % modulo == k.
Можно показать, что других интересных подмассивов нет. Итак, ответ 3.
Пример 2:

Вход: nums = [3,1,9,6], modulo = 3, k = 0
Выход: 2
Пояснение: В этом примере интересными подмассивами являются:
Подмассив nums[0..3], который равен [3,1,9,6].
- Есть три индекса, i = 0, 2, 3, в диапазоне [0, 3], которые удовлетворяют nums[i] % modulo == k.
- Следовательно, cnt = 3 и cnt % modulo == k.
Подмассив nums[1..1], который равен [1].
- Нет индекса i в диапазоне [1, 1], который удовлетворяет nums[i] % modulo == k.
- Следовательно, cnt = 0 и cnt % modulo == k.
Можно показать, что других интересных подмассивов нет. Поэтому ответ 2.

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

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


У вас есть массив nums длины n и целое число m. Необходимо определить, можно ли разбить массив на n непустых массивов, выполняя серию шагов.

На каждом шаге вы можете выбрать существующий массив (который может быть результатом предыдущих шагов) длиной не менее двух и разделить его на два подмассива, если для каждого полученного подмассива выполняется одно из следующих условий:

Длина подмассива равна единице, или
Сумма элементов подмассива больше или равна m.

Верните true, если вы можете разбить данный массив на n массивов, в противном случае верните false.
Замечание: Подмассив — это непрерывная непустая последовательность элементов внутри массива.

Пример 1:

Input: nums = [2, 2, 1], m = 4
Output: true
Explanation: Мы можем разбить массив на [2, 2] и [1] на первом шаге. Затем, на втором шаге, мы можем разделить [2, 2] на [2] и [2]. В результате ответ — true.
Пример 2:

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

Input: nums = [2, 3, 3, 2, 3], m = 6
Output: true
Explanation: Мы можем разбить массив на [2, 3, 3, 2] и [3] на первом шаге. Затем, на втором шаге, мы можем разделить [2, 3, 3, 2] на [2, 3, 3] и [2]. Затем, на третьем шаге, мы можем разделить [2, 3, 3] на [2] и [3, 3]. И на последнем шаге мы можем разделить [3, 3] на [3] и [3]. В результате ответ — true.

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

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

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

Длина подмассива равна единице или
Сумма элементов подмассива больше или равна m.

Верните true, если вы можете разбить заданный массив на n массивов, в противном случае верните false.
Примечание: Подмассив — это непрерывная непустая последовательность элементов внутри массива.

Пример 1:

Входные данные: nums = [2, 2, 1], m = 4
Выходные данные: true
Объяснение: Мы можем разбить массив на [2, 2] и [1] на первом шаге. Затем, на втором шаге, мы можем разделить [2, 2] на [2] и [2]. В результате ответ будет true.
Пример 2:

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

Входные данные: nums = [2, 3, 3, 2, 3], m = 6
Выходные данные: true
Пояснение: Мы можем разделить массив на [2, 3, 3, 2] и [3] на первом шаге. Затем, на втором шаге, мы можем разделить [2, 3, 3, 2] на [2, 3, 3] и [2]. Затем, на третьем шаге, мы можем разделить [2, 3, 3] на [2] и [3, 3]. И на последнем шаге мы можем разделить [3, 3] на [3] и [3]. В результате ответ будет true.

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

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Дан целочисленный массив nums длины n с 0-индексацией и целое число target. Вернуть количество пар (i, j), где 0 <= i < j < n и nums[i] + nums[j] < target.

Пример 1:

Вход: nums = [-1,1,2,3,1], target = 2
Выход: 3
Объяснение: Существует 3 пары индексов, которые удовлетворяют условиям в утверждении:
- (0, 1), так как 0 < 1 и nums[0] + nums[1] = 0 < target
- (0, 2), так как 0 < 2 и nums[0] + nums[2] = 1 < target
- (0, 4), так как 0 < 4 и nums[0] + nums[4] = 0 < target
Обратите внимание, что (0, 3) не учитывается, так как nums[0] + nums[3] не строго меньше target.

Пример 2:

Вход: nums = [-6,2,5,-2,-7,-1,3], target = -2
Выход: 10
Объяснение: Существует 10 пар индексов, которые удовлетворяют условиям в утверждении:
- (0, 1), так как 0 < 1 и nums[0] + nums[1] = -4 < target
- (0, 3), так как 0 < 3 и nums[0] + nums[3] = -8 < target
- (0, 4), так как 0 < 4 и nums[0] + nums[4] = -13 < target
- (0, 5), так как 0 < 5 и nums[0] + nums[5] = -7 < target
- (0, 6), так как 0 < 6 и nums[0] + nums[6] = -3 < target
- (1, 4), так как 1 < 4 и nums[1] + nums[4] = -5 < target
- (3, 4), так как 3 < 4 и nums[3] + nums[4] = -9 < target
- (3, 5), так как 3 < 5 и nums[3] + nums[5] = -3 < target
- (4, 5), так как 4 < 5 и nums[4] + nums[5] = -8 < target
- (4, 6), так как 4 < 6 и nums[4] + nums[6] = -4 < target

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

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Учитывая целочисленный массив nums с нулевым индексом длины n и целочисленную цель, верните количество пар (i, j), где 0 <= i < j < n и nums[i] + nums[j] < target.

Пример 1:

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

Пример 2:

Ввод: nums = [-6,2,5,-2,-7,-1,3], target = -2
Вывод: 10
Пояснение: Есть 10 пар индексов, которые удовлетворяют условиям оператора:
- (0, 1) поскольку 0 < 1 и nums[0] + nums[1] = -4 < target
- (0, 3) поскольку 0 < 3 и nums[0] + nums[3] = -8 < target
- (0, 4) поскольку 0 < 4 и nums[0] + nums[4] = -13 < target
- (0, 5) поскольку 0 < 5 и nums[0] + nums[5] = -7 < target
- (0, 6) поскольку 0 < 6 и nums[0] + nums[6] = -3 < target
- (1, 4) поскольку 1 < 4 и nums[1] + nums[4] = -5 < target
- (3, 4) поскольку 3 < 4 и nums[3] + nums[4] = -9 < target
- (3, 5) поскольку 3 < 5 и nums[3] + nums[5] = -3 < target
- (4, 5) поскольку 4 < 5 и nums[4] + nums[5] = -8 < target
- (4, 6) поскольку 4 < 6 и nums[4] + nums[6] = -4 < target

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

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Дан целочисленный массив nums длины n с 0-индексацией и целое число target. Вернуть количество пар (i, j), где 0 <= i < j < n и nums[i] + nums[j] < target.

Пример 1:

Ввод: nums = [-1,1,2,3,1], target = 2
Вывод: 3
Объяснение: Существует 3 пары индексов, которые удовлетворяют условиям в утверждении:
- (0, 1) так как 0 < 1 и nums[0] + nums[1] = 0 < target
- (0, 2) так как 0 < 2 и nums[0] + nums[2] = 1 < target
- (0, 4) так как 0 < 4 и nums[0] + nums[4] = 0 < target
Обратите внимание, что (0, 3) не учитывается, так как nums[0] + nums[3] не строго меньше target.

Example 2:

Ввод: nums = [-6,2,5,-2,-7,-1,3], target = -2
Вывод: 10
Объяснение: Существует 10 пар индексов, которые удовлетворяют условиям в утверждении:
- (0, 1) так как 0 < 1 и nums[0] + nums[1] = -4 < target
- (0, 3) так как 0 < 3 и nums[0] + nums[3] = -8 < target
- (0, 4) так как 0 < 4 и nums[0] + nums[4] = -13 < target
- (0, 5) так как 0 < 5 и nums[0] + nums[5] = -7 < target
- (0, 6) так как 0 < 6 и nums[0] + nums[6] = -3 < target
- (1, 4) так как 1 < 4 и nums[1] + nums[4] = -5 < target
- (3, 4) так как 3 < 4 и nums[3] + nums[4] = -9 < target
- (3, 5) так как 3 < 5 и nums[3] + nums[5] = -3 < target
- (4, 5) так как 4 < 5 и nums[4] + nums[5] = -8 < target
- (4, 6) так как 4 < 6 и nums[4] + nums[6] = -4 < target

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

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50


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

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

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

Пример 1:

Ввод: usageLimits = [1,2,5]
Вывод: 3
Пояснение: В этом примере можно использовать 0 не более одного раза, 1 не более двух раз и 2 не более пяти раз.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [2].
Группа 2 содержит числа [1,2].
Группа 3 содержит числа [0,1,2].
Можно доказать, что максимальное количество групп равно 3.
Таким образом, ответ 3.
Пример 2:

Ввод: usageLimits = [2,1,2]
Вывод: 2
Пояснение: В этом примере можно использовать 0 не более двух раз, 1 не более одного раза и 2 не более двух раз.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [0].
Группа 2 содержит числа [1,2].
Можно доказать, что максимальное количество групп равно 2.
Таким образом, ответ 2.

Пример 3:

Ввод: usageLimits = [1,1]
Вывод: 1
Пояснение: В этом примере можно использовать как 0, так и 1 не более одного раза.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [0].
Можно доказать, что максимальное количество групп равно 1.
Таким образом, ответ 1.

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

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

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

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

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

Пример 1:

Ввод: usageLimits = [1,2,5]
Вывод: 3
Объяснение: В этом примере мы можем использовать 0 не более одного раза, 1 не более двух раз, и 2 не более пяти раз.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [2].
Группа 2 содержит числа [1,2].
Группа 3 содержит числа [0,1,2].
Можно показать, что максимальное количество групп - 3.
Таким образом, ответ 3.
Пример 2:

Ввод: usageLimits = [2,1,2]
Вывод: 2
Объяснение: В этом примере мы можем использовать 0 не более двух раз, 1 не более одного раза, и 2 не более двух раз.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [0].
Группа 2 содержит числа [1,2].
Можно показать, что максимальное количество групп - 2.
Таким образом, ответ 2.

Пример 3:

Ввод: usageLimits = [1,1]
Вывод: 1
Объяснение: В этом примере мы можем использовать как 0, так и 1 не более одного раза.
Один из способов создать максимальное количество групп, удовлетворяющих условиям:
Группа 1 содержит число [0].
Можно показать, что максимальное количество групп - 1.
Таким образом, ответ 1.

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

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

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

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

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

Пример 1:

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

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

Пример 3:

Вход: usageLimits = [1,1]
Выход: 1
Пояснение: в этом примере мы можем использовать как 0, так и 1 одновременно.
Одним из способов создания максимального числа групп при соблюдении условий является:
Группа 1 содержит номер [0].
Можно показать, что максимальное количество групп — 1.
Итак, выход 1.

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

1 <= usageLimits.Длина <= 10^5
1 <= usageLimits[i] <= 10^9


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

Для каждого индекса i в диапазоне [0, n - 1], замените nums[i] на nums[i], nums[(i - 1 + n) % n] или nums[(i + 1) % n].

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

Пример 1:

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

Пример 2:

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

Пример 3:

Ввод: nums = [5,5,5,5]
Вывод: 0
Объяснение: Нам не нужно выполнять операции, так как все элементы в начальном массиве одинаковы.

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

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

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

Для каждого индекса i в диапазоне [0, n - 1] заменить nums[i] либо nums[i], nums[(i - 1 + n) % n], либо nums[(i + 1) % n].

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

Пример 1:

Ввод: nums = [1,2,1,2]
Выход: 1
Объяснение: мы можем уравнять массив в 1 секунду следующим образом:
- в 1^st second заменить значения в каждом индексе на [nums[3],nums[1],nums[3],nums[3]]. После замены nums = [2,2,2,2].
Можно доказать, что 1 секунда — минимальное время, необходимое для выравнивания массива.

Пример 2:

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

Пример 3:

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

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

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

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

Для каждого индекса i в диапазоне [0, n - 1], замените nums[i] на nums[i], nums[(i - 1 + n) % n] или nums[(i + 1) % n].

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

Пример 1:

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

Пример 2:

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

Пример 3:

Ввод: nums = [5,5,5,5]
Вывод: 0
Объяснение: Нам не нужно выполнять операции, так как все элементы в начальном массиве одинаковы.

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

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


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

Пример 1:

Ввод: low = "1", high = "11"
Вывод: 10
Пояснение: Число перехода в диапазоне [1,11] это 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10. Всего в диапазоне 10 числа перехода. Следовательно, вывод равен 10.
Пример 2:

Ввод: low = "90", high = "101"
Вывод: 2
Объяснение: Число перехода в диапазоне [90,101] — 98 и 101. Всего в диапазоне 2 числа перехода. Следовательно, вывод равен 2.

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

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low и high состоят только из цифр.
low и high не имеют ведущих нулей.

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

Пример 1:

Ввод: low = "1", high = "11"
Вывод: 10
Объяснение: Ступенчатые числа в диапазоне [1,11] — это 1, 2, 3, 4, 5, 6, 7, 8, 9 и 10. Всего в диапазоне 10 ступенчатых чисел. Следовательно, вывод равен 10.
Пример 2:

Ввод: low = "90", high = "101"
Вывод: 2
Объяснение: Ступенчатые числа в диапазоне [90,101] — это 98 и 101. Всего в диапазоне 2 ступенчатых числа. Следовательно, вывод равен 2.

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

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low и high состоят только из цифр.
low и high не имеют начальных нулей.

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

Пример 1:

Вход: low = "1", high = "11"
Выход: 10
Пояснение: Шаговые числа в диапазоне [1,11] равны 1, 2, 3, 4, 5, 6, 7, 8, 9 и 10. Всего в диапазоне 10 шаговых чисел. Следовательно, вывод равен 10.
Пример 2:

Вход: low = "90", high = "101"
Выход: 2
Пояснение: Шаговые числа в диапазоне [90,101] равны 98 и 101. Всего в диапазоне 2 шаговых числа. Следовательно, вывод равен 2.

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

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low и high состоят только из цифр.
low и high не имеют начальных нулей.


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

Выберите индекс 0 <= i < nums1.length и сделайте nums1[i] = 0.

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

Пример 1:

Ввод: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Вывод: 3
Объяснение:
В 1ю секунду мы применяем операцию к i = 0. Следовательно, nums1 = [0,2+2,3+3] = [0,4,6].
На 2ю секунду мы применяем операцию к i = 1. Поэтому nums1 = [0+1,0,6+3] = [1,0,9].
На 3й секунде мы применяем операцию к i = 2. Следовательно, nums1 = [1+1,0+2,0] = [2,2,0].
Теперь сумма nums1 = 4. Можно показать, что эти операции оптимальны, поэтому мы возвращаем 3.

Пример 2:

Ввод: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Вывод: -1
Пояснение: Можно показать, что сумма nums1 всегда будет больше x, независимо от того, какие операции выполняются.

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

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Вам даны два целочисленных массива с индексацией 0 nums1 и nums2 одинаковой длины. Каждую секунду для всех индексов 0 <= i < nums1.length, значение nums1[i] увеличивается на nums2[i]. После того, как это будет сделано, можно проделать следующую операцию:

Выберите индекс 0 <= i < nums1.length и сделайте nums1[i] = 0.

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

Пример 1:

Входные данные: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Выход: 3
Объяснение:
Для 1-й секунды мы применяем операцию на i = 0. Следовательно, nums1 = [0,2+2,3+3] = [0,4,6].
Для 2-й секунды мы применяем операцию на i = 1. Следовательно, nums1 = [0+1,0,6+3] = [1,0,9].
На 3-ю секунду мы применяем операцию на i = 2. Следовательно, nums1 = [1+1,0+2,0] = [2,2,0].
Теперь сумма чисел1 = 4. Можно показать, что эти операции являются оптимальными, поэтому возвращаем 3.

Пример 2:

Входные данные: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Выход: -1
Пояснение: Можно показать, что сумма nums1 всегда будет больше x, независимо от того, какие операции выполняются.

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

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Вам дают два 0-индексированных целочисленных массива Nums1 и Nums2 равной длины. Каждую секунду, для всех индексов 0 <= i <nums1.length, значение nums1 [i] увеличивается на Nums2 [i]. После того, как это сделано, вы можете сделать следующую операцию:

Выберите индекс 0 <= i <nums1.length и сделайте nums1 [i] = 0.

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

Пример 1:

Ввод: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Вывод: 3
Объяснение:
Для 1 -й секунды мы применяем операцию на i = 0. Поэтому nums1 = [0,2+2,3+3] = [0,4,6].
На 2 -й секунду мы применяем операцию на i = 1. Поэтому nums1 = [0+1,0,6+3] = [1,0,9].
Для 3 -й секунды мы применяем операцию на i = 2. Поэтому nums1 = [1+1,0+2,0] = [2,2,0].
Теперь сумма nums1 = 4. Можно показать, что эти операции являются оптимальными, поэтому мы возвращаем 3.

Пример 2:

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

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

1 <= nums1.length <= 10^3
1 <= nums1 [i] <= 10^3
0 <= nums2 [i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6


Вам дан двумерный целочисленный массив координат и целое число k, где координаты[i] = [x_i, y_i] — координаты i^th точки в двумерной плоскости.
Мы определяем расстояние между двумя точками (x_1, y_1) и (x_2, y_2) как (x1 XOR x2) + (y1 XOR y2), где XOR — это побитовая операция XOR.
Верните количество пар (i, j), таких что i < j, а расстояние между точками i и j равно k.

Пример 1:

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

Пример 2:

Вход: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Выход: 10
Пояснение: Любые две выбранные пары будут иметь расстояние 0. Существует 10 способов выбрать две пары.

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

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Дан двумерный целочисленный массив coordinates и целое число k, где coordinates[i] = [x_i, y_i] — координаты i-й точки на двумерной плоскости.
Мы определяем расстояние между двумя точками (x_1, y_1) и (x_2, y_2) как (x1 XOR x2) + (y1 XOR y2), где XOR — побитовая операция "исключающее ИЛИ".
Верните количество пар (i, j) таких, что i < j и расстояние между точками i и j равно k.

Пример 1:

Input: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Output: 2
Explanation: Мы можем выбрать следующие пары:
- (0,1): Потому что (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Потому что (1 XOR 5) + (3 XOR 2) = 5.

Пример 2:

Input: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Output: 10
Explanation: Любые две выбранные пары будут иметь расстояние 0. Есть 10 способов выбрать две пары.

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

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


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

Пример 1:

Ввод: nums = [2,6,7,3,1,7], m = 3, k = 4
Вывод: 18
Объяснение: Есть 3 почти уникальных подмассива размера k = 4. Эти подмассивы: [2, 6, 7, 3], [6, 7, 3, 1] и [7, 3, 1, 7]. Среди этих подмассивов максимальная сумма у [2, 6, 7, 3], которая равна 18.

Пример 2:

Ввод: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Вывод: 23
Объяснение: Есть 5 почти уникальных подмассивов размера k. Эти подмассивы: [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] и [4, 5, 4]. Среди этих подмассивов максимальная сумма у [5, 9, 9], которая равна 23.

Пример 3:

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

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

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

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

Пример 1:

Ввод: nums = [2,6,7,3,1,7], m = 3, k = 4
Вывод: 18
Пояснение: существует 3 почти уникальных подмассива размера k = 4. Этими подмассивами являются [2, 6, 7, 3], [6, 7, 3, 1], и [7, 3, 1, 7]. Среди этих подмассивов максимальной суммой является [2, 6, 7, 3] сумма которого равна 18.

Пример 2:

Ввод: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Вывод: 23
Пояснение: Имеется 5 почти уникальных подмассивов размера k. Этими подмассивами являются [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], и [4, 5, 4]. Среди этих подмассивов максимальной суммой является [5, 9, 9] сумма которого равна 23.

Пример 3:

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

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

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

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

Пример 1:

Ввод: nums = [2,6,7,3,1,7], m = 3, k = 4
Вывод: 18
Объяснение: Есть 3 почти уникальных подмассива размера k = 4. Эти подмассивы [2, 6, 7, 3], [6, 7, 3, 1], и [7, 3, 1, 7]. Среди этих подмассивов максимальная сумма у [2, 6, 7, 3], которая равна 18.

Пример 2:

Ввод: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Вывод: 23
Объяснение: Есть 5 почти уникальных подмассивов размера k. Эти подмассивы: [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] и [4, 5, 4]. Среди этих подмассивов максимальная сумма у [5, 9, 9], которая равна 23.

Пример 3:

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

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

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9


Изначально у вас на банковском счёте 100 долларов.
Вам дано целое число purchaseAmount, представляющее сумму в долларах, которую вы потратите на покупку.
В магазине, где вы собираетесь сделать покупку, сумма округляется до ближайшего кратного 10. Другими словами, вы платите неотрицательную сумму roundedAmount, такую, что roundedAmount кратно 10 и abs(roundedAmount - purchaseAmount) минимизировано.
Если существует более одного ближайшего кратного 10, выбирается большее из них.
Верните целое число, обозначающее ваш остаток на счёте после совершения покупки на сумму purchaseAmount долларов в магазине.
Примечание: 0 считается кратным 10 в этой задаче.

Пример 1:

Ввод: purchaseAmount = 9
Вывод: 90
Объяснение: В этом примере ближайшее кратное 10 к 9 — это 10. Соответственно, ваш остаток на счёте становится 100 - 10 = 90.

Пример 2:

Ввод: purchaseAmount = 15
Вывод: 80
Объяснение: В этом примере имеются два ближайших кратных 10 к 15: 10 и 20. Поэтому выбирается большее кратное, 20.
Соответственно, ваш остаток на счёте становится 100 - 20 = 80.

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

0 <= purchaseAmount <= 100

Изначально у вас есть баланс банковского счета в размере 100 долларов.
Вам дается целое число purchaseAmount, представляющее сумму, которую вы потратите на покупку в долларах.
В магазине, где вы будете совершать покупку, сумма покупки округляется до ближайшего кратного 10. Другими словами, вы платите неотрицательную сумму, roundedAmount, такую, что roundedAmount кратна 10, а abs(roundedAmount - purchaseAmount) минимизирована.
Если существует более одного ближайшего кратного 10, выбирается наибольшее кратное.
Выведите целое число, обозначающее баланс вашего счета после совершения покупки в магазине в размере purchaseAmount в долларах.
Примечание: В этой задаче 0 считается кратным 10.

Пример 1:

Input: purchaseAmount = 9
Output: 90
Объяснение: В этом примере ближайшим кратным от 10 до 9 является 10. Следовательно, баланс вашего счета становится 100 - 10 = 90.

Пример 2:

Input: purchaseAmount = 15
Output: 80
Объяснение: В этом примере есть два ближайших кратных от 10 до 15: 10 и 20. Таким образом, выбирается большее число, 20.
Следовательно баланс вашего счета становится 100 - 20 = 80.

Constraints:

0 <= purchaseAmount <= 100

Сначала у вас на банковском счете остаток в 100 долларов.
Вам дается целое покупная сумма, соответствующая сумме, которую вы потратите на покупку в долларах.
В магазине, где вы сделаете покупку, сумма покупки округляется до ближайшего кратного 10. Другими словами, вы платите неотрицательную сумму, округленную таким образом, чтобы округленная сумма была кратной 10 и абсолютное значение разности между округленной суммой и суммой покупки минимизировано.
При наличии более одного ближайшего множественного числа из 10 выбирается наибольшее кратное число.
Возвращайте целое число, обозначающее баланс вашего счета, после покупки на сумму purchaseAmount долларов.
Примечание: 0 считается кратным 10 в этой проблеме.

Пример 1:

Входные данные: purchaseAmount = 9
Выход: 90
Пояснение: в этом примере ближайшая кратная от 10 до 9 равна 10. Таким образом, остаток на вашем счете становится 100-10 = 90.

Пример 2:

Входные purchaseAmount = 15
Выход: 80
Объяснение: в этом примере есть два ближайших кратных числа от 10 до 15: 10 и 20. Итак, выбирается большее число, 20.
Таким образом, баланс вашего счета становится 100-20 = 80.

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

0 <= сумма покупки <= 100


Дан массив строк `words` и строка `s`, определите, является ли `s` акронимом `words`.
Строка `s` считается акронимом `words`, если она может быть образована путём объединения первой буквы каждой строки в `words` в указанном порядке. Например, "ab" может быть образована из ["apple", "banana"], но не может быть образована из ["bear", "aardvark"].
Верните `true`, если `s` является акронимом `words`, и `false` в противном случае.

Пример 1:

Входные данные: words = ["alice","bob","charlie"], s = "abc"
Выходные данные: true
Объяснение: Первые буквы в словах "alice", "bob" и "charlie" — 'a', 'b' и 'c' соответственно. Следовательно, s = "abc" является акронимом.

Пример 2:

Входные данные: words = ["an","apple"], s = "a"
Выходные данные: false
Объяснение: Первые буквы в словах "an" и "apple" — 'a' и 'a' соответственно.
Акроним, образованный путём объединения этих букв, — "aa".
Следовательно, s = "a" не является акронимом.

Пример 3:

Входные данные: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Выходные данные: true
Объяснение: Объединяя первые буквы слов в массиве, мы получаем строку "ngguoy".
Следовательно, s = "ngguoy" является акронимом.

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

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] и s состоят из строчных английских букв.

Дан массив строк words и строка s, определите, является ли s аббревиатурой слов.
Строка s считается аббревиатурой слов, если ее можно образовать путем конкатенации первых символов каждой строки в words по порядку. Например, «ab» можно образовать из [«apple», «banana»], но нельзя образовать из [«bear», «aardvark»].
Возвращает true, если s является аббревиатурой слов, и false в противном случае.

Пример 1:

Входные данные: words = ["alice","bob","charlie"], s = "abc"
Выходные данные: true
Объяснение: первые символы в словах «alice», «bob» и «charlie» — это «a», «b» и «c» соответственно. Следовательно, s = «abc» является аббревиатурой.

Пример 2:

Вход: words = ["an","apple"], s = "a"
Выход: false
Пояснение: первые символы в словах "an" и "apple" — это 'a' и 'a' соответственно.
Акроним, образованный путем конкатенации этих символов — "aa".
Следовательно, s = "a" — это не акроним.

Пример 3:

Вход: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Выход: true
Пояснение: путем конкатенации первых символов слов в массиве мы получаем строку "ngguoy".
Следовательно, s = "ngguoy" — это акроним.

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

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] и s состоят из строчных английских букв.

Учитывая массив строк слов и строку s, определите, является ли s аббревиатурой слов.
Строка s считается аббревиатурой слов, если её можно образовать путём объединения первого символа каждой строки в словах по порядку. Например, "ab" может быть образовано от ["apple", "banana"], но не может быть образовано от ["bear", "aardvark"].
Возвращайте true, если s является аббревиатурой слова, и false в противном случае.

Пример 1:

Ввод: words = ["alice","bob","charlie"], s = "abc"
Вывод: true
Пояснение: Первые символы в словах "alice", "bob", и "charlie" это 'a', 'b', и 'c', соответственно. Следовательно, s = "abc" это аббревиатура.

Пример 2:

Ввод: words = ["an","apple"], s = "a"
Вывод: false
Пояснение: Первые символы в словах "an" и "apple" это 'a' и 'a', соответственно.
Аббревиатура, образованная путём объединения этих символов, "aa".
Следовательно, s = "a" не является аббревиатурой.

Пример 3:

Ввод: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Вывод: true
Пояснение: Объединив первый символ слов в массиве, мы получим строку "ngguoy".
Следовательно, s = "ngguoy" это аббревиатура.

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

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] и s состоят из строчных Английских букв.


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

Пример 1:

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

Пример 2:

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

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

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

Вам дано целое число n, обозначающее количество домов на числовой прямой, пронумерованное от 0 до n – 1.
Кроме того, вам предоставляется 2D целочисленный массив предложений, где offers[i] = [start_i, end_i, gold_i], указывающие, что i^-й покупатель хочет купить все дома от start_i до end_i за количество gold_i золота.
Ваша цель как продавца это максимизировать свои доходы за счёт стратегического выбора и продажи домов покупателям.
Верните максимальное количество золота, которое вы можете заработать.
Обратите внимание, что разные покупатели не могут купить один и тот же дом, и некоторые дома могут остаться непроданными.

Пример 1:

Ввод: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Вывод: 3
Пояснение: Есть 5 домов, пронумерованных от 0 до 4, и есть 3 предложения о покупке.
Мы продаем дома в диапазоне от [0,0] to 1^го покупателя за 1 золото и дома в диапазоне [1,3] to 3^го покупателя за 2 золота.
Можно доказать, что 3 это максимальное количество золота, которое мы можем получить.

Пример 2:

Ввод: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Вывод: 10
Пояснение: Есть 5 домов, пронумерованных от 0 до 4, и есть 3 предложения о покупке.
Мы продаем дома в диапазоне [0,2] to 2^-му покупателю за 10 золотых.
Можно доказать, что 10 это максимальное количество золота, которое мы можем получить.

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

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3