Se te da una cadena de texto date que representa una fecha del calendario gregoriano en el formato yyyy-mm-dd.
date puede ser escrita en su representación binaria obtenida al convertir el año, mes y día a sus representaciones binarias sin ceros a la izquierda y escribiéndolos en el formato año-mes-día.
Devuelve la representación binaria de date.

Ejemplo 1:

Entrada: date = "2080-02-29"
Salida: "100000100000-10-11101"
Explicación:
100000100000, 10 y 11101 son las representaciones binarias de 2080, 02 y 29 respectivamente.

Ejemplo 2:

Entrada: date = "1900-01-01"
Salida: "11101101100-1-1"
Explicación:
11101101100, 1 y 1 son las representaciones binarias de 1900, 1 y 1 respectivamente.

Restricciones:

date.length == 10
date[4] == date[7] == '-', y todos los otros date[i] son dígitos.
La entrada se genera de tal manera que date representa una fecha válida del calendario gregoriano entre el 1 de enero de 1900 y el 31 de diciembre de 2100 (ambos inclusive).

Se le proporciona una cadena de fecha que representa una fecha del calendario gregoriano en el formato aaaa-mm-dd.
La fecha se puede escribir en su representación binaria obtenida al convertir año, mes y día a sus representaciones binarias sin ceros iniciales y escribiéndolas en formato año-mes-día.
Devuelve la representación binaria de la fecha.

Ejemplo 1:

Entrada: fecha = "2080-02-29"
Salida: "100000100000-10-11101"
Explicación:
100000100000, 10 y 11101 son las representaciones binarias de 2080, 02 y 29 respectivamente.

Ejemplo 2:

Entrada: date = "1900-01-01"
Salida: "11101101100-1-1"
Explicación:
11101101100, 1 y 1 son las representaciones binarias de 1900, 1 y 1 respectivamente.

Restricciones:

date.length == 10
date[4] == date[7] == '-', y todas las demás fechas[i] son dígitos.
La entrada se genera de modo que la fecha represente una fecha válida del calendario gregoriano entre el 1 de enero de 1900 y el 31 de diciembre de 2100 (ambos inclusive).


Te dan un array de enteros llamado start y un entero d, que representan n intervalos [start[i], start[i] + d].
Debes elegir n enteros donde el i-ésimo entero debe pertenecer al i-ésimo intervalo. La puntuación de los enteros elegidos se define como la mínima diferencia absoluta entre cualquiera de los dos enteros que se han escogido.
Devuelve la puntuación máxima posible de los enteros elegidos.

Ejemplo 1:

Entrada: start = [6,0,3], d = 2
Salida: 4
Explicación:
La puntuación máxima posible se puede obtener eligiendo los números: 8, 0, y 4. La puntuación de estos enteros elegidos es min(|8 - 0|, |8 - 4|, |0 - 4|) que es igual a 4.

Ejemplo 2:

Entrada: start = [2,6,13,13], d = 5
Salida: 5
Explicación:
La puntuación máxima posible se puede obtener eligiendo los números: 2, 7, 13, y 18. La puntuación de estos enteros elegidos es min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) que es igual a 5.

Restricciones:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Se le da una matriz de enteros start y un entero d, que representan n intervalos [start[i], start[i] + d].
Se le pide que elija n enteros donde el i^ésimo entero debe pertenecer al i^ésimo intervalo. La puntuación de los enteros elegidos se define como la diferencia absoluta mínima entre los dos enteros elegidos.
Devuelve la máxima puntuación posible de los enteros elegidos.

Ejemplo 1

Entrada: start = [6,0,3], d = 2
Salida: 4
Explicación:
La máxima puntuación posible se puede obtener eligiendo enteros: 8, 0 y 4. La puntuación de estos enteros elegidos es min(|8 - 0|, |8 - 4|, |0 - 4|) que es igual a 4.

Ejemplo 2:

Entrada: start = [2,6,13,13], d = 5
Salida: 5
Explicación:
La máxima puntuación posible se puede obtener eligiendo los enteros: 2, 7, 13 y 18. La puntuación de estos enteros elegidos es min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) que es igual a 5.

Restricciones:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


Tienes un array de enteros nums de longitud n.
Tu objetivo es comenzar en el índice 0 y alcanzar el índice n - 1. Solo puedes saltar a índices mayores que tu índice actual.
La puntuación para un salto del índice i al índice j se calcula como (j - i) * nums[i].
Devuelve la puntuación total máxima posible para cuando alcances el último índice.

Ejemplo 1:

Entrada: nums = [1,3,1,5]
Salida: 7
Explicación:
Primero, salta al índice 1 y luego salta al último índice. La puntuación final es 1 * 1 + 2 * 3 = 7.

Ejemplo 2:

Entrada: nums = [4,3,1,3,2]
Salida: 16
Explicación:
Salta directamente al último índice. La puntuación final es 4 * 4 = 16.

Restricciones:

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

Se le da una matriz de números enteros de longitud n. Su objetivo es comenzar en el índice 0 y llegar al índice n - 1. Solo puede saltar a índices mayores que su índice actual.
Tu objetivo es empezar en el índice 0 y llegar al índice n - 1. Solo puedes saltar a índices mayores que tu índice actual.
La puntuación de un salto del índice i al índice j se calcula como (j - i) * nums[i].
Devuelve la máxima puntuación total posible al llegar al último índice.

Ejemplo 1:

Entrada: nums = [1,3,1,5]
Salida: 7
Explicación:
Primero salta al índice 1 y luego salta al último índice. La puntuación final es 1 * 1 + 2 * 3 = 7.

Ejemplo 2:

Entrada: nums = [4,3,1,3,2]
Salida: 16
Explicación:
Salta directamente al último índice. La puntuación final es 4 * 4 = 16.

Restricciones:

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

Se le proporciona una matriz de números enteros nums de longitud n.
Su objetivo es comenzar en el índice 0 y alcanzar el índice n - 1. Solo puede saltar a índices mayores que su índice actual.
La puntuación para un salto del índice i al índice j se calcula como (j - i) * nums[i].
Devuelve la puntuación total máxima posible para el momento en que llega al último índice.

Ejemplo 1:

Entrada: nums = [1,3,1,5]
Salida: 7
Explicación:
Primero, salte al índice 1 y luego salte al último índice. La puntuación final es 1 * 1 + 2 * 3 = 7.

Ejemplo 2:

Entrada: nums = [4,3,1,3,2]
Salida: 16
Explicación:
Salte directamente al último índice. La puntuación final es 4 * 4 = 16.

Restricciones:

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


Hay un tablero de ajedrez de 50 x 50 con un caballo y algunos peones en él. Se te dan dos enteros kx y ky donde (kx, ky) denota la posición del caballo, y un arreglo 2D positions donde positions[i] = [x_i, y_i] denota la posición de los peones en el tablero de ajedrez.
Alice y Bob juegan un juego por turnos, donde Alice va primero. En cada turno de jugador:

El jugador selecciona un peón que aún existe en el tablero y lo captura con el caballo en el menor número de movimientos posible. Ten en cuenta que el jugador puede seleccionar cualquier peón, no necesariamente uno que pueda ser capturado en el menor número de movimientos.
En el proceso de capturar el peón seleccionado, el caballo puede pasar por otros peones sin capturarlos. Solo el peón seleccionado puede ser capturado en este turno.

Alice intenta maximizar la suma del número de movimientos realizados por ambos jugadores hasta que no queden más peones en el tablero, mientras que Bob intenta minimizarlos.
Devuelve el máximo número total de movimientos realizados durante el juego que Alice puede conseguir, asumiendo que ambos jugadores juegan de manera óptima.
Ten en cuenta que en un movimiento, un caballo de ajedrez tiene ocho posiciones posibles a las que puede moverse, como se ilustra a continuación. Cada movimiento es dos casillas en una dirección cardinal, luego una casilla en una dirección ortogonal.

Ejemplo 1:

Entrada: kx = 1, ky = 1, positions = [[0,0]]
Salida: 4
Explicación:

El caballo toma 4 movimientos para alcanzar el peón en (0, 0).

Ejemplo 2:

Entrada: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Salida: 8
Explicación:

Alice elige el peón en (2, 2) y lo captura en dos movimientos: (0, 2) -> (1, 4) -> (2, 2).
Bob elige el peón en (3, 3) y lo captura en dos movimientos: (2, 2) -> (4, 1) -> (3, 3).
Alice elige el peón en (1, 1) y lo captura en cuatro movimientos: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Ejemplo 3:

Entrada: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Salida: 3
Explicación:

Alice elige el peón en (2, 4) y lo captura en dos movimientos: (0, 0) -> (1, 2) -> (2, 4). Ten en cuenta que el peón en (1, 2) no es capturado.
Bob elige el peón en (1, 2) y lo captura en un movimiento: (2, 4) -> (1, 2).

Restricciones:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Todas las positions[i] son únicas.
La entrada se genera de tal manera que positions[i] != [kx, ky] para todos 0 <= i < positions.length.

Hay un tablero de ajedrez de 50 x 50 con un caballo y algunos peones en él. Se te dan dos enteros kx y ky donde (kx, ky) denota la posición del caballo, y un array 2D positions donde positions[i] = [x_i, y_i] denota la posición de los peones en el tablero de ajedrez.
Alice y Bob juegan un juego por turnos, donde Alice va primero. En cada turno de jugador:

El jugador selecciona un peón que aún existe en el tablero y lo captura con el caballo en el menor número de movimientos posible. Ten en cuenta que el jugador puede seleccionar cualquier peón, no necesariamente uno que pueda ser capturado en el menor número de movimientos.
En el proceso de capturar el peón seleccionado, el caballo puede pasar por otros peones sin capturarlos. Solo el peón seleccionado puede ser capturado en este turno.

Alice intenta maximizar la suma del número de movimientos realizados por ambos jugadores hasta que no queden más peones en el tablero, mientras que Bob intenta minimizarlos.
Devuelve el máximo número total de movimientos realizados durante el juego que Alice puede conseguir, asumiendo que ambos jugadores juegan de manera óptima.
Ten en cuenta que en un movimiento, un caballo de ajedrez tiene ocho posiciones posibles a las que puede moverse, como se ilustra a continuación. Cada movimiento es dos casillas en una dirección cardinal, luego una casilla en una dirección ortogonal.

