Se te da un array nums indexado desde 0 de tamaño n que consiste en enteros positivos.
También se te da un array 2D queries de tamaño m donde queries[i] = [index_i, k_i].
Inicialmente todos los elementos del array están sin marcar.
Necesitas aplicar m consultas en el array en orden, donde en la i-ésima consulta haces lo siguiente:

Marca el elemento en el índice index_i si no está ya marcado.
Luego marca k_i elementos no marcados en el array con los valores más pequeños. Si existen múltiples de tales elementos, marca los que tengan los índices más pequeños. Y si existen menos de k_i elementos no marcados, entonces márcalos a todos.

Devuelve un array answer de tamaño m donde answer[i] es la suma de los elementos no marcados en el array después de la i-ésima consulta.

Ejemplo 1:

Entrada: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Salida: [8,3,0]
Explicación:
Realizamos las siguientes consultas en el array:

Marca el elemento en el índice 1, y 2 de los elementos no marcados más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 2 + 2 + 3 + 1 = 8.
Marca el elemento en el índice 3, ya que está marcado lo omitimos. Luego marcamos 3 de los elementos no marcados más pequeños con los índices más pequeños, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 3.
Marca el elemento en el índice 4, ya que está marcado lo omitimos. Luego marcamos 2 de los elementos no marcados más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 0.

Ejemplo 2:

Entrada: nums = [1,4,2,3], queries = [[0,1]]
Salida: [7]
Explicación: Realizamos una consulta que es marcar el elemento en el índice 0 y marcar el elemento más pequeño entre los elementos no marcados. Los elementos marcados serán nums = [1,4,2,3], y la suma de los elementos no marcados es 4 + 3 = 7.

Restricciones:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Se le proporciona una matriz indexada en 0 nums de tamaño n que consta de números enteros positivos.
También se le proporciona una matriz 2D consultas de tamaño m donde consultas[i] = [índice_i, k_i].
Inicialmente, todos los elementos de la matriz no están marcados.
Debe aplicar m consultas en la matriz en orden, donde en la consulta i^th hace lo siguiente:

Marque el elemento en el índice index_i si aún no está marcado.
Luego marque k_i elementos no marcados en la matriz con los valores más pequeños. Si existen varios de estos elementos, marque los que tengan los índices más pequeños. Y si existen menos de k_i elementos no marcados, márquelos todos.

Devuelva una matriz respuesta de tamaño m donde respuesta[i] es la suma de los elementos no marcados en la matriz después de la consulta i^th.

Ejemplo 1:

Entrada: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Salida: [8,3,0]
Explicación:
Realizamos las siguientes consultas en la matriz:

Marcamos el elemento en el índice 1 y 2 de los elementos sin marcar más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos sin marcar es 2 + 2 + 3 + 1 = 8.
Marcamos el elemento en el índice 3, ya que ya está marcado lo saltamos. Luego marcamos 3 de los elementos sin marcar más pequeños con los índices más pequeños, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 3.
Marcamos el elemento en el índice 4, ya que ya está marcado lo omitimos. Luego marcamos 2 de los elementos no marcados más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 0.

Ejemplo 2:

Entrada: nums = [1,4,2,3], queries = [[0,1]]
Salida: [7]
Explicación: Hacemos una consulta que es marcar el elemento en el índice 0 y marcar el elemento más pequeño entre los elementos no marcados. Los elementos marcados serán nums = [1,4,2,3], y la suma de los elementos no marcados es 4 + 3 = 7.

Restricciones:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Se le proporciona una matriz indexada en 0 nums de tamaño n que consta de números enteros positivos.
También se le proporciona una matriz 2D consultas de tamaño m donde queries[i] = [index_i, k_i].
Inicialmente, todos los elementos de la matriz no están marcados.
Debe aplicar m consultas en la matriz en orden, donde en la consulta i^th hace lo siguiente:

Marque el elemento en el índice index_i si aún no está marcado.
Luego marque k_i elementos no marcados en la matriz con los valores más pequeños. Si existen varios de estos elementos, marque los que tengan los índices más pequeños. Y si existen menos de k_i elementos no marcados, márquelos todos.

Devuelva una matriz respuesta de tamaño m donde respuesta[i] es la suma de los elementos no marcados en la matriz después de la consulta i^th.

Ejemplo 1:

Entrada: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Salida: [8,3,0]
Explicación:
Realizamos las siguientes consultas en la matriz:

Marcamos el elemento en el índice 1 y 2 de los elementos sin marcar más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos sin marcar es 2 + 2 + 3 + 1 = 8.
Marcamos el elemento en el índice 3, ya que ya está marcado lo saltamos. Luego marcamos 3 de los elementos sin marcar más pequeños con los índices más pequeños, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 3.
Marcamos el elemento en el índice 4, ya que ya está marcado lo omitimos. Luego marcamos 2 de los elementos no marcados más pequeños con los índices más pequeños si existen, los elementos marcados ahora son nums = [1,2,2,1,2,3,1]. La suma de los elementos no marcados es 0.

Ejemplo 2:

Entrada: nums = [1,4,2,3], queries = [[0,1]]
Salida: [7]
Explicación: Hacemos una consulta que es marcar el elemento en el índice 0 y marcar el elemento más pequeño entre los elementos no marcados. Los elementos marcados serán nums = [1,4,2,3], y la suma de los elementos no marcados es 4 + 3 = 7.

Restricciones:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1


Se le proporciona una cadena s. s[i] es una letra minúscula del inglés o '?'.
Para una cadena t con una longitud m que contiene solo letras minúsculas del inglés, definimos la función cost(i) para un índice i como la cantidad de caracteres igual a t[i] que aparecieron antes de ella, es decir, en el rango [0, i - 1].
El valor de t es la suma de cost(i) para todos los índices i.
Por ejemplo, para la cadena t = "aab":

cost(0) = 0
cost(1) = 1
cost(2) = 0
Por lo tanto, el valor de "aab" es 0 + 1 + 0 = 1.

Su tarea es reemplazar todas las ocurrencias de '?' en s con cualquier letra minúscula del inglés de modo que el valor de s se minimice.
Devuelva una cadena que denote la cadena modificada con las ocurrencias reemplazadas de '?'. Si hay varias cadenas que dan como resultado el valor mínimo, devuelve la que sea lexicográficamente más pequeña.

Ejemplo 1:

Entrada: s = "???"
Salida: "abc"
Explicación: En este ejemplo, podemos reemplazar las ocurrencias de '?' para que s sea igual a "abc".
Para "abc", cost(0) = 0, cost(1) = 0 y cost(2) = 0.
El valor de "abc" es 0.
Otras modificaciones de s que tienen un valor de 0 son "cba", "abz" y "hey".
De entre todas ellas, elegimos la que sea lexicográficamente más pequeña.

Ejemplo 2:

Entrada: s = "a?a?"
Salida: "abac"
Explicación: En este ejemplo, las ocurrencias de '?' se pueden reemplazar para que s sea igual a "abac".
Para "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1 y cost(3) = 0.
El valor de "abac" es 1.

Restricciones:

1 <= s.length <= 10^5
s[i] es una letra minúscula del alfabeto inglés o un signo "?".

Se te da una cadena s. s[i] es una letra inglesa minúscula o '?'.
Para una cadena t de longitud m que contiene solo letras inglesas minúsculas, definimos la función cost(i) para un índice i como el número de caracteres iguales a t[i] que aparecieron antes, es decir, en el rango [0, i - 1].
El valor de t es la suma de cost(i) para todos los índices i.
Por ejemplo, para la cadena t = "aab":

cost(0) = 0
cost(1) = 1
cost(2) = 0

Por lo tanto, el valor de "aab" es 0 + 1 + 0 = 1.

Tu tarea es reemplazar todas las apariciones de '?' en s con cualquier letra inglesa minúscula para que el valor de s se minimice.
Devuelve una cadena que denote la cadena modificada con las ocurrencias de '?' reemplazadas. Si hay múltiples cadenas resultando en el valor mínimo, devuelve la lexicográficamente más pequeña.

Ejemplo 1:

Entrada:   s = "???"
Salida:   "abc"
Explicación:  En este ejemplo, podemos reemplazar las ocurrencias de '?' para hacer que s sea igual a "abc".
Para "abc", cost(0) = 0, cost(1) = 0, y cost(2) = 0.
El valor de "abc" es 0.
Algunas otras modificaciones de s que tienen un valor de 0 son "cba", "abz", y "hey".
Entre todas ellas, elegimos la lexicográficamente más pequeña.

Ejemplo 2:

Entrada:  s = "a?a?"
Salida:  "abac"
Explicación:  En este ejemplo, las ocurrencias de '?' pueden ser reemplazadas para hacer que s sea igual a "abac".
Para "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1, y cost(3) = 0.
El valor de "abac" es 1.

Restricciones:

1 <= s.length <= 10^5
s[i] es una letra inglesa minúscula o '?'.


Se te da un arreglo de enteros nums de longitud n y un entero positivo k.
La potencia de un arreglo de enteros se define como el número de subsecuencias con su suma igual a k.
Devuelve la suma de la potencia de todas las subsecuencias de nums.
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada:   nums = [1,2,3], k = 3
Salida:   6
Explicación:
Hay 5 subsecuencias de nums con potencia no nula:

La subsecuencia [1,2,3] tiene 2 subsecuencias con suma == 3: [1,2,3] y [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].

Por lo tanto, la respuesta es 2 + 1 + 1 + 1 + 1 = 6.

Ejemplo 2:

Entrada:   nums = [2,3,3], k = 5
Salida:   4
Explicación:
Hay 3 subsecuencias de nums con potencia no nula:

La subsecuencia [2,3,3] tiene 2 subsecuencias con suma == 5: [2,3,3] y [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].

Por lo tanto, la respuesta es 2 + 1 + 1 = 4.

Ejemplo 3:

Entrada:   nums = [1,2,3], k = 7
Salida:   0
Explicación: No existe subsecuencia con suma 7. Por lo tanto, todas las subsecuencias de nums tienen potencia = 0.

Restricciones:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

Se le proporciona una matriz de números enteros nums de longitud n y un entero positivo k.
La potencia de una matriz de números enteros se define como el número de subsecuencias con su suma igual a k.
Devuelve la suma de las potencias de todas las subsecuencias de números.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3], k = 3
Salida: 6
Explicación:
Hay 5 subsecuencias de números con potencia distinta de cero:

La subsecuencia [1,2,3] tiene 2 subsecuencias con suma == 3: [1,2,3] y [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].

Por lo tanto, la respuesta es 2 + 1 + 1 + 1 + 1 = 6.

Ejemplo 2:

Entrada: nums = [2,3,3], k = 5
Salida: 4
Explicación:
Hay 3 subsecuencias de nums con potencia distinta de cero:

La subsecuencia [2,3,3] tiene 2 subsecuencias con suma == 5: [2,3,3] y [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].

Por lo tanto, la respuesta es 2 + 1 + 1 = 4.

Ejemplo 3:

Entrada: nums = [1,2,3], k = 7
Salida: 0
Explicación: No existe ninguna subsecuencia con suma 7. Por lo tanto, todas las subsecuencias de nums tienen potencia = 0.

Restricciones:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

Se le da una matriz de números enteros de longitud n y un número entero positivo k.
La potencia de una matriz de enteros se define como el número de subsecuencias cuya suma es igual a k.
Devuelve la suma de potencias de todas las subsecuencias de nums.
Como la respuesta puede ser muy grande, devuélvala módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3], k = 3
Salida:   6
Explicación:
Hay 5 subsecuencias de nums con potencia distinta de cero:

La subsecuencia [1,2,3] tiene 2 subsecuencias con suma == 3: [1,2,3] y [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].
La subsecuencia [1,2,3] tiene 1 subsecuencia con suma == 3: [1,2,3].

Por tanto, la respuesta es 2 + 1 + 1 + 1 + 1 = 6.

Ejemplo 2:

Entrada: nums = [2,3,3], k = 5
Salida:   4
Explicación:
Hay 3 subsecuencias de nums con potencia distinta de cero:

La subsecuencia [2,3,3] tiene 2 subsecuencias con suma == 5: [2,3,3] y [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].
La subsecuencia [2,3,3] tiene 1 subsecuencia con suma == 5: [2,3,3].

Por tanto, la respuesta es 2 + 1 + 1 = 4.

Ejemplo 3:

Entrada: nums = [1,2,3], k = 7
Salida:   0
Explicación: No existe ninguna subsecuencia con suma 7. Por lo tanto todas las subsecuencias de nums tienen potencia = 0.

Restricciones:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100


Se te da un array nums de enteros no negativos y un entero k.
Un array se llama especial si el OR bit a bit de todos sus elementos es al menos k.
Devuelve la longitud del subarray especial no vacío más corto de nums, o devuelve -1 si no existe un subarray especial.

Ejemplo 1:

Entrada: nums = [1,2,3], k = 2
Salida: 1
Explicación:
El subarray [3] tiene un valor OR de 3. Por lo tanto, devolvemos 1.

Ejemplo 2:

Entrada: nums = [2,1,8], k = 10
Salida: 3
Explicación:
El subarray [2,1,8] tiene un valor OR de 11. Por lo tanto, devolvemos 3.

Ejemplo 3:

Entrada: nums = [1,2], k = 0
Salida: 1
Explicación:
El subarray [1] tiene un valor OR de 1. Por lo tanto, devolvemos 1.

Restricciones:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Se le proporciona una matriz nums de números enteros no negativos y un número entero k.
Una matriz se denomina especial si el OR bit a bit de todos sus elementos es al menos k.
Devuelve la longitud de la submatriz especial no vacía más corta de nums, o devuelve -1 si no existe ninguna submatriz especial.

Ejemplo 1:

Entrada: nums = [1,2,3], k = 2
Salida: 1
Explicación:
La submatriz [3] tiene un valor OR de 3. Por lo tanto, devolvemos 1.

Ejemplo 2:

Entrada: nums = [2,1,8], k = 10
Salida: 3
Explicación:
La submatriz [2,1,8] tiene un valor OR de 11. Por lo tanto, devolvemos 3.

Ejemplo 3:

Entrada: nums = [1,2], k = 0
Salida: 1
Explicación:
La submatriz [1] tiene un valor OR de 1. Por lo tanto, devolvemos 1.

Restricciones:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Se le da una matriz nums de enteros no negativos y un entero k.
Una matriz se llama especial si el OR a nivel de bits de todos sus elementos es al menos k.
Devuelve la longitud de la submatriz especial no vacía más corta de nums, o devuelve -1 si no existe ninguna submatriz especial.

Ejemplo 1:

Entrada: nums = [1,2,3], k = 2
Salida: 1
Explicación:
La submatriz [3] tiene un valor OR de 3. Por lo tanto, devolvemos 1.

Ejemplo 2:

Entrada: nums = [2,1,8], k = 10
Salida: 3
Explicación:
La submatriz [2,1,8] tiene un valor OR de 11. Por lo tanto, devolvemos 3.

Ejemplo 3:

Entrada: nums = [1,2], k = 0
Salida: 1
Explicación:
La submatriz [1] tiene valor OR de 1. Por lo tanto, devolvemos 1.

Restricciones:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64


Se te da un array binario llamado possible de longitud n.
Alice y Bob están jugando un juego que consta de n niveles. Algunos niveles en el juego son imposibles de superar, mientras que otros siempre se pueden superar. En particular, si possible[i] == 0, entonces el nivel i es imposible de superar para ambos jugadores. Un jugador gana 1 punto al superar un nivel y pierde 1 punto si falla en superarlo..
Al inicio del juego, Alice jugará algunos niveles en el orden dado comenzando desde el nivel 0, después de lo cual Bob jugará el resto de los niveles.
Alice quiere saber el número mínimo de niveles que debe jugar para obtener más puntos que Bob, si ambos jugadores juegan de manera óptima para maximizar sus puntos.
Devuelve el número mínimo de niveles que Alice debe jugar para ganar más puntos. Si esto no es posible, devuelve -1.
Ten en cuenta que cada jugador debe jugar al menos 1 nivel.

Ejemplo 1:

Input: possible = [1,0,1,0]
Output: 1
Explicación:
Veamos todos los niveles que Alice puede jugar hasta:

Si Alice juega solo el nivel 0 y Bob juega el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene -1 + 1 - 1 = -1 punto.
Si Alice juega hasta el nivel 1 y Bob juega el resto de los niveles, Alice tiene 1 - 1 = 0 puntos, mientras que Bob tiene 1 - 1 = 0 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 1 - 1 + 1 = 1 punto, mientras que Bob tiene -1 punto.

Alice debe jugar un mínimo de 1 nivel para ganar más puntos.

Ejemplo 2:

Input: possible = [1,1,1,1,1]
Output: 3
Explicación:
Veamos todos los niveles que Alice puede jugar hasta:

Si Alice juega solo el nivel 0 y Bob juega el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene 4 puntos.
Si Alice juega hasta el nivel 1 y Bob juega el resto de los niveles, Alice tiene 2 puntos, mientras que Bob tiene 3 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 3 puntos, mientras que Bob tiene 2 puntos.
Si Alice juega hasta el nivel 3 y Bob juega el resto de los niveles, Alice tiene 4 puntos, mientras que Bob tiene 1 punto.

Alice debe jugar un mínimo de 3 niveles para ganar más puntos.

Ejemplo 3:

Input: possible = [0,0]
Output: -1
Explicación:
La única manera posible es que ambos jugadores jueguen 1 nivel cada uno. Alice juega el nivel 0 y pierde 1 punto. Bob juega el nivel 1 y pierde 1 punto. Como ambos jugadores tienen puntos iguales, Alice no puede ganar más puntos que Bob.

Constraints:

2 <= n == possible.length <= 10^5
possible[i] es 0 o 1.

Se le da una matriz binaria posible de longitud n.
Alice y Bob están jugando a un juego que consta de n niveles. Algunos de los niveles del juego son imposibles de superar, mientras que otros siempre se pueden superar. En particular, si possible[i] == 0, el nivel i^ es imposible de superar para ambos jugadores. Un jugador gana 1 punto al superar un nivel y pierde 1 punto si no lo supera.
Al principio del juego, Alice jugará algunos niveles en el orden dado empezando por el nivel 0^, después de lo cual Bob jugará el resto de los niveles.
Alice quiere saber el número mínimo de niveles que debe jugar para ganar más puntos que Bob, si ambos jugadores juegan de forma óptima para maximizar sus puntos.
Devuelve el número mínimo de niveles que Alice debería jugar para ganar más puntos. Si no es posible, devuelve -1.
Tenga en cuenta que cada jugador debe jugar al menos 1 nivel.

Ejemplo 1:

Entrada: possible = [1,0,1,0]
Salida: 1
Explicación:
Veamos todos los niveles hasta los que puede jugar Alice:

Si Alice juega sólo el nivel 0 y Bob el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene -1 + 1 - 1 = -1 punto.
Si Alice juega hasta el nivel 1 y Bob juega el resto de niveles, Alice tiene 1 - 1 = 0 puntos, mientras que Bob tiene 1 - 1 = 0 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 1 - 1 + 1 = 1 punto, mientras que Bob tiene -1 punto.

Alice debe jugar un mínimo de 1 nivel para ganar más puntos.

Ejemplo 2:

Entrada:  possible = [1,1,1,1,1]
Salida: 3
Explicación:
Veamos todos los niveles hasta los que puede jugar Alice:

Si Alice juega sólo el nivel 0 y Bob el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene 4 puntos.
Si Alice juega hasta el nivel 1 y Bob juega el resto de los niveles, Alice tiene 2 puntos, mientras que Bob tiene 3 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 3 puntos, mientras que Bob tiene 2 puntos.
Si Alice juega hasta el nivel 3 y Bob juega el resto de los niveles, Alice tiene 4 puntos, mientras que Bob tiene 1 punto.

Alice debe jugar un mínimo de 3 niveles para ganar más puntos.

Ejemplo 3:

Entrada: possible = [0,0]
Salida: -1
Explicación:
La única forma posible es que ambos jugadores jueguen 1 nivel cada uno. Alice juega el nivel 0 y pierde 1 punto. Bob juega el nivel 1 y pierde 1 punto. Como ambos jugadores tienen los mismos puntos, Alice no puede ganar más puntos que Bob.

Restricciones:

2 <= n == possible.length <= 10^5
possible[i] es 0 o 1.

Se te da un array binario llamado possible de longitud n.
Alice y Bob están jugando un juego que consta de n niveles. Algunos niveles en el juego son imposibles de superar, mientras que otros siempre se pueden superar. En particular, si possible[i] == 0, entonces el nivel i^esímo es imposible de superar para ambos jugadores. Un jugador gana 1 punto al superar un nivel y pierde 1 punto si falla en superarlo.
Al inicio del juego, Alice jugará algunos niveles en el orden dado comenzando desde el nivel 0^esímo, después de lo cual Bob jugará el resto de los niveles.
Alice quiere saber el número mínimo de niveles que debe jugar para obtener más puntos que Bob, si ambos jugadores juegan de manera óptima para maximizar sus puntos.
Devuelve el número mínimo de niveles que Alice debe jugar para ganar más puntos. Si esto no es posible, devuelve -1.
Ten en cuenta que cada jugador debe jugar al menos 1 nivel.

Ejemplo 1:

Entrada: possible = [1,0,1,0]
Salida: 1
Explicación:
Veamos todos los niveles que Alice puede jugar hasta:

Si Alice juega solo el nivel 0 y Bob juega el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene -1 + 1 - 1 = -1 punto.
Si Alice juega hasta el nivel 1 y Bob juega el resto de los niveles, Alice tiene 1 - 1 = 0 puntos, mientras que Bob tiene 1 - 1 = 0 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 1 - 1 + 1 = 1 punto, mientras que Bob tiene -1 punto.

Alice debe jugar un mínimo de 1 nivel para ganar más puntos.

Ejemplo 2:

Entrada: possible = [1,1,1,1,1]
Salida: 3
Explicación:
Veamos todos los niveles que Alice puede jugar hasta:

Si Alice juega solo el nivel 0 y Bob juega el resto de los niveles, Alice tiene 1 punto, mientras que Bob tiene 4 puntos.
Si Alice juega hasta el nivel 1 y Bob juega el resto de los niveles, Alice tiene 2 puntos, mientras que Bob tiene 3 puntos.
Si Alice juega hasta el nivel 2 y Bob juega el resto de los niveles, Alice tiene 3 puntos, mientras que Bob tiene 2 puntos.
Si Alice juega hasta el nivel 3 y Bob juega el resto de los niveles, Alice tiene 4 puntos, mientras que Bob tiene 1 punto.

Alice debe jugar un mínimo de 3 niveles para ganar más puntos.

Ejemplo 3:

Entrada: possible = [0,0]
Salida: -1
Explicación:
La única manera posible es que ambos jugadores jueguen 1 nivel cada uno. Alice juega el nivel 0 y pierde 1 punto. Bob juega el nivel 1 y pierde 1 punto. Como ambos jugadores tienen puntos iguales, Alice no puede ganar más puntos que Bob.

Constraints:

2 <= n == possible.length <= 10^5
possible[i] es 0 o 1.


