Se te da un array de enteros nums de tamaño n indexado desde 0 que representa el costo de recolectar diferentes chocolates. El costo de recolectar el chocolate en el índice i es nums[i]. Cada chocolate es de un tipo diferente, y inicialmente, el chocolate en el índice i es del tipo i.
En una operación, puedes hacer lo siguiente con un costo incurrido de x:

Cambiar simultáneamente el chocolate del tipo i al tipo ((i + 1) mod n) para todos los chocolates.

Devuelve el costo mínimo para recolectar chocolates de todos los tipos, dado que puedes realizar tantas operaciones como desees.

Ejemplo 1:

Entrada: nums = [20,1,15], x = 5
Salida: 13
Explicación: Inicialmente, los tipos de chocolate son [0,1,2]. Compraremos el chocolate de tipo 1 a un costo de 1.
Ahora, realizaremos la operación a un costo de 5, y los tipos de chocolates se convertirán en [1,2,0]. Compraremos el chocolate de tipo 2 a un costo de 1.
Ahora, realizaremos nuevamente la operación a un costo de 5, y los tipos de chocolate se convertirán en [2,0,1]. Compraremos el chocolate de tipo 0 a un costo de 1.
Por lo tanto, el costo total será (1 + 5 + 1 + 5 + 1) = 13. Podemos demostrar que esto es óptimo.

Ejemplo 2:

Entrada: nums = [1,2,3], x = 4
Salida: 6
Explicación: Recolectaremos los tres tipos de chocolates a su propio precio sin realizar ninguna operación. Por lo tanto, el costo total es 1 + 2 + 3 = 6.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0, nums, de tamaño n, que representa el costo de recolectar diferentes chocolates. El costo de recolectar el chocolate en el índice i es nums[i]. Cada chocolate es de un tipo diferente e inicialmente, el chocolate en el índice i es del tipo i^th.
En una operación, puede hacer lo siguiente con un costo incurrido de x:

Cambiar simultáneamente el chocolate del tipo i^th al tipo ((i + 1) mod n)^th para todos los chocolates.

Devolver el costo mínimo para recolectar chocolates de todos los tipos, dado que puede realizar tantas operaciones como desee.

Ejemplo 1:

Entrada: nums = [20,1,15], x = 5
Salida: 13
Explicación: Inicialmente, los tipos de chocolate son [0,1,2]. Compraremos el 1^er tipo de chocolate a un coste de 1.
Ahora, realizaremos la operación a un coste de 5, y los tipos de chocolates pasarán a ser [1,2,0]. Compraremos el 2^do^ tipo de chocolate a un coste de 1.
Ahora, realizaremos de nuevo la operación a un coste de 5, y los tipos de chocolate pasarán a ser [2,0,1]. Compraremos el 0^o tipo de chocolate a un coste de 1.
Por tanto, el coste total pasará a ser (1 + 5 + 1 + 5 + 1) = 13. Podemos demostrar que esto es óptimo.

Ejemplo 2:

Entrada: nums = [1,2,3], x = 4
Salida: 6
Explicación: Recogeremos los tres tipos de chocolates a su propio precio sin realizar ninguna operación. Por lo tanto, el costo total es 1 + 2 + 3 = 6.

Restricciones:

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

Se te da un array de enteros nums de tamaño n indexado desde 0 que representa el costo de recolectar diferentes chocolates. El costo de recolectar el chocolate en el índice i es nums[i]. Cada chocolate es de un tipo diferente, y inicialmente, el chocolate en el índice i es del tipo i.
En una operación, puedes hacer lo siguiente con un costo incurrido de x:

Cambiar simultáneamente el chocolate del tipo i al tipo ((i + 1) mod n) para todos los chocolates.

Devuelve el costo mínimo para recolectar chocolates de todos los tipos, dado que puedes realizar tantas operaciones como desees.

Ejemplo 1:

Entrada: nums = [20,1,15], x = 5
Salida: 13
Explicación: Inicialmente, los tipos de chocolate son [0,1,2]. Compraremos el chocolate de tipo 1 a un costo de 1.
Ahora, realizaremos la operación a un costo de 5, y los tipos de chocolates se convertirán en [1,2,0]. Compraremos el chocolate de tipo 2 a un costo de 1.
Ahora, realizaremos nuevamente la operación a un costo de 5, y los tipos de chocolate se convertirán en [2,0,1]. Compraremos el chocolate de tipo 0 a un costo de 1.
Por lo tanto, el costo total será (1 + 5 + 1 + 5 + 1) = 13. Podemos demostrar que esto es óptimo.

Ejemplo 2:

Entrada: nums = [1,2,3], x = 4
Salida: 6
Explicación: Recolectaremos los tres tipos de chocolates a su propio precio sin realizar ninguna operación. Por lo tanto, el costo total es 1 + 2 + 3 = 6.1 + 2 + 3 = 6.

Restricciones:

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


Se te dan dos enteros, n y k.
Un arreglo de enteros positivos distintos se llama un arreglo que evita k si no existe ningún par de elementos distintos cuya suma sea k.
Devuelve la suma mínima posible de un arreglo que evita k de longitud n.

Ejemplo 1:

Entrada: n = 5, k = 4
Salida: 18
Explicación: Considera el arreglo que evita k [1,2,4,5,6], que tiene una suma de 18.
Se puede demostrar que no existe un arreglo que evita k con una suma menor que 18.

Ejemplo 2:

Entrada: n = 2, k = 6
Salida: 3
Explicación: Podemos construir el arreglo [1,2], que tiene una suma de 3.
Se puede demostrar que no existe un arreglo que evita k con una suma menor que 3.

Restricciones:

1 <= n, k <= 50

Se te dan dos enteros, n y k.
Un array de enteros positivos distintos se llama un array que evita k si no existe ningún par de elementos distintos cuya suma sea k.
Devuelve la suma mínima posible de un array que evita k de longitud n.

Ejemplo 1:

Entrada: n = 5, k = 4
Salida: 18
Explicación: Considera el arreglo que evita k [1,2,4,5,6], que tiene una suma de 18.
Se puede demostrar que no existe un array que evita k con una suma menor que 18.

Ejemplo 2:

Entrada: n = 2, k = 6
Salida: 3
Explicación: Podemos construir el arreglo [1,2], que tiene una suma de 3.
Se puede demostrar que no existe un arreglo que evita k con una suma menor que 3.

Restricciones:

1 <= n, k <= 50

Se le proporcionan dos números enteros, n y k.
Una matriz de números enteros positivos distintos se denomina matriz que evita el número k si no existe ningún par de elementos distintos que sumen k.
Devuelve la suma mínima posible de una matriz que evita el número k de longitud n.

Ejemplo 1:

Entrada: n = 5, k = 4
Salida: 18
Explicación: Considere la matriz que evita k [1,2,4,5,6], que tiene una suma de 18.
Se puede demostrar que no existe ninguna matriz que evite k con una suma menor que 18.

Ejemplo 2:

Entrada: n = 2, k = 6
Salida: 3
Explicación: Podemos construir la matriz [1,2], que tiene una suma de 3.
Se puede demostrar que no existe ninguna matriz que evite k con una suma menor que 3.

Restricciones:

1 <= n, k <= 50


Se te dan dos enteros, num y t.
Un entero x se llama alcanzable si puede ser igual a num después de aplicar la siguiente operación no más de t veces:

Aumentar o disminuir x en 1, y simultáneamente aumentar o disminuir num en 1.

Devuelve el número máximo posible alcanzable. Se puede probar que existe al menos un número alcanzable.

Ejemplo 1:

Entrada: num = 4, t = 1
Salida: 6
Explicación: El número máximo alcanzable es x = 6; puede ser igual a num después de realizar esta operación:
1- Disminuir x en 1, y aumentar num en 1. Ahora, x = 5 y num = 5.
Se puede probar que no hay un número alcanzable mayor que 6.

Ejemplo 2:

Entrada: num = 3, t = 2
Salida: 7
Explicación: El número máximo alcanzable es x = 7; después de realizar estas operaciones, x será igual a num:
1- Disminuir x en 1, y aumentar num en 1. Ahora, x = 6 y num = 4.
2- Disminuir x en 1, y aumentar num en 1. Ahora, x = 5 y num = 5.
Se puede probar que no hay un número alcanzable mayor que 7.

Restricciones:

1 <= num, t <= 50

Se le proporcionan dos números enteros, num y t.
Un número entero x se considera alcanzable si puede llegar a ser igual a num después de aplicar la siguiente operación no más de t veces:

Aumentar o disminuir x en 1 y, simultáneamente, aumentar o disminuir num en 1.

Devolver el máximo número posible alcanzable. Se puede demostrar que existe al menos un número alcanzable.

Ejemplo 1:

Entrada: num = 4, t = 1
Salida: 6
Explicación: El máximo número alcanzable es x = 6; puede llegar a ser igual a num después de realizar esta operación:
1- Disminuir x en 1 y aumentar num en 1. Ahora, x = 5 y num = 5.
Se puede demostrar que no hay ningún número alcanzable mayor que 6.

Ejemplo 2:

Entrada: num = 3, t = 2
Salida: 7
Explicación: El número máximo alcanzable es x = 7; después de realizar estas operaciones, x será igual a num:

1- Disminuir x en 1 y aumentar num en 1. Ahora, x = 6 y num = 4.
2- Disminuir x en 1 y aumentar num en 1. Ahora, x = 5 y num = 5.
Se puede demostrar que no hay ningún número alcanzable mayor que 7.

Restricciones:

1 <= num, t <= 50


Dada una cadena s que consiste en letras minúsculas del alfabeto inglés, se te permite realizar operaciones sobre ella. En una operación, puedes reemplazar un carácter en s con otra letra minúscula del alfabeto inglés.
Tu tarea es hacer que s sea un palíndromo con el número mínimo de operaciones posible. Si hay múltiples palíndromos que se pueden crear usando el número mínimo de operaciones, haz el menor lexicográficamente.
Una cadena a es lexicográficamente menor que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, la cadena a tiene una letra que aparece antes en el alfabeto que la letra correspondiente en b.
Devuelve la cadena palíndromo resultante.

Ejemplo 1:

Entrada: s = "egcfe"
Salida: "efcfe"
Explicación: El número mínimo de operaciones para hacer "egcfe" un palíndromo es 1, y la cadena palíndromo más pequeña lexicográficamente que podemos obtener modificando un carácter es "efcfe", cambiando 'g'.

Ejemplo 2:

Entrada: s = "abcd"
Salida: "abba"
Explicación: El número mínimo de operaciones para hacer "abcd" un palíndromo es 2, y la cadena palíndromo más pequeña lexicográficamente que podemos obtener modificando dos caracteres es "abba".

Ejemplo 3:

Entrada: s = "seven"
Salida: "neven"
Explicación: El número mínimo de operaciones para hacer "seven" un palíndromo es 1, y la cadena palíndromo más pequeña lexicográficamente que podemos obtener modificando un carácter es "neven".

Restricciones:

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

Se le proporciona una cadena s que consta de letras minúsculas en inglés y se le permite realizar operaciones sobre ella. En una operación, puede reemplazar un carácter en s con otra letra minúscula en inglés.
Su tarea es hacer que s sea un palíndromo con la mínima cantidad de operaciones posibles. Si hay múltiples palíndromos que se pueden hacer usando la mínima cantidad de operaciones, haga el más pequeño lexicográficamente.
Una cadena a es lexicográficamente más pequeña que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, la cadena a tiene una letra que aparece antes en el alfabeto que la letra correspondiente en b.
Devuelve la cadena palíndromo resultante.

Ejemplo 1:

Entrada: s = "egcfe"
Salida: "efcfe"
Explicación: La cantidad mínima de operaciones para hacer que "egcfe" sea un palíndromo es 1, y la cadena palíndromo lexicográficamente más pequeña que podemos obtener modificando un carácter es "efcfe", cambiando 'g'.

Ejemplo 2:

Entrada: s = "abcd"
Salida: "abba"
Explicación: El número mínimo de operaciones para hacer que "abcd" sea un palíndromo es 2, y la cadena de palíndromo lexicográficamente más pequeña que podemos obtener modificando dos caracteres es "abba".

Ejemplo 3:

Entrada: s = "seven"
Salida: "neven"
Explicación: El número mínimo de operaciones para hacer que "seven" sea un palíndromo es 1, y la cadena de palíndromo lexicográficamente más pequeña que podemos obtener modificando un carácter es "neven".

Restricciones:

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


