Se le proporciona una secuencia de números enteros A=(A_1,\ldots,A_N) de longitud N. Aquí, A_1, A_2, \ldots, A_N son todos distintos.
¿Qué elemento de A es el segundo más grande?

Entrada

La entrada se proporciona desde la Entrada estándar en el siguiente formato:
N
A_1 A_2 \ldots A_{N}

Salida

Imprima el número entero X tal que el elemento X-ésimo de A sea el segundo más grande.

Restricciones

- 2 \leq N \leq 100
- 1 \leq A_i \leq 10^9
- A_1, A_2, \ldots, A_N son todos distintos.
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

4
8 2 5 1

Salida de muestra 1

3

El segundo elemento más grande en A es A_3, por lo que se imprime 3.

Entrada de muestra 2

8
1 2 3 4 5 10 9 11

Salida de muestra 2

6

Se le da una secuencia entera A=(A_1,\ldots,A_N) de longitud N. Aquí, A_1, A_2, \ldots, A_N son todos distintos.
¿Qué elemento de A es el segundo más grande?

Entrada

La entrada se da desde Standard Input en el siguiente formato:
N
A_1 A_2 \ldots A_{N}

Salida

Imprime el número entero X tal que el elemento X-ésimo en A es el segundo más grande.

Restricciones

- 2 \leq N \leq 100
- 1 \leq A_i \leq 10^9
- A_1, A_2, \ldots, A_N son todos distintos.
- Todos los valores de entrada son enteros.

Entrada de muestra 1

4
8 2 5 1

Muestra de salida 1

3

El segundo elemento más grande de A es A_3, así que imprime 3.

Ejemplo de entrada 2

8
1 2 3 4 5 10 9 11

Ejemplo de salida 2

6

Dada una secuencia de enteros A=(A_1,\ldots,A_N) de longitud N. Aquí, A_1, A_2, \ldots, A_N son todos distintos.
¿Cuál elemento en A es el segundo más grande?

Entrada

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

Salida

Imprime el entero X tal que el X-ésimo elemento en A es el segundo más grande.

Restricciones

- 2 \leq N \leq 100
- 1 \leq A_i \leq 10^9
- A_1, A_2, \ldots, A_N son todos distintos.
- Todos los valores de entrada son enteros.

Entrada de Ejemplo 1

4
8 2 5 1

Salida de Ejemplo 1

3

El segundo elemento más grande en A es A_3, entonces imprime 3.

Entrada de Ejemplo 2

8
1 2 3 4 5 10 9 11

Salida de Ejemplo 2

6


Se le da un número entero Y entre 1583 y 2023.
Halla el número de días del año Y del calendario gregoriano.
Dentro del intervalo dado, el año Y tiene el siguiente número de días:

-
si Y no es múltiplo de 4, entonces 365 días;

-
si Y es un múltiplo de 4 pero no un múltiplo de 100, entonces 366 días;

-
si Y es un múltiplo de 100 pero no un múltiplo de 400, entonces 365 días;

-
si Y es un múltiplo de 400, entonces 366 días.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
Y

Salida

Imprime el número de días del año Y como un número entero.

Restricciones

- Y es un número entero entre 1583 y 2023, ambos incluidos.

Entrada de muestra 1

2023

Salida de muestra 1

365

2023 no es un múltiplo de 4, por lo que tiene 365 días.

Entrada de muestra 2

1992

Salida de muestra 2

366

1992 es un múltiplo de 4 pero no un múltiplo de 100, por lo que tiene 366 días.

Entrada de muestra 3

1800

Salida de muestra 3

365

1800 es un múltiplo de 100 pero no un múltiplo de 400, por lo que tiene 365 días.

Entrada de muestra 4

1600

Salida de muestra 4

366

1600 es un múltiplo de 400, por lo que tiene 366 días.

Se te da un entero Y entre 1583 y 2023.
Encuentra el número de días en el año Y del calendario gregoriano.
Dentro del rango dado, el año Y tiene el siguiente número de días:

-
si Y no es múltiplo de 4, entonces 365 días;

-
si Y es múltiplo de 4 pero no múltiplo de 100, entonces 366 días;

-
si Y es múltiplo de 100 pero no múltiplo de 400, entonces 365 días;

-
si Y es múltiplo de 400, entonces 366 días.

Entrada

La entrada se da desde la Entrada Estándar en el siguiente formato:
Y

Salida

Imprime el número de días en el año Y como un entero.

Restricciones

- Y es un entero entre 1583 y 2023, inclusive.

Entrada de Ejemplo 1

2023

Salida de Ejemplo 1

365

2023 no es un múltiplo de 4, por lo que tiene 365 días.

Entrada de Ejemplo 2

1992

Salida de Ejemplo 2

366

1992 es un múltiplo de 4 pero no un múltiplo de 100, por lo que tiene 366 días.

Entrada de Ejemplo 3

1800

Salida de Ejemplo 3

365

1800 es un múltiplo de 100 pero no un múltiplo de 400, por lo que tiene 365 días.

Entrada de Ejemplo 4

1600

Salida de Ejemplo 4

366

1600 es un múltiplo de 400, por lo que tiene 366 días.

Se le da un número entero Y comprendido entre 1583 y 2023.
Hallar el número de días del año Y del calendario gregoriano.
Dentro del intervalo dado, el año Y tiene el siguiente número de días:

-
si Y no es múltiplo de 4, entonces 365 días;

-
si Y es múltiplo de 4 pero no múltiplo de 100, entonces 366 días;

-
si Y es múltiplo de 100 pero no múltiplo de 400, entonces 365 días;

-
si Y es múltiplo de 400, entonces 366 días.

Entrada

La entrada se da desde Entrada estándar en el siguiente formato:
Y

Salida

Imprime el número de días del año Y como un número entero.

Restricciones

- Y es un número entero entre 1583 y 2023, ambos inclusive.

Ejemplo Entrada 1

2023

Ejemplo de salida 1

365

2023 no es múltiplo de 4, por lo que tiene 365 días.

Entrada de muestra 2

1992

Muestra de salida 2

366

1992 es múltiplo de 4 pero no de 100, por lo que tiene 366 días.

Entrada de muestra 3

1800

Muestra de salida 3

365

1800 es múltiplo de 100 pero no de 400, por lo que tiene 365 días.

Entrada de muestra 4

1600

Muestra de salida 4

366

1600 es múltiplo de 400, por lo que tiene 366 días.


Dada una secuencia de enteros A=(A_1,\ldots,A_N) de longitud N. Encuentra el valor de la siguiente expresión:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N (A_i \oplus A_{i+1}\oplus \ldots \oplus A_j).

Notas sobre XOR bit a bit
El XOR bit a bit de enteros no negativos A y B, denotado como A \oplus B, se define de la siguiente manera:
- En la representación binaria de A \oplus B, el dígito en la posición 2^k (k \geq 0) es 1 si y solo si exactamente uno de los dígitos en la posición 2^k en las representaciones binarias de A y B es 1; de lo contrario, es 0.
Por ejemplo, 3 \oplus 5 = 6 (en binario: 011 \oplus 101 = 110).
En general, el XOR bit a bit de k enteros p_1, \dots, p_k se define como (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k). Se puede demostrar que esto es independiente del orden de p_1, \dots, p_k.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N
A_1 A_2 \ldots A_{N}

Salida

Imprime la respuesta.

Restricciones

2 \leq N \leq 2 \times 10^5
1 \leq A_i \leq 10^8
Todos los valores de entrada son enteros.

Entrada de Ejemplo 1

3
1 3 2

Salida de Ejemplo 1

3

A_1 \oplus A_2 = 2, A_1 \oplus A_2 \oplus A_3 = 0, y A_2 \oplus A_3 = 1, así que la respuesta es 2 + 0 + 1 = 3.

Entrada de Ejemplo 2

7
2 5 6 5 2 1 7

Salida de Ejemplo 2

83

Se le proporciona una secuencia de números enteros A=(A_1,\ldots,A_N) de longitud N. Encuentre el valor de la siguiente expresión:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N (A_i \oplus A_{i+1}\oplus \ldots \oplus A_j).

Notas sobre la operación XOR bit a bit
La operación XOR bit a bit de los números enteros no negativos A y B, denotados como A \oplus B, se define de la siguiente manera:
- En la representación binaria de A \oplus B, el dígito en la posición 2^k (k \geq 0) es 1 si y solo si exactamente uno de los dígitos en la posición 2^k en las representaciones binarias de A y B es 1; de lo contrario, es 0.
Por ejemplo, 3 \oplus 5 = 6 (en binario: 011 \oplus 101 = 110).
En general, la operación XOR bit a bit de k enteros p_1, \dots, p_k se define como (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k). Se puede demostrar que esto es independiente del orden de p_1, \dots, p_k.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N
A_1 A_2 \ldots A_{N}

Salida

Imprima la respuesta.

Restricciones

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i \leq 10^8
- Todos los valores de entrada son enteros.

Entrada de muestra 1

3
1 3 2

Salida de muestra 1

3

A_1 \oplus A_2 = 2, A_1 \oplus A_2 \oplus A_3 = 0 y A_2 \oplus A_3 = 1, por lo que la respuesta es 2 + 0 + 1 = 3.

Entrada de muestra 2

7
2 5 6 5 2 1 7

Salida de muestra 2

83


Takahashi y Aoki jugaron piedra, papel y tijera N veces. [Nota: En este juego, piedra le gana a tijera, tijera le gana a papel y papel le gana a piedra.]
Los movimientos de Aoki están representados por una cadena S de longitud N que consta de los caracteres R, P y S.
El i-ésimo carácter de S indica el movimiento de Aoki en el i-ésimo juego: R para piedra, P para papel y S para tijera.
Los movimientos de Takahashi satisfacen las siguientes condiciones:

- Takahashi nunca perdió contra Aoki.
- Para i=1,2,\ldots,N-1, el movimiento de Takahashi en el i-ésimo juego es diferente de su movimiento en el (i+1)-ésimo juego.

Determine el número máximo de juegos que Takahashi podría haber ganado.
Se garantiza que existe una secuencia de movimientos de Takahashi que satisface estas condiciones.

Entrada

La entrada se proporciona desde la Entrada estándar en el siguiente formato:
N
S

Salida

Imprima el número máximo de juegos que Takahashi podría haber ganado.

Restricciones

- 1\leq N\leq2\times10 ^ 5
- S es una cadena de longitud N que consta de R, P y S.
- N es un entero.

Entrada de muestra 1

6
PRSSRS

Salida de muestra 1

5

En los seis juegos de piedra, papel y tijera, Aoki jugó Papel, Piedra, Tijera, Tijera, Piedra y Tijera.
Takahashi puede jugar Tijera, Papel, Piedra, Tijera, Papel y Piedra para ganar el 1.º, 2.º, 3.º, 5.º y 6.º juego.
No existe una secuencia de movimientos para Takahashi que satisfaga las condiciones y gane los seis juegos, por lo que se imprime 5.

Entrada de muestra 2

10
SSSSSSSSSS

Salida de muestra 2

5

Entrada de muestra 3

24
SPRPSRRRRRPPRPRPSSRSPRSS

Salida de muestra 3

18

Takahashi y Aoki jugaron piedra-papel-tijeras N veces. [Nota: En este juego, Piedra gana a Tijeras, Tijeras gana a Papel, y Papel gana a Piedra.]
Los movimientos de Aoki están representados por una cadena S de longitud N que consiste en los caracteres R, P, y S.
El i-ésimo carácter de S indica el movimiento de Aoki en el i-ésimo juego: R para Piedra, P para Papel, y S para Tijeras.
Los movimientos de Takahashi cumplen las siguientes condiciones:

- Takahashi nunca perdió contra Aoki.
- Para i=1,2,\ldots,N-1, el movimiento de Takahashi en el i-ésimo juego es diferente de su movimiento en el (i+1)-ésimo juego.

Determina el número máximo de juegos que Takahashi podría haber ganado.
Está garantizado que existe una secuencia de movimientos para Takahashi que satisface estas condiciones.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N
S

Salida

Imprime el número máximo de juegos que Takahashi podría haber ganado.

Restricciones

- 1\leq N\leq2\times10 ^ 5
- S es una cadena de longitud N que consiste en R, P, y S.
- N es un entero.

Entrada de muestra 1

6
PRSSRS

Salida de muestra 1

5

En los seis juegos de piedra-papel-tijeras, Aoki jugó Papel, Piedra, Tijeras, Tijeras, Piedra y Tijeras.
Takahashi puede jugar Tijeras, Papel, Piedra, Tijeras, Papel y Piedra para ganar el 1°, 2°, 3°, 5° y 6° juegos.
No hay una secuencia de movimientos para Takahashi que satisfaga las condiciones y gane los seis juegos, así que imprime 5.