Ejemplo 1:

Entrada: kx = 1, ky = 1, positions = [[0,0]]
Salida: 4
Explicación:

El caballo toma 4 movimientos para alcanzar el peón en (0, 0).

Ejemplo 2:

Entrada: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Salida: 8
Explicación:

Alice elige el peón en (2, 2) y lo captura en dos movimientos: (0, 2) -> (1, 4) -> (2, 2).
Bob elige el peón en (3, 3) y lo captura en dos movimientos: (2, 2) -> (4, 1) -> (3, 3).
Alice elige el peón en (1, 1) y lo captura en cuatro movimientos: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Ejemplo 3:

Input: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Output: 3
Explicación:

Alice elige el peón en (2, 4) y lo captura en dos movimientos: (0, 0) -> (1, 2) -> (2, 4). Ten en cuenta que el peón en (1, 2) no es capturado.
Bob elige el peón en (1, 2) y lo captura en un movimiento: (2, 4) -> (1, 2).

Restricciones:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Todas las positions[i] son únicas.
La entrada se genera de tal manera que positions[i] != [kx, ky] para todos 0 <= i < positions.length.

Hay un tablero de ajedrez de 50 x 50 con un caballo y algunos peones sobre él. Se le dan dos números enteros kx y ky donde (kx, ky) denota la posición del caballo y una matriz 2D posiciones donde posiciones[i] = [x_i, y_i] denota la posición de los peones en el tablero de ajedrez.
Alice y Bob juegan un juego por turnos, donde Alice empieza primero. En el turno de cada jugador:

El jugador selecciona un peón que aún exista en el tablero y lo captura con el caballo en la menor cantidad de movimientos posible. Tenga en cuenta que el jugador puede seleccionar cualquier peón, puede que no sea uno que pueda capturarse en la menor cantidad de movimientos.
En el proceso de capturar el peón seleccionado, el caballo puede pasar otros peones sin capturarlos. Solo el peón seleccionado puede ser capturado en este turno.

Alice está tratando de maximizar la suma de la cantidad de movimientos realizados por ambos jugadores hasta que no haya más peones en el tablero, mientras que Bob intenta minimizarlos. Devuelve el número total máximo de movimientos que Alice puede realizar durante el juego, suponiendo que ambos jugadores juegan de manera óptima.
Ten en cuenta que en un movimiento, un caballo de ajedrez tiene ocho posiciones posibles a las que puede moverse, como se ilustra a continuación. Cada movimiento son dos celdas en una dirección cardinal, luego una celda en una dirección ortogonal.

Ejemplo 1:

Entrada: kx = 1, ky = 1, positions = [[0,0]]
Salida: 4
Explicación:

El caballo tarda 4 movimientos en alcanzar el peón en (0, 0).

Ejemplo 2:

Entrada: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Salida: 8
Explicación:

Alice toma el peón en (2, 2) y lo captura en dos movimientos: (0, 2) -> (1, 4) -> (2, 2).
Bob toma el peón en (3, 3) y lo captura en dos movimientos: (2, 2) -> (4, 1) -> (3, 3).
Alice toma el peón en (1, 1) y lo captura en cuatro movimientos: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Ejemplo 3:

Entrada: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Salida: 3
Explicación:

Alice toma el peón en (2, 4) y lo captura en dos movimientos: (0, 0) -> (1, 2) -> (2, 4). Nótese que el peón en (1, 2) no es capturado.
Bob toma el peón en (1, 2) y lo captura en un movimiento: (2, 4) -> (1, 2).

Restricciones:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Todas las positions[i] son únicas.
La entrada se genera de modo que positions[i] != [kx, ky] para todos los 0 <= i < positions.length.


Se le da un array de enteros a de tamaño 4 y otro array de enteros b de tamaño al menos 4.
Tienes que elegir 4 índices i_0, i_1, i_2, y i_3 de la matriz b de tal manera que i_0 < i_1 < i_2 < i_3. Tu puntuación será igual al valor a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Devuelve la puntuación máxima que puede alcanzar.

Ejemplo 1:

Entrada: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Salida: 26
Explicación:
Podemos elegir los índices 0, 1, 2 y 5. La puntuación será 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Ejemplo 2:

Entrada: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Salida: -1
Explicación:
Podemos elegir los índices 0, 1, 3 y 4. La puntuación será (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Restricciones:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Se te da un arreglo de enteros a de tamaño 4 y otro arreglo de enteros b de tamaño al menos 4.
Necesitas elegir 4 índices i_0, i_1, i_2, e i_3 del arreglo b tales que i_0 < i_1 < i_2 < i_3. Tu puntuación será igual al valor a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Devuelve la puntuación máxima que puedas lograr.

Ejemplo 1:

Entrada: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Salida: 26
Explicación:
Podemos elegir los índices 0, 1, 2 y 5. La puntuación será 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Ejemplo 2:

Entrada: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Salida: -1
Explicación:
Podemos elegir los índices 0, 1, 3 y 4. La puntuación será (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Restricciones:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Se le proporciona una matriz de números enteros a de tamaño 4 y otra matriz de números enteros b de tamaño al menos 4.
Debe elegir 4 índices i_0, i_1, i_2 e i_3 de la matriz b de modo que i_0 < i_1 < i_2 < i_3. Su puntaje será igual al valor a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Devuelva el puntaje máximo que puede lograr.

Ejemplo 1:

Entrada: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Salida: 26
Explicación:
Podemos elegir los índices 0, 1, 2 y 5. La puntuación será 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Ejemplo 2:

Entrada: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Salida: -1
Explicación:
Podemos elegir los índices 0, 1, 3 y 4. La puntuación será (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Restricciones:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


Se te da un arreglo de cadenas words y una cadena target.
Una cadena x se llama válida si x es un prefijo de cualquier cadena en words.
Devuelve el número mínimo de cadenas válidas que se pueden concatenar para formar target. Si no es posible formar target, devuelve -1.

Ejemplo 1:

Entrada: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Salida: 3
Explicación:
La cadena objetivo puede formarse concatenando:

Prefijo de longitud 2 de words[1], es decir, "aa".
Prefijo de longitud 3 de words[2], es decir, "bcd".
Prefijo de longitud 3 de words[0], es decir, "abc".

Ejemplo 2:

Entrada: words = ["abababab","ab"], target = "ababaababa"
Salida: 2
Explicación:
La cadena objetivo puede formarse concatenando:

Prefijo de longitud 5 de words[0], es decir, "ababa".
Prefijo de longitud 5 de words[0], es decir, "ababa".

Ejemplo 3:

Entrada: words = ["abcdef"], target = "xyz"
Salida: -1

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
La entrada se genera de tal manera que sum(words[i].length) <= 10^5.
words[i] consiste solo en letras minúsculas del alfabeto inglés.
1 <= target.length <= 5 * 10^3
target consiste solo en letras minúsculas del alfabeto inglés.

Se le proporciona una matriz de cadenas de palabras y una cadena de destino.
Una cadena x se considera válida si x es un prefijo de cualquier cadena en palabras.
Devuelve la cantidad mínima de cadenas válidas que se pueden concatenar para formar el destino. Si no es posible formar el destino, devuelve -1.

Ejemplo 1:

Entrada: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Salida: 3
Explicación:
La cadena de destino se puede formar concatenando:

Prefijo de longitud 2 de palabras[1], es decir, "aa".
Prefijo de longitud 3 de palabras[2], es decir, "bcd".
Prefijo de longitud 3 de palabras[0], es decir, "abc".

Ejemplo 2:

Entrada: words = ["abababab","ab"], target = "ababaababa"
Salida: 2
Explicación:
La cadena de destino se puede formar concatenando:

Prefijo de longitud 5 de palabras[0], es decir, "ababa".
Prefijo de longitud 5 de palabras[0], es decir, "ababa".

Ejemplo 3:

Entrada: words = ["abcdef"], target = "xyz"
Salida: -1

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
La entrada se genera de modo que sum(words[i].length) <= 10^5.
words[i]  consta únicamente de letras minúsculas en inglés.
1 <= target.length <= 5 * 10^3
destino consta únicamente de letras minúsculas en inglés.

Se te da un arreglo de cadenas de caracteres words y una cadena target.
Una cadena x se considera válida si x es un prefijo de cualquier cadena en words.
Devuelve la cantidad mínima de cadenas válidas que se pueden concatenar para formar target. Si no es posible formar target, devuelve -1.

Ejemplo 1:

Entrada: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Salida: 3
Explicación:
La cadena de destino se puede formar concatenando:

Prefijo de longitud 2 de words[1], es decir, "aa".
Prefijo de longitud 3 de words[2], es decir, "bcd".
Prefijo de longitud 3 de words[0], es decir, "abc".

Ejemplo 2:

Entrada: words = ["abababab","ab"], target = "ababaababa"
Salida: 2
Explicación:
La cadena de destino se puede formar concatenando:

Prefijo de longitud 5 de words[0], es decir, "ababa".
Prefijo de longitud 5 de words[0], es decir, "ababa".

Ejemplo 3:

Entrada: words = ["abcdef"], target = "xyz"
Salida: -1

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
La entrada se genera de tal manera que la suma(words[i].length) <= 10^5.
words[i] consiste solo en letras minúsculas del alfabeto inglés.
1 <= target.length <= 5 * 10^3
target consiste solo en letras minúsculas del alfabeto inglés.


Dado un array de enteros `nums` de longitud `n` y un entero positivo `k`.
La potencia de un array se define como:

Su elemento máximo si todos sus elementos son consecutivos y están ordenados en orden ascendente.
-1 de lo contrario.

Necesitas encontrar la potencia de todos los subarrays de `nums` de tamaño `k`.
Devuelve un array de enteros `results` de tamaño `n - k + 1`, donde `results[i]` es la potencia de `nums[i..(i + k - 1)]`.

Ejemplo 1:

Entrada: nums = [1,2,3,4,3,2,5], k = 3
Salida: [3,4,-1,-1,-1]
Explicación:
Hay 5 subarrays de `nums` de tamaño 3:

[1, 2, 3] con el elemento máximo 3.
[2, 3, 4] con el elemento máximo 4.
[3, 4, 3] cuyos elementos no son consecutivos.
[4, 3, 2] cuyos elementos no están ordenados.
[3, 2, 5] cuyos elementos no son consecutivos.

Ejemplo 2:

Entrada: nums = [2,2,2,2,2], k = 4
Salida: [-1,-1]

Ejemplo 3:

Entrada: nums = [3,2,3,2,3,2], k = 2
Salida: [-1,3,-1,3,-1]

Restricciones:

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

Se le proporciona una matriz de números enteros nums de longitud n y un número entero positivo k.
La potencia de una matriz se define como:

Su elemento máximo si todos sus elementos son consecutivos y están ordenados en orden ascendente.
-1 en caso contrario.

Debe encontrar la potencia de todas las submatrices de nums de tamaño k.
Devuelva una matriz de números enteros results de tamaño n - k + 1, donde results[i] es la potencia de nums[i..(i + k - 1)].

Ejemplo 1:

Entrada: nums = [1,2,3,4,3,2,5], k = 3
Salida: [3,4,-1,-1,-1]
Explicación:
Hay 5 submatrices de nums de tamaño 3:

[1, 2, 3] con el elemento máximo 3.
[2, 3, 4] con el elemento máximo 4.
[3, 4, 3] cuyos elementos no son consecutivos.
[4, 3, 2] cuyos elementos no están ordenados.
[3, 2, 5] cuyos elementos no son consecutivos.

Ejemplo 2:

Entrada: nums = [2,2,2,2,2], k = 4
Salida: [-1,-1]

Ejemplo 3:

Entrada: nums = [3,2,3,2,3,2], k = 2
Salida: [-1,3,-1,3,-1]

Restricciones:

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

Se le da una matriz de números enteros de longitud n y un número entero positivo k.
La potencia de una matriz se define como:

Su elemento máximo si todos sus elementos son consecutivos y están ordenados en orden ascendente.
-1 en caso contrario.

Necesita encontrar la potencia de todas las submatrices de números de tamaño k.
Devuelve los resultados de una matriz de enteros de tamaño n - k + 1, donde results[i] es la potencia de nums[i.. (i + k - 1)].

Ejemplo 1:

Entrada: nums = [1,2,3,4,3,2,5], k = 3
Salida: [3,4,-1,-1,-1]
Explicación:
Hay 5 subarrays de nums de tamaño 3:

[1, 2, 3] con el elemento máximo 3.
[2, 3, 4] con el elemento máximo 4.
[3, 4, 3] cuyos elementos no son consecutivos.
[4, 3, 2] cuyos elementos no están ordenados.
[3, 2, 5] cuyos elementos no son consecutivos.

Ejemplo 2:

Entrada: nums = [2,2,2,2,2], k = 4
Salida: [-1,-1]

Ejemplo 3:

Entrada: nums = [3,2,3,2,3,2], k = 2
Salida: [-1,3,-1,3,-1]

Restricciones:

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


Se le proporciona una matriz 2D de m x n que representa un tablero de ajedrez, donde board[i][j] representa el valor de la celda (i, j).
Las torres en la misma fila o columna se atacan entre sí. Debe colocar tres torres en el tablero de ajedrez de manera que no se ataquen entre sí.
Devuelva la suma máxima de los valores de las celdas en las que se colocan las torres.

Ejemplo 1:

Entrada: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Salida: 4
Explicación:

Podemos colocar las torres en las celdas (0, 2), (1, 3) y (2, 1) para una suma de 1 + 1 + 2 = 4.

Ejemplo 2:

Entrada: board = [[1,2,3],[4,5,6],[7,8,9]]
Salida: 15
Explicación:
Podemos colocar las torres en las celdas (0, 0), (1, 1) y (2, 2) para una suma de 1 + 5 + 9 = 15.

Ejemplo 3:

Entrada: board = [[1,1,1],[1,1,1],[1,1,1]]
Resultado: 3
Explicación:
Podemos colocar las torres en las celdas (0, 2), (1, 1) y (2, 0) para una suma de 1 + 1 + 1 = 3.

Restricciones:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Tienes un tablero de ajedrez 2D de m x n representado por un array, donde board[i][j] representa el valor de la celda (i, j). Las torres en la misma fila o columna se atacan entre sí. Necesitas colocar tres torres en el tablero de ajedrez de manera que no se ataquen entre ellas. Devuelve la suma máxima de los valores de las celdas en las que se colocan las torres.

Ejemplo 1:

Entrada: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Salida: 4
Explicación:

Podemos colocar las torres en las celdas (0, 2), (1, 3) y (2, 1) para una suma de 1 + 1 + 2 = 4.

Ejemplo 2:

Entrada: board = [[1,2,3],[4,5,6],[7,8,9]]
Salida: 15
Explicación:
Podemos colocar las torres en las celdas (0, 0), (1, 1) y (2, 2) para una suma de 1 + 5 + 9 = 15.

Ejemplo 3:

Entrada: board = [[1,1,1],[1,1,1],[1,1,1]]
Salida: 3
Explicación:
Podemos colocar las torres en las celdas (0, 2), (1, 1) y (2, 0) para una suma de 1 + 1 + 1 = 3.

Restricciones:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Se le da un tablero de matriz 2D de m x n que representa un tablero de ajedrez, donde tablero[i][j] representa el valor de la celda (i, j).
Las torres de la misma fila o columna se atacan entre sí. Tienes que colocar tres torres en el tablero de ajedrez de forma que las torres no se ataquen entre sí.
Devuelve la suma máxima de los valores de las celdas en las que están colocadas las torres.

Ejemplo 1. Tablero

Entrada: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Salida: 4
Explicación:

Podemos colocar las torres en las casillas (0, 2), (1, 3) y (2, 1) para una suma de 1 + 1 + 2 = 4.

Ejemplo 2:

Entrada: board = [[1,2,3],[4,5,6],[7,8,9]]
Salida: 15
Explicación:
Podemos colocar las torres en las casillas (0, 0), (1, 1) y (2, 2) para una suma de 1 + 5 + 9 = 15.

Ejemplo 3:

Entrada: board = [[1,1,1],[1,1,1],[1,1,1]]
Salida: 3
Explicación:
Podemos colocar las torres en las casillas (0, 2), (1, 1) y (2, 0) para una suma de 1 + 1 + 1 = 3.

Restricciones:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


Se le proporcionan tres números enteros positivos num1, num2 y num3.
La clave de num1, num2 y num3 se define como un número de cuatro dígitos de modo que:

Inicialmente, si cualquier número tiene menos de cuatro dígitos, se rellena con ceros a la izquierda.
El dígito i^ésimo (1 <= i <= 4) de la clave se genera tomando el dígito más pequeño entre los dígitos i^ésimos de num1, num2 y num3.

Devuelve la clave de los tres números sin ceros a la izquierda (si los hay).

Ejemplo 1:

Entrada: num1 = 1, num2 = 10, num3 = 1000
Salida: 0
Explicación:
Al rellenar, num1 se convierte en "0001", num2 se convierte en "0010" y num3 sigue siendo "1000".

El primer dígito de la clave es min(0, 0, 1).
El segundo dígito de la clave es min(0, 0, 0).
El tercer dígito de la clave es min(0, 1, 0).
El cuarto dígito de la clave es min(1, 0, 0).

Por lo tanto, la clave es "0000", es decir, 0.

Ejemplo 2:

Entrada: num1 = 987, num2 = 879, num3 = 798
Salida: 777

Ejemplo 3:

Entrada: num1 = 1, num2 = 2, num3 = 3
Salida: 1

Restricciones:

1 <= num1, num2, num3 <= 9999

Se te dan tres números enteros positivos num1, num2 y num3.
La clave de num1, num2 y num3 se define como un número de cuatro dígitos tal que:

Inicialmente, si algún número tiene menos de cuatro dígitos, se completa con ceros a la izquierda.
El i-ésimo dígito (1 <= i <= 4) de la clave se genera tomando el dígito más pequeño entre los i-ésimos dígitos de num1, num2 y num3.

Devuelve la clave de los tres números sin ceros a la izquierda (si los hay).

Ejemplo 1:

Entrada: num1 = 1, num2 = 10, num3 = 1000
Salida: 0
Explicación:
Al completar, num1 se convierte en "0001", num2 se convierte en "0010" y num3 sigue siendo "1000".

El 1^er dígito de la clave es min(0, 0, 1).
El 2^o dígito de la clave es min(0, 0, 0).
El 3^er dígito de la clave es min(0, 1, 0).
El 4^o dígito de la clave es min(1, 0, 0).

Por lo tanto, la clave es "0000", es decir, 0.

Ejemplo 2:

Entrada: num1 = 987, num2 = 879, num3 = 798
Salida: 777

Ejemplo 3:

Entrada: num1 = 1, num2 = 2, num3 = 3
Salida: 1

Condiciones:

1 <= num1, num2, num3 <= 9999


Se te da una cadena s de longitud n y un entero k, donde n es un múltiplo de k. Tu tarea es transformar la cadena s en una nueva cadena llamada resultado, que tiene una longitud de n / k.
Primero, divide s en n / k subcadenas, cada una con una longitud de k. Luego, inicializa resultado como una cadena vacía.
Para cada subcadena en orden desde el principio:

El valor hash de un carácter es el índice de ese carácter en el alfabeto inglés (por ejemplo, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Calcula la suma de todos los valores hash de los caracteres en la subcadena.
Encuentra el residuo de esta suma cuando se divide por 26, lo cual se llama hashedChar.
Identifica el carácter en el alfabeto inglés en minúsculas que corresponde a hashedChar.
Añade ese carácter al final de resultado.

Devuelve resultado.

Ejemplo 1:

Entrada: s = "abcd", k = 2
Salida: "bf"
Explicación:
Primera subcadena: "ab", 0 + 1 = 1, 1 % 26 = 1, resultado[0] = 'b'.
Segunda subcadena: "cd", 2 + 3 = 5, 5 % 26 = 5, resultado[1] = 'f'.

Ejemplo 2:

Entrada: s = "mxz", k = 3
Salida: "i"
Explicación:
La única subcadena: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, resultado[0] = 'i'.

Restricciones:

1 <= k <= 100
k <= s.length <= 1000
s.length es divisible por k.
s consiste solo de letras minúsculas del alfabeto inglés.

Se le proporciona una cadena s de longitud n y un entero k, donde n es un múltiplo de k. Su tarea es convertir la cadena s en una nueva cadena llamada result, que tiene una longitud de n / k.
Primero, divida s en n / k subcadenas, cada una con una longitud de k. Luego, inicialice result como una cadena vacía.
Para cada subcadena en orden desde el principio:

El valor hash de un carácter es el índice de ese carácter en el alfabeto inglés (p. ej., 'a' → 0, 'b' → 1, ..., 'z' → 25).
Calcule la suma de todos los valores hash de los caracteres en la subcadena.
Encuentre el resto de esta suma cuando se divide por 26, que se llama hashedChar.
Identifique el carácter en el alfabeto inglés en minúsculas que corresponde a hashedChar.
Agregue ese carácter al final de result.

Devuelva result.

Ejemplo 1:

Entrada: s = "abcd", k = 2
Salida: "bf"
Explicación:
Primera subcadena: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Segunda subcadena: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Ejemplo 2:

Entrada: s = "mxz", k = 3
Salida: "i"
Explicación:
La única subcadena: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

Restricciones:

1 <= k <= 100
k <= s.length <= 1000
s.length es divisible por k.
s consta únicamente de letras minúsculas del alfabeto inglés.


Se le proporcionan dos números enteros positivos n y k.
Un número entero x se denomina k-palíndromo si:

x es un palíndromo.
x es divisible por k.

Un número entero se denomina bueno si sus dígitos se pueden reorganizar para formar un número entero k-palíndromo. Por ejemplo, para k = 2, 2020 se puede reorganizar para formar el número entero k-palíndromo 2002, mientras que 1010 no se puede reorganizar para formar un número entero k-palíndromo.
Devuelve el recuento de números enteros buenos que contienen n dígitos.
Tenga en cuenta que ningún número entero debe tener ceros a la izquierda, ni antes ni después de la reorganización. Por ejemplo, 1010 no se puede reorganizar para formar 101.

Ejemplo 1:

Entrada: n = 3, k = 5
Salida: 27
Explicación:
Algunos de los buenos números enteros son:

551 porque se puede reorganizar para formar 515.
525 porque ya es k-palindrómico.

Ejemplo 2:

Entrada: n = 1, k = 4
Salida: 2
Explicación:
Los dos buenos números enteros son 4 y 8.

Ejemplo 3:

Entrada: n = 5, k = 6
Salida: 2468

Restricciones:

1 <= n <= 10
1 <= k <= 9

Se te dan dos enteros positivos n y k.
Un entero x se llama k-palindrómico si:

x es un palíndromo.
x es divisible por k.

Un entero se llama bueno si sus dígitos pueden ser reorganizados para formar un entero k-palindrómico. Por ejemplo, para k = 2, 2020 puede ser reorganizado para formar el entero k-palindrómico 2002, mientras que 1010 no puede ser reorganizado para formar un entero k-palindrómico.
Devuelve el conteo de enteros buenos que contienen n dígitos.
Nota que ningún entero debe tener ceros a la izquierda, ni antes ni después de la reorganización. Por ejemplo, 1010 no puede ser reorganizado para formar 101.

Ejemplo 1:

Entrada: n = 3, k = 5
Salida: 27
Explicación:
Algunos de los enteros buenos son:

551 porque puede ser reorganizado para formar 515.
525 porque ya es k-palindrómico.

Ejemplo 2:

Entrada: n = 1, k = 4
Salida: 2
Explicación:
Los dos enteros buenos son 4 y 8.

Ejemplo 3:

Entrada: n = 5, k = 6
Salida: 2468

Restricciones:

1 <= n <= 10
1 <= k <= 9


Tienes un poder entero y dos conjuntos enteros daño y salud, ambos de longitud n.
Bob tiene n enemigos, donde el enemigo i le hará a Bob daño[i] puntos de daño por segundo mientras estén vivos (por ejemplo, salud[i] > 0).
Cada segundo, después de que los enemigos infligen daño a Bob, él elige a uno de los enemigos que aún está vivo y le causa poder puntos de daño.
Determina la cantidad mínima total de puntos de daño que se le harán a Bob antes de que todos los n enemigos estén muertos.

Ejemplo 1:

Entrada: poder = 4, daño = [1,2,3,4], salud = [4,5,6,8]
Salida: 39
Explicación:

Ataca al enemigo 3 en los dos primeros segundos, después de lo cual el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 10 + 10 = 20 puntos.
Ataca al enemigo 2 en los siguientes dos segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es 6 + 6 = 12 puntos.
Ataca al enemigo 0 en el siguiente segundo, después de lo cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es 3 puntos.
Ataca al enemigo 1 en los siguientes dos segundos, después de lo cual el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es 2 + 2 = 4 puntos.

Ejemplo 2:

Entrada: poder = 1, daño = [1,1,1,1], salud = [1,2,3,4]
Salida: 20
Explicación:

Ataca al enemigo 0 en el primer segundo, después de lo cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es 4 puntos.
Ataca al enemigo 1 en los siguientes dos segundos, después de lo cual el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es 3 + 3 = 6 puntos.
Ataca al enemigo 2 en los siguientes tres segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es 2 + 2 + 2 = 6 puntos.
Ataca al enemigo 3 en los siguientes cuatro segundos, después de lo cual el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 1 + 1 + 1 + 1 = 4 puntos.

Ejemplo 3:

Entrada: poder = 8, daño = [40], salud = [59]
Salida: 320

Restricciones:

1 <= poder <= 10^4
1 <= n == daño.length == salud.length <= 10^5
1 <= daño[i], salud[i] <= 10^4

Se le da una potencia entera y dos matrices enteras de daño y salud, ambas de longitud n.
Bob tiene n enemigos, donde el enemigo i infligirá a Bob puntos de daño[i] por segundo mientras estén vivos (es decir, salud[i] > 0).
Cada segundo, después de que los enemigos inflijan daño a Bob, éste elige uno de los enemigos que aún está vivo y le inflige puntos de daño de potencia.
Determina la cantidad total mínima de puntos de daño que se infligirán a Bob antes de que mueran todos los n enemigos.

Ejemplo 1:

Entrada: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Salida: 39
Explicación:

Ataca al enemigo 3 en los dos primeros segundos, tras los cuales el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 10 + 10 = 20 puntos.
Ataca al enemigo 2 en los siguientes dos segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es 6 + 6 = 12 puntos.
Ataca al enemigo 0 en el siguiente segundo, después de lo cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es de 3 puntos.
Ataca al enemigo 1 en los próximos dos segundos, después de lo cual el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es 2 + 2 = 4 puntos.

Ejemplo 2:

Entrada: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Salida: 20
Explicación:

Ataca al enemigo 0 en el primer segundo, tras el cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es de 4 puntos.
Ataca al enemigo 1 en los siguientes dos segundos, tras los cuales el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es de 3 + 3 = 6 puntos.
Ataca al enemigo 2 en los próximos tres segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es de 2 + 2 + 2 = 6 puntos.
Ataca al enemigo 3 en los próximos cuatro segundos, después de lo cual el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 1 + 1 + 1 + 1 = 4 puntos.

Ejemplo 3:

Entrada: power = 8, damage = [40], health = [59]
Salida: 320

Restricciones:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Tienes un poder entero y dos arreglos enteros damage y health, ambos de longitud n.
Bob tiene n enemigos, donde el enemigo i le hará a Bob damage[i] puntos de daño por segundo mientras estén vivos (es decir, health[i] > 0).
Cada segundo, después de que los enemigos infligen daño a Bob, él elige a uno de los enemigos que aún está vivo y le causa power puntos de daño.
Determina la cantidad mínima total de puntos de daño que se le harán a Bob antes de que todos los n enemigos estén muertos.

Ejemplo 1:

Entrada: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Salida: 39
Explicación:

Ataca al enemigo 3 en los dos primeros segundos, después de lo cual el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 10 + 10 = 20 puntos.
Ataca al enemigo 2 en los siguientes dos segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es 6 + 6 = 12 puntos.
Ataca al enemigo 0 en el siguiente segundo, después de lo cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es 3 puntos.
Ataca al enemigo 1 en los siguientes dos segundos, después de lo cual el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es 2 + 2 = 4 puntos.

Ejemplo 2:

Entrada: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Salida: 20
Explicación:

Ataca al enemigo 0 en el primer segundo, después de lo cual el enemigo 0 caerá, el número de puntos de daño infligidos a Bob es 4 puntos.
Ataca al enemigo 1 en los siguientes dos segundos, después de lo cual el enemigo 1 caerá, el número de puntos de daño infligidos a Bob es 3 + 3 = 6 puntos.
Ataca al enemigo 2 en los siguientes tres segundos, después de lo cual el enemigo 2 caerá, el número de puntos de daño infligidos a Bob es 2 + 2 + 2 = 6 puntos.
Ataca al enemigo 3 en los siguientes cuatro segundos, después de lo cual el enemigo 3 caerá, el número de puntos de daño infligidos a Bob es 1 + 1 + 1 + 1 = 4 puntos.

Ejemplo 3:

Entrada: power = 8, damage = [40], health = [59]
Salida: 320

Restricciones:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


Se te da una matriz binaria de tamaño m x n llamada grid y un entero health.
Comienzas en la esquina superior izquierda (0, 0) y te gustaría llegar a la esquina inferior derecha (m - 1, n - 1).
Puedes moverte hacia arriba, abajo, izquierda o derecha de una celda a otra celda adyacente mientras tu salud se mantenga positiva.
Las celdas (i, j) con grid[i][j] = 1 se consideran inseguras y reducen tu salud en 1.
Devuelve verdadero si puedes alcanzar la celda final con un valor de salud de 1 o más, y falso en caso contrario.

Ejemplo 1:

Entrada: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Salida: true
Explicación:
La celda final puede alcanzarse de manera segura caminando a lo largo de las celdas grises a continuación.

Ejemplo 2:

Entrada: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Salida: false
Explicación:
Se necesita un mínimo de 4 puntos de salud para llegar a la celda final de manera segura.

Ejemplo 3:

Entrada: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Salida: true
Explicación:
La celda final puede alcanzarse de manera segura caminando a lo largo de las celdas grises a continuación.

Cualquier camino que no pase por la celda (1, 1) es inseguro ya que tu salud caerá a 0 al llegar a la celda final.

Restricciones:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] es 0 o 1.

Se le da una rejilla de matriz binaria m x n y un entero de salud.
Empiezas en la esquina superior izquierda (0, 0) y quieres llegar a la esquina inferior derecha (m - 1, n - 1).
Puedes moverte hacia arriba, abajo, izquierda o derecha de una celda a otra adyacente siempre que tu salud siga siendo positiva.
Las celdas (i, j) con cuadrícula[i][j] = 1 se consideran inseguras y reducen tu salud en 1.
Devuelve verdadero si puedes alcanzar la celda final con un valor de salud de 1 o más, y falso en caso contrario.

Ejemplo 1:

Entrada: rejilla = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], salud = 1
Salida: true
Explicación:
Se puede llegar con seguridad a la celda final caminando por las celdas grises de abajo.

Ejemplo 2:

Entrada: cuadrícula = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], salud = 3
Salida: false
Explicación:
Se necesita un mínimo de 4 puntos de salud para llegar sano y salvo a la celda final.

Ejemplo 3:

Entrada: cuadrícula = [[1,1,1],[1,0,1],[1,1,1]], salud = 5
Salida: true
Explicación:
Se puede llegar a la celda final de forma segura caminando por las celdas grises de abajo.

Cualquier camino que no pase por la celda (1, 1) es inseguro ya que tu salud caerá a 0 al llegar a la celda final.

Restricciones:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] es 0 o 1.

