Есть три карты с буквами $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, расположенные в ряд в некотором порядке. Вы можете выполнить следующую операцию не более одного раза:

- Выберите две карты и поменяйте их местами. Возможно ли, что ряд станет $\texttt{abc}$ после операции? Выведите "YES", если это возможно, и "NO" в противном случае.

Вход

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 6$) — количество тестов.

Единственная строка каждого теста содержит одну строку, состоящую ровно из каждого из трех символов $\texttt{a}$, $\texttt{b}$ и $\texttt{c}$, представляющих карты.

Выход

Для каждого теста выведите "YES", если можно сделать ряд $\texttt{abc}$ не более чем за одну операцию, или "NO" в противном случае.

Вы можете вывести ответ в любом регистре (например, строки "yEs", "yes", "Yes" и "YES" будут признаны положительным ответом).

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

abc

acb

bac

bca

cab

cba

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

YES
YES
YES
NO
NO
YES

Примечание

В первом тесте не нужно выполнять никаких операций, так как ряд уже $\texttt{abc}$.

Во втором тесте можно поменять $\texttt{c}$ и $\texttt{b}$ местами: $\texttt{acb} \to \texttt{abc}$.

В третьем тесте можно поменять $\texttt{b}$ и $\texttt{a}$ местами: $\texttt{bac} \to \texttt{abc}$.

В четвертом тесте невозможно сделать $\texttt{abc}$, используя не более одной операции.

Есть три карточки с буквами etters $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, расположенными в ряд в некотором порядке. Вы можете выполнить следующую операцию не более одного раза:

- Возьмите две карты и поменяйте их местами.  Возможно ли, что после операции строка станет $\texttt{abc}$? Выведите "YES", если это возможно, и "NO", в противном случае.

Ввод

В первой строке записано одно целое число $t$ ($1 \leq t \leq 6$) это количество тестовых случаев.

Единственная строка каждого тестового примера содержит одну строку, состоящую из каждого из трех символов $\texttt{a}$, $\texttt{b}$, и $\texttt{c}$ ровно один раз, представляющих карты.

Вывод

Для каждого тестового примера выведите "YES", если вы можете создать строку $\texttt{abc}$ не более чем с помощью одной операции, или "NO" в противном случае.

Вывести ответ можно в любом случае (например, строки "yEs", "yes", "Yes" и "YES" будут распознаны как положительный ответ). Пример ввода 1:
6

abc

acb

bac

bca

cab

cba

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

YES
YES
YES
NO
NO
YES

Примечание

В первом тестовом примере нам не нужно выполнять никаких операций, поскольку строка уже $\texttt{abc}$.

Во втором тестовом примере мы можем поменять местами $\texttt{c}$ и $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

В третьем наборе входных данных мы можем поменять местами $\texttt{b}$ и $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

В четвёртом наборе входных данных невозможно создать $\texttt{abc}$, используя не более одной операции.

Есть три карты с буквами $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, расположенные в ряд в некотором порядке. Вы можете выполнить следующую операцию не более одного раза:

- Выберите две карты и поменяйте их местами. Возможно ли, что после операции ряд станет $\texttt{abc}$? Выведите "YES", если это возможно, и "NO" в противном случае.

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

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 6$) — количество тестовых случаев.

Единственная строка каждого тестового случая содержит одну строку, состоящую из каждого из трех символов $\texttt{a}$, $\texttt{b}$ и $\texttt{c}$ ровно один раз, что представляет карты.

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

Для каждого тестового случая выведите "YES", если вы можете составить ряд $\texttt{abc}$ не более чем за одну операцию, или "NO" в противном случае.

Вы можете вывести ответ в любом регистре (например, строки "yEs", "yes", "Yes" и "YES" будут распознаны как положительный ответ). Пример ввода 1:
6

abc

acb

bac

bca

cab

cba

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

YES
YES
YES
NO
NO
YES

Примечание

В первом тестовом случае нам не нужно выполнять никаких операций, так как строка уже $\texttt{abc}$.

Во втором тестовом случае мы можем поменять местами $\texttt{c}$ и $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

В третьем тестовом случае мы можем поменять местами $\texttt{b}$ и $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

В четвертом тестовом случае невозможно создать $\texttt{abc}$, используя максимум одну операцию.


Славик готовит подарок для дня рождения друга. У него есть массив $a$ из $n$ цифр, и подарок будет представлен произведением всех этих цифр. Поскольку Славик хочет сделать самое большое произведение, он хочет прибавить $1$ ровно к одной из его цифр.

Какое максимальное произведение может сделать Славик?

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

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестов.

Первая строка каждого теста содержит одно целое число $n$ ($1 \leq n \leq 9$) — количество цифр.

Вторая строка каждого теста содержит $n$ целых чисел $a_i$ ($0 \leq a_i \leq 9$) — цифры в массиве.

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

Для каждого теста выведите одно число — максимальное произведение, которое может сделать Славик, прибавив $1$ ровно к одной из его цифр.

Sample Input 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Sample Output 1:
16
2
432
430467210

Славик готовит подарок на день рождения другу. У него есть массив $a$ из цифр $n$, и настоящее будет произведением всех этих цифр. Поскольку Славик хороший ребенок, который хочет сделать максимально возможный продукт, он хочет добавить ровно 1 доллар к одной из своих цифр.

Какой максимальный продукт может сделать Славик?

Input

The first line contains a single integer $t$ ($1 \leq t \leq 10^4$) — the number of test cases.

The first line of each test case contains a single integer $n$ ($1 \leq n \leq 9$) — the number of digits.

The second line of each test case contains $n$ space-separated integers $a_i$ ($0 \leq a_i \leq 9$) — the digits in the array.

Output

For each test case, output a single integer — the maximum product Slavic can make, by adding $1$ to exactly one of his digits.Sample Input 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Sample Output 1:

16
2
432
430467210

Славик готовит подарок на день рождения друга. У него есть массив $ A $ $ n $ Цифры, и подарок будет произведением всех этих цифр. Поскольку Славик - хороший ребенок, который хочет сделать самый большой продукт возможным, он хочет добавить 1 $ в одну из своих цифр.

Какой максимальный продукт может сделать Славик?

Вход

Первая строка содержит единое целое число $ t $ ($ 1 \ leq t \ leq 10^4 $) - количество тестовых случаев.

Первая строка каждого тестового примера содержит одно целое число $ n $ (1 $ \ leq n \ leq 9 $) - количество цифр.

Вторая строка каждого тестового примера содержит $ n $, разделенные пробелами целые числа $ a_i $ ($ 0 \ leq a_i \ leq 9 $)-цифры в массиве.

Выход

Для каждого тестового примера выводите одно целое число - максимальное произведение, которое Славик может получить, добавив $ 1 $ к именно одной из его цифр. Пример вход 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Вывод образца 1:

16
2
432
430467210


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

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

Ввод

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 1000$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит два целых числа $n$ и $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — длину бумаги и целое число, используемое в операции.

Вторая строка каждого тестового случая содержит строку $s$ длиной $n$, состоящую из символов $\texttt{B}$ (представляющих черную клетку) или $\texttt{W}$ (представляющих белую клетку).

Сумма $n$ по всем тестовым случаям не превышает $2 \cdot 10^5$.

Вывод

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

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

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

2
1
2
1
4
3
4
0

Примечание

В первом тестовом случае вы можете выполнить следующие операции: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWW}$$

Во втором тестовом случае вы можете выполнить следующие операции: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

В третьем тестовом случае вы можете выполнить следующие операции: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

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

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

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

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 1000$) — количество тестов.

Первая строка каждого теста содержит два целых числа $n$ и $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — длина бумаги и целое число, используемое в операции.

Вторая строка каждого теста содержит строку $s$ длиной $n$, состоящую из символов $\texttt{B}$ (означающих черную ячейку) или $\texttt{W}$ (означающих белую ячейку).

Сумма всех $n$ по всем тестам не превышает $2 \cdot 10^5$.

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

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

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

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

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

2
1
2
1
4
3
4
0

Примечание

В первом тесте вы можете выполнить следующие операции: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

Во втором тесте вы можете выполнить следующие операции: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

В третьем тесте вы можете выполнить следующие операции: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

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

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

Ввод

В первой строке записано одно целое число $t$ ($1 \leq t \leq 1000$) — количество тестовых случаев.
Первая строка каждого набора входных данных содержит два целых числа $n$ и $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) длину бумаги и целое число, используемое в операции.

Вторая строка каждого набора входных данных содержит строку $s$ длины $n$ состоящую из символов $\texttt{B}$ (представляющих чёрную ячейку) или $\texttt{W}$ (представляющих белую ячейку).

Сумма $n$ по всем тестам не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового примера выведите одно целое число это минимальное количество операций, необходимое для удаления всех чёрных ячеек. Пример вводных данных 1:
8

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

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

2
1
2
1
4
3
4
0

Примечание

В первом тестовом примере вы можете выполнить следующие операции: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

Во втором тестовом примере вы можете выполнить следующие операции: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

В третьем наборе вводных данных вы можете выполнить следующие операции: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$


Дана строка $s$ длиной $n$, состоящая из строчных латинских букв, и целое число $k$.

Необходимо проверить, можно ли удалить ровно $k$ символов из строки $s$ таким образом, чтобы оставшиеся символы можно было переставить в палиндром. Оставшиеся символы можно переставлять любым образом.

Палиндром — это строка, которая читается одинаково слева направо и справа налево. Например, строки "z", "aaa", "aba", "abccba" являются палиндромами, тогда как строки "codeforces", "reality", "ab" — нет.

Ввод

Каждый тест состоит из нескольких тестовых случаев. Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестовых случаев. Далее следуют их описания.

Первая строка каждого тестового случая содержит два целых числа $n$ и $k$ ($0 \leq k < n \leq 10^5$) — длину строки $s$ и количество символов для удаления.

Вторая строка каждого тестового случая содержит строку $s$ длиной $n$, состоящую из строчных латинских букв.

Сумма $n$ по всем тестовым случаям не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового случая выведи "YES", если из строки $s$ можно удалить ровно $k$ символов таким образом, что оставшиеся символы можно будет переставить так, чтобы получился палиндром, и "NO" в противном случае.

