El patrón del papel tapiz de AtCoder se puede representar en el plano xy de la siguiente manera:

-
El plano está dividido por los siguientes tres tipos de líneas:

-
x = n (donde n es un número entero)

-
y = n (donde n es un número par)

-
x + y = n (donde n es un número par)

-
Cada región está pintada de negro o blanco. Dos regiones adyacentes a lo largo de una de estas líneas están pintadas en diferentes colores.

-
La región que contiene (0.5, 0.5) está pintada de negro.

La siguiente figura muestra una parte del patrón.

Se te dan los enteros A, B, C, D. Considera un rectángulo cuyos lados son paralelos a los ejes x e y, con el vértice inferior izquierdo en (A, B) y el vértice superior derecho en (C, D). Calcula el área de las regiones pintadas de negro dentro de este rectángulo y imprime el doble de esa área. Se puede demostrar que el valor de salida será un número entero.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
A B C D

Salida

Imprime la respuesta en una sola línea.

Restricciones

- -10^9 \leq A, B, C, D \leq 10^9
- A < C y B < D.
- Todos los valores de entrada son enteros.

Entrada de muestra 1

0 0 3 3

Salida de muestra 1

10

Debemos encontrar el área de la región pintada de negro dentro del siguiente cuadrado:

El área es 5, así que imprime el doble de ese valor: 10.

Entrada de muestra 2

-1 -2 1 3

Salida de muestra 2

11

El área es 5.5, que no es un número entero, pero el valor de salida es un número entero.

Entrada de muestra 3

-1000000000 -1000000000 1000000000 1000000000

Salida de muestra 3

4000000000000000000

Este es el caso con el rectángulo más grande, donde el resultado aún cabe en un entero con signo de 64 bits.

El patrón del fondo de pantalla de AtCoder se puede representar en el plano xy de la siguiente manera:

-
El plano está dividido por los siguientes tres tipos de líneas:

-
x = n (donde n es un entero)

-
y = n (donde n es un número par)

-
x + y = n (donde n es un número par)

-
Cada región está pintada de negro o blanco. Dos regiones cualesquiera adyacentes a lo largo de una de estas líneas están pintadas de diferentes colores.

-
La región que contiene (0,5, 0,5) está pintada de negro.

La siguiente figura muestra una parte del patrón.

Se le dan los números enteros A, B, C, D. Considere un rectángulo cuyos lados son paralelos a los ejes x e y, con su vértice inferior izquierdo en (A, B) y su vértice superior derecho en (C, D). Calcule el área de las regiones pintadas de negro dentro de este rectángulo e imprima el doble de esa área.
Se puede demostrar que el valor de salida será un entero.

Entrada

La entrada se proporciona desde la Entrada estándar en el siguiente formato:
A B C D

Salida

Imprima la respuesta en una sola línea.

Restricciones

- -10^9 \leq A, B, C, D \leq 10^9
- A < C y B < D.
- Todos los valores de entrada son enteros.

Entrada de muestra 1

0 0 3 3

Salida de muestra 1

10

Debemos encontrar el área de la región pintada de negro dentro del siguiente cuadrado:

El área es 5, por lo que imprima el doble de ese valor: 10.

Entrada de muestra 2

-1 -2 1 3

Salida de muestra 2

11

El área es 5, que no es un entero, pero el valor de salida es un entero.

Entrada de muestra 3

-1000000000 -1000000000 1000000000 1000000000

Salida de muestra 3

4000000000000000000

Este es el caso del rectángulo más grande, donde la salida aún cabe en un entero con signo de 64 bits.

El patrón del papel pintado de AtCoder puede representarse en el plano xy de la siguiente manera:

-
El plano está dividido por los tres tipos de líneas siguientes:

-
x = n (donde n es un número entero)

-
y = n (donde n es un número par)

-
x + y = n (donde n es un número par)

-
Cada región se pinta de negro o blanco. Dos regiones adyacentes a lo largo de una de estas líneas se pintan en colores diferentes.

-
La región que contiene (0,5, 0,5) se pinta de negro.

La siguiente figura muestra una parte del patrón.

Se le dan los números enteros A, B, C, D. Considere un rectángulo cuyos lados son paralelos a los ejes x e y, con su vértice inferior izquierdo en (A, B) y su vértice superior derecho en (C, D). Calcula el área de las regiones pintadas de negro dentro de este rectángulo, e imprime el doble de esa área.
Se puede demostrar que el valor de salida será un número entero.

Entrada

La entrada se da desde la Entrada Estándar en el siguiente formato:
A B C D

Salida

Imprime la respuesta en una sola línea.

Restricciones

- -10^9 \leq A, B, C, D \leq 10^9
- A < C y B < D.
- Todos los valores de entrada son enteros.

Ejemplo de entrada 1

0 0 3 3

Ejemplo de salida 1

10

Debemos encontrar el área de la región pintada de negro dentro del siguiente cuadrado:

El área es 5, así que imprime el doble de ese valor: 10.

Ejemplo de entrada 2

-1 -2 1 3

Ejemplo de salida 2

11

El área es 5.5, que no es un entero, pero el valor de salida es un entero.

Ejemplo de entrada 3

-1000000000 -1000000000 1000000000 1000000000

Ejemplo de salida 3

4000000000000000000

Este es el caso del rectángulo más grande, donde la salida aún cabe en un entero con signo de 64 bits.


Este es un problema interactivo (donde tu programa interactúa con el juez mediante entrada y salida).
Se te da un número entero positivo N y enteros L y R tales que 0 \leq L \leq R < 2^N. El juez tiene una secuencia oculta A = (A_0, A_1, \dots, A_{2^N-1}) que consiste en enteros entre 0 y 99, inclusive.
Tu objetivo es encontrar el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Sin embargo, no puedes conocer directamente los valores de los elementos en la secuencia A. En su lugar, puedes hacerle al juez la siguiente pregunta:

- Escoge enteros no negativos i y j tales que 2^i(j+1) \leq 2^N. Sea l = 2^i j y r = 2^i (j+1) - 1. Pregunta por el residuo cuando A_l + A_{l+1} + \dots + A_r se divide por 100.

Sea m el número mínimo de preguntas requeridas para determinar el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100 para cualquier secuencia A. Necesitas encontrar este residuo en un máximo de m preguntas.

Entrada y Salida

Este es un problema interactivo (donde tu programa interactúa con el juez mediante entrada y salida).
Primero, lee los enteros N, L y R desde la entrada estándar:
N L R

Luego, repite haciendo preguntas hasta que puedas determinar el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben cumplir las siguientes restricciones:

- i y j son enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la entrada estándar:
T

Aquí, T es la respuesta a la pregunta, que es el residuo cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no cumplen las restricciones, o si el número de preguntas excede m, entonces T será -1.
Si el juez devuelve -1, tu programa ya se considera incorrecto. En este caso, termina el programa inmediatamente.
Una vez que hayas determinado el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprime el residuo S en el siguiente formato y termina el programa inmediatamente:
! S

Entrada y Salida

Este es un problema interactivo (donde tu programa interactúa con el juez mediante entrada y salida).
Primero, lee los enteros N, L y R desde la entrada estándar:
N L R

Luego, repite haciendo preguntas hasta que puedas determinar el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben cumplir las siguientes restricciones:

- i y j son enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la entrada estándar:
T

Aquí, T es la respuesta a la pregunta, que es el residuo cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no cumplen las restricciones, o si el número de preguntas excede m, entonces T será -1.
Si el juez devuelve -1, tu programa ya se considera incorrecto. En este caso, termina el programa inmediatamente.
Una vez que hayas determinado el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprime el residuo S en el siguiente formato y termina el programa inmediatamente:
! S

Restricciones

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Todos los valores de entrada son enteros.

Este es un problema interactivo (donde su programa interactúa con el juez a través de entrada y salida).
Se le da un número entero positivo N y enteros L y R tal que 0 \leq L \leq R < 2^N. El juez tiene una secuencia oculta A = (A_0, A_1, \dots, A_{2^N-1}) que consiste en números enteros entre 0 y 99, ambos inclusive.
Su objetivo es encontrar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Sin embargo, no puede conocer directamente los valores de los elementos de la secuencia A. En su lugar, puede plantear al juez la siguiente pregunta:

- Elija enteros no negativos i y j tal que 2^i(j+1) \leq 2^N. Sea l = 2^i j y r = 2^i (j+1) - 1. Pregunte por el resto cuando A_l + A_{l+1} + \dots + A_r se divide por 100.

Sea m el número mínimo de preguntas necesarias para determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100 para cualquier secuencia A. Usted necesita encontrar este resto dentro de m preguntas.

Entrada y salida

Este es un problema interactivo (donde su programa interactúa con el juez a través de entrada y salida).
Primero, lea los enteros N, L, y R de la Entrada Estándar:
N L R

A continuación, repita las preguntas hasta que pueda determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben satisfacer las siguientes restricciones

- i y j son números enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la Entrada Estándar:
T

Aquí, T es la respuesta a la pregunta, que es el resto cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no satisfacen las restricciones, o si el número de preguntas es superior a m, entonces T será -1.
Si el juez devuelve -1, su programa ya se considera incorrecto. En este caso, termine el programa inmediatamente.
Una vez que haya determinado el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprimir el resto S en el siguiente formato y terminar el programa inmediatamente:
¡! S

Entrada y salida

Este es un problema interactivo (donde su programa interactúa con el juez a través de entrada y salida).
Primero, lea los enteros N, L, y R de la Entrada Estándar:
N L R

A continuación, repita las preguntas hasta que pueda determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben satisfacer las siguientes restricciones

- i y j son números enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la Entrada Estándar:
T

Aquí, T es la respuesta a la pregunta, que es el resto cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no satisfacen las restricciones, o si el número de preguntas es superior a m, entonces T será -1.
Si el juez devuelve -1, su programa ya se considera incorrecto. En este caso, termine el programa inmediatamente.
Una vez que haya determinado el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprimir el resto S en el siguiente formato y terminar el programa inmediatamente:
¡! S

Restricciones

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Todos los valores de entrada son enteros.

Este es un problema interactivo (en el que su programa interactúa con el juez a través de la entrada y la salida).
Se le proporciona un entero positivo N y los enteros L y R tales que 0 \leq L \leq R < 2^N. El juez tiene una secuencia oculta A = (A_0, A_1, \dots, A_{2^N-1}) que consta de números enteros entre 0 y 99, ambos inclusive.
Su objetivo es encontrar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Sin embargo, no puede saber directamente los valores de los elementos en la secuencia A. En cambio, puede hacerle la siguiente pregunta al juez:

- Elija los números enteros no negativos i y j tales que 2^i(j+1) \leq 2^N. Sea l = 2^i j y r = 2^i (j+1) - 1. Pregunte por el resto cuando A_l + A_{l+1} + \dots + A_r se divide por 100.

Sea m el número mínimo de preguntas necesarias para determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100 para cualquier secuencia A. Debe encontrar este resto dentro de m preguntas.

Entrada y salida

Este es un problema interactivo (donde su programa interactúa con el juez a través de entrada y salida).
Primero, lea los números enteros N, L y R de la entrada estándar:
N L R

Luego, repita las preguntas hasta que pueda determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben satisfacer las siguientes restricciones:

- i y j son números enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la entrada estándar:
T

Aquí, T es la respuesta a la pregunta, que es el residuo cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no satisfacen las restricciones, o si el número de preguntas excede m, entonces T será -1.
Si el juez devuelve -1, su programa ya se considera incorrecto. En este caso, finalice el programa inmediatamente.
Una vez que haya determinado el residuo cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprima el residuo S en el siguiente formato y finalice el programa inmediatamente:
! S

Entrada y salida

Este es un problema interactivo (donde su programa interactúa con el juez a través de la entrada y la salida).
Primero, lea los números enteros N, L y R de la entrada estándar:
N L R

Luego, repita las preguntas hasta que pueda determinar el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100. Cada pregunta debe imprimirse en el siguiente formato:
? i j

Aquí, i y j deben satisfacer las siguientes restricciones:

- i y j son números enteros no negativos.
- 2^i(j+1) \leq 2^N

La respuesta a la pregunta se dará en el siguiente formato desde la entrada estándar:
T

Aquí, T es la respuesta a la pregunta, que es el resto cuando A_l + A_{l+1} + \dots + A_r se divide por 100, donde l = 2^i j y r = 2^i (j+1) - 1.
Si i y j no satisfacen las restricciones, o si el número de preguntas excede m, entonces T será -1.
Si el juez devuelve -1, su programa ya se considera incorrecto. En este caso, finalice el programa inmediatamente.
Una vez que haya determinado el resto cuando A_L + A_{L+1} + \dots + A_R se divide por 100, imprima el resto S en el siguiente formato y finalice el programa inmediatamente:
! S