Se le proporciona una cuadrícula de matriz binaria de m x n y un valor entero de salud.
Comienza en la esquina superior izquierda (0, 0) y le gustaría llegar a la esquina inferior derecha (m - 1, n - 1).
Puede moverse hacia arriba, hacia abajo, hacia la izquierda o hacia la derecha de una celda a otra celda adyacente siempre que su salud se mantenga positiva.
Las celdas (i, j) con grid[i][j] = 1 se consideran inseguras y reducen su salud en 1.
Devuelve true si puede llegar a la celda final con un valor de salud de 1 o más, y false en caso contrario.

Ejemplo 1:

Entrada: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Salida: true
Explicación:
Se puede llegar a la celda final de manera segura caminando por las celdas grises que se muestran a continuación.

Ejemplo 2:

Entrada: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Salida: false
Explicación:
Se necesita un mínimo de 4 puntos de salud para llegar a la celda final de forma segura.

Ejemplo 3:

Entrada: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Salida: true
Explicación:
Se puede llegar a la celda final de forma segura caminando por las celdas grises que se muestran a continuación.

Cualquier camino que no pase por la celda (1, 1) no es seguro, ya que su salud bajará a 0 al llegar a la celda final.

Restricciones:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] es 0 o 1.


Dado un array de enteros nums y un entero positivo k. El valor de una secuencia seq de tamaño 2 * x se define como:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Devuelve el valor máximo de cualquier subsecuencia de nums de tamaño 2 * k.