Ответ можно выводить в любом регистре (верхнем или нижнем). Например, строки "yEs", "yes", "Yes" и "YES" будут распознаны как положительные ответы.

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

14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

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

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Примечание

В первом тестовом случае ничего нельзя удалить, и строка "a" является палиндромом.

Во втором тестовом случае ничего нельзя удалить, но строки "ab" и "ba" не являются палиндромами.

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

В четвёртом тестовом случае можно удалить один символ "a", в результате получится строка "bb", которая является палиндромом.

В шестом тестовом случае можно удалить один символ "b" и один символ "d", в результате чего получится строка "acac", которую можно переставить в строку "acca".

В девятом тестовом случае можно удалить один символ "t" и один символ "k", в результате чего получится строка "aagaa", которая является палиндромом.

Вам дана строка $s$ длины $n$, состоящая из строчных латинских букв, и целое число $k$.

Вам нужно проверить, можно ли удалить ровно $k$ символов из строки $s$ таким образом, чтобы оставшиеся символы можно было переставить в палиндром. Обратите внимание, что вы можете переставлять оставшиеся символы любым образом.

Палиндром — это строка, которая читается одинаково слева направо и справа налево. Например, строки "z", "aaa", "aba", "abccba" являются палиндромами, тогда как строки "codeforces", "reality", "ab" не являются.

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

Каждый тест состоит из нескольких тестов. Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестов. Далее следуют их описания.

Первая строка каждого теста содержит два целых числа $n$ и $k$ ($0 \leq k < n \leq 10^5$) — длину строки $s$ и количество символов для удаления.

Вторая строка каждого теста содержит строку $s$ длины $n$, состоящую из строчных латинских букв.

Гарантируется, что сумма $n$ по всем тестам не превышает $2 \cdot 10^5$.

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

Для каждого теста выведите "YES", если возможно удалить ровно $k$ символов из строки $s$ так, чтобы оставшиеся символы можно было переставить в палиндром, и "NO" в противном случае.

Вы можете выводить ответ в любом регистре (верхнем или нижнем). Например, строки "yEs", "yes", "Yes" и "YES" будут распознаны как положительные ответы.

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

14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

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

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Примечание

В первом тесте ничего нельзя удалить, и строка "a" является палиндромом.

Во втором тесте ничего нельзя удалить, но строки "ab" и "ba" не являются палиндромами.

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

В четвёртом тесте можно удалить один символ "a", в результате получится строка "bb", которая является палиндромом.

В шестом тесте можно удалить один символ "b" и один символ "d", в результате чего получится строка "acac", которую можно переставить в строку "acca".

В девятом тесте можно удалить один символ "t" и один символ "k", в результате чего получится строка "aagaa", которая является палиндромом.

Вам дается строка $s$длины $n$, состоящая из строчных латинских букв, и целое $k$.

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

Палиндром — это строка, которая читается одинаково в обоих направлениях. Например, строки "z", "aaa", "aba", "abccba"-палиндромы, а строки "codeforces", "reality", "ab"-нет.

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

Каждое испытание состоит из нескольких испытательных случаев. Первая строка содержит одно целое $t$($1 \leq t \leq 10^4$)-количество тестовых случаев. За этим следует их описание.

Первая строка каждого тестового случая содержит два целых числа $n$и $k$($0 \leq k < n \leq 10^5$)-длина строки $s$и количество символов, которые будут удалены.

Вторая строка каждого тестового случая содержит строку $s$длиной $n$, состоящую из строчных латинских букв.

Гарантируется, что сумма $n$во всех тестовых случаях не превышает $2 \cdot 10^5$.

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

Для каждого тестового случая выведите "YES", если можно удалить ровно $k$символы из строки $s$таким образом, что оставшиеся символы могут быть перестроены в палиндром, и "NO" в противном случае.

Вы можете вывести ответ в любом случае (верхний или нижний). Например, строки "yEs", "yes", "Yes", и "YES" будут признаны положительными ответами. Вход выборки 1:
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

Выход. выборки 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Примечание:

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

Во втором тестовом случае ничего нельзя удалить, но строки "ab" и "ba" не являются палиндромами.

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

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

В шестом тестовом случае, можно удалить по одному символов "b" и "d" может быть удалено, в результате чего появится строка "acac", которая может быть перестроена в строку "acca".

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


Вам дан массив целых чисел $a_1, a_2, \ldots, a_n$ и число $k$ ($2 \leq k \leq 5$). За одну операцию вы можете сделать следующее:

- Выбрать индекс $1 \leq i \leq n$,
- Установить $a_i = a_i + 1$. Найдите минимальное количество операций, необходимое для того, чтобы произведение всех чисел в массиве $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ делилось на $k$.

Ввод

Каждый тест состоит из нескольких тестовых случаев. Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестовых случаев. Затем следует описание тестовых случаев.

Первая строка каждого тестового случая содержит два целых числа $n$ и $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — размер массива $a$ и число $k$.

Вторая строка каждого тестового случая содержит $n$ целых чисел $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Гарантируется, что сумма $n$ по всем тестовым случаям не превысит $2 \cdot 10^5$.

Вывод

Для каждого тестового случая выведите минимальное количество операций, необходимое для того, чтобы произведение всех чисел в массиве делилось на $k$.Пример ввода 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Пример Вывод 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Примечание

В первом тестовом случае нам нужно дважды выбрать индекс $i = 2$. После этого массив будет $a = [7, 5]$. Произведение всех чисел в массиве равно $35$.

В четвертом тестовом случае произведение чисел в массиве равно $120$, что уже делится на $5$, поэтому никаких операций не требуется.

В восьмом тестовом случае мы можем выполнить две операции, выбрав $i = 2$ и $i = 3$ в любом порядке. После этого массив будет $a = [1, 6, 10]$. Произведение чисел в массиве равно $60$.

Дан массив целых чисел $a_1, a_2, \ldots, a_n$ и число $k$ ($2 \leq k \leq 5$). За одну операцию вы можете сделать следующее:

- Выбрать индекс $1 \leq i \leq n$,
- Установить $a_i = a_i + 1$. Найдите минимальное количество операций, необходимых для того, чтобы произведение всех чисел в массиве $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ делилось на $k$.

Вход

Каждый тест состоит из нескольких наборов тестов. Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество наборов тестов. Далее следует описание наборов тестов.

Первая строка каждого набора тестов содержит два целых числа $n$ и $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — размер массива $a$ и число $k$.

Вторая строка каждого набора тестов содержит $n$ целых чисел $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Гарантируется, что сумма $n$ по всем наборам тестов не превышает $2 \cdot 10^5$.

Выход

Для каждого набора тестов выведите минимальное количество операций, необходимых для того, чтобы произведение всех чисел в массиве делилось на $k$.

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

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

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

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Примечание

В первом наборе тестов нам нужно выбрать индекс $i = 2$ дважды. После этого массив станет $a = [7, 5]$. Произведение всех чисел в массиве — $35$.

В четвертом наборе тестов произведение чисел в массиве — $120$, которое уже делится на $5$, поэтому операции не требуются.

В восьмом наборе тестов можно выполнить две операции, выбрав $i = 2$ и $i = 3$ в любом порядке. После этого массив станет $a = [1, 6, 10]$. Произведение чисел в массиве — $60$.

Вам дан массив целых чисел $a_1, a_2, \ldots, a_n$ и число $k$ ($2 \leq k \leq 5$). За одну операцию можно сделать следующее:

- Выберите индекс $1 \leq i \leq n$,
- Установите Set $a_i = a_i + 1$.Найдите минимальное количество операций, необходимое для того, чтобы произведение всех чисел массива $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ делилось на $k$.

Ввод

Каждый тест состоит из нескольких тестовых случаев. В первой строке записано одно целое число  $t$ ($1 \leq t \leq 10^4$) это количество тестовых случаев. Далее следует описание тестовых случаев.

Первая строка каждого набора входных данных содержит два целых числа $n$ and $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) это размер массива $a$ и число $k$.

Вторая строка каждого набора входных данных содержит $n$ целых чисел $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Гарантируется, что сумма $n$ по всем тестам не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового примера выведите минимальное количество операций, необходимое для того, чтобы произведение всех чисел в массиве делилось на $k$.Пример вводных данных 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

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

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Примечание

В первом наборе входных данных нам нужно дважды выбрать индекс $i = 2$. После этого массив будет $a = [7, 5]$. Произведение всех чисел массива равно $35$.

В четвёртом наборе входных данных произведение чисел в массиве равно $120$, что уже делится на $5$, поэтому никаких операций не требуется.

В восьмом наборе входных данных мы можем выполнить две операции, выбрав $i = 2$ и $i = 3$ в любом порядке. После этого массив будет $a = [1, 6, 10]$. Произведение чисел в массиве равно $60$.


Ваня и Вова играют в игру. Игрокам дается целое число $n$. В свой ход игрок может добавить $1$ к текущему числу или вычесть $1$. Игроки ходят по очереди; Ваня начинает. Если после хода Вани число делится на $3$, он выигрывает. Если прошло $10$ ходов и Ваня не выиграл, то выигрывает Вова.

Напишите программу, которая по заданному числу $n$ определяет, кто победит, если оба игрока играют оптимально.

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

Первая строка содержит целое число $t$ ($1 \leq t \leq 100$) — количество тестов.

Каждая тестовая строка содержит одно целое число $n$ ($1 \leq n \leq 1000$).

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

Для каждого теста выведите "First" без кавычек, если выигрывает Ваня, и "Second" без кавычек, если выигрывает Вова.

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

1

3

5

100

999

1000

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

First
Second
First
First
Second
First

Ваня и Вова играют в игру. Игрокам дано целое число $n$. В свой ход игрок может прибавить $1$ к текущему целому числу или вычесть $1$. Игроки ходят по очереди; начинает Ваня. Если после хода Вани целое число делится на $3$, то он выигрывает. Если прошло $10$ ходов и Ваня не выиграл, то выигрывает Вова.

Напишите программу, которая на основе целого числа $n$ определяет, кто победит, если оба игрока будут играть оптимально.

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

Первая строка содержит целое число $t$ ($1 \leq t \leq 100$) — количество тестовых случаев.