Entrada de muestra 2

10
SSSSSSSSSS

Salida de muestra 2

5

Entrada de muestra 3

24
SPRPSRRRRRPPRPRPSSRSPRSS

Salida de muestra 3

18


Hay N personas participando en un evento, y el costo de transporte para la i-ésima persona es A_i yenes.
Takahashi, el organizador del evento, decidió establecer un límite máximo x para el subsidio de transporte. El subsidio para la persona i será \min(x, A_i) yenes. Aquí, x debe ser un entero no negativo.
Dado que el presupuesto de Takahashi es de M yenes, y desea que el subsidio total de transporte para todas las N personas sea como máximo M yenes, ¿cuál es el valor máximo posible del límite del subsidio x?
Si el límite del subsidio puede ser infinitamente grande, informa eso en su lugar.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N M
A_1 A_2 \ldots A_{N}

Salida

Imprime el valor máximo del límite del subsidio x que satisface la condición del presupuesto, como un entero.
Si el límite del subsidio puede ser infinitamente grande, imprime infinito en su lugar.

Restricciones

- 1 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^{14}
- 1 \leq A_i \leq 10^9
- Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

4 8
1 3 2 4

Ejemplo de Salida 1

2

Si el límite del subsidio se establece en 2 yenes, el subsidio total de transporte para todas las N personas es \min(2,1) + \min(2,3) + \min(2,2) + \min(2,4) = 7 yenes, que está dentro del presupuesto de 8 yenes.
Si el límite del subsidio se establece en 3 yenes, el subsidio total de transporte para todas las N personas es \min(3,1) + \min(3,3) + \min(3,2) + \min(3,4) = 9 yenes, que excede el presupuesto de 8 yenes.
Por lo tanto, el valor máximo posible del límite del subsidio es 2 yenes.

Ejemplo de Entrada 2

3 20
5 3 2

Ejemplo de Salida 2

infinito

El límite del subsidio puede ser infinitamente grande.

Ejemplo de Entrada 3

10 23
2 5 6 5 2 1 7 9 7 2

Ejemplo de Salida 3

2

Hay N personas participando en un evento, y el costo de transporte para la i-ésima persona es A_i yenes.
Takahashi, el organizador del evento, decidió establecer un límite máximo x para el subsidio de transporte. El subsidio para la persona i será \min(x, A_i) yenes. Aquí, x debe ser un entero no negativo.
Dado que el presupuesto de Takahashi es de M yenes, y desea que el subsidio total de transporte para todas las N personas sea como máximo M yenes, ¿cuál es el máximo valor posible del límite del subsidio x?
Si el límite del subsidio puede ser infinitamente grande, informa eso en su lugar.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N M
A_1 A_2 \ldots A_{N}

Salida

Muestra el valor máximo del límite del subsidio x, que satisface la condición del presupuesto, como un entero.
Si el límite del subsidio puede ser infinitamente grande, muestra infinito en su lugar.

Restricciones

- 1 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^{14}
- 1 \leq A_i \leq 10^9
- Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

4 8
1 3 2 4

Ejemplo de Salida 1

2

Si el límite del subsidio se establece en 2 yenes, el subsidio total de transporte para todas las N personas es \min(2,1) + \min(2,3) + \min(2,2) + \min(2,4) = 7 yenes, y está dentro del presupuesto de 8 yenes.
Si el límite del subsidio se establece en 3 yenes, el subsidio total de transporte para todas las N personas es \min(3,1) + \min(3,3) + \min(3,2) + \min(3,4) = 9 yenes, y excede el presupuesto de 8 yenes.
Por lo tanto, el máximo valor posible del límite del subsidio es 2 yenes.

Ejemplo de Entrada 2

3 20
5 3 2

Ejemplo de Salida 2

infinito

El límite del subsidio puede ser infinitamente grande.

Ejemplo de Entrada 3

10 23
2 5 6 5 2 1 7 9 7 2

Ejemplo de Salida 3

2

Hay N personas que participan en un evento y el costo de transporte para la i-ésima persona es A_i yenes.
Takahashi, el organizador del evento, decidió establecer un límite máximo x para el subsidio de transporte. El subsidio para la persona i será \min(x, A_i) yenes. Aquí, x debe ser un entero no negativo.
Dado que el presupuesto de Takahashi es M yenes y quiere que el subsidio de transporte total para todas las N personas sea como máximo M yenes, ¿cuál es el valor máximo posible del límite de subsidio x?
Si el límite de subsidio puede hacerse infinitamente grande, informe eso en su lugar.

Entrada

La entrada se proporciona desde la Entrada estándar en el siguiente formato:
N M
A_1 A_2 \ldots A_{N}

Salida

Imprima el valor máximo del límite de subsidio x que satisface la condición de presupuesto, como un entero.
Si el límite de subsidio puede hacerse infinitamente grande, imprima infinito en su lugar.

Restricciones

- 1 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^{14}
- 1 \leq A_i \leq 10^9
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

4 8
1 3 2 4

Salida de muestra 1

2

Si el límite del subsidio se establece en 2 yenes, el subsidio total para el transporte para todas las N personas es \min(2,1) + \min(2,3) + \min(2,2) + \min(2,4) = 7 yenes, que está dentro del presupuesto de 8 yenes.
Si el límite del subsidio se establece en 3 yenes, el subsidio total para el transporte para todas las N personas es \min(3,1) + \min(3,3) + \min(3,2) + \min(3,4) = 9 yenes, lo que excede el presupuesto de 8 yenes.
Por lo tanto, el valor máximo posible del límite del subsidio es 2 yenes.

Entrada de muestra 2

3 20
5 3 2

Salida de muestra 2

infinito

El límite del subsidio puede hacerse infinitamente grande.

Entrada de muestra 3

10 23
2 5 6 5 2 1 7 9 7 2

Salida de muestra 3

2


Se te da una cadena s. Simula eventos en cada segundo i:

Si s[i] == 'E', una persona entra en la sala de espera y ocupa una de las sillas en ella.
Si s[i] == 'L', una persona sale de la sala de espera, liberando una silla.

Devuelve el número mínimo de sillas necesarias para que haya una silla disponible para cada persona que entra en la sala de espera, dado que inicialmente está vacía.

Ejemplo 1:

Entrada: s = "EEEEEEE"
Salida: 7
Explicación:
Después de cada segundo, una persona entra en la sala de espera y nadie sale de ella. Por lo tanto, se necesitan un mínimo de 7 sillas.

Ejemplo 2:

Entrada: s = "ELELEEL"
Salida: 2
Explicación:
Consideremos que hay 2 sillas en la sala de espera. La tabla a continuación muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la Sala de Espera
Sillas Disponibles

0
Entrada
1
1

1
Salida
0
2

2
Entrada
1
1

3
Salida
0
2

4
Entrada
1
1

5
Entrada
2
0

6
Salida
1
1

Ejemplo 3:

Entrada: s = "ELEELEELLL"
Salida: 3
Explicación:
Consideremos que hay 3 sillas en la sala de espera. La tabla a continuación muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la Sala de Espera
Sillas Disponibles

0
Entrada
1
2

1
Salida
0
3

2
Entrada
1
2

3
Entrada
2
1

4
Salida
1
2

5
Entrada
2
1

6
Entrada
3
0

7
Salida
2
1

8
Salida
1
2

9
Salida
0
3

Restricciones:

1 <= s.length <= 50
s consiste solo en las letras 'E' y 'L'.
s representa una secuencia válida de entradas y salidas.

Se le proporciona una cadena s. Simule eventos en cada segundo i:

Si s[i] == 'E', una persona ingresa a la sala de espera y toma una de las sillas que hay en ella.
Si s[i] == 'L', una persona abandona la sala de espera, liberando una silla.

Devuelva la cantidad mínima de sillas necesarias para que haya una silla disponible para cada persona que ingrese a la sala de espera, dado que inicialmente está vacía.

Ejemplo 1:

Entrada: s = "EEEEEEE"
Salida: 7
Explicación:
Después de cada segundo, una persona ingresa a la sala de espera y ninguna la abandona. Por lo tanto, se necesita un mínimo de 7 sillas.

Ejemplo 2:

Entrada: s = "ELELEEL"
Salida: 2
Explicación:
Consideremos que hay 2 sillas en la sala de espera. La siguiente tabla muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la sala de espera
Sillas disponibles

0
Entrar
1
1

1
Salir
0
2

2
Entrar
1
1

3
Salir
0
2

4
Entrar
1
1

5
Entrar
2
0

6
Salir
1
1

Ejemplo 3:

Entrada: s = "ELEELEELLL"
Salida: 3
Explicación:
Consideremos que hay 3 sillas en la sala de espera. La siguiente tabla muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la sala de espera
Sillas disponibles

0
Entrar
1
2

1
Salir
0
3

2
Entrar
1
2

3
Entrar
2
1

4
Salir
1
2

5
Entrar
2
1

6
Entrar
3
0

7
Salir
2
1

8
Salir
1
2

9
Salir
0
3

Restricciones:

1 <= s.length <= 50
s consta únicamente de las letras 'E' y 'L'.
s representa una secuencia válida de entradas y salidas.

Se le da una cadena s. Simule los acontecimientos en cada segundo i:

Si s[i] == 'E', una persona entra en la sala de espera y ocupa una de las sillas que hay en ella.
Si s[i] == 'L', una persona abandona la sala de espera, liberando una silla.

Devuelve el número mínimo de sillas necesarias para que haya una silla disponible para cada persona que Entre la sala de espera dado que inicialmente está vacía.

Ejemplo 1

Entrada: s = "EEEEEEE"
Salida: 7
Explicación:
Cada segundo entra una persona en la sala de espera y no sale ninguna. Por lo tanto, se necesita un mínimo de 7 sillas.

Ejemplo 2:

Entrada: s = "ELELEEL"
Salida: 2
Explicación:
Consideremos que hay 2 sillas en la sala de espera. La siguiente tabla muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la sala de espera
Sillas disponibles

0
Entre
1
1

1
Deje
0
2

2
Entre
1
1

3
Deje
0
2

4
Entrar en
1
1

5
Entra
2
0

6
Deje
1
1

Ejemplo 3:

Entrada: s = "ELEELEELLL"
Salida: 3
Explicación:
Consideremos que hay 3 sillas en la sala de espera. La siguiente tabla muestra el estado de la sala de espera en cada segundo.

Segundo
Evento
Personas en la sala de espera
Sillas disponibles

0
Entre
1
2

1
Deje
0
3

2
Entre
1
2

3
Entra
2
1

4
Deje
1
2

5
Entre
2
1

6
Entra
3
0

7
Deje
2
1

8
Deje
1
2

9
Deje
0
3

Restricciones:

1 <= s.length <= 50
s consta sólo de las letras 'E' y 'L'.
s representa una secuencia válida de entradas y salidas.


Se te da un entero positivo days que representa el número total de días que un empleado está disponible para trabajar (comenzando desde el día 1). También se te da un array 2D meetings de tamaño n donde, meetings[i] = [start_i, end_i] representa los días de inicio y fin de la reunión i (inclusive).
Devuelve el conteo de días en que el empleado está disponible para trabajar pero no hay reuniones programadas.
Nota: Las reuniones pueden superponerse.

Ejemplo 1:

Entrada: days = 10, meetings = [[5,7],[1,3],[9,10]]
Salida: 2
Explicación:
No hay reunión programada en los días 4 y 8.

Ejemplo 2:

Entrada: days = 5, meetings = [[2,4],[1,3]]
Salida: 1
Explicación:
No hay reunión programada en el día 5.

Ejemplo 3:

Entrada: days = 6, meetings = [[1,6]]
Salida: 0
Explicación:
Las reuniones están programadas para todos los días laborales.

Restricciones:

1 <= days <= 10^9
1 <= meetings.length <= 10^5
meetings[i].length == 2
1 <= meetings[i][0] <= meetings[i][1] <= days

Se te da un entero positivo dias que representa el número total de días que un empleado está disponible para trabajar (comenzando desde el día 1). También se te da un array 2D reuniones de tamaño n donde, reuniones[i] = [start_i, end_i] representa los días de inicio y fin de la reunión i (inclusive).
Devuelve el conteo de días en que el empleado está disponible para trabajar pero no hay reuniones programadas.
Nota: Las reuniones pueden superponerse.

Ejemplo 1:

Entrada: dias = 10, reuniones = [[5,7],[1,3],[9,10]]
Salida: 2
Explicación:
No hay reunión programada en los días 4 y 8.

Ejemplo 2:

Entrada: dias = 5, reuniones = [[2,4],[1,3]]
Salida: 1
Explicación:
No hay reunión programada en el día 5.

Ejemplo 3:

Entrada: dias = 6, reuniones = [[1,6]]
Salida: 0
Explicación:
Las reuniones están programadas para todos los días laborales.

Restricciones:

1 <= dias <= 10^9
1 <= reuniones.length <= 10^5
reuniones[i].length == 2
1 <= reuniones[i][0] <= reuniones[i][1] <= dias

Se le da un entero positivo días que representa el número total de días que un empleado está disponible para trabajar (empezando por el día 1). También se le da una matriz 2D reuniones de tamaño n donde, reuniones[i] = [inicio_i, fin_i] representa los días de inicio y fin de la reunión i (inclusive).
Devuelve el recuento de días en los que el empleado está disponible para trabajar pero no hay reuniones programadas.
Nota: Las reuniones pueden solaparse.

Ejemplo 1

Entrada: días = 10, reuniones = [[5,7],[1,3],[9,10]]
Salida: 2
Explicación:
No hay ninguna reunión programada en los días 4^ y 8^.

Ejemplo 2:

Entrada: días = 5, reuniones = [[2,4],[1,3]]
Salida: 1
Explicación:
No hay ninguna reunión programada para el día 5^.

Ejemplo 3:

Entrada: días = 6, reuniones = [[1,6]]
Salida: 0
Explicación:
Las reuniones se programan para todos los días laborables.

Restricciones:

1 <= days <= 10^9
1 <= meetings.length <= 10^5
meetings[i].length == 2
1 <= meetings[i][0] <= meetings[i][1] <= days


Se te da un array nums y un entero k. Necesitas encontrar un subarray de nums tal que la diferencia absoluta entre k y el OR bit a bit de los elementos del subarray sea lo más pequeña posible. En otras palabras, selecciona un subarray nums[l..r] tal que |k - (nums[l] OR nums[l + 1] ... OR nums[r])| sea mínimo.
Devuelve el valor mínimo posible de la diferencia absoluta.
Un subarray es una secuencia continua no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [1,2,4,5], k = 3
Salida: 0
Explicación:
El subarray nums[0..1] tiene valor de OR 3, que da la diferencia absoluta mínima |3 - 3| = 0.

Ejemplo 2:

Entrada: nums = [1,3,1,3], k = 2
Salida: 1
Explicación:
El subarray nums[1..1] tiene valor de OR 3, que da la diferencia absoluta mínima |3 - 2| = 1.

Ejemplo 3:

Entrada: nums = [1], k = 10
Salida: 9
Explicación:
Hay un solo subarray con valor de OR 1, que da la diferencia absoluta mínima |10 - 1| = 9.

Condiciones:

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

Se le proporciona una matriz nums y un entero k. Debe encontrar una submatriz de nums de modo que la diferencia absoluta entre k y el OR bit a bit de los elementos de la submatriz sea lo más pequeña posible. En otras palabras, seleccione una submatriz nums[l..r] de modo que |k - (nums[l] OR nums[l + 1] ... OR nums[r])| sea mínima.
Devuelve el valor mínimo posible de la diferencia absoluta.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,2,4,5], k = 3
Salida: 0
Explicación:
La submatriz nums[0..1] tiene un valor OR de 3, lo que da como resultado la diferencia absoluta mínima |3 - 3| = 0.

Ejemplo 2:

Entrada: nums = [1,3,1,3], k = 2
Salida: 1
Explicación:
El subarreglo nums[1..1] tiene un valor OR de 3, lo que da como resultado la diferencia absoluta mínima |3 - 2| = 1.

Ejemplo 3:

Entrada: nums = [1], k = 10
Salida: 9
Explicación:
Hay un único subarreglo con un valor OR de 1, lo que da como resultado la diferencia absoluta mínima |10 - 1| = 9.

Restricciones:

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


Se dan dos números enteros positivos n y k. Hay n niños numerados de 0 a n - 1 colocados en una cola en orden de izquierda a derecha.
Inicialmente, el niño 0 sostiene una pelota y la dirección de paso de la pelota es hacia la derecha. Cada segundo, el niño que tiene la pelota se la pasa al niño de al lado. Una vez que la pelota llega a cualquiera de los extremos de la línea, es decir, al niño 0 o al niño n - 1, se invierte la dirección del pase.
Devuelve el número del niño que recibe la pelota después de k segundos.

Ejemplo 1

Entrada: n = 3, k = 5
Salida: 1
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Ejemplo 2:

Entrada: n = 5, k = 6
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Ejemplo 3:

Entrada: n = 4, k = 2
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Restricciones:

2 <= n <= 50
1 <= k <= 50

Se te dan dos números enteros positivos n y k. Hay n niños numerados del 0 al n - 1 en una fila de izquierda a derecha. Inicialmente, el niño 0 tiene una pelota y la pelota se pasa hacia la derecha. Después de cada segundo, el niño que sostiene la pelota se la pasa al niño a su lado. Si la pelota llega a cualquiera de los extremos de la fila, es decir, al niño 0 o al niño n - 1, la pelota se pasa en sentido contrario. Devuelve el número del niño que recibe la pelota después de k segundos.

Ejemplo 1:

Entrada: n = 3, k = 5
Salida: 1
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Ejemplo 2:

Entrada: n = 5, k = 6
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Ejemplo 3:

Entrada: n = 4, k = 2
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Restricciones:

2 <= n <= 50
1 <= k <= 50

Se te dan dos enteros positivos n y k. Hay n niños numerados del 0 al n - 1 en una fila de izquierda a derecha.
Inicialmente, el niño 0 tiene una pelota y la dirección de pasarla es hacia la derecha. Después de cada segundo, el niño que sostiene la pelota se la pasa al niño a su lado. Una vez que la pelota llega a cualquiera de los extremos de la fila, es decir, al niño 0 o al niño n - 1, la dirección de pasar se invierte.
Devuelve el número del niño que recibe la pelota después de k segundos.

Ejemplo 1:

Entrada: n = 3, k = 5
Salida: 1
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Ejemplo 2:

Entrada: n = 5, k = 6
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Ejemplo 3:

Entrada: n = 4, k = 2
Salida: 2
Explicación:

Tiempo transcurrido
Niños

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Restricciones:

2 <= n <= 50
1 <= k <= 50


Se te dan dos enteros n y k.
Inicialmente, comienzas con un arreglo a de n enteros donde a[i] = 1 para todo 0 <= i <= n - 1. Después de cada segundo, actualizas simultáneamente cada elemento para que sea la suma de todos sus elementos precedentes más el elemento mismo. Por ejemplo, después de un segundo, a[0] permanece igual, a[1] se convierte en a[0] + a[1], a[2] se convierte en a[0] + a[1] + a[2], y así sucesivamente.
Devuelve el valor de a[n - 1] después de k segundos.
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 4, k = 5
Salida: 56
Explicación:

Segundo
Estado Después

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Ejemplo 2:

Entrada: n = 5, k = 3
Salida: 35
Explicación:

Segundo
Estado Después

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Restricciones:

1 <= n, k <= 1000

Se te dan dos enteros n y k.
Inicialmente, comienzas con un array a de n enteros donde a[i] = 1 para todo 0 <= i <= n - 1. Después de cada segundo, actualizas simultáneamente cada elemento para que sea la suma de todos sus elementos precedentes más el elemento mismo. Por ejemplo, después de un segundo, a[0] permanece igual, a[1] se convierte en a[0] + a[1], a[2] se convierte en a[0] + a[1] + a[2], y así sucesivamente.
Devuelve el valor de a[n - 1] después de k segundos.
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 4, k = 5
Salida: 56
Explicación:

Segundos
Estado Después

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Ejemplo 2:

Entrada: n = 5, k = 3
Salida: 35
Explicación:

Segundos
Estado Después

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Condiciones:

1 <= n, k <= 1000

Se dan dos números enteros n y k.
Inicialmente, empiezas con una matriz a de n enteros donde a[i] = 1 para todos los 0 <= i <= n - 1. Después de cada segundo, actualizas simultáneamente cada elemento para que sea la suma de todos sus elementos precedentes más el propio elemento. Por ejemplo, después de un segundo, a[0] permanece igual, a[1] se convierte en a[0] + a[1], a[2] se convierte en a[0] + a[1] + a[2], y así sucesivamente.
Devuelve el valor de a[n - 1] al cabo de k segundos.
Como la respuesta puede ser muy grande, devuélvela en módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 4, k = 5
Salida: 56
Explicación:

Segundo
Estado Después de

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Ejemplo 2:

Entrada: n = 5, k = 3
Salida 35
Explicación:

Segundo
Estado Después de

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Restricciones:

1 <= n, k <= 1000


Se te da un arreglo de enteros rewardValues de longitud n, que representan los valores de las recompensas.
Inicialmente, tu recompensa total x es 0, y todos los índices no están marcados. Se te permite realizar la siguiente operación cualquier cantidad de veces:

Elige un índice no marcado i del rango [0, n - 1].
Si rewardValues[i] es mayor que tu recompensa total actual x, entonces añade rewardValues[i] a x (es decir, x = x + rewardValues[i]), y marca el índice i.

Devuelve un entero que denote la recompensa total máxima que puedes recolectar realizando las operaciones de manera óptima.

Ejemplo 1:

Entrada: rewardValues = [1,1,3,3]
Salida: 4
Explicación:
Durante las operaciones, podemos elegir marcar los índices 0 y 2 en orden, y la recompensa total será 4, que es el máximo.

Ejemplo 2:

Entrada: rewardValues = [1,6,4,3,2]
Salida: 11
Explicación:
Marca los índices 0, 2 y 1 en orden. La recompensa total será entonces 11, que es el máximo.

Restricciones:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000

Se te da un array de enteros rewardValues de longitud n, que representan los valores de las recompensas.
Inicialmente, tu recompensa total x es 0, y todos los índices no están marcados. Se te permite realizar la siguiente operación cualquier cantidad de veces:

Elige un índice no marcado i del rango [0, n - 1].
Si rewardValues[i] es mayor que tu recompensa total actual x, entonces añade rewardValues[i] a x (es decir, x = x + rewardValues[i]), y marca el índice i.

Devuelve un entero que denote la recompensa total máxima que puedes recolectar realizando las operaciones de manera óptima.

Ejemplo 1:

Entrada: rewardValues = [1,1,3,3]
Salida: 4
Explicación:
Durante las operaciones, podemos elegir marcar los índices 0 y 2 en orden, y la recompensa total será 4, que es el máximo.

Ejemplo 2:

Entrada: rewardValues = [1,6,4,3,2]
Salida: 11
Explicación:
Marca los índices 0, 2 y 1 en orden. La recompensa total será entonces 11, que es el máximo.

Restricciones:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000

Se le da un array entero rewardValues de longitud n, que representa los valores de las recompensas.
Inicialmente, su recompensa total x es 0, y todos los índices están sin marcar. Puede realizar la siguiente operación tantas veces como desee:

Elija un índice no marcado i del intervalo [0, n - 1].
Si rewardValues[i] es mayor que su recompensa total actual x, entonces añada rewardValues[i] a x (es decir, x = x + rewardValues[i]), y marque el índice i.

Devuelve un número entero que denota la recompensa total máxima que puede obtener realizando las operaciones de forma óptima.

Ejemplo 1:

Entrada: rewardValues = [1,1,3,3]
Salida: 4
Explicación:
Durante las operaciones, podemos elegir marcar los índices 0 y 2 en orden, y la recompensa total será 4, que es el máximo.

Ejemplo 2:

Entrada: rewardValues = [1,6,4,3,2]
Salida: 11
Explicación:
Marca los índices 0, 2 y 1 en orden. La recompensa total será entonces 11, que es el máximo.

Restricciones:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000


Dado un array de enteros `hours` que representa tiempos en horas, devuelve un entero que indica el número de pares \(i, j\) donde \(i < j\) y `hours[i]` + `hours[j]` forman un día completo.
Un día completo se define como una duración de tiempo que es un múltiplo exacto de 24 horas.
Por ejemplo, 1 día son 24 horas, 2 días son 48 horas, 3 días son 72 horas, y así sucesivamente.

Ejemplo 1:

Entrada: hours = [12,12,30,24,24]
Salida: 2
Explicación:
Los pares de índices que forman un día completo son (0, 1) y (3, 4).

Ejemplo 2:

Entrada: hours = [72,48,24,3]
Salida: 3
Explicación:
Los pares de índices que forman un día completo son (0, 1), (0, 2), y (1, 2).

Restricciones:

1 <= hours.length <= 100
1 <= hours[i] <= 10^9

Dada una matriz de enteros `hours` que representa tiempos en horas, devuelve un entero que indica el número de pares \(i, j\) donde \(i < j\) y `hours[i]` + `hours[j]` forman un día completo. Un día completo se define como una duración de tiempo que es un múltiplo exacto de 24 horas. Por ejemplo, 1 día son 24 horas, 2 días son 48 horas, 3 días son 72 horas, y así sucesivamente.

