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

Выберите индекс i в диапазоне [0, words.length - 1].
Допишите words[i] к s.
Стоимость операции равна costs[i].

Верните минимальную стоимость, чтобы сделать s равной target. Если это невозможно, верните -1.

Пример 1:

Ввод: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Вывод: 7
Объяснение:
Минимальная стоимость может быть достигнута, выполняя следующие операции:

Выберите индекс 1 и добавьте "abc" к s с затратами 1, получается s = "abc".
Выберите индекс 2 и добавьте "d" к s с затратами 1, получается s = "abcd".
Выберите индекс 4 и добавьте "ef" к s с затратами 5, получается s = "abcdef".

Пример 2:

Ввод: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Вывод: -1
Объяснение:
Невозможно сделать s равным target, поэтому мы возвращаем -1.

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

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Общая сумма длины words[i] не превышает 5 * 10^4.
target и words[i] состоят только из строчных английских букв.
1 <= costs[i] <= 10^4

У вас есть строка target, массив строк words и массив целых чисел costs, причем оба массива имеют одинаковую длину.

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

Выберите индекс i в диапазоне [0, words.length - 1].
Допишите words[i] к s.
Стоимость операции равна costs[i].

Верните минимальную стоимость, чтобы сделать s равной target. Если это невозможно, верните -1.

Пример 1:

Input: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Output: 7
Объяснение:
Минимальная стоимость может быть достигнута, выполняя следующие операции:

Выберите индекс 1 и добавьте "abc" к s с затратами 1, получается s = "abc".
Выберите индекс 2 и добавьте "d" к s с затратами 1, получается s = "abcd".
Выберите индекс 4 и добавьте "ef" к s с затратами 5, получается s = "abcdef".

Пример 2:

Input: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Output: -1
Объяснение:
Невозможно сделать s равным target, поэтому мы возвращаем -1.

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

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Общая сумма длины words[i] не превышает 5 * 10^4.
target и words[i] состоят только из строчных английских букв.
1 <= costs[i] <= 10^4

Вам дана строка target, массив строк words и целочисленный массив costs, оба массива одинаковой длины.
Представьте пустую строку s.
Вы можете выполнить следующую операцию любое количество раз (включая ноль):

Выберите индекс i в диапазоне [0, words.length - 1].
Добавьте words[i] к s.
Стоимость операции — costs[i].

Верните минимальную стоимость, чтобы сделать s равным target. Если это невозможно, верните -1.

Пример 1:

Входные данные: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Выходные данные: 7
Пояснение:
Минимальной стоимости можно достичь, выполнив следующие операции:

Выберите индекс 1 и добавьте "abc" к s со стоимостью 1, в результате чего получится s = "abc".
Выберите индекс 2 и добавьте "d" к s по стоимости 1, в результате чего получится s = "abcd".

Выберите индекс 4 и добавьте "ef" к s по стоимости 5, в результате чего получится s = "abcdef".

Пример 2:

Входные данные: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Выходные данные: -1
Пояснение:
Невозможно сделать s равным target, поэтому мы возвращаем -1.

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

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Общая сумма words[i].length меньше или равна 5 * 10^4.
target и words[i] состоят только из строчных английских букв.
1 <= зcosts[i] <= 10^4


Дана строка s, содержащая только цифры. Вернуть лексикографически наименьшую строку, которую можно получить, поменяв местами соседние цифры с одинаковой четностью не более одного раза.
Цифры имеют одинаковую четность, если обе нечётные или обе чётные. Например, 5 и 9, а также 2 и 4 имеют одинаковую четность, а 6 и 9 — нет.

Пример 1:

Ввод: s = "45320"
Вывод: "43520"
Объяснение:
s[1] == '5' и s[2] == '3' имеют одинаковую четность, и их обмен приводит к лексикографически наименьшей строке.

Пример 2:

Ввод: s = "001"
Вывод: "001"
Объяснение:
Нет необходимости выполнять обмен, так как s уже является лексикографически наименьшим.

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

2 <= s.length <= 100
s состоит только из цифр.

Учитывая строку s, содержащую только цифры, верните лексикографически наименьшую строку, которую можно получить после замены соседних цифр в s с одинаковой чётностью не более одного раза.
Цифры имеют одинаковую чётность, если обе они нечётные или обе чётные. Например, 5 и 9, а также 2 и 4 имеют одинаковую четность, а 6 и 9 нет.

Пример 1:

Ввод: s = "45320"
Вывод: "43520"
Объяснение:
s[1] == '5' и s[2] == '3' имеют одинаковую четность, и их замена приводит к получению лексикографически наименьшей строки.

Пример 2:

Ввод: s = "001"
Вывод: "001"
Объяснение:
Нет необходимости выполнять замену, поскольку s уже является наименьшим лексикографически.

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

2 <= s.length <= 100
s состоит только из цифр.

Дана строка s, содержащая только цифры, вернуть лексикографически наименьшую строку, которую можно получить, поменяв местами соседние цифры в s с одинаковой четностью не более одного раза.
Цифры имеют одинаковую четность, если обе нечетные или обе четные. Например, 5 и 9, а также 2 и 4 имеют одинаковую четность, а 6 и 9 — нет.

Пример 1:

Вход: s = "45320"
Выход: "43520"
Пояснение:
s[1] == '5' и s[2] == '3' имеют одинаковую четность, и их замена приводит к лексикографически наименьшей строке.

Пример 2:

Вход: s = "001"
Выход: "001"
Пояснение:
Нет необходимости выполнять обмен, поскольку s уже является лексикографически наименьшей.

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

2 <= s.length <= 100
s состоит только из цифр.


Дан торт размером m x n, который необходимо разрезать на кусочки размером 1 x 1.
Вам даны целые числа m, n и два массива:

horizontalCut размером m - 1, где horizontalCut[i] представляет стоимость разреза по горизонтальной линии i.
verticalCut размером n - 1, где verticalCut[j] представляет стоимость разреза по вертикальной линии j.

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

Разрезать по горизонтальной линии i со стоимостью horizontalCut[i].
Разрезать по вертикальной линии j со стоимостью verticalCut[j].

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

Пример 1:

Ввод: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Вывод: 13
Объяснение:

Выполните разрез по вертикальной линии 0 со стоимостью 5, текущая общая стоимость — 5.
Выполните разрез по горизонтальной линии 0 на подгриде 3 x 1 со стоимостью 1.
Выполните разрез по горизонтальной линии 0 на подгриде 3 x 1 со стоимостью 1.
Выполните разрез по горизонтальной линии 1 на подгриде 2 x 1 со стоимостью 3.
Выполните разрез по горизонтальной линии 1 на подгриде 2 x 1 со стоимостью 3.

Общая стоимость: 5 + 1 + 1 + 3 + 3 = 13.

Пример 2:

Ввод: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Вывод: 15
Объяснение:

Выполните разрез по горизонтальной линии 0 со стоимостью 7.
Выполните разрез по вертикальной линии 0 на подгриде 1 x 2 со стоимостью 4.
Выполните разрез по вертикальной линии 0 на подгриде 1 x 2 со стоимостью 4.

Общая стоимость: 7 + 4 + 4 = 15.

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

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

Есть торт m x n, который нужно разрезать на куски 1 x 1.
Вам даны целые числа m, n и два массива:

horizontalCut размером m - 1, где horizontalCut[i] представляет стоимость разреза по горизонтальной линии i.
verticalCut размером n - 1, где verticalCut[j] представляет стоимость разреза по вертикальной линии j.

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

Разрезать по горизонтальной линии i со стоимостью horizontalCut[i].

Разрезать по вертикальной линии j со стоимостью verticalCut[j].

После разреза кусок торта делится на два отдельных куска.

Стоимость разреза зависит только от начальной стоимости линии и не меняется.

Вернуть минимальную общую стоимость разреза всего торта на куски 1 x 1.

Пример 1:

Входные данные: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Выходные данные: 13
Пояснение:

Выполнить разрез по вертикальной линии 0 со стоимостью 5, текущая общая стоимость составляет 5.
Выполнить разрез по горизонтальной линии 0 на подсетке 3 x 1 со стоимостью 1.
Выполнить разрез по горизонтальной линии 0 на подсетке 3 x 1 со стоимостью 1.
Выполнить разрез по горизонтальной линии 1 на подсетке 2 x 1 со стоимостью 3.
Выполнить разрез по горизонтальной линии 1 на подсетке 2 x 1 со стоимостью 3.

Общая стоимость составляет 5 + 1 + 1 + 3 + 3 = 13.

Пример 2:

Входные данные: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Выход: 15
Объяснение:

Выполнить разрез по горизонтальной линии 0 со стоимостью 7.
Выполнить разрез по вертикальной линии 0 на подсетке 1 x 2 со стоимостью 4.
Выполнить разрез по вертикальной линии 0 на подсетке 1 x 2 со стоимостью 4.

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

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

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3


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

Пример 1:

Вход: n = 13, k = 4
Выход: 2
Пояснение:
Изначально двоичные представления n и k — n = (1101)_2 и k = (0100)_2.
Мы можем изменить первый и четвертый биты n. Полученное целое число — n = (0100)_2 = k.

Пример 2:

Вход: n = 21, k = 21
Выход: 0
Пояснение:
n и k уже равны, поэтому никаких изменений не требуется.

Пример 3:

Вход: n = 14, k = 13
Выход: -1
Пояснение:
Невозможно сделать n равным k.

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

1 <= n, k <= 10^6

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

Пример 1:

Ввод: n = 13, k = 4
Вывод: 2
Пояснение:
Изначально двоичные представления n и k это n = (1101)_2 и k = (0100)_2.
Мы можем изменить первый и четвертый биты n. Полученное число n = (0100)_2 = k.

Пример 2:

Ввод: n = 21, k = 21
Вывод: 0
Пояснение:
n и k уже равны, поэтому изменения не требуются.

Пример 3:

Ввод: n = 14, k = 13
Вывод: -1
Пояснение:
Сделать n равным k невозможно.

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

1 <= n, k <= 10^6


Алиса и Боб играют в игру на строке.
Вам даётся строка s, и Алиса с Бобом поочерёдно играют в следующую игру, где Алиса ходит первой:

На ходу Алисы она должна удалить любую непустую подстроку из строки s, которая содержит нечётное количество гласных.
На ходу Боба он должен удалить любую непустую подстроку из строки s, которая содержит чётное количество гласных.
Первый игрок, который не может сделать ход на своём ходу, проигрывает игру. Мы предполагаем, что и Алиса, и Боб играют оптимально.
Верните true, если Алиса выиграет игру, и false в противном случае.

Английские гласные: a, e, i, o, u.

Пример 1:

Ввод: s = "leetcoder"

Вывод: true
Объяснение:
Алиса может выиграть игру следующим образом:

Алиса играет первой, она может удалить подчёркнутую подстроку в s = "leetcoder", которая содержит 3 гласных. Полученная строка: s = "der".
Боб играет вторым, он может удалить подчёркнутую подстроку в s = "der", которая содержит 0 гласных. Полученная строка: s = "er".
Алиса играет третьей, она может удалить всю строку s = "er", которая содержит 1 гласный.
Боб играет четвёртым, поскольку строка пуста, у Боба нет действительного хода. Таким образом, Алиса выигрывает игру.

Пример 2:
Ввод: s = "bbcd"
Вывод: false
Объяснение:
На первом ходу у Алисы нет действительного хода, поэтому она проигрывает игру.

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

Алиса и Боб играют в игру на строке.
Вам дана строка s, Алиса и Боб по очереди играют в следующую игру, в которой Алиса начинает первой:

В свой ход Алиса должна удалить из s любую непустую подстроку, содержащую нечётное количество гласных.
В свой ход Боб должен удалить из s любую непустую подстроку, содержащую чётное количество гласных.

Первый игрок, который не может сделать ход в свой ход, проигрывает. Мы предполагаем, что и Алиса, и Боб играют оптимально.
Верните true, если Алиса выигрывает игру, и false в противном случае.
Английские гласные: a, e, i, o, и u.

Пример 1:

Ввод: s = "leetcoder"
Вывод: true
Объяснение:
Алиса может выиграть игру следующим образом:

Алиса играет первой, она может удалить подчёркнутую подстроку в s = "leetcoder", содержащую 3 гласные. Результирующая строка: s = "der".
Боб играет вторым, он может удалить подчёркнутую подстроку в s = "der", содержащую 0 гласных. Результирующая строка: s = "er".
Алиса играет третьей, она может удалить всю строку s = "er", содержащую 1 гласную.
Боб играет четвёртым, поскольку строка пуста, для Боба нет допустимого хода. Итак, Алиса выигрывает игру.

Пример 2:

Ввод: s = "bbcd"
Вывод: false
Объяснение:
В первый ход Алисы нет допустимой игры, поэтому Алиса проигрывает игру.

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

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

Алиса и Боб играют в игру на строке.
Вам дана строка s, Алиса и Боб по очереди играют в следующую игру, где Алиса начинает первой:

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

Первый игрок, который не может сделать ход в свой ход, проигрывает игру. Мы предполагаем, что и Алиса, и Боб играют оптимально.
Верните true, если Алиса выигрывает игру, и false в противном случае.
Английские гласные: a, e, i, o и u.

Пример 1:

Вход: s = "leetcoder"
Выход: true
Объяснение:
Алиса может выиграть игру следующим образом:

Алиса ходит первой, она может удалить подчеркнутую подстроку в s = "leetcoder", которая содержит 3 гласные. Результирующая строка - s = "der".
Боб ходит вторым, он может удалить подчеркнутую подстроку в s = "der", которая содержит 0 гласных. Результирующая строка - s = "er".
Алиса ходит третьей, она может удалить всю строку s = "er", которая содержит 1 гласную.
Боб ходит четвертым, так как строка пуста, для Боба нет допустимого хода. Поэтому Алиса выигрывает игру.

Пример 2:

Вход: s = "bbcd"
Выход: false
Объяснение:
В ее первом ходу для Алисы нет допустимого хода, поэтому Алиса проигрывает игру.

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

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


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

Выберите любой индекс i в строке, где i + 1 < s.length, такой что s[i] == '1' и s[i + 1] == '0'.
Переместите символ s[i] вправо до конца строки или до другого '1'. Например, для s = "010010", если выбрать i = 1, результирующая строка станет s = "000110".

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

Пример 1:

Ввод: s = "1001101"
Вывод: 4
Объяснение:
Мы можем выполнить следующие операции:

Выберите индекс i = 0. Результирующая строка будет s = "0011101".
Выберите индекс i = 4. Результирующая строка будет s = "0011011".
Выберите индекс i = 3. Результирующая строка будет s = "0010111".
Выберите индекс i = 2. Результирующая строка будет s = "0001111".

Пример 2:

Ввод: s = "00111"
Вывод: 0

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

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

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

Выберите любой индекс i в строке, где i + 1 < s.length, такой что s[i] == '1' и s[i + 1] == '0'.
Переместите символ s[i] вправо до конца строки или до другого '1'. Например, для s = "010010", если выбрать i = 1, результирующая строка станет s = "000110".

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

Пример 1:

Ввод: s = "1001101"
Вывод: 4
Объяснение:
Мы можем выполнить следующие операции:

Выберите индекс i = 0. Результирующая строка будет s = "0011101".
Выберите индекс i = 4. Результирующая строка будет s = "0011011".
Выберите индекс i = 3. Результирующая строка будет s = "0010111".
Выберите индекс i = 2. Результирующая строка будет s = "0001111".

Пример 2:

Ввод: s = "00111"
Вывод: 0

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

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

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

Выберите любой индекс Выберите любой индекс I из строки, где i + 1 <s.length так что s [i] == '1' и s [i + 1] == '0'.
Переместите символ s [i] вправо, пока он не достигнет конца строки или другого «1». Например, для s = "010010", если мы выберите I = 1, полученная строка будет S = "000110".

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

Пример 1:

Ввод: s = "1001101"
Объяснение:
Мы можем выполнить следующие операции:

Выберите индекс i = 0. Результирующая строка: s = "0011101".
Выберите индекс i = 4. Результирующая строка: s = "0011011".
Выберите индекс i = 3. Результирующая строка: s = "0010111".
Выберите индекс i = 2. Результирующая строка: s = "0001111".

Пример 2:

Ввод: s= "00111"
Вывод: 0

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

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


Даны два массива положительных целых чисел nums и target одинаковой длины.
За одну операцию вы можете выбрать любой подмассив nums и увеличить или уменьшить каждый элемент в этом подмассиве на 1.
Верните минимальное количество операций, необходимых для того, чтобы сделать nums равным массиву target.

Пример 1:

Вход: nums = [3,5,1,2], target = [4,6,2,4]
Выход: 2
Объяснение:
Мы выполним следующие операции, чтобы сделать nums равным target:
- Увеличим nums[0..3] на 1, nums = [4,6,2,3].
- Увеличим nums[3..3] на 1, nums = [4,6,2,4].

Пример 2:

Вход: nums = [1,3,2], target = [2,1,4]
Выход: 5
Объяснение:
Мы выполним следующие операции, чтобы сделать nums равным target:
- Увеличим nums[0..0] на 1, nums = [2,3,2].
- Уменьшим nums[1..1] на 1, nums = [2,2,2].
- Уменьшим nums[1..1] на 1, nums = [2,1,2].
- Увеличим nums[2..2] на 1, nums = [2,1,3].
- Увеличим nums[2..2] на 1, nums = [2,1,4].

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

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

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

Пример 1:

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

Пример 2:

Вход: nums = [1,3,2], target = [2,1,4]
Выход: 5
Пояснение:
Мы выполним следующие операции, чтобы сделать nums равным target:
- Увеличим nums[0..0] на 1, nums = [2,3,2].
- Уменьшим nums[1..1] на 1, nums = [2,2,2].
- Уменьшим nums[1..1] на 1, nums = [2,1,2].
- Увеличим nums[2..2] на 1, nums = [2,1,3].
- Увеличим nums[2..2] на 1, nums = [2,1,4].

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

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

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

Пример 1:

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

Пример 2:

Вход: nums = [1,3,2], target = [2,1,4]
Выход: 5
Пояснение:
Мы выполним следующие операции, чтобы сделать nums равным target:
- Увеличим nums[0..0] на 1, nums = [2,3,2].
- Уменьшим nums[1..1] на 1, nums = [2,2,2].
- Уменьшим nums[1..1] на 1, nums = [2,1,2].
- Увеличим nums[2..2] на 1, nums = [2,1,3].
- Увеличим nums[2..2] на 1, nums = [2,1,4].

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

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


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

Пример 1:

Вход: nums = [1,2,3,4,10]
Выход: false
Объяснение:
Алиса не может выиграть, выбрав однозначные или двузначные числа.

Пример 2:

Вход: nums = [1,2,3,4,5,14]
Выход: true
Пояснение:
Алиса может выиграть, выбрав однозначные числа, сумма которых равна 15.

Пример 3:

Вход: nums = [5,5,5,25]
Выход: true
Пояснение:
Алиса может выиграть, выбрав двузначные числа, сумма которых равна 25.

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

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

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

Пример 1:

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

Пример 2:

Ввод: nums = [1,2,3,4,5,14]
Вывод: true
Объяснение:
Алиса может выиграть, выбрав однозначные числа, сумма которых равна 15.

Пример 3:

Ввод: nums = [5,5,5,25]
Вывод: true
Объяснение:
Алиса может выиграть, выбрав двузначные числа, сумма которых равна 25.

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

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

Вам дан массив положительных целых чисел.
Алиса и Боб играют в игру . В игре Алиса может выбрать либо все однозначные числа, либо все двузначные числа из nums, а остальные числа передаются Бобу. Алиса выигрывает, если сумма ее чисел строго больше, чем сумма чисел Боба.
Вернуть True, если Алиса сможет выиграть эту игру, в противном случае вернуть False.

Пример 1:

Вход: nums = [1,2,3,4,10]
Вывод: false
Объяснение:
Алиса не может выиграть, выбрав ни однозначные, ни двузначные числа.

Пример 2:

Вход: nums = [1,2,3,4,5,14]
Вывод: true
Объяснение:
Алиса может выиграть, выбрав однозначные числа, которые имеют сумму, равную 15.

Пример 3:

Вход: nums = [5,5,5,25]
Вывод:true
Объяснение:
Алиса может выиграть, выбрав двузначные числа, которые имеют сумму, равную 25.

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

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


Заданы 2 положительных целых числа l и r. Для любого числа x все положительные делители x, кроме x, называются собственными делителями x. Число называется особым, если у него ровно 2 собственных делителя. Например:

Число 4 является особым, потому что у него есть собственные делители 1 и 2.
Число 6 не является особым, потому что у него есть собственные делители 1, 2 и 3.

Вернуть количество чисел в диапазоне [l, r], которые не являются особыми.

Пример 1:

Ввод: l = 5, r = 7
Вывод: 3
Пояснение:
В диапазоне [5, 7] нет особых чисел.

Пример 2:

Ввод: l = 4, r = 16
Вывод: 11
Пояснение:
Особые числа в диапазоне [4, 16] это 4 и 9.

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

1 <= l <= r <= 10^9

Вам даны 2 положительных целых числа l и r. Для любого числа x все положительные делители x, кроме x, называются собственными делителями x.
Число называется специальным, если у него ровно 2 собственных делителя. Например:

Число 4 является специальным, потому что у него есть собственные делители 1 и 2.
Число 6 не является специальным, потому что у него есть собственные делители 1, 2 и 3.

Верните количество чисел в диапазоне [l, r], которые не являются специальными.

Пример 1:

Вход: l = 5, r = 7
Выход: 3
Объяснение:
В диапазоне [5, 7] нет специальных чисел.

Пример 2:

Вход: l = 4, r = 16
Выход: 11
Пояснение:
Специальные числа в диапазоне [4, 16] — 4 и 9.

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