Restricciones

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Todos los valores de entrada son números enteros.


Se da una sucesión A=(A_1,A_2,\dots,A_N) de longitud N y una sucesión B=(B_1,B_2,\dots,B_M) de longitud M. Aquí, todos los elementos de A y B son distintos por pares. Determinar si la secuencia C=(C_1,C_2,\dots,C_{N+M}) formada ordenando todos los elementos de A y B en orden ascendente contiene dos elementos consecutivos que aparecen en A.

Entrada

La entrada se da desde Standard Input en el siguiente formato:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Salida

Si C contiene dos elementos consecutivos que aparecen en A, imprime Sí; en caso contrario, imprime No.

Restricciones

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M son distintos.
- Todos los valores de entrada son enteros.

Muestra Entrada 1

3 2
3 2 5
4 1

Salida de muestra 1

Yes

C=(1,2,3,4,5). Como 2 y 3 de A aparecen consecutivamente en C, imprime Sí.

Ejemplo de entrada 2

3 2
3 1 5
4 2

Ejemplo de salida 2

No

C=(1,2,3,4,5). Como no hay dos elementos de A consecutivos en C, imprime No.

Ejemplo de entrada 3

1 1
1
2

Ejemplo de salida 3

No

Se te da la secuencia A=(A_1,A_2,\dots,A_N) de longitud N y una secuencia B=(B_1,B_2,\dots,B_M) de longitud M. Aquí, todos los elementos de A y B son distintos entre sí. Determina si la secuencia C=(C_1,C_2,\dots,C{N+M}) formada al ordenar todos los elementos de A y B en orden ascendente contiene dos elementos consecutivos que aparecen en A.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Salida

Si C contiene dos elementos consecutivos que aparecen en A, imprime Yes; de lo contrario, imprime No.

Restricciones

1 \leq N, M \leq 100
1 \leq A_i, B_j \leq 200
A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M son distintos.
Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

3 2
3 2 5
4 1

Ejemplo de Salida 1

Yes

C=(1,2,3,4,5). Dado que 2 y 3 de A ocurren consecutivamente en C, imprime Yes.

Ejemplo de Entrada 2

3 2
3 1 5
4 2

Ejemplo de Salida 2

No

C=(1,2,3,4,5). Dado que ningún par de elementos de A ocurre consecutivamente en C, imprime No.

Ejemplo de Entrada 3

1 1
1
2

Ejemplo de Salida 3

No

Dada una secuencia A=(A_1,A_2,\dots,A_N) de longitud N y una secuencia B=(B_1,B_2,\dots,B_M) de longitud M. Aquí, todos los elementos de A y B son distintos entre sí. Determina si la secuencia C=(C_1,C_2,\dots,C_{N+M}) formada al ordenar todos los elementos de A y B en orden ascendente contiene dos elementos consecutivos que aparecen en A.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Salida

Si C contiene dos elementos consecutivos que aparecen en A, imprime Yes; de lo contrario, imprime No.

Restricciones

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M son distintos.
- Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

3 2
3 2 5
4 1

Ejemplo de Salida 1

Yes

C=(1,2,3,4,5). Dado que 2 y 3 de A ocurren consecutivamente en C, imprime Yes.

Ejemplo de Entrada 2

3 2
3 1 5
4 2

Ejemplo de Salida 2

No

C=(1,2,3,4,5). Dado que ningún par de elementos de A ocurre consecutivamente en C, imprime No.

Ejemplo de Entrada 3

1 1
1
2

Ejemplo de Salida 3

No


Hay una cuadrícula N \times N, donde la celda en la i-ésima fila desde arriba y la j-ésima columna desde la izquierda contiene el entero N \times (i-1) + j.
En T turnos, se anunciarán los enteros. En el turno i, se anuncia el entero A_i y se marca la celda que contiene A_i. Determine el turno en el que se logra el Bingo por primera vez. Si no se logra el Bingo dentro de T turnos, imprima -1.
Aquí, lograr el Bingo significa satisfacer al menos una de las siguientes condiciones:

- Existe una fila en la que están marcadas todas las N celdas.
- Existe una columna en la que están marcadas todas las N celdas.
- Existe una línea diagonal (de arriba a la izquierda a abajo a la derecha o de arriba a la derecha a abajo a la izquierda) en la que están marcadas todas las N celdas.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N T
A_1 A_2 \ldots A_T

Salida

Si se obtiene el bingo en T turnos, se imprime el número de turno en el que se obtiene el bingo por primera vez; de lo contrario, se imprime -1.

Restricciones

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j si i \neq j.
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

3 5
5 1 8 9 7

Salida de muestra 1

4

El estado de la cuadrícula cambia de la siguiente manera. El bingo se consigue por primera vez en el turno 4.

Entrada de ejemplo 2

3 5
4 2 9 7 5

Salida de ejemplo 2

-1

No se consigue el bingo en cinco turnos, por lo que se imprime -1.

Entrada de ejemplo 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Salida de ejemplo 3

9

Hay una cuadrícula de N \times N, donde la celda en la i-ésima fila desde arriba y la j-ésima columna desde la izquierda contiene el entero N \times (i-1) + j.
Durante T turnos, se anunciarán enteros. En el Turno i, se anuncia el entero A_i, y se marca la celda que contiene A_i. Determina el turno en el que se logra Bingo por primera vez. Si no se logra Bingo dentro de T turnos, imprime -1.
Aquí, lograr Bingo significa satisfacer al menos una de las siguientes condiciones:

- Existe una fila en la que todas las N celdas están marcadas.
- Existe una columna en la que todas las N celdas están marcadas.
- Existe una línea diagonal (de arriba a la izquierda a abajo a la derecha o de arriba a la derecha a abajo a la izquierda) en la que todas las N celdas están marcadas.

Entrada

La entrada se proporciona desde la Entrada Estándar en el siguiente formato:
N T
A_1 A_2 \ldots A_T

Salida

Si se logra Bingo dentro de T turnos, imprime el número de turno en el que se logra Bingo por primera vez; de lo contrario, imprime -1.

Restricciones

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j si i \neq j.
- Todos los valores de entrada son enteros.

Entrada de Muestra 1

3 5
5 1 8 9 7

Salida de Muestra 1

4

El estado de la cuadrícula cambia de la siguiente manera. Se logra Bingo por primera vez en el Turno 4.

Entrada de Muestra 2

3 5
4 2 9 7 5

Salida de Muestra 2

-1

No se logra Bingo dentro de cinco turnos, por lo que se imprime -1.

Entrada de Muestra 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Salida de Muestra 3

9

Hay una cuadrícula N veces N, en la que la celda de la i-ésima fila desde arriba y la j-ésima columna desde la izquierda contiene el número entero N veces (i-1) + j.
A lo largo de T turnos, se anunciarán los enteros. En el turno i, se anuncia el número entero A_i y se marca la casilla que contiene A_i. Determine el turno en el que se consigue Bingo por primera vez. Si no se consigue Bingo en T turnos, imprima -1.
Bingo significa que se cumple al menos una de las siguientes condiciones:

- Existe una fila en la que todas las N casillas están marcadas.
- Existe una columna en la que todas las N casillas están marcadas.
- Existe una línea diagonal (de arriba-izquierda a abajo-derecha o de arriba-derecha a abajo-izquierda) en la que todas las N celdas están marcadas.

Entrada

La entrada se da desde Entrada Estándar en el siguiente formato:
N T
A_1 A_2 \ldots A_T

Salida

Si se consigue el Bingo en T turnos, imprime el número de turno en el que se consigue el Bingo por primera vez; en caso contrario, imprime -1.

Restricciones

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- Todos los valores de entrada son enteros.

Ejemplo de entrada 1

3 5
5 1 8 9 7

Muestra de salida 1

4

El estado de la parrilla cambia como sigue. Se consigue bingo por primera vez en el turno 4.

Muestra de Entrada 2

3 5
4 2 9 7 5

Muestra de salida 2

-1

No se consigue el bingo en cinco turnos, así que imprime -1.

Ejemplo de entrada 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Ejemplo de salida 3

9


La tarta de Takahashi ha sido comida por alguien. Hay tres sospechosos: persona 1, persona 2 y persona 3.
Hay dos testigos, Ringo y Snuke. Ringo recuerda que la persona A no es el culpable, y Snuke recuerda que la persona B no es el culpable.
Determina si el culpable puede ser identificado de manera única basándose en los recuerdos de los dos testigos. Si el culpable puede ser identificado, imprime el número de la persona.

Entrada

La entrada se proporciona desde la Entrada Estándar en el siguiente formato:
A B

Salida

Si el culpable puede ser identificado de manera única basándose en los recuerdos de los dos testigos, imprime el número de la persona; de lo contrario, imprime -1.

Restricciones

- 1 \leq A, B \leq 3
- Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

1 2

Ejemplo de Salida 1

3

A partir de los recuerdos de los dos testigos, se puede determinar que la persona 3 es el culpable.

Ejemplo de Entrada 2

1 1

Ejemplo de Salida 2

-1

A partir de los recuerdos de los dos testigos, no se puede determinar si la persona 2 o la persona 3 es el culpable. Por lo tanto, imprime -1.

Ejemplo de Entrada 3

3 1

Ejemplo de Salida 3

2

Alguien se comió el pastel de Takahashi. Hay tres sospechosos: la persona 1, la persona 2 y la persona 3.
Hay dos testigos, Ringo y Snuke. Ringo recuerda que la persona A no es la culpable y Snuke recuerda que la persona B no es la culpable.
Determina si se puede identificar al culpable de forma única basándose en los recuerdos de los dos testigos. Si se puede identificar al culpable, imprime el número de la persona.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
A B

Salida

Si se puede identificar al culpable de forma única basándose en los recuerdos de los dos testigos, imprime el número de la persona; de lo contrario, imprime -1.

Restricciones

- 1 \leq A, B \leq 3
- Todos los valores de entrada son números enteros.

Ejemplo de entrada 1

1 2

Ejemplo de salida 1

3

A partir de los recuerdos de los dos testigos, se puede determinar que la persona 3 es la culpable.

Ejemplo de entrada 2

1 1

Ejemplo de salida 2

-1

A partir de los recuerdos de los dos testigos, no se puede determinar si la persona 2 o la persona 3 es la culpable. Por lo tanto, se imprime -1.

Ejemplo de entrada 3

3 1

Ejemplo de salida 3

2


Se le dan N intervalos de números reales. El intervalo i-ésimo (1 leq i leq N) es [l_i, r_i]. Halla el número de pares (i, j),(1 leq i < j leq N) tales que los intervalos i-ésimo y j-ésimo se intersequen.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Salida

Imprime la respuesta.

Restricciones

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Todos los valores de entrada son enteros.

Entrada de muestra 1

3
1 5
7 8
3 7

Salida de muestra 1

2

Los intervalos dados son [1,5], [7,8], [3,7]. Entre estos, se intersectan los intervalos 1 y 3, así como los intervalos 2 y 3, por lo que la respuesta es 2.

Entrada de muestra 2

3
3 4
2 5
1 6

Salida de muestra 2

3

Entrada de muestra 3

2
1 2
3 4

Salida de muestra 3

0

Se te dan N intervalos de números reales. El i-ésimo (1 \leq i \leq N) intervalo es [l_i, r_i]. Encuentra el número de pares (i, j)\,(1 \leq i < j \leq N) tales que los intervalos i-ésimo y j-ésimo se intersectan.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Salida

Imprime la respuesta.

Restricciones

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Todos los valores de entrada son enteros.

Entrada de muestra 1

3
1 5
7 8
3 7

Salida de muestra 1

2

Los intervalos dados son [1,5], [7,8], [3,7]. Entre estos, los intervalos 1-ero y 3-ero se intersectan, así como los intervalos 2-ndo y 3-ero, por lo que la respuesta es 2.

Entrada de muestra 2

3
3 4
2 5
1 6

Salida de muestra 2

3

Entrada de muestra 3

2
1 2
3 4

Salida de muestra 3

0


Se te da un array apple de tamaño n y un array capacity de tamaño m.
Hay n paquetes donde el i-ésimo paquete contiene apple[i] manzanas. También hay m cajas, y la i-ésima caja tiene una capacidad de capacity[i] manzanas.
Devuelve el número mínimo de cajas que necesitas seleccionar para redistribuir estos n paquetes de manzanas en las cajas.
Ten en cuenta que las manzanas de un mismo paquete se pueden distribuir en diferentes cajas.

Ejemplo 1:

Entrada: apple = [1,3,2], capacity = [4,3,1,5,2]
Salida: 2
Explicación: Usaremos cajas con capacidades 4 y 5.
Es posible distribuir las manzanas ya que la capacidad total es mayor o igual al número total de manzanas.