Ejemplo 1:

Input: hours = [12,12,30,24,24]
Output: 2
Explicación:
Los pares de índices que forman un día completo son (0, 1) y (3, 4).

Ejemplo 2:

Input: hours = [72,48,24,3]
Output: 3
Explicación:
Los pares de índices que forman un día completo son (0, 1), (0, 2), y (1, 2).

Restricciones:

1 <= hours.length <= 100
1 <= hours[i] <= 10^9

Dada una matriz de enteros hours que representa tiempos en horas, devuelve un entero que denota el número de pares i, j en los que i < j y hours[i] + hours[j] forman un día completo.
Un día completo se define como una duración de tiempo que es múltiplo exacto de 24 horas.
Por ejemplo, 1 día son 24 horas, 2 días son 48 horas, 3 días son 72 horas, etc.

Ejemplo 1

Entrada: hours = [12,12,30,24,24]
Salida: 2
Explicación:
Los pares de índices que forman un día completo son (0, 1) y (3, 4).

Ejemplo 2:

Entrada: hours = [72,48,24,3]
Salida: 3
Explicación:
Los pares de índices que forman un día completo son (0, 1), (0, 2) y (1, 2).

Restricciones:

1 <= hours.length <= 100
1 <= hours[i] <= 10^9


Un mago tiene varios hechizos.
Se le otorga una matriz de power, donde cada elemento representa el daño de un hechizo. Múltiples hechizos pueden tener el mismo valor de daño.
Es un hecho conocido que si un mago decide lanzar un hechizo con un daño de power[i], no puede lanzar ningún hechizo con un daño de power[i] - 2, power[i] - 1, power[i] + 1, o power[i] + 2.
Cada hechizo puede lanzarse solo una vez.
Devuelve el daño total máximo posible que un mago puede lanzar.

Ejemplo 1:

Entrada: power = [1,1,3,4]
Salida: 6
Explicación:
El daño máximo posible de 6 se produce al lanzar los hechizos 0, 1, 3 con daño 1, 1, 4.

Ejemplo 2:

Entrada: power = [7,1,6,6]
Salida: 13
Explicación:
El daño máximo posible de 13 se produce al lanzar los hechizos 1, 2, 3 con daño 1, 6, 6.

Restricciones:

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

Un mago tiene varios hechizos.
Se le da un poder de matriz, donde cada elemento representa el daño de un hechizo. Varios hechizos pueden tener el mismo valor de daño.
Es un hecho conocido que si un mago decide lanzar un hechizo con un daño de poder[i], no podrá lanzar ningún hechizo con un daño de poder[i] - 2, poder[i] - 1, poder[i] + 1, o poder[i] + 2.
Cada hechizo sólo puede lanzarse una vez.
Devuelve el máximo daño total posible que puede lanzar un mago.

Ejemplo 1:

Entrada: power = [1,1,3,4]
Salida: 6
Explicación:
El máximo daño posible de 6 se produce lanzando hechizos 0, 1, 3 con daño 1, 1, 4.

Ejemplo 2:

Entrada: power = [7,1,6,6]
Salida: 13
Explicación:
El máximo daño posible de 13 se produce lanzando los hechizos 1, 2, 3 con daño 1, 6, 6.

Restricciones:

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

Un mago tiene varios hechizos.
Se te da un arreglo power, donde cada elemento representa el daño de un hechizo. Varios hechizos pueden tener el mismo valor de daño.
Es un hecho conocido que si un mago decide lanzar un hechizo con un daño de power[i], no puede lanzar ningún hechizo con un daño de power[i] - 2, power[i] - 1, power[i] + 1, o power[i] + 2.
Cada hechizo se puede lanzar solo una vez.
Devuelve el daño total máximo posible que un mago puede lanzar.

Ejemplo 1:

Entrada: power = [1,1,3,4]
Salida: 6
Explicación:
El daño máximo posible de 6 se produce lanzando los hechizos 0, 1, 3 con daño 1, 1, 4.

Ejemplo 2:

Entrada: power = [7,1,6,6]
Salida: 13
Explicación:
El daño máximo posible de 13 se produce lanzando los hechizos 1, 2, 3 con daño 1, 6, 6.

Restricciones:

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


Un pico en un array `arr` es un elemento que es mayor que su elemento anterior y siguiente en `arr`.
Se te da un array de enteros `nums` y un array 2D de enteros `queries`.
Tienes que procesar consultas de dos tipos:

`queries[i] = [1, l_i, r_i]`, determina el conteo de elementos pico en el subarray `nums[l_i..r_i]`.
`queries[i] = [2, index_i, val_i]`, cambia `nums[index_i]` a `val_i`.

Devuelve un array `answer` que contiene los resultados de las consultas del primer tipo en orden.
Notas:

El primer y el último elemento de un array o subarray no pueden ser un pico.

Ejemplo 1:

Entrada: `nums = [3,1,4,2,5]`, `queries = [[2,3,4],[1,0,4]]`
Salida: `[0]`
Explicación:
Primera consulta: Cambiamos `nums[3]` a 4 y `nums` se convierte en `[3,1,4,4,5]`.
Segunda consulta: El número de picos en `[3,1,4,4,5]` es 0.

Ejemplo 2:

Entrada: `nums = [4,1,4,2,1,5]`, `queries = [[2,2,4],[1,0,2],[1,0,4]]`
Salida: `[0,1]`
Explicación:
Primera consulta: `nums[2]` debería convertirse en 4, pero ya está establecido a 4.
Segunda consulta: El número de picos en `[4,1,4]` es 0.
Tercera consulta: El segundo 4 es un pico en `[4,1,4,2,1]`.

Restricciones:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 o queries[i][0] == 2
Para todo i tal que:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Un pico en un conjunto arr es un elemento que es mayor que su elemento anterior y siguiente en arr.
Se te da un conjunto de enteros nums y un conjunto 2D de enteros queries.
Tienes que procesar consultas de dos tipos:

queries[i] = [1, l_i, r_i], determina la cantidad de elementos pico en el subconjunto nums[l_i..r_i].
queries[i] = [2, index_i, val_i], cambia nums[index_i] a val_i.

Devuelve un conjunto answer que contiene los resultados de las consultas del primer tipo en orden.
Notas:

El primer y el último elemento de un conjunto o subconjunto no pueden ser un pico.

Ejemplo 1:

Entrada: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Salida: [0]
Explicación:
Primera consulta: Cambiamos nums[3] a 4 y nums se convierte en [3,1,4,4,5].
Segunda consulta: El número de picos en [3,1,4,4,5] es 0.

Ejemplo 2:

Entrada: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Salida: [0,1]
Explicación:
Primera consulta: nums[2] debería convertirse en 4, pero ya está establecido a 4.
Segunda consulta: El número de picos en [4,1,4] es 0.
Tercera consulta: El segundo 4 es un pico en [4,1,4,2,1].

Restricciones:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 o queries[i][0] == 2
Para todo i tal que:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Un pico en una matriz arr es un elemento que es mayor que su elemento anterior y siguiente en arr.
Se le proporciona una matriz de enteros nums y una matriz de enteros 2D consultas.
Tiene que procesar consultas de dos tipos:

consultas[i] = [1, l_i, r_i], determinan el recuento de elementos máximos en la submatriz nums[l_i.. r_i].
consultas[i] = [2, index_i, val_i], cambie nums[index_i] a val_i.

Devuelve una respuesta de matriz que contiene los resultados de las consultas del primer tipo en orden.
Notas:

El primer y el último elemento de una matriz o una submatriz no pueden ser un pico.

Ejemplo 1:

Entrada: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Salida: [0]
Explicación:
Primera consulta: Cambiamos nums[3] a 4 y nums se convierte en [3,1,4,4,5].
Segunda consulta: El número de picos en [3,1,4,4,5] es 0.

Ejemplo 2:

Entrada: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Salida: [0,1]
Explicación:
Primera consulta: nums[2] debería convertirse en 4, pero ya está establecido en 4.
Segunda consulta: El número de picos en [4,1,4] es 0.
Tercera consulta: El segundo 4 es un pico en el [4,1,4,2,1].

Restricciones:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 or queries[i][0] == 2
Por todo lo que:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5


Tienes un arreglo de números de punto flotante averages que inicialmente está vacío. Se te da un arreglo nums de n enteros donde n es par.
Repite el siguiente procedimiento n / 2 veces:

Elimina el elemento más pequeño, minElement, y el elemento más grande, maxElement, de nums.
Agrega (minElement + maxElement) / 2 a averages.

Devuelve el elemento mínimo en averages.

Ejemplo 1:

Entrada: nums = [7,8,3,4,15,13,4,1]
Salida: 5.5
Explicación:

| paso | nums              | averages |
|------|-------------------|----------|
| 0    | [7,8,3,4,15,13,4,1] | []       |
| 1    | [7,8,3,4,13,4]   | [8]      |
| 2    | [7,8,4,4]        | [8,8]    |
| 3    | [7,4]            | [8,8,6]  |
| 4    | []               | [8,8,6,5.5] |

El elemento más pequeño de averages, 5.5, es devuelto.

Ejemplo 2:

Entrada: nums = [1,9,8,3,10,5]
Salida: 5.5
Explicación:

| paso | nums          | averages |
|------|---------------|----------|
| 0    | [1,9,8,3,10,5] | []       |
| 1    | [9,8,3,5]    | [5.5]    |
| 2    | [8,5]        | [5.5,6]  |
| 3    | []           | [5.5,6,6.5] |

Ejemplo 3:

Entrada: nums = [1,2,3,7,8,9]
Salida: 5.0
Explicación:

| paso | nums          | averages |
|------|---------------|----------|
| 0    | [1,2,3,7,8,9] | []       |
| 1    | [2,3,7,8]    | [5]      |
| 2    | [3,7]        | [5,5]    |
| 3    | []           | [5,5,5]  |

Condiciones:

2 <= n == nums.length <= 50
n es par.
1 <= nums[i] <= 50

Tienes una matriz de números de punto flotante,averages, que inicialmente está vacía. Te dan una matriz nums de n números enteros, donde n es par.
Repites el siguiente procedimiento n / 2 veces:

Eliminas el elemento más pequeño, minElement, y el elemento más grande, maxElement, de nums.
Agregas (minElement + maxElement) / 2 a averages.

Devuelves el elemento mínimo en averages.

Ejemplo 1:

Entrada: nums = [7,8,3,4,15,13,4,1]
Salida: 5.5
Explicación:

step
nums
averages

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

Se devuelve el elemento más pequeño de los promedios, 5.5.
Ejemplo 2:

Entrada: nums = [1,9,8,3,10,5]
Salida: 5.5
Explicación:

step
nums
averages

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Ejemplo 3:

Entrada: nums = [1,2,3,7,8,9]
Salida: 5.0
Explicación:

step
nums
averages

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Restricciones:

2 <= n == nums.length <= 50
n es par.
1 <= nums[i] <= 50

Tienes una matriz de números de punto flotante, promedios, que inicialmente está vacía. Te dan una matriz nums de n números enteros, donde n es par.
Repites el siguiente procedimiento n / 2 veces:

Eliminas el elemento más pequeño, minElement, y el elemento más grande, maxElement, de nums.
Agregas (minElement + maxElement) / 2 a promedios.

Devuelves el elemento mínimo en promedios.

Ejemplo 1:

Entrada: nums = [7,8,3,4,15,13,4,1]
Salida: 5.5
Explicación:

paso
nums
promedios

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

Se devuelve el elemento más pequeño de los promedios, 5.5.
Ejemplo 2:

Entrada: nums = [1,9,8,3,10,5]
Salida: 5.5
Explicación:

paso
nums
promedios

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Ejemplo 3:

Entrada: nums = [1,2,3,7,8,9]
Salida: 5.0
Explicación:

paso
nums
promedios

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Restricciones:

2 <= n == nums.length <= 50
n es par.
1 <= nums[i] <= 50


Se te da una matriz binaria 2D llamada grid. Encuentra un rectángulo con lados horizontales y verticales con el área más pequeña, de modo que todos los 1's en grid estén dentro de este rectángulo.
Devuelve el área mínima posible del rectángulo.

Ejemplo 1:

Entrada: grid = [[0,1,0],[1,0,1]]
Salida: 6
Explicación:

El rectángulo más pequeño tiene una altura de 2 y un ancho de 3, por lo que tiene un área de 2 * 3 = 6.

Ejemplo 2:

Entrada: grid = [[1,0],[0,0]]
Salida: 1
Explicación:

El rectángulo más pequeño tiene tanto altura como ancho 1, por lo que su área es 1 * 1 = 1.