1 <= l <= r <= 10^9

Даны 2 положительных целых числа l и r. Для любого числа x все положительные делители x, кроме x, называются собственными делителями x.
Число называется специальным, если оно имеет ровно 2 правильных делителя. Например:

Число 4 является особенным, потому что оно имеет правильные делители 1 и 2.
Число 6 не является особенным, потому что у него есть правильные делители 1, 2 и 3.

Выведите количество чисел в диапазоне [l, r], которые не являются специальными.

Пример 1:

Input: l = 5, r = 7
Output: 3
Explanation:
There are no special numbers in the range [5, 7].

Пример 2:

Input: l = 4, r = 16
Output: 11
Explanation:
The special numbers in the range [4, 16] are 4 and 9.

Constraints:

1 <= l <= r <= 10^9


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

Пример 1:

Вход: s = "00011"
Выход: 5
Объяснение:
Подстроки с доминирующими единицами показаны в таблице ниже.

i
j
s[i..j]
Количество нулей
Количество единиц

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Пример 2:

Вход: s = "101101"
Выход: 16
Пояснение:
Подстроки с недоминантными единицами показаны в таблице ниже.
Поскольку всего имеется 21 подстрока и 5 из них имеют недоминантные единицы, то получается, что имеется 16 подстрок с доминантными единицами.

i
j
s[i..j]
Количество нулей
Количество единиц

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

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

1 <= s.length <= 4 * 10^4
s состоит только из символов «0» и «1».

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

Пример 1:

Input: s = "00011"
Output: 5
Explanation:
The substrings with dominant ones are shown in the table below.

i
j
s[i..j]
Number of Zeros
Number of Ones

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Пример 2:

Input: s = "101101"
Output: 16
Explanation:
The substrings with non-dominant ones are shown in the table below.
Since there are 21 substrings total and 5 of them have non-dominant ones, it follows that there are 16 substrings with dominant ones.

i
j
s[i..j]
Number of Zeros
Number of Ones

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Constraints:

1 <= s.length <= 4 * 10^4
s consists only of characters '0' and '1'.

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

Пример 1:

Input: s = "00011"
Output: 5
Explanation:
The substrings with dominant ones are shown in the table below.

i
j
s[i..j]
Number of Zeros
Number of Ones

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Пример 2:

Input: s = "101101"
Output: 16
Explanation:
The substrings with non-dominant ones are shown in the table below.
Since there are 21 substrings total and 5 of them have non-dominant ones, it follows that there are 16 substrings with dominant ones.

i
j
s[i..j]
Number of Zeros
Number of Ones

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Constraints:

1 <= s.length <= 4 * 10^4
s consists only of characters '0' and '1'.


Вам даны два положительных целых числа xCorner и yCorner, и двумерный массив circles, где circles[i] = [x_i, y_i, r_i] обозначает круг с центром в точке (x_i, y_i) и радиусом r_i.
В координатной плоскости есть прямоугольник с левой нижней вершиной в начале координат и правой верхней вершиной в точке (xCorner, yCorner). Необходимо проверить, существует ли путь из левой нижней вершины в правую верхнюю, так чтобы весь путь находился внутри прямоугольника, не касался и не лежал внутри никакого круга и касался прямоугольника только в двух вершинах.
Верните true, если такой путь существует, и false в противном случае.

Пример 1:

Ввод: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Вывод: true
Объяснение:

Черная кривая показывает возможный путь между (0, 0) и (3, 4).

Пример 2:

Ввод: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Вывод: false
Объяснение:

Путь из (0, 0) в (3, 3) не существует.

Пример 3:

Ввод: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Вывод: false
Объяснение:

Путь из (0, 0) в (3, 3) не существует.

Пример 4:

Ввод: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Вывод: true
Объяснение:

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

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Вам даны два положительных целых числа xCorner и yCorner, а также 2D массив кругов, где круги[i] = [x_i, y_i, r_i] обозначают круг с центром в (x_i, y_i) и радиусом r_i.
В координатной плоскости имеется прямоугольник с левым нижним углом в начале координат и правым верхним углом в координате (xCorner, yCorner). Вам нужно проверить, существует ли путь из левого нижнего угла в правый верхний угол такой, что весь путь лежит внутри прямоугольника, не касается и не лежит внутри какого-либо круга и касается прямоугольника только в двух углах.
Выведите true, если такой путь существует, и false в противном случае.

Пример 1:

Input: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Output: true
Объяснение:

Черная кривая показывает возможный путь между (0, 0) и (3, 4).

Пример 2:

Input: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Output: false
Объяснение:

Путь от (0, 0) к (3, 3) не существует.

Пример 3:

Input: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Output: false
Объяснение:

Путь от (0, 0) к (3, 3) не существует.

Пример 4:

Input: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Output: true
Объяснение:

Constraints:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9


Дано целое число n и двумерный целочисленный массив queries.
Есть n городов, пронумерованных от 0 до n - 1. Изначально существует односторонняя дорога от города i к городу i + 1 для всех 0 <= i < n - 1.
queries[i] = [u_i, v_i] представляет добавление новой односторонней дороги от города u_i к городу v_i. После каждого запроса необходимо найти длину кратчайшего пути от города 0 до города n - 1.
Верните массив answer, где для каждого i в диапазоне [0, queries.length - 1], answer[i] — это длина кратчайшего пути от города 0 до города n - 1 после обработки первых i + 1 запросов.

Пример 1:

Входные данные: n = 5, queries = [[2,4],[0,2],[0,4]]
Выходные данные: [3,2,1]
Объяснение:

После добавления дороги от 2 до 4, длина кратчайшего пути от 0 до 4 равна 3.

После добавления дороги от 0 до 2, длина кратчайшего пути от 0 до 4 равна 2.

После добавления дороги от 0 до 4, длина кратчайшего пути от 0 до 4 равна 1.

Пример 2:

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

После добавления дороги от 0 до 3, длина кратчайшего пути от 0 до 3 равна 1.

После добавления дороги от 0 до 2, длина кратчайшего пути остается 1.

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

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Нет повторяющихся дорог среди запросов.

Вам даны запросы на целые числа n и 2D массив целых чисел.
Существует n городов, пронумерованных от 0 до n - 1. Изначально существует односторонняя дорога от города i до города i + 1 для всех 0 <= i < n - 1.
queries[i] = [u_i, v_i] представляет собой добавление новой однонаправленной дороги от города u_i к городскому v_i. После каждого запроса нужно найти длину кратчайшего пути от города 0 до города n - 1.
Выведите массив ответ, где для каждого i в диапазоне [0, queries.length - 1], answer[i] - длина кратчайшего пути от города 0 до города n - 1 после обработки первых i + 1 запросов.

Пример 1:

Input: n = 5, queries = [[2,4],[0,2],[0,4]]
Output: [3,2,1]
Explanation:

After the addition of the road from 2 to 4, the length of the shortest path from 0 to 4 is 3.

After the addition of the road from 0 to 2, the length of the shortest path from 0 to 4 is 2.

After the addition of the road from 0 to 4, the length of the shortest path from 0 to 4 is 1.

Пример 2:

Input: n = 4, queries = [[0,3],[0,2]]
Output: [1,1]
Explanation:

After the addition of the road from 0 to 3, the length of the shortest path from 0 to 3 is 1.

After the addition of the road from 0 to 2, the length of the shortest path remains 1.

Constraints:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
There are no repeated roads among the queries.

Вам задано целое число n и запросы к двумерному массиву целых чисел.
Имеется n городов, пронумерованных от 0 до n - 1. Изначально существует односторонняя дорога из города i в город i + 1 для всех 0 <= i < n - 1.
queries[i] = [u_i, v_i] представляет собой добавление новой односторонней дороги из города u_i в город v_i. После каждого запроса вам необходимо найти длину кратчайшего пути от города 0 до города n - 1.
Возвращает массив ответа, где для каждого i в диапазоне [0, queries.length - 1] ответ[i] это длина кратчайшего пути от города 0 до города n - 1 после обработки первых i + 1 запросов.

Пример 1:

Input: n = 5, queries = [[2,4],[0,2],[0,4]]
Output: [3,2,1]
Explanation:

After the addition of the road from 2 to 4, the length of the shortest path from 0 to 4 is 3.

After the addition of the road from 0 to 2, the length of the shortest path from 0 to 4 is 2.

After the addition of the road from 0 to 4, the length of the shortest path from 0 to 4 is 1.

Пример 2:

Input: n = 4, queries = [[0,3],[0,2]]
Output: [1,1]
Explanation:

After the addition of the road from 0 to 3, the length of the shortest path from 0 to 3 is 1.

After the addition of the road from 0 to 2, the length of the shortest path remains 1.

Constraints:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
There are no repeated roads among the queries.


Есть несколько красных и синих плиток, расположенных по кругу. Вам дан массив целых чисел colors и двумерный массив целых чисел queries.
Цвет плитки i представлен как colors[i]:

colors[i] == 0 означает, что плитка i красная.
colors[i] == 1 означает, что плитка i синяя.

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

Вам необходимо обработать queries двух типов:

queries[i] = [1, size_i], определить количество чередующихся групп размером size_i.
queries[i] = [2, index_i, color_i], изменить colors[index_i] на color_i.

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

Пример 1:

Входные данные: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Выходные данные: [2]
Пояснение:

Первый запрос:
Изменить цвета[1] на 0.

Второй запрос:
Количество чередующихся групп размером 4:

Пример 2:

Входные данные: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Выходные данные: [2,0]
Пояснение:

Первый запрос:
Количество чередующихся групп размером 3:

Второй запрос: цвета не изменятся.
Третий запрос: Нет чередующейся группы с размером 5.

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

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Для всех i, которые:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Есть несколько красных и синих плиток, расположенных по кругу. Вам дан массив целых чисел colors и двумерный массив целых чисел requests.
Цвет плитки i представлен как colors[i]:

colors[i] == 0 означает, что плитка i красная.
colors[i] == 1 означает, что плитка i синяя.

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

queries[i] = [1, size_i], определить количество чередующихся групп размером size_i.
queries[i] = [2, index_i, color_i], изменить colors[index_i] на color_i.

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

Пример 1:

Ввод: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Вывод: [2]
Объяснение:

Первый запрос:
Измените colors[1] на 0.

Второй запрос:
Количество чередующихся групп размером 4:

Пример 2:

Ввод: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Вывод: [2,0]
Объяснение:

Первый запрос:
Количество чередующихся групп размером 3:

Второй запрос: цвета не изменятся.
Третий запрос: Нет чередующейся группы с размером 5.

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

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Для всех i, которые:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Некоторые красные и синие плитки расположены по кругу. Вам дается массив целых чисел colors и 2D массив целых чисел queries.
Цвет плитки i представлен colors[i]:

colors[i] == 0 означает, что плитка i красная.
colors[i] == 1 означает, что плитка i синяя.

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

queries[i] = [1, size_i], определить количество чередующихся групп размера size_i.
queries[i] = [2, index_i, color_i], изменить colors[index_i] на color_i.

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