Ejemplo 1:

Entrada: nums = [2,6,7], k = 1
Salida: 5
Explicación:
La subsecuencia [2, 7] tiene el valor máximo de 2 XOR 7 = 5.

Ejemplo 2:

Entrada: nums = [4,2,5,6,7], k = 2
Salida: 2
Explicación:
La subsecuencia [4, 5, 6, 7] tiene el valor máximo de (4 OR 5) XOR (6 OR 7) = 2.

Restricciones:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Se le proporciona una matriz de números enteros nums y un entero positivo k.
El valor de una secuencia seq de tamaño 2 * x se define como:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Devuelve el valor máximo de cualquier subsecuencia de nums que tenga un tamaño de 2 * k.

Ejemplo 1:

Entrada: nums = [2,6,7], k = 1
Salida: 5
Explicación:
La subsecuencia [2, 7] tiene el valor máximo de 2 XOR 7 = 5.

Ejemplo 2:

Entrada: nums = [4,2,5,6,7], k = 2
Salida: 2
Explicación:
La subsecuencia [4, 5, 6, 7] tiene el valor máximo de (4 OR 5) XOR (6 OR 7) = 2.

Restricciones:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


Se le proporciona una matriz 2D de coordenadas de números enteros de longitud n y un número entero k, donde 0 <= k < n.
coordenadas[i] = [x_i, y_i] indica el punto (x_i, y_i) en un plano 2D.
Una ruta creciente de longitud m se define como una lista de puntos (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) tales que:

x_i < x_i + 1 e y_i < y_i + 1 para todo i donde 1 <= i < m.
(x_i, y_i) está en las coordenadas dadas para todo i donde 1 <= i <= m.

Devuelve la longitud máxima de una ruta creciente que contiene coordenadas[k].

Ejemplo 1:

Entrada: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Salida: 3
Explicación:
(0, 0), (2, 2), (5, 3) es la ruta creciente más larga que contiene (2, 2).

Ejemplo 2:

Entrada: coordinates = [[2,1],[7,0],[5,6]], k = 2
Salida: 2
Explicación:
(2, 1), (5, 6) es la ruta creciente más larga que contiene (5, 6).

Restricciones:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Todos los elementos en coordenadas son distintos.
0 <= k <= n - 1

Se te da un arreglo 2D de enteros coordinates de longitud n y un entero k, donde 0 <= k < n.
coordinates[i] = [x_i, y_i] indica el punto (x_i, y_i) en un plano 2D.
Un camino creciente de longitud m se define como una lista de puntos (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) tal que:

x_i < x_i + 1 y y_i < y_i + 1 para todo i donde 1 <= i < m.
(x_i, y_i) está en las coordenadas dadas para todo i donde 1 <= i <= m.

Devuelve la longitud máxima de un camino creciente que contiene coordinates[k].

Ejemplo 1:

Entrada: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Salida: 3
Explicación:
(0, 0), (2, 2), (5, 3) es el camino creciente más largo que contiene (2, 2).

Ejemplo 2:

Entrada: coordinates = [[2,1],[7,0],[5,6]], k = 2
Salida: 2
Explicación:
(2, 1), (5, 6) es el camino creciente más largo que contiene (5, 6).

Restricciones:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Todos los elementos en coordinates son distintos.
0 <= k <= n - 1

Se le proporciona una matriz 2D de coordinates de números enteros de longitud n y un número entero k, donde 0 <= k < n.
coordinates[i] = [x_i, y_i] indica el punto (x_i, y_i) en un plano 2D.
Una ruta creciente de longitud m se define como una lista de puntos (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) tales que:

x_i < x_i + 1 e y_i < y_i + 1 para todo i donde 1 <= i < m.
(x_i, y_i) está en las coordinates dadas para todo i donde 1 <= i <= m.

Devuelve la longitud máxima de una ruta creciente que contiene coordinates[k].

Ejemplo 1:

Entrada: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Salida: 3
Explicación:
(0, 0), (2, 2), (5, 3) es la ruta creciente más larga que contiene (2, 2).

Ejemplo 2:

Entrada: coordinates = [[2,1],[7,0],[5,6]], k = 2
Salida: 2
Explicación:
(2, 1), (5, 6) es la ruta creciente más larga que contiene (5, 6).

Restricciones:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Todos los elementos en coordinates son distintos.
0 <= k <= n - 1


Se le proporciona una matriz de cadenas message y una matriz de cadenas bannedWords.
Una matriz de palabras se considera spam si contiene al menos dos palabras que coincidan exactamente con cualquier palabra de bannedWords.
Devuelve true si la matriz message es spam y falso en caso contrario.

Ejemplo 1:

Entrada: message = ["hello", "world", "leetcode"], bannedWords = ["world", "hello"]
Salida: true
Explicación:
Las palabras "hello" y "world" de la matriz message aparecen en la matriz bannedWords.

Ejemplo 2:

Entrada: message = ["hello", "programming", "fun"], bannedWords = ["world", "programming", "leetcode"]
Salida: false
Explicación:
Solo aparece una palabra de la matriz message ("programming") en la matriz bannedWords.

Restricciones:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] y bannedWords[i] constan únicamente de letras minúsculas del alfabeto inglés.

Se le da un array de cadenas message y un array de cadenas bannedWords.
Un array de palabras se considera spam si hay al menos dos palabras en él que coincidan exactamente con cualquier palabra de bannedWords.
Devuelve true si el array mensaje es spam, y false en caso contrario.

Ejemplo 1

Entrada: mensaje = ["hola", "mundo", "leetcode"], palabrasProhibidas = ["mundo", "hola"]
Salida: verdadero
Explicación:
Las palabras "hola" y "mundo" de la matriz de mensajes aparecen en la matriz de palabrasProhibidas.

Ejemplo 2:

Entrada: mensaje = ["hola", "programación", "diversión"], palabrasProhibidas = ["mundo", "programación", "leetcode"]
Salida: falso
Explicación:
Solo una palabra de la matriz de mensajes ("programación") aparece en la matriz palabrasProhibidas.

Restricciones:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] y bannedWords[i] constan sólo de letras minúsculas inglesas.

Se te da un array de cadenas message y un array de cadenas bannedWords.
Un array de palabras se considera spam si hay al menos dos palabras en él que coincidan exactamente con alguna palabra en bannedWords.
Devuelve true si el array message es spam, y false en caso contrario.

Ejemplo 1:

Input: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Output: true
Explicación:
Las palabras "hello" y "world" del array message aparecen ambas en el array bannedWords.

Ejemplo 2:

Input: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Output: false
Explicación:
Solo una palabra del array message ("programming") aparece en el array bannedWords.

Restricciones:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] y bannedWords[i] consisten solo de letras minúsculas en inglés.