Restricciones:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] es 0 o 1.
La entrada se genera de tal manera que hay al menos un 1 en grid.

Se te da una cuadrícula de matriz binaria 2D. Encuentra un rectángulo con lados horizontales y verticales con el área más pequeña, de modo que todos los 1's en la cuadrícula estén dentro de este rectángulo.
Devuelve el área mínima posible del rectángulo.

Ejemplo 1:

Input: grid = [[0,1,0],[1,0,1]]
Output: 6
Explicación:

El rectángulo más pequeño tiene una altura de 2 y un ancho de 3, por lo que tiene un área de 2 * 3 = 6.

Ejemplo 2:

Input: grid = [[1,0],[0,0]]
Output: 1
Explicación:

El rectángulo más pequeño tiene tanto altura como ancho 1, por lo que su área es 1 * 1 = 1.

Restricciones:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] es 0 o 1.
La entrada se genera de tal manera que hay al menos un 1 en grid.

Se le da una rejilla de matriz binaria 2D. Encuentre un rectángulo con lados horizontales y verticales con el área más pequeña, de tal manera que todos los 1 en la rejilla se encuentran dentro de este rectángulo.
Devuelve el área mínima posible del rectángulo.

Ejemplo 1:

Entrada: grid = [[0,1,0],[1,0,1]]
Salida: 6
Explicación:

El rectángulo más pequeño tiene una altura de 2 y una anchura de 3, por lo que tiene un área de 2 * 3 = 6.

Ejemplo 2:

Entrada: grid = [[1,0],[0,0]]
Salida: 1
Explicación:

El rectángulo más pequeño tiene altura y anchura 1, por lo que su área es 1 * 1 = 1.

Restricciones:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] es 0 o 1.
La entrada se genera de forma que haya al menos un 1 en la cuadrícula.


Se te da un arreglo de enteros nums con longitud n.
El costo de un subarreglo nums[l..r], donde 0 <= l <= r < n, se define como:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Tu tarea es dividir nums en subarreglos de manera que el costo total de los subarreglos se maximice, asegurando que cada elemento pertenezca exactamente a un subarreglo.
Formalmente, si nums se divide en k subarreglos, donde k > 1, en los índices i_1, i_2, ..., i_k − 1, donde 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, entonces el costo total será:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Devuelve un entero que representa el costo total máximo de los subarreglos después de dividir el arreglo de manera óptima.
Nota: Si nums no se divide en subarreglos, es decir, k = 1, el costo total es simplemente cost(0, n - 1).

Ejemplo 1:

Entrada: nums = [1,-2,3,4]
Salida: 10
Explicación:
Una manera de maximizar el costo total es dividiendo [1, -2, 3, 4] en subarreglos [1, -2, 3] y [4]. El costo total será (1 + 2 + 3) + 4 = 10.

Ejemplo 2:

Entrada: nums = [1,-1,1,-1]
Salida: 4
Explicación:
Una manera de maximizar el costo total es dividiendo [1, -1, 1, -1] en subarreglos [1, -1] y [1, -1]. El costo total será (1 + 1) + (1 + 1) = 4.

Ejemplo 3:

Entrada: nums = [0]
Salida: 0
Explicación:
No podemos dividir el arreglo más, así que la respuesta es 0.

Ejemplo 4:

Entrada: nums = [1,-1]
Salida: 2
Explicación:
Seleccionar el arreglo completo da un costo total de 1 + 1 = 2, que es el máximo.

Restricciones:

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

Se te da un array de enteros nums con longitud n.
El costo de un subarray nums[l..r], donde 0 <= l <= r < n, se define como:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Tu tarea es dividir nums en subarrays de manera que el costo total de los subarrays se maximice, asegurando que cada elemento pertenezca exactamente a un subarray.
Formalmente, si nums se divide en k subarrays, donde k > 1, en los índices i_1, i_2, ..., i_k − 1, donde 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, entonces el costo total será:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Devuelve un entero que representa el costo total máximo de los subarrays después de dividir el array de manera óptima.
Nota: Si nums no se divide en subarrays, es decir, k = 1, el costo total es simplemente cost(0, n - 1).

Ejemplo 1:

Entrada: nums = [1,-2,3,4]
Salida: 10
Explicación:
Una manera de maximizar el costo total es dividiendo [1, -2, 3, 4] en subarrays [1, -2, 3] y [4]. El costo total será (1 + 2 + 3) + 4 = 10.

Ejemplo 2:

Entrada: nums = [1,-1,1,-1]
Salida: 4
Explicación:
Una manera de maximizar el costo total es dividiendo [1, -1, 1, -1] en subarrays [1, -1] y [1, -1]. El costo total será (1 + 1) + (1 + 1) = 4.

Ejemplo 3:

Entrada: nums = [0]
Salida: 0
Explicación:
No podemos dividir el array más, así que la respuesta es 0.

Ejemplo 4:

Entrada: nums = [1,-1]
Salida: 2
Explicación:
Seleccionar el array completo da un costo total de 1 + 1 = 2, que es el máximo.

Restricciones:

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

Se le proporciona una matriz de números enteros nums con una longitud de n.
El costo de una submatriz nums[l..r], donde 0 <= l <= r < n, se define como:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Su tarea es dividir nums en submatrices de modo que se maximice el costo total de las submatrices, asegurando que cada elemento pertenezca exactamente a una submatriz.
Formalmente, si nums se divide en k submatrices, donde k > 1, en los índices i_1, i_2, ..., i_k − 1, donde 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, entonces el costo total será:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Devuelve un entero que denota el costo total máximo de las submatrices después de dividir la matriz de manera óptima.
Nota: Si nums no se divide en submatrices, es decir, k = 1, el costo total es simplemente cost(0, n - 1).

Ejemplo 1:

Entrada: nums = [1,-2,3,4]
Salida: 10
Explicación:
Una forma de maximizar el costo total es dividir [1, -2, 3, 4] en los subarreglos [1, -2, 3] y [4]. El costo total será (1 + 2 + 3) + 4 = 10.

Ejemplo 2:

Entrada: nums = [1,-1,1,-1]
Salida: 4
Explicación:
Una forma de maximizar el costo total es dividir [1, -1, 1, -1] en los subarreglos [1, -1] y [1, -1]. El costo total será (1 + 1) + (1 + 1) = 4.

Ejemplo 3:

Entrada: nums = [0]
Salida: 0
Explicación:
No podemos dividir más la matriz, por lo que la respuesta es 0.

Ejemplo 4:

Entrada: nums = [1,-1]
Salida: 2
Explicación:
Al seleccionar toda la matriz, obtenemos un costo total de 1 + 1 = 2, que es el máximo.

Restricciones:

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


Se te dan dos enteros, rojo y azul, que representan la cantidad de pelotas de colores rojo y azul. Debes organizar estas pelotas para formar un triángulo de manera que la 1^a fila tenga 1 pelota, la 2^a fila tenga 2 pelotas, la 3^a fila tenga 3 pelotas, y así sucesivamente. Todas las pelotas en una fila particular deben ser del mismo color, y las filas adyacentes deben tener colores diferentes. Devuelve la altura máxima del triángulo que se puede lograr.

Ejemplo 1:

Entrada: red = 2, blue = 4
Salida: 3
Explicación:

El único arreglo posible se muestra arriba.

Ejemplo 2:

Entrada: red = 2, blue = 1
Salida: 2
Explicación:

El único arreglo posible se muestra arriba.

Ejemplo 3:

Entrada: red = 1, blue = 1
Salida: 1

Ejemplo 4:

Entrada: red = 10, blue = 1
Salida: 2
Explicación:

El único arreglo posible se muestra arriba.

Restricciones:

1 <= red, blue <= 100

Se le proporcionan dos números enteros, rojo y azul, que representan la cantidad de bolas de color rojo y azul. Debe colocar estas bolas para formar un triángulo de modo que la primera fila tenga 1 bola, la segunda fila tenga 2 bolas, la tercera fila tenga 3 bolas, y así sucesivamente.
Todas las bolas de una fila en particular deben ser del mismo color y las filas adyacentes deben tener colores diferentes.
Devuelve la altura máxima del triángulo que se puede lograr.

Ejemplo 1:

Entrada: rojo = 2, azul = 4
Salida: 3
Explicación:

La única disposición posible se muestra arriba.

Ejemplo 2:

Entrada: rojo = 2, azul = 1
Salida: 2
Explicación:

La única disposición posible se muestra arriba.

Ejemplo 3:

Entrada: rojo = 1, azul = 1
Salida: 1

Ejemplo 4:

Entrada: rojo = 10, azul = 1
Salida: 2
Explicación:

La única disposición posible se muestra arriba.

Restricciones:

1 <= rojo, azul <= 100

Se te dan dos enteros, rojo y azul, que representan la cantidad de pelotas de colores rojo y azul. Debes organizar estas pelotas para formar un triángulo de manera que la 1^a fila tenga 1 pelota, la 2^a fila tenga 2 pelotas, la 3^a fila tenga 3 pelotas, y así sucesivamente.
Todas las pelotas en una fila particular deben ser del mismo color, y las filas adyacentes deben tener colores diferentes.
Devuelve la altura máxima del triángulo que se puede lograr.

Ejemplo 1:

Entrada: rojo = 2, azul = 4
Salida: 3
Explicación:

El único arreglo posible se muestra arriba.

Ejemplo 2:

Entrada: rojo = 2, azul = 1
Salida: 2
Explicación:

El único arreglo posible se muestra arriba.

Ejemplo 3:

Entrada: rojo = 1, azul = 1
Salida: 1

Ejemplo 4:

Entrada: rojo = 10, azul = 1
Salida: 2
Explicación:

El único arreglo posible se muestra arriba.

Restricciones:

1 <= rojo, azul <= 100


Se te da un array de enteros nums.
Una subsecuencia sub de nums con longitud x se llama válida si satisface:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Devuelve la longitud de la subsecuencia válida más larga de nums.
Una subsecuencia es un array que se puede derivar de otro array eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación:
La subsecuencia válida más larga es [1, 2, 3, 4].

Ejemplo 2:

Entrada: nums = [1,2,1,1,2,1,2]
Salida: 6
Explicación:
La subsecuencia válida más larga es [1, 2, 1, 2, 1, 2].

Ejemplo 3:

Entrada: nums = [1,3]
Salida: 2
Explicación:
La subsecuencia válida más larga es [1, 3].

Restricciones:

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

Se te da un conjunto de enteros nums.
Una subsecuencia sub de nums con longitud x se llama válida si satisface:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Devuelve la longitud de la subsecuencia válida más larga de nums.
Una subsecuencia es un conjunto que se puede derivar de otro conjunto eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación:
La subsecuencia válida más larga es [1, 2, 3, 4].

Ejemplo 2:

Entrada: nums = [1,2,1,1,2,1,2]
Salida: 6
Explicación:
La subsecuencia válida más larga es [1, 2, 1, 2, 1, 2].

Ejemplo 3:

Entrada: nums = [1,3]
Salida: 2
Explicación:
La subsecuencia válida más larga es [1, 3].

Restricciones:

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

Se le da una matriz de números enteros.
Una subsecuencia sub de nums con longitud x se llama válida si satisface:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Devuelve la longitud de la subsecuencia válida más larga de nums.
Una subsecuencia es una matriz que se puede derivar de otra matriz eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación:
La subsecuencia válida más larga es [1, 2, 3, 4].

Ejemplo 2:

Entrada: nums = [1,2,1,1,2,1,2]
Salida: 6
Explicación:
La subsecuencia válida más larga es [1, 2, 1, 2, 1, 2].

Ejemplo 3:

Entrada: nums = [1,3]
Salida: 2
Explicación:
La subsecuencia válida más larga es [1, 3].

Restricciones:

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


Existen dos árboles no dirigidos con n y m nodos, numerados de 0 a n - 1 y de 0 a m - 1, respectivamente. Se le proporcionan dos matrices de enteros 2D, edges1 y edges2, de longitudes n - 1 y m - 1, respectivamente, donde edges1[i] = [a_i, b_i] indica que hay una arista entre los nodos a_i y b_i en el primer árbol y edges2[i] = [u_i, v_i] indica que hay una arista entre los nodos u_i y v_i en el segundo árbol.
Debe conectar un nodo del primer árbol con otro nodo del segundo árbol con una arista.
Devuelva el diámetro mínimo posible del árbol resultante.
El diámetro de un árbol es la longitud del camino más largo entre dos nodos cualesquiera del árbol.

Ejemplo 1:

Entrada: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Salida: 3
Explanation:
Podemos obtener un árbol de diámetro 3 conectando el nodo 0 del primer árbol con cualquier nodo del segundo árbol.

Ejemplo 2:

Entrada: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Salida: 5
Explanation:
Podemos obtener un árbol de diámetro 5 conectando el nodo 0 del primer árbol con el nodo 0 del segundo árbol.