Пример 1:

Ввод: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Вывод: [2]
Объяснение:

Первый запрос:
Измените colors[1] на 0.

Второй запрос:
Количество чередующихся групп размера 4:

Example 2:

Ввод: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Вывод: [2,0]
Объяснение:

Первый запрос:
Количество чередующихся групп размера 3:

Второй запрос: colors не изменится.
Третий запрос: Нет чередующейся группы размера 5.

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

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Для всех i что:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1


Змея находится в матрице размером n x n и может двигаться в четырех возможных направлениях. Каждая ячейка в сетке идентифицируется позицией: grid[i][j] = (i * n) + j.
Змея начинает в ячейке 0 и следует последовательности команд.
Вам дано целое число n, представляющее размер сетки, и массив строк commands, где каждая команда[i] — это "UP", "RIGHT", "DOWN" или "LEFT". Гарантируется, что змея останется в пределах сетки во время движения.
Верните позицию конечной ячейки, где змея окажется после выполнения команд.

Пример 1:

Ввод: n = 2, commands = ["RIGHT","DOWN"]
Вывод: 3
Объяснение:

0
1

2
3

0
1

2
3

0
1

2
3

Пример 2:

Ввод: n = 3, commands = ["DOWN","RIGHT","UP"]
Вывод: 1
Объяснение:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

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

2 <= n <= 10
1 <= commands.length <= 100
commands состоит только из "UP", "RIGHT", "DOWN", и "LEFT".
Входные данные сформированы так, что змея не выйдет за пределы границ.

В сетке матрицы n x n находится змея, которая может двигаться в четырех возможных направлениях. Каждая ячейка сетки идентифицируется позицией: grid[i][j] = (i * n) + j.
Змея начинает с ячейки 0 и следует последовательности команд.
Вам дано целое число n, представляющее размер сетки, и массив строковых команд, где каждая команда[i] — это «ВВЕРХ», «ВПРАВО», «ВНИЗ» и «ВЛЕВО». Гарантируется, что змея останется в пределах границ сетки на протяжении всего своего движения.
Верните позицию последней ячейки, в которой змея окажется после выполнения команд.

Пример 1:

Вход: n = 2, commands = ["RIGHT","DOWN"]
Выход: 3
Пояснение:

0
1

2
3

0
1

2
3

0
1

2
3

Пример 2:

Вход: n = 3, commands = ["DOWN","RIGHT","UP"]
Выход: 1
Пояснение:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

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

2 <= n <= 10
1 <= commands.length <= 100
команды состоят только из "UP", "RIGHT", "DOWN", и "LEFT".
Ввод генерируется таким образом, что змея не будет выходить за пределы границ.


Дан массив положительных целых чисел nums длины n.
Мы называем пару массивов неотрицательных целых чисел (arr1, arr2) монотонной, если:

Длины обоих массивов равны n.
arr1 монотонно не убывает, то есть arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 монотонно не возрастает, то есть arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] для всех 0 <= i <= n - 1.

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

Пример 1:

Ввод: nums = [2,3,2]
Вывод: 4
Объяснение:
Хорошие пары:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Пример 2:

Ввод: nums = [5,5,5,5]
Вывод: 126

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

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

Вам дан массив целых положительных чисел nums длины n.
Пара массивов неотрицательных целых чисел (arr1, arr2) называется монотонной, если:

Длина обоих массивов равна n.
arr1 монотонно не убывает, другими словами, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 монотонно не возрастает, другими словами, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] для всех 0 <= i <= n - 1.

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

Пример 1:

Ввод: nums = [2,3,2]
Вывод: 4
Объяснение:
Хорошие пары:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Пример 2:

Ввод: nums = [5,5,5,5]
Вывод: 126

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

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


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

Удалите первую цифру и ближайший нецифровой символ слева от нее.

Верните полученную строку после удаления всех цифр.

Пример 1:

Входные данные: s = "abc"
Выходные данные: "abc"
Пояснение:
В строке нет цифр.

Пример 2:

Входные данные: s = "cb34"
Выходные данные: ""
Пояснение:
Сначала мы применяем операцию к s[2], и s становится "c4".
Затем мы применяем операцию к s[1], и s становится "".

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

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

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

Удалите первую цифру и ближайший нецифровой символ слева от неё.

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

Пример 1:

Ввод: s = "abc"
Вывод: "abc"
Объяснение:
В строке нет цифр.

Пример 2:

Ввод: s = "cb34"
Вывод: ""
Объяснение:
Сначала мы применяем операцию к s[2], и s становится "c4".
Затем применяем операцию к s[1], и s становится "".

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

1 <= s.length <= 100
s состоит только из строчных английских букв и цифр.
Ввод сформирован так, что возможно удалить все цифры.

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

Удалите первую цифру и ближайший нецифровой символ слева от неё.

Верните полученную строку после удаления всех цифр.

Пример 1:

Ввод:  s = "abc"
Вывод: "abc"
Объяснение:
В строке нет цифры.

Пример 2:

Ввод: s = "cb34"
Вывод: ""
Объяснение:
Сначала мы применяем операцию к s[2], и s становится "c4".
Затем мы применяем операцию к s[1], и s становится "".

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

1 <= s.length <= 100
s состоит только из строчных Английских букв и цифр.
Ввод генерируется таким образом, что можно удалить все цифры.


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

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

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

Пример 1:

Ввод: skills = [4,2,6,3,9], k = 2
Вывод: 2
Объяснение:
Изначально очередь игроков [0,1,2,3,4]. Происходит следующее:

Игроки 0 и 1 играют игру, так как навык игрока 0 выше, чем у игрока 1, игрок 0 побеждает. Получившаяся очередь [0,2,3,4,1].
Игроки 0 и 2 играют игру, так как навык игрока 2 выше, чем у игрока 0, игрок 2 побеждает. Получившаяся очередь [2,3,4,1,0].
Игроки 2 и 3 играют игру, так как навык игрока 2 выше, чем у игрока 3, игрок 2 побеждает. Получившаяся очередь [2,4,1,0,3].

Игрок 2 выиграл k = 2 игры подряд, поэтому победителем является игрок 2.

Пример 2:

Ввод: skills = [2,5,4], k = 3
Вывод: 1
Объяснение:
Изначально очередь игроков [0,1,2]. Происходит следующее:

Игроки 0 и 1 играют игру, так как навык игрока 1 выше, чем у игрока 0, игрок 1 побеждает. Получившаяся очередь [1,2,0].
Игроки 1 и 2 играют игру, так как навык игрока 1 выше, чем у игрока 2, игрок 1 побеждает. Получившаяся очередь [1,0,2].
Игроки 1 и 0 играют игру, так как навык игрока 1 выше, чем у игрока 0, игрок 1 побеждает. Получившаяся очередь [1,2,0].

Игрок 1 выиграл k = 3 игры подряд, поэтому победителем является игрок 1.

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

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Все целые числа в skills уникальны.

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

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

Победителем соревнования становится первый игрок, который выигрывает k игр подряд.

Верните начальный индекс победившего игрока.

Пример 1:

Входные данные: skills = [4,2,6,3,9], k = 2
Выходные данные: 2
Пояснение:
Изначально очередь игроков равна [0,1,2,3,4]. Происходит следующий процесс:

Игроки 0 и 1 играют в игру, так как мастерство игрока 0 выше, чем у игрока 1, игрок 0 выигрывает. Результирующая очередь: [0,2,3,4,1].
Игроки 0 и 2 играют в игру, так как мастерство игрока 2 выше, чем у игрока 0, игрок 2 выигрывает. Результирующая очередь: [2,3,4,1,0].
Игроки 2 и 3 играют в игру, так как мастерство игрока 2 выше, чем у игрока 3, игрок 2 выигрывает. Результирующая очередь: [2,4,1,0,3].

Игрок 2 выиграл k = 2 игры подряд, поэтому победителем становится игрок 2.

Пример 2:

Вход: skills = [2,5,4], k = 3
Выход: 1
Пояснение:
Изначально очередь игроков равна [0,1,2]. Происходит следующий процесс:

Игроки 0 и 1 играют в игру, так как мастерство игрока 1 выше, чем у игрока 0, игрок 1 выигрывает. Результирующая очередь: [1,2,0].
Игроки 1 и 2 играют в игру, так как мастерство игрока 1 выше, чем у игрока 2, игрок 1 выигрывает. Результирующая очередь: [1,0,2].
Игроки 1 и 0 играют в игру, так как мастерство игрока 1 выше, чем у игрока 0, игрок 1 выигрывает. Результирующая очередь: [1,2,0].

Игрок 1 выиграл k = 3 игры подряд, поэтому победителем становится игрок 1.

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

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Все целые числа в skills уникальны.

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

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

Победитель соревнования — первый игрок, который выигрывает k игр подряд.
Верните начальный индекс победившего игрока.

Пример 1:

Вклад: skills = [4,2,6,3,9], k = 2
Вывод: 2
Объяснение:
Первоначально очередь игроков составляет [0,1,2,3,4]. Следующий процесс происходит:

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

Игрок 2 выиграл 2 игры подряд, поэтому победителем является игрок 2.

Пример 2:

Ввод:skills = [2,5,4], k = 3
Вывод: 1
Объяснение:
Первоначально очередь игроков составляет [0,1,2]. Следующий процесс происходит:

Игроки 0 и 1 играют в игру, поскольку навык игрока 1 выше, чем у игрок 0, игрок 1 выигрывает. Полученная очередь составляет [1,2,0].
Игроки 1 и 2 играют в игру, поскольку навык игрока 1 выше, чем у игрок 2, игрок 1 выигрывает. Полученная очередь составляет [1,0,2].
Игроки 1 и 0 играют в игру, поскольку навык игрока 1 выше, чем у игрок 0, игрок 1 выигрывает. Полученная очередь составляет [1,2,0].

Игрок 1 выиграл 3 игры подряд, поэтому победителем является игрок 1.

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

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <=  skills [i] <= 10^6
Все целые числа в навыках уникальны.


Дан целочисленный массив nums и неотрицательное целое число k. Последовательность целых чисел seq называется хорошей, если существует не более k индексов i в диапазоне [0, seq.length - 2] таких, что seq[i] != seq[i + 1].
Верните максимальную возможную длину хорошей подпоследовательности из nums.

Пример 1:

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

Пример 2:

Ввод: nums = [1,2,3,4,5,1], k = 0
Вывод: 2
Объяснение:
Максимальная длина подпоследовательности — [1,2,3,4,5,1].

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

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


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

Пример 1:

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

Вычесть 1 из 1.
Прибавить 1 к 2.
Вычесть 1 из 4.

Пример 2:

Ввод: nums = [3,6,9]
Вывод: 0

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

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

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

Пример 1:

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

Вычтите 1 из 1.
Добавить 1 к 2.
Вычтите 1 из 4.

Пример 2:

Ввод: nums = [3,6,9]
Вывод: 0

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

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

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

Пример 1:

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

