Hay tres cartas con las letras $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ colocadas en una fila en algún orden. Puedes hacer la siguiente operación como máximo una vez:

- Elige dos cartas e intercámbialas. ¿Es posible que la fila se convierta en $\texttt{abc}$ después de la operación? Muestra "SÍ" si es posible y "NO" en caso contrario.

Entrada

La primera línea contiene un único entero $t$ ($1 \leq t \leq 6$): la cantidad de casos de prueba.

La única línea de cada caso de prueba contiene una única cadena que consta de cada uno de los tres caracteres $\texttt{a}$, $\texttt{b}$ y $\texttt{c}$ exactamente una vez, lo que representa las cartas.

Salida

Para cada caso de prueba, muestra "SÍ" si puedes hacer que la fila sea $\texttt{abc}$ con como máximo una operación, o "NO" en caso contrario.

Puede generar la respuesta en cualquier caso (por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" se reconocerán como una respuesta positiva). Entrada de muestra 1:
6

abc

acb

bac

bca

cab

cba

Salida de muestra 1:

YES
YES
YES
NO
NO
YES

Nota

En el primer caso de prueba, no necesitamos hacer ninguna operación, ya que la fila ya es $\texttt{abc}$.

En el segundo caso de prueba, podemos intercambiar $\texttt{c}$ y $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

En el tercer caso de prueba, podemos intercambiar $\texttt{b}$ y $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

En el cuarto caso de prueba, es imposible hacer $\texttt{abc}$ usando como máximo una operación.

Hay tres cartas con las letras $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ colocadas en fila en algún orden. Puedes realizar la siguiente operación como máximo una vez:

- Escoger dos cartas y cambiarlas. ¿Es posible que la fila se convierta en $\texttt{abc}$ después de la operación? Escribe "YES" si es posible y "NO" en caso contrario.

Entrada

La primera línea contiene un solo entero $t$ ($1 \leq t \leq 6$) — el número de casos de prueba.

La única línea de cada caso de prueba contiene una cadena de tres caracteres $\texttt{a}$, $\texttt{b}$ y $\texttt{c}$ exactamente una vez, representando las cartas.

Salida

Para cada caso de prueba, escribe "YES" si puedes hacer la fila $\texttt{abc}$ con como máximo una operación, o "NO" en caso contrario.

Puedes escribir la respuesta en cualquier formato (por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" serán reconocidas como una respuesta positiva).

Ejemplo de entrada 1:
6

abc

acb

bac

bca

cab

cba

Ejemplo de salida 1:

YES
YES
YES
NO
NO
YES

Nota

En el primer caso de prueba, no necesitamos hacer ninguna operación, puesto que la fila ya es $\texttt{abc}$.

En el segundo caso de prueba, podemos cambiar $\texttt{c}$ y $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

En el tercer caso de prueba, podemos cambiar $\texttt{b}$ y $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

En el cuarto caso de prueba, es imposible hacer $\texttt{abc}$ usando como máximo una operación.

Hay tres cartas con letras $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ colocadas en una fila en cierto orden. Se puede hacer la siguiente operación como máximo una vez:

- Elige dos cartas e intercámbialas.  ¿Es posible que la fila se convierta en $\texttt{abc}$ después de la operación? Salida «SÍ» si es posible, y «NO» en caso contrario.

Entrada

La primera línea contiene un único número entero $t$ ($1 \leq t \leq 6$) - el número de casos de prueba.

La única línea de cada caso de prueba contiene una única cadena formada por cada uno de los tres caracteres $texttt{a}$, $texttt{b}$, y $\texttt{c}$ exactamente una vez, representando las tarjetas.

Salida

Para cada caso de prueba, la salida "YES" si se puede hacer la fila $\texttt{abc}$ con al menos una operación, o «NO» en caso contrario.

Puede dar salida a la respuesta en cualquier caso (por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" se reconocerán como una respuesta positiva).Ejemplo de entrada 1:
6

abc

acb

bac

bca

cab

cba

Salida de muestra 1:

YES
YES
YES
NO
NO
YES

Nota

En el primer caso de prueba, no necesitamos hacer ninguna operación, ya que la fila ya es $\texttt{abc}$.

En el segundo caso de prueba, podemos intercambiar $\texttt{c}$ y $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

En el tercer caso de prueba, podemos intercambiar $\texttt{b}$ y $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

En el cuarto caso de prueba, es imposible hacer $\texttt{abc}$ utilizando como máximo una operación.


Slavic está preparando un regalo para el cumpleaños de un amigo. Tiene un arreglo $a$ de $n$ dígitos y el regalo será el producto de todos estos dígitos. Debido a que Slavic es un buen chico que quiere hacer el producto más grande posible, quiere sumar $1$ a exactamente uno de sus dígitos.

¿Cuál es el producto máximo que Slavic puede hacer?

Entrada

La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene un solo entero $n$ ($1 \leq n \leq 9$) — el número de dígitos.

La segunda línea de cada caso de prueba contiene $n$ enteros separados por espacio $a_i$ ($0 \leq a_i \leq 9$) — los dígitos en el arreglo.

Salida

Para cada caso de prueba, imprime un solo entero — el producto máximo que Slavic puede hacer sumando $1$ a exactamente uno de sus dígitos.

Ejemplo de entrada 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

Ejemplo de salida 1:

16
2
432
430467210

Slavic está preparando un regalo para el cumpleaños de un amigo. Tiene una matriz $a$ de $n$ dígitos y el regalo será el producto de todos estos dígitos. Como Slavic es un buen chico que quiere hacer el mayor producto posible, quiere sumar $1$ a exactamente uno de sus dígitos.

¿Cuál es el producto máximo que puede hacer Slavic?

Entrada

La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene un solo entero $n$ ($1 \leq n \leq 9$) — el número de dígitos.

La segunda línea de cada caso de prueba contiene $n$ enteros separados por espacios $a_i$ ($0 \leq a_i \leq 9$) — los dígitos de la matriz.

Salida

Para cada caso de prueba, genere un único entero: el producto máximo que puede generar Slavic, sumando $1$ a exactamente uno de sus dígitos.Entrada de muestra 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

Salida de muestra 1:

16
2
432
430467210


Tienes una tira de papel $s$ que tiene $n$ celdas de largo. Cada celda es negra o blanca. En una operación, puedes tomar cualquier $k$ celdas consecutivas y hacerlas todas blancas.

Encuentra el número mínimo de operaciones necesarias para eliminar todas las celdas negras.

Entrada

La primera línea contiene un solo entero $t$ ($1 \leq t \leq 1000$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene dos enteros $n$ y $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — la longitud del papel y el entero usado en la operación.

La segunda línea de cada caso de prueba contiene una cadena $s$ de longitud $n$ compuesta de caracteres $\texttt{B}$ (que representa una celda negra) o $\texttt{W}$ (que representa una celda blanca).

La suma de $n$ en todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, imprime un solo entero — el número mínimo de operaciones necesarias para eliminar todas las celdas negras.

Ejemplo de entrada 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

Ejemplo de salida 1:

2
1
2
1
4
3
4
0

Nota

En el primer caso de prueba, puedes realizar las siguientes operaciones: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

En el segundo caso de prueba, puedes realizar las siguientes operaciones: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

En el tercer caso de prueba, puedes realizar las siguientes operaciones: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

Se le proporciona una tira de papel $s$ que tiene $n$ celdas de largo. Cada celda es negra o blanca. En una operación, puede tomar $k$ celdas consecutivas y convertirlas todas en blancas.

Encuentre la cantidad mínima de operaciones necesarias para eliminar todas las celdas negras.

Entrada

La primera línea contiene un solo entero $t$ ($1 \leq t \leq 1000$): la cantidad de casos de prueba.

La primera línea de cada caso de prueba contiene dos enteros $n$ y $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$): la longitud del papel y el entero utilizado en la operación.

La segunda línea de cada caso de prueba contiene una cadena $s$ de longitud $n$ que consta de caracteres $\texttt{B}$ (que representan una celda negra) o $\texttt{W}$ (que representan una celda blanca).

La suma de $n$ en todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, genere un único entero: la cantidad mínima de operaciones necesarias para eliminar todas las celdas negras.Entrada de muestra 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

Salida de muestra 1:

2
1
2
1
4
3
4
0

Nota

En el primer caso de prueba, puede realizar las siguientes operaciones: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

En el segundo caso de prueba, puede realizar las siguientes operaciones: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

En el tercer caso de prueba, puede realizar las siguientes operaciones: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$


Se te da una cadena $s$ de longitud $n$, compuesta por letras latinas minúsculas, y un entero $k$.

Necesitas verificar si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes puedan reorganizarse para formar un palíndromo. Ten en cuenta que puedes reordenar los caracteres restantes de cualquier manera.

Un palíndromo es una cadena que se lee igual hacia adelante y hacia atrás. Por ejemplo, las cadenas "z", "aaa", "aba", "abccba" son palíndromos, mientras que las cadenas "codeforces", "reality", "ab" no lo son.

Entrada

Cada prueba consiste en múltiples casos de prueba. La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba. Esto es seguido por su descripción.

La primera línea de cada caso de prueba contiene dos enteros $n$ y $k$ ($0 \leq k < n \leq 10^5$) — la longitud de la cadena $s$ y el número de caracteres a eliminar.

La segunda línea de cada caso de prueba contiene una cadena $s$ de longitud $n$, compuesta por letras latinas minúsculas.

Se garantiza que la suma de $n$ sobre todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, imprime "YES" si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes puedan reorganizarse para formar un palíndromo, y "NO" en caso contrario.

Puedes imprimir la respuesta en cualquier caso (mayúsculas o minúsculas). Por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" serán reconocidas como respuestas positivas. Ejemplo de Entrada 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

Ejemplo de Salida 1:

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

Nota

En el primer caso de prueba, nada se puede eliminar, y la cadena "a" es un palíndromo.

En el segundo caso de prueba, nada se puede eliminar, pero las cadenas "ab" y "ba" no son palíndromos.

En el tercer caso de prueba, se puede eliminar cualquier carácter, y la cadena resultante será un palíndromo.

En el cuarto caso de prueba, se puede eliminar una ocurrencia del carácter "a", resultando en la cadena "bb", que es un palíndromo.

En el sexto caso de prueba, se puede eliminar una ocurrencia de los caracteres "b" y "d", resultando en la cadena "acac", que puede reorganizarse en la cadena "acca".

En el noveno caso de prueba, se puede eliminar una ocurrencia de los caracteres "t" y "k", resultando en la cadena "aagaa", que es un palíndromo.

Se le proporciona una cadena $s$ de longitud $n$, que consta de letras latinas minúsculas y un entero $k$.

Debe comprobar si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes se puedan reorganizar para formar un palíndromo. Tenga en cuenta que puede reordenar los caracteres restantes de cualquier manera.

Un palíndromo es una cadena que se lee igual hacia adelante y hacia atrás. Por ejemplo, las cadenas "z", "aaa", "aba", "abccba" son palíndromos, mientras que las cadenas "codeforces", "reality", "ab" no lo son.

Entrada

Cada prueba consta de varios casos de prueba. La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$): el número de casos de prueba. A esto le sigue su descripción.

La primera línea de cada caso de prueba contiene dos números enteros $n$ y $k$ ($0 \leq k < n \leq 10^5$): la longitud de la cadena $s$ y la cantidad de caracteres que se eliminarán.

La segunda línea de cada caso de prueba contiene una cadena $s$ de longitud $n$, que consta de letras latinas minúsculas.

Se garantiza que la suma de $n$ en todos los casos de prueba no exceda $2 \cdot 10^5$.

Salida

Para cada caso de prueba, muestre "SÍ" si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes se puedan reorganizar para formar un palíndromo, y "NO" en caso contrario.

Puede mostrar la respuesta en cualquier caso (mayúsculas o minúsculas). Por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" se reconocerán como respuestas positivas. Entrada de ejemplo 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

Salida de ejemplo 1:

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

Nota

En el primer caso de prueba, no se puede eliminar nada y la cadena "a" es un palíndromo.

En el segundo caso de prueba, no se puede eliminar nada, pero las cadenas "ab" y "ba" no son palíndromos.

En el tercer caso de prueba, se puede eliminar cualquier carácter y la cadena resultante será un palíndromo.

En el cuarto caso de prueba, se puede eliminar una aparición del carácter "a", lo que da como resultado la cadena "bb", que es un palíndromo.

En el sexto caso de prueba, se puede eliminar una aparición de los caracteres "b" y "d", lo que da como resultado la cadena "acac", que se puede reorganizar en la cadena "acca".

En el noveno caso de prueba, se puede eliminar una aparición de los caracteres "t" y "k", lo que da como resultado la cadena "aagaa", que es un palíndromo.

Se le proporciona una cadena $s$ de longitud $n$, que consta de letras latinas minúsculas y un entero $k$.

Debe comprobar si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes se puedan reorganizar para formar un palíndromo. Tenga en cuenta que puede reordenar los caracteres restantes de cualquier manera.

Un palíndromo es una cadena que se lee igual hacia adelante y hacia atrás. Por ejemplo, las cadenas "z", "aaa", "aba", "abccba" son palíndromos, mientras que las cadenas "codeforces", "reality", "ab" no lo son.

Entrada

Cada prueba consta de varios casos de prueba. La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$): el número de casos de prueba. A esto le sigue su descripción.

La primera línea de cada caso de prueba contiene dos números enteros $n$ y $k$ ($0 \leq k < n \leq 10^5$): la longitud de la cadena $s$ y la cantidad de caracteres que se eliminarán.

La segunda línea de cada caso de prueba contiene una cadena $s$ de longitud $n$, que consta de letras latinas minúsculas.

Se garantiza que la suma de $n$ en todos los casos de prueba no exceda $2 \cdot 10^5$.

Salida

Para cada caso de prueba, muestre "YES" si es posible eliminar exactamente $k$ caracteres de la cadena $s$ de tal manera que los caracteres restantes se puedan reorganizar para formar un palíndromo, y "NO" en caso contrario.

Puede mostrar la respuesta en cualquier caso (mayúsculas o minúsculas). Por ejemplo, las cadenas "yEs", "yes", "Yes" y "YES" se reconocerán como respuestas positivas. Entrada de ejemplo 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

Salida de ejemplo 1:

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

Nota

En el primer caso de prueba, no se puede eliminar nada y la cadena "a" es un palíndromo.

En el segundo caso de prueba, no se puede eliminar nada, pero las cadenas "ab" y "ba" no son palíndromos.

En el tercer caso de prueba, se puede eliminar cualquier carácter y la cadena resultante será un palíndromo.

En el cuarto caso de prueba, se puede eliminar una aparición del carácter "a", lo que da como resultado la cadena "bb", que es un palíndromo.

En el sexto caso de prueba, se puede eliminar una aparición de los caracteres "b" y "d", lo que da como resultado la cadena "acac", que se puede reorganizar en la cadena "acca".

En el noveno caso de prueba, se puede eliminar una aparición de los caracteres "t" y "k", lo que da como resultado la cadena "aagaa", que es un palíndromo.


Se te da un arreglo de enteros $a_1, a_2, \ldots, a_n$ y un número $k$ ($2 \leq k \leq 5$). En una operación, puedes hacer lo siguiente:

- Escoger un índice $1 \leq i \leq n$,
- Establecer $a_i = a_i + 1$.

Determina el número mínimo de operaciones necesarias para que el producto de todos los números en el arreglo $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ sea divisible por $k$.

Entrada

Cada prueba consta de múltiples casos de prueba. La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba. Luego sigue la descripción de los casos de prueba.

La primera línea de cada caso de prueba contiene dos enteros $n$ y $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — el tamaño del arreglo $a$ y el número $k$.

La segunda línea de cada caso de prueba contiene $n$ enteros $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Se garantiza que la suma de $n$ en todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, muestra el número mínimo de operaciones necesarias para que el producto de todos los números en el arreglo sea divisible por $k$.

Ejemplo de entrada 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

Ejemplo de salida 1:

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

Nota

En el primer caso de prueba, necesitamos escoger el índice $i = 2$ dos veces. Después de eso, el arreglo será $a = [7, 5]$. El producto de todos los números en el arreglo es $35$.

En el cuarto caso de prueba, el producto de los números en el arreglo es $120$, que ya es divisible por $5$, por lo que no se necesitan operaciones.

En el octavo caso de prueba, podemos realizar dos operaciones eligiendo $i = 2$ y $i = 3$ en cualquier orden. Después de eso, el arreglo será $a = [1, 6, 10]$. El producto de los números en el arreglo es $60$.

Se le proporciona una matriz de números enteros $a_1, a_2, \ldots, a_n$ y un número $k$ ($2 \leq k \leq 5$). En una operación, puede hacer lo siguiente:

- Elija un índice $1 \leq i \leq n$,
- Establezca $a_i = a_i + 1$. Encuentre la cantidad mínima de operaciones necesarias para que el producto de todos los números en la matriz $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ sea divisible por $k$.

Entrada

Cada prueba consta de varios casos de prueba. La primera línea contiene un solo número entero $t$ ($1 \leq t \leq 10^4$): la cantidad de casos de prueba. Luego sigue la descripción de los casos de prueba.

La primera línea de cada caso de prueba contiene dos números enteros $n$ y $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$): el tamaño de la matriz $a$ y el número $k$.