Ejemplo 2:

Entrada: apple = [5,5,5], capacity = [2,4,2,7]
Salida: 4
Explicación: Necesitaremos usar todas las cajas.

Restricciones:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
La entrada se genera de tal manera que es posible redistribuir los paquetes de manzanas en las cajas.

Se le proporciona una matriz de manzanas de tamaño n y una matriz de capacidad de tamaño m.
Hay n paquetes donde el i^ésimo paquete contiene manzanas apple[i] manzanas. También hay m cajas, y la i^ésima caja tiene una capacidad de capacidad[i] manzanas.
Devuelva la cantidad mínima de cajas que necesita seleccionar para redistribuir estos n paquetes de manzanas en cajas.
Tenga en cuenta que las manzanas del mismo paquete se pueden distribuir en diferentes cajas.

Ejemplo 1:

Entrada: apple = [1,3,2], capacity = [4,3,1,5,2]
Salida: 2
Explicación: Usaremos cajas con capacidades 4 y 5.
Es posible distribuir las manzanas ya que la capacidad total es mayor o igual que la cantidad total de manzanas.

Ejemplo 2:

Entrada: apple = [5,5,5], capacity = [2,4,2,7]
Salida: 4
Explicación: Necesitaremos usar todas las cajas.

Restricciones:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
La entrada se genera de tal manera que sea posible redistribuir paquetes de manzanas en cajas.

Se le proporciona una matriz de manzanas de tamaño n y una matriz de capacidad de tamaño m.
Hay n paquetes donde el i^ésimo paquete contiene manzanas [i] manzanas. También hay m cajas, y la i^ésima caja tiene una capacidad de capacidad [i] manzanas.
Devuelva la cantidad mínima de cajas que necesita seleccionar para redistribuir estos n paquetes de manzanas en cajas.
Tenga en cuenta que las manzanas del mismo paquete se pueden distribuir en diferentes cajas.

Ejemplo 1:

Entrada: manzana = [1,3,2], capacidad = [4,3,1,5,2]
Salida: 2
Explicación: Usaremos cajas con capacidades 4 y 5.
Es posible distribuir las manzanas ya que la capacidad total es mayor o igual que la cantidad total de manzanas.

Ejemplo 2:

Entrada: manzana = [5,5,5], capacidad = [2,4,2,7]
Salida: 4
Explicación: Necesitaremos usar todas las cajas.

Restricciones:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
La entrada se genera de manera que sea posible redistribuir paquetes de manzanas en cajas.


Se le proporciona una matriz felicidad de longitud n y un entero positivo k.
Hay n niños en una cola, donde el i^ésimo niño tiene el valor de felicidad felicidad[i]. Quiere seleccionar k niños de estos n niños en k turnos.
En cada turno, cuando selecciona un niño, el valor de felicidad de todos los niños que no se han seleccionado hasta ahora disminuye en 1. Tenga en cuenta que el valor de felicidad no puede volverse negativo y se reduce solo si es positivo.
Devuelva la suma máxima de los valores de felicidad de los niños seleccionados que puede lograr seleccionando k niños.

Ejemplo 1:

Entrada: happiness = [1,2,3], k = 2
Salida: 4
Explicación: Podemos elegir 2 niños de la siguiente manera:
- Elija el niño con el valor de felicidad == 3. El valor de felicidad de los niños restantes se convierte en [0,1].
- Elija el niño con el valor de felicidad == 1. El valor de felicidad del niño restante se convierte en [0]. Tenga en cuenta que el valor de felicidad no puede ser menor que 0.
La suma de los valores de felicidad de los niños seleccionados es 3 + 1 = 4.

Ejemplo 2:

Entrada: happiness = [1,1,1,1], k = 2
Salida: 1
Explicación: Podemos elegir 2 niños de la siguiente manera:
- Elija cualquier niño con el valor de felicidad == 1. El valor de felicidad de los niños restantes se convierte en [0,0,0].
- Elija el niño con el valor de felicidad == 0. El valor de felicidad del niño restante se convierte en [0,0].
La suma de los valores de felicidad de los niños seleccionados es 1 + 0 = 1.

Ejemplo 3:

Entrada: happiness = [2,3,4,5], k = 1
Salida: 5
Explicación: Podemos elegir 1 niño de la siguiente manera:
- Elija el niño con el valor de felicidad == 5. El valor de felicidad de los niños restantes se convierte en [1,2,3].
La suma de los valores de felicidad de los niños seleccionados es 5.

Restricciones:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n

Se te da un arreglo happiness de longitud n, y un entero positivo k.
Hay n niños en una fila, donde el i^ésimo niño tiene un valor de felicidad happiness[i]. Quieres seleccionar k niños de estos n niños en k turnos.
En cada turno, cuando seleccionas a un niño, el valor de felicidad de todos los niños que no han sido seleccionados hasta ahora disminuye en 1. Ten en cuenta que el valor de felicidad no puede ser negativo y solo se decrementa si es positivo.
Devuelve la suma máxima de los valores de felicidad de los niños seleccionados que puedes lograr seleccionando k niños.

Ejemplo 1:

Entrada: happiness = [1,2,3], k = 2
Salida: 4
Explicación: Podemos elegir 2 niños de la siguiente manera:
- Elegir al niño con el valor de felicidad == 3. El valor de felicidad de los niños restantes se convierte en [0,1].
- Elegir al niño con el valor de felicidad == 1. El valor de felicidad del niño restante se convierte en [0]. Ten en cuenta que el valor de felicidad no puede ser menor que 0.
La suma de los valores de felicidad de los niños seleccionados es 3 + 1 = 4.

Ejemplo 2:

Entrada: happiness = [1,1,1,1], k = 2
Salida: 1
Explicación: Podemos elegir 2 niños de la siguiente manera:
- Elegir cualquier niño con el valor de felicidad == 1. El valor de felicidad de los niños restantes se convierte en [0,0,0].
- Elegir al niño con el valor de felicidad == 0. El valor de felicidad del niño restante se convierte en [0,0].
La suma de los valores de felicidad de los niños seleccionados es 1 + 0 = 1.

Ejemplo 3:

Entrada: happiness = [2,3,4,5], k = 1
Salida: 5
Explicación: Podemos elegir 1 niño de la siguiente manera:
- Elegir al niño con el valor de felicidad == 5. El valor de felicidad de los niños restantes se convierte en [1,2,3].
La suma de los valores de felicidad de los niños seleccionados es 5.

Restricciones:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n


Se te da un arreglo arr de tamaño n compuesto por cadenas no vacías. Encuentra un arreglo de cadenas answer de tamaño n tal que:

answer[i] sea la subcadena más corta de arr[i] que no aparezca como subcadena en ninguna otra cadena en arr. Si existen múltiples subcadenas así, answer[i] debe ser la más pequeña lexicográficamente. Y si no existe tal subcadena, answer[i] debe ser una cadena vacía.

Devuelve el arreglo answer.

Ejemplo 1:

Entrada: arr = ["cab","ad","bad","c"]
Salida: ["ab","","ba",""]
Explicación: Tenemos lo siguiente:
- Para la cadena "cab", la subcadena más corta que no aparece en ninguna otra cadena es "ca" o "ab", elegimos la subcadena lexicográficamente menor, que es "ab".
- Para la cadena "ad", no hay subcadena que no aparezca en otra cadena.
- Para la cadena "bad", la subcadena más corta que no aparece en ninguna otra cadena es "ba".
- Para la cadena "c", no hay subcadena que no aparezca en otra cadena.

Ejemplo 2:

Entrada: arr = ["abc","bcd","abcd"]
Salida: ["","","abcd"]
Explicación: Tenemos lo siguiente:
- Para la cadena "abc", no hay subcadena que no aparezca en otra cadena.
- Para la cadena "bcd", no hay subcadena que no aparezca en otra cadena.
- Para la cadena "abcd", la subcadena más corta que no aparece en otra cadena es "abcd".

Condiciones:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] consiste solo en letras minúsculas del alfabeto inglés.

Se le proporciona una matriz arr de tamaño n que consta de cadenas no vacías.
Encuentre una matriz de cadenas answer de tamaño n tal que:

answer[i] es la subcadena más corta de arr[i] que no aparece como subcadena en ninguna otra cadena en arr. Si existen múltiples subcadenas de este tipo, answer[i] debe ser la más pequeña lexicográficamente. Y si no existe dicha subcadena, answer[i] debe ser una cadena vacía.

Devuelva la matriz answer.

Ejemplo 1:

Entrada: arr = ["cab","ad","bad","c"]
Salida: ["ab","","ba",""]
Explicación: Tenemos lo siguiente:
- Para la cadena "cab", la subcadena más corta que no aparece en ninguna otra cadena es "ca" o "ab", seleccionamos la subcadena lexicográficamente más pequeña, que es "ab".
- Para la cadena "ad", no hay ninguna subcadena que no aparezca en ninguna otra cadena. - Para la cadena "bad", la subcadena más corta que no aparece en ninguna otra cadena es "ba".
- Para la cadena "c", no existe ninguna subcadena que no aparezca en ninguna otra cadena.

Ejemplo 2:

Entrada: arr = ["abc", "bcd", "abcd"]
Salida: ["","","abcd"]
Explicación: Tenemos lo siguiente:
- Para la cadena "abc", no existe ninguna subcadena que no aparezca en ninguna otra cadena.
- Para la cadena "bcd", no existe ninguna subcadena que no aparezca en ninguna otra cadena.
- Para la cadena "abcd", la subcadena más corta que no aparece en ninguna otra cadena es "abcd".

Restricciones:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] consta únicamente de letras minúsculas en inglés.

Se le proporciona una matriz arr de tamaño n que consta de cadenas no vacías.
Encuentre una matriz de cadenas answer de tamaño n tal que:

answer[i] es la subcadena más corta de arr[i] que no aparece como subcadena en ninguna otra cadena en arr. Si existen múltiples subcadenas de este tipo, answer[i] debe ser la más pequeña lexicográficamente. Y si no existe dicha subcadena, answer[i] debe ser una cadena vacía.

Devuelva la matriz answer.

Ejemplo 1:

Entrada: arr = ["cab","ad","bad","c"]
Salida: ["ab","","ba",""]
Explicación: Tenemos lo siguiente:
- Para la cadena "cab", la subcadena más corta que no aparece en ninguna otra cadena es "ca" o "ab", elegimos la subcadena lexicográficamente más pequeña, que es "ab".
- Para la cadena "ad", no hay ninguna subcadena que no aparezca en ninguna otra cadena. - Para la cadena "bad", la subcadena más corta que no aparece en ninguna otra cadena es "ba".
- Para la cadena "c", no existe ninguna subcadena que no aparezca en ninguna otra cadena.

Ejemplo 2:

Entrada: arr = ["abc","bcd","abcd"]
Salida: ["","","abcd"]
Explicación: Tenemos lo siguiente:
- Para la cadena "abc", no existe ninguna subcadena que no aparezca en ninguna otra cadena.
- Para la cadena "bcd", no existe ninguna subcadena que no aparezca en ninguna otra cadena.
- Para la cadena "abcd", la subcadena más corta que no aparece en ninguna otra cadena es "abcd".

Restricciones:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] consta únicamente de letras minúsculas en inglés.


Se te da un array de enteros indexado desde cero, `nums`, de longitud `n`, y un entero positivo impar `k`.
La fuerza de las subarreglos de x está definida como fuerza = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, donde sum[i] es la suma de los elementos en el i-ésimo subarreglo. Formalmente, la fuerza es la suma de (-1)^i+1 * sum[i] * (x - i + 1) sobre todos los i tales que 1 <= i <= x.
Necesitas seleccionar `k` subarreglos disjuntos de `nums`, de manera que su fuerza sea máxima.
Devuelve la fuerza máxima posible que se puede obtener.
Nota que los subarreglos seleccionados no necesitan cubrir todo el array.

Ejemplo 1:

Entrada: nums = [1,2,3,-1,2], k = 3
Salida: 22
Explicación: La mejor forma de seleccionar 3 subarreglos es: nums[0..2], nums[3..3], y nums[4..4]. La fuerza es (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Ejemplo 2:

Entrada: nums = [12,-2,-2,-2,-2], k = 5
Salida: 64
Explicación: La única forma posible de seleccionar 5 subarreglos disjuntos es: nums[0..0], nums[1..1], nums[2..2], nums[3..3], y nums[4..4]. La fuerza es 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Ejemplo 3:

Entrada: nums = [-1,-2,-3], k = 1
Salida: -1
Explicación: La mejor forma posible de seleccionar 1 subarreglo es: nums[0..0]. La fuerza es -1.

Restricciones:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
`k` es impar.

Se le proporciona una matriz indexada en 0 de números enteros nums de longitud n y un entero impar positivo k.
La fuerza de x subarreglos se define como fuerza = suma[1] * x - suma[2] * (x - 1) + suma[3] * (x - 2) - suma[4] * (x - 3) + ... + suma[x] * 1 donde suma[i] es la suma de los elementos en el subarreglo i^ésimo. Formalmente, la fuerza es la suma de (-1)^i+1 * suma[i] * (x - i + 1) sobre todos los i tales que 1 <= i <= x.
Debe seleccionar k subarreglos disjuntos de nums, tales que su fuerza sea máxima.
Devuelva la máxima fuerza posible que se puede obtener.
Tenga en cuenta que los subarreglos seleccionados no necesitan cubrir todo el arreglo.

Ejemplo 1:

Entrada: nums = [1,2,3,-1,2], k = 3
Salida: 22
Explicación: La mejor forma posible de seleccionar 3 submatrices es: nums[0..2], nums[3..3] y nums[4..4]. La fuerza es (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Ejemplo 2:

Entrada: nums = [12,-2,-2,-2,-2], k = 5
Salida: 64
Explicación: La única forma posible de seleccionar 5 submatrices disjuntas es: nums[0..0], nums[1..1], nums[2..2], nums[3..3] y nums[4..4]. La fuerza es 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Ejemplo 3:

Entrada: nums = [-1,-2,-3], k = 1
Salida: -1
Explicación: La mejor forma posible de seleccionar 1 subarreglo es: nums[0..0]. La fuerza es -1.

Restricciones:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k es impar.


Dada una cadena s, encuentra cualquier subcadena de longitud 2 que también esté presente en el inverso de s.
Devuelve true si existe tal subcadena, y false en caso contrario.

Ejemplo 1:

Entrada: s = "leetcode"
Salida: true
Explicación: La subcadena "ee" tiene longitud 2 y también está presente en reverse(s) == "edocteel".

Ejemplo 2:

Entrada: s = "abcba"
Salida: true
Explicación: Todas las subcadenas de longitud 2 "ab", "bc", "cb", "ba" también están presentes en reverse(s) == "abcba".

Ejemplo 3:

Entrada: s = "abcd"
Salida: false
Explicación: No hay ninguna subcadena de longitud 2 en s que también esté presente en el inverso de s.

Restricciones:

1 <= s.length <= 100
s consiste solo en letras minúsculas del inglés.

Dada una cadena s, encuentre cualquier subcadena de longitud 2 que también esté presente en el reverso de s.
Devuelve verdadero si existe dicha subcadena y falso en caso contrario.

Ejemplo 1:

Entrada: s = "leetcode"
Salida: true
Explicación: La subcadena "ee" tiene una longitud 2 que también está presente en reverse(s) == "edocteel".

Ejemplo 2:

Entrada: s = "abcba"
Salida: true
Explicación: Todas las subcadenas de longitud 2 "ab", "bc", "cb", "ba" también están presentes en reverse(s) == "abcba".

Ejemplo 3:

Entrada: s = "abcd"
Salida: false
Explicación: No hay ninguna subcadena de longitud 2 en s, que también esté presente en el reverso de s.

Restricciones:

1 <= s.length <= 100
s consta únicamente de letras minúsculas del alfabeto inglés.

Dada una cadena s, encuentre cualquier subcadena de longitud 2 que también esté presente en el reverso de s.
Devuelve true si existe dicha subcadena y false en caso contrario.

Ejemplo 1:

Entrada: s = "leetcode"
Salida: true
Explicación: La subcadena "ee" tiene una longitud 2 que también está presente en reverse(s) == "edocteel".

Ejemplo 2:

Entrada: s = "abcba"
Salida: true
Explicación: Todas las subcadenas de longitud 2 "ab", "bc", "cb", "ba" también están presentes en reverse(s) == "abcba".

Ejemplo 3:

Entrada: s = "abcd"
Salida: false
Explicación: No hay ninguna subcadena de longitud 2 en s, que también esté presente en el reverso de s.

Restricciones:

1 <= s.length <= 100
s consta únicamente de letras minúsculas del alfabeto inglés.


Se le proporciona una cadena s y un carácter c. Devuelva el número total de subcadenas de s que comienzan y terminan con c.

Ejemplo 1:

Entrada: s = "abada", c = "a"
Salida: 6
Explicación: Las subcadenas que comienzan y terminan con "a" son: "abada", "abada", "abada", "abada", "abada", "abada".

Ejemplo 2:

Entrada: s = "zzz", c = "z"
Salida: 6
Explicación: Hay un total de 6 subcadenas en s y todas comienzan y terminan con "z".

Restricciones:

1 <= s.length <= 10^5
s y c constan solo de letras minúsculas del alfabeto inglés.

Se te da una cadena s y un carácter c. Devuelve el número total de subcadenas de s que comienzan y terminan con c.

Ejemplo 1:

Entrada: s = "abada", c = "a"
Salida: 6
Explicación: Las subcadenas que comienzan y terminan con "a" son: "abada", "abada", "abada", "abada", "abada", "abada".

Ejemplo 2:

Entrada: s = "zzz", c = "z"
Salida: 6
Explicación: Hay un total de 6 subcadenas en s y todas comienzan y terminan con "z".

Restricciones:

1 <= s.length <= 10^5
s y c consisten solo de letras minúsculas del alfabeto inglés.


Se te da una cadena word y un entero k.
Consideramos que word es k-especial si |freq(word[i]) - freq(word[j])| <= k para todos los índices i y j en la cadena.
Aquí, freq(x) denota la frecuencia del carácter x en word, y |y| denota el valor absoluto de y.
Devuelve el número mínimo de caracteres que necesitas eliminar para que word sea k-especial.

Ejemplo 1:

Entrada: word = "aabcaba", k = 0
Salida: 3
Explicación: Podemos hacer que word sea 0-especial eliminando 2 ocurrencias de "a" y 1 ocurrencia de "c". Por lo tanto, word se convierte en "baba" donde freq('a') == freq('b') == 2.

Ejemplo 2:

Entrada: word = "dabdcbdcdcd", k = 2
Salida: 2
Explicación: Podemos hacer que word sea 2-especial eliminando 1 ocurrencia de "a" y 1 ocurrencia de "d". Por lo tanto, word se convierte en "bdcbdcdcd" donde freq('b') == 2, freq('c') == 3 y freq('d') == 4.

Ejemplo 3:

Entrada: word = "aaabaaa", k = 2
Salida: 1
Explicación: Podemos hacer que word sea 2-especial eliminando 1 ocurrencia de "b". Por lo tanto, word se convierte en "aaaaaa" donde la frecuencia de cada letra ahora es uniformemente 6.

Restricciones:

1 <= word.length <= 10^5
0 <= k <= 10^5
word consiste solo de letras minúsculas en inglés.

Se da una cadena palabra y un número entero k.
Consideramos que la palabra es k-especial si |freq(palabra[i]) - freq(palabra[j])| <= k para todos los índices i y j de la cadena.
Aquí, freq(x) denota la frecuencia del carácter x en la palabra, y |y| denota el valor absoluto de y.
Devuelve el número mínimo de caracteres que hay que eliminar para que la palabra sea k-especial.

Ejemplo 1

Entrada: word = "aabcaba", k = 0
Salida: 3
Explicación: Podemos hacer que la palabra sea 0 especial eliminando 2 apariciones de «a» y 1 aparición de «c». Por lo tanto, la palabra pasa a ser igual a «baba» donde freq('a') == freq('b') == 2.

Ejemplo 2:

Entrada: word = "dabdcbdcdcd", k = 2
Salida: 2
Explicación: Podemos hacer la palabra 2-especial suprimiendo 1 ocurrencia de «a» y 1 ocurrencia de «d». Por lo tanto, la palabra pasa a ser igual a «bdcbdcd» donde freq('b') == 2, freq('c') == 3, y freq('d') == 4.

Ejemplo 3:

Entrada: word = "aaabaaa", k = 2
Salida: 1
Explicación: Podemos hacer la palabra 2-especial suprimiendo 1 ocurrencia de «b». Por lo tanto, la palabra pasa a ser igual a «aaaaaa», donde la frecuencia de cada letra es ahora 6 uniformemente.

Restricciones:

1 <= word.length <= 10^5
0 <= k <= 10^5
palabra está formada sólo por letras minúsculas inglesas.

Se te da una string word y un entero k.
Consideramos que word es k-especial si |freq(word[i]) - freq(word[j])| <= k para todos los índices i y j en el string.
Aquí, freq(x) denota la frecuencia del carácter x en word, y |y| denota el valor absoluto de y.
Devuelve el número mínimo de caracteres que necesitas eliminar para que word sea k-especial.

Ejemplo 1:

Entrada: word = "aabcaba", k = 0
Salida: 3
Explicación: Podemos hacer que word sea 0-especial eliminando 2 ocurrencias de "a" y 1 ocurrencia de "c". Por lo tanto, word se convierte en "baba" donde freq('a') == freq('b') == 2.

Ejemplo 2:

Entrada: word = "dabdcbdcdcd", k = 2
Salida: 2
Explicación: Podemos hacer que word sea 2-especial eliminando 1 ocurrencia de "a" y 1 ocurrencia de "d". Por lo tanto, word se convierte en "bdcbdcdcd" donde freq('b') == 2, freq('c') == 3 y freq('d') == 4.

Ejemplo 3:

Entrada: word = "aaabaaa", k = 2
Salida: 1
Explicación: Podemos hacer que word sea 2-especial eliminando 1 ocurrencia de "b". Por lo tanto, word se convierte en "aaaaaa" donde la frecuencia de cada letra ahora es uniformemente 6.

Condiciones:

1 <= word.length <= 10^5
0 <= k <= 10^5
word consiste solo de letras minúsculas en inglés.


Te dan un arreglo binario `nums` de longitud `n`, un entero positivo `k` y un entero no negativo `maxChanges`.
Alicia juega un juego en el que el objetivo es que Alicia recoja `k` unos de `nums` usando el menor número de movimientos. Cuando el juego comienza, Alicia elige cualquier índice `aliceIndex` en el rango ` [0, n - 1]` y se para ahí. Si `nums[aliceIndex] == 1`, Alicia recoge el uno y `nums[aliceIndex]` se convierte en `0` (esto no cuenta como un movimiento). Después de esto, Alicia puede hacer cualquier número de movimientos (incluyendo cero) donde en cada movimiento Alicia debe realizar exactamente una de las siguientes acciones:

Selecciona cualquier índice `j` != `aliceIndex` tal que `nums[j] == 0` y establece `nums[j] = 1`. Esta acción se puede realizar como máximo `maxChanges` veces.
Selecciona dos índices adyacentes `x` e `y` (|x - y| == 1) tal que `nums[x] == 1`, `nums[y] == 0`, luego intercambia sus valores (establece `nums[y] = 1` y `nums[x] = 0`). Si `y == aliceIndex`, Alicia recoge el uno después de este movimiento y `nums[y]` se convierte en `0`.

Devuelve el número mínimo de movimientos que Alicia necesita para recoger exactamente `k` unos.

Ejemplo 1:

Entrada: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Salida: 3
Explicación: Alicia puede recoger 3 unos en 3 movimientos, si Alicia realiza las siguientes acciones en cada movimiento cuando está en aliceIndex == 1:

 Al inicio del juego Alicia recoge el uno y `nums[1]` se convierte en `0`. `nums` se convierte en [1,1,1,0,0,1,1,0,0,1].
Selecciona `j == 2` y realiza una acción del primer tipo. `nums` se convierte en [1,0,1,0,0,1,1,0,0,1]
Selecciona `x == 2` e `y == 1`, y realiza una acción del segundo tipo. `nums` se convierte en [1,1,0,0,0,1,1,0,0,1]. Como `y == aliceIndex`, Alicia recoge el uno y `nums` se convierte en [1,0,0,0,0,1,1,0,0,1].
Selecciona `x == 0` e `y == 1`, y realiza una acción del segundo tipo. `nums` se convierte en [0,1,0,0,0,1,1,0,0,1]. Como `y == aliceIndex`, Alicia recoge el uno y `nums` se convierte en [0,0,0,0,0,1,1,0,0,1].

Nota que puede ser posible que Alicia recoja 3 unos usando otra secuencia de 3 movimientos.

Ejemplo 2:

Entrada: nums = [0,0,0,0], k = 2, maxChanges = 3
Salida: 4
Explicación: Alicia puede recoger 2 unos en 4 movimientos, si Alicia realiza las siguientes acciones en cada movimiento cuando está en aliceIndex == 0:

Selecciona `j == 1` y realiza una acción del primer tipo. `nums` se convierte en [0,1,0,0].
Selecciona `x == 1` e `y == 0`, y realiza una acción del segundo tipo. `nums` se convierte en [1,0,0,0]. Como `y == aliceIndex`, Alicia recoge el uno y `nums` se convierte en [0,0,0,0].
Selecciona `j == 1` de nuevo y realiza una acción del primer tipo. `nums` se convierte en [0,1,0,0].
Selecciona `x == 1` e `y == 0` de nuevo, y realiza una acción del segundo tipo. `nums` se convierte en [1,0,0,0]. Como `y == aliceIndex`, Alicia recoge el uno y `nums` se convierte en [0,0,0,0].

Restricciones:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Se le proporciona una matriz binaria nums de longitud n, un entero positivo k y un entero no negativo maxChanges.
Alice juega un juego, donde el objetivo es que Alice tome k unos de nums utilizando la cantidad mínima de movimientos. Cuando comienza el juego, Alice toma cualquier índice aliceIndex en el rango [0, n - 1] y se queda allí. Si nums[aliceIndex] == 1, Alice toma el uno y nums[aliceIndex] se convierte en 0 (esto no cuenta como un movimiento). Después de esto, Alice puede hacer cualquier cantidad de movimientos (incluido cero) donde en cada movimiento Alice debe realizar exactamente una de las siguientes acciones:

Seleccione cualquier índice j != aliceIndex tal que nums[j] == 0 y establezca nums[j] = 1. Esta acción se puede realizar en la mayoría de los casos maxChanges.
Seleccione dos índices adyacentes x e y (|x - y| == 1) de modo que nums[x] == 1, nums[y] == 0, luego intercambie sus valores (establezca nums[y] = 1 y nums[x] = 0). Si y == aliceIndex, Alice toma el que sigue a este movimiento y nums[y] se convierte en 0.

Devuelve la cantidad mínima de movimientos que necesita Alice para elegir exactamente k unos.

Ejemplo 1:

Entrada: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Salida: 3
Explicación: Alicia puede tomar 3 unos en 3 movimientos, si Alicia realiza las siguientes acciones en cada movimiento cuando se encuentra en aliceIndex == 1:

Al comienzo del juego Alicia toma el uno y nums[1] se convierte en 0. nums se convierte en [1,1,1,0,0,1,1,0,0,1].
Seleccione j == 2 y realice una acción del primer tipo. nums se convierte en [1,0,1,0,0,1,1,0,0,1]
Seleccione x == 2 e y == 1, y realice una acción del segundo tipo. nums se convierte en [1,1,0,0,0,1,1,0,0,1]. Como y == aliceIndex, Alice toma el uno y nums se convierte en [1,0,0,0,0,1,1,0,0,1].
Seleccione x == 0 e y == 1, y realice una acción del segundo tipo. nums se convierte en [0,1,0,0,0,1,1,0,0,1]. Como y == aliceIndex, Alice toma el uno y nums se convierte en [0,0,0,0,0,1,1,0,0,1].

Tenga en cuenta que es posible que Alice tome 3 unos utilizando alguna otra secuencia de 3 movimientos.

Ejemplo 2:

Entrada: nums = [0,0,0,0], k = 2, maxChanges = 3
Salida: 4
Explicación: Alice puede tomar 2 unos en 4 movimientos, si Alice realiza las siguientes acciones en cada movimiento cuando se encuentra en aliceIndex == 0:

Seleccione j == 1 y realice una acción del primer tipo. nums se convierte en [0,1,0,0].
Seleccione x == 1 e y == 0, y realice una acción del segundo tipo. nums se convierte en [1,0,0,0]. Como y == aliceIndex, Alice toma el uno y nums se convierte en [0,0,0,0].
Seleccione j == 1 nuevamente y realice una acción del primer tipo. nums se convierte en [0,1,0,0].
Seleccione x == 1 e y == 0 nuevamente, y realice una acción del segundo tipo. nums se convierte en [1,0,0,0]. Como y == aliceIndex, Alice toma el uno y nums se convierte en [0,0,0,0].

Restricciones:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Se le da una matriz binaria nums de longitud n, un entero positivo k y un entero no negativo maxCambios.
Alice juega un juego, donde el objetivo es que Alice recoja k unos de nums usando el mínimo número de movimientos. Cuando empieza el juego, Alice coge cualquier índice aliceIndex en el rango [0, n - 1] y se queda ahí. Si nums[aliceIndex] == 1 , Alice coge el uno y nums[aliceIndex] pasa a ser 0 (esto no cuenta como movimiento). Después de esto, Alice puede hacer cualquier número de movimientos (incluyendo cero) donde en cada movimiento Alice debe realizar exactamente una de las siguientes acciones:

Seleccionar cualquier índice j != aliceIndex tal que nums[j] == 0 y poner nums[j] = 1. Esta acción se puede realizar como máximo maxCambios veces.
Selecciona dos índices adyacentes x e y (|x - y| == 1) de forma que nums[x] == 1, nums[y] == 0, e intercambia sus valores (nums[y] = 1 y nums[x] = 0). Si y == aliceIndex, Alice recoge el después de este movimiento y nums[y] se convierte en 0.

Devuelve el número mínimo de movimientos que necesita Alice para coger exactamente k unos.

Ejemplo 1:

Entrada: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxCambios = 1
Salida: 3
Explicación: Alice puede coger 3 unos en 3 movimientos, si Alice realiza las siguientes acciones en cada movimiento cuando está en aliceIndex == 1:

 Al principio del juego Alice coge el uno y nums[1] se convierte en 0. nums se convierte en [1,1,1,0,0,1,1,0,0,1].
Selecciona j == 2 y realiza una acción del primer tipo. nums pasa a ser [1,0,1,0,0,1,1,0,0,1].
Selecciona x == 2 e y == 1, y realiza una acción del segundo tipo. nums pasa a ser [1,1,0,0,0,1,1,0,0,1]. Como y == aliceIndex, Alice coge el uno y nums pasa a ser [1,0,0,0,0,1,1,0,0,1].
Selecciona x == 0 e y == 1, y realiza una acción del segundo tipo. nums pasa a ser [0,1,0,0,0,1,1,0,0,1]. Como y == aliceIndex, Alice coge el uno y nums pasa a ser [0,0,0,0,0,1,1,0,0,1].

Tenga en cuenta que puede ser posible para Alice para recoger 3 unos utilizando alguna otra secuencia de 3 movimientos.

Ejemplo 2:

Entrada: nums = [0,0,0,0], k = 2, maxCambios = 3
Salida: 4
Explicación: Alice puede coger 2 unos en 4 movimientos, si Alice realiza las siguientes acciones en cada movimiento cuando se encuentra en aliceIndex == 0:

Selecciona j == 1 y realiza una acción del primer tipo. nums se convierte en [0,1,0,0].
Selecciona x == 1 e y == 0, y realiza una acción del segundo tipo. nums pasa a ser [1,0,0,0]. Como y == aliceIndex, Alice coge el uno y nums pasa a ser [0,0,0,0].
Selecciona de nuevo j == 1 y realiza una acción del primer tipo. nums pasa a ser [0,1,0,0].
Vuelve a seleccionar x == 1 e y == 0 y realiza una acción del segundo tipo. nums pasa a ser [1,0,0,0]. Como y == aliceIndex, Alice coge el uno y nums pasa a ser [0,0,0,0].

Restricciones:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxCambios + suma(números) >= k


Dada una cadena s, devuelve la longitud máxima de una subcadena tal que contenga como máximo dos ocurrencias de cada carácter.

Ejemplo 1:

Entrada: s = "bcbbbcba"
Salida: 4
Explicación:
La siguiente subcadena tiene una longitud de 4 y contiene como máximo dos ocurrencias de cada carácter: "bcbbbcba".
Ejemplo 2:

Entrada: s = "aaaa"
Salida: 2
Explicación:
La siguiente subcadena tiene una longitud de 2 y contiene como máximo dos ocurrencias de cada carácter: "aaaa".

Restricciones:

2 <= s.length <= 100
s consta únicamente de letras minúsculas del alfabeto inglés.

Dada una cadena s, devuelve la longitud máxima de una subcadena tal que contenga como máximo dos apariciones de cada carácter.

Ejemplo 1

Entrada: s = "bcbbbcba"
Salida: 4
Explicación:
La siguiente subcadena tiene una longitud de 4 y contiene como máximo dos apariciones de cada carácter: "bcbbbcba".
Ejemplo 2:

Entrada: s = "aaaa"
Salida: 2
Explicación:
La siguiente subcadena tiene una longitud de 2 y contiene como máximo dos ocurrencias de cada carácter: "aaaa".

Restricciones:

2 <= s.length <= 100
s está formada sólo por letras minúsculas inglesas.

Dada una cadena s, devuelve la longitud máxima de un substring tal que contenga como máximo dos ocurrencias de cada carácter.

Ejemplo 1:

Entrada: s = "bcbbbcba"
Salida: 4
Explicación:
El siguiente substring tiene una longitud de 4 y contiene como máximo dos ocurrencias de cada carácter: "bcbbbcba".

Ejemplo 2:

Entrada: s = "aaaa"
Salida: 2
Explicación:
El siguiente substring tiene una longitud de 2 y contiene como máximo dos ocurrencias de cada carácter: "aaaa".

Restricciones:

2 <= s.length <= 100
s consiste solo en letras minúsculas del alfabeto inglés.


Se te da un número entero positivo k. Inicialmente, tienes un arreglo nums = [1].
Puedes realizar cualquiera de las siguientes operaciones en el arreglo cualquier número de veces (posiblemente cero):

Elige cualquier elemento en el arreglo y aumenta su valor en 1.
Duplica cualquier elemento en el arreglo y agrégalo al final del arreglo.

Devuelve el número mínimo de operaciones requeridas para hacer que la suma de elementos del arreglo final sea mayor o igual a k.

Ejemplo 1:

Entrada: k = 11
Salida: 5
Explicación:
Podemos hacer las siguientes operaciones en el arreglo nums = [1]:

Aumentar el elemento en 1 tres veces. El arreglo resultante es nums = [4].
Duplicar el elemento dos veces. El arreglo resultante es nums = [4,4,4].

La suma del arreglo final es 4 + 4 + 4 = 12, que es mayor o igual a k = 11.
El número total de operaciones realizadas es 3 + 2 = 5.

Ejemplo 2:

Entrada: k = 1
Salida: 0
Explicación:
La suma del arreglo original ya es mayor o igual a 1, por lo que no se necesitan operaciones.

Restricciones:

1 <= k <= 10^5

Se le proporciona un entero positivo k. Inicialmente, tiene una matriz nums = [1].
Puede realizar cualquiera de las siguientes operaciones en la matriz cualquier cantidad de veces (posiblemente cero):

Elija cualquier elemento de la matriz y aumente su valor en 1.
Duplicar cualquier elemento de la matriz y agregarlo al final de la matriz.

Devuelva la cantidad mínima de operaciones necesarias para que la suma de elementos de la matriz final sea mayor o igual a k.

Ejemplo 1:

Entrada: k = 11
Salida: 5
Explicación:
Podemos realizar las siguientes operaciones en la matriz nums = [1]:

Aumente el elemento en 1 tres veces. La matriz resultante es nums = [4].
Duplicar el elemento dos veces. La matriz resultante es nums = [4,4,4].

La suma de la matriz final es 4 + 4 + 4 = 12, que es mayor o igual a k = 11.
El número total de operaciones realizadas es 3 + 2 = 5.

Ejemplo 2:

Entrada: k = 1
Salida: 0
Explicación:
La suma de la matriz original ya es mayor o igual a 1, por lo que no se necesitan operaciones.

Restricciones:

1 <= k <= 10^5


El problema involucra el seguimiento de la frecuencia de IDs en una colección que cambia con el tiempo. Tienes dos arreglos de enteros, `nums` y `freq`, de igual longitud `n`. Cada elemento en `nums` representa un ID, y el elemento correspondiente en `freq` indica cuántas veces ese ID debe ser añadido o eliminado de la colección en cada paso.

Adición de IDs: Si `freq[i]` es positivo, significa que `freq[i]` IDs con el valor `nums[i]` son añadidos a la colección en el paso `i`.
Eliminación de IDs: Si `freq[i]` es negativo, significa que `-freq[i]` IDs con el valor `nums[i]` son eliminados de la colección en el paso `i`.

Devuelve un arreglo `ans` de longitud `n`, donde `ans[i]` representa el conteo del ID más frecuente en la colección después del i-ésimo paso. Si la colección está vacía en algún paso, `ans[i]` debe ser 0 para ese paso.

Ejemplo 1:

Entrada: nums = [2,3,2,1], freq = [3,2,-3,1]
Salida: [3,3,2,2]
Explicación:
Después del paso 0, tenemos 3 IDs con el valor de 2. Así que `ans[0] = 3`.
Después del paso 1, tenemos 3 IDs con el valor de 2 y 2 IDs con el valor de 3. Así que `ans[1] = 3`.
Después del paso 2, tenemos 2 IDs con el valor de 3. Así que `ans[2] = 2`.
Después del paso 3, tenemos 2 IDs con el valor de 3 y 1 ID con el valor de 1. Así que `ans[3] = 2`.

Ejemplo 2:

Entrada: nums = [5,5,3], freq = [2,-2,1]
Salida: [2,0,1]
Explicación:
Después del paso 0, tenemos 2 IDs con el valor de 5. Así que `ans[0] = 2`.
Después del paso 1, no hay IDs. Así que `ans[1] = 0`.
Después del paso 2, tenemos 1 ID con el valor de 3. Así que `ans[2] = 1`.

Condiciones:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
La entrada está generada de tal manera que las ocurrencias de un ID no serán negativas en ningún paso.

El problema implica el seguimiento de la frecuencia de los identificadores en una colección que cambia con el tiempo. Tienes dos matrices de números enteros, nums y freq, de igual longitud n. Cada elemento en nums representa un identificador, y el elemento correspondiente en freq indica cuántas veces se debe agregar o quitar ese identificador de la colección en cada paso.

Adición de identificadores: si freq[i] es positivo, significa que los identificadores freq[i] con el valor nums[i] se agregan a la colección en el paso i.
Eliminación de identificadores: si freq[i] es negativo, significa que los identificadores -freq[i] con el valor nums[i] se eliminan de la colección en el paso i.

Devuelve una matriz ans de longitud n, donde ans[i] representa el recuento del identificador más frecuente en la colección después del paso i^th. Si la colección está vacía en cualquier paso, ans[i] debe ser 0 para ese paso.

Ejemplo 1:

Entrada: nums = [2,3,2,1], freq = [3,2,-3,1]
Salida: [3,3,2,2]
Explicación:
Después del paso 0, tenemos 3 ID con el valor 2. Por lo tanto, ans[0] = 3.
Después del paso 1, tenemos 3 ID con el valor 2 y 2 ID con el valor 3. Por lo tanto, ans[1] = 3.
Después del paso 2, tenemos 2 ID con el valor 3. Por lo tanto, ans[2] = 2.
Después del paso 3, tenemos 2 ID con el valor 3 y 1 ID con el valor 1. Por lo tanto, ans[3] = 2.

Ejemplo 2:

Entrada: nums = [5,5,3], freq = [2,-2,1]
Salida: [2,0,1]
Explicación:
Después del paso 0, tenemos 2 ID con el valor 5. Por lo tanto, ans[0] = 2.
Después del paso 1, no hay ID. Por lo tanto, ans[1] = 0.
Después del paso 2, tenemos 1 ID con el valor 3. Por lo tanto, ans[2] = 1.

Restricciones:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
La entrada se genera de modo que las ocurrencias de un ID no sean negativas en ningún paso.

El problema consiste en hacer un seguimiento de la frecuencia de IDs en una colección que cambia con el tiempo. Se dispone de dos matrices de enteros, nums y freq, de igual longitud n. Cada elemento de nums representa un ID, y el elemento correspondiente de freq indica cuántas veces debe añadirse o eliminarse ese ID de la colección en cada paso.

Adición de ID: Si freq[i] es positivo, significa que freq[i] IDs con el valor nums[i] se añaden a la colección en el paso i.
Eliminación de ID: Si freq[i] es negativo, significa que -freq[i] IDs con el valor nums[i] se eliminan de la colección en el paso i.

Devuelve una matriz ans de longitud n, donde ans[i] representa el recuento del ID más frecuente en la colección después del paso i^. Si la colección está vacía en algún paso, ans[i] debe ser 0 para ese paso.

Ejemplo 1

Entrada: nums = [2,3,2,1], freq = [3,2,-3,1]
Salida: [3,3,2,2]
Explicación:
Después del paso 0, tenemos 3 IDs con el valor de 2. Así que ans[0] = 3.
Después del paso 1, tenemos 3 IDs con el valor 2 y 2 IDs con el valor 3. Así que ans[1] = 3.
Después del paso 2, tenemos 2 ID con el valor 3. Por lo tanto ans[2] = 2.
Después del paso 3, tenemos 2 ID con el valor 3 y 1 ID con el valor 1. Por lo tanto ans[3] = 2.

Ejemplo 2:

Entrada: nums = [5,5,3], freq = [2,-2,1]
Salida: [2,0,1]
Explicación:
Después del paso 0, tenemos 2 IDs con el valor de 5. Así que ans[0] = 2.
Después del paso 1, no hay IDs. Por lo tanto ans[1] = 0.
Después del paso 2, tenemos 1 ID con el valor 3. Por lo tanto ans[2] = 1.

Restricciones:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
La entrada se genera de forma que las apariciones de un ID no sean negativas en ningún paso.


Se te dan dos arreglos de cadenas de texto, wordsContainer y wordsQuery.
Para cada wordsQuery[i], necesitas encontrar una cadena en wordsContainer que tenga el sufijo común más largo con wordsQuery[i]. Si hay dos o más cadenas en wordsContainer que comparten el sufijo común más largo, encuentra la cadena que sea la más pequeña en longitud. Si hay dos o más de estas cadenas que tienen la misma longitud más pequeña, encuentra la que apareció antes en wordsContainer.
Devuelve un arreglo de enteros ans, donde ans[i] es el índice de la cadena en wordsContainer que tiene el sufijo común más largo con wordsQuery[i].

Ejemplo 1:

Entrada: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"] Output: [1,1,1]
Explicación:
Veamos cada wordsQuery[i] por separado:

Para wordsQuery[0] = "cd", las cadenas de wordsContainer que comparten el sufijo común más largo "cd" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 1 porque tiene la menor longitud de 3.
Para wordsQuery[1] = "bcd", las cadenas de wordsContainer que comparten el sufijo común más largo "bcd" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 1 porque tiene la menor longitud de 3.
Para wordsQuery[2] = "xyz", no hay ninguna cadena de wordsContainer que comparta un sufijo común. Por lo tanto, el sufijo común más largo es "", que se comparte con las cadenas en el índice 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 1 porque tiene la menor longitud de 3.

Ejemplo 2:

Entrada: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Salida: [2,0,2]
Explicación:
Veamos cada wordsQuery[i] por separado:

Para wordsQuery[0] = "gh", las cadenas de wordsContainer que comparten el sufijo común más largo "gh" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 2 porque tiene la menor longitud de 6.
Para wordsQuery[1] = "acbfgh", solo la cadena en el índice 0 comparte el sufijo común más largo "fgh". Por lo tanto, es la respuesta, aunque la cadena en el índice 2 es más corta.
Para wordsQuery[2] = "acbfegh", las cadenas de wordsContainer que comparten el sufijo común más largo "gh" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 2 porque tiene la menor longitud de 6.

Restricciones:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] consiste solo en letras minúsculas inglesas.
wordsQuery[i] consiste solo en letras minúsculas inglesas.
La suma de wordsContainer[i].length es como máximo 5 * 10^5.
La suma de wordsQuery[i].length es como máximo 5 * 10^5.

Se le proporcionan dos matrices de cadenas wordsContainer y wordsQuery.
Para cada wordsQuery[i], debe encontrar una cadena de wordsContainer que tenga el sufijo común más largo con wordsQuery[i]. Si hay dos o más cadenas en wordsContainer que comparten el sufijo común más largo, encuentre la cadena que tenga la longitud más pequeña. Si hay dos o más cadenas de este tipo que tienen la misma longitud más pequeña, encuentre la que apareció antes en wordsContainer.
Devuelve una matriz de números enteros ans, donde ans[i] es el índice de la cadena en wordsContainer que tiene el sufijo común más largo con wordsQuery[i].

Ejemplo 1:

Entrada: wordsContainer = ["abcd", "bcd", "xbcd"], wordsQuery = ["cd", "bcd", "xyz"]
Salida: [1,1,1]
Explicación:
Veamos cada wordsQuery[i] por separado:

Para wordsQuery[0] = "cd", las cadenas de wordsContainer que comparten el sufijo común más largo "cd" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 1 porque tiene la longitud más corta de 3.
Para wordsQuery[1] = "bcd", las cadenas de wordsContainer que comparten el sufijo común más largo "bcd" están en los índices 0, 1 y 2. Entre estas, la respuesta es la cadena en el índice 1 porque tiene la longitud más corta de 3.
Para wordsQuery[2] = "xyz", no hay ninguna cadena de wordsContainer que comparta un sufijo común. Por lo tanto, el sufijo común más largo es "", que se comparte con las cadenas en los índices 0, 1 y 2. Entre ellas, la respuesta es la cadena en el índice 1 porque tiene la longitud más corta de 3.

Ejemplo 2:

Entrada: wordsContainer = ["abcdefgh", "poiuygh", "ghghgh"], wordsQuery = ["gh", "acbfgh", "acbfegh"]
Salida: [2,0,2]
Explicación:
Veamos cada wordsQuery[i] por separado:

Para wordsQuery[0] = "gh", las cadenas de wordsContainer que comparten el sufijo común más largo "gh" están en los índices 0, 1 y 2. Entre ellas, la respuesta es la cadena en el índice 2 porque tiene la longitud más corta de 6.
Para wordsQuery[1] = "acbfgh", solo la cadena en el índice 0 comparte el sufijo común más largo "fgh". Por lo tanto, es la respuesta, aunque la cadena en el índice 2 sea más corta.
Para wordsQuery[2] = "acbfegh", las cadenas de wordsContainer que comparten el sufijo común más largo "gh" están en los índices 0, 1 y 2. Entre ellas, la respuesta es la cadena en el índice 2 porque tiene la longitud más corta de 6.

Restricciones:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] consta solo de letras minúsculas en inglés.
wordsQuery[i] consta solo de letras minúsculas en inglés.
La suma de wordsContainer[i].length es como máximo 5 * 10^5.
La suma de wordsQuery[i].length es como máximo 5 * 10^5.