Единственная строка каждого тестового случая содержит целое число $n$ ($1 \leq n \leq 1000$).

Вывод

Для каждого тестового случая выведите «First» без кавычек, если победит Ваня, и «Second» без кавычек, если победит Вова.Пример ввода 1:
6

1

3

5

100

999

1000

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

First
Second
First
First
Second
First


Алекс участвует в съёмках очередного видео для BrMeast, и BrMeast попросил его подготовить 250 тысяч тонн тротила, но Алекс не расслышал и подготовил $n$ ящиков, выстроив их в ряд в ожидании грузовиков. Вес $i$-го ящика слева составляет $a_i$ тонн.

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

- Первые $k$ ящиков загружают в первый грузовик,
- Вторые $k$ ящиков загружают во второй грузовик,
- $\dotsb$
- Последние $k$ ящиков загружают в $\frac{n}{k}$-й грузовик. После завершения погрузки в каждом грузовике должно быть ровно $k$ ящиков. Другими словами, если в какой-то момент невозможно загрузить ровно $k$ ящиков в грузовик, то вариант погрузки с таким $k$ невозможен.

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

У Алекса много связей, поэтому для каждого $1 \leq k \leq n$ он может найти компанию, грузовики которой могут вмещать ровно $k$ ящиков. Выведи максимальную абсолютную разницу между общим весом любых двух грузовиков.

Ввод

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число $n$ ($1 \leq n \leq 150\,000$) — количество ящиков.

Вторая строка содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — вес ящиков.

Сумма $n$ во всех тестовых случаях не превышает $150\,000$.

Вывод

Для каждого тестового случая выведи одно целое число — ответ на задачу.

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

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

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

1
9
0
189114
112141

Примечание

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

Во втором случае нужно выбрать шесть грузовиков, максимальная масса будет $10$, минимальная — $1$, ответ $10 - 1 = 9$.

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

Алекс участвует в съемках очередного видео BrMeast, и BrMeast попросил Алекс подготовить 250 тысяч тонн тротила, но Алекс его плохо расслышал, поэтому он подготовил $n$ ящиков и выстроил их в ряд в ожидании грузовиков. $i$-й ящик слева весит $a_i$ тонн.

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

- Первые $k$ ящиков отправляются в первый грузовик,
- Вторые $k$ ящиков отправляются во второй грузовик,
- $\dotsb$
- Последние $k$ ящиков отправляются в $\frac{n}{k}$-й грузовик. После завершения загрузки в каждом грузовике должно быть ровно $k$ ящиков. Другими словами, если в какой-то момент невозможно загрузить ровно $k$ ящиков в грузовик, то вариант загрузки с этими $k$ невозможен.

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

У Алекс довольно много связей, поэтому для каждого $1 \leq k \leq n$ он может найти компанию, в которой каждый из ее грузовиков может вместить ровно $k$ коробок. Выведите максимальную абсолютную разницу между общим весом любых двух грузовиков.

Ввод

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число $n$ ($1 \leq n \leq 150\,000$) — количество коробок.

Вторая строка содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — вес коробок.

Гарантируется, что сумма $n$ для всех тестовых случаев не превысит $150\,000$.

Вывод

Для каждого тестового случая выведите одно целое число — ответ на задачу.Пример ввода 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

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

1
9
0
189114
112141

Примечание

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

Во втором случае мы должны выбрать шесть грузовиков, так что максимум будет $10$, минимум будет $1$, и ответ будет $10 - 1 = 9$.

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

Алекс участвует в съемках очередного видео BrMeast, и BrMeast попросил Алекса подготовить 250 тысяч тонн тротила, но Алекс его плохо расслышал, поэтому он подготовил $n$ ящиков и выстроил их в ряд в ожидании грузовиков. $i$-й ящик слева весит $a_i$ тонн.

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

- Первые $k$ ящиков отправляются в первый грузовик,
- Вторые $k$ ящиков отправляются во второй грузовик,
- $\dotsb$
- Последние $k$ ящиков отправляются в $\frac{n}{k}$-й грузовик. После завершения загрузки в каждом грузовике должно быть ровно $k$ ящиков. Другими словами, если в какой-то момент невозможно загрузить ровно $k$ ящиков в грузовик, то вариант загрузки с этими $k$ невозможен.

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

У Алекса довольно много связей, поэтому для каждого $1 \leq k \leq n$ он может найти компанию, в которой каждый из ее грузовиков может вместить ровно $k$ коробок. Выведите максимальную абсолютную разницу между общим весом любых двух грузовиков.

Ввод