La segunda línea de cada caso de prueba contiene $n$ números enteros $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Se garantiza que la suma de $n$ en todos los casos de prueba no exceda $2 \cdot 10^5$.

Salida

Para cada caso de prueba, genere la cantidad mínima de operaciones necesarias para que el producto de todos los números de la matriz sea divisible por $k$.Entrada de muestra 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

Salida de muestra 1:

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

Nota

En el primer caso de prueba, debemos elegir el índice $i = 2$ dos veces. Después de eso, la matriz será $a = [7, 5]$. El producto de todos los números en la matriz es $35$.

En el cuarto caso de prueba, el producto de los números en la matriz es $120$, que ya es divisible por $5$, por lo que no se necesitan operaciones.

En el octavo caso de prueba, podemos realizar dos operaciones eligiendo $i = 2$ e $i = 3$ en cualquier orden. Después de eso, la matriz será $a = [1, 6, 10]$. El producto de los números en la matriz es $60$.

Se le da un conjunto de enteros $a_1, a_2, \ldots, a_n$ y un número $k$ ($2 \leq k \leq 5$). En una operación, puedes hacer lo siguiente:

- Escoge un índice $1 \leq i \leq n$,
- Establece $a_i = a_i + 1$.Determina el número mínimo de operaciones necesarias para que el producto de todos los números en el conjunto $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ sea divisible por $k$.

Entrada

Cada prueba consta de múltiples casos de prueba. La primera línea contiene un solo entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba. Luego sigue la descripción de los casos de prueba.

La primera línea de cada caso de prueba contiene dos enteros $n$ y $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — el tamaño del conjunto $a$ y el número $k$.

La segunda línea de cada caso de prueba contiene $n$ enteros $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Se garantiza que la suma de $n$ en todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, muestra el número mínimo de operaciones necesarias para que el producto de todos los números en el conjunto sea divisible por $k$.Ejemplo de entrada 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

Ejemplo de salida 1:

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

Nota

En el primer caso de prueba, necesitamos escoger el índice $i = 2$ dos veces. Después de eso, el conjunto será $a = [7, 5]$. El producto de todos los números en el conjunto es $35$.

En el cuarto caso de prueba, el producto de los números en el conjunto es $120$, que ya es divisible por $5$, por lo que no se necesitan operaciones.

En el octavo caso de prueba, podemos realizar dos operaciones eligiendo $i = 2$ y $i = 3$ en cualquier orden. Después de eso, el conjunto será $a = [1, 6, 10]$. El producto de los números en el conjunto es $60$.


Vanya y Vova están jugando un juego. A los jugadores se les da un entero $n$. En su turno, el jugador puede sumar $1$ al entero actual o restar $1$. Los jugadores se turnan; Vanya comienza. Si después del movimiento de Vanya el entero es divisible por $3$, entonces él gana. Si han pasado $10$ movimientos y Vanya no ha ganado, entonces Vova gana.

Escribe un programa que, basado en el entero $n$, determine quién ganará si ambos jugadores juegan de manera óptima.

Entrada

La primera línea contiene el entero $t$ ($1 \leq t \leq 100$) — el número de casos de prueba.

La línea única de cada caso de prueba contiene el entero $n$ ($1 \leq n \leq 1000$).

Salida

Para cada caso de prueba, imprime "First" sin comillas si Vanya gana, y "Second" sin comillas si Vova gana.

Sample Input 1:

6

1

3

5

100

999

1000

Sample Output 1:

First
Second
First
First
Second
First

Vanya y Vova están jugando un juego. A los jugadores se les da un entero $n$. En su turno, el jugador puede sumar $1$ al entero actual o restar $1$. Los jugadores se turnan; Vanya comienza. Si después del movimiento de Vanya el entero es divisible por $3$, entonces él gana. Si han pasado $10$ movimientos y Vanya no ha ganado, entonces Vova gana.

Escribe un programa que, basado en el entero $n$, determine quién ganará si ambos jugadores juegan de manera óptima.

Entrada

La primera línea contiene el entero $t$ ($1 \leq t \leq 100$) — el número de casos de prueba.

La línea única de cada caso de prueba contiene el entero $n$ ($1 \leq n \leq 1000$).

Salida

Para cada caso de prueba, imprime "First" sin comillas si Vanya gana, y "Second" sin comillas si Vova gana.Ejemplo de entrada 1:

6

1

3

5

100

999

1000

Ejemplo de salida 1:

First
Second
First
First
Second
First

Vanya y Vova están jugando un juego. Los jugadores reciben un entero $n$. En su turno, el jugador puede sumar $1$ al entero actual o restar $1$. Los jugadores se turnan; Vanya empieza. Si después del movimiento de Vanya el entero es divisible por $3$, entonces gana. Si han pasado $10$ movimientos y Vanya no ha ganado, entonces gana Vova.

Escriba un programa que, basándose en el entero $n$, determine quién ganará si ambos jugadores juegan de manera óptima.

Entrada

La primera línea contiene el entero $t$ ($1 \leq t \leq 100$) — el número de casos de prueba.

La línea única de cada caso de prueba contiene el entero $n$ ($1 \leq n \leq 1000$).

Salida

Para cada caso de prueba, imprima "First" sin comillas si gana Vanya y "Second" sin comillas si gana Vova.Entrada de muestra 1:
6

1

3

5

100

999

1000

Salida de muestra 1:

First
Second
First
First
Second
First


Alex está participando en la filmación de otro video de BrMeast, y BrMeast le pidió a Alex que preparara 250 mil toneladas de TNT, pero Alex no lo escuchó bien, así que preparó $n$ cajas y las dispuso en una fila esperando camiones. La caja $i$ desde la izquierda pesa $a_i$ toneladas.

Todos los camiones que Alex va a usar transportan la misma cantidad de cajas, denotada por $k$. La carga se realiza de la siguiente manera:

- Las primeras $k$ cajas van al primer camión,
- Las segundas $k$ cajas van al segundo camión,
- $\dotsb$
- Las últimas $k$ cajas van al $\frac{n}{k}$-ésimo camión. Una vez que la carga se completa, cada camión debe tener exactamente $k$ cajas. En otras palabras, si en algún momento no es posible cargar exactamente $k$ cajas en el camión, entonces la opción de carga con ese $k$ no es posible.

Alex odia la justicia, por lo que quiere que la diferencia absoluta máxima entre los pesos totales de dos camiones sea lo más grande posible. Si solo hay un camión, este valor es $0$.