Te dan una cadena binaria indexada en 0, \( s \), de longitud \( n \) sobre la cual puedes aplicar dos tipos de operaciones:

Elige un índice \( i \) e invierte todos los caracteres desde el índice 0 hasta el índice \( i \) (ambos inclusive), con un costo de \( i + 1 \).
Elige un índice \( i \) e invierte todos los caracteres desde el índice \( i \) hasta el índice \( n - 1 \) (ambos inclusive), con un costo de \( n - i \).

Devuelve el costo mínimo para hacer iguales todos los caracteres de la cadena.
Invertir un carácter significa que si su valor es '0' se convierte en '1' y viceversa.

Ejemplo 1:

Entrada: s = "0011"
Salida: 2
Explicación: Aplica la segunda operación con \( i = 2 \) para obtener \( s = "0000" \) por un costo de 2. Se puede demostrar que 2 es el costo mínimo para hacer todos los caracteres iguales.

Ejemplo 2:

Entrada: s = "010101"
Salida: 9
Explicación: Aplica la primera operación con \( i = 2 \) para obtener \( s = "101101" \) por un costo de 3.
Aplica la primera operación con \( i = 1 \) para obtener \( s = "011101" \) por un costo de 2.
Aplica la primera operación con \( i = 0 \) para obtener \( s = "111101" \) por un costo de 1.
Aplica la segunda operación con \( i = 4 \) para obtener \( s = "111110" \) por un costo de 2.
Aplica la segunda operación con \( i = 5 \) para obtener \( s = "111111" \) por un costo de 1.
El costo total para hacer iguales todos los caracteres es 9. Se puede demostrar que 9 es el costo mínimo para hacer iguales todos los caracteres.

Restricciones:

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

Se le proporciona una cadena binaria s con índice 0 y longitud n sobre la que puede aplicar dos tipos de operaciones:

Elija un índice i e invierta todos los caracteres desde el índice 0 hasta el índice i (ambos incluidos), con un coste de i + 1
Elija un índice i e invierta todos los caracteres desde el índice i hasta el índice n - 1 (ambos incluidos), con un coste de n - i

Devuelva el coste mínimo para que todos los caracteres de la cadena sean iguales.
Invertir un carácter significa que si su valor es '0' se convierte en '1' y viceversa.

Ejemplo 1:

Entrada: s = "0011"
Salida: 2
Explicación: Aplique la segunda operación con i = 2 para obtener s = "0000" con un coste de 2. Se puede demostrar que 2 es el coste mínimo para que todos los caracteres sean iguales.

Ejemplo 2:

Entrada: s = "010101"
Salida: 9
Explicación: Aplique la primera operación con i = 2 para obtener s = "101101" con un costo de 3.
Aplique la primera operación con i = 1 para obtener s = "011101" con un costo de 2.
Aplique la primera operación con i = 0 para obtener s = "111101" con un costo de 1.
Aplique la segunda operación con i = 4 para obtener s = "111110" con un costo de 2.
Aplique la segunda operación con i = 5 para obtener s = "111111" con un costo de 1.
El costo total para que todos los caracteres sean iguales es 9. Se puede demostrar que 9 es el costo mínimo para que todos los caracteres sean iguales.

Restricciones:

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

Te dan una cadena binaria indexada en 0, s, de longitud n sobre la cual puedes aplicar dos tipos de operaciones:

Elige un índice i e invierte todos los caracteres desde el índice 0 hasta el índice i (ambos inclusive), con un costo de i + 1
Elige un índice i e invierte todos los caracteres desde el índice i hasta el índice n - 1 (ambos inclusive), con un costo de n - i

Devuelve el costo mínimo para hacer iguales todos los caracteres de la cadena.
Invertir un carácter significa que si su valor es '0' se convierte en '1' y viceversa.

Ejemplo 1:

Entrada: s = "0011"
Salida: 2
Explicación: Aplica la segunda operación con i = 2 para obtener s = "0000" por un costo de 2. Se puede demostrar que 2 es el costo mínimo para hacer todos los caracteres iguales.

Ejemplo 2:

Entrada: s = "010101"
Salida: 9
Explicación: Aplica la primera operación con i = 2 para obtener s = "101101" por un costo de 3.
Aplica la primera operación con i = 1 para obtener s = "011101" por un costo de 2.
Aplica la primera operación con i = 0 para obtener s = "111101" por un costo de 1.
Aplica la segunda operación con i = 4 para obtener s = "111110" por un costo de 2.
Aplica la segunda operación con i = 5 para obtener s = "111111" por un costo de 1.
El costo total para hacer iguales todos los caracteres es 9. Se puede demostrar que 9 es el costo mínimo para hacer iguales todos los caracteres.

Restricciones:

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


Dado un entero positivo num representado como una cadena, devuelve el entero num sin ceros finales como una cadena.

Ejemplo 1:

Entrada: num = "51230100"
Salida: "512301"
Explicación: El entero "51230100" tiene 2 ceros finales, los eliminamos y devolvemos el entero "512301".

Ejemplo 2:

Entrada: num = "123"
Salida: "123"
Explicación: El entero "123" no tiene ceros finales, devolvemos el entero "123".

Restricciones:

1 <= num.length <= 1000
num consta solo de dígitos.
num no tiene ceros iniciales.

Dado un entero positivo num representado como una cadena, devuelve el entero num sin ceros finales como una cadena.

Ejemplo 1:

Entrada: num = "51230100"
Salida: "512301"
Explicación: El entero "51230100" tiene 2 ceros finales, los eliminamos y devolvemos el entero "512301".

Ejemplo 2:

Entrada: num = "123"
Salida: "123"
Explicación: El entero "123" no tiene ceros finales, devolvemos el entero "123".

Condiciones:

1 <= num.length <= 1000
num consiste solo en dígitos.
num no tiene ceros iniciales.


Se te da un entero n que consta de exactamente 3 dígitos. Llamamos al número n fascinante si, después de la siguiente modificación, el número resultante contiene todos los dígitos del 1 al 9 exactamente una vez y no contiene ningún 0:

Concatena n con los números 2 * n y 3 * n.

Devuelve true si n es fascinante, o false en caso contrario. Concatener dos números significa unirlos. Por ejemplo, la concatenación de 121 y 371 es 121371.

Ejemplo 1:

Entrada: n = 192
Salida: true
Explicación: Concatenamos los números n = 192 y 2 * n = 384 y 3 * n = 576. El número resultante es 192384576. Este número contiene todos los dígitos del 1 al 9 exactamente una vez.

Ejemplo 2:

Entrada: n = 100
Salida: false
Explicación: Concatenamos los números n = 100 y 2 * n = 200 y 3 * n = 300. El número resultante es 100200300. Este número no satisface ninguna de las condiciones.

Restricciones:

100 <= n <= 999

Se da un número entero n que consta exactamente de 3 cifras.
Llamamos al número n fascinante si, después de la siguiente modificación, el número resultante contiene todos los dígitos del 1 al 9 exactamente una vez y no contiene ningún 0:

Concatene n con los números 2 * n y 3 * n.

Devuelve true si n es fascinante, o false en caso contrario.
Concatenar dos números significa unirlos. Por ejemplo, la concatenación de 121 y 371 es 121371.

Ejemplo 1:

Entrada: n = 192
Salida: true
Explicación: Concatenamos los números n = 192 y 2 * n = 384 y 3 * n = 576. El número resultante es . El número resultante es 192384576. Este número contiene todos los dígitos del 1 al 9 exactamente una vez.

Ejemplo 2:

Entrada: n = 100
Salida: false
Explicación: Concatenamos los números n = 100 y 2 * n = 200 y 3 * n = 300. El número resultante es . El número resultante es 100200300. Este número no cumple ninguna de las condiciones.

Restricciones:

100 <= n <= 999

Se le proporciona un número entero n que consta de exactamente 3 dígitos.
Decimos que el número n es fascinante si, después de la siguiente modificación, el número resultante contiene todos los dígitos del 1 al 9 exactamente una vez y no contiene ningún 0:

Concatene n con los números 2 * n y 3 * n.

Devuelve true si n es fascinante o false en caso contrario.Concatenar dos números significa unirlos. Por ejemplo, la concatenación de 121 y 371 es 121371.

Ejemplo 1:

Entrada: n = 192
Salida: true
Explicación: Concatenamos los números n = 192 y 2 * n = 384 y 3 * n = 576. El número resultante es 192384576. Este número contiene todos los dígitos del 1 al 9 exactamente una vez.

Ejemplo 2:

Entrada: n = 100
Salida: false
Explicación: Concatenamos los números n = 100 y 2 * n = 200 y 3 * n = 300. El número resultante es 100200300. Este número no satisface ninguna de las condiciones.

Restricciones:

100 <= n <= 999


Dada una cadena de caracteres s indexada desde 0, realiza repetidamente la siguiente operación cualquier cantidad de veces:

Elige un índice i en la cadena y deja que c sea el carácter en la posición i. Elimina la aparición más cercana de c a la izquierda de i (si existe) y la aparición más cercana de c a la derecha de i (si existe).

Tu tarea es minimizar la longitud de s realizando la operación anterior cualquier cantidad de veces.
Devuelve un entero que denote la longitud de la cadena minimizada.

Ejemplo 1:

Entrada: s = "aaabc"
Salida: 3
Explicación: En este ejemplo, s es "aaabc". Podemos comenzar seleccionando el carácter 'a' en el índice 1. Luego eliminamos la 'a' más cercana a la izquierda del índice 1, que está en el índice 0, y la 'a' más cercana a la derecha del índice 1, que está en el índice 2. Después de esta operación, la cadena se convierte en "abc". Cualquier operación adicional que realizamos en la cadena la dejará sin cambios. Por lo tanto, la longitud de la cadena minimizada es 3.

Ejemplo 2:

Entrada: s = "cbbd"
Salida: 3
Explicación: Para esto, podemos comenzar con el carácter 'b' en el índice 1. No hay ocurrencia de 'b' a la izquierda del índice 1, pero hay una a la derecha en el índice 2, por lo que eliminamos la 'b' en el índice 2. La cadena se convierte en "cbd" y más operaciones la dejarán sin cambios. Por lo tanto, la longitud minimizada es 3.

Ejemplo 3:

Entrada: s = "dddaaa"
Salida: 2
Explicación: Para esto, podemos comenzar con el carácter 'd' en el índice 1. La ocurrencia más cercana de una 'd' a su izquierda está en el índice 0, y la ocurrencia más cercana de una 'd' a su derecha está en el índice 2. Eliminamos ambos índices 0 y 2, por lo que la cadena se convierte en "daaa". En la nueva cadena, podemos seleccionar el carácter 'a' en el índice 2. La ocurrencia más cercana de una 'a' a su izquierda está en el índice 1, y la ocurrencia más cercana de una 'a' a su derecha está en el índice 3. Eliminamos ambos, y la cadena se convierte en "da". No podemos minimizar esto más, por lo que la longitud minimizada es 2.

Restricciones:

1 <= s.length <= 100
s contiene solo letras minúsculas inglesas

Dada una cadena s con índice 0, realice repetidamente la siguiente operación cualquier número de veces:

Elija un índice i en la cadena, y sea c el carácter en la posición i. Borre la aparición más cercana de c a la izquierda de i (si la hay) y la aparición más cercana de c a la derecha de i (si la hay).

Su tarea consiste en minimizar la longitud de s realizando la operación anterior cualquier número de veces.
Devuelve un número entero que denota la longitud de la cadena minimizada.

Ejemplo 1

Entrada: s = "aaabc"
Salida: 3
Explicación: En este ejemplo, s es "aaabc". Podemos comenzar seleccionando el carácter "a" en el índice 1. Luego eliminamos la "a" más cercana a la izquierda del índice 1, que está en el índice 0, y la "a" más cercana a la derecha del índice 1, que está en el índice 2. Después de esta operación, la cadena se convierte en "abc". Cualquier operación posterior que realicemos en la cadena la dejará sin cambios. Por lo tanto, la longitud de la cadena minimizada es 3.
Ejemplo 2:

Entrada: s = "cbbd"
Salida: 3
Explicación: Para esto podemos empezar con el carácter 'b' en el índice 1. No hay ninguna ocurrencia de 'b' a la izquierda del índice 1, pero hay una a la derecha en el índice 2, así que borramos la 'b' en el índice 2. La cadena se convierte en "cbd" y las operaciones posteriores la dejarán sin cambios. La cadena se convierte en "cbd" y las operaciones posteriores la dejarán sin cambios. Por lo tanto, la longitud minimizada es 3.