Un número entero divisible por la suma de sus dígitos se dice que es un número de Harshad. Se te da un número entero x. Devuelve la suma de los dígitos de x si x es un número de Harshad, de lo contrario, devuelve -1.

Ejemplo 1:

Entrada: x = 18
Salida: 9
Explicación:
La suma de los dígitos de x es 9. 18 es divisible por 9. Así que 18 es un número de Harshad y la respuesta es 9.

Ejemplo 2:

Entrada: x = 23
Salida: -1
Explicación:
La suma de los dígitos de x es 5. 23 no es divisible por 5. Así que 23 no es un número de Harshad y la respuesta es -1.

Restricciones:

1 <= x <= 100

Un entero divisible por la suma de sus dígitos se dice que es un número Harshad. Se le proporciona un entero x. Devuelva la suma de los dígitos de x si x es un número Harshad; de lo contrario, devuelva -1.

Ejemplo 1:

Entrada: x = 18
Salida: 9
Explicación:
La suma de los dígitos de x es 9. 18 es divisible por 9. Por lo tanto, 18 es un número Harshad y la respuesta es 9.

Ejemplo 2:

Entrada: x = 23
Salida: -1
Explicación:
La suma de los dígitos de x es 5. 23 no es divisible por 5. Por lo tanto, 23 no es un número Harshad y la respuesta es -1.