Restricciones:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
La entrada se genera de modo que edges1 y edges2 representen árboles válidos.

Existen dos árboles no dirigidos con n y m nodos, numerados de 0 a n - 1 y de 0 a m - 1, respectivamente. Se dan dos matrices enteras 2D aristas1 y aristas2 de longitudes n - 1 y m - 1, respectivamente, donde aristas1[i] = [a_i, b_i] indica que hay una arista entre los nodos a_i y b_i en el primer árbol y aristas2[i] = [u_i, v_i] indica que hay una arista entre los nodos u_i y v_i en el segundo árbol.
Debe conectar un nodo del primer árbol con otro nodo del segundo árbol mediante una arista.
Devuelve el diámetro mínimo posible del árbol resultante.
El diámetro de un árbol es la longitud del camino más largo entre dos nodos cualesquiera del árbol.

Ejemplo 1:

Entrada:  edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Salida: 3
Explicación:
Podemos obtener un árbol de diámetro 3 conectando el nodo 0 del primer árbol con cualquier nodo del segundo árbol.

Ejemplo 2:

Entrada: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Salida: 5
Explicación:
Podemos obtener un árbol de diámetro 5 conectando el nodo 0 del primer árbol con el nodo 0 del segundo árbol.

Restricciones:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
La entrada se genera de forma que las aristas1 y las aristas2 representen árboles válidos.

Existen dos árboles no dirigidos con n y m nodos, numerados del 0 al n - 1 y del 0 al m - 1, respectivamente. Se te dan dos arreglos 2D de enteros edges1 y edges2 de longitudes n - 1 y m - 1, respectivamente, donde edges1[i] = [a_i, b_i] indica que hay una arista entre los nodos a_i y b_i en el primer árbol y edges2[i] = [u_i, v_i] indica que hay una arista entre los nodos u_i y v_i en el segundo árbol.
Debes conectar un nodo del primer árbol con otro nodo del segundo árbol con una arista.
Devuelve el diámetro mínimo posible del árbol resultante.
El diámetro de un árbol es la longitud del camino más largo entre dos nodos cualquiera en el árbol.

Ejemplo 1:

Entrada: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Salida: 3
Explicación:
Podemos obtener un árbol de diámetro 3 conectando el nodo 0 del primer árbol con cualquier nodo del segundo árbol.

Ejemplo 2:

Entrada: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Salida: 5
Explicación:
Podemos obtener un árbol de diámetro 5 conectando el nodo 0 del primer árbol con el nodo 0 del segundo árbol.

Restricciones:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
La entrada se genera de manera que edges1 y edges2 representen árboles válidos.


Se te da una cadena s y un entero k. Encripta la cadena usando el siguiente algoritmo:

Para cada carácter c en s, reemplaza c con el k-ésimo carácter después de c en la cadena (de manera cíclica).

Devuelve la cadena encriptada.

Ejemplo 1:

Entrada: s = "dart", k = 3
Salida: "tdar"
Explicación:

Para i = 0, el 3^er carácter después de 'd' es 't'.
Para i = 1, el 3^er carácter después de 'a' es 'd'.
Para i = 2, el 3^er carácter después de 'r' es 'a'.
Para i = 3, el 3^er carácter después de 't' es 'r'.

Ejemplo 2:

Entrada: s = "aaa", k = 1
Salida: "aaa"
Explicación:
Como todos los caracteres son iguales, la cadena encriptada también será la misma.

Restricciones:

1 <= s.length <= 100
1 <= k <= 10^4
s consiste solo de letras minúsculas del alfabeto inglés.

Se le proporciona una cadena s y un entero k. Cifre la cadena utilizando el siguiente algoritmo:

Para cada carácter c en s, reemplace c con el k^ésimo carácter después de c en la cadena (de manera cíclica).

Devuelva la cadena cifrada.

Ejemplo 1:

Entrada: s = "dart", k = 3
Salida: "tdar"
Explicación:

Para i = 0, el 3^er carácter después de 'd' es 't'.
Para i = 1, el 3^er carácter después de 'a' es 'd'.
Para i = 2, el 3^er carácter después de 'r' es 'a'.
Para i = 3, el 3^er carácter después de 't' es 'r'.

Ejemplo 2:

Entrada: s = "aaa", k = 1
Salida: "aaa"
Explicación:
Como todos los caracteres son iguales, la cadena cifrada también será la misma.

Restricciones:

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

Se te da una cadena s y un número entero k. Encripta la cadena usando el siguiente algoritmo:

Para cada carácter c en s, reemplaza c con el k-ésimo carácter después de c en la cadena (de manera cíclica).

Devuelve la cadena encriptada.

Ejemplo 1:

Input: s = "dart", k = 3
Output: "tdar"
Explicación:

Para i = 0, el 3^er carácter después de 'd' es 't'.
Para i = 1, el 3^er carácter después de 'a' es 'd'.
Para i = 2, el 3^er carácter después de 'r' es 'a'.
Para i = 3, el 3^er carácter después de 't' es 'r'.

Ejemplo 2:

Input: s = "aaa", k = 1
Output: "aaa"
Explicación:
Como todos los caracteres son iguales, la cadena encriptada también será la misma.

Restricciones:

1 <= s.length <= 100
1 <= k <= 10^4
s solo contiene letras minúsculas del alfabeto inglés.


Se le proporciona un entero positivo n.
Una cadena binaria x es válida si todas las subcadenas de x de longitud 2 contienen al menos un "1".
Devuelve todas las cadenas válidas con longitud n, en cualquier orden.

Ejemplo 1:

Entrada: n = 3
Salida: ["010", "011", "101", "110", "111"]
Explicación:
Las cadenas válidas de longitud 3 son: "010", "011", "101", "110" y "111".

Ejemplo 2:

Entrada: n = 1
Salida: ["0", "1"]
Explicación:
Las cadenas válidas de longitud 1 son: "0" y "1".

Restricciones:

1 <= n <= 18

Se le proporciona un entero positivo n.
Una cadena binaria x es válida si todas las subcadenas de x de longitud 2 contienen al menos un "1".
Devuelve todas las cadenas válidas con longitud n, en cualquier orden.

Ejemplo 1:

Entrada: n = 3
Salida: ["010","011","101","110","111"]
Explicación:
Las cadenas válidas de longitud 3 son: "010", "011", "101", "110" y "111".

Ejemplo 2:

Entrada: n = 1
Salida: ["0","1"]
Explicación:
Las cadenas válidas de longitud 1 son: "0" y "1".

Restricciones:

1 <= n <= 18

Se te da un entero positivo n.
Una cadena binaria x es válida si todos los subcadenas de x de longitud 2 contienen al menos un "1".
Devuelve todas las cadenas válidas con longitud n, en cualquier orden.

Ejemplo 1:

Entrada: n = 3
Salida: ["010","011","101","110","111"]
Explicación:
Las cadenas válidas de longitud 3 son: "010", "011", "101", "110" y "111".

Ejemplo 2:

Entrada: n = 1
Salida: ["0","1"]
Explicación:
Las cadenas válidas de longitud 1 son: "0" y "1".

Restricciones:

1 <= n <= 18


Dada una matriz de caracteres 2D, donde grid[i][j] es 'X', 'Y' o '.', devuelve la cantidad de submatrices que contienen:

grid[0][0]
una frecuencia igual de 'X' e 'Y'.
al menos una 'X'.

Ejemplo 1:

Entrada: grid = [["X", "Y", "."],["Y", "."]]
Salida: 3
Explicación:

Ejemplo 2:

Entrada: grid = [["X", "X"],["X", "Y"]]
Salida: 0
Explicación:
Ninguna submatriz tiene una frecuencia igual de 'X' e 'Y'.

Ejemplo 3:

Entrada: grid = [[".", "."],[".", "."]]
Salida: 0
Explicación:
Ninguna submatriz tiene al menos una 'X'.

Restricciones:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] es 'X', 'Y' o '.'.

Dada una matriz de caracteres en 2D, grid, donde grid[i][j] es 'X', 'Y' o '.', devuelve el número de submatrices que contienen:

grid[0][0]
una frecuencia igual de 'X' y 'Y'.
al menos una 'X'.

Ejemplo 1:

Entrada: grid = [["X","Y","."],["Y",".","."]]
Salida: 3
Explicación:

Ejemplo 2:

Entrada: grid = [["X","X"],["X","Y"]]
Salida: 0
Explicación:
Ninguna submatriz tiene una frecuencia igual de 'X' y 'Y'.

Ejemplo 3:

Entrada: grid = [[".","."],[".","."]]
Salida: 0
Explicación:
Ninguna submatriz tiene al menos una 'X'.

Restricciones:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] es 'X', 'Y' o '.'.


Se te da una cadena objetivo llamada target, un arreglo de cadenas words, y un arreglo de enteros costs, ambos arreglos de la misma longitud.
Imagina una cadena vacía s.
Puedes realizar la siguiente operación cualquier cantidad de veces (incluyendo cero):

Elige un índice i en el rango [0, words.length - 1].
Añade words[i] a s.
El costo de la operación es costs[i].

Devuelve el costo mínimo para hacer que s sea igual a target. Si no es posible, devuelve -1.

Ejemplo 1:

Entrada: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Salida: 7
Explicación:
El costo mínimo se puede lograr realizando las siguientes operaciones:

Selecciona el índice 1 y añade "abc" a s con un costo de 1, resultando en s = "abc".
Selecciona el índice 2 y añade "d" a s con un costo de 1, resultando en s = "abcd".
Selecciona el índice 4 y añade "ef" a s con un costo de 5, resultando en s = "abcdef".

Ejemplo 2:

Entrada: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Salida: -1
Explicación:
Es imposible hacer que s sea igual a target, así que devolvemos -1.

Restricciones:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La suma total de words[i].length es menor o igual a 5 * 10^4.
target y words[i] consisten solo en letras minúsculas inglesas.
1 <= costs[i] <= 10^4

Se le proporciona una cadena target, una matriz de cadenas words y una matriz de enteros costs, ambas matrices de la misma longitud.
Imagine una cadena vacía s.
Puede realizar la siguiente operación cualquier cantidad de veces (incluido cero):

Elija un índice i en el rango [0, words.length - 1].
Añada words[i] a s.
El costo de la operación es costs[i].

Devuelva el costo mínimo para que s sea igual a target. Si no es posible, devuelva -1.

Ejemplo 1:

Entrada: target = "abcdef", words = ["abdef", "abc", "d", "def", "ef"], costs = [100,1,1,10,5]
Salida: 7
Explicación:
El costo mínimo se puede lograr realizando las siguientes operaciones:

Seleccione el índice 1 y añada "abc" a s con un costo de 1, lo que da como resultado s = "abc".
Seleccione el índice 2 y agregue "d" a s con un costo de 1, lo que da como resultado s = "abcd".
Seleccione el índice 4 y agregue "ef" a s con un costo de 5, lo que da como resultado s = "abcdef".

Ejemplo 2:

Entrada: target = "aaaa", words = ["z", "zz", "zzz"], costs = [1,10,100]
Salida: -1
Explicación:
Es imposible hacer que s sea igual a target, por lo que devolvemos -1.

Restricciones:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La suma total de words[i].length es menor o igual a 5 * 10^4.
target y words[i] constan solo de letras minúsculas en inglés.
1 <= costs[i] <= 10^4

Se te da un string target, un array de strings words y un array de enteros costs, ambos arrays de la misma longitud.
Imagina un string vacío s.
Puedes realizar la siguiente operación cualquier cantidad de veces (incluyendo cero):

Elige un índice i en el rango [0, words.length - 1].
Agrega words[i] a s.
El costo de la operación es costs[i].

Devuelve el costo mínimo para hacer que s sea igual a target. Si no es posible, devuelve -1.

Ejemplo 1:

Input: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Output: 7
Explicación:
El costo mínimo se puede lograr realizando las siguientes operaciones:

Selecciona el índice 1 y agrega "abc" a s con un costo de 1, resultando en s = "abc".
Selecciona el índice 2 y agrega "d" a s con un costo de 1, resultando en s = "abcd".
Selecciona el índice 4 y agrega "ef" a s con un costo de 5, resultando en s = "abcdef".

Ejemplo 2:

Input: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Output: -1
Explicación:
Es imposible hacer que s sea igual a target, así que devolvemos -1.

Restricciones:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La suma total de las longitudes de words[i] es menor o igual a 5 * 10^4.
target y words[i] consisten solo de letras minúsculas del alfabeto inglés.
1 <= costs[i] <= 10^4.