Первая строка содержит одно целое число $t$ ($1 \leq t \leq 10^4$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число $n$ ($1 \leq n \leq 150\,000$) — количество коробок.

Вторая строка содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — вес коробок.

Гарантируется, что сумма $n$ для всех тестовых случаев не превысит $150\,000$.

Вывод

Для каждого тестового случая выведите одно целое число — ответ на задачу.Пример ввода 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

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

1
9
0
189114
112141

Примечание

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

Во втором случае мы должны выбрать шесть грузовиков, так что максимум будет $10$, минимум будет $1$, и ответ будет $10 - 1 = 9$.

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


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

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

Например, $[1, 2, 3]$ приемлемо, а $[1, 2, 4]$ — нет, так как $2$ и $4$ оба четные и смежные.

Вам нужно помочь Ярику, найдя максимальную сумму такого подмассива.

Ввод

Первая строка содержит целое число $t$ $(1 \le t \le 10^4)$ — количество тестовых случаев. Каждый тестовый случай описывается следующим образом.

Первая строка каждого тестового случая содержит целое число $n$ $(1 \le n \le 2 \cdot 10^5)$ — длину массива.

Вторая строка каждого тестового случая содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — элементы массива.

Гарантируется, что сумма $n$ для всех тестовых случаев не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового случая выведите одно целое число — ответ на задачу.Пример ввода 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

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

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

15
17
8
4
-1000
101
10

Подмассив это непрерывная часть массива.

Недавно Ярик нашёл массив $a$ из $n$ элементов и очень заинтересовался поиском максимальной суммы непустого подмассива. Однако Ярик не любит последовательные целые числа с одинаковой чётностью, поэтому выбранный им подмассив должен иметь чередующуюся чётность для соседних элементов.

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

Вам нужно помочь Ярику найти максимальную сумму такого подмассива.

Ввод

В первой строке записано целое число $t$ $(1 \le t \le 10^4)$ — количество тестовых случаев. Каждый тестовый пример описывается следующим образом.

Первая строка каждого набора входных данных содержит целое число $n$ $(1 \le n \le 2 \cdot 10^5)$ — длина массива.

Вторая строка каждого набора входных данных содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — элементы массива.

Гарантируется, что сумма $n$ для всех тестовых случаев не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового примера выведите одно целое число — ответ на задачу. Пример входных данных 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

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

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

15
17
8
4
-1000
101
10

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

Ярик недавно нашел массив $a$ из $n$ элементов и очень заинтересовался поиском максимальной суммы подмассива, который не пуст. Однако Ярик не любит последовательные числа с одинаковой четностью, поэтому подмассив, который он выбирает, должен иметь чередующуюся четность для соседних элементов.

Например, $[1, 2, 3]$ допустим, но $[1, 2, 4]$ нет, так как $2$ и $4$ оба четные и соседние.

Вам нужно помочь Ярику, найдя максимальную сумму такого подмассива.

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

Первая строка содержит целое число $t$ $(1 \le t \le 10^4)$ — количество тестов. Каждый тест описывается следующим образом.

Первая строка каждого теста содержит целое число $n$ $(1 \le n \le 2 \cdot 10^5)$ — длина массива.

Вторая строка каждого теста содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — элементы массива.

Гарантируется, что сумма $n$ для всех тестов не превышает $2 \cdot 10^5$.

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

Для каждого теста выведите одно целое число — ответ на задачу.


Ярик — большой поклонник многих видов музыки. Но Ярик любит не только слушать музыку, но и сочинять её. Больше всего он любит электронную музыку, поэтому создал собственную систему музыкальных нот, которая, по его мнению, лучше всего подходит для неё.

Поскольку Ярик также любит информатику, в его системе ноты обозначаются целыми числами вида $2^k$, где $k \ge 1$ — положительное целое число. Но, как известно, для написания музыки недостаточно использовать только ноты, поэтому Ярик использует комбинации из двух нот. Комбинацию двух нот $(a, b)$, где $a = 2^k$ и $b = 2^l$, он обозначает целым числом $a^b$.

Например, если $a = 8 = 2^3$, $b = 4 = 2^2$, то комбинация $(a, b)$ обозначается целым числом $a^b = 8^4 = 4096$. Обрати внимание, что разные комбинации могут иметь одинаковое обозначение, например, комбинация $(64, 2)$ также обозначается целым числом $4096 = 64^2$.

Ярик уже выбрал $n$ нот, которые хочет использовать в своей новой мелодии. Однако, поскольку их целые числа могут быть очень большими, он записал их в виде массива $a$ длиной $n$, и тогда нота $i$ равна $b_i = 2^{a_i}$. Целые числа в массиве $a$ могут повторяться.

Мелодия будет состоять из нескольких комбинаций двух нот. Ярик хочет узнать, сколько существует пар нот $b_i, b_j$ $(i < j)$, где комбинация $(b_i, b_j)$ равна комбинации $(b_j, b_i)$. Другими словами, он хочет подсчитать количество пар $(i, j)$ $(i < j)$, где $b_i^{b_j} = b_j^{b_i}$. Помоги ему найти количество таких пар.

Ввод

Первая строка ввода содержит одно целое число $t$ ($1 \le t \le 10^4$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число $n$ ($1 \leq n \leq 2 \cdot 10^5$) — длину массивов.

Следующая строка содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — массив $a$.

Сумма $n$ по всем тестовым случаям не превышает $2 \cdot 10^5$.

Вывод

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

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

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

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

0
2
1
3
19

Ярик большой поклонник разной музыки. Но Ярик любит не только слушать музыку, но и писать её. Больше всего ему нравится электронная музыка, поэтому он создал свою собственную систему нот, которая, по его мнению, лучше всего для этого подходит.

Поскольку Ярик тоже любит информатику, в его системе заметки обозначаются целыми числами $2^k$, where $k \ge 1$ — целое положительное число. Но, как известно, для написания музыки нельзя использовать только ноты, поэтому Ярик использует комбинации из двух нот. Комбинацию двух нот $a = 2^k$ and $b = 2^l$, он обозначает целым числом $a^b$.

Например, если $a = 8 = 2^3$, $b = 4 = 2^2$, то комбинация $(a, b)$ обозначается целым числом $a^b = 8^4 = 4096$. Обратите внимание, что разные комбинации могут иметь одинаковые обозначения, например, комбинация $(64, 2)$ также обозначается целым числом $4096 = 64^2$.

Ярик уже выбрал $n$ нот, которые хочет использовать в своей новой мелодии. Однако, поскольку их целые числа могут быть очень большими, он записал их в виде массива $a$ длины $n$, тогда запись $i$ is $b_i = 2^{a_i}$. Целые числа в массиве $a$ могут повторяться.

Мелодия будет состоять из нескольких комбинаций двух нот. Ярику было интересно, сколько существует пар нот $b_i, b_j$ $(i < j)$ таких, что комбинация $(b_i, b_j)$ равна комбинации $(b_j, b_i)$. Другими словами, он хочет посчитать количество пар $(i, j)$ $(i < j)$ таких, что $b_i^{b_j} = b_j^{b_i}$. Помогите ему найти количество таких пар.

Ввод

В первой строке входных данных содержится одно целое число $t$ ($1 \le t \le 10^4$) это количество тестовых случаев.

Первая строка каждого тестового примера содержит одно целое число $n$ ($1 \leq n \leq 2 \cdot 10^5$) это длину массивов.

В следующей строке записаны $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) это массив $a$.

Гарантируется, что сумма $n$ по всем тестам не превышает $2 \cdot 10^5$.

Вывод

Для каждого тестового примера выведите количество пар, удовлетворяющих заданному условию. Пример входных данных 1:
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

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

0
2
1
3
19

Ярик — большой поклонник многих видов музыки. Но Ярик любит не только слушать музыку, но и писать ее. Больше всего ему нравится электронная музыка, поэтому он создал свою собственную систему нот, которая, по его мнению, лучше всего подходит для нее.

Поскольку Ярик также любит информатику, в его системе ноты обозначаются целыми числами $2^k$, где $k \ge 1$ — положительное целое число. Но, как вы знаете, для записи музыки нельзя использовать только ноты, поэтому Ярик использует комбинации из двух нот. Комбинацию из двух нот $(a, b)$, где $a = 2^k$ и $b = 2^l$, он обозначает целым числом $a^b$.

Например, если $a = 8 = 2^3$, $b = 4 = 2^2$, то комбинация $(a, b)$ обозначается целым числом $a^b = 8^4 = 4096$. Обратите внимание, что разные комбинации могут иметь одинаковую нотацию, например, комбинация $(64, 2)$ также обозначается целым числом $4096 = 64^2$.

Ярик уже выбрал $n$ нот, которые он хочет использовать в своей новой мелодии. Однако, поскольку их целые числа могут быть очень большими, он записал их в виде массива $a$ длины $n$, тогда нота $i$ равна $b_i = 2^{a_i}$. Целые числа в массиве $a$ могут повторяться.

Мелодия будет состоять из нескольких комбинаций двух нот. Ярику было интересно, сколько пар нот $b_i, b_j$ $(i < j)$ существует таких, что комбинация $(b_i, b_j)$ равна комбинации $(b_j, b_i)$. Другими словами, он хочет посчитать количество пар $(i, j)$ $(i < j)$ таких, что $b_i^{b_j} = b_j^{b_i}$. Помогите ему найти количество таких пар.

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

Первая строка входных данных содержит одно целое число $t$ ($1 \le t \le 10^4$) — количество тестовых случаев.

Первая строка каждого тестового случая содержит одно целое число $n$ ($1 \leq n \leq 2 \cdot 10^5$) — длину массивов.

Следующая строка содержит $n$ целых чисел $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — массив $a$.

Гарантируется, что сумма $n$ по всем тестовым случаям не превысит $2 \cdot 10^5$.

Вывод

Для каждого тестового случая выведите количество пар, которые удовлетворяют заданному условию.Пример ввода 1:
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

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

0
2
1
3
19


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

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

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

Пример 1:

Вход: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Выход: 2
Объяснение: Пассажиры с индексами 0, 1 и 2 имеют возраст 75, 92 и 40. Таким образом, есть 2 человека, которым больше 60 лет.

Пример 2:

Вход: details = ["1313579440F2036","2921522980M5644"]
Выход: 0
Объяснение: Ни один из пассажиров не старше 60 лет.

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

1 <= details.length <= 100
details[i].length == 15
details[i] состоит из цифр от  '0' до '9'.
details[i][10] — это либо 'M', либо 'F', либо 'O'.
Номера телефонов и номера мест пассажиров различны.

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

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

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

Пример 1:

Вход: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Выход: 2
Объяснение: Пассажиры с индексами 0, 1 и 2 имеют возраст 75, 92 и 40 лет. Таким образом, есть 2 человека, которым больше 60 лет.

Пример 2:

Вход: details = ["1313579440F2036","2921522980M5644"]
Выход: 0
Объяснение: Ни один из пассажиров не старше 60 лет.

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

1 <= details.length <= 100
details[i].length == 15
details[i] состоит из цифр от '0' до '9'.
details[i][10] — это либо 'M', либо 'F', либо 'O'.
Номера телефонов и номера мест пассажиров различны.

Вам предоставляется массив данных о строках с 0-индексом. Каждый элемент реквизитов предоставляет информацию о данном пассажире, сжатую в строку длиной 15. Система такова, что:

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

Возвращает количество пассажиров строго старше 60 лет.

Пример 1:

Ввод: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Вывод: 2
Пояснение: Пассажиры с индексами 0, 1, и 2 имеют возраст 75, 92, и 40 лет. Таким образом, есть 2 человека старше 60 лет.

Пример 2:

Ввод: details = ["1313579440F2036","2921522980M5644"]
Вывод: 0
Пояснение: Никто из пассажиров не старше 60 лет.

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

1 <= details.length <= 100
details[i].length == 15
details[i] состоит из цифр от '0' до '9'.
details[i][10] это либо 'M' или 'F' или 'O'.
Номера телефонов и места пассажиров различаются.


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

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

Верните итоговый счет.

Пример 1:

Ввод: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Вывод: 15
Объяснение: В первой операции мы удаляем 7, 6, 6 и 3. Затем добавляем 7 к нашему счету. Затем мы удаляем 2, 4, 5 и 2. Мы добавляем 5 к нашему счету. Наконец, мы удаляем 1, 2, 3 и 1. Мы добавляем 3 к нашему счету. Таким образом, наш итоговый счет равен 7 + 5 + 3 = 15.

Пример 2:

Ввод: nums = [[1]]
Вывод: 1
Объяснение: Мы удаляем 1 и добавляем его к ответу. Мы возвращаем 1.

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

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3

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

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

Верните окончательный счет.

Пример 1:

Вход: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Выход: 15
Пояснение: в первой операции мы удаляем 7, 6, 6 и 3. Затем мы добавляем 7 к нашему счету. Затем мы удаляем 2, 4, 5 и 2. Мы добавляем 5 к нашему счету. Наконец, мы удаляем 1, 2, 3 и 1. Мы добавляем 3 к нашему счету. Таким образом, наш окончательный счет: 7 + 5 + 3 = 15.

Пример 2:

Вход: nums = [[1]]
Выход: 1
Пояснение: Мы удаляем 1 и добавляем его к ответу. Мы возвращаем 1.

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

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3


Вам дан 0-индексированный целочисленный массив nums длины n и целое число k. В операции вы можете выбрать элемент и умножить его на 2.
Вернуть максимально возможное значение nums[0] | nums[1] | ... | nums[n - 1], которое может быть получено после применения операции к nums не более k раз.
Обратите внимание, что a | b обозначает побитовое ИЛИ между двумя целыми числами a и b.

Пример 1:

Вход: nums = [12,9], k = 1
Выход: 30
Объяснение: Если мы применим операцию к индексу 1, наш новый массив nums будет равен [12,18]. Таким образом, мы возвращаем побитовое ИЛИ 12 и 18, что равно 30.

Пример 2:

Вход: nums = [8,1,2], k = 2
Выход: 35
Пояснение: Если мы дважды применим операцию к индексу 0, мы получим новый массив [32,1,2]. Таким образом, мы возвращаем 32|1|2 = 35.

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

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

Дан целочисленный массив nums с индексами от 0 длины n и целое число k. В одной операции вы можете выбрать элемент и умножить его на 2.
Возвращает максимальное возможное значение nums[0] | nums[1] | ... | nums[n - 1], которое можно получить после применения операции к элементам массива nums не более k раз.
Обратите внимание, что a | b обозначает побитовое или между двумя целыми числами a и b.

Пример 1:

Ввод: nums = [12,9], k = 1
Вывод: 30
Пояснение: Если мы применим операцию к индексу 1, то новый массив nums будет равен [12,18]. Таким образом, мы возвращаем побитовое или 12 и 18, что равно 30.

Пример 2:

Ввод: nums = [8,1,2], k = 2
Вывод: 35
Пояснение: Если мы применим операцию дважды к индексу 0, мы получим новый массив [32,1,2]. Таким образом, мы возвращаем 32|1|2 = 35.

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

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

Вам дан целочисленный массив nums с нулевым индексом длины n и целое число k. В операции вы можете выбрать элемент и умножить его на 2.
Вернуть максимально возможное значение nums[0] | nums[1] | ... | nums[n - 1], которое можно получить после применения операции к nums не более k раз.
Обратите внимание, что a | b обозначает поразрядное число или между двумя целыми числами a и b.

Пример 1:

Ввод: nums = [12,9], k = 1
Вывод: 30
Пояснение: Если мы применим операцию к индексу 1, числа нашего нового массива будут равны [12,18]. Таким образом, мы возвращаем побитовое или 12 и 18, что равно 30.

Пример 2:

Ввод: nums = [8,1,2], k = 2
Выход: 35
Объяснение: Если мы дважды применим операцию к индексу 0, мы получим новый массив [32,1,2]. Таким образом, мы возвращаем 32|1|2 = 35.

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

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


Вам дан 0-индексированный целочисленный массив nums, представляющий оценки студентов за экзамен. Учитель хотел бы сформировать одну непустую группу студентов с максимальной силой, где сила группы студентов с индексами i_0, i_1, i_2, ... , i_k определяется как nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Верните максимальную силу группы, которую учитель может создать.

Пример 1:

Ввод: nums = [3,-1,-5,2,5,-9]
Вывод: 1350
Пояснение: Один из способов сформировать группу с максимальной силой — это объединить студентов с индексами [0,2,3,4,5]. Их сила равна 3 * (-5) * 2 * 5 * (-9) = 1350, что, как можно показать, является оптимальным.

Пример 2:

Ввод: nums = [-4,-5,-4]
Вывод: 20
Пояснение: Объедините студентов с индексами [0, 1]. Тогда их сила будет равна 20. Мы не можем достичь большей силы.

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

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Вам дан целочисленный массив nums с индексом 0, представляющий баллы студентов на экзамене. Преподаватель хотел бы сформировать одну непустую группу студентов с максимальной силой, где сила группы студентов с индексами i_0, i_1, i_2, ... , i_k определяется как nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Вернуть максимальную силу группы, которую может создать преподаватель.

Пример 1:

Входные данные: nums = [3,-1,-5,2,5,-9]
Выходные данные: 1350
Пояснение: Один из способов сформировать группу максимальной силы — сгруппировать студентов по индексам [0,2,3,4,5]. Их сила равна 3 * (-5) * 2 * 5 * (-9) = 1350, что, как мы можем показать, является оптимальным.

Пример 2:

Вход: nums = [-4,-5,-4]
Выход: 20
Объяснение: Группируем студентов по индексам [0, 1]. Тогда у нас будет результирующая сила 20. Большей силы достичь нельзя.

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

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Вам дано множество целых чисел с нумерацией с нуля, представляющее собой баллы студентов на экзамене. Учителю нужно сформировать одну непустую группу студентов максимальной насыщенности, где индексы последней i_0, i_1, i_2, ... , i_k определяются как nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Восстановите максимальную насыщенность группы, которую может создать учитель.

Пример 1:

Input: nums = [3,-1,-5,2,5,-9]
Output: 1350
Explanation: One way to form a group of maximal strength is to group the students at indices [0,2,3,4,5]. Their strength is 3 * (-5) * 2 * 5 * (-9) = 1350, which we can show is optimal.

Пример 2:

Input: nums = [-4,-5,-4]
Output: 20
Explanation: Group the students at indices [0, 1] . Then, we’ll have a resulting strength of 20. We cannot achieve greater strength.

Constraints:

1 <= nums.length <= 13
-9 <= nums[i] <= 9


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

Пример 1:

Ввод: s = "leetscode", dictionary = ["leet","code","leetcode"]
Вывод: 1
Объяснение: Мы можем разбить s на две подстроки: "leet" с индекса 0 до 3 и "code" с индекса 5 до 8. Есть только 1 неиспользуемый символ (на индексе 4), поэтому возвращаем 1.

Пример 2:

Ввод: s = "sayhelloworld", dictionary = ["hello","world"]
Вывод: 3
Объяснение: Мы можем разбить s на две подстроки: "hello" с индекса 3 до 7 и "world" с индекса 8 до 12. Символы на индексах 0, 1, 2 не используются ни в одной подстроке и поэтому считаются лишними символами. Следовательно, возвращаем 3.

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

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

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

Пример 1:

Ввод: s = "leetscode", dictionary = ["leet","code","leetcode"]
Вывод: 1
Объяснение: Мы можем разбить s на две подстроки: "leet" с индексом от 0 до 3 и "code" с индексом от 5 до 8. Существует только 1 неиспользуемый символ (по индексу 4), поэтому мы возвращаем 1.

Пример 2:

Ввод: s = "sayhelloworld", dictionary = ["hello","world"]
Вывод: 3
Объяснение: Мы можем разбить s на две подстроки: "hello" с индексом 3 по 7 и "world" с индексом 8 по 12. Символы с индексами 0, 1, 2 не используются ни в одной подстроке и поэтому считаются дополнительными символами. Следовательно, мы возвращаем 3.

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

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

Дана строка строка s с индексом 0 и словарь слов dictionary. Необходимо разбить s на одну или более непересекающихся подстрок так, чтобы каждая подстрока содержалась в dictionary. В строке s могут быть лишние символы, которые не входят ни в одну из подстрок.
Верни минимальное количество лишних символов, оставшихся после оптимального разбиения s.

Пример 1:

Ввод: s = "leetscode", dictionary = ["leet","code","leetcode"]
Вывод: 1
Пояснение: Можно разбить s на две подстроки: "leet" с индекса 0 до индекса 3 и "code" с индекса 5 до индекса 8. Есть только 1 неиспользуемый символ (с индексом 4), поэтому возвращаем 1.

Пример 2:

Ввод: s = "sayhelloworld", dictionary = ["hello","world"]
Вывод: 3
Пояснение: Можно разбить s на две подстроки: "hello" с индекса 3 до индекса 7 и "world" с индекса 8 до индекса 12. Символы с индексами 0, 1, 2 не используются ни в одной подстроке и поэтому считаются лишними. Следовательно, возвращаем 3.

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

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


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

Пример 1:

Входные данные: prices = [1,2,2], money = 3
Выходные данные: 0
Объяснение: Купите шоколадки по цене 1 и 2 единицы соответственно. После этого у вас останется 3 - 3 = 0 единиц денег. Таким образом, мы возвращаем 0.

Пример 2:

Вход: prices = [3,2,3], money = 3
Выход: 3
Объяснение: вы не можете купить 2 шоколадки, не влезая в долги, поэтому мы возвращаем 3.

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

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100

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

Пример 1:

Ввод: prices = [1,2,2], money = 3
Вывод: 0
Объяснение: Купите шоколадки по цене 1 и 2 единицы соответственно. У вас останется 3 - 3 = 0 единиц денег. Таким образом, мы возвращаем 0.

Пример 2:

Ввод: prices = [3,2,3], money = 3
Вывод: 3
Объяснение: Нельзя купить 2 шоколадки, не оказавшись в долгу, поэтому возвращаем 3.

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

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100

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

Пример 1:

Входные данные: prices = [1,2,2], money = 3
Выходные данные: 0
Объяснение: Купите шоколадки по цене 1 и 2 единицы соответственно. После этого у вас останется 3 - 3 = 0 единиц денег. Таким образом, мы возвращаем 0.

Пример 2:

Вход: prices = [3,2,3], money = 3
Выход: 3
Пояснение: вы не можете купить 2 шоколадки, не влезая в долги, поэтому мы возвращаем 3.

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

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100


Даны две числовые строки num1 и num2 и два целых числа max_sum и min_sum. Мы называем целое число x хорошим, если:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

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

Пример 1:

Ввод: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Вывод: 11
Объяснение: Существует 11 чисел, сумма цифр которых находится между 1 и 8: 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 и 12. Таким образом, мы возвращаем 11.

Пример 2:

Ввод: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Вывод: 5
Объяснение: 5 чисел, сумма цифр которых находится между 1 и 5: 1, 2, 3, 4 и 5. Таким образом, мы возвращаем 5.

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

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

Вам даны две числовые строки num1 и num2 и два целых числа max_sum и min_sum. Мы обозначаем целое число x как хорошее, если:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

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

Пример 1:

Вход: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Выход: 11
Пояснение: есть 11 целых чисел, сумма цифр которых лежит между 1 и 8: 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 и 12. Таким образом, мы возвращаем 11.

Пример 2:

Вход: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Выход: 5
Пояснение: 5 целых чисел, сумма цифр которых лежит между 1 и 5: 1, 2, 3, 4 и 5. Таким образом, мы возвращаем 5.

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

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400


У вас есть массив с нулевой индексацией `nums` длины `n`.
Массив отличий distinct difference массива `nums` - это массив `diff` длины `n`, такой, что `diff[i]` равен количеству уникальных элементов в суффиксе `nums[i + 1, ..., n - 1]`, вычтенному из количества уникальных элементов в префиксе `nums[0, ..., i]`.
Верните массив отличий distinct difference массива `nums`.
Отметим, что `nums[i, ..., j]` обозначает подмассив `nums`, начинающийся с индекса `i` и заканчивающийся индексом `j` включительно. В частности, если `i > j`, то `nums[i, ..., j]` обозначает пустой подмассив.

Пример 1:

Ввод: nums = [1,2,3,4,5]
Вывод: [-3,-1,1,3,5]
Объяснение: Для индекса `i = 0`, в префиксе 1 элемент и 4 уникальных элемента в суффиксе. Следовательно, `diff[0] = 1 - 4 = -3`.
Для индекса `i = 1`, в префиксе 2 уникальных элемента и 3 уникальных элемента в суффиксе. Следовательно, `diff[1] = 2 - 3 = -1`.
Для индекса `i = 2`, в префиксе 3 уникальных элемента и 2 уникальных элемента в суффиксе. Следовательно, `diff[2] = 3 - 2 = 1`.
Для индекса `i = 3`, в префиксе 4 уникальных элемента и 1 уникальный элемент в суффиксе. Следовательно, `diff[3] = 4 - 1 = 3`.
Для индекса `i = 4`, в префиксе 5 уникальных элементов и нет элементов в суффиксе. Следовательно, `diff[4] = 5 - 0 = 5`.

Пример 2:

Ввод: nums = [3,2,3,4,2]
Вывод: [-2,-1,0,2,3]
Объяснение: Для индекса `i = 0`, в префиксе 1 элемент и 3 уникальных элемента в суффиксе. Следовательно, `diff[0] = 1 - 3 = -2`.
Для индекса `i = 1`, в префиксе 2 уникальных элемента и 3 уникальных элемента в суффиксе. Следовательно, `diff[1] = 2 - 3 = -1`.
Для индекса `i = 2`, в префиксе 2 уникальных элемента и 2 уникальных элемента в суффиксе. Следовательно, `diff[2] = 2 - 2 = 0`.
Для индекса `i = 3`, в префиксе 3 уникальных элемента и 1 уникальный элемент в суффиксе. Следовательно, `diff[3] = 3 - 1 = 2`.
Для индекса `i = 4`, в префиксе 3 уникальных элемента и нет элементов в суффиксе. Следовательно, `diff[4] = 3 - 0 = 3`.

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

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

Вам дан 0-индексированный массив nums длины n.
Массив различных разностей nums — это массив diff длины n, такой что diff[i] равен количеству различных элементов в суффиксе nums[i + 1, ..., n - 1], вычтенному из количества различных элементов в префиксе nums[0, ..., i].
Верните массив различных разностей nums.
Обратите внимание, что nums[i, ..., j] обозначает подмассив nums, начинающийся с индекса i и заканчивающийся индексом j включительно. В частности, если i > j, то nums[i, ..., j] обозначает пустой подмассив.

Пример 1:

Вход: nums = [1,2,3,4,5]
Выход: [-3,-1,1,3,5]
Пояснение: Для индекса i = 0 в префиксе 1 элемент, а в суффиксе — 4 различных элемента. Таким образом, diff[0] = 1 - 4 = -3.
Для индекса i = 1 в префиксе 2 различных элемента, а в суффиксе — 3 различных элемента. Таким образом, diff[1] = 2 - 3 = -1.
Для индекса i = 2 в префиксе 3 различных элемента, а в суффиксе — 2 различных элемента. Таким образом, diff[2] = 3 - 2 = 1.
Для индекса i = 3 в префиксе 4 различных элемента, а в суффиксе — 1 отдельный элемент. Таким образом, diff[3] = 4 - 1 = 3.
Для индекса i = 4 в префиксе 5 различных элементов, а в суффиксе нет. Таким образом, diff[4] = 5 - 0 = 5.

Пример 2:

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

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

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


Дан 0-индексированный массив nums длиной n. Изначально все элементы не окрашены (имеют значение 0).
Дан двумерный целочисленный массив queries, где queries[i] = [index_i, color_i].
Для каждого запроса индекс index_i окрашивается цветом color_i в массиве nums.
Верни массив answer той же длины, что и queries, где answer[i] — количество соседних элементов с тем же цветом после i-го запроса.
Answer[i] — количество индексов j, где 0 <= j < n - 1 и nums[j] == nums[j + 1] и nums[j] != 0 после i-го запроса.

Пример 1:

Ввод: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Вывод: [0,1,1,0,2]
Пояснение: Изначально массив nums = [0,0,0,0], где 0 обозначает неокрашенные элементы массива.
- После 1-го запроса nums = [2,0,0,0]. Количество соседних элементов с тем же цветом — 0.
- После 2-го запроса nums = [2,2,0,0]. Количество соседних элементов с тем же цветом — 1.
- После 3-го запроса nums = [2,2,0,1]. Количество соседних элементов с тем же цветом — 1.
- После 4-го запроса nums = [2,1,0,1]. Количество соседних элементов с тем же цветом — 0.
- После 5-го запроса nums = [2,1,1,1]. Количество соседних элементов с тем же цветом — 2.

Пример 2:

Ввод: n = 1, queries = [[0,100000]]
Вывод: [0]
Пояснение: Изначально массив nums = [0], где 0 обозначает неокрашенные элементы массива.
- После 1-го запроса nums = [100000]. Количество соседних элементов с тем же цветом — 0.

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

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5

Дан массив nums с 0-индексацией длины n. Изначально все элементы не окрашены (имеют значение 0).
Вам предоставлен двумерный целочисленный массив queries, где queries[i] = [index_i, color_i].
Для каждого запроса вы окрашиваете индекс index_i цветом color_i в массиве nums.
Верните массив answer той же длины, что и queries, где answer[i] — это количество соседних элементов с тем же цветом после i-го запроса.
Более формально, answer[i] — это количество индексов j, таких что 0 <= j < n - 1 и nums[j] == nums[j + 1] и nums[j] != 0 после i-го запроса.

Пример 1:

Ввод: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Вывод: [0,1,1,0,2]
Объяснение: Изначально массив nums = [0,0,0,0], где 0 обозначает неокрашенные элементы массива.
- После 1-го запроса nums = [2,0,0,0]. Количество соседних элементов с тем же цветом — 0.
- После 2-го запроса nums = [2,2,0,0]. Количество соседних элементов с тем же цветом — 1.
- После 3-го запроса nums = [2,2,0,1]. Количество соседних элементов с тем же цветом — 1.
- После 4-го запроса nums = [2,1,0,1]. Количество соседних элементов с тем же цветом — 0.
- После 5-го запроса nums = [2,1,1,1]. Количество соседних элементов с тем же цветом — 2.

Пример 2:

Ввод: n = 1, queries = [[0,100000]]
Вывод: [0]
Объяснение: Изначально массив nums = [0], где 0 обозначает неокрашенные элементы массива.
- После 1-го запроса nums = [100000]. Количество соседних элементов с тем же цветом — 0.

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

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5


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

Пусть i_0, i_1, ... ,i_k — индексы героев в группе. Тогда мощность этой группы равна max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

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

Пример 1:

Ввод: nums = [2,1,4]
Вывод: 141
Пояснение:
1-я группа: [2] имеет мощность = 2^2 * 2 = 8.
2-я группа: [1] имеет мощность = 1^2 * 1 = 1.
3-я группа: [4] имеет мощность = 4^2 * 4 = 64.
4-я группа: [2,1] имеет мощность = 2^2 * 1 = 4.
5-я группа: [2,4] имеет мощность = 4^2 * 2 = 32.
6-я группа: [1,4] имеет мощность = 4^2 * 1 = 16.
7-я группа: [2,1,4] имеет мощность = 4^2 * 1 = 16.
Сумма мощностей всех групп составляет 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Пример 2:

Ввод: nums = [1,1,1]
Вывод: 7
Пояснение: Всего возможно 7 групп, и мощность каждой группы будет равна 1. Следовательно, сумма мощностей всех групп равна 7.

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

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


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

Выберите два соседних элемента в nums, затем поменяйте их местами.

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

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

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums является перестановкой.

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

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

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

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums это перестановка.


Дана строка s с 0-индексацией, состоящая из цифр от 0 до 9.
Строка t называется полуповторяющейся, если в ней есть не более одной последовательной пары одинаковых цифр. Например, 0010, 002020, 0123, 2002 и 54944 являются полуповторяющимися, в то время как 00101022 и 1101234883 — нет.
Возвращает длину самой длинной полуповторяющейся подстроки внутри s.
Подстрока — это непрерывная непустая последовательность символов внутри строки.

Пример 1:

Ввод: s = "52233"
Вывод: 4
Пояснение: Самая длинная полуповторяющаяся подстрока — "5223", которая начинается с i = 0 и заканчивается на j = 3.

Пример 2:

Ввод: s = "5494"
Вывод: 4
Пояснение: s является полуповторяющейся строкой, так что ответ — 4.

Пример 3:

Ввод: s = "1111111"
Вывод: 2
Пояснение: Самая длинная полуповторяющаяся подстрока — "11", которая начинается с i = 0 и заканчивается на j = 1.

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

1 <= s.length <= 50
'0' <= s[i] <= '9'


В игру играют n друзей. Друзья сидят в кругу и пронумерованы от 1 до n по часовой стрелке. Более формально, движение по часовой стрелке от i^th друга приводит вас к (i+1)^th другу для 1 <= i < n, а движение по часовой стрелке от n^th друга приводит вас к 1^st другу.
Правила игры следующие:
1^st друг получает мяч.

После этого 1^st друг передает его другу, который находится в k шагах от него по часовой стрелке.
После этого друг, который получил мяч, должен передать его другу, который находится в 2 * k шагах от него по часовой стрелке.
После этого друг, который получил мяч, должен передать его другу, который находится в 3 * k шагах от него по часовой стрелке, и так далее и тому подобное.

Другими словами, на i-м ходу друг, держащий мяч, должен передать его другу, который находится в i * k шагах от него по часовой стрелке.
Игра заканчивается, когда какой-либо друг получает мяч во второй раз.
Проигравшими в игре считаются друзья, которые не получали мяч за всю игру.
Знав количество друзей n и целое число k, верните массив ответов, который содержит проигравших в игре в порядке возрастания.

Пример 1:

Вход: n = 5, k = 2
Выход: [4,5]
Пояснение: Игра проходит следующим образом:
1) Начинается с 1-го друга и передает мяч другу, который находится в 2 шагах от него — 3-му другу.
2) 3-й друг передает мяч другу, который находится в 4 шагах от него — 2-му другу.
3) 2-й друг передает мяч другу, который находится в 6 шагах от него — 3-му другу.
4) Игра заканчивается, когда 3-й друг получает мяч во второй раз.