Restricciones:

1 <= x <= 100


Se te da un array binario nums.
Llamamos a un subarray alternante si no hay dos elementos adyacentes en el subarray que tengan el mismo valor.
Devuelve el número de subarrays alternantes en nums.

Ejemplo 1:

Entrada: nums = [0,1,1,1]
Salida: 5
Explicación:
Los siguientes subarrays son alternantes: [0], [1], [1], [1], y [0,1].

Ejemplo 2:

Entrada: nums = [1,0,1,0]
Salida: 10
Explicación:
Cada subarray del array es alternante. Hay 10 subarrays posibles que podemos elegir.

Restricciones:

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

Se le proporciona una matriz binaria nums.
Llamamos a una submatriz alternante si no hay dos elementos adyacentes en la submatriz que tengan el mismo valor.
Devuelve la cantidad de submatrices alternantes en nums.

Ejemplo 1:

Entrada: nums = [0,1,1,1]
Salida: 5
Explicación:
Las siguientes submatrices son alternantes: [0], [1], [1], [1] y [0,1].

Ejemplo 2:

Entrada: nums = [1,0,1,0]
Salida: 10
Explicación:
Cada submatriz de la matriz es alternante. Hay 10 submatrices posibles que podemos elegir.

Restricciones:

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


Se le proporciona una matriz de puntos que representan las coordenadas enteras de algunos puntos en un plano 2D, donde points[i] = [x_i, y_i].
La distancia entre dos puntos se define como su distancia de Manhattan.
Devuelve el valor mínimo posible para la distancia máxima entre dos puntos cualesquiera eliminando exactamente un punto.