Вычесть 1 из 1.
Прибавить 1 к 2.
Вычесть 1 из 4.

Пример 2:

Ввод: nums = [3,6,9]
Вывод: 0

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

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


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

Выберите любые 3 подряд идущих элемента из массива и инвертируйте их.

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

Пример 1:

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

Выберите элементы по индексам 0, 1 и 2. Получившийся массив nums = [1,0,0,1,0,0].
Выберите элементы по индексам 1, 2 и 3. Получившийся массив nums = [1,1,1,0,0,0].
Выберите элементы по индексам 3, 4 и 5. Получившийся массив nums = [1,1,1,1,1,1].

Пример 2:

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

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

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

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

Выберите любые 3 последовательных элемента массива и переверните их всех.

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

Пример 1:

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

Выберите элементы в индексах 0, 1 и 2. Полученный массив: nums = [1,0,0,1,0,0].
Выберите элементы в индексах 1, 2 и 3. Полученный массив: nums = [1,1,1,0,0,0].
Выберите элементы в индексах 3, 4 и 5. Полученный массив: nums = [1,1,1,1,1,1].

Пример 2:

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

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

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

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

Выберите любые 3 последовательных элемента из массива и переверните их все.

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

Пример 1:

Вход: nums = [0,1,1,1,0,0]
Выход: 3
Пояснение:
Мы можем выполнить следующие операции:

Выберите элементы с индексами 0, 1 и 2. Результирующий массив будет nums = [1,0,0,1,0,0].
Выберите элементы с индексами 1, 2 и 3. Результирующий массив будет nums = [1,1,1,0,0,0].
Выберите элементы с индексами 3, 4 и 5. Результирующий массив — nums = [1,1,1,1,1,1].

Пример 2:

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

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

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


Дано целое число n и двумерный массив requirements, где requirements[i] = [end_i, cnt_i] представляет конечный индекс и количество инверсий для каждого требования.
Пара индексов (i, j) из целочисленного массива nums называется инверсией, если:

i < j и nums[i] > nums[j]

Верните количество перестановок perm множества [0, 1, 2, ..., n - 1] так, чтобы для всех requirements[i] подмассив perm[0..end_i] имел ровно cnt_i инверсий.
Так как ответ может быть очень большим, верните его по модулю 10^9 + 7.

Пример 1:

Входные данные: n = 3, requirements = [[2,2],[0,0]]
Выходные данные: 2
Пояснение:
Две перестановки:

[2, 0, 1]

Префикс [2, 0, 1] имеет инверсии (0, 1) и (0, 2).
Префикс [2] имеет 0 инверсий.

[1, 2, 0]

Префикс [1, 2, 0] имеет инверсии (0, 2) и (1, 2).
Префикс [1] имеет 0 инверсий.

Пример 2:

Входные данные: n = 3, requirements = [[2,2],[1,1],[0,0]]
Выходные данные: 1
Пояснение:
Единственная подходящая перестановка [2, 0, 1]:

Префикс [2, 0, 1] имеет инверсии (0, 1) и (0, 2).
Префикс [2, 0] имеет инверсию (0, 1).
Префикс [2] имеет 0 инверсий.

Пример 3:

Входные данные: n = 2, requirements = [[0,0],[1,0]]
Выходные данные: 1
Пояснение:
Единственная подходящая перестановка [0, 1]:

Префикс [0] имеет 0 инверсий.
Префикс [0, 1] имеет инверсию (0, 1).

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

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Входные данные сгенерированы так, что существует хотя бы один i, для которого end_i == n - 1.
Входные данные сгенерированы так, что все end_i уникальны.

Вам дано целое число n и двумерный массив requirements, где requirements[i] = [end_i, cnt_i] представляет конечный индекс и количество инверсий каждого требования.
Пара индексов (i, j) из целочисленного массива nums называется инверсией, если:

i < j и nums[i] > nums[j]

Верните количество перестановок perm из [0, 1, 2, ..., n - 1], таких, что для всех requirement[i], perm[0..end_i] имеет ровно cnt_i инверсий.
Так как ответ может быть очень большим, верните его по модулю 10^9 + 7.

Пример 1:

Входные данные: n = 3, требования = [[2,2],[0,0]]
Выходные данные: 2
Пояснение:
Две перестановки:

[2, 0, 1]

Префикс [2, 0, 1] имеет инверсии (0, 1) и (0, 2).
Префикс [2] имеет 0 инверсий.

[1, 2, 0]

Префикс [1, 2, 0] имеет инверсии (0, 2) и (1, 2).
Префикс [1] имеет 0 инверсий.

Пример 2:

Вход: n = 3, requirements = [[2,2],[1,1],[0,0]]
Выход: 1
Пояснение:
Единственная удовлетворяющая перестановка — [2, 0, 1]:

Префикс [2, 0, 1] имеет инверсии (0, 1) и (0, 2).
Префикс [2, 0] имеет инверсию (0, 1).
Префикс [2] имеет 0 инверсий.

Пример 3:

Вход: n = 2, requirements = [[0,0],[1,0]]
Выход: 1
Пояснение:
Единственная удовлетворяющая перестановка — [0, 1]:

Префикс [0] имеет 0 инверсий.
Префикс [0, 1] имеет инверсию (0, 1).

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

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Входные данные генерируются таким образом, что существует хотя бы одно i, такое что end_i == n - 1.
Входные данные генерируются таким образом, что все end_i уникальны.


Есть круг из красных и синих плиток. Вам дан массив целых чисел colors. Цвет плитки i представлен как colors[i]:

colors[i] == 0 означает, что плитка i красная.
colors[i] == 1 означает, что плитка i синяя.

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

Пример 1:

Ввод: colors = [1,1,1]
Вывод: 0
Объяснение:

Пример 2:

Ввод: colors = [0,1,0,0,1]
Вывод: 3
Объяснение:

Чередующиеся группы:

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

3 <= colors.length <= 100
0 <= colors[i] <= 1

Существует окружность, состоящая из красных и синих плиток. Вам дано множество целых чисел цветов. Цвет плитки i представлен цветами [i]:

цвета[i] == 0 указывает, что плитка красная.
цвета[i] == 1 указывает, что плитка синяя.

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

Пример 1:

Input: colors = [1,1,1]
Output: 0
Explanation:

Пример 2:

Input: colors = [0,1,0,0,1]
Output: 3
Explanation:

Alternating groups:

Есть круг из красных и синих плиток. Вам дан массив целых чисел цветов. Цвет плитки i представлен цветами[i]:

цвета[i] == 0 означает, что плитка i красная.
цвета[i] == 1 означает, что плитка i голубая.

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

Пример 1:

Input: colors = [1,1,1]
Output: 0
Explanation:

Пример 2:

Input: colors = [0,1,0,0,1]
Output: 3
Explanation:

Alternating groups:

Constraints:

3 <= colors.length <= 100
0 <= colors[i] <= 1


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

Выберите неотмеченного врага i, такого, что currentEnergy >= enemyEnergies[i]. Выбрав этот вариант:

Вы получаете 1 очко.
Ваша энергия уменьшается на энергию врага, т.е. currentEnergy = currentEnergy - enemyEnergies[i].

Если у вас есть хотя бы 1 очко, вы можете выбрать немаркированного врага, т.е. Выбрав этот вариант:

Ваша энергия увеличивается на энергию врага, т.е. currentEnergy = currentEnergy + enemyEnergies[i].
Враг i отмечен.

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

Пример 1:

Ввод: enemyEnergies = [3,2,2], currentEnergy = 2
Вывод: 3
Объяснение:
Чтобы получить 3 балла (максимум), можно выполнить следующие действия:

Первая операция по врагу 1: очки увеличиваются на 1, а currentEnergy уменьшаются на 2. Итак, points = 1, и currentEnergy = 0.
Вторая операция над врагом 0: текущая энергия увеличивается на 3, и враг 0 отмечается. Итак, points = 1, currentEnergy = 3, и marked enemies = [0].
Первая операция над врагом 2: очки увеличиваются на 1, а currentEnergy уменьшаются на 2. Итак, points = 2, currentEnergy = 1, и marked enemies = [0].
Вторая операция по врагу 2: текущая энергия увеличивается на 2, враг 2 отмечен. Итак, points = 2, currentEnergy = 3, и marked enemies = [0, 2].
Первая операция над врагом 1: очки увеличиваются на 1, а currentEnergy уменьшаются на 2. Итак, points = 3, currentEnergy = 1, и marked enemies = [0, 2].

Пример 2:

Ввод: enemyEnergies = [2], currentEnergy = 10
Вывод: 5
Объяснение:
Выполнение первой операции 5 раз на противнике 0 даёт максимальное количество очков.

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

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

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

Выберите неотмеченного врага i, так что currentEnergy >= enemyEnergies[i]. Выбрав этот вариант:

Вы получаете 1 очко.
Ваша энергия уменьшается на энергию врага, т. е. currentEnergy = currentEnergy - enemyEnergies[i].
Если у вас есть хотя бы 1 очко, вы можете выбрать неотмеченного врага i. Выбрав этот вариант:

Ваша энергия увеличивается на энергию врага, т. е. currentEnergy = currentEnergy + enemyEnergies[i].
Враг i отмечен.

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

Пример 1:

Входные данные: enemyEnergies = [3,2,2], currentEnergy = 2
Выходные данные: 3
Пояснение:
Следующие операции можно выполнить, чтобы получить 3 очка, что является максимумом:
Первая операция над врагом 1: очки увеличиваются на 1, а currentEnergy уменьшаются на 2. Таким образом, points = 1, а currentEnergy = 0.
Вторая операция над врагом 0: currentEnergy увеличивается на 3, и враг 0 помечается. Таким образом, points = 1, currentEnergy = 3, и помеченные враги = [0].
Первая операция над врагом 2: очки увеличиваются на 1, а currentEnergy уменьшается на 2. Таким образом, points = 2, currentEnergy = 1, и помеченные враги = [0].
Вторая операция над врагом 2: currentEnergy увеличивается на 2, и враг 2 помечается. Итак, очки = 2, текущая энергия = 3, а отмеченные враги = [0, 2].
Первая операция над врагом 1: очки увеличиваются на 1, а текущая энергия уменьшается на 2. Итак, очки = 3, текущая энергия = 1, а отмеченные враги = [0, 2].

Пример 2:

Входные данные: enemyEnergies = [2], currentEnergy = 10
Выходные данные: 5
Пояснение:
Выполнение первой операции 5 раз над врагом 0 дает максимальное количество очков.

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

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

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

Выберите неотмеченного врага, i, такого, чтобы текущая энергия >= enemyEnergies[i]. Выбрав этот вариант:

Вы получаете 1 очко.
Ваша энергия уменьшается на энергию противника, т.е.  currentEnergy = currentEnergy - enemyEnergies[i].

Если у вас есть хотя бы 1 очко, вы можете выбрать немаркированного врага, т.е. Выбрав этот вариант:

Ваша энергия увеличивается на энергию противника, т.е. currentEnergy = currentEnergy + enemyEnergies[i].
Враг i отмечен.

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