Alex tiene bastantes conexiones, por lo que para cada $1 \leq k \leq n$, puede encontrar una empresa tal que cada uno de sus camiones pueda transportar exactamente $k$ cajas. Imprime la diferencia absoluta máxima entre los pesos totales de dos camiones cualesquiera.

Entrada

La primera línea contiene un entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene un entero $n$ ($1 \leq n \leq 150\,000$) — el número de cajas.

La segunda línea contiene $n$ enteros $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — los pesos de las cajas.

Se garantiza que la suma de $n$ para todos los casos de prueba no excede $150\,000$.

Salida

Para cada caso de prueba, imprime un solo entero — la respuesta al problema.

Entrada de Muestra 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

Salida de Muestra 1:

1
9
0
189114
112141

Nota

En el primer caso, deberíamos elegir dos camiones, por lo que el primero tendrá solo la primera caja, y el segundo solo la segunda caja.

En el segundo caso, deberíamos elegir seis camiones, por lo que el máximo será $10$, el mínimo será $1$, y la respuesta es $10 - 1 = 9$.

En el tercer caso, para cualquier posible $k$, los camiones tendrán el mismo peso total de cajas, por lo que la respuesta es $0$.

Alex está participando en la filmación de otro video de BrMeast, y BrMeast le pidió a Alex que preparara 250 mil toneladas de TNT, pero Alex no lo escuchó bien, por lo que preparó $n$ cajas y las colocó en fila esperando los camiones. La $i$-ésima caja desde la izquierda pesa $a_i$ toneladas.

Todos los camiones que Alex va a utilizar tienen la misma cantidad de cajas, denotadas por $k$. La carga se realiza de la siguiente manera:

- Las primeras $k$ cajas van al primer camión,
- Las segundas $k$ cajas van al segundo camión,
- $\dotsb$
- Las últimas $k$ cajas van al $\frac{n}{k}$-ésimo camión. Una vez completada la carga, cada camión debe tener exactamente $k$ cajas. En otras palabras, si en algún momento no es posible cargar exactamente $k$ cajas en el camión, entonces la opción de carga con esas $k$ no es posible.

Alex odia la justicia, por lo que quiere que la diferencia absoluta máxima entre los pesos totales de dos camiones sea lo más grande posible. Si solo hay un camión, este valor es $0$.

Alex tiene muchas conexiones, por lo que por cada $1 \leq k \leq n$, puede encontrar una empresa tal que cada uno de sus camiones pueda contener exactamente $k$ cajas. Imprima la diferencia absoluta máxima entre los pesos totales de dos camiones cualesquiera.

Entrada