Ejemplo 1:

Entrada: points = [[3,10],[5,15],[10,2],[4,4]]
Salida: 12
Explicación:
La distancia máxima después de eliminar cada punto es la siguiente:

Después de eliminar el punto 0^th, la distancia máxima es entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.
Después de eliminar el punto 1^st, la distancia máxima es entre los puntos (3, 10) y (10, 2), que es |3 - 10| + |10 - 2| = 15.
Después de quitar el 2.º punto, la distancia máxima está entre los puntos (5, 15) y (4, 4), que es |5 - 4| + |15 - 4| = 12.
Después de quitar el 3.er punto, la distancia máxima está entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.

12 es la distancia máxima mínima posible entre dos puntos cualesquiera después de quitar exactamente un punto.

Ejemplo 2:

Entrada: points = [[1,1],[1,1],[1,1]]
Salida: 0
Explicación:
Si se elimina cualquiera de los puntos, la distancia máxima entre dos puntos es 0.

Restricciones:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Se te da un conjunto points que representa coordenadas enteras de algunos puntos en un plano 2D, donde points[i] = [x_i, y_i].
La distancia entre dos puntos se define como su distancia Manhattan.
Devuelve el valor mínimo posible para la distancia máxima entre dos puntos al eliminar exactamente un punto.

Ejemplo 1:

Entrada: points = [[3,10],[5,15],[10,2],[4,4]]
Salida: 12
Explicación:
La distancia máxima después de eliminar cada punto es la siguiente:

Después de eliminar el punto 0, la distancia máxima es entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.
Después de eliminar el punto 1, la distancia máxima es entre los puntos (3, 10) y (10, 2), que es |3 - 10| + |10 - 2| = 15.
Después de eliminar el punto 2, la distancia máxima es entre los puntos (5, 15) y (4, 4), que es |5 - 4| + |15 - 4| = 12.
Después de eliminar el punto 3, la distancia máxima es entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.

12 es la distancia máxima mínima posible entre cualquier dos puntos después de eliminar exactamente un punto.

Ejemplo 2:

Entrada: points = [[1,1],[1,1],[1,1]]
Salida: 0
Explicación:
Eliminar cualquiera de los puntos resulta en una distancia máxima entre cualquier par de puntos de 0.

Restricciones:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Se te da una matriz de puntos que representa coordenadas enteras de algunos puntos en un plano 2D, donde points[i] = [x_i, y_i].
La distancia entre dos puntos se define como su distancia Manhattan.
Devuelve el valor mínimo posible para la distancia máxima entre dos puntos al eliminar exactamente un punto.

Ejemplo 1:

Entrada: points = [[3,10],[5,15],[10,2],[4,4]]
Salida: 12
Explicación:
La distancia máxima después de eliminar cada punto es la siguiente:

Después de eliminar el punto 0, la distancia máxima es entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.
Después de eliminar el punto 1, la distancia máxima es entre los puntos (3, 10) y (10, 2), que es |3 - 10| + |10 - 2| = 15.
Después de eliminar el punto 2, la distancia máxima es entre los puntos (5, 15) y (4, 4), que es |5 - 4| + |15 - 4| = 12.
Después de eliminar el punto 3, la distancia máxima es entre los puntos (5, 15) y (10, 2), que es |5 - 10| + |15 - 2| = 18.

12 es la distancia máxima mínima posible entre cualesquiera dos puntos después de eliminar exactamente un punto.

Ejemplo 2:

Entrada: points = [[1,1],[1,1],[1,1]]
Salida: 0
Explicación:
Eliminar cualquiera de los puntos resulta en una distancia máxima entre cualquier par de puntos de 0.

Restricciones:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8


Se te da un array de enteros nums. Devuelve la longitud del subarray más largo de nums que sea estrictamente creciente o estrictamente decreciente.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2]
Salida: 2
Explicación:
Los subarrays estrictamente crecientes de nums son [1], [2], [3], [3], [4], y [1,4].
Los subarrays estrictamente decrecientes de nums son [1], [2], [3], [3], [4], [3,2], y [4,3].
Por lo tanto, devolvemos 2.

Ejemplo 2:

Entrada: nums = [3,3,3,3]
Salida: 1
Explicación:
Los subarrays estrictamente crecientes de nums son [3], [3], [3], y [3].
Los subarrays estrictamente decrecientes de nums son [3], [3], [3], y [3].
Por lo tanto, devolvemos 1.

Ejemplo 3:

Entrada: nums = [3,2,1]
Salida: 3
Explicación:
Los subarrays estrictamente crecientes de nums son [3], [2], y [1].
Los subarrays estrictamente decrecientes de nums son [3], [2], [1], [3,2], [2,1], y [3,2,1].
Por lo tanto, devolvemos 3.

Restricciones:

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

Se le da una matriz de enteros nums. Devuelve la longitud de la submatriz más larga de nums que sea estrictamente creciente o estrictamente decreciente.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2]
Salida: 2
Explicación:
Las submatrices estrictamente crecientes de nums son [1], [2], [3], [3], [4] y [1,4].
Las submatrices estrictamente decrecientes de nums son [1], [2], [3], [3], [4], [3,2] y [4,3].
Por lo tanto, devolvemos 2.

Ejemplo 2:

Entrada: nums = [3,3,3,3]
Salida: 1
Explicación:
Las submatrices estrictamente crecientes de nums son [3], [3], [3] y [3].
Las submatrices estrictamente decrecientes de nums son [3], [3], [3] y [3].
Por lo tanto, devolvemos 1.

Ejemplo 3:

Entrada: nums = [3,2,1]
Salida: 3
Explicación:
Las submatrices estrictamente crecientes de nums son [3], [2] y [1].
Las submatrices estrictamente decrecientes de nums son [3], [2], [1], [3,2], [2,1] y [3,2,1].
Por lo tanto, devolvemos 3.

Restricciones:

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


Se le proporciona una cadena s y un entero k.
Defina una función distancia(s_1, s_2) entre dos cadenas s_1 y s_2 de la misma longitud n como:

La suma de la distancia mínima entre s_1[i] y s_2[i] cuando los caracteres de 'a' a 'z' se colocan en un orden cíclico, para todos los i en el rango [0, n - 1].

Por ejemplo, distancia("ab", "cd") == 4, y distancia("a", "z") == 1.
Puede cambiar cualquier letra de s por cualquier otra letra minúscula del inglés, cualquier número de veces.
Devuelva una cadena que denote la cadena t más pequeña lexicográficamente que puede obtener después de algunos cambios, de modo que distancia(s, t) <= k.

Ejemplo 1:

Entrada: s = "zbbz", k = 3
Salida: "aaaz"
Explicación:
Cambie s por "aaaz". La distancia entre "zbbz" y "aaaz" es igual a k = 3.

Ejemplo 2:

Entrada: s = "xaxcd", k = 4
Salida: "aawcd"
Explicación:
La distancia entre "xaxcd" y "aawcd" es igual a k = 4.

Ejemplo 3:

Entrada: s = "lol", k = 0
Salida: "lol"
Explicación:
Es imposible cambiar cualquier carácter ya que k = 0.

Restricciones:

1 <= s.length <= 100
0 <= k <= 2000
s consta únicamente de letras minúsculas del alfabeto inglés.

Se te da una cadena s y un entero k.
Define una función distancia(s_1, s_2) entre dos cadenas s_1 y s_2 de la misma longitud n como:

La suma de la distancia mínima entre s_1[i] y s_2[i] cuando los caracteres de 'a' a 'z' están en un orden cíclico, para todos los i en el rango [0, n - 1].

Por ejemplo, distancia("ab", "cd") == 4, y distancia("a", "z") == 1.
Puedes cambiar cualquier letra de s por cualquier otra letra minúscula inglesa, cualquier cantidad de veces.
Devuelve una cadena que denote la cadena más pequeña lexicográficamente t que puedas obtener después de algunos cambios, tal que distancia(s, t) <= k.

Ejemplo 1:

Entrada: s = "zbbz", k = 3
Salida: "aaaz"
Explicación:
Cambia s a "aaaz". La distancia entre "zbbz" y "aaaz" es igual a k = 3.

Ejemplo 2:

Entrada: s = "xaxcd", k = 4
Salida: "aawcd"
Explicación:
La distancia entre "xaxcd" y "aawcd" es igual a k = 4.

Ejemplo 3:

Entrada: s = "lol", k = 0
Salida: "lol"
Explicación:
Es imposible cambiar cualquier carácter ya que k = 0.

Restricciones:

1 <= s.length <= 100
0 <= k <= 2000
s consiste solo de letras minúsculas inglesas.


Se te da un array de enteros nums y un entero no negativo k. En una operación, puedes aumentar o disminuir cualquier elemento en 1.
Devuelve el número mínimo de operaciones necesarias para que la mediana de nums sea igual a k.
La mediana de un array se define como el elemento del medio del array cuando está ordenado en orden no decreciente. Si hay dos opciones para una mediana, se toma el mayor de los dos valores.

Ejemplo 1:

Entrada: nums = [2,5,6,8,5], k = 4
Salida: 2
Explicación:
Podemos restar uno de nums[1] y nums[4] para obtener [2, 4, 6, 8, 4]. La mediana del array resultante es igual a k.

Ejemplo 2:

Entrada: nums = [2,5,6,8,5], k = 7
Salida: 3
Explicación:
Podemos sumar uno a nums[1] dos veces y sumar uno a nums[2] una vez para obtener [2, 7, 7, 8, 5].

Ejemplo 3:

Entrada: nums = [1,2,3,4,5,6], k = 4
Salida: 0
Explicación:
La mediana del array ya es igual a k.

Restricciones:

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

Se le da una matriz de enteros nums y un entero no negativo k. En una operación, puede aumentar o disminuir cualquier elemento en 1.
Devuelve el número mínimo de operaciones necesarias para que la mediana de nums sea igual a k.
La mediana de una matriz se define como el elemento central de la matriz cuando se ordena en orden no decreciente. Si hay dos opciones para una mediana, se toma el mayor de los dos valores.

Ejemplo 1:

Entrada: nums = [2,5,6,8,5], k = 4
Salida: 2
Explicación:
Podemos restar uno de nums[1] y nums[4] para obtener [2, 4, 6, 8, 4]. La mediana de la matriz resultante es igual a k.

Ejemplo 2:

Entrada: nums = [2,5,6,8,5], k = 7
Salida: 3
Explicación:
Podemos agregar uno a nums[1] dos veces y agregar uno a nums[2] una vez para obtener [2, 7, 7, 8, 5].

Ejemplo 3:

Entrada: nums = [1,2,3,4,5,6], k = 4
Salida: 0
Explicación:
La mediana de la matriz ya es igual a k.

Restricciones:

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

Se te da un array de enteros nums y un entero no negativo k. En una operación, puedes aumentar o disminuir cualquier elemento en 1.
Devuelve el número mínimo de operaciones necesarias para que la mediana de nums sea igual a k.
La mediana de un array se define como el elemento del medio del array cuando está ordenado en orden no decreciente. Si hay dos opciones para una mediana, se toma el mayor de los dos valores.

Ejemplo 1:

Input: nums = [2,5,6,8,5], k = 4
Output: 2
Explicación:
Podemos restar uno de nums[1] y nums[4] para obtener [2, 4, 6, 8, 4]. La mediana del array resultante es igual a k.

Ejemplo 2:

Input: nums = [2,5,6,8,5], k = 7
Output: 3
Explicación:
Podemos sumar uno a nums[1] dos veces y sumar uno a nums[2] una vez para obtener [2, 7, 7, 8, 5].

Ejemplo 3:

Input: nums = [1,2,3,4,5,6], k = 4
Output: 0
Explicación:
La mediana del array ya es igual a k.

Restricciones:

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


Se te da una cadena s que representa una hora en formato de 12 horas donde algunos de los dígitos (posiblemente ninguno) son reemplazados por un "?".
Las horas en formato de 12 horas se expresan como "HH:MM", donde HH está entre 00 y 11, y MM está entre 00 y 59. La hora más temprana en formato de 12 horas es 00:00 y la más tardía es 11:59.
Tienes que reemplazar todos los caracteres "?" en s por dígitos de manera que la hora resultante sea válida en formato de 12 horas y sea la última posible.
Devuelve la cadena resultante.

Ejemplo 1:

Entrada: s = "1?:?4"
Salida: "11:54"
Explicación: La última hora en formato de 12 horas que se puede lograr al reemplazar los caracteres "?" es "11:54".

Ejemplo 2:

Entrada: s = "0?:5?"
Salida: "09:59"
Explicación: La última hora en formato de 12 horas que se puede lograr al reemplazar los caracteres "?" es "09:59".