Dada una cadena s que contiene solo dígitos, devuelve la cadena lexicográficamente más pequeña que se puede obtener después de intercambiar dígitos adyacentes en s con la misma paridad, como máximo una vez.
Los dígitos tienen la misma paridad si ambos son impares o ambos son pares. Por ejemplo, 5 y 9, así como 2 y 4, tienen la misma paridad, mientras que 6 y 9 no.

Ejemplo 1:

Entrada: s = "45320"
Salida: "43520"
Explicación:
s[1] == '5' y s[2] == '3' tienen la misma paridad, y al intercambiarlos, se obtiene la cadena lexicográficamente más pequeña.

Ejemplo 2:

Entrada: s = "001"
Salida: "001"
Explicación:
No es necesario realizar un intercambio porque s ya es la cadena lexicográficamente más pequeña.

Restricciones:

2 <= s.length <= 100
s consiste solo de dígitos.

Dada una cadena s que sólo contiene dígitos, devuelve la cadena lexicográficamente más pequeña que puede obtenerse tras intercambiar dígitos adyacentes en s con la misma paridad como máximo una vez.
Los dígitos tienen la misma paridad si ambos son pares o impares. Por ejemplo, 5 y 9, así como 2 y 4, tienen la misma paridad, mientras que 6 y 9 no.

Ejemplo 1

Entrada: s = "45320"
Salida: "43520"
Explicación:
s[1] == '5' y s[2] == '3' tienen ambas la misma paridad, y al intercambiarlas se obtiene la cadena lexicográficamente más pequeña.

Ejemplo 2:

Entrada: s = "001"
Salida: "001"
Explicación:
No es necesario realizar un intercambio porque s ya es el más pequeño lexicográficamente.

Restricciones:

2 <= s.length <= 100
s consists only of digits.

Dada una cadena s que contiene solo dígitos, devuelve la cadena lexicográficamente más pequeña que se puede obtener después de intercambiar dígitos adyacentes en s con la misma paridad, como máximo una vez.
Los dígitos tienen la misma paridad si ambos son impares o ambos son pares. Por ejemplo, 5 y 9, así como 2 y 4, tienen la misma paridad, mientras que 6 y 9 no.

Ejemplo 1:

Input: s = "45320"
Output: "43520"
Explicación:
s[1] == '5' y s[2] == '3' tienen la misma paridad, y al intercambiarlos, se obtiene la cadena lexicográficamente más pequeña.

Ejemplo 2:

Input: s = "001"
Output: "001"
Explicación:
No es necesario realizar un intercambio porque s ya es la cadena lexicográficamente más pequeña.

Restricciones:

2 <= s.length <= 100
s consiste solo de dígitos.


Hay un pastel de m x n que necesita ser cortado en piezas de 1 x 1.
Se te dan los enteros m, n y dos matrices:

horizontalCut de tamaño m - 1, donde horizontalCut[i] representa el costo de cortar a lo largo de la línea horizontal i.
verticalCut de tamaño n - 1, donde verticalCut[j] representa el costo de cortar a lo largo de la línea vertical j.

En una operación, puedes elegir cualquier pedazo de pastel que aún no sea un cuadrado de 1 x 1 y realizar uno de los siguientes cortes:

Cortar a lo largo de una línea horizontal i con un costo de horizontalCut[i].
Cortar a lo largo de una línea vertical j con un costo de verticalCut[j].

Después del corte, el pedazo de pastel se divide en dos piezas distintas.
El costo de un corte depende solo del costo inicial de la línea y no cambia.
Devuelve el costo total mínimo para cortar todo el pastel en piezas de 1 x 1.

Ejemplo 1:

Entrada: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Salida: 13
Explicación:

Realiza un corte en la línea vertical 0 con costo 5, el costo total actual es 5.
Realiza un corte en la línea horizontal 0 en la subcuadrícula de 3 x 1 con costo 1.
Realiza un corte en la línea horizontal 0 en la subcuadrícula de 3 x 1 con costo 1.
Realiza un corte en la línea horizontal 1 en la subcuadrícula de 2 x 1 con costo 3.
Realiza un corte en la línea horizontal 1 en la subcuadrícula de 2 x 1 con costo 3.

El costo total es 5 + 1 + 1 + 3 + 3 = 13.

Ejemplo 2:

Entrada: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Salida: 15
Explicación:

Realiza un corte en la línea horizontal 0 con costo 7.
Realiza un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con costo 4.
Realiza un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con costo 4.

El costo total es 7 + 4 + 4 = 15.

Condiciones:

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

Hay una torta m x n que se debe cortar en pedazos de 1 x 1.
Se le proporcionan los números enteros m, n y dos matrices:

horizontalCut de tamaño m - 1, donde horizontalCut[i] representa el costo de cortar a lo largo de la línea horizontal i.
verticalCut de tamaño n - 1, donde verticalCut[j] representa el costo de cortar a lo largo de la línea vertical j.

En una operación, puede elegir cualquier pedazo de torta que aún no sea un cuadrado de 1 x 1 y realizar uno de los siguientes cortes:

Cortar a lo largo de una línea horizontal i a un costo de horizontalCut[i].
Cortar a lo largo de una línea vertical j a un costo de verticalCut[j].

Después del corte, la torta se divide en dos pedazos distintos.
El costo de un corte depende solo del costo inicial de la línea y no cambia.
Devuelve el costo total mínimo para cortar toda la torta en pedazos de 1 x 1.

Ejemplo 1:

Entrada: m = 3, n = 2, corteHorizontal = [1,3], corteVertical = [5]
Salida: 13
Explicación:

Realice un corte en la línea vertical 0 con un costo de 5, el costo total actual es 5.
Realice un corte en la línea horizontal 0 en una subcuadrícula de 3 x 1 con un costo de 1.
Realice un corte en la línea horizontal 0 en una subcuadrícula de 3 x 1 con un costo de 1.
Realice un corte en la línea horizontal 1 en una subcuadrícula de 2 x 1 con un costo de 3.
Realice un corte en la línea horizontal 1 en una subcuadrícula de 2 x 1 con un costo de 3.

El costo total es 5 + 1 + 1 + 3 + 3 = 13.

Ejemplo 2:

Entrada: m = 2, n = 2, corteHorizontal = [7], corteVertical = [4]
Salida: 15
Explicación:

Realice un corte en la línea horizontal 0 con un costo de 7.
Realice un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con un costo de 4.
Realice un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con un costo de 4.

El costo total es 7 + 4 + 4 = 15.

Restricciones:

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

Hay un pastel de m x n que necesita ser cortado en piezas de 1 x 1.
Se te dan los enteros m, n y dos arreglos:

horizontalCut de tamaño m - 1, donde horizontalCut[i] representa el costo de cortar a lo largo de la línea horizontal i.
verticalCut de tamaño n - 1, donde verticalCut[j] representa el costo de cortar a lo largo de la línea vertical j.

En una operación, puedes elegir cualquier pedazo de pastel que aún no sea un cuadrado de 1 x 1 y realizar uno de los siguientes cortes:

Cortar a lo largo de una línea horizontal i con un costo de horizontalCut[i].
Cortar a lo largo de una línea vertical j con un costo de verticalCut[j].

Después del corte, el pedazo de pastel se divide en dos piezas distintas.
El costo de un corte depende solo del costo inicial de la línea y no cambia.
Devuelve el costo total mínimo para cortar todo el pastel en piezas de 1 x 1.

Ejemplo 1:

Entrada: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Salida: 13
Explicación:

Realiza un corte en la línea vertical 0 con costo 5, el costo total actual es 5.
Realiza un corte en la línea horizontal 0 en la subcuadrícula de 3 x 1 con costo 1.
Realiza un corte en la línea horizontal 0 en la subcuadrícula de 3 x 1 con costo 1.
Realiza un corte en la línea horizontal 1 en la subcuadrícula de 2 x 1 con costo 3.
Realiza un corte en la línea horizontal 1 en la subcuadrícula de 2 x 1 con costo 3.

El costo total es 5 + 1 + 1 + 3 + 3 = 13.

Ejemplo 2:

Entrada: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Salida: 15
Explicación:

Realiza un corte en la línea horizontal 0 con costo 7.
Realiza un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con costo 4.
Realiza un corte en la línea vertical 0 en la subcuadrícula de 1 x 2 con costo 4.

El costo total es 7 + 4 + 4 = 15.

Condiciones:

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


Se te dan dos enteros positivos n y k.
Puedes elegir cualquier bit en la representación binaria de n que sea igual a 1 y cambiarlo a 0.
Devuelve el número de cambios necesarios para hacer que n sea igual a k. Si es imposible, devuelve -1.

Ejemplo 1:

Entrada: n = 13, k = 4
Salida: 2
Explicación:
Inicialmente, las representaciones binarias de n y k son n = (1101)_2 y k = (0100)_2.
Podemos cambiar el primer y cuarto bit de n. El entero resultante es n = (0100)_2 = k.

Ejemplo 2:

Entrada: n = 21, k = 21
Salida: 0
Explicación:
n y k ya son iguales, por lo que no se necesitan cambios.

Ejemplo 3:

Entrada: n = 14, k = 13
Salida: -1
Explicación:
No es posible hacer que n sea igual a k.

Restricciones:

1 <= n, k <= 10^6

Se le dan dos números enteros positivos n y k.
Puedes elegir cualquier bit de la representación binaria de n que sea igual a 1 y cambiarlo a 0.
Devuelve el número de cambios necesarios para que n sea igual a k. Si es imposible, devuelve -1.

Ejemplo 1:

Entrada: n = 13, k = 4
Salida: 2
Explicación:
Inicialmente, las representaciones binarias de n y k son n = (1101)_2 y k = (0100)_2.
Podemos cambiar el primer y cuarto bits de n. El número entero resultante es n = (0100)_2 = k.

Ejemplo 2:

Entrada: n = 21, k = 21
Salida: 0
Explicación:
n y k ya son iguales, por lo que no es necesario ningún cambio.

Ejemplo 3:

Entrada: n = 14, k = 13
Salida: -1
Explicación:
No es posible hacer n igual a k.

Restricciones:

1 <= n, k <= 10^6


Alice y Bob están jugando un juego con una cadena.
Se te da una cadena s, Alice y Bob tomarán turnos jugando el siguiente juego donde Alice comienza primero:

En el turno de Alice, ella tiene que eliminar cualquier subcadena no vacía de s que contenga un número impar de vocales.
En el turno de Bob, él tiene que eliminar cualquier subcadena no vacía de s que contenga un número par de vocales.

El primer jugador que no pueda hacer un movimiento en su turno pierde el juego. Asumimos que tanto Alice como Bob juegan de manera óptima.
Devuelve true si Alice gana el juego, y false en caso contrario.
Las vocales en inglés son: a, e, i, o, y u.

Ejemplo 1:

Entrada: s = "leetcoder"
Salida: true
Explicación:
Alice puede ganar el juego de la siguiente manera:

Alice juega primero, ella puede eliminar la subcadena subrayada en s = "leetcoder" que contiene 3 vocales. La cadena resultante es s = "der".
Bob juega segundo, él puede eliminar la subcadena subrayada en s = "der" que contiene 0 vocales. La cadena resultante es s = "er".
Alice juega tercero, ella puede eliminar toda la cadena s = "er" que contiene 1 vocal.
Bob juega cuarto, dado que la cadena está vacía, no hay un movimiento válido para Bob. Así que Alice gana el juego.

Ejemplo 2:

Entrada: s = "bbcd"
Salida: false
Explicación:
No hay un movimiento válido para Alice en su primer turno, así que Alice pierde el juego.

Restricciones:

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

Alice y Bob están jugando a un juego con una cuerda.
Se te da una cuerda s, Alice y Bob jugarán por turnos al siguiente juego, en el que Alice empieza primero:

En el turno de Alice, tiene que eliminar cualquier subcadena no vacía de s que contenga un número impar de vocales.
En el turno de Bob, tiene que eliminar cualquier subcadena no vacía de s que contenga un número par de vocales.

El primer jugador que no pueda hacer un movimiento en su turno pierde el juego. Suponemos que tanto Alice como Bob juegan de forma óptima.
Devuelve verdadero si Alice gana el juego y falso en caso contrario.
Las vocales en inglés son: a, e, i, o y u.

Ejemplo 1:

Entrada: s = "leetcoder"
Salida: verdadero
Explicación:
Alice puede ganar el juego de la siguiente manera:

Alice juega primero, puede eliminar la subcadena subrayada en s = "leetcoder" que contiene 3 vocales. La cadena resultante es s = "der".
Bob juega segundo, puede eliminar la subcadena subrayada en s = "der" que contiene 0 vocales. La cadena resultante es s = "er".
Alice juega tercero, puede eliminar toda la cadena s = "er" que contiene 1 vocal.
Bob juega cuarto, ya que la cadena está vacía, no hay ninguna jugada válida para Bob. Por lo tanto, Alice gana el juego.