La primera línea contiene un entero $t$ ($1 \leq t \leq 10^4$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene un entero $n$ ($1 \leq n \leq 150\,000$) — el número de cajas.

La segunda línea contiene $n$ enteros $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — los pesos de las cajas.

Se garantiza que la suma de $n$ para todos los casos de prueba no exceda $150\,000$.

Salida

Para cada caso de prueba, imprima un solo entero: la respuesta al problema.Entrada de ejemplo 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

Ejemplo de salida 1:

1
9
0
189114
112141

Nota

En el primer caso, debemos elegir dos camiones, de modo que el primero tenga solo la primera caja y el segundo solo la segunda.

En el segundo caso, debemos elegir seis camiones, de modo que el máximo sea $10$, el mínimo sea $1$ y la respuesta sea $10 - 1 = 9$.

En el tercer caso, para cualquier $k$ posible, los camiones tendrán el mismo peso total de cajas, de modo que la respuesta sea $0$.


Un subarreglo es una parte continua de un arreglo.

Yarik encontró recientemente un arreglo $a$ de $n$ elementos y se interesó mucho en encontrar la suma máxima de un subarreglo no vacío. Sin embargo, a Yarik no le gustan los números enteros consecutivos con la misma paridad, por lo que el subarreglo que elija debe tener paridades alternadas para los elementos adyacentes.

Por ejemplo, $[1, 2, 3]$ es aceptable, pero $[1, 2, 4]$ no lo es, ya que $2$ y $4$ son pares y adyacentes.

Debes ayudar a Yarik a encontrar la suma máxima de dicho subarreglo.

Entrada

La primera línea contiene un entero $t$ $(1 \le t \le 10^4)$ —número de casos de prueba. Cada caso de prueba se describe a continuación.

La primera línea de cada caso de prueba contiene un entero $n$ $(1 \le n \le 2 \cdot 10^5)$ —longitud del arreglo.

La segunda línea de cada caso de prueba contiene $n$ números enteros $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — elementos de la matriz.

Se garantiza que la suma de $n$ para todos los casos de prueba no exceda $2 \cdot 10^5$.

Salida

Para cada caso de prueba, genere un único entero: la respuesta al problema.Entrada de ejemplo 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

Salida de ejemplo 1:

15
17
8
4
-1000
101
10

Una subarray es una parte continua de un array.

Yarik encontró recientemente un array $a$ de $n$ elementos y se interesó mucho en encontrar la suma máxima de una subarray no vacía. Sin embargo, a Yarik no le gustan los enteros consecutivos con la misma paridad, por lo que la subarray que elige debe tener paridades alternadas para elementos adyacentes.

Por ejemplo, $[1, 2, 3]$ es aceptable, pero $[1, 2, 4]$ no lo es, ya que $2$ y $4$ son ambos pares y adyacentes.

Necesitas ayudar a Yarik encontrando la suma máxima de tal subarray.

Entrada

La primera línea contiene un entero $t$ $(1 \le t \le 10^4)$ — número de casos de prueba. Cada caso de prueba se describe de la siguiente manera.

La primera línea de cada caso de prueba contiene un entero $n$ $(1 \le n \le 2 \cdot 10^5)$ — longitud del array.

La segunda línea de cada caso de prueba contiene $n$ enteros $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — elementos del array.

Se garantiza que la suma de $n$ para todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, salida un solo entero — la respuesta al problema.Sample Input 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

Sample Output 1:

15
17
8
4
-1000
101
10

Una submatriz es una parte continua de una matriz.

Yarik encontró recientemente una matriz $a$ de $n$ elementos y se interesó mucho en encontrar la suma máxima de una submatriz no vacía. Sin embargo, a Yarik no le gustan los enteros consecutivos con la misma paridad, por lo que la submatriz que elige debe tener paridades alternas para elementos adyacentes.

Por ejemplo, $[1, 2, 3]$ es aceptable, pero $[1, 2, 4]$ no lo es, ya que $2$ y $4$ son ambos pares y adyacentes.

Debes ayudar a Yarik a encontrar la suma máxima de tal submatriz.

Entrada

La primera línea contiene un entero $t$ $(1 \le t \le 10^4)$ — número de casos de prueba. Cada caso de prueba se describe de la siguiente manera.

La primera línea de cada caso de prueba contiene un entero $n$ $(1 \le n \le 2 \cdot 10^5)$ — longitud de la matriz.

La segunda línea de cada caso de prueba contiene $n$ enteros $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — elementos de la matriz.

Se garantiza que la suma de $n$ para todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, salida un solo entero — la respuesta al problema.Sample Input 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

Ejemplo de salida 1:

15
17
8
4
-1000
101
10


Yarik es un gran fan de varios tipos de música. Pero a Yarik le encanta no solo escuchar música, sino también componerla. Le gusta más que nada la música electrónica, por lo que ha creado su propio sistema de notas musicales que, en su opinión, es el mejor para ello.

Dado que a Yarik también le gusta la informática, en su sistema las notas se denotan mediante enteros de $2^k$, donde $k \ge 1$ — un entero positivo. Pero, como sabes, no puedes usar solo notas para escribir música, por lo que Yarik utiliza combinaciones de dos notas. La combinación de dos notas $(a, b)$, donde $a = 2^k$ y $b = 2^l$, la denomina con el entero $a^b$.

Por ejemplo, si $a = 8 = 2^3$, $b = 4 = 2^2$, entonces la combinación $(a, b)$ se denota por el entero $a^b = 8^4 = 4096$. Nota que diferentes combinaciones pueden tener la misma notación, por ejemplo, la combinación $(64, 2)$ también se denota por el entero $4096 = 64^2$.

Yarik ya ha elegido $n$ notas que quiere usar en su nueva melodía. Sin embargo, dado que sus enteros pueden ser muy grandes, las ha anotado como un arreglo $a$ de longitud $n$, entonces la nota $i$ es $b_i = 2^{a_i}$. Los enteros en el arreglo $a$ pueden repetirse.

La melodía consistirá en varias combinaciones de dos notas. Yarik se estaba preguntando cuántos pares de notas $b_i, b_j$ $(i < j)$ existen tales que la combinación $(b_i, b_j)$ es igual a la combinación $(b_j, b_i)$. En otras palabras, quiere contar el número de pares $(i, j)$ $(i < j)$ tales que $b_i^{b_j} = b_j^{b_i}$. Ayúdalo a encontrar el número de tales pares.

Entrada

La primera línea de la entrada contiene un entero $t$ ($1 \le t \le 10^4$) — el número de casos de prueba.

La primera línea de cada caso de prueba contiene un entero $n$ ($1 \leq n \leq 2 \cdot 10^5$) — la longitud de los arreglos.

La siguiente línea contiene $n$ enteros $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — el arreglo $a$.

Se garantiza que la suma de $n$ sobre todos los casos de prueba no excede $2 \cdot 10^5$.

Salida

Para cada caso de prueba, escribe el número de pares que satisfacen la condición dada.

Entrada de Muestra 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

Salida de Muestra 1:

0
2
1
3
19

Yarik es un gran aficionado a muchos tipos de música, pero no sólo le gusta escuchar música, sino también escribirla. Le gusta sobre todo la música electrónica, por lo que ha creado su propio sistema de notas musicales, que, en su opinión, es el mejor para ella.

Como a Yarik también le gusta la informática, en su sistema las notas se denotan con números enteros de $2^k$, donde $k \ge 1$ es un número entero positivo. Pero, como ya sabes, no se pueden utilizar sólo notas para escribir música, por lo que Yarik utiliza combinaciones de dos notas. La combinación de dos notas $(a, b)$, donde $a = 2^k$ y $b = 2^l$, la denota con el número entero $a^b$.

Por ejemplo, si $a = 8 = 2^3$, $b = 4 = 2^2$, entonces la combinación $(a, b)$ se denota con el número entero $a^b = 8^4 = 4096$. Tenga en cuenta que diferentes combinaciones pueden tener la misma notación, por ejemplo, la combinación $(64, 2)$ también se denota por el entero $4096 = 64^2$.

Yarik ya ha elegido $n$ notas que quiere usar en su nueva melodía. Sin embargo, dado que sus enteros pueden ser muy grandes, los ha escrito como una matriz $a$ de longitud $n$, luego la nota $i$ es $b_i = 2^{a_i}$. Los enteros en la matriz $a$ se pueden repetir.

La melodía constará de varias combinaciones de dos notas. Yarik se preguntaba cuántos pares de notas $b_i, b_j$ $(i < j)$ existen de manera que la combinación $(b_i, b_j)$ sea igual a la combinación $(b_j, b_i)$. En otras palabras, quiere contar la cantidad de pares $(i, j)$ $(i < j)$ tales que $b_i^{b_j} = b_j^{b_i}$. Ayúdelo a encontrar la cantidad de dichos pares.

Entrada

La primera línea de la entrada contiene un entero $t$ ($1 \le t \le 10^4$) — la cantidad de casos de prueba.

La primera línea de cada caso de prueba contiene un entero $n$ ($1 \leq n \leq 2 \cdot 10^5$) — la longitud de las matrices.

La siguiente línea contiene $n$ enteros $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — la matriz $a$.

Se garantiza que la suma de $n$ en todos los casos de prueba no exceda $2 \cdot 10^5$.

Salida

Para cada caso de prueba, muestre la cantidad de pares que satisfacen la condición dada. Entrada de muestra 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

Salida de muestra 1:

0
2
1
3
19


Se te da un arreglo de cadenas de caracteres de índice 0 llamado details. Cada elemento de details proporciona información sobre un pasajero dada en una cadena comprimida de longitud 15. El sistema es tal que:

Los primeros diez caracteres consisten en el número de teléfono de los pasajeros.
El siguiente carácter indica el género de la persona.
Los dos caracteres siguientes se utilizan para indicar la edad de la persona.
Los dos últimos caracteres determinan el asiento asignado a esa persona.

Devuelve el número de pasajeros que tienen estrictamente más de 60 años.

Ejemplo 1:

Entrada: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Salida: 2
Explicación: Los pasajeros en los índices 0, 1 y 2 tienen 75, 92 y 40 años. Por lo tanto, hay 2 personas que tienen más de 60 años.

Ejemplo 2:

Entrada: details = ["1313579440F2036","2921522980M5644"]
Salida: 0
Explicación: Ninguno de los pasajeros tiene más de 60 años.

Restricciones:

1 <= details.length <= 100
details[i].length == 15
details[i] consiste en dígitos del '0' al '9'.
details[i][10] es 'M' o 'F' o 'O'.
Los números de teléfono y los números de asiento de los pasajeros son distintos.

Se le da una matriz con índice 0 de cadenas detalles. Cada elemento de detalles proporciona información sobre un pasajero determinado comprimida en una cadena de longitud 15. El sistema es tal que

Los diez primeros caracteres consisten en el número de teléfono de los pasajeros.
El siguiente carácter indica el sexo de la persona.
Los dos caracteres siguientes indican la edad de la persona.
Los dos últimos caracteres determinan el asiento asignado a esa persona.

Devuelve el número de pasajeros que tienen estrictamente más de 60 años.

Ejemplo 1

Entrada: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Salida: 2
Explicación: Los pasajeros de los índices 0, 1 y 2 tienen 75, 92 y 40 años. Por lo tanto, hay 2 personas que tienen más de 60 años.

Ejemplo 2:

Entrada: details = ["1313579440F2036","2921522980M5644"]
Salida: 0
Explicación: Ninguno de los pasajeros tiene más de 60 años.

Restricciones:

1 <= details.length <= 100
details[i].length == 15
details[i] consta de dígitos del '0' al '9'.
details[i][10] es 'M', 'F' u  'O'.
Los números de teléfono y los números de asiento de los pasajeros son distintos.

Se te da un arreglo de cadenas de caracteres de índice 0 llamado details. Cada elemento de details proporciona información sobre un pasajero dada en una cadena comprimida de longitud 15. El sistema es tal que:

Los primeros diez caracteres consisten en el número de teléfono de los pasajeros.
El siguiente carácter representa el género de la persona.
Los dos caracteres siguientes se usan para indicar la edad de la persona.
Los dos últimos caracteres determinan el asiento asignado a esa persona.

Devuelve el número de pasajeros que tienen estrictamente más de 60 años.

Ejemplo 1:

Entrada: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Salida: 2
Explicación: Los pasajeros en los índices 0, 1 y 2 tienen edades 75, 92 y 40. Por lo tanto, hay 2 personas que tienen más de 60 años.

Ejemplo 2:

Entrada: details = ["1313579440F2036","2921522980M5644"]
Salida: 0
Explicación: Ninguno de los pasajeros tiene más de 60 años.

Restricciones:

1 <= details.length <= 100
details[i].length == 15
details[i] consiste en dígitos del '0' al '9'.
details[i][10] es 'M' o 'F' o 'O'.
Los números de teléfono y los números de asiento de los pasajeros son distintos.


Se le proporciona una matriz de números enteros 2D indexada en 0, nums. Inicialmente, su puntaje es 0. Realice las siguientes operaciones hasta que la matriz quede vacía:

De cada fila de la matriz, seleccione el número más grande y elimínelo. En caso de empate, no importa qué número se elija.
Identifique el número más alto entre todos los eliminados en el paso 1. Agregue ese número a su puntaje.

Devuelva el puntaje final.

Ejemplo 1:

Entrada: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Salida: 15
Explicación: En la primera operación, eliminamos 7, 6, 6 y 3. Luego, agregamos 7 a nuestro puntaje. Luego, eliminamos 2, 4, 5 y 2. Agregamos 5 a nuestro puntaje. Por último, eliminamos 1, 2, 3 y 1. Agregamos 3 a nuestro puntaje. Por lo tanto, nuestra puntuación final es 7 + 5 + 3 = 15.

Ejemplo 2:

Entrada: nums = [[1]]
Salida: 1
Explicación: Eliminamos 1 y lo sumamos a la respuesta. Devolvemos 1.

Restricciones:

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

Se te da un array 2D de enteros nums indexado en 0. Inicialmente, tu puntuación es 0. Realiza las siguientes operaciones hasta que la matriz quede vacía:

De cada fila en la matriz, selecciona el número más grande y elimínalo. En caso de empate, no importa qué número se elija.
Identifica el número más alto entre todos los eliminados en el paso 1. Agrega ese número a tu puntuación.

Devuelve la puntuación final.

Ejemplo 1:

Entrada: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Salida: 15
Explicación: En la primera operación, eliminamos 7, 6, 6 y 3. Luego sumamos 7 a nuestra puntuación. A continuación, eliminamos 2, 4, 5 y 2. Sumamos 5 a nuestra puntuación. Finalmente, eliminamos 1, 2, 3 y 1. Sumamos 3 a nuestra puntuación. Por lo tanto, nuestra puntuación final es 7 + 5 + 3 = 15.

Ejemplo 2:

Entrada: nums = [[1]]
Salida: 1
Explicación: Eliminamos 1 y lo sumamos a la respuesta. Devolvemos 1.

Restricciones:

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

Se te da un array 2D de enteros nums indexado en 0. Inicialmente, tu puntuación es 0. Realiza las siguientes operaciones hasta que la matriz quede vacía:

De cada fila en la matriz, selecciona el número más grande y elimínalo. En caso de empate, no importa qué número se elija.
Identifica el número más alto entre todos los eliminados en el paso 1. Agrega ese número a tu puntuación.

Devuelve la puntuación final.

Ejemplo 1:

Input: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Output: 15
Explicación: En la primera operación, eliminamos 7, 6, 6 y 3. Luego sumamos 7 a nuestra puntuación. A continuación, eliminamos 2, 4, 5 y 2. Sumamos 5 a nuestra puntuación. Finalmente, eliminamos 1, 2, 3 y 1. Sumamos 3 a nuestra puntuación. Por lo tanto, nuestra puntuación final es 7 + 5 + 3 = 15.

Ejemplo 2:

Input: nums = [[1]]
Output: 1
Explicación: Eliminamos 1 y lo sumamos a la respuesta. Devolvemos 1.

Restricciones:

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


Se te da un array de enteros nums indexado desde 0 de longitud n y un entero k. En una operación, puedes elegir un elemento y multiplicarlo por 2.
Devuelve el mayor valor posible de nums[0] | nums[1] | ... | nums[n - 1] que se puede obtener después de aplicar la operación en nums como máximo k veces.
Ten en cuenta que a | b denota el "or" bit a bit entre dos enteros a y b.

Ejemplo 1:

Entrada: nums = [12,9], k = 1
Salida: 30
Explicación: Si aplicamos la operación al índice 1, nuestro nuevo array nums será igual a [12,18]. Así, devolvemos el "or" bit a bit de 12 y 18, que es 30.

Ejemplo 2:

Entrada: nums = [8,1,2], k = 2
Salida: 35
Explicación: Si aplicamos la operación dos veces en el índice 0, obtenemos un nuevo array de [32,1,2]. Así, devolvemos 32|1|2 = 35.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums de longitud n y un entero k. En una operación, puede elegir un elemento y multiplicarlo por 2.
Devuelve el valor máximo posible de nums[0] | nums[1] | ... | nums[n - 1] que se puede obtener después de aplicar la operación en nums como máximo k veces.
Tenga en cuenta que a | b denota el bit a bit o entre dos enteros a y b.

Ejemplo 1:

Entrada: nums = [12,9], k = 1
Salida: 30
Explicación: Si aplicamos la operación al índice 1, nuestra nueva matriz nums será igual a [12,18]. Por lo tanto, devolvemos el bit a bit de 12 y 18, que es 30.

Ejemplo 2:

Entrada: nums = [8,1,2], k = 2
Salida: 35
Explicación: Si aplicamos la operación dos veces en el índice 0, obtenemos una nueva matriz de [32,1,2]. Por lo tanto, devolvemos 32|1|2 = 35.

Restricciones:

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


Se te da un array de enteros indexado a partir de 0, nums, que representa la puntuación de los estudiantes en un examen. El maestro desea formar un grupo no vacío de estudiantes con la fuerza máxima, donde la fuerza de un grupo de estudiantes de índices i_0, i_1, i_2, ... , i_k se define como nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Devuelve la fuerza máxima de un grupo que el maestro puede crear.

Ejemplo 1:

Entrada: nums = [3,-1,-5,2,5,-9]
Salida: 1350
Explicación: Una forma de formar un grupo con fuerza máxima es agrupar a los estudiantes en los índices [0,2,3,4,5]. Su fuerza es 3 * (-5) * 2 * 5 * (-9) = 1350, lo cual es óptimo.

Ejemplo 2:

Entrada: nums = [-4,-5,-4]
Salida: 20
Explicación: Agrupar a los estudiantes en los índices [0, 1]. Entonces, la fuerza resultante sería 20. No podemos lograr una fuerza mayor.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0, nums, que representa la puntuación de los estudiantes en un examen. El profesor desea formar un grupo no vacío de estudiantes con una fuerza máxima, donde la fuerza de un grupo de estudiantes con índices i_0, i_1, i_2, ... , i_k se define como nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Devuelve la fuerza máxima de un grupo que el profesor puede crear.

Ejemplo 1:

Entrada: nums = [3,-1,-5,2,5,-9]
Salida: 1350
Explicación: Una forma de formar un grupo de fuerza máxima es agrupar a los estudiantes en los índices [0,2,3,4,5]. Su fuerza es 3 * (-5) * 2 * 5 * (-9) = 1350, que podemos demostrar que es óptima.

Ejemplo 2:

Entrada: nums = [-4,-5,-4]
Salida: 20
Explicación: Agrupe a los estudiantes en los índices [0, 1]. Entonces, obtendremos una fuerza resultante de 20. No podemos lograr una fuerza mayor.

Restricciones:

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


Se te da una cadena indexada a partir de 0, s, y un diccionario de palabras dictionary. Tienes que dividir s en una o más subcadenas no superpuestas de manera que cada subcadena esté presente en el diccionario. Puede haber algunos caracteres adicionales en s que no están presentes en ninguno de las subcadenas.
Devuelve el número mínimo de caracteres adicionales que quedan si divides s de manera óptima.

Ejemplo 1:

Entrada: s = "leetscode", dictionary = ["leet","code","leetcode"]
Salida: 1
Explicación: Podemos dividir s en dos subcadenas: "leet" de índice 0 a 3 y "code" de índice 5 a 8. Hay solo 1 carácter no usado (en el índice 4), así que devolvemos 1.

Ejemplo 2:

Entrada: s = "sayhelloworld", dictionary = ["hello","world"]
Salida: 3
Explicación: Podemos dividir s en dos subcadenas: "hello" de índice 3 a 7 y "world" de índice 8 a 12. Los caracteres en los índices 0, 1, 2 no se usan en ninguna subcadena y por lo tanto se consideran caracteres adicionales. Por lo tanto, devolvemos 3.

Restricciones:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] y s consisten solo en letras minúsculas del alfabeto inglés
dictionary contiene palabras distintas

Se le da una cadena s con índice 0 y un diccionario de palabras diccionario. Tiene que dividir s en una o más subcadenas no superpuestas de forma que cada subcadena esté presente en el diccionario. Puede haber algunos caracteres extra en s que no estén presentes en ninguna de las subcadenas.
Devuelve el número mínimo de caracteres sobrantes si rompe s de forma óptima.