Пример 2:

Вход: n = 4, k = 4
Выход: [2,3,4]
Объяснение: Игра идет следующим образом:
1) Начните с 1-го друга и передайте мяч другу, который находится в 4 шагах от него - 1-му другу.
2) Игра заканчивается, когда 1-й друг получает мяч во второй раз.

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

1 <= k <= n <= 50

У n друзей, играющих в игру. Друзья сидят по кругу и пронумерованы от 1 до n по часовой стрелке. Формально, движение по часовой стрелке от i-го друга ведет к (i+1)-му другу для 1 <= i < n, а движение по часовой стрелке от n-го друга ведет к 1-му другу.
Правила игры следующие:
1-й друг получает мяч.

После этого 1-й друг передает мяч другу, который находится на k шагов от него по часовой стрелке.
После этого друг, получивший мяч, должен передать его другу, который находится на 2 * k шагов от него по часовой стрелке.
После этого друг, получивший мяч, должен передать его другу, который находится на 3 * k шагов от него по часовой стрелке, и так далее.

Другими словами, на i-ом ходу друг, держащий мяч, должен передать его другу, который находится на i * k шагов от него по часовой стрелке.
Игра заканчивается, когда какой-то друг получает мяч второй раз.
Проигравшие игры - друзья, которые ни разу не получили мяч за всю игру.
Дано количество друзей n и целое число k, вернуть массив answer, содержащий проигравших игры в порядке возрастания.