Пример 1:

Input: enemyEnergies = [3,2,2], currentEnergy = 2
Output: 3
Explanation:
The following operations can be performed to get 3 points, which is the maximum:

First operation on enemy 1: points increases by 1, and currentEnergy decreases by 2. So, points = 1, and currentEnergy = 0.
Second operation on enemy 0: currentEnergy increases by 3, and enemy 0 is marked. So, points = 1, currentEnergy = 3, and marked enemies = [0].
First operation on enemy 2: points increases by 1, and currentEnergy decreases by 2. So, points = 2, currentEnergy = 1, and marked enemies = [0].
Second operation on enemy 2: currentEnergy increases by 2, and enemy 2 is marked. So, points = 2, currentEnergy = 3, and marked enemies = [0, 2].
First operation on enemy 1: points increases by 1, and currentEnergy decreases by 2. So, points = 3, currentEnergy = 1, and marked enemies = [0, 2].

Пример 2:

Input: enemyEnergies = [2], currentEnergy = 10
Output: 5
Explanation:
Performing the first operation 5 times on enemy 0 results in the maximum number of points.

Constraints:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9


Дан массив целых чисел nums и целое число k, вернуть количество подмассивов nums, где побитовое И элементов подмассива равно k.

Пример 1:

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

Пример 2:

Входные данные: nums = [1,1,2], k = 1
Выходные данные: 3
Пояснение:
Подмассивы, имеющие значение И 1: [1,1,2], [1,1,2], [1,1,2].

Пример 3:

Входные данные: nums = [1,2,3], k = 2
Выходные данные: 2
Пояснение:
Подмассивы, имеющие значение И 2: [1,2,3], [1,2,3].

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

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

Дан массив целых чисел nums и целое число k. Верни количество подмассивов из nums, в которых поразрядное И элементов подмассива равно k.

Пример 1:

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

Пример 2:

Ввод: nums = [1,1,2], k = 1
Вывод: 3
Пояснение:
Подмассивы, имеющие значение И, равное 1: [1,1,2], [1,1,2], [1,1,2].

Пример 3:

Ввод: nums = [1,2,3], k = 2
Вывод: 2
Пояснение:
Подмассивы, имеющие значение И, равное 2: [1,2,3], [1,2,3].

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

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


Вам даны два положительных целых числа x и y, обозначающие количество монет номиналом 75 и 10 соответственно.
Алиса и Боб играют в игру. Каждый ход, начиная с Алисы, игрок должен подобрать монеты общим номиналом 115. Если игрок не может этого сделать, он проигрывает.
Верните имя игрока, который выиграет игру, если оба игрока будут играть оптимально.

Пример 1:

Вход: x = 2, y = 7
Выход: "Alice"
Пояснение:
Игра заканчивается за один ход:

Алиса выбирает 1 монету достоинством 75 и 4 монеты достоинством 10.

Пример 2:

Вход: x = 4, y = 11
Выход: "Bob"
Пояснение:
Игра заканчивается за 2 хода:

Алиса выбирает 1 монету достоинством 75 и 4 монеты достоинством 10.
Боб выбирает 1 монету достоинством 75 и 4 монеты достоинством 10.

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

1 <= x, y <= 100

Вам даны два положительных целых числа x и y, обозначающие количество монет с номиналами 75 и 10 соответственно. Алиса и Боб играют в игру. Каждый ход, начиная с Алисы, игрок должен взять монеты общей стоимостью 115. Если игрок не может этого сделать, он проигрывает игру. Верните имя игрока, который выиграет игру, если оба игрока играют оптимально.

Пример 1:

Ввод: x = 2, y = 7
Вывод: "Alice"
Объяснение:
Игра заканчивается за один ход:

Алиса берет 1 монету номиналом 75 и 4 монеты номиналом 10.

Пример 2:

Ввод: x = 4, y = 11
Вывод: "Bob"
Объяснение:
Игра заканчивается за 2 хода:

Алиса берет 1 монету номиналом 75 и 4 монеты номиналом 10.
Боб берет 1 монету номиналом 75 и 4 монеты номиналом 10.

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

1 <= x, y <= 100

Вам даны два целых положительных числа x и y, обозначающие количество монет со значениями 75 и 10 соответственно.
Алиса и Боб играют в игру. Каждый ход, начиная с Алисы, игрок должен собирать монеты общей стоимостью 115. Если игрок не может этого сделать, он проигрывает игру.
Возвращает имя игрока, который выиграет игру, если оба игрока играют оптимально.

Пример 1:

Ввод: x = 2, y = 7
Результат: "Alice"
Объяснение:
Игра заканчивается в один ход:

Алиса выбирает 1 монету достоинством 75 и 4 монеты достоинством 10.

Пример 2:

Ввод: x = 4, y = 11
Выход: "Bob"
Объяснение:
Игра заканчивается в 2 хода:

Алиса выбирает 1 монету номиналом 75 и 4 монеты номиналом 10.
Боб выбирает 1 монету достоинством 75 и 4 монеты достоинством 10.

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

1 <= x, y <= 100


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

Выберите индекс i в строке так, чтобы был хотя бы один символ слева от индекса i, который равен s[i], и хотя бы один символ справа, который также равен s[i].
Удалите ближайший символ слева от индекса i, который равен s[i].
Удалите ближайший символ справа от индекса i, который равен s[i].

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

Пример 1:

Вход: s = "abaacbcbb"
Выход: 5
Объяснение:
Мы выполняем следующие операции:

Выбираем индекс 2, затем удаляем символы с индексами 0 и 3. Результирующая строка — s = "bacbcbb".
Выбираем индекс 3, затем удаляем символы с индексами 0 и 5. Результирующая строка — s = "acbcb".

Пример 2:

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

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

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

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

Выберите индекс i в строке так, чтобы слева от индекса i был хотя бы один символ, равный s[i], и хотя бы один символ справа, который также равен s[i].
Удалить ближайший символ слева от индекса i, равный s[i].
Удалить ближайший символ справа от индекса i, равный s[i].

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

Пример 1:

Ввод: s = "abaacbcbb"
Вывод: 5
Объяснение:
Делаем следующие операции:

Выберите индекс 2, затем удалите символы с индексами 0 и 3. В результате получится строка s = "bacbcbb".
Выберите индекс 3, затем удалите символы с индексами 0 и 5. В результате получится строка s = "acbcb".

Пример 2:

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

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

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

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

Выберите индекс i в строке так, чтобы слева от индекса i был хотя бы один символ, равный s[i], и справа от индекса i тоже был хотя бы один символ, равный s[i].
Удалите ближайший к индексу i символ слева, который равен s[i].
Удалите ближайший к индексу i символ справа, который равен s[i].

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

Пример 1:

Input: s = "abaacbcbb"
Output: 5
Объяснение:
Мы выполняем следующие операции:

Выберите индекс 2, затем удалите символы на индексах 0 и 3. Полученная строка: s = "bacbcbb".
Выберите индекс 3, затем удалите символы на индексах 0 и 5. Полученная строка: s = "acbcb".

Пример 2:

Input: s = "aa"
Output: 2
Объяснение:
Мы не можем выполнить никакие операции, поэтому возвращаем длину исходной строки.

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

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


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

Существует целое число X такое, что abs(a[i] - a[n - i - 1]) = X для всех (0 <= i < n).

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

Пример 1:

Ввод: nums = [1,0,1,2,4,3], k = 4
Вывод: 2
Объяснение:
Можно выполнить следующие изменения:

Заменить nums[1] на 2. Итоговый массив: nums = [1,2,1,2,4,3].
Заменить nums[3] на 3. Итоговый массив: nums = [1,2,1,3,4,3].

Целое число X будет равно 2.

Пример 2:

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

Заменить nums[3] на 0. Итоговый массив: nums = [0,1,2,0,3,6,5,4].
Заменить nums[4] на 4. Итоговый массив: nums = [0,1,2,0,4,6,5,4].

Целое число X будет равно 4.

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

2 <= n == nums.length <= 10^5
n — четное.
0 <= nums[i] <= k <= 10^5

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

Существует целое число X такое, что abs(a[i] - a[n - i - 1]) = X для всех (0 <= i < n).

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

Пример 1:

Ввод: nums = [1,0,1,2,4,3], k = 4
Вывод: 2
Объяснение:
Мы можем внести следующие изменения:

Замените nums[1] на 2. В результате получится массив nums = [1,2,1,2,4,3].
Замените nums[3] на 3. В результате получится массив nums = [1,2,1,3,4,3].

Целое число X будет 2.

Пример 2:

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

Замените nums[3] на 0. В результате получится массив nums = [0,1,2,0,3,6,5,4].
Замените nums[4] на 4. В результате получится массив nums = [0,1,2,0,4,6,5,4].

Целое число X будет 4.

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

2 <= n == nums.length <= 10^5
n чётное.
0 <= nums[i] <= k <= 10^5


Вам дано целое число n, представляющее количество игроков в игре, и двумерный массив pick, где pick[i] = [x_i, y_i] представляет, что игрок x_i выбрал шар цвета y_i.
Игрок i выигрывает игру, если он выбирает строго больше, чем i шаров одного цвета. Другими словами,

Игрок 0 выигрывает, если выбирает любой шар.
Игрок 1 выигрывает, если выбирает не менее двух шаров одного цвета.
...
Игрок i выигрывает, если выбирает не менее i + 1 шаров одного цвета.

Верните количество игроков, выигравших игру.
Обратите внимание, что в игре могут выиграть несколько игроков.

Пример 1:

Вход: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Выход: 2
Пояснение:
Игрок 0 и игрок 1 выигрывают игру, а игроки 2 и 3 не выигрывают.

Пример 2:

Вход: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Выход: 0
Пояснение:
Ни один игрок не выигрывает игру.

Пример 3:

Вход: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Выход: 1
Пояснение:
Игрок 2 выигрывает игру, выбирая 3 мяча цвета 4.

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

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10

Вам дано целое число n, представляющее количество игроков в игре, и двумерный массив pick, где pick[i] = [x_i, y_i] означает, что игрок x_i выбрал шар цвета y_i.
Игрок i выигрывает игру, если они выбирают строго больше чем i шары одного цвета. Другими словами,

Игрок 0 выигрывает, если выбирает любой шар.
Игрок 1 выигрывает, если выбирает не менее двух шаров одного цвета.
...
Игрок i выигрывает, если выбирает не менее i + 1 шаров одного цвета.

Верните количество игроков, выигравших игру.
Обратите внимание, что в игре могут выиграть несколько игроков.

Пример 1:

Ввод: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Вывод: 2
Объяснение:
Игрок 0 и игрок 1 выигрывают игру, а игроки 2 и 3 не выигрывают.

Пример 2:

Ввод: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Вывод: 0
Объяснение:
Ни один игрок не выигрывает игру.

Пример 3:

Ввод: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Вывод: 1
Объяснение:
Игрок 2 выигрывает игру, выбирая 3 мяча цвета 4.

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

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10