Ejemplo 1:

Entrada: s = "leetscode", dictionary = ["leet","code","leetcode"]
Salida: 1
Explicación: Podemos dividir s en dos subcadenas: "leet" del índice 0 al 3 y “code” del índice 5 al 8. Sólo hay 1 carácter no utilizado (en el índice 4), por lo que devolvemos 1.

Ejemplo 2:

Entrada: s = "sayhelloworld", dictionary = ["hello","world"]
Salida: 3
Explicación: Podemos dividir s en dos subcadenas: «hola» del índice 3 al 7 y “mundo” del índice 8 al 12. Los caracteres en los índices 0, 1, 2 no se utilizan en ninguna subcadena y por lo tanto se consideran caracteres adicionales. Por lo tanto, devolvemos 3.

Restricciones:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] y s constan sólo de letras minúsculas inglesas
el diccionario contiene palabras distintas

Se le proporciona una cadena indexada en 0 s y un diccionario de palabras dictionary. Debe dividir s en una o más subcadenas que no se superpongan de modo que cada subcadena esté presente en dictionary. Puede haber algunos caracteres adicionales en s que no estén presentes en ninguna de las subcadenas.
Devuelve la cantidad mínima de caracteres adicionales que quedan si divide s de manera óptima.

Ejemplo 1:

Entrada: s = "leetscode", dictionary = ["leet", "code", "leetcode"]
Salida: 1
Explicación: Podemos dividir s en dos subcadenas: "leet" del índice 0 al 3 y "code" del índice 5 al 8. Solo hay 1 carácter sin usar (en el índice 4), por lo que devolvemos 1.

Ejemplo 2:

Entrada: s = "sayhelloworld", dictionary = ["hello", "world"]
Salida: 3
Explicación: Podemos dividir s en dos subcadenas: "hello" del índice 3 al 7 y "world" del índice 8 al 12. Los caracteres en los índices 0, 1, 2 no se usan en ninguna subcadena y, por lo tanto, se consideran caracteres adicionales. Por lo tanto, devolvemos 3.

Restricciones:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] y s consisten únicamente en letras minúsculas del inglés
dictionary contiene palabras distintas


Se te da un array de enteros, `prices`, que representa los precios de varios chocolates en una tienda. También se te da un único entero, `money`, que representa tu cantidad inicial de dinero.
Debes comprar exactamente dos chocolates de tal manera que todavía te quede algo de dinero no negativo. Quisieras minimizar la suma de los precios de los dos chocolates que compras.
Devuelve la cantidad de dinero que te quedará después de comprar los dos chocolates. Si no hay manera de comprar dos chocolates sin terminar en deuda, devuelve `money`. Nota que el dinero restante debe ser no negativo.

Ejemplo 1:

Entrada: prices = [1,2,2], money = 3
Salida: 0
Explicación: Compra los chocolates con precios de 1 y 2 unidades respectivamente. Tendrás 3 - 3 = 0 unidades de dinero después. Por lo tanto, devolvemos 0.

Ejemplo 2:

Entrada: prices = [3,2,3], money = 3
Salida: 3
Explicación: No puedes comprar 2 chocolates sin endeudarte, así que devolvemos 3.

Restricciones:

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

Se le proporciona una matriz de números enteros, price, que representa los precios de varios chocolates en una tienda. También se le proporciona un único número entero, money, que representa su cantidad inicial de dinero.
Debe comprar exactamente dos chocolates de manera que aún le quede algo de dinero sobrante no negativo. Le gustaría minimizar la suma de los precios de los dos chocolates que compre.
Devuelva la cantidad de dinero que le quedará después de comprar los dos chocolates. Si no tiene forma de comprar dos chocolates sin terminar endeudado, devuelva money. Tenga en cuenta que el sobrante debe ser no negativo.

Ejemplo 1:

Entrada: prices = [1,2,2], money = 3
Salida: 0
Explicación: Compre los chocolates con precios de 1 y 2 unidades respectivamente. Tendrá 3 - 3 = 0 unidades de dinero después. Por lo tanto, devolvemos 0.

Ejemplo 2:

Entrada: precios = [3,2,3], dinero = 3
Salida: 3
Explicación: No puedes comprar 2 chocolates sin endeudarte, por lo que devolvemos 3.

Restricciones:

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

Se te da una matriz de enteros, `prices`, que representa los precios de varias chocolatinas en una tienda. También se te da un único número entero, `money`, que representa tu cantidad inicial de dinero.
Debes comprar exactamente dos chocolatinas de tal manera que todavía tu saldo de dinero sea no negativo. Quisieras minimizar la suma de los precios de las dos chocolatinas que compras.
Devuelve la cantidad de dinero que te quedará después de comprar los dos chocolates. Si no hay manera de comprar dos chocolatinas sin terminar en deuda, devuelve `money`. Ten en cuenta que el dinero restante debe ser no negativo.

Ejemplo 1:

Input: prices = [1,2,2], money = 3
Output: 0
Explicación: Compra los chocolates con precios de 1 y 2 unidades respectivamente. Tendrás 3 - 3 = 0 unidades de dinero después. Por lo tanto, devolvemos 0.

Ejemplo 2:

Input: prices = [3,2,3], money = 3
Output: 3
Explicación: No puedes comprar 2 chocolates sin endeudarte, así que devolvemos 3.

Restricciones:

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


Se le proporcionan dos cadenas numéricas num1 y num2 y dos enteros max_sum y min_sum. Denotamos que un entero x es bueno si:

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

Devuelve la cantidad de enteros buenos. Como la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Tenga en cuenta que digit_sum(x) denota la suma de los dígitos de x.

Ejemplo 1:

Entrada: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Salida: 11
Explicación: Hay 11 números enteros cuya suma de dígitos se encuentra entre 1 y 8: 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 y 12. Por lo tanto, devolvemos 11.

Ejemplo 2:

Entrada: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Salida: 5
Explicación: Los 5 números enteros cuya suma de dígitos se encuentra entre 1 y 5 son 1, 2, 3, 4 y 5. Por lo tanto, devolvemos 5.

Restricciones:

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

Se te dan dos cadenas numéricas num1 y num2 y dos enteros max_sum y min_sum. Denotamos un entero x como bueno si:

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

Devuelve el número de enteros buenos. Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Nota que digit_sum(x) denota la suma de los dígitos de x.

Ejemplo 1:

Entrada: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Salida: 11
Explicación: Hay 11 enteros cuya suma de dígitos está entre 1 y 8, que son 1,2,3,4,5,6,7,8,10,11 y 12. Por lo tanto, devolvemos 11.

Ejemplo 2:

Entrada: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Salida: 5
Explicación: Los 5 enteros cuya suma de dígitos está entre 1 y 5 son 1,2,3,4 y 5. Por lo tanto, devolvemos 5.

Restricciones:

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


Se te da un arreglo nums indexado desde 0 de longitud n.
El arreglo de diferencias distintas de nums es un arreglo diff de longitud n tal que diff[i] es igual al número de elementos distintos en el sufijo nums[i + 1, ..., n - 1] restando el número de elementos distintos en el prefijo nums[0, ..., i].
Devuelve el arreglo de diferencias distintas de nums.
Nota que nums[i, ..., j] denota el subarreglo de nums comenzando en el índice i y terminando en el índice j inclusive. En particular, si i > j entonces nums[i, ..., j] denota un subarreglo vacío.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: [-3,-1,1,3,5]
Explicación: Para el índice i = 0, hay 1 elemento en el prefijo y 4 elementos distintos en el sufijo. Así, diff[0] = 1 - 4 = -3.
Para el índice i = 1, hay 2 elementos distintos en el prefijo y 3 elementos distintos en el sufijo. Así, diff[1] = 2 - 3 = -1.
Para el índice i = 2, hay 3 elementos distintos en el prefijo y 2 elementos distintos en el sufijo. Así, diff[2] = 3 - 2 = 1.
Para el índice i = 3, hay 4 elementos distintos en el prefijo y 1 elemento distinto en el sufijo. Así, diff[3] = 4 - 1 = 3.
Para el índice i = 4, hay 5 elementos distintos en el prefijo y no hay elementos en el sufijo. Así, diff[4] = 5 - 0 = 5.

Ejemplo 2:

Entrada: nums = [3,2,3,4,2]
Salida: [-2,-1,0,2,3]
Explicación: Para el índice i = 0, hay 1 elemento en el prefijo y 3 elementos distintos en el sufijo. Así, diff[0] = 1 - 3 = -2.
Para el índice i = 1, hay 2 elementos distintos en el prefijo y 3 elementos distintos en el sufijo. Así, diff[1] = 2 - 3 = -1.
Para el índice i = 2, hay 2 elementos distintos en el prefijo y 2 elementos distintos en el sufijo. Así, diff[2] = 2 - 2 = 0.
Para el índice i = 3, hay 3 elementos distintos en el prefijo y 1 elemento distinto en el sufijo. Así, diff[3] = 3 - 1 = 2.
Para el índice i = 4, hay 3 elementos distintos en el prefijo y no hay elementos en el sufijo. Así, diff[4] = 3 - 0 = 3.

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums de longitud n.
La matriz de diferencias distintas de nums es una matriz diff de longitud n tal que diff[i] es igual a la cantidad de elementos distintos en el sufijo nums[i + 1, ..., n - 1] menos la cantidad de elementos distintos en el prefijo nums[0, ..., i].
Devuelve la matriz de diferencias distintas de nums.
Tenga en cuenta que nums[i, ..., j] denota la submatriz de nums que comienza en el índice i y termina en el índice j inclusive. En particular, si i > j, entonces nums[i, ..., j] denota una submatriz vacía.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: [-3,-1,1,3,5]
Explicación: Para el índice i = 0, hay 1 elemento en el prefijo y 4 elementos distintos en el sufijo. Por lo tanto, diff[0] = 1 - 4 = -3.
Para el índice i = 1, hay 2 elementos distintos en el prefijo y 3 elementos distintos en el sufijo. Por lo tanto, diff[1] = 2 - 3 = -1.
Para el índice i = 2, hay 3 elementos distintos en el prefijo y 2 elementos distintos en el sufijo. Por lo tanto, diff[2] = 3 - 2 = 1.
Para el índice i = 3, hay 4 elementos distintos en el prefijo y 1 elemento distinto en el sufijo. Por lo tanto, diff[3] = 4 - 1 = 3.
Para el índice i = 4, hay 5 elementos distintos en el prefijo y ningún elemento en el sufijo. Por lo tanto, diff[4] = 5 - 0 = 5.

Ejemplo 2:

Entrada: nums = [3,2,3,4,2]
Salida: [-2,-1,0,2,3]
Explicación: Para el índice i = 0, hay 1 elemento en el prefijo y 3 elementos distintos en el sufijo. Por lo tanto, diff[0] = 1 - 3 = -2.
Para el índice i = 1, hay 2 elementos distintos en el prefijo y 3 elementos distintos en el sufijo. Por lo tanto, diff[1] = 2 - 3 = -1.
Para el índice i = 2, hay 2 elementos distintos en el prefijo y 2 elementos distintos en el sufijo. Por lo tanto, diff[2] = 2 - 2 = 0.
Para el índice i = 3, hay 3 elementos distintos en el prefijo y 1 elemento distinto en el sufijo. Por lo tanto, diff[3] = 3 - 1 = 2.
Para el índice i = 4, hay 3 elementos distintos en el prefijo y ningún elemento en el sufijo. Por lo tanto, diff[4] = 3 - 0 = 3.

Restricciones:

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