Пример 1:

Input: n = 5, k = 2
Output: [4,5]
Explanation: Игра проходит следующим образом:
1) Начинаем с 1-го друга и передаем мяч другу, который находится на 2 шага от него - 3-й друг.
2) 3-й друг передает мяч другу, который находится на 4 шага от него - 2-й друг.
3) 2-й друг передает мяч другу, который находится на 6 шагов от него - 3-й друг.
4) Игра заканчивается, так как 3-й друг получает мяч второй раз.

Пример 2:

Input: n = 4, k = 4
Output: [2,3,4]
Explanation: Игра проходит следующим образом:
1) Начинаем с 1-го друга и передаем мяч другу, который находится на 4 шага от него - 1-й друг.
2) Игра заканчивается, так как 1-й друг получает мяч второй раз.

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

1 <= k <= n <= 50

У n друзей, играющих в игру. Друзья сидят по кругу и пронумерованы от 1 до n по часовой стрелке. Формально, движение по часовой стрелке от i-го друга ведет к (i+1)-му другу для 1 <= i < n, а движение по часовой стрелке от n-го друга ведет к 1-му другу.
Правила игры следующие:
1-й друг получает мяч.

После этого 1-й друг передает мяч другу, который находится на k шагов от него по часовой стрелке.
После этого друг, получивший мяч, должен передать его другу, который находится на 2 * k шагов от него по часовой стрелке.
После этого друг, получивший мяч, должен передать его другу, который находится на 3 * k шагов от него по часовой стрелке, и так далее.