Condiciones:

s.length == 5
s[2] es igual al carácter ":".
Todos los caracteres excepto s[2] son dígitos o caracteres "?".
La entrada está generada de tal manera que hay al menos un horario entre "00:00" y "11:59" que se puede obtener después de reemplazar los caracteres "?".

Se le proporciona una cadena s que representa una hora en formato de 12 horas donde algunos de los dígitos (posiblemente ninguno) se reemplazan con un "?".
Las horas en formato de 12 horas se formatean como "HH:MM", donde HH está entre 00 y 11, y MM está entre 00 y 59. La hora de 12 horas más temprana es 00:00, y la más tardía es 11:59.
Debe reemplazar todos los caracteres "?" en s con dígitos de modo que la hora que obtenemos por la cadena resultante sea una hora válida en formato de 12 horas y sea la más tardía posible.
Devuelve la cadena resultante.

Ejemplo 1:

Entrada: s = "1?:?4"
Salida: "11:54"
Explicación: La hora en formato de 12 horas más tardía que podemos lograr reemplazando los caracteres "?" es "11:54".

Ejemplo 2:

Entrada: s = "0?:5?"
Salida: "09:59"
Explicación: La última hora en formato de 12 horas que podemos obtener reemplazando los caracteres "?" es "09:59".

Restricciones:

s.length == 5
s[2] es igual al carácter :".
Todos los caracteres excepto s[2] son dígitos o caracteres "?".
La entrada se genera de manera que haya al menos una hora entre "00:00" y "11:59" que se pueda obtener después de reemplazar los caracteres "?".


Se te da un arreglo de enteros nums.
Devuelve un entero que sea la distancia máxima entre los índices de dos números primos (no necesariamente diferentes) en nums.

Ejemplo 1:

Entrada: nums = [4,2,9,5,3]
Salida: 3
Explicación: nums[1], nums[3] y nums[4] son primos. Entonces la respuesta es |4 - 1| = 3.

Ejemplo 2:

Entrada: nums = [4,8,2,8]
Salida: 0
Explicación: nums[2] es primo. Como solo hay un número primo, la respuesta es |2 - 2| = 0.

Restricciones:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
La entrada se genera de manera que el número de números primos en nums es al menos uno.

Se te da un conjunto de enteros nums.
Devuelve un entero que sea la distancia máxima entre los índices de dos números primos (no necesariamente diferentes) en nums.

Ejemplo 1:

Entrada: nums = [4,2,9,5,3]
Salida: 3
Explicación: nums[1], nums[3] y nums[4] son primos. Entonces la respuesta es |4 - 1| = 3.

Ejemplo 2:

Entrada: nums = [4,8,2,8]
Salida: 0
Explicación: nums[2] es primo. Como solo hay un número primo, la respuesta es |2 - 2| = 0.

Restricciones:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
La entrada se genera de manera que el número de números primos en nums es al menos uno.

Se le da una matriz de números enteros nums.
Devuelve un entero que es la distancia máxima entre los índices de dos números primos (no necesariamente diferentes) en nums.

Ejemplo 1:

Entrada: nums = [4,2,9,5,3]
Salida: 3
Explicación: nums[1], nums[3] y nums[4] son primos. Así que la respuesta es |4 - 1| = 3.

Ejemplo 2:

Entrada: nums = [4,8,2,8]
Salida: 0
Explicación: nums[2] es primo. Como sólo hay un número primo, la respuesta es |2 - 2| = 0.

Restricciones:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
La entrada se genera de tal manera que el número de números primos en nums es al menos uno.


Se te da una matriz coins de números enteros que representa monedas de diferentes denominaciones y un entero k. Tienes un número infinito de monedas de cada denominación. Sin embargo, no se te permite combinar monedas de diferentes denominaciones. Devuelve la k^ésima cantidad más pequeña que se puede hacer usando estas monedas.

Ejemplo 1:

Entrada: coins = [3,6,9], k = 3
Salida: 9
Explicación: Las monedas dadas pueden hacer las siguientes cantidades:
La moneda 3 produce múltiplos de 3: 3, 6, 9, 12, 15, etc.
La moneda 6 produce múltiplos de 6: 6, 12, 18, 24, etc.
La moneda 9 produce múltiplos de 9: 9, 18, 27, 36, etc.
Todas las monedas combinadas producen: 3, 6, 9, 12, 15, etc.

Ejemplo 2:

Entrada: coins = [5,2], k = 7
Salida: 12
Explicación: Las monedas dadas pueden hacer las siguientes cantidades:
La moneda 5 produce múltiplos de 5: 5, 10, 15, 20, etc.
La moneda 2 produce múltiplos de 2: 2, 4, 6, 8, 10, 12, etc.
Todas las monedas combinadas producen: 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Restricciones:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contiene enteros distintos entre sí.

Se le proporciona una matriz de números enteros que representan monedas de diferentes denominaciones y un número entero k.
Tiene una cantidad infinita de monedas de cada denominación. Sin embargo, no se le permite combinar monedas de diferentes denominaciones.
Devuelva la k^ésima cantidad más pequeña que se puede obtener utilizando estas monedas.

Ejemplo 1:

Entrada: coins = [3,6,9], k = 3
Salida: 9
Explicación: Las monedas dadas pueden formar las siguientes cantidades:
La moneda 3 produce múltiplos de 3: 3, 6, 9, 12, 15, etc.
La moneda 6 produce múltiplos de 6: 6, 12, 18, 24, etc.
La moneda 9 produce múltiplos de 9: 9, 18, 27, 36, etc.
Todas las monedas combinadas producen: 3, 6, 9, 12, 15, etc.

Ejemplo 2:

Entrada: coins = [5,2], k = 7
Salida: 12
Explicación: Las monedas dadas pueden formar las siguientes cantidades:
La moneda 5 produce múltiplos de 5: 5, 10, 15, 20, etc.
La moneda 2 produce múltiplos de 2: 2, 4, 6, 8, 10, 12, etc.
Todas las monedas combinadas producen: 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Restricciones:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contiene números enteros distintos por pares.

Se te da una matriz de enteros coins que representa monedas de diferentes denominaciones y un entero k. Tienes un número infinito de monedas de cada denominación. Sin embargo, no se te permite combinar monedas de diferentes denominaciones. Devuelve la k^ésima cantidad más pequeña que se puede hacer usando estas monedas.

Ejemplo 1:

Entrada: coins = [3,6,9], k = 3
Salida: 9
Explicación: Las monedas dadas pueden hacer las siguientes cantidades:
La moneda 3 produce múltiplos de 3: 3, 6, 9, 12, 15, etc.
La moneda 6 produce múltiplos de 6: 6, 12, 18, 24, etc.
La moneda 9 produce múltiplos de 9: 9, 18, 27, 36, etc.
Todas las monedas combinadas producen: 3, 6, 9, 12, 15, etc.

Ejemplo 2:

Entrada: coins = [5,2], k = 7
Salida: 12
Explicación: Las monedas dadas pueden hacer las siguientes cantidades:
La moneda 5 produce múltiplos de 5: 5, 10, 15, 20, etc.
La moneda 2 produce múltiplos de 2: 2, 4, 6, 8, 10, 12, etc.
Todas las monedas combinadas producen: 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Condiciones:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contiene enteros distintos entre sí.


Se te dan dos arreglos, nums y andValues de longitud n y m respectivamente.
El valor de un arreglo es igual al último elemento de ese arreglo.
Tienes que dividir nums en m subarreglos disjuntos contiguos de manera que para el i-ésimo subarreglo [l_i, r_i], el AND bit a bit de los elementos del subarreglo sea igual a andValues[i], en otras palabras, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] para todo 1 <= i <= m, donde & representa el operador AND bit a bit.
Devuelve la suma mínima posible de los valores de los m subarreglos en los que se divide nums. Si no es posible dividir nums en m subarreglos que satisfacen estas condiciones, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Salida: 12
Explicación:
La única forma posible de dividir nums es:

[1,4] ya que 1 & 4 == 0.
[3] ya que el AND bit a bit de un subarreglo de un solo elemento es ese mismo elemento.
[3] ya que el AND bit a bit de un subarreglo de un solo elemento es ese mismo elemento.
[2] ya que el AND bit a bit de un subarreglo de un solo elemento es ese mismo elemento.

La suma de los valores de estos subarreglos es 4 + 3 + 3 + 2 = 12.

Ejemplo 2:

Entrada: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Salida: 17
Explicación:
Hay tres formas de dividir nums:

[[2,3,5],[7,7,7],[5]] con la suma de los valores 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] con la suma de los valores 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] con la suma de los valores 7 + 7 + 5 == 19.

La suma mínima posible de los valores es 17.

Ejemplo 3:

Entrada: nums = [1,2,3,4], andValues = [2]
Salida: -1
Explicación:
El AND bit a bit de todo el arreglo nums es 0. Como no hay forma posible de dividir nums en un solo subarreglo para que el AND bit a bit de los elementos sea 2, devuelve -1.

Restricciones:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Se le proporcionan dos matrices nums y andValues de longitud n y m respectivamente.
El valor de una matriz es igual al último elemento de esa matriz.
Debe dividir nums en m submatrices contiguas disjuntas de modo que para la i^ésima submatriz [l_i, r_i], el AND bit a bit de los elementos de la submatriz sea igual a andValues[i], en otras palabras, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] para todos los 1 <= i <= m, donde & representa el operador AND bit a bit.
Devuelve la suma mínima posible de los valores de las m submatrices en las que se divide nums. Si no es posible dividir nums en m submatrices que satisfagan estas condiciones, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Salida: 12
Explicación:
La única forma posible de dividir nums es:

[1,4] como 1 y 4 == 0.
[3] como el AND bit a bit de un subarreglo de un solo elemento es ese elemento en sí.
[3] como el AND bit a bit de un subarreglo de un solo elemento es ese elemento en sí.
[2] como el AND bit a bit de un subarreglo de un solo elemento es ese elemento en sí.

La suma de los valores de estos subconjuntos es 4 + 3 + 3 + 2 = 12.

Ejemplo 2:

Entrada: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Salida: 17
Explicación:
Hay tres formas de dividir nums:

[[2,3,5],[7,7,7],[5]] con la suma de los valores 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] con la suma de los valores 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] con la suma de los valores 7 + 7 + 5 == 19.

La suma mínima posible de los valores es 17.

Ejemplo 3:

Entrada: nums = [1,2,3,4], andValues = [2]
Salida: -1
Explicación:
El AND bit a bit de todo el arreglo nums es 0. Como no hay forma posible de dividir nums en un único subarreglo para tener el AND bit a bit de los elementos 2, devuelve -1.

Restricciones:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Se te da un array de enteros nums que contiene números enteros positivos. Definimos una función encrypt tal que encrypt(x) reemplaza cada dígito en x con el dígito más grande en x. Por ejemplo, encrypt(523) = 555 y encrypt(213) = 333.
Devuelve la suma de los elementos encriptados.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 6
Explicación: Los elementos encriptados son [1,2,3]. La suma de los elementos encriptados es 1 + 2 + 3 == 6.

Ejemplo 2:

Entrada: nums = [10,21,31]
Salida: 66
Explicación: Los elementos encriptados son [11,22,33]. La suma de los elementos encriptados es 11 + 22 + 33 == 66.

Condiciones:

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

Se te da un conjunto de enteros nums que contiene números enteros positivos. Definimos una función encrypt tal que encrypt(x) reemplaza cada dígito en x con el dígito más grande en x. Por ejemplo, encrypt(523) = 555 y encrypt(213) = 333.
Devuelve la suma de los elementos encriptados.

Ejemplo 1:

Input: nums = [1,2,3]
Output: 6
Explicación: Los elementos encriptados son [1,2,3]. La suma de los elementos encriptados es 1 + 2 + 3 == 6.

Ejemplo 2:

Input: nums = [10,21,31]
Output: 66
Explicación: Los elementos encriptados son [11,22,33]. La suma de los elementos encriptados es 11 + 22 + 33 == 66.

Restricciones:

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

Se da una matriz de enteros nums que contiene enteros positivos. Definimos una función cifrar tal que cifrar(x) sustituye cada dígito de x por el dígito mayor de x. Por ejemplo, cifrar(523) = 555 y cifrar(213) = 333.
Devuelve la suma de los elementos cifrados.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 6
Explicación: Los elementos cifrados son [1,2,3]. La suma de los elementos cifrados es 1 + 2 + 3 == 6.

Ejemplo 2:

Entrada: nums = [10,21,31]
Salida: 66
Explicación: Los elementos cifrados son [11,22,33]. La suma de los elementos cifrados es 11 + 22 + 33 == 66.

Restricciones:

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