Se le proporciona un entero mountainHeight que denota la altura de una montaña.
También se le proporciona una matriz de enteros workerTimes que representa el tiempo de trabajo de los trabajadores en segundos.
Los trabajadores trabajan simultáneamente para reducir la altura de la montaña. Para el trabajador i:

Para disminuir la altura de la montaña en x, se necesitan workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x segundos. Por ejemplo:

Para reducir la altura de la montaña en 1, se necesitan workerTimes[i] segundos.
Para reducir la altura de la montaña en 2, se necesitan workerTimes[i] + workerTimes[i] * 2 segundos, y así sucesivamente.

Devuelve un entero que representa la cantidad mínima de segundos que necesitan los trabajadores para hacer que la altura de la montaña sea 0.

Ejemplo 1:

Entrada: mountainHeight = 4, workerTimes = [2,1,1]
Salida: 3
Explicación:
Una forma de reducir la altura de la montaña a 0 es:

El trabajador 0 reduce la altura en 1, lo que hace que workerTimes[0] = 2 segundos.
El trabajador 1 reduce la altura en 2, lo que hace que workerTimes[1] + workerTimes[1] * 2 = 3 segundos.
El trabajador 2 reduce la altura en 1, lo que hace que workerTimes[2] = 1 segundo.

Como trabajan simultáneamente, el tiempo mínimo necesario es max(2, 3, 1) = 3 segundos.

Ejemplo 2:

Entrada: mountainHeight = 10, workerTimes = [3,2,2,4]
Salida: 12
Explicación:

El trabajador 0 reduce la altura en 2, lo que toma workerTimes[0] + workerTimes[0] * 2 = 9 segundos.
El trabajador 1 reduce la altura en 3, lo que toma workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 segundos.
El trabajador 2 reduce la altura en 3, lo que toma workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 segundos.
El trabajador 3 reduce la altura en 2, lo que toma workerTimes[3] + workerTimes[3] * 2 = 12 segundos.

La cantidad de segundos necesarios es max(9, 12, 12, 12) = 12 segundos.

Ejemplo 3:

Entrada: mountainHeight = 5, workerTimes = [1]
Salida: 15
Explicación:
En este ejemplo solo hay un trabajador, por lo que la respuesta es workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Restricciones:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Se te da un entero mountainHeight que representa la altura de una montaña.
También se te da un arreglo de enteros workerTimes que representa el tiempo de trabajo de los trabajadores en segundos.
Los trabajadores trabajan simultáneamente para reducir la altura de la montaña. Para el trabajador i:

Para disminuir la altura de la montaña en x, toma workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x segundos. Por ejemplo:

Para reducir la altura de la montaña en 1, toma workerTimes[i] segundos.
Para reducir la altura de la montaña en 2, toma workerTimes[i] + workerTimes[i] * 2 segundos, y así sucesivamente.

Devuelve un entero que representa el número mínimo de segundos requeridos para que los trabajadores reduzcan la altura de la montaña a 0.

Ejemplo 1:

Entrada: mountainHeight = 4, workerTimes = [2,1,1]
Salida: 3
Explicación:
Una forma en que la altura de la montaña puede reducirse a 0 es:

El trabajador 0 reduce la altura en 1, tomando workerTimes[0] = 2 segundos.
El trabajador 1 reduce la altura en 2, tomando workerTimes[1] + workerTimes[1] * 2 = 3 segundos.
El trabajador 2 reduce la altura en 1, tomando workerTimes[2] = 1 segundo.

Como trabajan simultáneamente, el tiempo mínimo necesario es max(2, 3, 1) = 3 segundos.

Ejemplo 2:

Entrada: mountainHeight = 10, workerTimes = [3,2,2,4]
Salida: 12
Explicación:

El trabajador 0 reduce la altura en 2, tomando workerTimes[0] + workerTimes[0] * 2 = 9 segundos.
El trabajador 1 reduce la altura en 3, tomando workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 segundos.
El trabajador 2 reduce la altura en 3, tomando workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 segundos.
El trabajador 3 reduce la altura en 2, tomando workerTimes[3] + workerTimes[3] * 2 = 12 segundos.

El número de segundos necesarios es max(9, 12, 12, 12) = 12 segundos.

Ejemplo 3:

Entrada: mountainHeight = 5, workerTimes = [1]
Salida: 15
Explicación:
Solo hay un trabajador en este ejemplo, por lo que la respuesta es workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Restricciones:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6


Se te dan dos cadenas word1 y word2.
Una cadena x es válida si x puede ser reorganizada para tener word2 como prefijo.
Devuelve el número total de subcadenas válidas de word1.

Ejemplo 1:

Entrada: word1 = "bcca", word2 = "abc"
Salida: 1
Explicación:
La única subcadena válida es "bcca" que puede ser reorganizada a "abcc" teniendo "abc" como prefijo.

Ejemplo 2:

Entrada: word1 = "abcabc", word2 = "abc"
Salida: 10
Explicación:
Todas las subcadenas excepto las subcadenas de tamaño 1 y tamaño 2 son válidas.

Ejemplo 3:

Entrada: word1 = "abcabc", word2 = "aaabc"
Salida: 0

Restricciones:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 y word2 consisten solo en letras minúsculas del alfabeto inglés.

Se le proporcionan dos cadenas, palabra1 y palabra2.
Una cadena x se considera válida si x se puede reorganizar para tener palabra2 como prefijo.
Devuelve el número total de subcadenas válidas de palabra1.

Ejemplo 1:

Entrada: word1 = "bcca", word2 = "abc"
Salida: 1
Explicación:
La única subcadena válida es "bcca", que se puede reorganizar en "abcc" con "abc" como prefijo.

Ejemplo 2:

Entrada: word1 = "abcabc", word2 = "abc"
Salida: 10
Explicación:
Todas las subcadenas, excepto las de tamaño 1 y 2, son válidas.

Ejemplo 3:

Entrada: word1 = "abcabc", word2 = "aaabc"
Salida: 0

Restricciones:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
palabra1 y palabra2 constan únicamente de letras minúsculas en inglés.

Se te dan dos cadenas word1 y word2.
Una cadena x se llama válida si x puede ser reorganizada para tener word2 como prefijo.
Devuelve el número total de subcadenas válidas de word1.

Ejemplo 1:

Entrada: word1 = "bcca", word2 = "abc"
Salida: 1
Explicación:
La única subcadena válida es "bcca" que puede ser reorganizada a "abcc" teniendo "abc" como prefijo.

Ejemplo 2:

Entrada: word1 = "abcabc", word2 = "abc"
Salida: 10
Explicación:
Todas las subcadenas excepto las subcadenas de tamaño 1 y tamaño 2 son válidas.

Ejemplo 3:

Entrada: word1 = "abcabc", word2 = "aaabc"
Salida: 0

Restricciones:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 y word2 consisten solo en letras minúsculas del alfabeto inglés.


Alice y Bob están jugando un juego. Inicialmente, Alice tiene una cadena word = "a". Se te da un entero positivo k. Ahora Bob le pedirá a Alice que realice la siguiente operación para siempre:
Genera una nueva cadena cambiando cada carácter en word a su siguiente carácter en el alfabeto inglés, y añádelo al final de la palabra original.

Por ejemplo, realizar la operación en "c" genera "cd" y realizar la operación en "zb" genera "zbac". Devuelve el valor del k-ésimo carácter en word, después de que se hayan hecho suficientes operaciones para que word tenga al menos k caracteres. Nota que el carácter 'z' puede cambiarse a 'a' en la operación.

Ejemplo 1:

Entrada: k = 5
Salida: "b"
Explicación:
Inicialmente, word = "a". Necesitamos realizar la operación tres veces:

La cadena generada es "b", word se convierte en "ab".
La cadena generada es "bc", word se convierte en "abbc".
La cadena generada es "bccd", word se convierte en "abbcbccd".

Ejemplo 2:

Entrada: k = 10
Salida: "c"

Restricciones:

1 <= k <= 500

Alice y Bob están jugando un juego. Inicialmente, Alice tiene una cadena palabra = "a".
Se le da un entero positivo k.
Ahora Bob le pedirá a Alice que realice la siguiente operación para siempre:

Generar una nueva cadena cambiando cada carácter en palabra por el siguiente carácter en el alfabeto inglés y agregarlo a la palabra original.

Por ejemplo, realizar la operación en "c" genera "cd" y realizar la operación en "zb" genera "zbac".
Devuelve el valor del k^ésimo carácter en palabra, después de que se hayan realizado suficientes operaciones para que palabra tenga al menos k caracteres.
Tenga en cuenta que el carácter 'z' se puede cambiar a 'a' en la operación.

Ejemplo 1:

Entrada: k = 5
Salida: "b"
Explicación:
Inicialmente, word = "a". Necesitamos realizar la operación tres veces:

La cadena generada es "b", palabra se convierte en "ab".
La cadena generada es "bc", palabra se convierte en "abbc".
La cadena generada es "bccd", la palabra se convierte en "abbcbccd".

Ejemplo 2:

Entrada: k = 10
Salida: "c"

Restricciones:

1 <= k <= 500

Alice y Bob están jugando a un juego. Inicialmente, Alice tiene una cadena de caracteres = "a".
Se le da un número entero positivo k.
Ahora Bob le pedirá a Alice que realice la siguiente operación para siempre:

Generar una nueva cadena cambiando cada carácter de palabra por su siguiente carácter en el alfabeto inglés, y añadirla a la palabra original.

Por ejemplo, realizar la operación en "c" genera "cd" y realizar la operación en "zb" genera "zbac".
Devuelve el valor del k^ésimo carácter de la palabra, después de que se hayan realizado suficientes operaciones para que la palabra tenga al menos k caracteres.
Tenga en cuenta que el carácter 'z' se puede cambiar a 'a' en la operación.

Ejemplo 1

Entrada: k = 5
Salida: "b"
Explicación:
Inicialmente, palabra = "a". Hay que hacer la operación tres veces:

La cadena generada es "b", la palabra se convierte en "ab".
La cadena generada es "bc", la palabra se convierte en "abbc".
La cadena generada es "bccd", la palabra se convierte en "abbcbccd".