Вам дано целое число n, представляющее количество игроков в игре и массив данных 2D pick, где pick[i] = [x_i, y_i] представляет, что игрок  x_i поймал шар цвета y_i.
Игрок i выигрывает игру, если он поймали точно более чем i шаров одного цвета. Другими словами,

Игрок 0 выигрывает, если он поймал любой мяч.
Игрок 1 выигрывает, если они поймали хотя бы два шара одного цвета.
...
Игрок i выигрывает, если он поймал хотя бы i + 1 шара одного цвета.

Верните количество игроков, которые выиграли игру.
Обратите внимание, что игру могут выиграть несколько игроков.

Пример 1:

Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Output: 2
Explanation:
Player 0 and player 1 win the game, while players 2 and 3 do not win.

Пример 2:

Input: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Output: 0
Explanation:
No player wins the game.

Пример 3:

Input: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Output: 1
Explanation:
Player 2 wins the game by picking 3 balls with color 4.

Constraints:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10


Дана двоичная матрица размером m x n под названием grid.
Строка или столбец считаются палиндромными, если их значения читаются одинаково в прямом и обратном направлении.
Вы можете перевернуть любое количество ячеек в grid с 0 на 1 или с 1 на 0.
Верните минимальное количество ячеек, которые нужно перевернуть, чтобы сделать палиндромными либо все строки, либо все столбцы.

Пример 1:

Ввод: grid = [[1,0,0],[0,0,0],[0,0,1]]
Вывод: 2
Пояснение:

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

Пример 2:

Ввод: grid = [[0,1],[0,1],[0,0]]
Вывод: 1
Пояснение:

Переворачивание выделенной ячейки делает все столбцы палиндромными.

Пример 3:

Ввод: grid = [[1],[0]]
Вывод: 0
Пояснение:
Все строки уже палиндромные.

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

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1

Дан двоичный матрица размером m x n под названием grid.
Строка или столбец считаются палиндромными, если их значения читаются одинаково в прямом и обратном направлении.
Вы можете перевернуть любое количество ячеек в grid с 0 на 1 или с 1 на 0.
Верните минимальное количество ячеек, которые нужно перевернуть, чтобы сделать палиндромными либо все строки, либо все столбцы.

Пример 1:

Ввод: grid = [[1,0,0],[0,0,0],[0,0,1]]
Вывод: 2
Пояснение:

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

Пример 2:

Ввод: grid = [[0,1],[0,1],[0,0]]
Вывод: 1
Пояснение:

Переворачивание выделенной ячейки делает все столбцы палиндромными.

Пример 3:

Ввод: grid = [[1],[0]]
Вывод: 0
Пояснение:
Все строки уже палиндромные.

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

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1

Вам дана двоичная матричная сетка m x n.
Строка или столбец считаются палиндромными, если их значения читаются одинаково вперед и назад.
Вы можете перевернуть любое количество ячеек в сетке с 0 на 1 или с 1 на 0.
Верните минимальное количество ячеек, которые нужно перевернуть, чтобы сделать все строки или все столбцы палиндромными.

Пример 1:

Вход: grid = [[1,0,0],[0,0,0],[0,0,1]]
Выход: 2
Пояснение:

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

Пример 2:

Вход: grid = [[0,1],[0,1],[0,0]]
Выход: 1
Пояснение:

Переворот выделенной ячейки делает все столбцы палиндромными.

Пример 3:

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

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

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1


Существует неориентированное дерево с n узлами, пронумерованными от 0 до n - 1. Вам дан двумерный целочисленный массив edges длины n - 1, где edges[i] = [u_i, v_i] указывает, что существует ребро между узлами u_i и v_i в дереве.
Изначально все узлы не отмечены. Для каждого узла i:

Если i нечетное, узел будет отмечен во время x, если есть как минимум один смежный с ним узел, который был отмечен во время x - 1.
Если i четное, узел будет отмечен во время x, если есть как минимум один смежный с ним узел, который был отмечен во время x - 2.

Верните массив times, где times[i] это время, когда все узлы будут отмечены в дереве, если вы отметите узел i во время t = 0.
Заметьте, что ответ для каждого times[i] независим, то есть когда вы отмечаете узел i, все остальные узлы не отмечены.

Пример 1:

Ввод: edges = [[0,1],[0,2]]
Вывод: [2,4,3]
Объяснение:

Для i = 0:

Узел 1 будет отмечен при t = 1, а узел 2 при t = 2.

Для i = 1:

Узел 0 будет отмечен при t = 2, а узел 2 при t = 4.

Для i = 2:

Узел 0 будет отмечен при t = 2, а узел 1 при t = 3.

Пример 2:

Ввод: edges = [[0,1]]
Вывод: [1,2]
Объяснение:

Для i = 0:

Узел 1 будет отмечен при t = 1.

Для i = 1:

Узел 0 будет отмечен при t = 2.

Пример 3:

Ввод: edges = [[2,4],[0,1],[2,3],[0,2]]
Вывод: [4,6,3,5,5]
Объяснение:

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

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
Входные данные сгенерированы таким образом, что edges представляет собой допустимое дерево.

Существует неориентированное дерево с n узлами, пронумерованными от 0 до n - 1. Вам дан двумерный целочисленный массив ребер длины n - 1, где edges[i] = [u_i, v_i] указывает, что в дереве есть ребро между узлами u_i и v_i.
Изначально все узлы не отмечены. Для каждого узла i:

Если i нечетное, узел будет отмечен в момент времени x, если есть хотя бы один смежный узел, который был отмечен в момент времени x - 1.
Если i четное, узел будет отмечен в момент времени x, если есть хотя бы один смежный узел, который был отмечен в момент времени x - 2.

Вернуть массив times, где times[i] — это время, когда все узлы будут отмечены в дереве, если вы отметили узел i в момент времени t = 0.
Обратите внимание, что ответ для каждого times[i] независим, т. е. когда вы отмечаете узел i, все остальные узлы не отмечены.

Пример 1:

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

Для i = 0:

Узел 1 отмечен при t = 1, а узел 2 — при t = 2.

Для i = 1:

Узел 0 отмечен при t = 2, а узел 2 — при t = 4.

Для i = 2:

Узел 0 отмечен при t = 2, а узел 1 — при t = 3.

Пример 2:

Вход: edges = [[0,1]]
Выход: [1,2]
Пояснение:

Для i = 0:

Узел 1 отмечен при t = 1.

Для i = 1:

Узел 0 отмечен при t = 2.

Пример 3:

Вход: edges = [[2,4],[0,1],[2,3],[0,2]]
Выход: [4,6,3,5,5]
Объяснение:

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

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
Входные данные генерируются таким образом, что edges представляет собой допустимое дерево.

Существует неориентированное дерево с n узлами с номерами от 0 до n - 1. Вам задан 2D массив целых чисел с рёбрами длины n - 1, где вершины[i] = [u_i, v_i] указывают, что между узлами u_i и v_i есть ребро в дереве.
Изначально все узлы не отмечены. Для каждого узла i:

Если i нечётно, узел будет отмечен в момент времени x, если к нему примыкает хотя бы один узел, который был отмечен в момент времени x - 1.
Если i чётное, узел будет помечен в момент x, если к нему примыкает хотя бы один узел, который был отмечен в момент x - 2.

Верните массив времени, где время[i] это время, когда все узлы отмечаются в дереве, если вы отмечаете узел i в момент времени t = 0.
Обратите внимание, что ответ для каждого время[i] независим, т. е. когда вы отмечаете узел i, все остальные узлы не отмечены.

Пример 1:

Input: edges = [[0,1],[0,2]]
Output: [2,4,3]
Explanation:

For i = 0:

Node 1 is marked at t = 1, and Node 2 at t = 2.

For i = 1:

Node 0 is marked at t = 2, and Node 2 at t = 4.

For i = 2:

Node 0 is marked at t = 2, and Node 1 at t = 3.

Пример 2:

Input: edges = [[0,1]]
Output: [1,2]
Explanation:

For i = 0:

Node 1 is marked at t = 1.

For i = 1:

Node 0 is marked at t = 2.

Пример 3:

Input: edges = [[2,4],[0,1],[2,3],[0,2]]
Output: [4,6,3,5,5]
Explanation:

Constraints:

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
The input is generated such that edges represents a valid tree.


Дано N линейных функций f_1, f_2, \ldots, f_N, где f_i(x) = A_i x + B_i.
Найдите максимально возможное значение f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) для последовательности p = (p_1, p_2, \ldots, p_K) из K различных целых чисел от 1 до N включительно.

Ввод

Ввод предоставляется из стандартного ввода в следующем формате:
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Вывод

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

Ограничения

- 1 \leq N \leq 2 \times 10^{5}
- 1 \leq K \leq \text{min}(N,10)
- 1 \leq A_i, B_i \leq 50 (1 \leq i \leq N)
- Все входные значения — целые числа.

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

3 2
2 3
1 5
4 2

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

26

Здесь все возможные p и соответствующие значения f_{p_1}(f_{p_2}(1)):

- p= ( 1,2 ) : f_1(f_2(1))=15
- p= ( 1,3 ) : f_1(f_3(1))=15
- p= ( 2,1 ) : f_2(f_1(1))=10
- p= ( 2,3 ) : f_2(f_3(1))=11
- p= ( 3,1 ) : f_3(f_1(1))=22
- p= ( 3,2 ) : f_3(f_2(1))=26

Поэтому, выведите 26.

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

10 3
48 40
34 22
24 37
45 40
48 31
49 44
45 40
44 6
35 22
39 28

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

216223

Вам даны N линейных функций f_1, f_2, \ldots, f_N, где f_i(x) = A_i x + B_i.
Найдите максимально возможное значение f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) для последовательности p = (p_1, p_2, \ldots, p_K) из K различных целых чисел от 1 до N включительно.

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

Входные данные даются из стандартного ввода в следующем формате:
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

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

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

Ограничения

- 1 \leq N \leq 2 \times 10^{5}
- 1 \leq K \leq \text{min}(N,10)
- 1 \leq A_i, B_i \leq 50 (1 \leq i \leq N)
- Все входные значения являются целыми числами.

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

3 2
2 3
1 5
4 2

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

26

Вот все возможные p и соответствующие им значения f_{p_1}(f_{p_2}(1)):

- p= ( 1,2 ) : f_1(f_2(1))=15
- p= ( 1,3 ) : f_1(f_3(1))=15
- p= ( 2,1 ) : f_2(f_1(1))=10
- p= ( 2,3 ) : f_2(f_3(1))=11
- p= ( 3,1 ) : f_3(f_1(1))=22
- p= ( 3,2 ) : f_3(f_2(1))=26

Поэтому выведите 26.

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

10 3
48 40
34 22
24 37
45 40
48 31
49 44
45 40
44 6
35 22
39 28

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

216223


Вам дан горизонтально написанный текст. Преобразуйте его в вертикальное написание, заполнив пробелы *.