Ejemplo 2:

Entrada: s = "bbcd"
Salida: false
Explicación:
No hay ninguna jugada válida para Alice en su primer turno, por lo que Alice pierde el juego.

Restricciones:

1 <= s.length <= 10^5
s consta solo de letras minúsculas en inglés.

Alice y Bob están jugando a un juego con una cuerda.
Se te da una cuerda s, Alice y Bob jugarán por turnos al siguiente juego, en el que Alice empieza primero:

En el turno de Alice, tiene que eliminar cualquier subcadena no vacía de s que contenga un número impar de vocales.
En el turno de Bob, tiene que eliminar cualquier subcadena no vacía de s que contenga un número par de vocales.

El primer jugador que no pueda hacer un movimiento en su turno pierde el juego. Suponemos que tanto Alice como Bob juegan de forma óptima.
Devuelve true si Alice gana el juego y false en caso contrario.
Las vocales en inglés son: a, e, i, o y u.

Ejemplo 1:

Entrada: s = "leetcoder"
Salida: true
Explicación:
Alice puede ganar el juego de la siguiente manera:

Alice juega primero, puede eliminar la subcadena subrayada en s = "leetcoder" que contiene 3 vocales. La cadena resultante es s = "der".
Bob juega segundo, puede eliminar la subcadena subrayada en s = "der" que contiene 0 vocales. La cadena resultante es s = "er".
Alice juega tercero, puede eliminar toda la cadena s = "er" que contiene 1 vocal.
Bob juega cuarto, ya que la cadena está vacía, no hay ninguna jugada válida para Bob. Por lo tanto, Alice gana el juego.

Ejemplo 2:

Entrada: s = "bbcd"
Salida: false
Explicación:
No hay ninguna jugada válida para Alice en su primer turno, por lo que Alice pierde el juego.

Restricciones:

1 <= s.length <= 10^5
s consta solo de letras minúsculas en inglés.


Dada una cadena binaria s.
Puedes realizar la siguiente operación en la cadena cualquier número de veces:

Elige cualquier índice i de la cadena donde i + 1 < s.length tal que s[i] == '1' y s[i + 1] == '0'.
Mueve el carácter s[i] hacia la derecha hasta que llegue al final de la cadena o hasta otro '1'. Por ejemplo, para s = "010010", si elegimos i = 1, la cadena resultante será s = "000110".

Devuelve el número máximo de operaciones que puedes realizar.

Ejemplo 1:

Entrada: s = "1001101"
Salida: 4
Explicación:
Podemos realizar las siguientes operaciones:

Elige el índice i = 0. La cadena resultante es s = "0011101".
Elige el índice i = 4. La cadena resultante es s = "0011011".
Elige el índice i = 3. La cadena resultante es s = "0010111".
Elige el índice i = 2. La cadena resultante es s = "0001111".

Ejemplo 2:

Entrada: s = "00111"
Salida: 0

Restricciones:

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

Dada una cadena binaria s.
Puedes realizar la siguiente operación en la cadena cuanto número de veces quieras:

Elige cualquier índice i de la cadena donde i + 1 < s.length tal que s[i] == '1' y s[i + 1] == '0'.
Mueve el carácter s[i] hacia la derecha hasta que llegue al final de la cadena o hasta otro '1'. Por ejemplo, para s = "010010", si elegimos i = 1, la cadena resultante será s = "000110".

Devuelve el número máximo de operaciones que puedes realizar.

Ejemplo 1:

Entrada: s = "1001101"
Salida: 4
Explicación:
Podemos realizar las siguientes operaciones:

Elige el índice i = 0. La cadena resultante es s = "0011101".
Elige el índice i = 4. La cadena resultante es s = "0011011".
Elige el índice i = 3. La cadena resultante es s = "0010111".
Elige el índice i = 2. La cadena resultante es s = "0001111".

Ejemplo 2:

Entrada: s = "00111"
Salida: 0

Restricciones:

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

Se le da una cadena binaria s.
Puede realizar la siguiente operación en la cadena cualquier número de veces:

Elija cualquier índice i de la cadena donde i + 1 < s.length tal que s[i] == '1' y s[i + 1] == '0'.
Mueva el carácter s[i] hacia la derecha hasta que llegue al final de la cadena o a otro '1'. Por ejemplo, para s = "010010", si elegimos i = 1, la cadena resultante será s = "000110".

Devuelve el número máximo de operaciones que puede realizar.

Ejemplo 1:

Entrada: s = "1001101"
Salida: 4
Explicación:
Podemos realizar las siguientes operaciones:

Elegir índice i = 0. La cadena resultante es s = "0011101".
Elegir el índice i = 4. La cadena resultante es s = "0011011".
Elija el índice i = 3. La cadena resultante es s = "0010111".
Elija el índice i = 2. La cadena resultante es s = "0001111".

Ejemplo 2:

Entrada: s = "00111"
Salida: 0

Restricciones:

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


Se te dan dos arreglos de enteros positivos, nums y target, de la misma longitud.
En una sola operación, puedes seleccionar cualquier subarreglo de nums e incrementar o decrementar cada elemento dentro de ese subarreglo en 1.
Devuelve el número mínimo de operaciones requeridas para hacer nums igual al arreglo target.

Ejemplo 1:

Entrada: nums = [3,5,1,2], target = [4,6,2,4]
Salida: 2
Explicación:
Realizaremos las siguientes operaciones para hacer nums igual a target:
- Incrementar nums[0..3] en 1, nums = [4,6,2,3].
- Incrementar nums[3..3] en 1, nums = [4,6,2,4].

Ejemplo 2:

Entrada: nums = [1,3,2], target = [2,1,4]
Salida: 5
Explicación:
Realizaremos las siguientes operaciones para hacer nums igual a target:
- Incrementar nums[0..0] en 1, nums = [2,3,2].
- Decrementar nums[1..1] en 1, nums = [2,2,2].
- Decrementar nums[1..1] en 1, nums = [2,1,2].
- Incrementar nums[2..2] en 1, nums = [2,1,3].
- Incrementar nums[2..2] en 1, nums = [2,1,4].

Constraints:

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

Se le dan dos matrices de enteros positivos nums y target, de la misma longitud.
En una sola operación, puede seleccionar cualquier subarray de nums e incrementar o decrementar cada elemento dentro de ese subarray en 1.
Devuelve el número mínimo de operaciones necesarias para hacer nums igual a la matriz objetivo.

Ejemplo 1:

Entrada: nums = [3,5,1,2], target = [4,6,2,4]
Salida: 2
Explicación:
Realizaremos las siguientes operaciones para que nums sea igual a target:
- Incrementar nums[0..3] en 1, nums = [4,6,2,3].
- Incrementar nums[3..3] en 1, nums = [4,6,2,4].

Ejemplo 2:

Entrada: nums = [1,3,2], target = [2,1,4]
Salida: 5
Explicación:
Realizaremos las siguientes operaciones para que nums sea igual a target:
- Incrementar nums[0..0] en 1, nums = [2,3,2].
- Disminuir números[1..1] en 1,  nums = [2,2,2].
- Disminuye nums[1..1] en 1, nums = [2,1,2].
- Incrementa nums[2..2] en 1, nums = [2,1,3].
- Incrementa nums[2..2] en 1, nums = [2,1,4].

Restricciones:

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

Se le proporcionan dos matrices de números enteros positivos, nums y target, de la misma longitud.
En una sola operación, puede seleccionar cualquier submatriz de nums e incrementar o decrementar cada elemento dentro de esa submatriz en 1.
Devuelve la cantidad mínima de operaciones necesarias para que nums sea igual a la matriz target.

Ejemplo 1:

Entrada: nums = [3,5,1,2], target = [4,6,2,4]
Salida: 2
Explicación:
Realizaremos las siguientes operaciones para que nums sea igual a target:
- Incrementar nums[0..3] en 1, nums = [4,6,2,3].
- Incrementar nums[3..3] en 1, nums = [4,6,2,4].

Ejemplo 2:

Entrada: nums = [1,3,2], target = [2,1,4]
Salida: 5
Explicación:
Realizaremos las siguientes operaciones para que nums sea igual a target:
- Incrementar nums[0..0] en 1, nums = [2,3,2].
- Decrementar nums[1..1] en 1, nums = [2,2,2].
- Decrementar nums[1..1] en 1, nums = [2,1,2].
- Incrementar nums[2..2] en 1, nums = [2,1,3].
- Incrementar nums[2..2] en 1, nums = [2,1,4].

Restricciones:

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


Se te da un arreglo de números enteros positivos nums.
Alice y Bob están jugando un juego. En el juego, Alice puede elegir todos los números de un solo dígito o todos los números de dos dígitos de nums, y el resto de los números se le dan a Bob. Alice gana si la suma de sus números es estrictamente mayor que la suma de los números de Bob.
Devuelve true si Alice puede ganar este juego, de lo contrario, devuelve false.

Ejemplo 1:

Entrada: nums = [1,2,3,4,10]
Salida: false
Explicación:
Alice no puede ganar eligiendo ni números de un solo dígito ni de dos dígitos.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5,14]
Salida: true
Explicación:
Alice puede ganar eligiendo números de un solo dígito, que tienen una suma igual a 15.

Ejemplo 3:

Entrada: nums = [5,5,5,25]
Salida: true
Explicación:
Alice puede ganar eligiendo números de dos dígitos, que tienen una suma igual a 25.

Restricciones:

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

Se le proporciona una matriz de números enteros positivos nums.
Alice y Bob están jugando a un juego. En el juego, Alice puede elegir entre todos los números de un solo dígito o todos los números de dos dígitos de nums, y el resto de los números se le dan a Bob. Alice gana si la suma de sus números es estrictamente mayor que la suma de los números de Bob.
Devuelve verdadero si Alice puede ganar este juego; de lo contrario, devuelve falso.

Ejemplo 1:

Entrada: nums = [1,2,3,4,10]
Salida: false
Explicación:
Alicia no puede ganar eligiendo números de un solo dígito o de dos dígitos.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5,14]
Salida: true
Explicación:
Alicia puede ganar eligiendo números de un solo dígito cuya suma sea igual a 15.

Ejemplo 3:

Entrada: nums = [5,5,5,25]
Salida: true
Explicación:
Alicia puede ganar eligiendo números de dos dígitos cuya suma sea igual a 25.

Restricciones:

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

Se le proporciona una matriz de números enteros positivos nums.
Alice y Bob están jugando a un juego. En el juego, Alice puede elegir entre todos los números de un solo dígito o todos los números de dos dígitos de nums, y el resto de los números se le dan a Bob. Alice gana si la suma de sus números es estrictamente mayor que la suma de los números de Bob.
Devuelve verdadero si Alice puede ganar este juego; de lo contrario, devuelve falso.

Ejemplo 1:

Entrada: nums = [1,2,3,4,10]
Salida: falso
Explicación:
Alicia no puede ganar eligiendo números de un solo dígito o de dos dígitos.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5,14]
Salida: true
Explicación:
Alicia puede ganar eligiendo números de un solo dígito cuya suma sea igual a 15.

Ejemplo 3:

Entrada: nums = [5,5,5,25]
Salida: true
Explicación:
Alicia puede ganar eligiendo números de dos dígitos cuya suma sea igual a 25.

Restricciones:

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


Se te dan 2 enteros positivos l y r. Para cualquier número x, todos los divisores positivos de x excepto x se llaman los divisores propios de x.
Un número se llama especial si tiene exactamente 2 divisores propios. Por ejemplo:

El número 4 es especial porque tiene divisores propios 1 y 2.
El número 6 no es especial porque tiene divisores propios 1, 2, y 3.

Devuelve el conteo de números en el rango [l, r] que no son especiales.

Ejemplo 1:

Entrada: l = 5, r = 7
Salida: 3
Explicación:
No hay números especiales en el rango [5, 7].

Ejemplo 2:

Entrada: l = 4, r = 16
Salida: 11
Explicación:
Los números especiales en el rango [4, 16] son 4 y 9.

Restricciones:

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

Se le dan 2 números enteros positivos l y r. Para cualquier número x, todos los divisores positivos de x excepto x se denominan divisores propios de x.
Un número se denomina especial si tiene exactamente 2 divisores propios. Por ejemplo:

El número 4 es especial porque tiene divisores propios 1 y 2.
El número 6 no es especial porque tiene divisores propios 1, 2 y 3.

Devuelve el recuento de números en el rango [l, r] que no son especiales.

Ejemplo 1:

Entrada: l = 5, r = 7
Salida: 3
Explicación:
No hay números especiales en el rango [5, 7].

Ejemplo 2:

Entrada: l = 4, r = 16
Salida: 11
Explicación:
Los números especiales en el rango [4, 16] son 4 y 9.

Restricciones:

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