Ejemplo 3

Entrada: s = "dddaaa"
Salida: 2
Explicación: Para esto, podemos empezar con el carácter 'd' en el índice 1. La ocurrencia más cercana de una 'd' a su izquierda está en el índice 0, y la ocurrencia más cercana de una 'd' a su derecha está en el índice 2. Eliminamos tanto el índice 0 como el 2, por lo que la cadena se convierte en "daaa". En la nueva cadena, podemos seleccionar el carácter 'a' en el índice 2. La ocurrencia más cercana de una 'a' a su izquierda está en el índice 1, y la ocurrencia más cercana de una 'a' a su derecha está en el índice 3. Eliminamos ambos, y la cadena se convierte en "da". No podemos minimizar esto más, por lo que la longitud minimizada es 2.

Restricciones:

1 <= s.length <= 100
s sólo contiene letras minúsculas inglesas


Dado un array de enteros nums indexado desde 0, se te permite recorrer sus índices. Puedes recorrer entre el índice i y el índice j, i != j, si y solo si gcd(nums[i], nums[j]) > 1, donde gcd es el máximo común divisor.
Tu tarea es determinar si para cada par de índices i y j en nums, donde i < j, existe una secuencia de recorridos que nos pueda llevar de i a j.
Devuelve true si es posible recorrer entre todos esos pares de índices, o false en caso contrario.

Ejemplo 1:

Entrada: nums = [2,3,6]
Salida: true
Explicación: En este ejemplo, hay 3 pares posibles de índices: (0, 1), (0, 2) y (1, 2).
Para ir del índice 0 al índice 1, podemos usar la secuencia de recorridos 0 -> 2 -> 1, donde nos movemos del índice 0 al índice 2 porque gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, y luego nos movemos del índice 2 al índice 1 porque gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Para ir del índice 0 al índice 2, podemos ir directamente porque gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Del mismo modo, para ir del índice 1 al índice 2, podemos ir directamente porque gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Ejemplo 2:

Entrada: nums = [3,9,5]
Salida: false
Explicación: Ninguna secuencia de recorridos puede llevarnos del índice 0 al índice 2 en este ejemplo. Por lo tanto, devolvemos false.

Ejemplo 3:

Entrada: nums = [4,3,12,8]
Salida: true
Explicación: Hay 6 pares posibles de índices para recorrer entre ellos: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) y (2, 3). Existe una secuencia válida de recorridos para cada par, por lo que devolvemos true.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums y se le permite recorrer entre sus índices. Puede recorrer entre el índice i y el índice j, i != j, si y solo si mcd(nums[i], nums[j]) > 1, donde mcd es el máximo común divisor.
Su tarea es determinar si para cada par de índices i y j en nums, donde i < j, existe una secuencia de recorridos que nos puede llevar de i a j.
Devuelve verdadero si es posible recorrer entre todos esos pares de índices, o falso en caso contrario.

Ejemplo 1:

Entrada: nums = [2,3,6]
Salida: true
Explicación: En este ejemplo, hay 3 pares de índices posibles: (0, 1), (0, 2) y (1, 2).
Para ir del índice 0 al índice 1, podemos usar la secuencia de recorridos 0 -> 2 -> 1, donde nos movemos del índice 0 al índice 2 porque mcd(nums[0], nums[2]) = mcd(2, 6) = 2 > 1, y luego nos movemos del índice 2 al índice 1 porque mcd(nums[2], nums[1]) = mcd(6, 3) = 3 > 1.
Para ir del índice 0 al índice 2, podemos ir directamente porque mcd(nums[0], nums[2]) = mcd(2, 6) = 2 > 1. Del mismo modo, para ir del índice 1 al índice 2, podemos ir directamente porque mcd(nums[1], nums[2]) = mcd(3, 6) = 3 > 1.

Ejemplo 2:

Entrada: nums = [3,9,5]
Salida: false
Explicación: Ninguna secuencia de recorridos puede llevarnos del índice 0 al índice 2 en este ejemplo. Por lo tanto, devolvemos false.

Ejemplo 3:

Entrada: nums = [4,3,12,8]
Salida: true
Explicación: Hay 6 pares de índices posibles para recorrer entre: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) y (2, 3). Existe una secuencia válida de recorridos para cada par, por lo que devolvemos true.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums y se le permite recorrer entre sus índices. Puede recorrer entre el índice i y el índice j, i != j, si y solo si gcd(nums[i], nums[j]) > 1, donde mcd es el máximo común divisor.
Su tarea es determinar si para cada par de índices i y j en nums, donde i < j, existe una secuencia de recorridos que nos puede llevar de i a j.
Devuelve true si es posible recorrer entre todos esos pares de índices, o false en caso contrario.

Ejemplo 1:

Entrada: nums = [2,3,6]
Salida: true
Explicación: En este ejemplo, hay 3 pares de índices posibles: (0, 1), (0, 2) y (1, 2).
Para ir del índice 0 al índice 1, podemos usar la secuencia de recorridos 0 -> 2 -> 1, donde nos movemos del índice 0 al índice 2 porque gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, y luego nos movemos del índice 2 al índice 1 porque gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Para ir del índice 0 al índice 2, podemos ir directamente porque gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Del mismo modo, para ir del índice 1 al índice 2, podemos ir directamente porque gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Ejemplo 2:

Entrada: nums = [3,9,5]
Salida: false
Explicación: Ninguna secuencia de recorridos puede llevarnos del índice 0 al índice 2 en este ejemplo. Por lo tanto, devolvemos false.

Ejemplo 3:

Entrada: nums = [4,3,12,8]
Salida: true
Explicación: Hay 6 pares de índices posibles para recorrer entre: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) y (2, 3). Existe una secuencia válida de recorridos para cada par, por lo que devolvemos true.

Restricciones:

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


Se le da una cadena s que consta solo de letras inglesas minúsculas. En una operación, puede hacer lo siguiente:

Seleccione cualquier subcadena no vacía de s, posiblemente la cadena completa, y luego reemplace cada uno de sus caracteres con el carácter anterior del alfabeto inglés. Por ejemplo, 'b' se convierte en 'a' y 'a' se convierte en 'z'.

Devuelva la cadena lexicográficamente más pequeña que pueda obtener después de realizar la operación anterior exactamente una vez.
Una subcadena es una secuencia contigua de caracteres en una cadena.
Una cadena x es lexicográficamente más pequeña que una cadena y de la misma longitud si x[i] va antes de y[i] en orden alfabético para la primera posición i tal que x[i] != y[i].

Ejemplo 1:

Entrada: s = "cbabc"
Salida: "baabc"
Explicación: Aplicamos la operación en la subcadena comenzando en el índice 0 y terminando en el índice 1 inclusive.
Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Ejemplo 2:

Entrada: s = "acbbc"
Salida: "abaab"
Explicación: Aplicamos la operación en la subcadena comenzando en el índice 1 y terminando en el índice 4 inclusive.
Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Ejemplo 3:

Entrada: s = "leetcode"
Salida: "kddsbncd"
Explicación: Aplicamos la operación en toda la cadena.
Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Restricciones:

1 <= s.length <= 3 * 10^5
s consta de letras inglesas minúsculas

Se le proporciona una cadena s que consta únicamente de letras minúsculas del alfabeto inglés. En una operación, puede hacer lo siguiente:

Seleccione cualquier subcadena no vacía de s, posiblemente la cadena completa, luego reemplace cada uno de sus caracteres con el carácter anterior del alfabeto inglés. Por ejemplo, 'b' se convierte en 'a' y 'a' se convierte en 'z'.

Devuelva la cadena lexicográficamente más pequeña que pueda obtener después de realizar la operación anterior exactamente una vez.
Una subcadena es una secuencia contigua de caracteres en una cadena.
Una cadena x es lexicográficamente más pequeña que una cadena y de la misma longitud si x[i] viene antes de y[i] en orden alfabético para la primera posición i de modo que x[i] != y[i].

Ejemplo 1:

Entrada: s = "cbabc"
Salida: "baabc"
Explicación: Aplicamos la operación en la subcadena que comienza en el índice 0 y termina en el índice 1 inclusive. Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Ejemplo 2:

Entrada: s = "acbbc"
Salida: "abaab"
Explicación: Aplicamos la operación a la subcadena que comienza en el índice 1 y termina en el índice 4 inclusive.
Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Ejemplo 3:

Entrada: s = "leetcode"
Salida: "kddsbncd"
Explicación: Aplicamos la operación a la cadena completa.
Se puede demostrar que la cadena resultante es la más pequeña lexicográficamente.

Restricciones:

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

Se te da una cadena s que consiste únicamente en letras minúsculas del alfabeto inglés. En una operación, puedes hacer lo siguiente:

Selecciona cualquier subcadena no vacía de s, posiblemente la cadena completa, y reemplaza cada uno de sus caracteres con el carácter anterior del alfabeto inglés. Por ejemplo, 'b' se convierte en 'a' y 'a' se convierte en 'z'.

Devuelve la cadena lexicográficamente más pequeña que puedes obtener después de realizar la operación anterior exactamente una vez. Una subcadena es una secuencia continua de caracteres en una cadena. Una cadena x es lexicográficamente menor que una cadena y de la misma longitud si x[i] viene antes que y[i] en orden alfabético para la primera posición i tal que x[i] ≠ y[i].

Ejemplo 1:

Entrada: s = "cbabc"
Salida: "baabc"
Explicación: Aplicamos la operación en la subcadena que comienza en el índice 0 y termina en el índice 1 inclusive. Se puede probar que la cadena resultante es la lexicográficamente más pequeña.

Ejemplo 2:

Entrada: s = "acbbc"
Salida: "abaab"
Explicación: Aplicamos la operación en la subcadena que comienza en el índice 1 y termina en el índice 4 inclusive. Se puede probar que la cadena resultante es la lexicográficamente más pequeña.

Ejemplo 3:

Entrada: s = "leetcode"
Salida: "kddsbncd"
Explicación: Aplicamos la operación en toda la cadena. Se puede probar que la cadena resultante es la lexicográficamente más pequeña.

Restricciones:

1 <= s.longitud <= 3 * 10^5
s consiste en letras minúsculas del alfabeto inglés.


Se te da un array de enteros nums indexado desde 0. Un par de índices i, j donde 0 <= i < j < nums.length se llama hermoso si el primer dígito de nums[i] y el último dígito de nums[j] son coprimos.
Devuelve el número total de pares hermosos en nums.
Dos enteros x e y son coprimos si no hay un entero mayor que 1 que divida a ambos.
En otras palabras, x e y son coprimos si gcd(x, y) == 1, donde gcd(x, y) es el máximo común divisor de x e y.

Ejemplo 1:

Entrada: nums = [2,5,1,4]
Salida: 5
Explicación: Hay 5 pares hermosos en nums:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 2, y el último dígito de nums[1] es 5. Podemos confirmar que 2 y 5 son coprimos, ya que gcd(2,5) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 2, y el último dígito de nums[2] es 1. De hecho, gcd(2,1) == 1.
Cuando i = 1 y j = 2: el primer dígito de nums[1] es 5, y el último dígito de nums[2] es 1. De hecho, gcd(5,1) == 1.
Cuando i = 1 y j = 3: el primer dígito de nums[1] es 5, y el último dígito de nums[3] es 4. De hecho, gcd(5,4) == 1.
Cuando i = 2 y j = 3: el primer dígito de nums[2] es 1, y el último dígito de nums[3] es 4. De hecho, gcd(1,4) == 1.
Por lo tanto, devolvemos 5.

Ejemplo 2:

Entrada: nums = [11,21,12]
Salida: 2
Explicación: Hay 2 pares hermosos:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 1, y el último dígito de nums[1] es 1. De hecho, gcd(1,1) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 1, y el último dígito de nums[2] es 2. De hecho, gcd(1,2) == 1.
Por lo tanto, devolvemos 2.

Restricciones:

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0

Se le proporciona una matriz de números enteros indexada en 0 nums. Un par de índices i, j donde 0 <= i < j < nums.length se denomina bello si el primer dígito de nums[i] y el último dígito de nums[j] son coprimos.
Devuelve la cantidad total de pares bellos en nums.
Dos enteros x e y son coprimos si no hay un entero mayor que 1 que divida a ambos. En otras palabras, x e y son coprimos si gcd(x, y) == 1, donde gcd(x, y) es el máximo común divisor de x e y.

Ejemplo 1:

Entrada: nums = [2,5,1,4]
Salida: 5
Explicación: Hay 5 pares hermosos en nums:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 2 y el último dígito de nums[1] es 5. Podemos confirmar que 2 y 5 son coprimos, ya que mcd(2,5) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 2 y el último dígito de nums[2] es 1. De hecho, mcd(2,1) == 1.
Cuando i = 1 y j = 2: el primer dígito de nums[1] es 5 y el último dígito de nums[2] es 1. De hecho, mcd(5,1) == 1.
Cuando i = 1 y j = 3: el primer dígito de nums[1] es 5 y el último dígito de nums[3] es 4. De hecho, mcd(5,4) == 1.
Cuando i = 2 y j = 3: el primer dígito de nums[2] es 1 y el último dígito de nums[3] es 4. De hecho, mcd(1,4) == 1.
Por lo tanto, devolvemos 5.

Ejemplo 2:

Entrada: nums = [11,21,12]
Salida: 2
Explicación: Hay 2 pares hermosos:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 1 y el último dígito de nums[1] es 1. De hecho, mcd(1,1) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 1 y el último dígito de nums[2] es 2. De hecho, mcd(1,2) == 1.
Por lo tanto, devolvemos 2.

Restricciones:

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0

Se le proporciona una matriz de números enteros indexada en 0 nums. Un par de índices i, j donde 0 <= i < j < nums.length se denomina bello si el primer dígito de nums[i] y el último dígito de nums[j] son coprimos.
Devuelve la cantidad total de pares bellos en nums.
Dos números enteros x e y son coprimos si no hay ningún número entero mayor que 1 que los divida a ambos. En otras palabras, x e y son coprimos si mcd(x, y) == 1, donde mcd(x, y) es el máximo común divisor de x e y.

Ejemplo 1:

Entrada: nums = [2,5,1,4]
Salida: 5
Explicación: Hay 5 pares hermosos en nums:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 2 y el último dígito de nums[1] es 5. Podemos confirmar que 2 y 5 son coprimos, ya que mcd(2,5) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 2 y el último dígito de nums[2] es 1. De hecho, mcd(2,1) == 1.
Cuando i = 1 y j = 2: el primer dígito de nums[1] es 5 y el último dígito de nums[2] es 1. De hecho, mcd(5,1) == 1.
Cuando i = 1 y j = 3: el primer dígito de nums[1] es 5 y el último dígito de nums[3] es 4. De hecho, mcd(5,4) == 1.
Cuando i = 2 y j = 3: el primer dígito de nums[2] es 1 y el último dígito de nums[3] es 4. De hecho, mcd(1,4) == 1.
Por lo tanto, devolvemos 5.

Ejemplo 2:

Entrada: nums = [11,21,12]
Salida: 2
Explicación: Hay 2 pares hermosos:
Cuando i = 0 y j = 1: el primer dígito de nums[0] es 1 y el último dígito de nums[1] es 1. De hecho, mcd(1,1) == 1.
Cuando i = 0 y j = 2: el primer dígito de nums[0] es 1 y el último dígito de nums[2] es 2. De hecho, mcd(1,2) == 1.
Por lo tanto, devolvemos 2.

Restricciones:

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0


Se te da un arreglo de enteros llamado nums indexado desde 0 y un entero k.
Un subarreglo se llama igual si todos sus elementos son iguales. Nota que el subarreglo vacío también es un subarreglo igual.
Devuelve la longitud del subarreglo igual más largo posible después de eliminar como máximo k elementos de nums.
Un subarreglo es una secuencia contigua, posiblemente vacía, de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums = [1,3,2,3,1,3], k = 3
Salida: 3
Explicación: Es óptimo eliminar los elementos en los índices 2 y 4.
Después de eliminarlos, nums se convierte en [1, 3, 3, 3].
El subarreglo igual más largo comienza en i = 1 y termina en j = 3 con longitud igual a 3.
Se puede demostrar que no se pueden crear subarreglos iguales más largos.

Ejemplo 2:

Entrada: nums = [1,1,2,2,1,1], k = 2
Salida: 4
Explicación: Es óptimo eliminar los elementos en los índices 2 y 3.
Después de eliminarlos, nums se convierte en [1, 1, 1, 1].
El arreglo en sí es un subarreglo igual, por lo que la respuesta es 4.
Se puede demostrar que no se pueden crear subarreglos iguales más largos.

Restricciones:

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

Se le da una matriz de números enteros con índice 0 y un número entero k.
Una submatriz se llama igual si todos sus elementos son iguales. Observe que la submatriz vacía es una submatriz igual.
Devuelve la longitud de la submatriz igual más larga posible después de eliminar como máximo k elementos de nums.
Una submatriz es una secuencia contigua, posiblemente vacía, de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,3,2,3,1,3], k = 3
Salida: 3
Explicación: Es óptimo eliminar los elementos en el índice 2 y el índice 4.
Después de borrarlos, nums pasa a ser igual a [1, 3, 3, 3].
La submatriz igual más larga empieza en i = 1 y termina en j = 3 con longitud igual a 3.
Se puede demostrar que no se pueden crear más submatrices iguales.

Ejemplo 2:

Entrada: nums = [1,1,2,2,1,1], k = 2
Salida: 4
Explicación: Es óptimo eliminar los elementos en el índice 2 y el índice 3.
Después de borrarlos, nums pasa a ser igual a [1, 1, 1, 1].
El array en sí es un subarray igual, por lo que la respuesta es 4.
Se puede demostrar que ya no se pueden crear submatrices iguales.

Restricciones:

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

Se te da un array de enteros nums indexado desde 0 y un entero k.
Un subarray se llama igual si todos sus elementos son iguales. Nota que el subarray vacío es un subarray igual.
Devuelve la longitud del subarray igual más largo posible después de eliminar como máximo k elementos de nums.
Un subarray es una secuencia contigua, posiblemente vacía, de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [1,3,2,3,1,3], k = 3
Salida: 3
Explicación: Es óptimo eliminar los elementos en los índices 2 y 4.
Después de eliminarlos, nums se convierte en [1, 3, 3, 3].
El subarray igual más largo comienza en i = 1 y termina en j = 3 con longitud igual a 3.
Se puede demostrar que no se pueden crear subarrays iguales más largos.

Ejemplo 2:

Entrada: nums = [1,1,2,2,1,1], k = 2
Salida: 4
Explicación: Es óptimo eliminar los elementos en los índices 2 y 3.
Después de eliminarlos, nums se convierte en [1, 1, 1, 1].
El array en sí es un subarray igual, por lo que la respuesta es 4.
Se puede demostrar que no se pueden crear subarrays iguales más largos.

Restricciones:

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


Se le proporciona un entero n que denota la cantidad total de servidores y una matriz de enteros indexada en 0 en 2D logs, donde logs[i] = [server_id, time] denota que el servidor con id server_id recibió una solicitud en el momento time.
También se le proporciona un entero x y una matriz de enteros indexada en 0 queries.
Devuelve una matriz de enteros indexada en 0 arr de longitud queries.length donde arr[i] representa la cantidad de servidores que no recibieron ninguna solicitud durante el intervalo de tiempo [queries[i] - x, queries[i]].
Tenga en cuenta que los intervalos de tiempo son inclusivos.

Ejemplo 1:

Entrada: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Salida: [1,2]
Explicación:
Para queries[0]: los servidores con los identificadores 1 y 2 reciben solicitudes en la duración de [5, 10]. Por lo tanto, solo el servidor 3 recibe cero solicitudes.
Para queries[1]: solo el servidor con el identificador 2 recibe una solicitud en la duración de [6,11]. Por lo tanto, los servidores con los identificadores 1 y 3 son los únicos servidores que no reciben ninguna solicitud durante ese período de tiempo.

Ejemplo 2:

Entrada: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Salida: [0,1]
Explicación:
Para queries[0]: todos los servidores reciben al menos una solicitud en la duración de [1, 3].
Para queries[1]: solo el servidor con id 3 no recibe ninguna solicitud en la duración de [2,4].

Restricciones:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Se le da un entero n que denota el número total de servidores y un array de enteros 2D con índice 0 logs, donde logs[i] = [server_id, time] denota que el servidor con id server_id recibió una petición en el momento time.
También se le da un entero x y un array de enteros con índice 0 queries.
Devuelve una matriz de enteros con índice 0 arr de longitud queries.length donde arr[i] representa el número de servidores que no recibieron ninguna petición durante el intervalo de tiempo [queries[i] - x, queries[i]].
Tenga en cuenta que los intervalos de tiempo son inclusivos.

Ejemplo 1

Entrada: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Salida: [1,2]
Explicación:
Para consultas[0]: Los servidores con ids 1 y 2 reciben peticiones en la duración de [5, 10]. Por lo tanto, sólo el servidor 3 recibe cero peticiones.
Para consultas[1]: Sólo el servidor con id 2 recibe una petición en la duración de [6,11]. Por lo tanto, los servidores con ids 1 y 3 son los únicos que no reciben ninguna petición durante ese periodo de tiempo.

Ejemplo 2:

Entrada: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Salida: [0,1]
Explicación:
Para consultas[0]: Todos los servidores reciben al menos una petición en la duración de [1, 3].
Para consultas[1]: Sólo el servidor con id 3 no recibe ninguna petición en la duración [2,4].

Restricciones:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Se te da un entero n que denota el número total de servidores y un array de enteros bidimensional logs con índice 0, donde logs[i] = [server_id, time] indica que el servidor con id server_id recibió una solicitud en el momento time.
También se te da un entero x y un array de enteros queries con índice 0.
Devuelve un array de enteros arr con índice 0 de longitud queries.length donde arr[i] representa el número de servidores que no recibieron ninguna solicitud durante el intervalo de tiempo [queries[i] - x, queries[i]].
Nota que los intervalos de tiempo son inclusivos.

Ejemplo 1:

Entrada: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Salida: [1,2]
Explicación:
Para queries[0]: Los servidores con ids 1 y 2 reciben solicitudes en la duración de [5, 10]. Por lo tanto, solo el servidor 3 no recibe ninguna solicitud.
Para queries[1]: Solo el servidor con id 2 recibe una solicitud en la duración de [6,11]. Por lo tanto, los servidores con ids 1 y 3 son los únicos que no reciben ninguna solicitud durante ese período de tiempo.

Ejemplo 2:

Entrada: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Salida: [0,1]
Explicación:
Para queries[0]: Todos los servidores reciben al menos una solicitud en la duración de [1, 3].
Para queries[1]: Solo servidor con id 3 no recibe solicitud en la duración [2,4].

Restricciones:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6


Se te da un array de enteros indexado desde 0, `nums`, que representa las posiciones iniciales de algunas canicas. También se te dan dos arrays de enteros indexados desde 0, `moveFrom` y `moveTo`, de igual longitud.
A lo largo de `moveFrom.length` pasos, cambiarás las posiciones de las canicas. En el i-ésimo paso, moverás todas las canicas de la posición `moveFrom[i]` a la posición `moveTo[i]`.
Después de completar todos los pasos, devuelve la lista ordenada de posiciones ocupadas.

Notas:

Llamamos a una posición ocupada si hay al menos una canica en esa posición. Puede haber múltiples canicas en una sola posición.

Ejemplo 1:

Entrada: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Salida: [5,6,8,9]
Explicación: Inicialmente, las canicas están en las posiciones 1,6,7,8.
En el paso i = 0, movemos las canicas de la posición 1 a la posición 2. Luego, las posiciones 2,6,7,8 están ocupadas.
En el paso i = 1, movemos las canicas de la posición 7 a la posición 9. Luego, las posiciones 2,6,8,9 están ocupadas.
En el paso i = 2, movemos las canicas de la posición 2 a la posición 5. Luego, las posiciones 5,6,8,9 están ocupadas.
Al final, las posiciones finales que contienen al menos una canica son [5,6,8,9].

Ejemplo 2:

Entrada: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Salida: [2]
Explicación: Inicialmente, las canicas están en las posiciones [1,1,3,3].
En el paso i = 0, movemos todas las canicas de la posición 1 a la posición 2. Luego, las canicas están en las posiciones [2,2,3,3].
En el paso i = 1, movemos todas las canicas de la posición 3 a la posición 2. Luego, las canicas están en las posiciones [2,2,2,2].
Dado que 2 es la única posición ocupada, devolvemos [2].

Restricciones:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Los casos de prueba se generan de tal manera que haya al menos una canica en moveFrom[i] en el momento en que queremos aplicar el i-ésimo movimiento.