Другими словами, на i-ом ходу друг, держащий мяч, должен передать его другу, который находится на i * k шагов от него по часовой стрелке.
Игра заканчивается, когда какой-то друг получает мяч второй раз.
Проигравшие игры - друзья, которые ни разу не получили мяч за всю игру.
Дано количество друзей n и целое число k, вернуть массив answer, содержащий проигравших игры в порядке возрастания.

Пример 1:

Ввод: n = 5, k = 2
Вывод: [4,5]
Объяснение: Игра проходит следующим образом:
1) Начинаем с 1-го друга и передаем мяч другу, который находится на 2 шага от него - 3-й друг.
2) 3-й друг передает мяч другу, который находится на 4 шага от него - 2-й друг.
3) 2-й друг передает мяч другу, который находится на 6 шагов от него - 3-й друг.
4) Игра заканчивается, так как 3-й друг получает мяч второй раз.

Пример 2:

Ввод: n = 4, k = 4
Вывод: [2,3,4]
Объяснение: Игра проходит следующим образом:
1) Начинаем с 1-го друга и передаем мяч другу, который находится на 4 шага от него - 1-й друг.
2) Игра заканчивается, так как 1-й друг получает мяч второй раз.

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

1 <= k <= n <= 50


Массив derived с индексами, начинающимися с 0, длиной n получается поэлементным побитовым XOR (⊕) значений соседних элементов в бинарном массиве original длиной n.
Конкретно, для каждого индекса i в диапазоне [0, n - 1]:

Если i = n - 1, то derived[i] = original[i] ⊕ original[0].
Иначе, derived[i] = original[i] ⊕ original[i + 1].

Дан массив derived. Ваша задача — определить, существует ли валидный бинарный массив original, который мог бы образовать derived.
Верните true, если такой массив существует, или false в противном случае.

Бинарный массив — это массив, содержащий только 0 и 1.

Пример 1:

Ввод: derived = [1,1,0]
Вывод: true
Объяснение: Валидный массив original, который дает derived, равен [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Пример 2:

Ввод: derived = [1,1]
Вывод: true
Объяснение: Валидный массив original, который дает derived, равен [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Пример 3:

Ввод: derived = [1,0]
Вывод: false
Объяснение: Не существует валидного массива original, который дает derived.

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

n == derived.length
1 <= n <= 10^5
Значения в derived — это либо 0, либо 1.

Массив derived с индексами, начинающимися с 0, длиной n получается поэлементным побитовым XOR (⊕) значений соседних элементов в бинарном массиве original длиной n.
Конкретно, для каждого индекса i в диапазоне [0, n - 1]:

Если i = n - 1, то derived[i] = original[i] ⊕ original[0].
Иначе, derived[i] = original[i] ⊕ original[i + 1].

Дан массив derived. Ваша задача — определить, существует ли валидный бинарный массив original, который мог бы образовать derived.
Верните true, если такой массив существует, или false в противном случае.

Бинарный массив — это массив, содержащий только 0 и 1.

Пример 1:

Input: derived = [1,1,0]
Output: true
Explanation: Валидный массив original, который дает derived, равен [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Пример 2:

Input: derived = [1,1]
Output: true
Explanation: Валидный массив original, который дает derived, равен [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Пример 3:

Input: derived = [1,0]
Output: false
Explanation: Не существует валидного массива original, который дает derived.

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

n == derived.length
1 <= n <= 10^5
Значения в derived — это либо 0, либо 1.

0-индексированный массив derived с длиной n получается путем вычисления побитового XOR (⊕) смежных значений в двоичном массиве original длины n.
В частности, для каждого индекса i в диапазоне [0, n - 1]:

Если i = n - 1, то derived[i] = original[i] ⊕ original[0].
В противном случае derived[i] = original[i] ⊕ original[i + 1].

Для заданного массива derived ваша задача — определить, существует ли допустимый двоичный массив original, который мог бы образовать derived.
Верните true, если такой массив существует, или false в противном случае.

Двоичный массив — это массив, содержащий только 0 и 1

Пример 1:

Вход: derived = [1,1,0]
Выход: true
Объяснение: допустимый исходный массив, который дает derived, — это [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Пример 2:

Вход: derived = [1,1]
Выход: true
Пояснение: допустимый исходный массив, который дает derived, — это [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Пример 3:

Вход: derived = [1,0]
Выход: false
Пояснение: допустимого исходного массива, который дает derived, не существует.

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

n == derived.length
1 <= n <= 10^5
Значения в derived — это либо 0, либо 1


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

Пример 1:

Input: s = "ABFCACDB"
Output: 2
Explanation: Мы можем выполнить следующие операции:
- Удалить подстроку "ABFCACDB", так что s = "FCACDB".
- Удалить подстроку "FCACDB", так что s = "FCAB".
- Удалить подстроку "FCAB", так что s = "FC".
Таким образом, результирующая длина строки равна 2.
Можно показать, что это минимальная длина, которую мы можем получить.

Пример 2:

Input: s = "ACBBD"
Output: 5
Explanation: Мы не можем выполнить никакие операции над строкой, поэтому длина остается прежней.

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

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

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

Пример 1:

Ввод: s = "ABFCACDB"
Выход: 2
Пояснение: Мы можем выполнять следующие операции:
- Удалите подстроку "ABFCACDB", чтобы s = "FCACDB".
- Удалите подстроку "FCACDB", чтобы s = "FCAB".
- Удалите подстроку "FCAB", чтобы s = "FC".
Таким образом, результирующая длина строки равна 2.
Можно показать, что это минимальная длина, которую мы можем получить.
Пример 2:

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

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

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

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

Пример 1:

Ввод: s = "ABFCACDB"
Вывод: 2
Объяснение: We can do the following operations:
- Удалить подстроку "ABFCACDB", так что s = "FCACDB".
- Удалить подстроку "FCACDB", так что s = "FCAB".
- Удалить подстроку "FCAB", так что s = "FC".
Таким образом, результирующая длина строки равна 2.
Можно показать, что это минимальная длина, которую мы можем получить.
Пример 2:

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

Constraints:

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


Дано положительное целое число n, вернуть наказательное число n.
Наказательное число n определяется как сумма квадратов всех целых чисел i, таких что:

1 <= i <= n
Десятичное представление i * i может быть разделено на смежные подстроки так, что сумма значений этих подстрок равна i.

Пример 1:

Ввод: n = 10
Вывод: 182
Объяснение: Существует ровно 3 целых числа i, которые удовлетворяют условиям в утверждении:
- 1, поскольку 1 * 1 = 1
- 9, поскольку 9 * 9 = 81 и 81 можно разделить на 8 + 1.
- 10, поскольку 10 * 10 = 100 и 100 можно разделить на 10 + 0.
Следовательно, наказательное число 10 равно 1 + 81 + 100 = 182

Пример 2:

Ввод: n = 37
Вывод: 1478
Объяснение: Существует ровно 4 целых числа i, которые удовлетворяют условиям в утверждении:
- 1, поскольку 1 * 1 = 1.
- 9, поскольку 9 * 9 = 81 и 81 можно разделить на 8 + 1.
- 10, поскольку 10 * 10 = 100 и 100 можно разделить на 10 + 0.
- 36, поскольку 36 * 36 = 1296 и 1296 можно разделить на 1 + 29 + 6.
Следовательно, наказательное число 37 равно 1 + 81 + 100 + 1296 = 1478

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

1 <= n <= 1000

Учитывая положительное целое число n, верните количество наказаний n.
Число наказания n определяется как сумма квадратов всех целых чисел i таких, что:

1 <= i <= n
Десятичное представление i * i можно разделить на смежные подстроки так, что сумма целых значений этих подстрок равна i.

Пример 1:

Ввод: n = 10
Вывод: 182
Пояснение: Существует ровно 3 целых числа i, удовлетворяющих условиям утверждения:
- 1, так как 1 * 1 = 1
- 9, так как 9 * 9 = 81 и 81 можно разделить на 8 + 1.
- 10, так как 10 * 10 = 100 и 100 можно разделить на 10 + 0.
Следовательно, число наказания 10 равно 1 + 81 + 100 = 182

Пример 2:

Ввод: n = 37
Вывод: 1478
Пояснение: Существует ровно 4 целых числа i, удовлетворяющих условиям утверждения:
- 1, так как 1 * 1 = 1.
- 9, так как 9 * 9 = 81 и 81 можно разделить на 8 + 1.
- 10, так как 10 * 10 = 100 и 100 можно разделить на 10 + 0.
- 36, так как 36 * 36 = 1296, а 1296 можно разделить на 1 + 29 + 6.
Следовательно, число наказания 37 равно 1 + 81 + 100 + 1296 = 1478

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

1 <= n <= 1000


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

Платный маляр, который красит i-ю стену за time[i] единиц времени и берет cost[i] единиц денег.
Бесплатный маляр, который красит любую стену за 1 единицу времени и бесплатно. Но бесплатный маляр может быть использован только если платный маляр уже занят.

Верните минимальную сумму денег, необходимую для покраски n стен.

Пример 1:

Ввод: cost = [1,2,3,2], time = [1,2,3,2]
Вывод: 3
Объяснение: Стены с индексами 0 и 1 будут покрашены платным маляром, и это займет 3 единицы времени; в это время бесплатный маляр покрасит стены с индексами 2 и 3, бесплатно, за 2 единицы времени. Таким образом, общая стоимость составляет 1 + 2 = 3.

Пример 2:

Ввод: cost = [2,3,4,2], time = [1,1,1,1]
Вывод: 4
Объяснение: Стены с индексами 0 и 3 будут покрашены платным маляром, и это займет 2 единицы времени; в это время бесплатный маляр покрасит стены с индексами 1 и 2, бесплатно, за 2 единицы времени. Таким образом, общая стоимость составляет 2 + 2 = 4.

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

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

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

Оплачиваемый маляр, который красит i^ю стену за time[i] единиц и тратит на это cost[i] единиц.
Бесплатный маляр, который красит любую стену за 1 единицу времени по цене 0. Но бесплатного маляра можно использовать только в том случае, если платный маляр уже занят.

Верните минимальную сумму денег, необходимую для покраски n стен.

Пример 1:

Ввод: cost = [1,2,3,2], time = [1,2,3,2]
Вывод: 3
Пояснение: Стены с индексами 0 и 1 будут покрашены оплачиваемым маляром, и это займет 3 единицы времени; тем временем свободный маляр бесплатно покрасит стены с индексами 2 и 3, за 2 единицы времени. Таким образом, общая стоимость равна 1 + 2 = 3.

Пример 2:

Ввод: cost = [2,3,4,2], time = [1,1,1,1]
Вывод: 4
Пояснение: Стены с индексами 0 и 3 будут покрашены оплачиваемым маляром, и это займет 2 единицы времени; тем временем свободный маляр бесплатно покрасит стены с индексами 1 и 2, за 2 единицы времени. Таким образом, общая стоимость равна 2 + 2 = 4.

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

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

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

Платный маляр, который красит i^th стену за time[i] единиц времени и берет cost[i] единиц денег.
Бесплатный маляр, который красит любую стену за 1 единицу времени по цене 0. Но бесплатный маляр может быть использован только в том случае, если платный маляр уже занят.

Вернуть минимальную сумму денег, необходимую для покраски n стен.

Пример 1:

Входные данные: cost = [1,2,3,2], time = [1,2,3,2]
Выходные данные: 3
Объяснение: стены с индексами 0 и 1 будут покрашены платным маляром, и это займет 3 единицы времени; в то же время бесплатный маляр покрасит стены с индексами 2 и 3 бесплатно за 2 единицы времени. Таким образом, общая стоимость составляет 1 + 2 = 3.

Пример 2:

Вход: cost = [2,3,4,2], time = [1,1,1,1]
Выход: 4
Пояснение: стены с индексом 0 и 3 будут окрашены платным маляром, и это займет 2 единицы времени; в то же время бесплатный маляр покрасит стены с индексом 1 и 2 бесплатно за 2 единицы времени. Таким образом, общая стоимость составляет 2 + 2 = 4.

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

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500


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

Одновременно изменить шоколадку типа i^th на тип ((i + 1) mod n)^th для всех шоколадок.

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

Пример 1:

Входные данные: nums = [20,1,15], x = 5
Выходные данные: 13
Объяснение: изначально типы шоколадок — [0,1,2]. Мы купим 1^й тип шоколада по цене 1.
Теперь мы выполним операцию по цене 5, и типы шоколада станут [1,2,0]. Мы купим 2^й^ тип шоколада по цене 1.
Теперь мы снова выполним операцию по цене 5, и типы шоколада станут [2,0,1]. Мы купим 0^й тип шоколада по цене 1.
Таким образом, общая стоимость станет (1 + 5 + 1 + 5 + 1) = 13. Мы можем доказать, что это оптимально.

Пример 2:

Вход: nums = [1,2,3], x = 4
Выход: 6
Объяснение: Мы соберем все три типа шоколада по их собственной цене, не выполняя никаких операций. Таким образом, общая стоимость составляет 1 + 2 + 3 = 6.

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

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

Вам дан 0-индексированный целочисленный массив размера N, представляющий стоимость сбора различных конфет. Стоимость сбора шоколада с индексом I - Nums[i]. Каждый шоколад имеет другой тип, и изначально шоколад в индексе I имеет тип.
В одной операции вы можете сделать следующее с понесенной стоимостью x:

Одновременно измените тип шоколада с индексом I на ((i + 1) mod n)-й тип для всех конфет.

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

Пример 1:

Ввод: nums = [20,1,15], x = 5
Вывод: 13
Объяснение: Первоначально типы шоколада составляют [0,1,2]. Мы купим шоколад 1-го типа по цене 1.
Теперь мы выполним операцию по цене 5, и типы конфет станут [1,2,0]. Мы купим шоколад 2-го типа по цене 1.
Теперь мы снова выполним операцию по цене 5, и типы шоколада станут [2,0,1]. Мы купим шоколад 0-го типа по цене 1.
Таким образом, общая стоимость станет (1 + 5 + 1 + 5 + 1) = 13. Мы можем доказать, что это оптимально.

Пример 2:

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

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

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

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

Одновременно изменить шоколадку типа i^th на тип ((i + 1) mod n)^th для всех шоколадок.

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

Пример 1:

Ввод: nums = [20,1,15], x = 5
Вывод: 13
Пояснение: Изначально типы шоколадок [0,1,2]. Мы купим шоколадку 1-го типа по цене 1.
Теперь мы выполним операцию по цене 5, и типы шоколадок станут [1,2,0]. Мы купим шоколадку 2-го типа по цене 1.
Теперь мы снова выполним операцию по цене 5, и типы шоколадок станут [2,0,1]. Мы купим шоколадку 0-го типа по цене 1.
Таким образом, общая стоимость составит (1 + 5 + 1 + 5 + 1) = 13. Мы можем доказать, что это оптимально.

Пример 2:

Ввод: nums = [1,2,3], x = 4
Вывод: 6
Пояснение: Мы соберём все три типа шоколадок по их собственной цене без выполнения операций. Поэтому общая стоимость будет 1 + 2 + 3 = 6.

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

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


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

Пример 1:

Ввод: n = 5, k = 4
Вывод: 18
Пояснение: Рассмотрим k-избегающий массив [1,2,4,5,6], сумма которого равна 18.
Можно доказать, что не существует k-избегающего массива с суммой меньше 18.

Пример 2:

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

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

1 <= n, k <= 50

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

Пример 1:

Входные данные: n = 5, k = 4
Выходные данные: 18
Объяснение: Рассмотрим k-избегающий массив [1,2,4,5,6], сумма которого равна 18.
Можно доказать, что не существует k-избегающего массива с суммой меньше 18.

Пример 2:

Входные данные: n = 2, k = 6
Выходные данные: 3
Объяснение: Можно построить массив [1,2], сумма которого равна 3.
Можно доказать, что не существует k-избегающего массива с суммой меньше 3.

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

1 <= n, k <= 50

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

Пример 1:

Входные данные: n = 5, k = 4
Выходные данные: 18
Пояснение: Рассмотрим массив, избегающий k [1,2,4,5,6], сумма которого равна 18.
Можно доказать, что не существует массива, избегающего k, с суммой меньше 18.

Пример 2:

Входные данные: n = 2, k = 6
Выходные данные: 3
Пояснение: Мы можем построить массив [1,2], сумма которого равна 3.
Можно доказать, что не существует массива, избегающего k, с суммой меньше 3.

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

1 <= n, k <= 50


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

Увеличьте или уменьшите x на 1, и одновременно увеличьте или уменьшите num на 1.

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

Пример 1:

Входные данные: num = 4, t = 1
Выходные данные: 6
Объяснение: Максимальное достижимое число — x = 6; оно может стать равным num после выполнения этой операции:
1- Уменьшите x на 1 и увеличьте num на 1. Теперь x = 5 и num = 5.
Можно доказать, что не существует достижимого числа больше 6.

Пример 2:

Входные данные: num = 3, t = 2
Выходные данные: 7
Объяснение: Максимальное достижимое число — x = 7; после выполнения этих операций x станет равным num:
1- Уменьшите x на 1 и увеличьте num на 1. Теперь x = 6 и num = 4.
2- Уменьшите x на 1 и увеличьте num на 1. Теперь x = 5 и num = 5.
Можно доказать, что не существует достижимого числа больше 7.

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

1 <= num, t <= 50

Даны два целых числа: num и t.
Целое число x называется достижимым, если оно может стать равным num после применения следующей операции не более чем t раз:

Увеличьте или уменьшите x на 1 и одновременно увеличьте или уменьшите num на 1.

Верните максимально возможное достижимое число. Гарантируется, что существует как минимум одно достижимое число.

Пример 1:

Ввод: num = 4, t = 1
Вывод: 6
Объяснение: Максимально достижимое число — это x = 6. Оно может стать равным num после выполнения следующей операции:
Уменьшите x на 1 и увеличьте num на 1. Теперь x = 5 и num = 5.
Гарантируется, что нет достижимого числа, большего чем 6.
Пример 2:
Ввод: num = 3, t = 2
Вывод: 7

Объяснение: Максимально достижимое число — это x = 7. Оно может стать равным num после выполнения следующих операций:
Уменьшите x на 1 и увеличьте num на 1. Теперь x = 6 и num = 4.
Уменьшите x на 1 и увеличьте num на 1. Теперь x = 5 и num = 5.
Гарантируется, что нет достижимого числа, большего чем 7.

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

1 <= num, t <= 50