Вам дано N строк S_1, S_2, \dots, S_N, состоящих из строчных английских букв. Пусть M будет максимальной длиной этих строк.
Выведите M строк T_1, T_2, \dots, T_M, которые удовлетворяют следующим условиям:

- Каждая T_i состоит из строчных английских букв и *.
- Каждая T_i не заканчивается *.
- Для каждого 1 \leq i \leq N выполняется следующее:
- Для каждого 1 \leq j \leq |S_i| существует (N-i+1)-й символ T_j, и конкатенация (N-i+1)-х символов T_1, T_2, \dots, T_{|S_i|} в этом порядке равна S_i.
- Для каждого |S_i| + 1 \leq j \leq M, (N-i+1)-й символ T_j либо не существует, либо равен *.

Здесь |S_i| обозначает длину строки S_i.

Ввод

Вводные данные даются из стандартного ввода в следующем формате:
N
S_1
S_2
\vdots
S_N

Вывод

Выведите ответ в следующем формате:
T_1
T_2
\vdots
T_M

Ограничения

- N — целое число от 1 до 100 включительно.
- Каждое S_i — это строка строчных английских букв длиной от 1 до 100 включительно.

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

3
abc
de
fghi

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

fda
geb
h*c
i

Размещение * в качестве второго символа T_3 помещает c в правильное положение.
С другой стороны, размещение * в качестве 2-го и 3-го символов T_4 приведет к тому, что T_4 будет заканчиваться на *, что нарушает условие.

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

3
atcoder
beginner
contest

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

cba
oet
ngc
tio
end
sne
ter
*r

Вам дан горизонтально написанный текст. Преобразуйте его в вертикальное написание, заполняя пробелы *.

Вам даны N строк S_1, S_2, \dots, S_N, состоящих из строчных Английских букв. Пусть M это максимальная длина этих строк.
Выведите M строк T_1, T_2, \dots, T_M, удовлетворяющих следующие условия:

- Каждый T_i состоит из строчных Английских букв и *.
- Каждый T_i не заканчивается *.
- Для каждого 1 \leq i \leq N справедливо следующее:
- Для каждого 1 \leq j \leq |S_i|, существует (N-i+1)-й символ T_j и конкатенация (N-i+1)-го символа T_1, T_2, \dots, T_{|S_i|} в этом порядке равно S_i.
- Для каждого|S_i| + 1 \leq j \leq M, (N-i+1)-й символ T_j либо не существует, либо равен *.

Здесь |S_i| обозначает длину строки S_i.

Вход

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

Выход

Распечатайте ответ в следующем формате:
T_1
T_2
\vdots
T_M

Ограничения

- N представляет собой целое число от 1 до 100 включительно.
— Каждый S_i представляет собой строку строчных Английских букв длиной от 1 до 100 включительно.

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

3
abc
de
fghi

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

fda
geb
h*c
i

Размещение * в качестве второго символа T_3 помещает c в правильное положение.
С другой стороны, размещение * в качестве второго и третьего символов T_4 приведет к тому, что T_4 закончится на *, что нарушает условие.

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

3
atcoder
beginner
contest

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

cba
oet
ngc
tio
end
sne
ter
*r


Вам даны N точек (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) на двумерной плоскости и неотрицательное целое число D.
Найдите количество пар целых чисел (x, y), таких что \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

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

Входные данные подаются со стандартного входа в следующем формате:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

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

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

Ограничения

- 1 \leq N \leq 2 \times 10^5
- 0 \leq D \leq 10^6
- -10^6 \leq x_i, y_i \leq 10^6
- (x_i, y_i) \neq (x_j, y_j) для i \neq j.
- Все входные значения являются целыми числами.

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

2 3
0 0
1 0

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

8

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

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

2 0
0 0
2 0

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

0

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

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

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

419

Вам дают N точек (x_1, y_1), (x_2, y_2), \ dots, (x_N, y_N) на двумерной плоскости и неотрицательное целое число D.
Найдите количество целых пар (x, y) такого, что \ displaystyle \ sum_ {i = 1}^N(| x-x_i |+| y-y_i |) \ leq D.

Вход

Ввод приведен из стандартного ввода в следующем формате:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Выход

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

Ограничения

- (1 \leq N \leq 2 \times 10^5
-(0 \leq D \leq 10^6)
-(-10^6 \leq x_i, y_i \leq 10^6
-((x_i, y_i) \neq (x_j, y_j) for i \neq j.
- Все входные значения являются целыми числами.

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

2 3
0 0
1 0

Образец вывода 1

8

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

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

2 0
0 0
2 0

Образец вывода 2

0

Образец ввода 3

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

Образец вывода 3

419

Вам заданы N точки (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) на двухмерной плоскости и неотрицательное целое число D.
Найти число целые пары (x, y) такие, что \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

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

Ввод осуществляется из стандартного ввода в следующем формате:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Вывод

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

Ограничения

- 1 \leq N \leq 2 \times 10^5
- 0 \leq D \leq 10^6
- -10^6 \leq x_i, y_i \leq 10^6
- (x_i, y_i) \neq (x_j, y_j) for i \neq j.
- все входные значения являются числами.

входные данные выборки 1

2 3
0 0
1 0

Выходной сигнал выборки 1

8

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

Вход в выборку 2

2 0
0 0
2 0

Выходной сигнал выборки 2

0

Вход в выборку 3

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

Выходной сигнал выборки 3

419


Дано положительное целое число N и целое число A_{x,y,z} для каждой тройки целых чисел (x, y, z) таких, что 1 \leq x, y, z \leq N.
Вам даны Q запросов в следующем формате, которые необходимо обработать по порядку.
Для i-го запроса (1 \leq i \leq Q) вам дан кортеж целых чисел (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i), такой что 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, и 1 \leq Lz_i \leq Rz_i \leq N. Найдите:
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Ввод

Ввод осуществляется через стандартный ввод в следующем формате:
N
A_{1,1,1} A_{1,1,2} \ldots A_{1,1,N}
A_{1,2,1} A_{1,2,2} \ldots A_{1,2,N}
\vdots
A_{1,N,1} A_{1,N,2} \ldots A_{1,N,N}
A_{2,1,1} A_{2,1,2} \ldots A_{2,1,N}
A_{2,2,1} A_{2,2,2} \ldots A_{2,2,N}
\vdots
A_{2,N,1} A_{2,N,2} \ldots A_{2,N,N}
\vdots
A_{N,1,1} A_{N,1,2} \ldots A_{N,1,N}
A_{N,2,1} A_{N,2,2} \ldots A_{N,2,N}
\vdots
A_{N,N,1} A_{N,N,2} \ldots A_{N,N,N}
Q
Lx_1 Rx_1 Ly_1 Ry_1 Lz_1 Rz_1
Lx_2 Rx_2 Ly_2 Ry_2 Lz_2 Rz_2
\vdots
Lx_Q Rx_Q Ly_Q Ry_Q Lz_Q Rz_Q

Вывод

Выведите Q строк.
i-я строка должна содержать ответ на i-й запрос.

Ограничения

- 1 \leq N \leq 100
- 1 \leq Q \leq 2 \times 10^{5}
- 0 \leq A_{x,y,z} \leq 999 (1 \leq x, y, z \leq N)
- 1 \leq Lx_i \leq Rx_i \leq N (1 \leq i \leq Q)
- 1 \leq Ly_i \leq Ry_i \leq N (1 \leq i \leq Q)
- 1 \leq Lz_i \leq Rz_i \leq N (1 \leq i \leq Q)
- Все входные значения — целые числа.

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

2
1 2
3 4
5 6
7 8
2
1 2 2 2 1 1
2 2 1 2 1 2

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

10
26

Для 1-го запроса искомое значение A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Поэтому выведите 10.
Для 2-го запроса искомое значение A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Поэтому выведите 26.

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

3
733 857 714
956 208 257
123 719 648
840 881 245
245 112 746
306 942 694
58 870 849
13 208 789
687 906 783
8
3 3 3 3 1 1
1 3 2 3 3 3
2 2 2 3 1 1
1 3 1 1 1 1
2 3 2 3 2 3
1 2 1 1 1 2
3 3 2 2 1 3
1 2 2 3 2 3

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

687
3917
551
1631
5180
3311
1010
4326

Дано положительное целое число N и целое число A_{x,y,z} для каждой тройки целых чисел (x, y, z) таких, что 1 \leq x, y, z \leq N.
Вам даны Q запросов в следующем формате, которые необходимо обработать по порядку.
Для i-го запроса (1 \leq i \leq Q) вам дан кортеж целых чисел (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i), такой что 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, and 1 \leq Lz_i \leq Rz_i \leq N. Найдите:
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Ввод

Ввод осуществляется через стандартный ввод в следующем формате:
N
A_{1,1,1} A_{1,1,2} \ldots A_{1,1,N}
A_{1,2,1} A_{1,2,2} \ldots A_{1,2,N}
\vdots
A_{1,N,1} A_{1,N,2} \ldots A_{1,N,N}
A_{2,1,1} A_{2,1,2} \ldots A_{2,1,N}
A_{2,2,1} A_{2,2,2} \ldots A_{2,2,N}
\vdots
A_{2,N,1} A_{2,N,2} \ldots A_{2,N,N}
\vdots
A_{N,1,1} A_{N,1,2} \ldots A_{N,1,N}
A_{N,2,1} A_{N,2,2} \ldots A_{N,2,N}
\vdots
A_{N,N,1} A_{N,N,2} \ldots A_{N,N,N}
Q
Lx_1 Rx_1 Ly_1 Ry_1 Lz_1 Rz_1
Lx_2 Rx_2 Ly_2 Ry_2 Lz_2 Rz_2
\vdots
Lx_Q Rx_Q Ly_Q Ry_Q Lz_Q Rz_Q

Вывод

Выведите Q строк.
i-я строка должна содержать ответ на i-й запрос.

Ограничения

- 1 \leq N \leq 100
- 1 \leq Q \leq 2 \times 10^{5}
- 0 \leq A_{x,y,z} \leq 999 (1 \leq x, y, z \leq N)
- 1 \leq Lx_i \leq Rx_i \leq N (1 \leq i \leq Q)
- 1 \leq Ly_i \leq Ry_i \leq N (1 \leq i \leq Q)
- 1 \leq Lz_i \leq Rz_i \leq N (1 \leq i \leq Q)
- Все входные значения — целые числа.

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

2
1 2
3 4
5 6
7 8
2
1 2 2 2 1 1
2 2 1 2 1 2

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

10
26

Для 1-го запроса искомое значение A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Поэтому выведите 10.
Для 2-го запроса искомое значение A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Поэтому выведите 26.

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

3
733 857 714
956 208 257
123 719 648
840 881 245
245 112 746
306 942 694
58 870 849
13 208 789
687 906 783
8
3 3 3 3 1 1
1 3 2 3 3 3
2 2 2 3 1 1
1 3 1 1 1 1
2 3 2 3 2 3
1 2 1 1 1 2
3 3 2 2 1 3
1 2 2 3 2 3

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

687
3917
551
1631
5180
3311
1010
4326