Se le proporciona una matriz de números enteros indexada en 0, nums, que representa las posiciones iniciales de algunas canicas. También se le proporcionan dos matrices de números enteros indexadas en 0, moveFrom y moveTo, de igual longitud.
A lo largo de los pasos de moveFrom.length, cambiará las posiciones de las canicas. En el paso i^th, moverá todas las canicas en la posición moveFrom[i] a la posición moveTo[i].
Después de completar todos los pasos, devuelva la lista ordenada de posiciones ocupadas.
Notas:

Llamamos a una posición ocupada si hay al menos una canica en esa posición.
Puede haber varias canicas en una sola posición.

Ejemplo 1:

Entrada: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Salida: [5,6,8,9]
Explicación: Inicialmente, las canicas están en las posiciones 1,6,7,8.
En el paso i = 0, movemos las canicas de la posición 1 a la posición 2. Luego, las posiciones 2, 6, 7, 8 están ocupadas.
En el paso i = 1, movemos las canicas de la posición 7 a la posición 9. Luego, las posiciones 2, 6, 8, 9 están ocupadas.
En el paso i = 2, movemos las canicas de la posición 2 a la posición 5. Luego, las posiciones 5, 6, 8, 9 están ocupadas.
Al final, las posiciones finales que contienen al menos una canica son [5, 6, 8, 9].
Ejemplo 2:

Entrada: nums = [1, 1, 3, 3], moveFrom = [1, 3], moveTo = [2, 2]
Salida: [2]
Explicación: Inicialmente, las canicas están en las posiciones [1, 1, 3, 3].
En el paso i = 0, movemos todas las canicas en la posición 1 a la posición 2. Entonces, las canicas están en las posiciones [2,2,3,3].
En el paso i = 1, movemos todas las canicas en la posición 3 a la posición 2. Entonces, las canicas están en las posiciones [2,2,2,2].
Como 2 es la única posición ocupada, devolvemos [2].

Restricciones:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Los casos de prueba se generan de manera que haya al menos una canica en moveFrom[i] en el momento en que queremos aplicar el movimiento i^th.


Tienes dos números enteros num1 y num2.
En una operación, puedes elegir el número entero i en el rango [0, 60] y restar 2^i + num2 de num1.
Devuelve el número entero que indica la cantidad mínima de operaciones necesarias para que num1 sea igual a 0.
Si es imposible que num1 sea igual a 0, devuelve -1.

Ejemplo 1:

Entrada: num1 = 3, num2 = -2
Salida: 3
Explicación: Podemos hacer que 3 sea igual a 0 con las siguientes operaciones:
- Elegimos i = 2 y restamos 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Elegimos i = 2 y restamos 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Elegimos i = 0 y restamos 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Se puede demostrar que 3 es el número mínimo de operaciones que debemos realizar.

Ejemplo 2:

Entrada: num1 = 5, num2 = 7
Salida: -1
Explicación: Se puede demostrar que es imposible hacer que 5 sea igual a 0 con la operación dada.

Restricciones:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Se le dan dos números enteros num1 y num2.
En una operación, puede elegir un número entero i en el rango [0, 60] y restar 2^i + num2 de num1.
Devuelve el número entero que denota el número mínimo de operaciones necesarias para hacer num1 igual a 0.
Si es imposible hacer num1 igual a 0, devuelve -1.

Ejemplo 1:

Entrada: num1 = 3, num2 = -2
Salida: 3
Explicación: Podemos hacer que 3 sea igual a 0 con las siguientes operaciones:
- Elegimos i = 2 y restamos 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Elegimos i = 2 y restamos 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Elegimos i = 0 y restamos 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Se puede demostrar que 3 es el número mínimo de operaciones que hay que realizar.

Ejemplo 2:

Entrada: num1 = 5, num2 = 7
Salida: -1
Explicación: Se puede demostrar que es imposible hacer 5 igual a 0 con la operación dada.

Restricciones:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Se te dan dos enteros num1 y num2.
En una operación, puedes elegir un entero i en el rango [0, 60] y restar 2^i + num2 de num1.
Devuelve el entero que representa el número mínimo de operaciones necesarias para hacer que num1 sea igual a 0.
Si es imposible hacer que num1 sea igual a 0, devuelve -1.

Ejemplo 1:

Entrada: num1 = 3, num2 = -2
Salida: 3
Explicación: Podemos hacer que 3 sea igual a 0 con las siguientes operaciones:
- Elegimos i = 2 y restamos 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Elegimos i = 2 y restamos 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Elegimos i = 0 y restamos 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Se puede probar que 3 es el número mínimo de operaciones que necesitamos realizar.

Ejemplo 2:

Entrada: num1 = 5, num2 = 7
Salida: -1
Explicación: Se puede probar que es imposible hacer que 5 sea igual a 0 con la operación dada.

Restricciones:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


Se te dan dos arreglos de enteros indexados desde 0, nums1 y nums2, cada uno de longitud n, y un arreglo 2D indexado desde 1, queries, donde queries[i] = [x_i, y_i].
Para la i-ésima consulta, encuentra el valor máximo de nums1[j] + nums2[j] entre todos los índices j (0 <= j < n), donde nums1[j] >= x_i y nums2[j] >= y_i, o -1 si no hay ningún j que satisfaga las restricciones.
Devuelve un arreglo answer donde answer[i] es la respuesta a la i-ésima consulta.

Ejemplo 1:

Entrada: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Salida: [6,10,7]
Explicación:
Para la 1ª consulta x_i = 4 y y_i = 1, podemos seleccionar el índice j = 0 ya que nums1[j] >= 4 y nums2[j] >= 1. La suma nums1[j] + nums2[j] es 6, y podemos mostrar que 6 es el máximo que podemos obtener.

Para la 2ª consulta x_i = 1 y y_i = 3, podemos seleccionar el índice j = 2 ya que nums1[j] >= 1 y nums2[j] >= 3. La suma nums1[j] + nums2[j] es 10, y podemos mostrar que 10 es el máximo que podemos obtener.

Para la 3ª consulta x_i = 2 y y_i = 5, podemos seleccionar el índice j = 3 ya que nums1[j] >= 2 y nums2[j] >= 5. La suma nums1[j] + nums2[j] es 7, y podemos mostrar que 7 es el máximo que podemos obtener.

Por lo tanto, devolvemos [6,10,7].

Ejemplo 2:

Entrada: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Salida: [9,9,9]
Explicación: Para este ejemplo, podemos usar el índice j = 2 para todas las consultas ya que satisface las restricciones para cada consulta.

Ejemplo 3:

Entrada: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Salida: [-1]
Explicación: Hay una consulta en este ejemplo con x_i = 3 y y_i = 3. Para cada índice, j, ya sea nums1[j] < x_i o nums2[j] < y_i. Por lo tanto, no hay solución.

Restricciones:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9

Se le proporcionan dos matrices de enteros indexadas en 0, nums1 y nums2, cada una de longitud n, y una matriz 2D indexada en 1, consultas, donde consultas[i] = [x_i, y_i].
Para la consulta i^th, encuentre el valor máximo de nums1[j] + nums2[j] entre todos los índices j (0 <= j < n), donde nums1[j] >= x_i y nums2[j] >= y_i, o -1 si no hay ningún j que cumpla las restricciones.
Devuelva una matriz respuesta donde respuesta[i] es la respuesta a la consulta i^th.

Ejemplo 1:

Entrada: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Salida: [6,10,7]
Explicación:
Para la primera consulta x_i = 4 e y_i = 1, podemos seleccionar el índice j = 0 ya que nums1[j] >= 4 y nums2[j] >= 1. La suma nums1[j] + nums2[j] es 6, y podemos demostrar que 6 es el máximo que podemos obtener.

Para la segunda consulta x_i = 1 e y_i = 3, podemos seleccionar el índice j = 2 ya que nums1[j] >= 1 y nums2[j] >= 3. La suma nums1[j] + nums2[j] es 10, y podemos demostrar que 10 es el máximo que podemos obtener.

Para la tercera consulta x_i = 2 e y_i = 5, podemos seleccionar el índice j = 3 ya que nums1[j] >= 2 y nums2[j] >= 5. La suma nums1[j] + nums2[j] es 7, y podemos demostrar que 7 es el máximo que podemos obtener.

Por lo tanto, devolvemos [6,10,7].

Ejemplo 2:

Entrada: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Salida: [9,9,9]
Explicación: Para este ejemplo, podemos usar el índice j = 2 para todas las consultas, ya que satisface las restricciones para cada consulta.

Ejemplo 3:

Entrada: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Salida: [-1]
Explicación: Hay una consulta en este ejemplo con x_i = 3 e y_i = 3. Para cada índice, j, nums1[j] < x_i o nums2[j] < y_i. Por lo tanto, no hay solución.

Restricciones:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9

Se te dan dos matrices de enteros indexadas desde 0, nums1 y nums2, cada uno de longitud n, y una matriz 2D indexada desde 1, queries, donde queries[i] = [x_i, y_i]. Para la i-ésima consulta, encuentra el valor máximo de nums1[j] + nums2[j] entre todos los índices j (0 <= j < n), donde nums1[j] >= x_i y nums2[j] >= y_i, o -1 si no hay ningún j que satisfaga las restricciones. Devuelve una matriz answer donde answer[i] es la respuesta a la i-ésima consulta.

Ejemplo 1:

Entrada: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Salida: [6,10,7]
Explicación:
Para la 1ª consulta x_i = 4 y y_i = 1, podemos seleccionar el índice j = 0 ya que nums1[j] >= 4 y nums2[j] >= 1. La suma nums1[j] + nums2[j] es 6, y podemos mostrar que 6 es el máximo que podemos obtener.

Para la 2ª consulta x_i = 1 y y_i = 3, podemos seleccionar el índice j = 2 ya que nums1[j] >= 1 y nums2[j] >= 3. La suma nums1[j] + nums2[j] es 10, y podemos mostrar que 10 es el máximo que podemos obtener.

Para la 3ª consulta x_i = 2 y y_i = 5, podemos seleccionar el índice j = 3 ya que nums1[j] >= 2 y nums2[j] >= 5. La suma nums1[j] + nums2[j] es 7, y podemos mostrar que 7 es el máximo que podemos obtener.

Por lo tanto, devolvemos [6,10,7].

Ejemplo 2:

Entrada: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Salida: [9,9,9]
Explicación: Para este ejemplo, podemos usar el índice j = 2 para todas las consultas ya que satisface las restricciones para cada consulta.

Ejemplo 3:

Entrada: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Salida: [-1]
Explicación: Hay una consulta en este ejemplo con x_i = 3 y y_i = 3. Para cada índice, j, ya sea nums1[j] < x_i o nums2[j] < y_i. Por lo tanto, no hay solución.

Restricciones:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9


Se le proporciona una matriz de enteros indexada en 1 nums de longitud n.
Un elemento nums[i] de nums se denomina especial si i divide a n, es decir, n % i == 0.
Devuelve la suma de los cuadrados de todos los elementos especiales de nums.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 21
Explicación: Hay exactamente 3 elementos especiales en nums: nums[1] ya que 1 divide a 4, nums[2] ya que 2 divide a 4 y nums[4] ya que 4 divide a 4.
Por lo tanto, la suma de los cuadrados de todos los elementos especiales de nums es nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Ejemplo 2:

Entrada: nums = [2,7,1,19,18,3]
Salida: 63
Explicación: Hay exactamente 4 elementos especiales en nums: nums[1] ya que 1 divide a 6, nums[2] ya que 2 divide a 6, nums[3] ya que 3 divide a 6, y nums[6] ya que 6 divide a 6.
Por lo tanto, la suma de los cuadrados de todos los elementos especiales de nums es nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Restricciones:

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

Se te da un array de enteros, nums, indexado desde 1 de longitud n.
Un elemento nums[i] de nums se llama especial si i divide a n, es decir, n % i == 0.
Devuelve la suma de los cuadrados de todos los elementos especiales de nums.

Ejemplo 1:

Input: nums = [1,2,3,4]
Output: 21
Explicación: Hay exactamente 3 elementos especiales en nums: nums[1] ya que 1 divide a 4, nums[2] ya que 2 divide a 4, y nums[4] ya que 4 divide a 4.
Por lo tanto, la suma de los cuadrados de todos los elementos especiales de nums es nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Ejemplo 2:

Input: nums = [2,7,1,19,18,3]
Output: 63
Explicación: Hay exactamente 4 elementos especiales en nums: nums[1] ya que 1 divide a 6, nums[2] ya que 2 divide a 6, nums[3] ya que 3 divide a 6, y nums[6] ya que 6 divide a 6.
Por lo tanto, la suma de los cuadrados de todos los elementos especiales de nums es nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Restricciones:

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


Se te da un array de enteros positivos nums.
Particiona nums en dos arrays, nums1 y nums2, de tal manera que:

Cada elemento del array nums pertenece o bien al array nums1 o al array nums2.
Ambos arrays son no vacíos.
El valor de la partición se minimiza.

El valor de la partición es |max(nums1) - min(nums2)|.
Aquí, max(nums1) denota el elemento máximo del array nums1, y min(nums2) denota el elemento mínimo del array nums2.
Devuelve el entero que denota el valor de dicha partición.

Ejemplo 1:

Entrada: nums = [1,3,2,4]
Output: 1
Explicación: Podemos particionar el array nums en nums1 = [1,2] y nums2 = [3,4].
- El elemento máximo del array nums1 es igual a 2.
- El elemento mínimo del array nums2 es igual a 3.
El valor de la partición es |2 - 3| = 1.
Se puede demostrar que 1 es el valor mínimo de todas las particiones.

Ejemplo 2:

Entrada: nums = [100,1,10]
Output: 9
Explicación: Podemos particionar el array nums en nums1 = [10] y nums2 = [100,1].
- El elemento máximo del array nums1 es igual a 10.
- El elemento mínimo del array nums2 es igual a 1.
El valor de la partición es |10 - 1| = 9.
Se puede demostrar que 9 es el valor mínimo de todas las particiones.

Restricciones:

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

Se le proporciona una matriz de números enteros positivos nums.
Particione nums en dos matrices, nums1 y nums2, de modo que:

Cada elemento de la matriz nums pertenece a la matriz nums1 o a la matriz nums2.
Ninguna de las matrices está vacía.
El valor de la partición se minimiza.

El valor de la partición es |max(nums1) - min(nums2)|.
Aquí, max(nums1) denota el elemento máximo de la matriz nums1 y min(nums2) denota el elemento mínimo de la matriz nums2.
Devuelva el entero que denota el valor de dicha partición.

Ejemplo 1:

Entrada: nums = [1,3,2,4]
Salida: 1
Explicación: Podemos particionar la matriz nums en nums1 = [1,2] y nums2 = [3,4].
- El elemento máximo de la matriz nums1 es igual a 2.
- El elemento mínimo de la matriz nums2 es igual a 3.
El valor de la partición es |2 - 3| = 1.
Se puede demostrar que 1 es el valor mínimo de todas las particiones.

Ejemplo 2:

Entrada: nums = [100,1,10]
Salida: 9
Explicación: Podemos particionar la matriz nums en nums1 = [10] y nums2 = [100,1].
- El elemento máximo de la matriz nums1 es igual a 10.
- El elemento mínimo de la matriz nums2 es igual a 1.
El valor de la partición es |10 - 1| = 9.
Se puede demostrar que 9 es el valor mínimo de todas las particiones.

Restricciones:

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

Se te da un array de enteros positivos nums.
Particiona nums en dos arrays, nums1 y nums2, de tal manera que:

Cada elemento del array nums pertenece o bien al array nums1 o al array nums2.
Ambos arrays son no vacíos.
El valor de la partición se minimiza.

El valor de la partición es |max(nums1) - min(nums2)|.
Aquí, max(nums1) denota el elemento máximo del array nums1, y min(nums2) denota el elemento mínimo del array nums2.
Devuelve el entero que denota el valor de dicha partición.

Ejemplo 1:

Input: nums = [1,3,2,4]
Output: 1
Explicación: Podemos particionar el array nums en nums1 = [1,2] y nums2 = [3,4].
- El elemento máximo del array nums1 es igual a 2.
- El elemento mínimo del array nums2 es igual a 3.
El valor de la partición es |2 - 3| = 1.
Se puede demostrar que 1 es el valor mínimo de todas las particiones.

Ejemplo 2:

Input: nums = [100,1,10]
Output: 9
Explicación: Podemos particionar el array nums en nums1 = [10] y nums2 = [100,1].
- El elemento máximo del array nums1 es igual a 10.
- El elemento mínimo del array nums2 es igual a 1.
El valor de la partición es |10 - 1| = 9.
Se puede demostrar que 9 es el valor mínimo de todas las particiones.

Restricciones:

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


Se te da un array indexado desde 0 llamado words que consiste en cadenas distintas.
La cadena words[i] puede emparejarse con la cadena words[j] si:

La cadena words[i] es igual a la cadena invertida de words[j].
0 <= i < j < words.length.

Devuelve el número máximo de pares que se pueden formar a partir del array words. Ten en cuenta que cada cadena puede pertenecer como máximo a un par.

Ejemplo 1:

Entrada: words = ["cd","ac","dc","ca","zz"]
Salida: 2
Explicación: En este ejemplo, podemos formar 2 pares de cadenas de la siguiente manera:
- Emparejamos la cadena 0^th con la cadena 2^nd, ya que la cadena invertida de word[0] es "dc" y es igual a words[2].
- Emparejamos la cadena 1^st con la cadena 3^rd, ya que la cadena invertida de word[1] es "ca" y es igual a words[3].
Se puede probar que 2 es el número máximo de pares que se pueden formar.
Ejemplo 2:

Entrada: words = ["ab","ba","cc"]
Salida: 1
Explicación: En este ejemplo, podemos formar 1 par de cadenas de la siguiente manera:
- Emparejamos la cadena 0^th con la cadena 1^st, ya que la cadena invertida de words[1] es "ab" y es igual a words[0].
Se puede probar que 1 es el número máximo de pares que se pueden formar.

Ejemplo 3:

Entrada: words = ["aa","ab"]
Salida: 0
Explicación: En este ejemplo, no se puede formar ningún par de cadenas.

Restricciones:

1 <= words.length <= 50
words[i].length == 2
words consiste en cadenas distintas.
words[i] contiene solo letras minúsculas del inglés.

Se le proporciona una matriz indexada en 0, compuesta por cadenas únicas.
La cadena palabras[i] puede emparejarse con la cadena palabras[j] si:

La cadena words[i] es igual a la cadena invertida de words[j].
0 <= i < j < words.length.

Devuelve el número máximo de pares que se pueden formar a partir de la matriz words.
Tenga en cuenta que cada cadena puede pertenecer como máximo a un par.

Ejemplo 1:

Entrada: words = ["cd","ac","dc","ca","zz"]
Salida: 2
Explicación: En este ejemplo, podemos formar 2 pares de cadenas de la siguiente manera:
- Emparejamos la cadena 0^ª con la cadena 2^ª, ya que la cadena invertida de palabra[0] es"dc" y es igual a palabra[2].
- Emparejamos la cadena 1^ con la cadena 3^, ya que la cadena invertida de la palabra[1] es «ca» y es igual a palabras[3].
Se puede demostrar que 2 es el número máximo de pares que se pueden formar.
Ejemplo 2:

Entrada: words = ["ab","ba","cc"]
Salida: 1
Explicación: En este ejemplo, podemos formar 1 par de cadenas de la siguiente manera:
- Emparejamos la cadena 0^ª con la cadena 1^ª, ya que la cadena invertida de palabras[1] es «ab» y es igual a palabras[0].
Se puede demostrar que 1 es el número máximo de pares que se pueden formar.

Ejemplo 3:

Entrada: words = ["aa","ab"]
Salida: 0
Explicación: En este ejemplo, no podemos formar ningún par de cadenas.

Restricciones:

1 <= words.length <= 50
words[i].length == 2
words está formado por cadenas únicas.
words[i] sólo contiene letras minúsculas inglesas.


Se le proporciona una matriz de números enteros indexada en 0, nums, que contiene n números enteros positivos distintos. Una permutación de nums se denomina especial si:

Para todos los índices 0 <= i < n - 1, nums[i] % nums[i+1] == 0 o nums[i+1] % nums[i] == 0.

Devuelve el número total de permutaciones especiales. Como la respuesta podría ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,3,6]
Salida: 2
Explicación: [3,6,2] y [2,6,3] son las dos permutaciones especiales de nums.

Ejemplo 2:

Entrada: nums = [1,4,3]
Salida: 2
Explicación: [3,1,4] y [4,1,3] son las dos permutaciones especiales de nums.

Restricciones:

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

Se te proporciona un conjunto de enteros nums indexado desde 0 que contiene n enteros positivos distintos. Una permutación de nums se llama especial si:

Para todos los índices 0 <= i < n - 1, se cumple que nums[i] % nums[i+1] == 0 o nums[i+1] % nums[i] == 0.

Devuelve el número total de permutaciones especiales. Como el resultado puede ser grande, devuélvelo módulo 10^9 + 7.

Ejemplo 1:

Input: nums = [2,3,6]
Output: 2
Explicación: [3,6,2] y [2,6,3] son las dos permutaciones especiales de nums.

Ejemplo 2:

Input: nums = [1,4,3]
Output: 2
Explicación: [3,1,4] y [4,1,3] son las dos permutaciones especiales de nums.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums que contiene n enteros positivos distintos. Una permutación de nums se denomina especial si:

Para todos los índices 0 <= i < n - 1, nums[i] % nums[i+1] == 0 o nums[i+1] % nums[i] == 0.

Devuelve el número total de permutaciones especiales. Como la respuesta podría ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,3,6]
Salida: 2
Explicación: [3,6,2] y [2,6,3] son las dos permutaciones especiales de nums.

Ejemplo 2:

Entrada: nums = [1,4,3]
Salida: 2
Explicación: [3,1,4] y [4,1,3] son las dos permutaciones especiales de nums.

Restricciones:

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


El número de desequilibrio de un array de enteros indexado en 0, arr, de longitud n se define como la cantidad de índices en sarr = sorted(arr) tal que:

0 <= i < n - 1, y
sarr[i+1] - sarr[i] > 1

Aquí, sorted(arr) es la función que devuelve la versión ordenada de arr.
Dado un array de enteros indexado en 0, nums, devuelve la suma de los números de desequilibrio de todos sus subarrays.
Un subarray es una secuencia contigua no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [2,3,1,4]
Salida: 3
Explicación: Hay 3 subarrays con números de desequilibrio no cero:
- Subarray [3, 1] con un número de desequilibrio de 1.
- Subarray [3, 1, 4] con un número de desequilibrio de 1.
- Subarray [1, 4] con un número de desequilibrio de 1.
El número de desequilibrio de todos los otros subarrays es 0. Por lo tanto, la suma de los números de desequilibrio de todos los subarrays de nums es 3.

Ejemplo 2:

Entrada: nums = [1,3,3,3,5]
Salida: 8
Explicación: Hay 7 subarrays con números de desequilibrio no cero:
- Subarray [1, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3, 3, 5] con un número de desequilibrio de 2.
- Subarray [3, 3, 3, 5] con un número de desequilibrio de 1.
- Subarray [3, 3, 5] con un número de desequilibrio de 1.
- Subarray [3, 5] con un número de desequilibrio de 1.
El número de desequilibrio de todos los otros subarrays es 0. Por lo tanto, la suma de los números de desequilibrio de todos los subarrays de nums es 8.

Restricciones:

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

El número de desequilibrio de una matriz de enteros con índice 0 arr de longitud n se define como el número de índices en sarr = sorted(arr) tales que:

0 <= i < n - 1, y
sarr[i+1] - sarr[i] > 1

Aquí, sorted(arr) es la función que devuelve la versión ordenada de arr.
Dada una matriz de enteros con índice 0 nums, devuelve la suma de los números de desequilibrio de todas sus submatrices.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [2,3,1,4]
Salida: 3
Explicación: Hay 3 submatrices con números de desequilibrio distintos de cero:
- Subarray [3, 1] con un número de desequilibrio de 1.
- Submatriz [3, 1, 4] con un número de desequilibrio de 1.
- Submatriz [1, 4] con un número de desequilibrio de 1.
El número de desequilibrio de todas las demás submatrices es 0. Por lo tanto, la suma de los números de desequilibrio de todas las submatrices de nums es 3.

Ejemplo 2:

Entrada: nums = [1,3,3,3,5]
Salida: 8
Explicación: Hay 7 submatrices con números de desequilibrio distintos de cero:
- Subarray [1, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3, 3] con un número de desequilibrio de 1.
- Subarray [1, 3, 3, 3, 5] con un número de desequilibrio de 2.
- Submatriz [3, 3, 3, 5] con un número de desequilibrio de 1.
- Submatriz [3, 3, 5] con un número de desequilibrio de 1.
- Submatriz [3, 5] con un número de desequilibrio de 1.
El número de desequilibrio de todas las demás submatrices es 0. Por lo tanto, la suma de los números de desequilibrio de todas las submatrices de nums es 8.

Restricciones:

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

El número de desequilibrio de una matriz de enteros indexada en 0 arr de longitud n se define como la cantidad de índices en sarr = sorted(arr) tales que:

0 <= i < n - 1, y
sarr[i+1] - sarr[i] > 1

Aquí, sorted(arr) es la función que devuelve la versión ordenada de arr.
Dada una matriz de enteros indexada en 0 nums, devuelve la suma de los números de desequilibrio de todas sus submatrices.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [2,3,1,4]
Salida: 3
Explicación: Hay 3 submatrices con números de desequilibrio distintos de cero:
- Submatriz [3, 1] con un número de desequilibrio de 1.
- Submatriz [3, 1, 4] con un número de desequilibrio de 1.
- Submatriz [1, 4] con un número de desequilibrio de 1.
El número de desequilibrio de todas las demás submatrices es 0. Por lo tanto, la suma de los números de desequilibrio de todas las submatrices de nums es 3.

Ejemplo 2:

Entrada: nums = [1,3,3,3,5]
Salida: 8
Explicación: Hay 7 submatrices con números de desequilibrio distintos de cero:
- Submatriz [1, 3] con un número de desequilibrio de 1.
- Submatriz [1, 3, 3] con un número de desequilibrio de 1.
- Subarreglo [1, 3, 3, 3] con un número de desequilibrio de 1.
- Subarreglo [1, 3, 3, 3, 5] con un número de desequilibrio de 2.
- Subarreglo [3, 3, 3, 5] con un número de desequilibrio de 1.
- Subarreglo [3, 3, 5] con un número de desequilibrio de 1.
- Subarreglo [3, 5] con un número de desequilibrio de 1.

El número de desequilibrio de todos los demás subarreglos es 0. Por lo tanto, la suma de los números de desequilibrio de todos los subarreglos de nums es 8.

Restricciones:

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


Se te dan tres enteros x, y y z.
Tienes x cadenas iguales a "AA", y cadenas iguales a "BB", y z cadenas iguales a "AB". Quieres elegir algunas (posiblemente todas o ninguna) de estas cadenas y concatenarlas en algún orden para formar una nueva cadena. Esta nueva cadena no debe contener "AAA" o "BBB" como subcadena.
Devuelve la longitud máxima posible de la nueva cadena.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: x = 2, y = 5, z = 1
Salida: 12
Explicación: Podemos concatenar las cadenas "BB", "AA", "BB", "AA", "BB" y "AB" en ese orden. Entonces, nuestra nueva cadena es "BBAABBAABBAB".
Esa cadena tiene longitud 12, y podemos demostrar que es imposible construir una cadena de mayor longitud.

Ejemplo 2:

Entrada: x = 3, y = 2, z = 2
Salida: 14
Explicación: Podemos concatenar las cadenas "AB", "AB", "AA", "BB", "AA", "BB" y "AA" en ese orden. Entonces, nuestra nueva cadena es "ABABAABBAABBAA".
Esa cadena tiene longitud 14, y podemos demostrar que es imposible construir una cadena de mayor longitud.

Restricciones:

1 <= x, y, z <= 50

Tienes tres números enteros x, y y z.
Tienes x cadenas iguales a "AA", y cadenas iguales a "BB" y z cadenas iguales a "AB". Quieres elegir algunas (posiblemente todas o ninguna) de estas cadenas y concatenarlas en algún orden para formar una nueva cadena. Esta nueva cadena no debe contener "AAA" o "BBB" como subcadena.
Devuelve la longitud máxima posible de la nueva cadena.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: x = 2, y = 5, z = 1
Salida: 12
Explicación: Podemos concatenar las cadenas "BB", "AA", "BB", "AA", "BB" y "AB" en ese orden. Entonces, nuestra nueva cadena es "BBAABBAABBAB".
Esa cadena tiene una longitud de 12 y podemos demostrar que es imposible construir una cadena de mayor longitud.

Ejemplo 2:

Entrada: x = 3, y = 2, z = 2
Salida: 14
Explicación: Podemos concatenar las cadenas "AB", "AB", "AA", "BB", "AA", "BB" y "AA" en ese orden. Entonces, nuestra nueva cadena es "ABABAABBAABBAA".
Esa cadena tiene una longitud de 14 y podemos demostrar que es imposible construir una cadena de mayor longitud.

Restricciones:

1 <= x, y, z <= 50


Se te da un array indexado desde 0 llamado words que contiene n cadenas.
Definamos una operación de unión join(x, y) entre dos cadenas x e y como concatenarlas en xy. Sin embargo, si el último carácter de x es igual al primer carácter de y, se elimina uno de ellos.
Por ejemplo, join("ab", "ba") = "aba" y join("ab", "cde") = "abcde".
Debes realizar n - 1 operaciones de unión. Sea str_0 = words[0]. Comenzando desde i = 1 hasta i = n - 1, para la i-ésima operación, puedes hacer una de las siguientes:

Hacer str_i = join(str_i - 1, words[i])
Hacer str_i = join(words[i], str_i - 1)

Tu tarea es minimizar la longitud de str_n - 1.
Devuelve un entero que denote la longitud mínima posible de str_n - 1.

Ejemplo 1:

Entrada: words = ["aa","ab","bc"]
Salida: 4
Explicación: En este ejemplo, podemos realizar las operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Se puede demostrar que la longitud mínima posible de str_2 es 4.

Ejemplo 2:

Entrada: words = ["ab","b"]
Salida: 2
Explicación: En este ejemplo, str_0 = "ab", hay dos maneras de obtener str_1:
join(str_0, "b") = "ab" o join("b", str_0) = "bab".
El primer string, "ab", tiene la longitud mínima. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: words = ["aaa","c","aba"]
Salida: 6
Explicación: En este ejemplo, podemos realizar las operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Se puede demostrar que la longitud mínima posible de str_2 es 6.

Restricciones:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Cada carácter en words[i] es una letra minúscula inglesa.

Se le proporciona una matriz indexada en 0, words, que contiene n cadenas.
Definamos una operación de unión join(x, y) entre dos cadenas x e y como una concatenación entre ellas en xy. Sin embargo, si el último carácter de x es igual al primer carácter de y, se elimina uno de ellos.
Por ejemplo, join("ab", "ba") = "aba" y join("ab", "cde") = "abcde".
Debe realizar n - 1 operaciones de unión. Sea str_0 = words[0]. A partir de i = 1 hasta i = n - 1, para la operación i^th, puede realizar una de las siguientes acciones:

Hacer str_i = join(str_i - 1, words[i])
Hacer str_i = join(words[i], str_i - 1)

Su tarea es minimizar la longitud de str_n - 1.
Devolver un entero que denote la longitud mínima posible de str_n - 1.

Ejemplo 1:

Entrada: words = ["aa", "ab", "bc"]
Salida: 4
Explicación: En este ejemplo, podemos realizar operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Se puede demostrar que la longitud mínima posible de str_2 es 4.
Ejemplo 2:

Entrada: words = ["ab", "b"]
Salida: 2
Explicación: En este ejemplo, str_0 = "ab", hay dos formas de obtener str_1:
join(str_0, "b") = "ab" o join("b", str_0) = "bab".
La primera cadena, "ab", tiene la longitud mínima. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: words = ["aaa", "c", "aba"]
Salida: 6
Explicación: En este ejemplo, podemos realizar operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Se puede demostrar que la longitud mínima posible de str_2 es 6.

Restricciones:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Cada carácter en words[i] es una letra minúscula del inglés

Se le proporciona una matriz indexada en 0, words, que contiene n cadenas.
Definamos una operación de unión join(x, y) entre dos cadenas x e y como una concatenación entre ellas en xy. Sin embargo, si el último carácter de x es igual al primer carácter de y, se elimina uno de ellos.
Por ejemplo, join("ab", "ba") = "aba" y join("ab", "cde") = "abcde".
Debe realizar n - 1 operaciones de unión. Sea str_0 = words[0]. A partir de i = 1 hasta i = n - 1, para la operación i^th, puede realizar una de las siguientes acciones:

Hacer str_i = join(str_i - 1, words[i])
Hacer str_i = join(words[i], str_i - 1)

Su tarea es minimizar la longitud de str_n - 1.
Devolver un entero que denote la longitud mínima posible de str_n - 1.

Ejemplo 1:

Entrada: words = ["aa","ab","bc"]
Salida: 4
Explicación: En este ejemplo, podemos realizar operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Se puede demostrar que la longitud mínima posible de str_2 es 4.
Ejemplo 2:

Entrada: words = ["ab","b"]
Salida: 2
Explicación: En este ejemplo, str_0 = "ab", hay dos formas de obtener str_1:
join(str_0, "b") = "ab" o join("b", str_0) = "bab".
La primera cadena, "ab", tiene la longitud mínima. Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: words = ["aaa","c","aba"]
Salida: 6
Explicación: En este ejemplo, podemos realizar operaciones de unión en el siguiente orden para minimizar la longitud de str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Se puede demostrar que la longitud mínima posible de str_2 es 6.

Restricciones:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Cada carácter en words[i] es una letra minúscula del inglés


Se te da un array nums indexado desde 0 de n enteros y un entero target. Inicialmente estás posicionado en el índice 0. En un paso, puedes saltar del índice i a cualquier índice j tal que:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Devuelve el número máximo de saltos que puedes hacer para llegar al índice n - 1. Si no hay manera de llegar al índice n - 1, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,3,6,4,1,2], target = 2
Salida: 3
Explicación: Para ir del índice 0 al índice n - 1 con el número máximo de saltos, puedes realizar la siguiente secuencia de saltos:
- Salta del índice 0 al índice 1.
- Salta del índice 1 al índice 3.
- Salta del índice 3 al índice 5.
Se puede demostrar que no hay otra secuencia de saltos que vaya de 0 a n - 1 con más de 3 saltos. Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: nums = [1,3,6,4,1,2], target = 3
Salida: 5
Explicación: Para ir del índice 0 al índice n - 1 con el número máximo de saltos, puedes realizar la siguiente secuencia de saltos:
- Salta del índice 0 al índice 1.
- Salta del índice 1 al índice 2.
- Salta del índice 2 al índice 3.
- Salta del índice 3 al índice 4.
- Salta del índice 4 al índice 5.
Se puede demostrar que no hay otra secuencia de saltos que vaya de 0 a n - 1 con más de 5 saltos. Por lo tanto, la respuesta es 5.

Ejemplo 3:

Entrada: nums = [1,3,6,4,1,2], target = 0
Salida: -1
Explicación: Se puede demostrar que no hay ninguna secuencia de saltos que vaya de 0 a n - 1. Por lo tanto, la respuesta es -1.

Restricciones:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Se le proporciona una matriz indexada en 0 nums de n números enteros y un target entero.
Inicialmente, se le posiciona en el índice 0. En un paso, puede saltar del índice i a cualquier índice j de modo que:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Devuelve la cantidad máxima de saltos que puede realizar para alcanzar el índice n - 1.
Si no hay forma de alcanzar el índice n - 1, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,3,6,4,1,2], target = 2
Salida: 3
Explicación: Para ir del índice 0 al índice n - 1 con el máximo número de saltos, se puede realizar la siguiente secuencia de saltos:
- Saltar del índice 0 al índice 1.
- Saltar del índice 1 al índice 3.
- Saltar del índice 3 al índice 5.
Se puede demostrar que no existe otra secuencia de saltos que vaya del 0 al n - 1 con más de 3 saltos. Por lo tanto, la respuesta es 3.
Ejemplo 2:

Entrada: nums = [1,3,6,4,1,2], target = 3
Salida: 5
Explicación: Para ir del índice 0 al índice n - 1 con el máximo número de saltos, se puede realizar la siguiente secuencia de saltos:
- Saltar del índice 0 al índice 1.
- Saltar del índice 1 al índice 2.
- Saltar del índice 2 al índice 3.
- Saltar del índice 3 al índice 4.
- Saltar del índice 4 al índice 5.
Se puede demostrar que no existe otra secuencia de saltos que vaya del 0 al n - 1 con más de 5 saltos. Por lo tanto, la respuesta es 5.
Ejemplo 3:

Entrada: nums = [1,3,6,4,1,2], target = 0
Salida: -1
Explicación: Se puede demostrar que no existe una secuencia de saltos que vaya de 0 a n - 1. Por lo tanto, la respuesta es -1.

Restricciones:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Se le da un array nums con índice 0 de n enteros y un objetivo entero.
Inicialmente se sitúa en el índice 0. En un paso, puedes saltar del índice i a cualquier índice j tal que:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Devuelve el número máximo de saltos que puedes realizar para alcanzar el índice n - 1.
Si no hay forma de alcanzar el índice n - 1, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,3,6,4,1,2], objetivo = 2
Salida: 3
Explicación: Para ir del índice 0 al índice n - 1 con el máximo número de saltos, se puede realizar la siguiente secuencia de saltos:
- Saltar del índice 0 al índice 1.
- Saltar del índice 1 al índice 3.
- Salto del índice 3 al índice 5.
Se puede demostrar que no existe ninguna otra secuencia de saltos que vaya de 0 a n - 1 con más de 3 saltos. Por lo tanto, la respuesta es 3.
Ejemplo 2:

Entrada: nums = [1,3,6,4,1,2], objetivo = 3
Salida: 5
Explicación: Para ir del índice 0 al índice n - 1 con el máximo número de saltos, se puede realizar la siguiente secuencia de saltos:
- Saltar del índice 0 al índice 1.
- Saltar del índice 1 al índice 2.
- Salto del índice 2 al índice 3.
- Salto del índice 3 al índice 4.
- Salto del índice 4 al índice 5.
Se puede demostrar que no hay otra secuencia de saltos que vaya de 0 a n - 1 con más de 5 saltos. Por lo tanto, la respuesta es 5.
Ejemplo 3:

Entrada: nums = [1,3,6,4,1,2], target = 0
Salida: -1
Explicación: Se puede demostrar que no hay ninguna secuencia de saltos que vaya de 0 a n - 1. Por lo tanto, la respuesta es -1.

Restricciones:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9


Se te da un arreglo nums que consiste en enteros positivos.
Llamamos a un subarreglo de un arreglo completo si se cumple la siguiente condición:

El número de elementos distintos en el subarreglo es igual al número de elementos distintos en todo el arreglo.

Devuelve el número de subarreglos completos.
Un subarreglo es una parte contigua y no vacía de un arreglo.

Ejemplo 1:

Entrada: nums = [1,3,1,2,2]
Salida: 4
Explicación: Los subarreglos completos son los siguientes: [1,3,1,2], [1,3,1,2,2], [3,1,2] y [3,1,2,2].

Ejemplo 2:

Entrada: nums = [5,5,5,5]
Salida: 10
Explicación: El arreglo solo consiste en el entero 5, así que cualquier subarreglo es completo. El número de subarreglos que podemos elegir es 10.

Restricciones:

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

Se da una matriz nums formada por enteros positivos.
Llamamos completa a una submatriz de una matriz si se cumple la siguiente condición:

El número de elementos distintos de la submatriz es igual al número de elementos distintos de la matriz completa.

Devuelve el número de submatrices completas.
Una submatriz es una parte contigua no vacía de una matriz.

Ejemplo 1:

Entrada: nums = [1,3,1,2,2]
Salida: 4
Explicación: Las submatrices completas son las siguientes: [1,3,1,2], [1,3,1,2,2], [3,1,2] y [3,1,2,2].

Ejemplo 2:

Entrada: nums = [5,5,5,5]
Salida: 10
Explicación: El array está formado sólo por el entero 5, por lo que cualquier subarray está completo. El número de submatrices que podemos elegir es 10.

Restricciones:

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

Se te da un array nums que consiste en enteros positivos.
Llamamos a un subarray de un array completo si se cumple la siguiente condición:

El número de elementos distintos en el subarray es igual al número de elementos distintos en todo el array.

Devuelve el número de subarrays completos.
Un subarray es una parte contigua y no vacía de un array.

Ejemplo 1:

Entrada: nums = [1,3,1,2,2]
Salida: 4
Explicación: Los subarrays completos son los siguientes: [1,3,1,2], [1,3,1,2,2], [3,1,2] y [3,1,2,2].

Ejemplo 2:

Entrada: nums = [5,5,5,5]
Salida: 10
Explicación: El array solo consiste en el entero 5, así que cualquier subarray es completo. El número de subarrays que podemos elegir es 10.

Restricciones:

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


Un camión tiene dos tanques de combustible. Se te dan dos números enteros, mainTank que representa el combustible presente en el tanque principal en litros y additionalTank que representa el combustible presente en el tanque adicional en litros.
El camión tiene un rendimiento de 10 km por litro. Cada vez que se consumen 5 litros de combustible del tanque principal, si el tanque adicional tiene al menos 1 litro de combustible, se transferirá 1 litro de combustible del tanque adicional al tanque principal.
Devuelve la distancia máxima que se puede recorrer.
Nota: La inyección desde el tanque adicional no es continua. Sucede de repente e inmediatamente por cada 5 litros consumidos.

Ejemplo 1:

Entrada: mainTank = 5, additionalTank = 10
Salida: 60
Explicación:
Después de gastar 5 litros de combustible, el combustible restante es (5 - 5 + 1) = 1 litro y la distancia recorrida es de 50 km.
Después de gastar otro litro de combustible, no se inyecta combustible en el tanque principal y el tanque principal se vacía.
La distancia total recorrida es de 60 km.

Ejemplo 2:

Entrada: mainTank = 1, additionalTank = 2
Salida: 10
Explicación:
Después de gastar 1 litro de combustible, el tanque principal se vacía.
La distancia total recorrida es de 10 km.

Restricciones:

1 <= mainTank, additionalTank <= 100

Un camión tiene dos tanques de combustible. Se le proporcionan dos números enteros, mainTank que representa el combustible presente en el tanque principal en litros y additionalTank que representa el combustible presente en el tanque adicional en litros.
El camión tiene un kilometraje de 10 km por litro. Siempre que se utilicen 5 litros de combustible en el tanque principal, si el tanque adicional tiene al menos 1 litro de combustible, se transferirá 1 litro de combustible del tanque adicional al tanque principal.
Devuelve la distancia máxima que se puede recorrer.
Nota: La inyección desde el tanque adicional no es continua. Ocurre de repente e inmediatamente por cada 5 litros consumidos.

Ejemplo 1:

Entrada: mainTank = 5, additionalTank = 10
Salida: 60
Explicación:
Después de gastar 5 litros de combustible, el combustible restante es (5 - 5 + 1) = 1 litro y la distancia recorrida es de 50 km.
Después de gastar otro litro de combustible, no se inyecta combustible en el tanque principal y este se vacía. La distancia total recorrida es de 60 km.

Ejemplo 2:

Entrada: mainTank = 1, additionalTank = 2
Salida: 10
Explicación:
Después de gastar 1 litro de combustible, el tanque principal se vacía.
La distancia total recorrida es de 10 km.

Restricciones:

1 <= mainTank, additionalTank <= 100

Un camión tiene dos depósitos de combustible. Se le dan dos enteros, mainTank que representa el combustible presente en el depósito principal en litros y additionalTank que representa el combustible presente en el depósito adicional en litros.
El camión tiene un kilometraje de 10 km por litro. Cada vez que se agoten 5 litros de combustible en el depósito principal, si el depósito adicional tiene al menos 1 litro de combustible, se transferirá 1 litro de combustible del depósito adicional al depósito principal.
Devuelve la distancia máxima que se puede recorrer.
Nota: La inyección desde el depósito adicional no es continua. Se produce de forma repentina e inmediata por cada 5 litros consumidos.

Ejemplo 1:

Entrada: mainTank = 5, additionalTank = 10
Salida 60
Explicación:
Después de gastar 5 litros de combustible, el combustible restante es (5 - 5 + 1) = 1 litro y la distancia recorrida es de 50km.
Después de gastar otro 1 litro de combustible, no se inyecta combustible en el tanque principal y el tanque principal queda vacío.
La distancia total recorrida es de 60 km.

Ejemplo 2:

Entrada: mainTank = 1, additionalTank = 2
Salida 10
Explicación:
Después de gastar 1 litro de combustible, el depósito principal se vacía.
La distancia total recorrida es de 10 km.

Restricciones:

1 <= mainTank, additionalTank <= 100


Se te da un array de enteros nums indexado desde cero y un entero threshold.
Encuentra la longitud de la subarray más larga de nums comenzando en el índice l y terminando en el índice r (0 <= l <= r < nums.length) que satisfaga las siguientes condiciones:

nums[l] % 2 == 0
Para todos los índices i en el rango [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Para todos los índices i en el rango [l, r], nums[i] <= threshold

Devuelve un entero que denote la longitud de dicha subarray más larga.
Nota: Una subarray es una secuencia continua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [3,2,5,4], threshold = 5
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 1 y termina en r = 3 => [2,5,4]. Esta subarray satisface las condiciones.
Por lo tanto, la respuesta es la longitud de la subarray, 3. Podemos demostrar que 3 es la máxima longitud alcanzable posible.

Ejemplo 2:

Entrada: nums = [1,2], threshold = 2
Salida: 1
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 1 y termina en r = 1 => [2].
Satisface todas las condiciones y podemos demostrar que 1 es la máxima longitud alcanzable posible.

Ejemplo 3:

Entrada: nums = [2,3,4,5], threshold = 4
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 0 y termina en r = 2 => [2,3,4].
Satisface todas las condiciones.
Por lo tanto, la respuesta es la longitud de la subarray, 3. Podemos demostrar que 3 es la máxima longitud alcanzable posible.

Restricciones:

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

Se le da una matriz de números enteros con índice 0 y un umbral entero.
Hallar la longitud de la submatriz más larga de nums que comienza en el índice l y termina en el índice r (0 <= l <= r < nums.length) que satisface las siguientes condiciones:

nums[l] % 2 == 0
Para todos los índices i del intervalo [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Para todos los índices i en el intervalo [l, r], nums[i] <= umbral

Devuelve un entero que denota la longitud de la submatriz más larga.
Nota: Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1

Entrada: nums = [3,2,5,4], umbral = 5
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la submatriz que empieza en l = 1 y termina en r = 3 => [2,5,4]. Esta submatriz cumple las condiciones.
Por lo tanto, la respuesta es la longitud de la submatriz, 3. Podemos demostrar que 3 es la longitud máxima alcanzable.
Ejemplo 2:

Entrada: nums = [1,2], umbral = 2
Salida: 1
Explicación: En este ejemplo, podemos seleccionar la submatriz que empieza en l = 1 y termina en r = 1 => [2].
Satisface todas las condiciones y podemos demostrar que 1 es la longitud máxima alcanzable.

Ejemplo 3:

Entrada: nums = [2,3,4,5], umbral = 4
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la submatriz que empieza en l = 0 y termina en r = 2 => [2,3,4].
Cumple todas las condiciones.
Por lo tanto, la respuesta es la longitud de la submatriz, 3. Podemos demostrar que 3 es la máxima longitud posible alcanzable.

Restricciones:

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

Se te da un array de enteros nums indexado desde cero y un entero threshold.
Encuentra la longitud de la subarray más larga de nums comenzando en el índice l y terminando en el índice r (0 <= l <= r < nums.length) que satisfaga las siguientes condiciones:

nums[l] % 2 == 0
Para todos los índices i en el rango [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Para todos los índices i en el rango [l, r], nums[i] <= threshold

Devuelve un entero que denote la longitud de dicha subarray más larga.
Nota: Una subarray es una secuencia continua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [3,2,5,4], threshold = 5
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 1 y termina en r = 3 => [2,5,4]. Esta subarray satisface las condiciones.
Por lo tanto, la respuesta es la longitud de la subarray, 3. Podemos demostrar que 3 es la máxima longitud alcanzable posible.

Entrada: nums = [1,2], threshold = 2
Salida: 1
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 1 y termina en r = 1 => [2].
Satisface todas las condiciones y podemos demostrar que 1 es la máxima longitud alcanzable posible..

Ejemplo 3:

Input: nums = [2,3,4,5], threshold = 4
Salida: 3
Explicación: En este ejemplo, podemos seleccionar la subarray que comienza en l = 0 y termina en r = 2 => [2,3,4].
Satisface todas las condiciones.
Por lo tanto, la respuesta es la longitud de la subarray, 3. Podemos demostrar que 3 es la máxima longitud alcanzable posible.

Restricciones:

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