Ejemplo 2

Entrada: k = 10
Salida: "c"

Restricciones:

1 <= k <= 500


Se te da una cadena de caracteres llamada word y un número entero no negativo k.
Devuelve el número total de subcadenas de word que contengan cada vocal ('a', 'e', 'i', 'o' y 'u') al menos una vez y exactamente k consonantes.

Ejemplo 1:

Entrada: word = "aeioqq", k = 1
Salida: 0
Explicación:
No hay subcadena con todas las vocales.

Ejemplo 2:

Entrada: word = "aeiou", k = 0
Salida: 1
Explicación:
La única subcadena con todas las vocales y cero consonantes es word[0..4], que es "aeiou".

Ejemplo 3:

Entrada: word = "ieaouqqieaouqq", k = 1
Salida: 3
Explicación:
Las subcadenas con todas las vocales y una consonante son:

word[0..5], que es "ieaouq".
word[6..11], que es "qieaou".
word[7..12], que es "ieaouq".

Restricciones:

5 <= word.length <= 250
word consiste solo en letras minúsculas en inglés.
0 <= k <= word.length - 5

Se le proporciona una cadena de caracteres word y un entero no negativo k.
Devuelve el número total de subcadenas de word que contienen todas las vocales ('a', 'e', 'i', 'o' y 'u') al menos una vez y exactamente k consonantes.

Ejemplo 1:

Entrada: word = "aeioqq", k = 1
Salida: 0
Explicación:
No existe ninguna subcadena con todas las vocales.

Ejemplo 2:

Entrada: word = "aeiou", k = 0
Salida: 1
Explicación:
La única subcadena con todas las vocales y cero consonantes es word[0..4], que es "aeiou".

Ejemplo 3:

Entrada: palabra = "ieaouqqieaouqq", k = 1
Salida: 3
Explicación:
Las subcadenas con todas las vocales y una consonante son:

palabra[0..5], que es "ieaouq".
palabra[6..11], que es "qieaou".
palabra[7..12], que es "ieaouq".

Restricciones:

5 <= word.length <= 250
palabra consta únicamente de letras minúsculas en inglés.
0 <= k <= word.length - 5


Se te da un array de enteros nums de tamaño 3.
Devuelve el número máximo posible cuya representación binaria se puede formar concatenando la representación binaria de todos los elementos en nums en algún orden.
Ten en cuenta que la representación binaria de cualquier número no contiene ceros a la izquierda.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 30
Explicación:
Concatena los números en el orden [3, 1, 2] para obtener el resultado "11110", que es la representación binaria de 30.

Ejemplo 2:

Entrada: nums = [2,8,16]
Salida: 1296
Explicación:
Concatena los números en el orden [2, 8, 16] para obtener el resultado "10100010000", que es la representación binaria de 1296.

Restricciones:

nums.length == 3
1 <= nums[i] <= 127

Se te da un arreglo de enteros llamado nums de tamaño 3.
Devuelve el número máximo posible cuya representación binaria se puede formar concatenando la representación binaria de todos los elementos en nums en algún orden.
Ten en cuenta que la representación binaria de cualquier número no contiene ceros a la izquierda.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 30
Explicación:
Concatena los números en el orden [3, 1, 2] para obtener el resultado "11110", que es la representación binaria de 30.

Ejemplo 2:

Entrada: nums = [2,8,16]
Salida: 1296
Explicación:
Concatena los números en el orden [2, 8, 16] para obtener el resultado "10100010000", que es la representación binaria de 1296.

Restricciones:

nums.length == 3
1 <= nums[i] <= 127

Se le proporciona una matriz de números enteros nums de tamaño 3.
Devuelva el número máximo posible cuya representación binaria se puede formar concatenando la representación binaria de todos los elementos en nums en algún orden.
Tenga en cuenta que la representación binaria de cualquier número no contiene ceros a la izquierda.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 30
Explicación:
Concatene los números en el orden [3, 1, 2] para obtener el resultado "11110", que es la representación binaria de 30.

Ejemplo 2:

Entrada: nums = [2,8,16]
Salida: 1296
Explicación:
Concatene los números en el orden [2, 8, 16] para obtener el resultado "10100010000", que es la representación binaria de 1296.

Restricciones:

nums.length == 3
1 <= nums[i] <= 127


Se te da un array de enteros nums de longitud n y un array de enteros queries.
Sea gcdPairs un array obtenido calculando el MCD de todos los pares posibles (nums[i], nums[j]), donde 0 <= i < j < n, y luego ordenando estos valores en orden ascendente.
Para cada consulta queries[i], necesitas encontrar el elemento en el índice queries[i] en gcdPairs.
Devuelve un array de enteros answer, donde answer[i] es el valor en gcdPairs[queries[i]] para cada consulta.
El término gcd(a, b) denota el máximo común divisor de a y b.

Ejemplo 1:

Input: nums = [2,3,4], queries = [0,2,2]
Output: [1,2,2]
Explicación:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Después de ordenar en orden ascendente, gcdPairs = [1, 1, 2].
Entonces, la respuesta es [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Ejemplo 2:

Input: nums = [4,4,2,1], queries = [5,3,1,0]
Output: [4,2,1,1]
Explicación:
gcdPairs ordenado en orden ascendente es [1, 1, 1, 2, 2, 4].

Ejemplo 3:

Input: nums = [2,2], queries = [0,0]
Output: [2,2]
Explicación:
gcdPairs = [2].

Restricciones:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Se le proporciona una matriz de enteros nums de longitud n y una matriz de enteros queries.
Sea gcdPairs una matriz obtenida calculando el MCD de todos los pares posibles (nums[i], nums[j]), donde 0 <= i < j < n, y luego ordenando estos valores en orden ascendente.
Para cada consulta queries[i], debe encontrar el elemento en el índice queries[i] en gcdPairs.
Devuelva una matriz de enteros answer, donde answer[i] es el valor en gcdPairs[queries[i]] para cada consulta.
El término gcd(a, b) denota el máximo común divisor de a y b.

Ejemplo 1:

Entrada: nums = [2,3,4], queries = [0,2,2]
Salida: [1,2,2]
Explicación:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Después de ordenar en orden ascendente, gcdPairs = [1, 1, 2].
Por lo tanto, la respuesta es [gcdPairs[consultas[0]], gcdPairs[consultas[1]], gcdPairs[consultas[2]]] = [1, 2, 2].

Ejemplo 2:

Entrada: nums = [4,4,2,1], queries = [5,3,1,0]
Salida: [4,2,1,1]
Explicación:
gcdPairs ordenado en orden ascendente es [1, 1, 1, 2, 2, 4].

Ejemplo 3:

Entrada: nums = [2,2], queries = [0,0]
Salida: [2,2]
Explicación:
gcdPairs = [2].

Restricciones:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Se le da un array entero nums de longitud n y un array entero queries.
Sea gcdPares una matriz obtenida calculando el GCD de todos los pares posibles (nums[i], nums[j]), donde 0 <= i < j < n, y luego ordenando estos valores en orden ascendente.
Para cada consulta queries[i], debe encontrar el elemento en el índice queries[i] en gcdPairs.
Devuelve un array entero answer, donde answer[i] es el valor en gcdPairs[queries[i]] para cada consulta.
El término gcd(a, b) indica el máximo común divisor de a y b.

Ejemplo 1:

Entrada: nums = [2,3,4], queries = [0,2,2]
Salida: [1,2,2]
Explicación:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Después de ordenar en orden ascendente, gcdPares = [1, 1, 2].
Por tanto, la respuesta es [gcdPares[consultas[0]], gcdPares[consultas[1]], gcdPares[consultas[2]]] = [1, 2, 2].

Ejemplo 2:

Entrada: nums = [4,4,2,1], queries = [5,3,1,0]
Salida: [4,2,1,1]
Explicación:
gcdPares ordenados de forma ascendente es [1, 1, 1, 2, 2, 4].

Ejemplo 3:

Entrada: nums = [2,2], queries = [0,0]
Salida: [2,2]
Explicación:
gcdPares = [2].

Restricciones:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2


Se le proporciona una matriz de números enteros nums.
Reemplaza cada elemento de nums con la suma de sus dígitos.
Devuelve el elemento mínimo de nums después de todos los reemplazos.

Ejemplo 1:

Entrada: nums = [10,12,13,14]
Salida: 1
Explicación:
nums se convierte en [1, 3, 4, 5] después de todos los reemplazos, con un elemento mínimo de 1.

Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: 1
Explicación:
nums se convierte en [1, 2, 3, 4] después de todos los reemplazos, con un elemento mínimo de 1.

Ejemplo 3:

Entrada: nums = [999,19,199]
Salida: 10
Explicación:
nums se convierte en [27, 10, 19] después de todos los reemplazos, con un elemento mínimo de 10.

Restricciones:

1 <= nums.length <= 100
1 <= nums[i] <= 10^4

Se te da un array de enteros nums.
Reemplazas cada elemento en nums con la suma de sus dígitos.
Devuelve el elemento mínimo en nums después de todos los reemplazos.

Ejemplo 1:

Entrada: nums = [10,12,13,14]
Salida: 1
Explicación:
nums se convierte en [1, 3, 4, 5] después de todos los reemplazos, con el elemento mínimo 1.

Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: 1
Explicación:
nums se convierte en [1, 2, 3, 4] después de todos los reemplazos, con el elemento mínimo 1.

Ejemplo 3:

Entrada: nums = [999,19,199]
Salida: 10
Explicación:
nums se convierte en [27, 10, 19] después de todos los reemplazos, con el elemento mínimo 10.

Condiciones:

1 <= nums.length <= 100
1 <= nums[i] <= 10^4


Se te da un array maximumHeight, donde maximumHeight[i] denota la altura máxima que puede asignarse a la i-ésima torre. Tu tarea es asignar una altura a cada torre de manera que:

La altura de la i-ésima torre sea un número entero positivo y no exceda maximumHeight[i].
No haya dos torres con la misma altura.

Devuelve la suma total máxima posible de las alturas de las torres. Si no es posible asignar alturas, devuelve -1.

Ejemplo 1:

Entrada: maximumHeight = [2,3,4,3]
Salida: 10
Explicación:
Podemos asignar alturas de la siguiente manera: [1, 2, 4, 3].

Ejemplo 2:

Entrada: maximumHeight = [15,10]
Salida: 25
Explicación:
Podemos asignar alturas de la siguiente manera: [15, 10].

Ejemplo 3:

Entrada: maximumHeight = [2,2,1]
Salida: -1
Explicación:
Es imposible asignar alturas positivas a cada índice de manera que no haya dos torres con la misma altura.

Restricciones:

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

Se le da una matriz maximumHeight, donde maximumHeight[i] denota la altura máxima que se puede asignar a la i^ésima torre.
Su tarea consiste en asignar una altura a cada torre de modo que:

La altura de la i^ésima torre sea un número entero positivo y no exceda de maximumHeight[i].
No haya dos torres con la misma altura.

Devuelve la suma total máxima posible de las alturas de las torres. Si no es posible asignar alturas, devuelve -1.

Ejemplo 1:

Entrada: maximumHeight = [2,3,4,3]
Salida: 10
Explicación:
Podemos asignar alturas de la siguiente manera: [1, 2, 4, 3].

Ejemplo 2:

Entrada: maximumHeight = [15,10]
Salida: 25
Explicación:
Podemos asignar alturas de la siguiente manera: [15, 10].

Ejemplo 3:

Entrada: maximumHeight = [2,2,1]
Salida: -1
Explicación:
Es imposible asignar alturas positivas a cada índice para que no haya dos torres con la misma altura.

Restricciones:

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


Se te dan dos cadenas word1 y word2.
Una cadena x se llama casi igual a y si puedes cambiar como máximo un carácter en x para que sea idéntica a y.
Una secuencia de índices seq se llama válida si:

Los índices están ordenados en orden ascendente.
Concatenar los caracteres en estos índices en word1 en el mismo orden resulta en una cadena que es casi igual a word2.

Devuelve un arreglo de tamaño word2.length que representa la secuencia válida de índices más pequeña lexicográficamente. Si no existe tal secuencia de índices, devuelve un arreglo vacío.
Nota que la respuesta debe representar el arreglo más pequeño lexicográficamente, no la cadena correspondiente formada por esos índices.

Ejemplo 1:

Entrada: word1 = "vbcca", word2 = "abc"
Salida: [0,1,2]
Explicación:
La secuencia válida de índices más pequeña lexicográficamente es [0, 1, 2]:

Cambia word1[0] a 'a'.
word1[1] ya es 'b'.
word1[2] ya es 'c'.

Ejemplo 2:

Entrada: word1 = "bacdc", word2 = "abc"
Salida: [1,2,4]
Explicación:
La secuencia válida de índices más pequeña lexicográficamente es [1, 2, 4]:

word1[1] ya es 'a'.
Cambia word1[2] a 'b'.
word1[4] ya es 'c'.

Ejemplo 3:

Entrada: word1 = "aaaaaa", word2 = "aaabc"
Salida: []
Explicación:
No hay una secuencia válida de índices.

Ejemplo 4:

Entrada: word1 = "abc", word2 = "ab"
Salida: [0,1]

Restricciones:

1 <= word2.length < word1.length <= 3 * 10^5
word1 y word2 consisten solo de letras minúsculas del inglés.

Se te dan dos cadenas word1 y word2.
Una cadena x se llama casi igual a y si puedes cambiar como máximo un carácter en x para que sea idéntica a y.
Una secuencia de índices seq se llama válida si:

Los índices están ordenados en orden ascendente.
Concatenar los caracteres en estos índices en word1 en el mismo orden resulta en una cadena que es casi igual a word2.

Devuelve un conjunto de tamaño word2.length que representa la secuencia válida de índices más pequeña lexicográficamente. Si no existe tal secuencia de índices, devuelve un conjunto vacío.
Nota que la respuesta debe representar el conjunto más pequeño lexicográficamente, no la cadena correspondiente formada por esos índices.

Ejemplo 1:

Input: word1 = "vbcca", word2 = "abc"
Output: [0,1,2]
Explicación:
La secuencia válida de índices más pequeña lexicográficamente es [0, 1, 2]:

Cambia word1[0] a 'a'.
word1[1] ya es 'b'.
word1[2] ya es 'c'.

Ejemplo 2:

Input: word1 = "bacdc", word2 = "abc"
Output: [1,2,4]
Explicación:
La secuencia válida de índices más pequeña lexicográficamente es [1, 2, 4]:

word1[1] ya es 'a'.
Cambia word1[2] a 'b'.
word1[4] ya es 'c'.

Ejemplo 3:

Input: word1 = "aaaaaa", word2 = "aaabc"
Output: []
Explicación:
No hay una secuencia válida de índices.

Ejemplo 4:

Input: word1 = "abc", word2 = "ab"
Output: [0,1]

Restricciones:

1 <= word2.length < word1.length <= 3 * 10^5
word1 y word2 consisten solo de letras minúsculas del inglés.

Se dan dos cadenas palabra1 y palabra2.
Una cadena x se llama casi igual a y si se puede cambiar como máximo un carácter de x para que sea idéntica a y.
Una secuencia de índices seq se llama válida si:

Los índices están ordenados de forma ascendente.
La concatenación de los caracteres en estos índices en palabra1 en el mismo orden resulta en una cadena que es casi igual a palabra2.

Devuelve una matriz de tamaño word2.length que representa la secuencia de índices válida lexicográficamente más pequeña. Si no existe tal secuencia de índices, devuelve una matriz vacía.
Tenga en cuenta que la respuesta debe representar la matriz lexicográficamente más pequeña, no la cadena correspondiente formada por esos índices.

Ejemplo 1

Entrada: palabra1 = "vbcca", palabra2 = "abc"
Salida: [0,1,2]
Explicación:
La secuencia de índices válida lexicográficamente más pequeña es [0, 1, 2]:

Cambia palabra1[0] por 'a'.
palabra1[1] ya es 'b'.
palabra1[2] ya es 'c'.

Ejemplo 2:

Entrada: palabra1 = "bacdc", palabra2 = "abc"
Salida: [1,2,4]
Explicación:
La secuencia de índices válida lexicográficamente más pequeña es [1, 2, 4]:

palabra1[1] ya es 'a'.
Cambia palabra1[2] a 'b'.
palabra1[4] ya es 'c'.

Ejemplo 3:

Entrada: palabra1 = "aaaaaa", palabra2 = "aaabc"
Salida: []
Explicación:
No existe una secuencia válida de índices.

Ejemplo 4:

Entrada: palabra1 = "abc", palabra2 = "ab"
Salida: [0,1]

Restricciones:

1 <= palabra2.longitud < palabra1.longitud <= 3 * 10^5
palabra1 y palabra2 constan sólo de letras minúsculas inglesas.


Se le proporcionan dos cadenas s y patrón.
Se dice que una cadena x es casi igual a y si puede cambiar como máximo un carácter en x para que sea idéntica a y.
Devuelve el índice inicial más pequeño de una subcadena en s que sea casi igual a patrón. Si no existe dicho índice, devuelve -1.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "abcdefg", pattern = "bcdffg"
Salida: 1
Explicación:
La subcadena s[1..6] == "bcdefg" se puede convertir a "bcdffg" cambiando s[4] por "f".

Ejemplo 2:

Entrada: s = "ababbababa", pattern = "bacaba"
Salida: 4
Explicación:
La subcadena s[4..9] == "bababa" se puede convertir en "bacaba" cambiando s[6] por "c".

Ejemplo 3:

Entrada: s = "abcd", pattern = "dba"
Salida: -1

Ejemplo 4:

Entrada: s = "dde", pattern = "d"
Salida: 0

Restricciones:

1 <= patrón.length < s.length <= 10^5
s y patrón constan únicamente de letras minúsculas en inglés.

Seguimiento: ¿Podrías resolver el problema si se pueden cambiar como máximo k caracteres consecutivos?

Se le proporcionan dos cadenas s y patrón.
Se dice que una cadena x es casi igual a y si puede cambiar como máximo un carácter en x para que sea idéntica a y.
Devuelve el índice inicial más pequeño de una subcadena en s que sea casi igual a patrón. Si no existe dicho índice, devuelve -1.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "abcdefg", pattern = "bcdffg"
Salida: 1
Explicación:
La subcadena s[1..6] == "bcdefg" se puede convertir a "bcdffg" cambiando s[4] por "f".

Ejemplo 2:

Entrada: s = "ababbababa", pattern = "bacaba"
Salida: 4
Explicación:
La subcadena s[4..9] == "bababa" se puede convertir en "bacaba" cambiando s[6] por "c".

Ejemplo 3:

Entrada: s = "abcd", pattern = "dba"
Salida: -1

Ejemplo 4:

Entrada: s = "dde", patrón = "d"
Salida: 0

Restricciones:

1 <= pattern.length < s.length <= 10^5
s y patrón constan únicamente de letras minúsculas en inglés.

Seguimiento: ¿Podrías resolver el problema si se pueden cambiar como máximo k caracteres consecutivos?

Tienes dos cadenas, s y pattern.
Una cadena x se llama casi igual a y si puedes cambiar como máximo un carácter en x para hacerla idéntica a y.
Devuelve el índice de inicio más pequeño de un substring en s que sea casi igual a pattern. Si no existe tal índice, devuelve -1.
Un substring es una secuencia contigua y no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "abcdefg", pattern = "bcdffg"
Salida: 1
Explicación:
El substring s[1..6] == "bcdefg" se puede convertir en "bcdffg" cambiando s[4] a "f".

Ejemplo 2:

Entrada: s = "ababbababa", pattern = "bacaba"
Salida: 4
Explicación:
El substring s[4..9] == "bababa" se puede convertir en "bacaba" cambiando s[6] a "c".

Ejemplo 3:

Entrada: s = "abcd", pattern = "dba"
Salida: -1

Ejemplo 4:

Entrada: s = "dde", pattern = "d"
Salida: 0

Restricciones:

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

Seguimiento: ¿Podrías resolver el problema si se pueden cambiar como máximo k caracteres consecutivos?