Se tiene un array nums de índice 0 de longitud n. Inicialmente, todos los elementos están sin colorear (tiene valor 0).
Se le da un array entero 2D consultas donde consultas[i] = [índice_i, color_i].
Para cada consulta, se colorea el índice index_i con el color color_i en el array nums.
Devuelve un array respuesta de la misma longitud que consultas donde respuesta[i] es el número de elementos adyacentes con el mismo color después de la consulta i^ésima.
Más formalmente, respuesta[i] es el número de índices j, tales que 0 <= j < n - 1 y nums[j] == nums[j + 1] y nums[j] != 0 después de la i^ésima consulta.

Ejemplo 1:

Entrada: n = 4, consultas = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Salida: [0,1,1,0,2]
Explicación: Inicialmente array nums = [0,0,0,0], donde 0 denota elementos no coloreados del array.
- Después de la 1^a consulta nums = [2,0,0,0]. El recuento de elementos adyacentes con el mismo color es 0.
- Después de la 2^a consulta nums = [2,2,0,0]. El recuento de elementos adyacentes con el mismo color es 1.
- Después de la 3^a consulta nums = [2,2,0,1]. El recuento de elementos adyacentes con el mismo color es 1.
- Después de la 4^a consulta nums = [2,1,0,1]. El recuento de elementos adyacentes con el mismo color es 0.
- Después de la 5^a consulta nums = [2,1,1,1]. El recuento de elementos adyacentes con el mismo color es 2.

Ejemplo 2

Entrada: n = 1, consultas = [[0,100000]]
Salida: [0]
Explicación: Inicialmente array nums = [0], donde 0 denota elementos no coloreados del array.
- Después de la 1^ª consulta nums = [100000]. El número de elementos adyacentes con el mismo color es 0.

Restricciones:

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

Hay una matriz indexada en 0 nums de longitud n. Inicialmente, todos los elementos no están coloreados (tienen un valor de 0).
Se le proporciona una matriz de enteros 2D consultas donde consultas[i] = [índice_i, color_i].
Para cada consulta, colorea el índice index_i con el color color_i en la matriz nums.
Devuelve una matriz respuesta de la misma longitud que consultas donde respuesta[i] es la cantidad de elementos adyacentes con el mismo color después de la consulta i^th.
Más formalmente, respuesta[i] es la cantidad de índices j, de modo que 0 <= j < n - 1 y nums[j] == nums[j + 1] y nums[j] != 0 después de la consulta i^th.

Ejemplo 1:

Entrada: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Salida: [0,1,1,0,2]
Explicación: Inicialmente, la matriz nums = [0,0,0,0], donde 0 denota elementos sin color de la matriz.
- Después de la 1^a consulta nums = [2,0,0,0]. El recuento de elementos adyacentes con el mismo color es 0.
- Después de la 2^a consulta nums = [2,2,0,0]. El recuento de elementos adyacentes con el mismo color es 1.
- Después de la 3^a consulta nums = [2,2,0,1]. El recuento de elementos adyacentes con el mismo color es 1.
- Después de la 4^a consulta nums = [2,1,0,1]. El recuento de elementos adyacentes con el mismo color es 0.
- Después de la 5^a consulta nums = [2,1,1,1]. El recuento de elementos adyacentes con el mismo color es 2.

Ejemplo 2:

Entrada: n = 1, queries = [[0,100000]]
Salida: [0]
Explicación: Inicialmente, la matriz nums = [0], donde 0 denota elementos sin color de la matriz.
- Después de la 1^a consulta nums = [100000]. El recuento de elementos adyacentes con el mismo color es 0.

Restricciones:

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

Hay un array nums indexado a partir de 0 de longitud n. Inicialmente, todos los elementos están sin colorear (tienen un valor de 0).
Se te da un array 2D de enteros queries donde queries[i] = [index_i, color_i].
Para cada consulta, coloreas el índice index_i con el color color_i en el array nums.
Devuelve un array answer de la misma longitud que queries, donde answer[i] es el número de elementos adyacentes con el mismo color después de la i-ésima consulta.
De manera más formal, answer[i] es el número de índices j, tal que 0 <= j < n - 1 y nums[j] == nums[j + 1] y nums[j] != 0 después de la i-ésima consulta.

Ejemplo 1:

Entrada: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Salida: [0,1,1,0,2]
Explicación: Inicialmente array nums = [0,0,0,0], donde 0 denota elementos sin colorear del array.
- Después de la 1^era consulta nums = [2,0,0,0]. El conteo de elementos adyacentes con el mismo color es 0.
- Después de la 2^da consulta nums = [2,2,0,0]. El conteo de elementos adyacentes con el mismo color es 1.
- Después de la 3^era consulta nums = [2,2,0,1]. El conteo de elementos adyacentes con el mismo color es 1.
- Después de la 4^ta consulta nums = [2,1,0,1]. El conteo de elementos adyacentes con el mismo color es 0.
- Después de la 5^ta consulta nums = [2,1,1,1]. El conteo de elementos adyacentes con el mismo color es 2.

Ejemplo 2:

Entrada: n = 1, queries = [[0,100000]]
Salida: [0]
Explicación: Inicialmente array nums = [0], donde 0 denota elementos sin colorear del array.
- Después de la 1^era consulta nums = [100000]. El conteo de elementos adyacentes con el mismo color es 0.

Restricciones:

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


Se le proporciona una matriz de números enteros indexada en 0 que representa la fuerza de algunos héroes. La potencia de un grupo de héroes se define de la siguiente manera:

Sea i_0, i_1, ... ,i_k los índices de los héroes de un grupo. Entonces, la potencia de este grupo es max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Devuelve la suma de la potencia de todos los grupos de héroes no vacíos posibles. Como la suma podría ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,1,4]
Salida: 141
Explicación:
1^er grupo: [2] tiene potencia = 2^2 * 2 = 8.
2^do grupo: [1] tiene potencia = 1^2 * 1 = 1.
3^er grupo: [4] tiene potencia = 4^2 * 4 = 64.
4^to grupo: [2,1] tiene potencia = 2^2 * 1 = 4.
5^to grupo: [2,4] tiene potencia = 4^2 * 2 = 32.
6^to grupo: [1,4] tiene potencia = 4^2 * 1 = 16.
7^to grupo: [2,1,4] tiene potencia = 4^2 * 1 = 16.
La suma de las potencias de todos los grupos es 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Ejemplo 2:

Entrada: nums = [1,1,1]
Salida: 7
Explicación: Son posibles un total de 7 grupos y la potencia de cada grupo será 1. Por lo tanto, la suma de las potencias de todos los grupos es 7.

Restricciones:

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

Se te da un array de enteros indexado desde 0 nums que representa la fuerza de algunos héroes. La potencia de un grupo de héroes se define de la siguiente manera:

Sean i_0, i_1, ... ,i_k los índices de los héroes en un grupo. Entonces, la potencia de este grupo es max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Devuelve la suma de la potencia de todos los grupos no vacíos de héroes posibles. Dado que la suma podría ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,1,4]
Salida: 141
Explicación:
1^er grupo: [2] tiene potencia = 2^2 * 2 = 8.
2^do grupo: [1] tiene potencia = 1^2 * 1 = 1.
3^er grupo: [4] tiene potencia = 4^2 * 4 = 64.
4^to grupo: [2,1] tiene potencia = 2^2 * 1 = 4.
5^to grupo: [2,4] tiene potencia = 4^2 * 2 = 32.
6^to grupo: [1,4] tiene potencia = 4^2 * 1 = 16.
7^mo grupo: [2,1,4] tiene potencia = 4^2 * 1 = 16.
La suma de las potencias de todos los grupos es 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Ejemplo 2:

Entrada: nums = [1,1,1]
Salida: 7
Explicación: Un total de 7 grupos son posibles, y la potencia de cada grupo será 1. Por lo tanto, la suma de las potencias de todos los grupos es 7.

Restricciones:

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

Se te da un array de enteros indexado desde 0 `nums` que representa la fuerza de algunos héroes. La potencia de un grupo de héroes se define de la siguiente manera:

Sean i_0, i_1, ... ,i_k los índices de los héroes en un grupo. Entonces, la potencia de este grupo es max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Devuelve la suma de la potencia de todos los grupos no vacíos de héroes posibles. Dado que la suma podría ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,1,4]
Salida: 141
Explicación:
1^er grupo: [2] tiene potencia = 2^2 * 2 = 8.
2^do grupo: [1] tiene potencia = 1^2 * 1 = 1.
3^er grupo: [4] tiene potencia = 4^2 * 4 = 64.
4^to grupo: [2,1] tiene potencia = 2^2 * 1 = 4.
5^to grupo: [2,4] tiene potencia = 4^2 * 2 = 32.
6^to grupo: [1,4] tiene potencia = 4^2 * 1 = 16.
7^mo grupo: [2,1,4] tiene potencia = 4^2 * 1 = 16.
La suma de las potencias de todos los grupos es 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Ejemplo 2:

Entrada: nums = [1,1,1]
Salida: 7
Explicación: Un total de 7 grupos son posibles, y la potencia de cada grupo será 1. Por lo tanto, la suma de las potencias de todos los grupos es 7.

Restricciones:

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


Se te da una permutación indexada desde 0 de n enteros nums.
Una permutación se llama semi-ordenada si el primer número es igual a 1 y el último número es igual a n. Puedes realizar la siguiente operación tantas veces como desees hasta que nums sea una permutación semi-ordenada:

Elige dos elementos adyacentes en nums, luego intercámbialos.

Devuelve el número mínimo de operaciones para hacer que nums sea una permutación semi-ordenada.
Una permutación es una secuencia de enteros del 1 al n de longitud n que contiene cada número exactamente una vez.

Ejemplo 1:

Entrada: nums = [2,1,4,3]
Salida: 2
Explicación: Podemos hacer que la permutación sea semi-ordenada usando esta secuencia de operaciones:
1 - intercambiar i = 0 y j = 1. La permutación se convierte en [1,2,4,3].
2 - intercambiar i = 2 y j = 3. La permutación se convierte en [1,2,3,4].
Se puede probar que no hay una secuencia de menos de dos operaciones que haga que nums sea una permutación semi-ordenada.

Ejemplo 2:

Entrada: nums = [2,4,1,3]
Salida: 3
Explicación: Podemos hacer que la permutación sea semi-ordenada usando esta secuencia de operaciones:
1 - intercambiar i = 1 y j = 2. La permutación se convierte en [2,1,4,3].
2 - intercambiar i = 0 y j = 1. La permutación se convierte en [1,2,4,3].
3 - intercambiar i = 2 y j = 3. La permutación se convierte en [1,2,3,4].
Se puede probar que no hay una secuencia de menos de tres operaciones que haga que nums sea una permutación semi-ordenada.

Ejemplo 3:

Entrada: nums = [1,3,4,2,5]
Salida: 0
Explicación: La permutación ya es una permutación semi-ordenada.

Restricciones:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums es una permutación.

Se le proporciona una permutación de n números enteros con índice 0.
Una permutación se denomina semiordenada si el primer número es igual a 1 y el último número es igual a n. Puede realizar la siguiente operación tantas veces como desee hasta que haga de nums una permutación semiordenada:

Seleccione dos elementos adyacentes en nums y luego intercámbielos.

Devuelva el número mínimo de operaciones para hacer de nums una permutación semiordenada.
Una permutación es una secuencia de números enteros del 1 al n de longitud n que contiene cada número exactamente una vez.

Ejemplo 1:

Entrada: nums = [2,1,4,3]
Salida: 2
Explicación: Podemos hacer que la permutación sea semiordenada utilizando esta secuencia de operaciones:
1 - intercambiar i = 0 y j = 1. La permutación se convierte en [1,2,4,3].
2 - intercambiamos i = 2 y j = 3. La permutación se convierte en [1,2,3,4].
Se puede demostrar que no existe una secuencia de menos de dos operaciones que hagan de nums una permutación semiordenada.

Ejemplo 2:

Entrada: nums = [2,4,1,3]
Salida: 3
Explicación: Podemos hacer que la permutación sea semiordenada utilizando esta secuencia de operaciones:
1 - intercambiamos i = 1 y j = 2. La permutación se convierte en [2,1,4,3].
2 - intercambiamos i = 0 y j = 1. La permutación se convierte en [1,2,4,3].
3 - intercambiamos i = 2 y j = 3. La permutación se convierte en [1,2,3,4].
Se puede demostrar que no existe una secuencia de menos de tres operaciones que hagan de nums una permutación semiordenada.

Ejemplo 3:

Entrada: nums = [1,3,4,2,5]
Salida: 0
Explicación: La permutación ya es una permutación semiordenada.

Restricciones:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums es una permutación.


Se le proporciona una cadena s indexada en 0 que consta de dígitos del 0 al 9.
Una cadena t se denomina semirrepetitiva si hay como máximo un par consecutivo de los mismos dígitos dentro de t. Por ejemplo, 0010, 002020, 0123, 2002 y 54944 son semirrepetitivos, mientras que 00101022 y 1101234883 no lo son.
Devuelve la longitud de la subcadena semirrepetitiva más larga dentro de s.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "52233"
Salida: 4
Explicación: La subcadena semirrepetitiva más larga es "5223", que comienza en i = 0 y termina en j = 3.

Ejemplo 2:

Entrada: s = "5494"
Salida: 4
Explicación: s es una cadena semirrepetitiva, por lo que la respuesta es 4.

Ejemplo 3:

Entrada: s = "1111111"
Salida: 2
Explicación: La subcadena semirrepetitiva más larga es "11", que comienza en i = 0 y termina en j = 1.

Restricciones:

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

Se te da una cadena `s` indexada desde 0 que consiste en dígitos del 0 al 9.
Una cadena `t` se llama semi-repetitiva si hay como máximo un par consecutivo del mismo dígito dentro de `t`. Por ejemplo, 0010, 002020, 0123, 2002 y 54944 son semi-repetitivas mientras que 00101022 y 1101234883 no lo son.
Devuelve la longitud de la subcadena semi-repetitiva más larga dentro de `s`.
Una subcadena es una secuencia continua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "52233"
Salida: 4
Explicación: La subcadena semi-repetitiva más larga es "5223", que comienza en i = 0 y termina en j = 3.

Ejemplo 2:

Entrada: s = "5494"
Salida: 4
Explicación: s es una cadena semi-repetitiva, por lo que la respuesta es 4.

Ejemplo 3:

Entrada: s = "1111111"
Salida: 2
Explicación: La subcadena semi-repetitiva más larga es "11", que comienza en i = 0 y termina en j = 1.

Restricciones:

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


Hay n amigos que están jugando un juego. Los amigos están sentados en un círculo y están numerados del 1 al n en sentido horario. Más formalmente, moverse en el sentido horario desde el amigo i^enésima te lleva al amigo (i+1)^enésima para 1 <= i < n, y moverse en sentido horario desde el amigo n^enésima te lleva al amigo 1^er.
Las reglas del juego son las siguientes:
El 1^er amigo recibe la pelota.

Después de eso, el 1^er amigo se la pasa al amigo que está k pasos alejado de ellos en el sentido horario.
Después de eso, el amigo que recibe la pelota debe pasársela al amigo que está 2 * k pasos alejado de ellos en el sentido horario.
Después de eso, el amigo que recibe la pelota debe pasársela al amigo que está 3 * k pasos alejado de ellos en el sentido horario, y así sucesivamente.

En otras palabras, en el turno i^enésima, el amigo que tiene la pelota debe pasársela al amigo que está i * k pasos alejado de ellos en el sentido horario.
El juego termina cuando algún amigo recibe la pelota por segunda vez.
Los perdedores del juego son los amigos que no recibieron la pelota en todo el juego.
Dado el número de amigos, n, y un entero k, devuelve el array answer, que contiene los perdedores del juego en orden ascendente.

Ejemplo 1:

Entrada: n = 5, k = 2
Salida: [4,5]
Explicación: El juego procede de la siguiente manera:
1) Comienza en el 1^er amigo y pasa la pelota al amigo que está 2 pasos alejado de ellos - 3^er amigo.
2) El 3^er amigo pasa la pelota al amigo que está 4 pasos alejado de ellos - 2^do amigo.
3) El 2^do amigo pasa la pelota al amigo que está 6 pasos alejado de ellos - 3^er amigo.
4) El juego termina cuando el 3^er amigo recibe la pelota por segunda vez.

Ejemplo 2:

Entrada: n = 4, k = 4
Salida: [2,3,4]
Explicación: El juego procede de la siguiente manera:
1) Comienza en el 1^er amigo y pasa la pelota al amigo que está 4 pasos alejado de ellos - 1^er amigo.
2) El juego termina cuando el 1^er amigo recibe la pelota por segunda vez.

Restricciones:

1 <= k <= n <= 50

Hay n amigos que están jugando un juego. Los amigos están sentados en un círculo y están numerados del 1 al n en el sentido de las agujas del reloj. Más formalmente, si se avanza en el sentido de las agujas del reloj desde el i^ésimo amigo se llega al (i+1)^ésimo amigo para 1 <= i < n, y si se avanza en el sentido de las agujas del reloj desde el n^ésimo amigo se llega al 1^er amigo.
Las reglas del juego son las siguientes:
1^er amigo recibe la pelota.

Después, el 1^er amigo se la pasa al amigo que está a k pasos de distancia de él en el sentido de las agujas del reloj.
Después, el amigo que recibe la pelota debe pasársela al amigo que está a 2 * k pasos de distancia de él en el sentido de las agujas del reloj.
Después, el amigo que recibe la pelota debe pasársela al amigo que está a 3 * k pasos de distancia de él en el sentido de las agujas del reloj, y así sucesivamente.

En otras palabras, en el turno i, el amigo que tiene la pelota debe pasársela al amigo que está a i * k pasos de él en el sentido de las agujas del reloj.
El juego termina cuando algún amigo recibe la pelota por segunda vez.
Los perdedores del juego son los amigos que no recibieron la pelota en todo el juego.
Dada la cantidad de amigos, n, y un entero k, devuelve la respuesta de la matriz, que contiene a los perdedores del juego en orden ascendente.

Ejemplo 1:

Entrada: n = 5, k = 2
Salida: [4,5]
Explicación: El juego se desarrolla de la siguiente manera:
1) Comienza con el 1.er amigo y pasa la pelota al amigo que está a 2 pasos de él: 3.er amigo.
2) El 3.er amigo pasa la pelota al amigo que está a 4 pasos de él: 2.º amigo.
3) El 2.º amigo pasa la pelota al amigo que está a 6 pasos de él: 3.er amigo.
4) El juego termina cuando el 3er amigo recibe la pelota por segunda vez.

Ejemplo 2:

Entrada: n = 4, k = 4
Salida: [2,3,4]
Explicación: El juego se desarrolla de la siguiente manera:
1) Comienza en el 1er amigo y pasa la pelota al amigo que está a 4 pasos de él: el 1er amigo.
2) El juego termina cuando el 1er amigo recibe la pelota por segunda vez.

Restricciones:

1 <= k <= n <= 50

Hay n amigos que están jugando un juego. Los amigos están sentados en un círculo y están numerados del 1 al n en el sentido de las agujas del reloj. Más formalmente, si se avanza en el sentido de las agujas del reloj desde el i^ésimo amigo se llega al (i+1)^ésimo amigo para 1 <= i < n, y si se avanza en el sentido de las agujas del reloj desde el n^ésimo amigo se llega al 1^er amigo.
Las reglas del juego son las siguientes:
1^er amigo recibe la pelota.

Después, el 1^er amigo se la pasa al amigo que está a k pasos de distancia de él en el sentido de las agujas del reloj.
Después, el amigo que recibe la pelota debe pasársela al amigo que está a 2 * k pasos de distancia de él en el sentido de las agujas del reloj.
Después, el amigo que recibe la pelota debe pasársela al amigo que está a 3 * k pasos de distancia de él en el sentido de las agujas del reloj, y así sucesivamente.

En otras palabras, en el turno i, el amigo que tiene la pelota debe pasársela al amigo que está a i * k pasos de él en el sentido de las agujas del reloj.
El juego termina cuando algún amigo recibe la pelota por segunda vez.
Los perdedores del juego son los amigos que no recibieron la pelota en todo el juego.
Dada la cantidad de amigos, n, y un entero k, devuelve la respuesta de la matriz, que contiene a los perdedores del juego en orden ascendente.

Ejemplo 1:

Entrada: n = 5, k = 2
Salida: [4,5]
Explicación: El juego se desarrolla de la siguiente manera:
1) Comienza con el 1.er amigo y pasa la pelota al amigo que está a 2 pasos de él: 3.er amigo.
2) El 3.er amigo pasa la pelota al amigo que está a 4 pasos de él: 2.º amigo.
3) El 2.º amigo pasa la pelota al amigo que está a 6 pasos de él: 3.er amigo.
4) El juego termina cuando el 3er amigo recibe la pelota por segunda vez.

Ejemplo 2:

Entrada: n = 4, k = 4
Salida: [2,3,4]
Explicación: El juego se desarrolla de la siguiente manera:
1) Empieza en el 1^er amigo y pasa la pelota al amigo que está a 4 pasos de ellos - 1^er amigo.
2) El juego termina cuando el primer amigo recibe el balón por segunda vez.

Restricciones:

1 <= k <= n <= 50


Un arreglo 0-indexado llamado derived con longitud n se obtiene calculando el XOR bit a bit (⊕) de valores adyacentes en un arreglo binario original de longitud n. Específicamente, para cada índice i en el rango [0, n - 1]:

Si i = n - 1, entonces derived[i] = original[i] ⊕ original[0].
De lo contrario, derived[i] = original[i] ⊕ original[i + 1].

Dado un arreglo derived, tu tarea es determinar si existe un arreglo binario original válido que pudo haber formado derived. Devuelve true si tal arreglo existe o false en caso contrario.

Un arreglo binario es un arreglo que contiene solo 0's y 1's.

Ejemplo 1:

Entrada: derived = [1,1,0]
Salida: true
Explicación: Un arreglo original válido que da derived es [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

Ejemplo 2:

Entrada: derived = [1,1]
Salida: true
Explicación: Un arreglo original válido que da derived es [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Ejemplo 3:

Entrada: derived = [1,0]
Salida: false
Explicación: No hay un arreglo original válido que dé derived.

Restricciones:

n == derived.length
1 <= n <= 10^5
Los valores en derived son 0's o 1's.

Una matriz indexada 0 derivada con longitud n se deriva calculando el XOR bit a bit (⊕) de los valores adyacentes en una matriz binaria original de longitud n.
En concreto, para cada índice i en el intervalo [0, n - 1]:

Si i = n - 1, entonces derivado[i] = original[i] ⊕ original[0].
De lo contrario, derivado[i] = original[i] ⊕ original[i + 1].

Dada una matriz derivada, su tarea es determinar si existe una matriz binaria válida original que podría haberse formado derivada.
Devuelve true si existe una matriz de este tipo o false en caso contrario.

Una matriz binaria es una matriz que contiene solo 0 y 1

Ejemplo 1:

Entrada: derivada = [1,1,0]
Salida: true
Explicación: Una matriz original válida que da derivado es [0,1,0].
derivado[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derivado[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derivado[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Ejemplo 2:

Entrada: derivada = [1,1]
Salida: true
Explicación: Una matriz original válida que da derivado es [0,1].
derivado[0] = original[0] ⊕ original[1] = 1
derivado[1] = original[1] ⊕ original[0] = 1

Ejemplo 3:

Entrada: derivada = [1,0]
Salida: false
Explicación: No hay una matriz original válida que dé derivado.

Restricciones:

n == derived.length
1 <= n <= 10^5
Los valores de derivado son 0 o 1

Una matriz derivada de índice 0 con longitud n se obtiene calculando el XOR a nivel de bits (⊕) de valores adyacentes en una matriz binaria original de longitud n.
Específicamente, para cada índice i en el rango [0, n - 1]:

Si i = n - 1, entonces derivado[i] = original[i] ⊕ original[0].
En caso contrario, derivado[i] = original[i] ⊕ original[i + 1].

Dado un array derivado, tu tarea es determinar si existe un array binario válido original que podría haber formado derivado.
Devuelve verdadero si existe tal matriz o falso en caso contrario.

Una matriz binaria es una matriz que sólo contiene 0 y 1.

Ejemplo 1:

Entrada: derivado = [1,1,0]
Salida: true
Explicación: Un array original válido que da derivado es [0,1,0].
derivado[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derivado[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derivado[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Ejemplo 2:

Entrada: derivado = [1,1]
Salida: true
Explicación: Un array original válido que da derivado es [0,1].
derivado[0] = original[0] ⊕ original[1] = 1
derivado[1] = original[1] ⊕ original[0] = 1

Ejemplo 3:

Entrada: derivado = [1,0]
Salida: false
Explicación: No hay ningún array original válido que dé derivado.

Restricciones:

n == derived.length
1 <= n <= 10^5
Los valores en derived son 0's o 1's


Se le proporciona una cadena s que consta únicamente de letras mayúsculas en inglés.
Puede aplicar algunas operaciones a esta cadena donde, en una operación, puede eliminar cualquier ocurrencia de una de las subcadenas "AB" o "CD" de s.
Devuelve la longitud mínima posible de la cadena resultante que puede obtener.
Tenga en cuenta que la cadena se concatena después de eliminar la subcadena y podría producir nuevas subcadenas "AB" o "CD".

Ejemplo 1:

Entrada: s = "ABFCACDB"
Salida: 2
Explicación: Podemos realizar las siguientes operaciones:
- Eliminar la subcadena "ABFCACDB", por lo que s = "FCACDB".
- Eliminar la subcadena "FCACDB", por lo que s = "FCAB".
- Eliminar la subcadena "FCAB", por lo que s = "FC".
Por lo tanto, la longitud resultante de la cadena es 2.
Se puede demostrar que es la longitud mínima que podemos obtener.
Ejemplo 2:

Entrada: s = "ACBBD"
Salida: 5
Explicación: No podemos realizar ninguna operación en la cadena, por lo que la longitud permanece igual.

Restricciones:

1 <= s.length <= 100
s consta únicamente de letras mayúsculas en inglés.

Dada una cadena s compuesta solo de letras mayúsculas del alfabeto inglés.
Puedes aplicar algunas operaciones a esta cadena donde, en una operación, puedes eliminar cualquier aparición de uno de los subconjuntos "AB" o "CD" de s.
Devuelve la longitud mínima posible de la cadena resultante que puedes obtener.
Ten en cuenta que la cadena se concatena después de eliminar el subconjunto y podría producir nuevos subconjuntos "AB" o "CD".

Ejemplo 1:

Entrada: s = "ABFCACDB"
Salida: 2
Explicación: Podemos hacer las siguientes operaciones:
- Eliminar el subconjunto "ABFCACDB", así que s = "FCACDB".
- Eliminar el subconjunto "FCACDB", así que s = "FCAB".
- Eliminar el subconjunto "FCAB", así que s = "FC".
Por lo tanto, la longitud resultante de la cadena es 2.
Se puede demostrar que es la longitud mínima que podemos obtener.
Ejemplo 2:

Entrada: s = "ACBBD"
Salida: 5
Explicación: No podemos hacer ninguna operación en la cadena, así que la longitud permanece igual.

Restricciones:

1 <= s.length <= 100
s está compuesta solo de letras mayúsculas del alfabeto inglés.

Dada una cadena s compuesta solo de letras mayúsculas del alfabeto inglés.
Puedes aplicar algunas operaciones a esta cadena donde, en una operación, puedes eliminar cualquier aparición de uno de los subconjuntos "AB" o "CD" de s.
Devuelve la longitud mínima posible de la cadena resultante que puedes obtener.
Ten en cuenta que la cadena se concatena después de eliminar el subconjunto y podría producir nuevos subconjuntos "AB" o "CD".

Ejemplo 1:

Entrada: s = "ABFCACDB"
Salida: 2
Explicación: Podemos realizar las siguientes operaciones:
- Eliminar el subconjunto "ABFCACDB", para que s = "FCACDB".
- Eliminar el subconjunto "FCACDB", para que s = "FCAB".
- Eliminar el subconjunto "FCAB", así que s = "FC".
Por lo tanto, la longitud resultante de la cadena es 2.
Se puede demostrar que es la longitud mínima que podemos obtener.
Ejemplo 2:

Entrada: s = "ACBBD"
Salida: 5
Explicación: No podemos realizar ninguna operación en la cadena, por lo que la longitud permanece igual.

Restricciones:

1 <= s.length <= 100
s está compuesta solo de letras mayúsculas del alfabeto inglés.


Dado un entero positivo n, devuelve el número de castigo de n.
El número de castigo de n se define como la suma de los cuadrados de todos los enteros i tales que:

1 <= i <= n
La representación decimal de i * i se puede dividir en subcadenas contiguas de tal manera que la suma de los valores enteros de estas subcadenas sea igual a i.

Ejemplo 1:

Entrada: n = 10
Salida: 182
Explicación: Hay exactamente 3 enteros i que satisfacen las condiciones en el enunciado:
- 1 ya que 1 * 1 = 1
- 9 ya que 9 * 9 = 81 y 81 se puede dividir en 8 + 1.
- 10 ya que 10 * 10 = 100 y 100 se puede dividir en 10 + 0.
Por lo tanto, el número de castigo de 10 es 1 + 81 + 100 = 182

Ejemplo 2:

Entrada: n = 37
Salida: 1478
Explicación: Hay exactamente 4 enteros i que satisfacen las condiciones en el enunciado:
- 1 ya que 1 * 1 = 1.
- 9 ya que 9 * 9 = 81 y 81 se puede dividir en 8 + 1.
- 10 ya que 10 * 10 = 100 y 100 se puede dividir en 10 + 0.
- 36 ya que 36 * 36 = 1296 y 1296 se puede dividir en 1 + 29 + 6.
Por lo tanto, el número de castigo de 37 es 1 + 81 + 100 + 1296 = 1478

Restricciones:

1 <= n <= 1000

Dado un entero positivo n, devuelve el número de castigo de n.
El número de castigo de n se define como la suma de los cuadrados de todos los enteros i tales que:

1 <= i <= n
La representación decimal de i * i se puede dividir en subcadenas contiguas de modo que la suma de los valores enteros de estas subcadenas sea igual a i.

Ejemplo 1:

Entrada: n = 10
Salida: 182
Explicación: Hay exactamente 3 enteros i que satisfacen las condiciones de la declaración:
- 1 ya que 1 * 1 = 1
- 9 ya que 9 * 9 = 81 y 81 se puede dividir en 8 + 1.
- 10 ya que 10 * 10 = 100 y 100 se puede dividir en 10 + 0.
Por lo tanto, el número de castigo de 10 es 1 + 81 + 100 = 182

Ejemplo 2:

Entrada: n = 37
Salida: 1478
Explicación: Hay exactamente 4 enteros i que satisfacen las condiciones de la declaración:
- 1 ya que 1 * 1 = 1.
- 9 ya que 9 * 9 = 81 y 81 se puede dividir en 8 + 1.
- 10 ya que 10 * 10 = 100 y 100 se puede dividir en 10 + 0.
- 36 ya que 36 * 36 = 1296 y 1296 se puede dividir en 1 + 29 + 6.
Por lo tanto, el número de castigo de 37 es 1 + 81 + 100 + 1296 = 1478

Restricciones:

1 <= n <= 1000


Se te dan dos arreglos de enteros indexados desde cero, cost y time, de tamaño n, que representan los costos y el tiempo necesario para pintar n paredes diferentes, respectivamente. Hay dos pintores disponibles:

Un pintor de pago que pinta la i-ésima pared en time[i] unidades de tiempo y requiere cost[i] unidades de dinero.
Un pintor gratuito que pinta cualquier pared en 1 unidad de tiempo sin costo. Pero el pintor gratuito solo puede ser utilizado si el pintor de pago ya está ocupado.

Devuelve la cantidad mínima de dinero requerida para pintar las n paredes.

Ejemplo 1:

Entrada: cost = [1,2,3,2], time = [1,2,3,2]
Salida: 3
Explicación: Las paredes en los índices 0 y 1 serán pintadas por el pintor de pago, y tomará 3 unidades de tiempo; mientras tanto, el pintor gratuito pintará las paredes en los índices 2 y 3, sin costo en 2 unidades de tiempo. Por lo tanto, el costo total es 1 + 2 = 3.

Ejemplo 2:

Entrada: cost = [2,3,4,2], time = [1,1,1,1]
Salida: 4
Explicación: Las paredes en los índices 0 y 3 serán pintadas por el pintor de pago, y tomará 2 unidades de tiempo; mientras tanto, el pintor gratuito pintará las paredes en los índices 1 y 2, sin costo en 2 unidades de tiempo. Por lo tanto, el costo total es 2 + 2 = 4.

Restricciones:

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

Se dan dos matrices de enteros con índice 0, coste y tiempo, de tamaño n que representan los costes y el tiempo necesarios para pintar n paredes diferentes respectivamente. Hay dos pintores disponibles:

Un pintor de pago que pinta la i^ésima pared en tiempo[i] unidades de tiempo y se lleva coste[i] unidades de dinero.
Un pintor gratuito que pinta cualquier pared en 1 unidad de tiempo con un coste de 0. Pero el pintor gratuito sólo se puede utilizar si el pintor de pago ya está ocupado.

Devuelve la cantidad mínima de dinero necesaria para pintar las n paredes.

Ejemplo 1:

Entrada: cost = [1,2,3,2], time = [1,2,3,2]
Salida: 3
Explicación: Las paredes de índice 0 y 1 serán pintadas por el pintor pagado, y le llevará 3 unidades de tiempo; mientras tanto, el pintor libre pintará las paredes de índice 2 y 3, sin coste en 2 unidades de tiempo. Por tanto, el coste total es 1 + 2 = 3.

Ejemplo 2:

Entrada: cost = [2,3,4,2], time = [1,1,1,1]
Salida: 4
Explicación: Las paredes de índice 0 y 3 serán pintadas por el pintor pagado, y tardará 2 unidades de tiempo; mientras tanto, el pintor libre pintará las paredes de índice 1 y 2, sin coste en 2 unidades de tiempo. Por tanto, el coste total es 2 + 2 = 4.

Restricciones:

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

Se te dan dos array de enteros indexados desde cero, cost y time, de tamaño n, que representan los costos y el tiempo necesario para pintar n paredes diferentes, respectivamente. Hay dos pintores disponibles:

Un pintor de pago que pinta la i-ésima pared en time[i] unidades de tiempo y requiere cost[i] unidades de dinero.
Un pintor gratuito que pinta cualquier pared en 1 unidad de tiempo sin costo. Pero el pintor gratuito solo puede ser utilizado si el pintor de pago ya está ocupado

Devuelve la cantidad mínima de dinero requerida para pintar las n paredes.

Ejemplo 1:

Entrada: cost = [1,2,3,2], time = [1,2,3,2]
Salida: 3
Explicación: Las paredes en los índices 0 y 1 serán pintadas por el pintor de pago, y tomará 3 unidades de tiempo; mientras tanto, el pintor gratuito pintará las paredes en los índices 2 y 3, sin costo en 2 unidades de tiempo. Por lo tanto, el costo total es 1 + 2 = 3.

Ejemplo 2:

Entrada: cost = [2,3,4,2], time = [1,1,1,1]
Salida: 4
Explicación: Las paredes en los índices 0 y 3 serán pintadas por el pintor de pago, y tomará 2 unidades de tiempo; mientras tanto, el pintor gratuito pintará las paredes en los índices 1 y 2, sin costo en 2 unidades de tiempo. Por lo tanto, el costo total es 2 + 2 = 4.

Restricciones:

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