Se te da un array de enteros nums de longitud n, y un entero positivo k.
El poder de una subsecuencia se define como la diferencia mínima absoluta entre cualquier par de elementos en la subsecuencia.
Devuelve la suma de los poderes de todas las subsecuencias de nums que tengan longitud igual a k.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3,4], k = 3
Salida: 4
Explicación:
Hay 4 subsecuencias en nums que tienen longitud 3: [1,2,3], [1,3,4], [1,2,4] y [2,3,4]. La suma de los poderes es |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Ejemplo 2:

Entrada: nums = [2,2], k = 2
Salida: 0
Explicación:
La única subsecuencia en nums que tiene longitud 2 es [2,2]. La suma de los poderes es |2 - 2| = 0.

Ejemplo 3:

Entrada: nums = [4,3,-1], k = 2
Salida: 10
Explicación:
Hay 3 subsecuencias en nums que tienen longitud 2: [4,3], [4,-1] y [3,-1]. La suma de los poderes es |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Restricciones:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

Se te da un array de enteros nums de longitud n, y un entero positivo k.
El poder de una subsecuencia se define como la diferencia mínima absoluta entre cualquier par de elementos en la subsecuencia.
Devuelve la suma de los poderes de todas las subsecuencias de nums que tengan longitud igual a k.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3,4], k = 3
Salida: 4
Explicación:
Hay 4 subsecuencias en nums que tienen longitud 3: [1,2,3], [1,3,4], [1,2,4] y [2,3,4]. La suma de los poderes es |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Ejemplo 2:

Entrada: nums = [2,2], k = 2
Salida: 0
Explicación:
La única subsecuencia en nums que tiene longitud 2 es [2,2]. La suma de los poderes es |2 - 2| = 0.

Ejemplo 3:

Salida: 10
Explicación:
Hay 3 subsecuencias en nums que tienen longitud 2: [4,3], [4,-1] y [3,-1]. La suma de los poderes es |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Restricciones:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= 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 subsecuencia se define como la diferencia absoluta mínima entre dos elementos cualesquiera de la subsecuencia.
Devuelve la suma de las potencias de todas las subsecuencias de nums que tienen una longitud igual a k.
Como la respuesta puede ser grande, devuélvala módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3,4], k = 3
Salida: 4
Explicación:
Hay 4 subsecuencias en nums que tienen una longitud de 3: [1,2,3], [1,3,4], [1,2,4] y [2,3,4]. La suma de las potencias es |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Ejemplo 2:

Entrada: nums = [2,2], k = 2
Salida: 0
Explicación:
La única subsecuencia en nums que tiene una longitud de 2 es [2,2]. La suma de potencias es |2 - 2| = 0.

Ejemplo 3:

Entrada: nums = [4,3,-1], k = 2
Salida: 10
Explicación:
Hay 3 subsecuencias en nums que tienen una longitud de 2: [4,3], [4,-1] y [3,-1]. La suma de potencias es |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Restricciones:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n


Se le proporciona una cadena s. La puntuación de una cadena se define como la suma de la diferencia absoluta entre los valores ASCII de caracteres adyacentes.
Devuelve la puntuación de s.

Ejemplo 1:

Entrada: s = "hello"
Salida: 13
Explicación:
Los valores ASCII de los caracteres en s son: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Por lo tanto, la puntuación de s sería |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Ejemplo 2:

Entrada: s = "zaz"
Salida: 50
Explicación:
Los valores ASCII de los caracteres en s son: 'z' = 122, 'a' = 97. Por lo tanto, la puntuación de s sería |122 - 97| + |97 - 122| = 25 + 25 = 50.

Restricciones:

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

Se te da una cadena s. La puntuación de una cadena se define como la suma de la diferencia absoluta entre los valores ASCII de los caracteres adyacentes.
Devuelve la puntuación de s.

Ejemplo 1:

Entrada: s = "hello"
Salida: 13
Explicación:
Los valores ASCII de los caracteres en s son: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Entonces, la puntuación de s sería |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Ejemplo 2:

Entrada: s = "zaz"
Salida: 50
Explicación:
Los valores ASCII de los caracteres en s son: 'z' = 122, 'a' = 97. Entonces, la puntuación de s sería |122 - 97| + |97 - 122| = 25 + 25 = 50.

Restricciones:

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


Se te da un array de enteros positivos nums.
Devuelve el número de subarrays de nums, donde el primer y el último elemento del subarray son iguales al elemento más grande en el subarray.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2]
Salida: 6
Explicación:
Hay 6 subarrays que tienen el primer y el último elemento igual al elemento más grande del subarray:

subarray [1,4,3,3,2], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
subarray [1,4,3,3,2], con su elemento más grande 4. El primer elemento es 4 y el último elemento también es 4.
subarray [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [1,4,3,3,2], con su elemento más grande 2. El primer elemento es 2 y el último elemento también es 2.
subarray [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 2:

Entrada: nums = [3,3,3]
Salida: 6
Explicación:
Hay 6 subarrays que tienen el primer y el último elemento igual al elemento más grande del subarray:

subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarray [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 3:

Entrada: nums = [1]
Salida: 1
Explicación:
Hay un solo subarray de nums que es [1], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
Por lo tanto, devolvemos 1.

Restricciones:

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

Se te da un conjunto de enteros positivos nums.
Devuelve el número de subconjuntos de nums, donde el primer y el último elemento del subconjunto son iguales al elemento más grande en el subconjunto.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2]
Salida: 6
Explicación:
Hay 6 subconjuntos que tienen el primer y el último elemento igual al elemento más grande del subconjunto:

subconjunto [1,4,3,3,2], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
subconjunto [1,4,3,3,2], con su elemento más grande 4. El primer elemento es 4 y el último elemento también es 4.
subconjunto [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [1,4,3,3,2], con su elemento más grande 2. El primer elemento es 2 y el último elemento también es 2.
subconjunto [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 2:

Entrada: nums = [3,3,3]
Salida: 6
Explicación:
Hay 6 subconjuntos que tienen el primer y el último elemento igual al elemento más grande del subconjunto:

subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subconjunto [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 3:

Entrada: nums = [1]
Salida: 1
Explicación:
Hay un solo subconjunto de nums que es [1], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
Por lo tanto, devolvemos 1.

Restricciones:

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

Se le proporciona una matriz de números enteros positivos.
Devuelve la cantidad de submatrices de números, donde el primer y el último elemento de la submatriz son iguales al elemento más grande de la submatriz.

Ejemplo 1:

Entrada: nums = [1,4,3,3,2]
Salida: 6
Explicación:
Hay 6 submatrices que tienen el primer y el último elemento igual al elemento más grande de la submatriz:

submatriz [1,4,3,3,2], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
submatriz [1,4,3,3,2], con su elemento más grande 4. El primer elemento es 4 y el último elemento también es 4.
submatriz [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
submatriz [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
submatriz [1,4,3,3,2], con su elemento más grande 2. El primer elemento es 2 y el último elemento también es 2.
subarreglo [1,4,3,3,2], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 2:

Entrada: nums = [3,3,3]
Salida: 6
Explicación:
Hay 6 submatrices que tienen el primer y el último elemento igual al elemento más grande de la submatriz:

subarreglo [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarreglo [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarreglo [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
subarreglo [3,3,3], con su elemento más grande 3. El primer El elemento es 3 y el último elemento también es 3.
Subarreglo [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.
Subarreglo [3,3,3], con su elemento más grande 3. El primer elemento es 3 y el último elemento también es 3.

Por lo tanto, devolvemos 6.

Ejemplo 3:

Entrada: nums = [1]
Salida: 1
Explicación:
Hay un único subarreglo de nums que es [1], con su elemento más grande 1. El primer elemento es 1 y el último elemento también es 1.
Por lo tanto, devolvemos 1.

Restricciones:

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


Se te da una cadena de caracteres llamada word. Una letra se denomina especial si aparece tanto en minúscula como en mayúscula en word.
Devuelve el número de letras especiales en word.

Ejemplo 1:

Entrada: word = "aaAbcBC"
Salida: 3
Explicación:
Los caracteres especiales en word son 'a', 'b' y 'c'.

Ejemplo 2:

Entrada: word = "abc"
Salida: 0
Explicación:
Ningún carácter en word aparece en mayúscula.

Ejemplo 3:

Entrada: word = "abBCab"
Salida: 1
Explicación:
El único carácter especial en word es 'b'.

Restricciones:

1 <= word.length <= 50
word consiste solo en letras inglesas mayúsculas y minúsculas.

Se le proporciona una cadena de caracteres word. Una letra se denomina especial si aparece tanto en mayúscula como en minúscula en word.
Devuelve la cantidad de letras especiales en word.

Ejemplo 1:

Entrada: word = "aaAbcBC"
Salida: 3
Explicación:
Los caracteres especiales en word son 'a', 'b' y 'c'.

Ejemplo 2:

Entrada: word = "abc"
Salida: 0
Explicación:
Ningún carácter en word aparece en mayúscula.

Ejemplo 3:

Entrada: word = "abBCab"
Salida: 1
Explicación:
El único carácter especial en word es 'b'.

Restricciones:

1 <= word.length <= 50
word consta solo de letras mayúsculas y minúsculas del idioma inglés.

Se le proporciona una cadena de caracteres word. Una letra se denomina especial si aparece tanto en mayúscula como en minúscula en word.
Devuelve la cantidad de letras especiales en word.

Ejemplo 1:

Entrada: word = "aaAbcBC"
Salida: 3
Explicación:
Los caracteres especiales en word son 'a', 'b' y 'c'.

Ejemplo 2:

Entrada: word = "abc"
Salida: 0
Explicación:
Ningún carácter en word aparece en mayúscula.

Ejemplo 3:

Entrada: word = "abBCab"
Salida: 1
Explicación:
El único carácter especial en word es 'b'.

Restricciones:

1 <= word.length <= 50
word consta solo de letras mayúsculas y minúsculas del inglés.


Se te dan dos arreglos de igual longitud, nums1 y nums2.
Cada elemento en nums1 ha sido incrementado (o decrementado en el caso de negativos) por un entero, representado por la variable x.
Como resultado, nums1 se convierte en igual a nums2. Dos arreglos se consideran iguales cuando contienen los mismos enteros con las mismas frecuencias.
Devuelve el entero x.

Ejemplo 1:

Entrada: nums1 = [2,6,4], nums2 = [9,7,5]
Salida: 3
Explicación:
El entero añadido a cada elemento de nums1 es 3.

Ejemplo 2:

Entrada: nums1 = [10], nums2 = [5]
Salida: -5
Explicación:
El entero añadido a cada elemento de nums1 es -5.

Ejemplo 3:

Entrada: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Salida: 0
Explicación:
El entero añadido a cada elemento de nums1 es 0.

Condiciones:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Los casos de prueba se generan de manera que hay un entero x tal que nums1 puede convertirse en igual a nums2 sumando x a cada elemento de nums1.

Se dan dos matrices de igual longitud, nums1 y nums2.
Cada elemento de nums1 se ha incrementado (o disminuido en caso de ser negativo) en un número entero, representado por la variable x.
Como resultado, nums1 pasa a ser igual a nums2. Dos matrices se consideran iguales cuando contienen los mismos enteros con las mismas frecuencias.
Devuelve el entero x.

Ejemplo 1:

Entrada: nums1 = [2,6,4], nums2 = [9,7,5]
Salida: 3
Explicación:
El entero añadido a cada elemento de nums1 es 3.

Ejemplo 2:

Entrada: nums1 = [10], nums2 = [5]
Salida: -5
Explicación:
El entero añadido a cada elemento de nums1 es -5.

Ejemplo 3:

Entrada: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Salida: 0
Explicación:
El entero añadido a cada elemento de nums1 es 0.

Restricciones:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Los casos de prueba se generan de forma que haya un número entero x tal que nums1 pueda llegar a ser igual a nums2 sumando x a cada elemento de nums1.

Se te dan dos array de igual longitud, nums1 y nums2.
Cada elemento en nums1 ha sido incrementado (o decrementado en el caso de negativos) por un entero, representado por la variable x.
Como resultado, nums1 se convierte en igual a nums2. Dos array se consideran iguales cuando contienen los mismos enteros con las mismas frecuencias.
Devuelve el entero x.

Ejemplo 1:

Entrada: nums1 = [2,6,4], nums2 = [9,7,5]
Salida: 3
Explicación:
El entero añadido a cada elemento de nums1 es 3.

Ejemplo 2:

Entrada: nums1 = [10], nums2 = [5]
Salida: -5
Explicación:
El entero añadido a cada elemento de nums1 es -5.

Ejemplo 3:

Entrada: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Salida: 0
Explicación:
El entero añadido a cada elemento de nums1 es 0.

Condiciones:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Los casos de prueba se generan de manera que hay un entero x tal que nums1 puede convertirse en igual a nums2 sumando x a cada elemento de nums1.


Se te dan dos números enteros n y x. Tienes que construir un arreglo de enteros positivos nums de tamaño n donde para cada 0 <= i < n - 1, nums[i + 1] es mayor que nums[i], y el resultado de la operación AND a nivel de bits entre todos los elementos de nums es x.
Devuelve el valor mínimo posible de nums[n - 1].

Ejemplo 1:

Entrada: n = 3, x = 4
Salida: 6
Explicación:
nums puede ser [4,5,6] y su último elemento es 6.

Ejemplo 2:

Entrada: n = 2, x = 7
Salida: 15
Explicación:
nums puede ser [7,15] y su último elemento es 15.

Restricciones:

1 <= n, x <= 10^8

Se le proporcionan dos números enteros n y x. Debe construir una matriz de números enteros positivos nums de tamaño n donde para cada 0 <= i < n - 1, nums[i + 1] es mayor que nums[i], y el resultado de la operación AND bit a bit entre todos los elementos de nums es x.
Devuelve el valor mínimo posible de nums[n - 1].

Ejemplo 1:

Entrada: n = 3, x = 4
Salida: 6
Explicación:
nums puede ser [4,5,6] y su último elemento es 6.

Ejemplo 2:

Entrada: n = 2, x = 7
Salida: 15
Explicación:
nums puede ser [7,15] y su último elemento es 15.

Restricciones:

1 <= n, x <= 10^8


Se te proporciona un array de enteros nums. El array de unicidad de nums es el array ordenado que contiene el número de elementos distintos de todos los subarrays de nums. En otras palabras, es un array ordenado que consiste en distintos(nums[i..j]), para todos 0 <= i <= j < nums.length.
Aquí, distintos(nums[i..j]) denota el número de elementos distintos en el subarray que comienza en el índice i y termina en el índice j.
Devuelve la mediana del array de unicidad de nums.
Nota que la mediana de un array se define como el elemento medio del array cuando está ordenado en orden no decreciente. Si hay dos opciones para una mediana, se toma el menor de los dos valores.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 1
Explicación:
El array de unicidad de nums es [distintos(nums[0..0]), distintos(nums[1..1]), distintos(nums[2..2]), distintos(nums[0..1]), distintos(nums[1..2]), distintos(nums[0..2])] que es igual a [1, 1, 1, 2, 2, 3]. El array de unicidad tiene una mediana de 1. Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums = [3,4,3,4,5]
Salida: 2
Explicación:
El array de unicidad de nums es [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. El array de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: nums = [4,3,5,4]
Salida: 2
Explicación:
El array de unicidad de nums es [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. El array de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Restricciones:

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

Se le da una matriz de números enteros. La matriz de unicidad de nums es la matriz ordenada que contiene el número de elementos distintos de todas las submatrices de nums. En otras palabras, es una matriz ordenada que consta de distinct(nums[i.. j]), para todos los 0 <= i <= j < nums.length.
Aquí, distinct(nums[i.. j]) denota el número de elementos distintos en la submatriz que comienza en el índice i y termina en el índice j.
Devuelve la mediana de la matriz de unicidad de nums.
Tenga en cuenta que la mediana de una matriz se define como el elemento central de la matriz cuando se ordena en orden no decreciente. Si hay dos opciones para una mediana, se toma el menor de los dos valores.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 1
Explicación:
La matriz de unicidad de nums es [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] que es igual a [1, 1, 1, 2, 2, 3]. La matriz de unicidad tiene una mediana de 1. Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums = [3,4,3,4,5]
Salida: 2
Explicación:
La matriz de unicidad de nums es [1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. La matriz de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: nums = [4,3,5,4]
Salida: 2
Explicación:
La matriz de unicidad de nums es [1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3]. La matriz de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Restricciones:

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

Se le proporciona una matriz de números enteros nums. La matriz de unicidad de nums es la matriz ordenada que contiene la cantidad de elementos distintos de todas las submatrices de nums. En otras palabras, es una matriz ordenada que consta de distinct(nums[i..j]), para todos los 0 <= i <= j < nums.length.
Aquí, distinct(nums[i..j]) denota la cantidad de elementos distintos en la submatriz que comienza en el índice i y termina en el índice j.
Devuelve la mediana de la matriz de unicidad de nums.
Tenga en cuenta que la mediana de una matriz se define como el elemento central de la matriz cuando se ordena en orden no decreciente. Si hay dos opciones para una mediana, se toma el menor de los dos valores.

Ejemplo 1:

Entrada: nums = [1,2,3]
Salida: 1
Explicación:
La matriz de unicidad de nums es [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] que es igual a [1, 1, 1, 2, 2, 3]. La matriz de unicidad tiene una mediana de 1. Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums = [3,4,3,4,5]
Salida: 2
Explicación:
La matriz de unicidad de nums es [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3]. La matriz de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: nums = [4,3,5,4]
Salida: 2
Explicación:
La matriz de unicidad de nums es [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. La matriz de unicidad tiene una mediana de 2. Por lo tanto, la respuesta es 2.

Restricciones:

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


Una palabra se considera válida si:

Contiene un mínimo de 3 caracteres.
Contiene solo dígitos (0-9) y letras en inglés (mayúsculas y minúsculas).
Incluye al menos una vocal.
Incluye al menos una consonante.

Se te da una cadena de texto word.
Devuelve true si word es válida, de lo contrario, devuelve false.
Notas:

'a', 'e', 'i', 'o', 'u', y sus mayúsculas son vocales.
Una consonante es una letra en inglés que no es una vocal.

Ejemplo 1:

Entrada: word = "234Adas"
Salida: true
Explicación:
Esta palabra cumple con las condiciones.

Ejemplo 2:

Entrada: word = "b3"
Salida: false
Explicación:
La longitud de esta palabra es menor de 3 y no tiene vocal.

Ejemplo 3:

Entrada: word = "a3$e"
Salida: false
Explicación:
Esta palabra contiene un carácter '$' y no tiene una consonante.

Restricciones:

1 <= word.length <= 20
word consiste en letras en inglés mayúsculas y minúsculas, dígitos, '@', '#' y '$'.

Una palabra se considera válida si:

Contiene un mínimo de 3 caracteres.
Contiene solo dígitos (0-9) y letras en inglés (mayúsculas y minúsculas).
Incluye al menos una vocal.
Incluye al menos una consonante.

Se te da una cadena word.
Devuelve true si word es válida, de lo contrario, devuelve false.
Notas:

'a', 'e', 'i', 'o', 'u', y sus mayúsculas son vocales.
Una consonante es una letra en inglés que no es una vocal.

Ejemplo 1:

Entrada: word = "234Adas"
Salida: true
Explicación:
Esta palabra cumple con las condiciones.

Ejemplo 2:

Entrada: word = "b3"
Salida: false
Explicación:
La longitud de esta palabra es menor de 3 y no tiene vocal.

Ejemplo 3:

Entrada: word = "a3$e"
Salida: false
Explicación:
Esta palabra contiene un carácter '$' y no tiene una consonante.

Restricciones:

1 <= word.length <= 20
word consiste en letras en inglés mayúsculas y minúsculas, dígitos, '@', '#' y '$'.

Una palabra se considera válida si:

Contiene un mínimo de 3 caracteres.
Contiene solo dígitos (0-9) y letras en inglés (mayúsculas y minúsculas).
Incluye al menos una vocal.
Incluye al menos una consonante.

Se te da una cadena de texto word.
Devuelve true si word es válida, de lo contrario, devuelve false.
Notas:

'a', 'e', 'i', 'o', 'u', y sus mayúsculas son vocales.
Una consonante es una letra en inglés que no es una vocal.

Ejemplo 1:

Input: word = "234Adas"
Output: true
Explicación:
Esta palabra cumple con las condiciones.

Ejemplo 2:

Input: word = "b3"
Output: false
Explicación:
La longitud de esta palabra es menor de 3 y no tiene vocal.

Ejemplo 3:

Input: word = "a3$e"
Output: false
Explicación:
Esta palabra contiene un carácter '$' y no tiene una consonante.

Restricciones:

1 <= word.length <= 20
word consiste en letras en inglés mayúsculas y minúsculas, dígitos, '@', '#' y '$'.


Se te da una cadena word de tamaño n, y un entero k tal que k divide a n.
En una operación, puedes elegir dos índices i y j, que sean divisibles por k, y luego reemplazar la subcadena de longitud k comenzando en i con la subcadena de longitud k comenzando en j. Es decir, reemplaza la subcadena word[i..i + k - 1] con la subcadena word[j..j + k - 1].
Devuelve el número mínimo de operaciones necesarias para hacer que word sea k-periódica.
Decimos que word es k-periódica si hay alguna cadena s de longitud k tal que word puede obtenerse concatenando s un número arbitrario de veces. Por ejemplo, si word == "ababab", entonces word es 2-periódica para s = "ab".

Ejemplo 1:

Entrada: word = "leetcodeleet", k = 4
Salida: 1
Explicación:
Podemos obtener una cadena 4-periódica eligiendo i = 4 y j = 0. Después de esta operación, word se convierte en "leetleetleet".

Ejemplo 2:

Entrada: word = "leetcoleet", k = 2
Salida: 3
Explicación:
Podemos obtener una cadena 2-periódica aplicando las operaciones en la siguiente tabla.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Restricciones:

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

Se te da una cadena word de tamaño n, y un entero k tal que k divide a n.
En una operación, puedes elegir dos índices i y j, que sean divisibles por k, y luego reemplazar la subcadena de longitud k que comienza en i con la subcadena de longitud k que comienza en j. Es decir, reemplaza la subcadena word[i..i + k - 1] con la subcadena word[j..j + k - 1].
Devuelve el número mínimo de operaciones necesarias para hacer que word sea k-periódica.
Decimos que word es k-periódica si hay alguna cadena s de longitud k tal que word puede obtenerse concatenando s un número arbitrario de veces. Por ejemplo, si word == "ababab", entonces word es 2-periódica para s = "ab".

Ejemplo 1:

Entrada: word = "leetcodeleet", k = 4
Salida: 1
Explicación:
Podemos obtener una cadena 4-periódica eligiendo i = 4 y j = 0. Después de esta operación, word se convierte en "leetleetleet".

Ejemplo 2:

Entrada: word = "leetcoleet", k = 2
Salida: 3
Explicación:
Podemos obtener una cadena 2-periódica aplicando las operaciones en la siguiente tabla.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Restricciones:

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

Se le proporciona una cadena de caracteres word de tamaño n y un entero k tal que k divide a n.
En una operación, puede elegir dos índices i y j, que sean divisibles por k, y luego reemplazar la subcadena de longitud k que comienza en i con la subcadena de longitud k que comienza en j. Es decir, reemplazar la subcadena word[i..i + k - 1] con la subcadena word[j..j + k - 1].
Devuelve el número mínimo de operaciones necesarias para que word sea k-periódica.
Decimos que word es k-periódica si existe alguna cadena s de longitud k tal que word se puede obtener concatenando s una cantidad arbitraria de veces. Por ejemplo, si word == “ababab”, entonces word es 2-periódica para s = "ab".

Ejemplo 1:

Entrada: word = "leetcodeleet", k = 4
Salida: 1
Explicación:
Podemos obtener una cadena periódica de 4 caracteres eligiendo i = 4 y j = 0. Después de esta operación, palabra se vuelve igual a "leetleetleet".

Ejemplo 2:

Entrada: word = "leetcoleet", k = 2
Salida: 3
Explicación:
Podemos obtener una cadena periódica de 2 caracteres aplicando las operaciones de la siguiente tabla.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Restricciones:

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


Se te da una cadena s, que se conoce como una concatenación de anagramas de alguna cadena t.
Devuelve la longitud mínima posible de la cadena t.
Un anagrama se forma reorganizando las letras de una cadena. Por ejemplo, "aab", "aba" y "baa" son anagramas de "aab".

Ejemplo 1:

Entrada: s = "abba"
Salida: 2
Explicación:
Una cadena t posible podría ser "ba".

Ejemplo 2:

Entrada: s = "cdef"
Salida: 4
Explicación:
Una cadena t posible podría ser "cdef", nota que t puede ser igual a s.

Restricciones:

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

Se le proporciona una cadena s, que se sabe que es una concatenación de anagramas de alguna cadena t.
Devuelve la longitud mínima posible de la cadena t.
Un anagrama se forma reorganizando las letras de una cadena. Por ejemplo, "aab", "aba", y, "baa" son anagramas de "aab".

Ejemplo 1:

Entrada: s = "abba"
Salida: 2
Explicación:
Una posible cadena t podría ser "ba".

Ejemplo 2:

Entrada: s = "cdef"
Salida: 4
Explicación:
Una posible cadena t podría ser "cdef", observe que t puede ser igual a s.

Restricciones:

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

Se le proporciona una cadena s, que se sabe que es una concatenación de anagramas de alguna cadena t.
Devuelve la longitud mínima posible de la cadena t.
Un anagrama se forma reorganizando las letras de una cadena. Por ejemplo, "aab", "aba" y "baa" son anagramas de "aab".

Ejemplo 1:

Entrada: s = "abba"
Salida: 2
Explicación:
Una posible cadena t podría ser "ba".

Ejemplo 2:

Entrada: s = "cdef"
Salida: 4
Explicación:
Una posible cadena t podría ser "cdef", observe que t puede ser igual a s.

Restricciones:

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


Se te da un array de enteros `nums` y dos enteros `cost1` y `cost2`. Se permite realizar cualquiera de las siguientes operaciones cualquier número de veces:

- Elige un índice `i` de `nums` y aumenta `nums[i]` en 1 por un costo de `cost1`.
- Elige dos índices diferentes `i, j` de `nums` y aumenta `nums[i]` y `nums[j]` en 1 por un costo de `cost2`.

Devuelve el costo mínimo requerido para hacer que todos los elementos del array sean iguales.
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [4,1], cost1 = 5, cost2 = 2
Salida: 15
Explicación:
Se pueden realizar las siguientes operaciones para hacer que los valores sean iguales:

Aumenta `nums[1]` en 1 por un costo de 5. `nums` se convierte en [4,2].
Aumenta `nums[1]` en 1 por un costo de 5. `nums` se convierte en [4,3].
Aumenta `nums[1]` en 1 por un costo de 5. `nums` se convierte en [4,4].

El costo total es 15.

Ejemplo 2:

Entrada: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Salida: 6
Explicación:
Se pueden realizar las siguientes operaciones para hacer que los valores sean iguales:

Aumenta `nums[0]` y `nums[1]` en 1 por un costo de 1. `nums` se convierte en [3,4,3,3,5].
Aumenta `nums[0]` y `nums[2]` en 1 por un costo de 1. `nums` se convierte en [4,4,4,3,5].
Aumenta `nums[0]` y `nums[3]` en 1 por un costo de 1. `nums` se convierte en [5,4,4,4,5].
Aumenta `nums[1]` y `nums[2]` en 1 por un costo de 1. `nums` se convierte en [5,5,5,4,5].
Aumenta `nums[3]` en 1 por un costo de 2. `nums` se convierte en [5,5,5,5,5].

El costo total es 6.

Ejemplo 3:

Entrada: nums = [3,5,3], cost1 = 1, cost2 = 3
Salida: 4
Explicación:
Se pueden realizar las siguientes operaciones para hacer que los valores sean iguales:

Aumenta `nums[0]` en 1 por un costo de 1. `nums` se convierte en [4,5,3].
Aumenta `nums[0]` en 1 por un costo de 1. `nums` se convierte en [5,5,3].
Aumenta `nums[2]` en 1 por un costo de 1. `nums` se convierte en [5,5,4].
Aumenta `nums[2]` en 1 por un costo de 1. `nums` se convierte en [5,5,5].

El costo total es 4.

Restricciones:

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

Se le da una matriz de enteros nums y dos enteros cost1 y cost2. Puede realizar cualquiera de las siguientes operaciones cualquier número de veces:

Elija un índice i de nums y aumente nums[i] en 1 para obtener un costo de cost1.
Elija dos índices diferentes i, j, de nums y aumente nums[i] y nums[j] en 1 para obtener un costo de cost2.

Devuelve el costo mínimo necesario para que todos los elementos de la matriz sean iguales.
Dado que la respuesta puede ser muy grande, devuélvala módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [4,1], cost1 = 5, cost2 = 2
Salida: 15
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumenta nums[1] en 1 por un costo de 5. nums se convierte en [4,2].
Aumenta nums[1] en 1 por un costo de 5. nums se convierte en [4,3].
Aumenta nums[1] en 1 por un costo de 5. nums se convierte en [4,4].

El costo total es de 15.

Ejemplo 2:

Entrada: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Salida: 6
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumenta nums[0] y nums[1] en 1 por un costo de 1. nums se convierte en [3,4,3,3,5].
Aumenta nums[0] y nums[2] en 1 por un costo de 1. nums se convierte en [4,4,4,3,5].
Aumenta nums[0] y nums[3] en 1 por un costo de 1. nums se convierte en [5,4,4,4,5].
Aumenta nums[1] y nums[2] en 1 por un costo de 1. nums se convierte en [5,5,5,4,5].
Aumenta nums[3] en 1 por un costo de 2. nums se convierte en [5,5,5,5,5].

El costo total es de 6.

Ejemplo 3:

Entrada: nums = [3,5,3], cost1 = 1, cost2 = 3
Salida: 4
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumenta nums[0] en 1 por un costo de 1. nums se convierte en [4,5,3].
Aumenta nums[0] en 1 por un costo de 1. nums se convierte en [5,5,3].
Aumenta nums[2] en 1 por un costo de 1. nums se convierte en [5,5,4].
Aumenta nums[2] en 1 por un costo de 1. nums se convierte en [5,5,5].

El costo total es de 4.

Restricciones:

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

Se le proporciona una matriz de enteros nums y dos enteros cost1 y cost2. Puede realizar cualquiera de las siguientes operaciones cualquier cantidad de veces:

Elija un índice i de nums y aumente nums[i] en 1 para un costo de cost1.
Elija dos índices diferentes i, j, de nums y aumente nums[i] y nums[j] en 1 para un costo de cost2.

Devuelva el costo mínimo requerido para que todos los elementos de la matriz sean iguales.
Como la respuesta puede ser muy grande, devuélvala módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [4,1], cost1 = 5, cost2 = 2
Salida: 15
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumente nums[1] en 1 para un costo de 5. nums se convierte en [4,2].
Aumenta nums[1] en 1 para un costo de 5. nums se convierte en [4,3].
Aumenta nums[1] en 1 para un costo de 5. nums se convierte en [4,4].

El costo total es 15.

Ejemplo 2:

Entrada: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Salida: 6
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumenta nums[0] y nums[1] en 1 para un costo de 1. nums se convierte en [3,4,3,3,5].
Aumenta nums[0] y nums[2] en 1 para un costo de 1. nums se convierte en [4,4,4,3,5].
Aumenta nums[0] y nums[3] en 1 para un costo de 1. nums se convierte en [5,4,4,4,5].
Aumenta nums[1] y nums[2] en 1 para un costo de 1. nums se convierte en [5,5,5,4,5].
Aumenta nums[3] en 1 para un costo de 2. nums se convierte en [5,5,5,5,5].

El costo total es 6.

Ejemplo 3:

Entrada: nums = [3,5,3], cost1 = 1, cost2 = 3
Salida: 4
Explicación:
Se pueden realizar las siguientes operaciones para que los valores sean iguales:

Aumenta nums[0] en 1 para un costo de 1. nums se convierte en [4,5,3].
Aumenta nums[0] en 1 para un costo de 1. nums se convierte en [5,5,3].
Aumenta nums[2] en 1 para un costo de 1. nums se convierte en [5,5,4].
Aumenta nums[2] en 1 para un costo de 1. nums se convierte en [5,5,5].

El costo total es 4.

Restricciones:

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


Se le proporciona una cuadrícula de matriz 2D de tamaño 3 x 3 que consta únicamente de los caracteres "B" y "W". El carácter "W" representa el color blanco y el carácter "B" representa el color negro.
Su tarea es cambiar el color de una celda como máximo para que la matriz tenga un cuadrado de 2 x 2 donde todas las celdas sean del mismo color.
Devuelva verdadero si es posible crear un cuadrado de 2 x 2 del mismo color; de lo contrario, devuelva falso.

Ejemplo 1:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Salida: verdadero
Explicación:
Se puede hacer cambiando el color de la cuadrícula[0][2].

Ejemplo 2:

Entrada: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Salida: false
Explicación:
No se puede hacer modificando como máximo una celda.

Ejemplo 3:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Salida: true
Explicación:
La cuadrícula ya contiene un cuadrado de 2 x 2 del mismo color.

Restricciones:

grid.length == 3
grid[i].length == 3
grid[i][j] is either 'W' or 'B'.

Se le proporciona una cuadrícula de matriz 2D de tamaño 3 x 3 que consta únicamente de los caracteres "B" y "W". El carácter "W" representa el color blanco y el carácter "B" representa el color negro.
Su tarea es cambiar el color de una celda como máximo para que la matriz tenga un cuadrado de 2 x 2 donde todas las celdas sean del mismo color.
Devuelva verdadero si es posible crear un cuadrado de 2 x 2 del mismo color; de lo contrario, devuelva falso.
Ejemplo 1:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Salida: true
Explicación:
Se puede hacer cambiando el color de la cuadrícula[0][2].

Ejemplo 2:

Entrada: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Salida: false
Explicación:
No se puede hacer modificando como máximo una celda.

Ejemplo 3:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Salida: true
Explicación:
La cuadrícula ya contiene un cuadrado de 2 x 2 del mismo color.

Restricciones:

grid.length == 3
grid[i].length == 3
grid[i][j] es 'W' o 'B'.

Se te proporciona una matriz 2D de tamaño 3 x 3 compuesta únicamente por los caracteres 'B' y 'W'. El carácter 'W' representa el color blanco, y el carácter 'B' representa el color negro.
Tu tarea es cambiar el color de una celda, como máximo, una vez para que la matriz tenga un cuadrado de 2 x 2 donde todas las celdas sean del mismo color. Devuelve true si es posible crear un cuadrado de 2 x 2 del mismo color; de lo contrario, devuelve false.
Devuelve true si es posible crear un cuadrado de 2 x 2 del mismo color, en caso contrario, devuelve false.

Ejemplo 1:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Salida: true
Explicación:
Se puede lograr cambiando el color de la celda grid[0][2].

Ejemplo 2:

Entrada: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Salida: false
Explicación:
No se puede lograr cambiando como máximo una celda.

Ejemplo 3:

Entrada: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Salida: true
Explicación:
La matriz ya contiene un cuadrado de 2 x 2 del mismo color.

Restricciones:

grid.length == 3
grid[i].length == 3
grid[i][j] es 'W' o 'B'.


Tienes una matriz booleana 2D llamada grid.
Devuelve un número entero que sea el número de triángulos rectángulos que se pueden formar con los 3 elementos de grid, de modo que todos ellos tengan un valor de 1.
Nota:

Una colección de 3 elementos de grid es un triángulo rectángulo si uno de sus elementos está en la misma fila que otro elemento y en la misma columna que el tercer elemento. Los 3 elementos no tienen que estar uno al lado del otro.

Ejemplo 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrada: grid = [[0,1,0],[0,1,1],[0,1,0]]
Salida: 2
Explicación: Hay dos triángulos rectángulos.

Ejemplo 2:

1
0
0
0

0
1
0
1

1
0
0
0

Entrada: grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Salida: 0
Explicación: No hay triángulos rectángulos.

Ejemplo 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrada: grid = [[1,0,1],[1,0,0],[1,0,0]]
Salida: 2
Explicación: Hay dos triángulos rectángulos.

Restricciones:

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

Se le proporciona una cuadrícula de matriz booleana 2D.
Devuelve un entero que es la cantidad de triángulos rectángulos que se pueden formar con los 3 elementos de la cuadrícula de manera que todos tengan un valor de 1.
Nota:

Una colección de 3 elementos de la cuadrícula es un triángulo rectángulo si uno de sus elementos está en la misma fila que otro elemento y en la misma columna que el tercer elemento. Los 3 elementos no tienen que estar uno al lado del otro.

Ejemplo 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrada: grid = [[0,1,0],[0,1,1],[0,1,0]]
Salida: 2
Explicación:
Hay dos triángulos rectángulos.

Ejemplo 2:

1
0
0
0

0
1
0
1

1
0
0
0

Entrada: grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Salida: 0
Explicación:
No hay triángulos rectángulos.

Ejemplo 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrada: grid = [[1,0,1],[1,0,0],[1,0,0]]
Salida: 2
Explicación:
Hay dos triángulos rectángulos.

Restricciones:

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

Se le da una rejilla 2D de matriz booleana.
Devuelve un entero que es el número de triángulos rectángulos que se pueden formar con los 3 elementos de la rejilla de forma que todos ellos tengan valor 1.
Nota:

Una colección de 3 elementos de rejilla es un triángulo rectángulo si uno de sus elementos está en la misma fila con otro elemento y en la misma columna con el tercer elemento. No es necesario que los 3 elementos estén uno al lado del otro.

Ejemplo 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrada: grid = [[0,1,0],[0,1,1],[0,1,0]]
Salida: 2
Explicación:
Hay dos triángulos rectángulos.

Ejemplo 2:

1
0
0
0

0
1
0
1

1
0
0
0

Entrada: grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Salida: 0
Explicación:
No hay triángulos rectángulos.

Ejemplo 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrada: grid = [[1,0,1],[1,0,0],[1,0,0]]
Salida: 2
Explicación:
Hay dos triángulos rectángulos.

Restricciones:

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1


Se te dan 3 enteros positivos zero, one y limit.
Un arreglo binario arr se denomina estable si:

El número de ocurrencias de 0 en arr es exactamente zero.
El número de ocurrencias de 1 en arr es exactamente one.
Cada subarreglo de arr con un tamaño mayor que limit debe contener tanto 0 como 1.

Devuelve el número total de arreglos binarios estables.
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: zero = 1, one = 1, limit = 2
Salida: 2
Explicación:
Los dos posibles arreglos binarios estables son [1,0] y [0,1], ya que ambos arreglos tienen un solo 0 y un solo 1, y ningún subarreglo tiene una longitud mayor que 2.

Ejemplo 2:

Entrada: zero = 1, one = 2, limit = 1
Salida: 1
Explicación:
El único arreglo binario estable posible es [1,0,1].
Note que los arreglos binarios [1,1,0] y [0,1,1] tienen subarreglos de longitud 2 con elementos idénticos, por lo tanto, no son estables.

Ejemplo 3:

Entrada: zero = 3, one = 3, limit = 2
Salida: 14
Explicación:
Todos los posibles arreglos binarios estables son [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0], y [1,1,0,1,0,0].

Restricciones:

1 <= zero, one, limit <= 200

Se le proporcionan 3 números enteros positivos: cero, uno y límite.
Una matriz binaria arr se denomina estable si:

La cantidad de ocurrencias de 0 en arr es exactamente cero.
La cantidad de ocurrencias de 1 en arr es exactamente uno.
Cada submatriz de arr con un tamaño mayor que límite debe contener tanto 0 como 1.

Devuelve la cantidad total de matrices binarias estables.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: zero = 1, one = 1, limit = 2
Salida: 2
Explicación:
Las dos posibles matrices binarias estables son [1,0] y [0,1], ya que ambas matrices tienen un único 0 y un único 1, y ninguna submatriz tiene una longitud mayor que 2.

Ejemplo 2:

Entrada: zero = 1, one = 2, limit = 1
Salida: 1
Explicación:
La única matriz binaria estable posible es [1,0,1].
Nótese que las matrices binarias [1,1,0] y [0,1,1] tienen submatrices de longitud 2 con elementos idénticos, por lo tanto, no son estables.

Ejemplo 3:

Entrada: zero = 3, one = 3, limit = 2
Salida: 14
Explicación:
Todas las posibles matrices binarias estables son [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] y [1,1,0,1,0,0].

Restricciones:

1 <= zero, one, limit <= 200

Se le proporcionan 3 números enteros positivos: cero, uno y límite.
Una matriz binaria arr se denomina estable si:

La cantidad de ocurrencias de 0 en arr es exactamente cero.
La cantidad de ocurrencias de 1 en arr es exactamente uno.
Cada submatriz de arr con un tamaño mayor que límite debe contener tanto 0 como 1.

Devuelve la cantidad total de matrices binarias estables.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: cero = 1, uno = 1, límite = 2
Salida: 2
Explicación:
Las dos posibles matrices binarias estables son [1,0] y [0,1], ya que ambas matrices tienen un único 0 y un único 1, y ninguna submatriz tiene una longitud mayor que 2.

Ejemplo 2:

Entrada: cero = 1, uno = 2, límite = 1
Salida: 1
Explicación:
La única matriz binaria estable posible es [1,0,1].
Nótese que las matrices binarias [1,1,0] y [0,1,1] tienen submatrices de longitud 2 con elementos idénticos, por lo tanto, no son estables.

Ejemplo 3:

Entrada: cero = 3, uno = 3, límite = 2
Salida: 14
Explicación:
Todas las posibles matrices binarias estables son [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] y [1,1,0,1,0,0].

Restricciones:

1 <= cero, uno, límite <= 200


Se le proporcionan dos cadenas s y t de modo que cada carácter aparece como máximo una vez en s y t es una permutación de s.
La diferencia de permutación entre s y t se define como la suma de la diferencia absoluta entre el índice de aparición de cada carácter en s y el índice de aparición del mismo carácter en t.
Devuelve la diferencia de permutación entre s y t.

Ejemplo 1:

Entrada: s = "abc", t = "bac"
Salida: 2
Explicación:
Para s = "abc" y t = "bac", la diferencia de permutación de s y t es igual a la suma de:

La diferencia absoluta entre el índice de aparición de "a" en s y el índice de aparición de "a" en t.
La diferencia absoluta entre el índice de aparición de "b" en s y el índice de aparición de "b" en t.
Diferencia absoluta entre el índice de ocurrencia de "c" en s y el índice de ocurrencia de "c" en t.

Es decir, la diferencia de permutación entre s y t es igual a |0 - 1| + |2 - 2| + |1 - 0| = 2.

Ejemplo 2:

Entrada: s = "abcde", t = "edbac"
Salida: 12
Explicación: La diferencia de permutación entre s y t es igual a |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Restricciones:

1 <= s.length <= 26
Cada carácter aparece como máximo una vez en s.
t es una permutación de s.
s consta únicamente de letras minúsculas del alfabeto inglés.

Se te dan dos cadenas s y t de tal manera que cada carácter ocurre como máximo una vez en s y t es una permutación de s.
La diferencia de permutación entre s y t se define como la suma de la diferencia absoluta entre el índice de ocurrencia de cada carácter en s y el índice de ocurrencia del mismo carácter en t.
Devuelve la diferencia de permutación entre s y t.

Ejemplo 1:

Entrada: s = "abc", t = "bac"
Salida: 2
Explicación:
Para s = "abc" y t = "bac", la diferencia de permutación de s y t es igual a la suma de:

La diferencia absoluta entre el índice de ocurrencia de "a" en s y el índice de ocurrencia de "a" en t.
La diferencia absoluta entre el índice de ocurrencia de "b" en s y el índice de ocurrencia de "b" en t.
La diferencia absoluta entre el índice de ocurrencia de "c" en s y el índice de ocurrencia de "c" en t.

Es decir, la diferencia de permutación entre s y t es igual a |0 - 1| + |2 - 2| + |1 - 0| = 2.

Ejemplo 2:

Entrada: s = "abcde", t = "edbac"
Salida: 12
Explicación: La diferencia de permutación entre s y t es igual a |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Restricciones:

1 <= s.length <= 26
Cada carácter ocurre como máximo una vez en s.
t es una permutación de s.
s consiste solo en letras minúsculas del inglés.

Se dan dos cadenas s y t tales que cada carácter aparece como máximo una vez en s y t es una permutación de s.
La diferencia de permutación entre s y t se define como la suma de la diferencia absoluta entre el índice de aparición de cada carácter en s y el índice de aparición del mismo carácter en t.
Devuelve la diferencia de permutación entre s y t.

Ejemplo 1

Entrada: s = "abc", t = "bac"
Salida: 2
Explicación:
Para s = "abc" y t = "bac", la diferencia de permutación de s y t es igual a la suma de:

La diferencia absoluta entre el índice de la ocurrencia de "a" en s y el índice de la ocurrencia de "a" en t.
La diferencia absoluta entre el índice de la aparición de "b" en s y el índice de la aparición de "b" en t.
La diferencia absoluta entre el índice de la aparición de «c» en s y el índice de la aparición de "c" en t.

Es decir, la diferencia de permutación entre s y t es igual a |0 - 1| + |2 - 2| + |1 - 0| = 2.

Ejemplo 2

Entrada: s = "abcde", t = "edbac"
Salida: 12
Explicación: La diferencia de permutación entre s y t es igual a |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Restricciones:

1 <= s.length <= 26
Cada carácter aparece como máximo una vez en s.
t es una permutación de s.
s consta sólo de letras minúsculas inglesas.


En una mazmorra mística, n magos están de pie en una fila. Cada mago tiene un atributo que le otorga energía. Algunos magos pueden otorgarte energía negativa, lo que significa quitarte energía.
Te han maldecido de tal manera que después de absorber energía del mago i, serás transportado instantáneamente al mago (i + k). Este proceso se repetirá hasta que llegues al mago donde (i + k) no existe.
En otras palabras, elegirás un punto de partida y luego te teletransportarás con k saltos hasta llegar al final de la secuencia de magos, absorbiendo toda la energía durante el viaje.
Se te da una matriz de energía y un entero k. Devuelve la máxima energía posible que puedes obtener.

Ejemplo 1:

Entrada: energy = [5,2,-10,-5,1], k = 3
Salida: 3
Explicación: Podemos obtener una energía total de 3 si comenzamos con el mago 1 y absorbemos 2 + 1 = 3.

Ejemplo 2:

Entrada: energy = [-2,-3,-1], k = 2
Salida: -1
Explicación: Podemos obtener una energía total de -1 si comenzamos con el mago 2.

Restricciones:

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

En una mazmorra mística, n magos están formados en una línea. Cada mago tiene un atributo que te da energía. Algunos magos pueden darte energía negativa, lo que significa que te quitan energía.
Has sido maldecido de tal manera que, después de absorber energía del mago i, serás transportado instantáneamente al mago (i + k). Este proceso se repetirá hasta que llegues al mago donde (i + k) no exista.
En otras palabras, elegirás un punto de inicio y luego te teletransportarás con k saltos hasta llegar al final de la secuencia de magos, absorbiendo toda la energía durante el trayecto.
Se te da un arreglo de energías y un entero k. Devuelve la máxima energía posible que puedas obtener.

Ejemplo 1:

Entrada: energy = [5,2,-10,-5,1], k = 3
Salida: 3
Explicación: Podemos obtener un total de energía de 3 comenzando desde el mago 1 absorbiendo 2 + 1 = 3.

Ejemplo 2:

Entrada: energy = [-2,-3,-1], k = 2
Salida: -1
Explicación: Podemos obtener un total de energía de -1 comenzando desde el mago 2.

Restricciones:

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

En una mazmorra mística, hay n magos en fila. Cada mago tiene un atributo que te da energía. Algunos magos pueden darte energía negativa, lo que significa quitarte energía.
Has sido maldecido de tal manera que después de absorber energía del mago i, serás transportado instantáneamente al mago (i + k). Este proceso se repetirá hasta que llegues al mago donde (i + k) no existe.
En otras palabras, elegirás un punto de partida y luego te teletransportarás con k saltos hasta llegar al final de la secuencia de magos, absorbiendo toda la energía durante el viaje.
Se te da una matriz energía y un número entero k. Devuelve la máxima energía posible que puedes obtener.

Ejemplo 1:

Entrada: energy = [5,2,-10,-5,1], k = 3
Salida: 3
Explicación: Podemos ganar una energía total de 3 partiendo del mago 1 absorbiendo 2 + 1 = 3.

Ejemplo 2:

Entrada: energy = [-2,-3,-1], k = 2
Salida: -1
Explicación: Podemos ganar una energía total de -1 empezando por el mago 2.

Restricciones:

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1


Un arreglo se considera especial si cada par de sus elementos adyacentes contiene dos números con diferente paridad. Se te da un arreglo de enteros nums. Devuelve true si nums es un arreglo especial, de lo contrario, devuelve false.

Ejemplo 1:

Entrada: nums = [1]
Salida: true
Explicación:
Solo hay un elemento. Así que la respuesta es true.

Ejemplo 2:

Entrada: nums = [2,1,4]
Salida: true
Explicación:
Solo hay dos pares: (2,1) y (1,4), y ambos contienen números con diferente paridad. Así que la respuesta es true.

Ejemplo 3:

Entrada: nums = [4,3,1,6]
Salida: false
Explicación:
nums[1] y nums[2] son ambos impares. Así que la respuesta es false.

Restricciones:

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

Una matriz se considera especial si cada par de sus elementos adyacentes contiene dos números con diferente paridad.
Se le proporciona una matriz de números enteros nums. Devuelva verdadero si nums es una matriz especial; de lo contrario, devuelva falso.

Ejemplo 1:

Entrada: nums = [1]
Salida: true
Explicación:
Solo hay un elemento. Por lo tanto, la respuesta es verdadera.

Ejemplo 2:

Entrada: nums = [2,1,4]
Salida: true
Explicación:
Solo hay dos pares: (2,1) y (1,4), y ambos contienen números con diferente paridad. Por lo tanto, la respuesta es verdadera.

Ejemplo 3:

Entrada: nums = [4,3,1,6]
Salida: false
Explicación:
nums[1] y nums[2] son impares. Por lo tanto, la respuesta es falsa.

Restricciones:

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

Una matriz se considera especial si cada par de sus elementos adyacentes contiene dos números con diferente paridad.
Se le proporciona una matriz de números enteros nums. Devuelva verdadero si nums es una matriz especial; de lo contrario, devuelva false.

Ejemplo 1:

Entrada: nums = [1]
Salida: true
Explicación:
Solo hay un elemento. Por lo tanto, la respuesta es true.

Ejemplo 2:

Entrada: nums = [2,1,4]
Salida: true
Explicación:
Solo hay dos pares: (2,1) y (1,4), y ambos contienen números con diferente paridad. Por lo tanto, la respuesta es true.

Ejemplo 3:

Entrada: nums = [4,3,1,6]
Salida: false
Explicación:
nums[1] y nums[2] son impares. Por lo tanto, la respuesta es false.

Restricciones:

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


Dado un array nums que consiste en enteros positivos donde todos los enteros tienen el mismo número de dígitos.
La diferencia de dígitos entre dos enteros es la cantidad de dígitos diferentes que están en la misma posición en los dos enteros.
Devuelve la suma de las diferencias de dígitos entre todos los pares de enteros en nums.

Ejemplo 1:

Entrada: nums = [13,23,12]
Salida: 4
Explicación:
Tenemos lo siguiente:
- La diferencia de dígitos entre 13 y 23 es 1.
- La diferencia de dígitos entre 13 y 12 es 1.
- La diferencia de dígitos entre 23 y 12 es 2.
Entonces la suma total de las diferencias de dígitos entre todos los pares de enteros es 1 + 1 + 2 = 4.

Ejemplo 2:

Entrada: nums = [10,10,10,10]
Salida: 0
Explicación:
Todos los enteros en el array son iguales. Así que la suma total de las diferencias de dígitos entre todos los pares de enteros será 0.

Condiciones:

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Todos los enteros en nums tienen el mismo número de dígitos.

Se le proporciona una matriz nums que consta de números enteros positivos, donde todos los números enteros tienen la misma cantidad de dígitos.
La diferencia de dígitos entre dos números enteros es el recuento de dígitos diferentes que están en la misma posición en los dos números enteros.
Devuelve la suma de las diferencias de dígitos entre todos los pares de números enteros en nums.

Ejemplo 1:

Entrada: nums = [13,23,12]
Salida: 4
Explicación:
Tenemos lo siguiente:
- La diferencia de dígitos entre 13 y 23 es 1.
- La diferencia de dígitos entre 13 y 12 es 1.
- La diferencia de dígitos entre 23 y 12 es 2.
Por lo tanto, la suma total de las diferencias de dígitos entre todos los pares de números enteros es 1 + 1 + 2 = 4.

Ejemplo 2:

Entrada: nums = [10,10,10,10]
Salida: 0
Explicación:
Todos los números enteros de la matriz son iguales. Por lo tanto, la suma total de las diferencias de dígitos entre todos los pares de números enteros será 0.

Restricciones:

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Todos los números enteros en nums tienen la misma cantidad de dígitos.


Se le da un número entero no negativo k. Existe una escalera con un número infinito de escaleras, con la escalera más baja numerada 0.
Alice tiene un salto entero, con un valor inicial de 0. Comienza en la escalera 1 y quiere llegar a la escalera k utilizando cualquier número de operaciones. Si está en la escalera i, en una operación puede:

Baja hasta la escalera i - 1. Esta operación no se puede utilizar de forma consecutiva ni en la escalera 0.
Sube la escalera i + 2^salto. Y luego, saltar se convierte en saltar + 1.

Devuelve el número total de formas en que Alicia puede llegar a la escalera k.
Tenga en cuenta que es posible que Alicia llegue a la escalera k y realice algunas operaciones para volver a llegar a la escalera k.

Ejemplo 1:

Entrada: k = 0
Salida: 2
Explicación:
Las 2 formas posibles de llegar a la escalera 0 son:

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escaleras para llegar a la escalera 1.
Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.

Ejemplo 2:

Entrada: k = 1
Salida: 4
Explicación:
Las 4 formas posibles de llegar a la escalera 1 son:

Alicia comienza en la escalera 1. Alicia está en la escalera 1.
Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escaleras para llegar a la escalera 1.

Alicia comienza en la escalera 1.

Usando una operación del segundo tipo, sube 2^0 escaleras para llegar a la escalera 2.
Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 1.

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escaleras para llegar a la escalera 1.
Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^1 escaleras para llegar a la escalera 2.
Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 1.

Restricciones:

0 <= k <= 10^9

Se te da un número entero no negativo k. Existe una escalera con un número infinito de peldaños, siendo el peldaño más bajo numerado con 0.
Alice tiene un salto entero, con un valor inicial de 0. Ella comienza en el peldaño 1 y quiere llegar al peldaño k usando cualquier número de operaciones. Si está en el peldaño i, en una operación puede:

Bajar al peldaño i - 1. Esta operación no puede usarse consecutivamente o en el peldaño 0.
Subir al peldaño i + 2^salto. Y luego, el salto se convierte en salto + 1.

Devuelve el número total de formas en que Alice puede llegar al peldaño k.
Nota que es posible que Alice llegue al peldaño k, y realice algunas operaciones para llegar nuevamente al peldaño k.

Ejemplo 1:

Entrada: k = 0
Salida: 2
Explicación:
Las 2 formas posibles de llegar al peldaño 0 son:

Alice comienza en el peldaño 1.

Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.

Alice comienza en el peldaño 1.

Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.
Usando una operación del segundo tipo, sube 2^0 peldaños para llegar al peldaño 1.
Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.

Ejemplo 2:

Entrada: k = 1
Salida: 4
Explicación:
Las 4 formas posibles de llegar al peldaño 1 son:

Alice comienza en el peldaño 1. Alice está en el peldaño 1.
Alice comienza en el peldaño 1.

Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.
Usando una operación del segundo tipo, sube 2^0 peldaños para llegar al peldaño 1.

Alice comienza en el peldaño 1.

Usando una operación del segundo tipo, sube 2^0 peldaños para llegar al peldaño 2.
Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 1.

Alice comienza en el peldaño 1.

Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.
Usando una operación del segundo tipo, sube 2^0 peldaños para llegar al peldaño 1.
Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 0.
Usando una operación del segundo tipo, sube 2^1 peldaños para llegar al peldaño 2.
Usando una operación del primer tipo, baja 1 peldaño para llegar al peldaño 1.

Restricciones:

0 <= k <= 10^9

Se le proporciona un entero no negativo k. Existe una escalera con un número infinito de escalones, siendo el escalón más bajo el número 0.
Alicia tiene un salto entero, con un valor inicial de 0. Comienza en el escalón 1 y quiere llegar al escalón k utilizando cualquier número de operaciones. Si está en el escalón i, en una operación puede:

Bajar al escalón i - 1. Esta operación no se puede utilizar de forma consecutiva ni en el escalón 0.
Subir al escalón i + 2^salto. Y luego, salto se convierte en salto + 1.

Devuelve el número total de formas en que Alicia puede llegar al escalón k.
Tenga en cuenta que es posible que Alicia llegue al escalón k y realice algunas operaciones para llegar al escalón k nuevamente.

Ejemplo 1:

Entrada: k = 0
Salida: 2
Explicación:
Las 2 formas posibles de llegar a la escalera 0 son:

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 0.

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escaleras para llegar a la escalera 1.
Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 0.

Ejemplo 2:

Entrada: k = 1
Salida: 4
Explicación:
Las 4 formas posibles de llegar a la escalera 1 son:

Alicia comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalera para llegar a la escalera 0. primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escalones para llegar a la escalera 1.

Alice comienza en la escalera 1.

Usando una operación del segundo tipo, sube 2^0 escalones para llegar a la escalera 2.
Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 1.

Alice comienza en la escalera 1.

Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^0 escalones para llegar a la escalera 1.
Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 0.
Usando una operación del segundo tipo, sube 2^1 escalones para llegar a la escalera 2.
Usando una operación del primer tipo, baja 1 escalón para llegar a la escalera 1.

 Restricciones:

0 <= k <= 10^9


Se te dan 2 arreglos de enteros nums1 y nums2 de longitudes n y m respectivamente. También se te da un entero positivo k.
Un par (i, j) se llama bueno si nums1[i] es divisible por nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Devuelve el número total de pares buenos.

Ejemplo 1:

Entrada: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Salida: 5
Explicación:
Los 5 pares buenos son (0, 0), (1, 0), (1, 1), (2, 0) y (2, 2).
Ejemplo 2:

Entrada: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Salida: 2
Explicación:
Los 2 pares buenos son (3, 0) y (3, 1).

Restricciones:

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50

Se le dan 2 matrices enteras nums1 y nums2 de longitudes n y m respectivamente. También se le da un número entero positivo k.
Un par (i, j) se llama bueno si nums1[i] es divisible por nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Devuelve el número total de pares buenos.

Ejemplo 1:

Entrada: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Salida: 5
Explicación:
Los 5 pares buenos son (0, 0), (1, 0), (1, 1), (2, 0) y (2, 2).
Ejemplo 2:

Entrada: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Salida: 2
Explicación:
Los 2 pares buenos son (3, 0) y (3, 1).

Restricciones:

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50

Se te dan 2 matrices de enteros nums1 y nums2 de longitudes n y m respectivamente. También se te da un entero positivo k.
Un par (i, j) se llama bueno si nums1[i] es divisible por nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Devuelve el número total de pares buenos.

Ejemplo 1:

Entrada: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Salida: 5
Explicación:
Los 5 pares buenos son (0, 0), (1, 0), (1, 1), (2, 0) y (2, 2).
Ejemplo 2:

Entrada: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Salida: 2
Explicación:
Los 2 pares buenos son (3, 0) y (3, 1).

Condiciones:

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50


Dada una cadena word, comprímela utilizando el siguiente algoritmo:

Comienza con una cadena vacía comp. Mientras word no esté vacía, utiliza la siguiente operación:

Elimina un prefijo de longitud máxima de word formado por un solo carácter c que se repite como máximo 9 veces.
Anexa la longitud del prefijo seguida de c a comp.

Devuelve la cadena comp.

Ejemplo 1:

Entrada: word = "abcde"
Salida: "1a1b1c1d1e"
Explicación:
Inicialmente, comp = "". Aplica la operación 5 veces, eligiendo "a", "b", "c", "d", y "e" como el prefijo en cada operación.
Para cada prefijo, anexa "1" seguido del carácter a comp.

Ejemplo 2:

Entrada: word = "aaaaaaaaaaaaaabb"
Salida: "9a5a2b"
Explicación:
Inicialmente, comp = "". Aplica la operación 3 veces, eligiendo "aaaaaaaaa", "aaaaa", y "bb" como el prefijo en cada operación.

Para el prefijo "aaaaaaaaa", anexa "9" seguido de "a" a comp.
Para el prefijo "aaaaa", anexa "5" seguido de "a" a comp.
Para el prefijo "bb", anexa "2" seguido de "b" a comp.

Restricciones:

1 <= word.length <= 2 * 10^5
word consiste solo de letras minúsculas del alfabeto inglés.

Dada una cadena de caracteres word, comprímela utilizando el siguiente algoritmo:

Comienza con una cadena de caracteres vacía comp. Mientras word no esté vacía, utiliza la siguiente operación:

Elimina un prefijo de longitud máxima de word formado por un solo carácter c que se repita como máximo 9 veces.
Añade la longitud del prefijo seguido de c a comp.

Devuelve la cadena de caracteres comp.

Ejemplo 1:

Entrada: word = "abcde"
Salida: "1a1b1c1d1e"
Explicación:
Inicialmente, comp = "". Aplica la operación 5 veces, eligiendo "a", "b", "c", "d" y "e" como prefijo en cada operación.
Para cada prefijo, añade "1" seguido del carácter a comp.

Ejemplo 2:

Entrada: word = "aaaaaaaaaaaaaabb"
Salida: "9a5a2b"
Explicación:
Inicialmente, comp = "". Aplique la operación 3 veces, eligiendo "aaaaaaaaa", "aaaaa" y "bb" como prefijo en cada operación.

Para el prefijo "aaaaaaaa", agregue "9" seguido de "a" a comp.
Para el prefijo "aaaaa", agregue "5" seguido de "a" a comp.
Para el prefijo "bb", agregue "2" seguido de "b" a comp.

Restricciones:

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

Dada una cadena de caracteres word, comprímela utilizando el siguiente algoritmo:

Comienza con una cadena de caracteres vacía comp. Mientras word no esté vacía, utiliza la siguiente operación:

Elimina un prefijo de longitud máxima de word formado por un único carácter c que se repita como máximo 9 veces.
Añade la longitud del prefijo seguido de c a comp.

Devuelve la cadena de caracteres comp.

Ejemplo 1:

Entrada: word = "abcde"
Salida: "1a1b1c1d1e"
Explicación:
Inicialmente, comp = "". Aplica la operación 5 veces, eligiendo "a", "b", "c", "d" y "e" como prefijo en cada operación.
Para cada prefijo, añade "1" seguido del carácter a comp.

Ejemplo 2:

Entrada: word = "aaaaaaaaaaaaaabb"
Salida: "9a5a2b"
Explicación:
Inicialmente, comp = "". Aplique la operación 3 veces, eligiendo "aaaaaaaaa", "aaaaa" y "bb" como prefijo en cada operación.

Para el prefijo "aaaaaaaa", agregue "9" seguido de "a" a comp.
Para el prefijo "aaaaa", agregue "5" seguido de "a" a comp.
Para el prefijo "bb", agregue "2" seguido de "b" a comp.

Restricciones:

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


Tienes un arreglo nums compuesto por enteros. También se te da un arreglo 2D queries, donde queries[i] = [pos_i, x_i].
Para la consulta i, primero establecemos nums[pos_i] igual a x_i, luego calculamos la respuesta a la consulta i, que es la suma máxima de una subsecuencia de nums donde no se seleccionan dos elementos adyacentes.
Devuelve la suma de las respuestas a todas las consultas.
Dado que la respuesta final puede ser muy grande, devuélvela módulo 10^9 + 7.
Una subsecuencia es un arreglo que puede derivarse de otro arreglo eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Salida: 21
Explicación:
Después de la 1^ra consulta, nums = [3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 3 + 9 = 12.
Después de la 2^da consulta, nums = [-3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 9.

Ejemplo 2:

Entrada: nums = [0,-1], queries = [[0,-5]]
Salida: 0
Explicación:
Después de la 1^ra consulta, nums = [-5,-1] y la suma máxima de una subsecuencia con elementos no adyacentes es 0 (eligiendo una subsecuencia vacía).

Restricciones:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

Tienes un arreay nums compuesto por enteros. También se te da un arreglo 2D queries, donde queries[i] = [pos_i, x_i].
Para la consulta i, primero establecemos nums[pos_i] igual a x_i, luego calculamos la respuesta a la consulta i, que es la suma máxima de una subsecuencia de nums donde no se seleccionan dos elementos adyacentes.
Devuelve la suma de las respuestas a todas las consultas. Dado que la respuesta final puede ser muy grande, devuélvela módulo 10^9 + 7.
Una subsecuencia es un array que puede derivarse de otro array eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Input: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Output: 21
Explicación:
Después de la 1^ra consulta, nums = [3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 3 + 9 = 12.
Después de la 2^da consulta, nums = [-3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 9.

Ejemplo 2:

Input: nums = [0,-1], queries = [[0,-5]]
Output: 0
Explicación:
Después de la 1^ra consulta, nums = [-5,-1] y la suma máxima de una subsecuencia con elementos no adyacentes es 0 (eligiendo una subsecuencia vacía).

Restricciones:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

Se te da un array nums formado por enteros. También se le da una matriz 2D consultas, donde consultas[i] = [pos_i, x_i].
Para la consulta i, primero establecemos nums[pos_i] igual a x_i, luego calculamos la respuesta a la consulta i que es la suma máxima de una subsecuencia de nums donde no se seleccionan dos elementos adyacentes.
Devuelve la suma de las respuestas a todas las consultas.
Como la respuesta final puede ser muy grande, devuélvela módulo 10^9 + 7.
Una subsecuencia es una matriz que puede derivarse de otra matriz eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1

Entrada: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Salida: 21
Explicación:
Tras la 1^ª consulta, nums = [3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 3 + 9 = 12.
Tras la 2ª consulta, nums = [-3,-2,9] y la suma máxima de una subsecuencia con elementos no adyacentes es 9.

Ejemplo 2:

Entrada: nums = [0,-1], queries = [[0,-5]]
Salida: 0
Explicación:
Después de la 1^ª consulta, nums = [-5,-1] y la suma máxima de una subsecuencia con elementos no adyacentes es 0 (eligiendo una subsecuencia vacía).

Restricciones:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5


Dada una cadena s, debe dividirla en una o más subcadenas equilibradas. Por ejemplo, si s == "ababcc", entonces ("abab", "c", "c"), ("ab", "abc", "c") y ("ababcc") son particiones válidas, pero ("a", "bab", "cc"), ("aba", "bc", "c") y ("ab", "abcc") no lo son. Las subcadenas no equilibradas están en negrita.
Devuelve el número mínimo de subcadenas en las que puede dividir s.
Nota: Una cadena equilibrada es una cadena en la que cada carácter de la cadena aparece la misma cantidad de veces.

Ejemplo 1:

Entrada: s = "fabccddg"
Salida: 3
Explicación:
Podemos dividir la cadena s en 3 subcadenas de una de las siguientes maneras: ("fab, "ccdd", "g") o ("fabc", "cd", "dg").

Ejemplo 2:

Entrada: s = "abababaccddb"
Salida: 2
Explicación:
Podemos dividir la cadena s en 2 subcadenas de la siguiente manera: ("abab", "abaccddb").

Restricciones:

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

Dada una cadena s, necesitas dividirla en una o más subcadenas balanceadas. Por ejemplo, si s == "ababcc" entonces ("abab", "c", "c"), ("ab", "abc", "c") y ("ababcc") son particiones válidas, pero ("a", "bab", "cc"), ("aba", "bc", "c") y ("ab", "abcc") no lo son. Las subcadenas desbalanceadas están en negrita.
Devuelve el número mínimo de subcadenas en las que puedes dividir s.
Nota: Una cadena balanceada es una cadena donde cada carácter en la cadena ocurre el mismo número de veces.

Ejemplo 1:

Entrada: s = "fabccddg"
Salida: 3
Explicación:
Podemos dividir la cadena s en 3 subcadenas de la siguiente manera: ("fab, "ccdd", "g"), o ("fabc", "cd", "dg").

Ejemplo 2:

Entrada: s = "abababaccddb"
Salida: 2
Explicación:
Podemos dividir la cadena s en 2 subcadenas así: ("abab", "abaccddb").

Restricciones:

1 <= s.length <= 1000
s consiste solo de letras minúsculas del alfabeto inglés.