Se le da una matriz 2D de coordenadas enteras y un número entero k, donde coordenadas[i] = [x_i, y_i] son las coordenadas del i^ésimo punto en un plano 2D.
Definimos la distancia entre dos puntos (x_1, y_1) y (x_2, y_2) como (x1 XOR x2) + (y1 XOR y2) donde XOR es la operación XOR a nivel de bit.
Devuelve el número de pares (i, j) tales que i < j y la distancia entre los puntos i y j es igual a k.

Ejemplo 1:

Entrada: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Salida: 2
Explicación: Podemos elegir los siguientes pares:
- (0,1): Porque tenemos (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Porque tenemos (1 XOR 5) + (3 XOR 2) = 5.

Ejemplo 2:

Entrada: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Salida: 10
Explicación: Dos pares cualesquiera elegidos tendrán una distancia de 0. Hay 10 formas de elegir dos pares.

Restricciones:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Dadas las coordenadas de una matriz de enteros 2D y un entero k, donde las coordenadas [i] = [x_i, y_i] son las coordenadas del i-ésimo punto en un plano 2D.
Definimos la distancia entre dos puntos (x_1, y_1) y (x_2, y_2) como (x1 XOR x2) + (y1 XOR y2) donde XOR es la operación bit a bit XOR.
Devuelve el número de pares (i, j) de manera que i < j y la distancia entre los puntos i y j sea igual a k.

Ejemplo 1:

Input: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Output: 2
Explicación: Podemos elegir los siguientes pares:
- (0,1): Porque tenemos (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Porque tenemos (1 XOR 5) + (3 XOR 2) = 5.

Ejemplo 2:

Input: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Output: 10
Explicación: Cualquier par que elijamos tendrá una distancia de 0. Hay 10 maneras de elegir dos pares.

Restricciones:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Se te da un array 2D de enteros coordinates y un entero k, donde coordinates[i] = [x_i, y_i] son las coordenadas del i-ésimo punto en un plano 2D.
Definimos la distancia entre dos puntos (x_1, y_1) y (x_2, y_2) como (x1 XOR x2) + (y1 XOR y2) donde XOR es la operación bit a bit XOR.
Devuelve el número de pares (i, j) tal que i < j y la distancia entre los puntos i y j es igual a k.

Ejemplo 1:

Entrada: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Salida: 2
Explicación: Podemos elegir los siguientes pares:
- (0,1): Porque tenemos (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Porque tenemos (1 XOR 5) + (3 XOR 2) = 5.

Ejemplo 2:

Entrada: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Salida: 10
Explicación: Cualquier par que elijamos tendrá una distancia de 0. Hay 10 maneras de elegir dos pares.

Restricciones:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


Se te da un array de enteros nums y dos enteros positivos m y k.
Devuelve la suma máxima de todos los subarrays casi únicos de longitud k de nums. Si no existe tal subarray, devuelve 0.
Un subarray de nums es casi único si contiene al menos m elementos distintos.
Un subarray es una secuencia contigua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [2,6,7,3,1,7], m = 3, k = 4
Salida: 18
Explicación: Hay 3 subarrays casi únicos de tamaño k = 4. Estos subarrays son [2, 6, 7, 3], [6, 7, 3, 1], y [7, 3, 1, 7]. Entre estos subarrays, el que tiene la suma máxima es [2, 6, 7, 3] que tiene una suma de 18.

Ejemplo 2:

Entrada: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Salida: 23
Explicación: Hay 5 subarrays casi únicos de tamaño k. Estos subarrays son [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], y [4, 5, 4]. Entre estos subarrays, el que tiene la suma máxima es [5, 9, 9] que tiene una suma de 23.

Ejemplo 3:

Entrada: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Salida: 0
Explicación: No hay subarrays de tamaño k = 3 que contengan al menos m = 3 elementos distintos en el array dado [1,2,1,2,1,2,1]. Por lo tanto, no existen subarrays casi únicos, y la suma máxima es 0.

Restricciones:

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

Se le proporciona una matriz de números enteros nums y dos números enteros positivos m y k.
Devuelve la suma máxima de todas las submatrices casi únicas de longitud k de nums. Si no existe ninguna submatriz de este tipo, devuelve 0.
Una submatriz de nums es casi única si contiene al menos m elementos distintos.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [2,6,7,3,1,7], m = 3, k = 4
Salida: 18
Explicación: Hay 3 submatrices casi únicas de tamaño k = 4. Estas submatrices son [2, 6, 7, 3], [6, 7, 3, 1] y [7, 3, 1, 7]. Entre estos subconjuntos, el que tiene la suma máxima es [2, 6, 7, 3], que tiene una suma de 18.

Ejemplo 2:

Entrada: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Salida: 23
Explicación: Hay 5 subconjuntos casi únicos de tamaño k. Estos subconjuntos son [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] y [4, 5, 4]. Entre estos subconjuntos, el que tiene la suma máxima es [5, 9, 9], que tiene una suma de 23.

Ejemplo 3:

Entrada: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Salida: 0
Explicación: No existen subconjuntos de tamaño k = 3 que contengan al menos m = 3 elementos distintos en el conjunto dado [1,2,1,2,1,2,1]. Por lo tanto, no existen subconjuntos casi únicos y la suma máxima es 0.

Restricciones:

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

Se te da un array de enteros nums y dos enteros positivos m y k.
Devuelve la suma máxima de todos los subarrays casi únicos de longitud k de nums. Si no existe tal subarray, devuelve 0.
Un subarray de nums es casi único si contiene al menos m elementos distintos.
Un subarray es una secuencia contigua y no vacía de elementos dentro de un array.

Ejemplo 1:

Input: nums = [2,6,7,3,1,7], m = 3, k = 4
Output: 18
Explicación :  Hay 3 subarrays casi únicos de tamaño k = 4. Estos subarrays son [2, 6, 7, 3], [6, 7, 3, 1], y [7, 3, 1, 7]. Entre estos subarrays, el que tiene la suma máxima es [2, 6, 7, 3] que tiene una suma de 18.

Ejemplo 2:

Input: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Output: 23
Explicación: Hay 5 subarrays casi únicos de tamaño k. Estos subarrays son [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], y [4, 5, 4]. Entre estos subarrays, el que tiene la suma máxima es [5, 9, 9] que tiene una suma de 23.

Ejemplo 3:

Input: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Output: 0
Explicación: No hay subarrays de tamaño k = 3 que contengan al menos m = 3 elementos distintos en el array dado [1,2,1,2,1,2,1]. Por lo tanto, no existen subarrays casi únicos, y la suma máxima es 0.

Restricciones:

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


Inicialmente, tienes un saldo de cuenta bancaria de 100 dólares.
Se te da un entero purchaseAmount que representa la cantidad que gastarás en una compra en dólares.
En la tienda donde harás la compra, el monto de la compra se redondea al múltiplo de 10 más cercano. En otras palabras, pagas una cantidad no negativa, roundedAmount, tal que roundedAmount es un múltiplo de 10 y abs(roundedAmount - purchaseAmount) se minimiza.
Si hay más de un múltiplo de 10 más cercano, se elige el múltiplo más grande.
Devuelve un entero que denote tu saldo de cuenta después de realizar una compra por valor de purchaseAmount dólares en la tienda.
Nota: en este problema, 0 se considera un múltiplo de 10.

Ejemplo 1:

Entrada: purchaseAmount = 9
Salida: 90
Explicación: En este ejemplo, el múltiplo de 10 más cercano a 9 es 10. Por lo tanto, tu saldo de cuenta se convierte en 100 - 10 = 90.

Ejemplo 2:

Entrada: purchaseAmount = 15
Salida: 80
Explicación: En este ejemplo, hay dos múltiplos de 10 más cercanos a 15: 10 y 20. Así que se elige el múltiplo más grande, 20.
Por lo tanto, tu saldo de cuenta se convierte en 100 - 20 = 80.

Restricciones:

0 <= purchaseAmount <= 100

Inicialmente, tienes un saldo en tu cuenta bancaria de 100 dólares.
Se te da un número entero purchaseAmount que representa el monto que gastarás en una compra en dólares.
En la tienda donde realizarás la compra, el monto de la compra se redondea al múltiplo de 10 más cercano. En otras palabras, pagas un monto no negativo, roundedAmount, de modo que roundedAmount es un múltiplo de 10 y abs(roundedAmount - purchaseAmount) se minimiza.
Si hay más de un múltiplo de 10 más cercano, se elige el múltiplo más grande.
Devuelve un número entero que denota el saldo de tu cuenta después de realizar una compra por un valor de purchaseAmount en dólares en la tienda.
Nota: 0 se considera un múltiplo de 10 en este problema.

Ejemplo 1:

Entrada: purchaseAmount = 9
Salida: 90
Explicación: En este ejemplo, el múltiplo más cercano de 10 a 9 es 10. Por lo tanto, el saldo de su cuenta se convierte en 100 - 10 = 90.

Ejemplo 2:

Entrada: purchaseAmount = 15
Salida: 80
Explicación: En este ejemplo, hay dos múltiplos más cercanos de 10 a 15: 10 y 20. Por lo tanto, se elige el múltiplo más grande, 20.
Por lo tanto, el saldo de su cuenta se convierte en 100 - 20 = 80.

Restricciones:

0 <= purchaseAmount <= 100


Dado un array de cadenas words y una cadena s, determina si s es un acrónimo de words.
La cadena s se considera un acrónimo de words si se puede formar concatenando el primer carácter de cada cadena en words en orden. Por ejemplo, "ab" se puede formar a partir de ["apple", "banana"], pero no se puede formar a partir de ["bear", "aardvark"].
Devuelve true si s es un acrónimo de words, y false en caso contrario.

Ejemplo 1:

Entrada: words = ["alice","bob","charlie"], s = "abc"
Salida: true
Explicación: El primer carácter en las palabras "alice", "bob" y "charlie" son 'a', 'b' y 'c', respectivamente. Por lo tanto, s = "abc" es el acrónimo.

Ejemplo 2:

Entrada: words = ["an","apple"], s = "a"
Salida: false
Explicación: El primer carácter en las palabras "an" y "apple" son 'a' y 'a', respectivamente.
El acrónimo formado concatenando estos caracteres es "aa".
Por lo tanto, s = "a" no es el acrónimo.

Ejemplo 3:

Entrada: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Salida: true
Explicación: Al concatenar el primer carácter de las palabras en el array, obtenemos la cadena "ngguoy".
Por lo tanto, s = "ngguoy" es el acrónimo.

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] y s consisten en letras minúsculas inglesas.

Dado un arreglo de cadenas de palabras y una cadena de caracteres s, determine si s es un acrónimo de palabras.
La cadena de caracteres s se considera un acrónimo de palabras si se puede formar concatenando el primer carácter de cada cadena de caracteres en palabras en orden. Por ejemplo, "ab" se puede formar a partir de ["manzana", "plátano"], pero no se puede formar a partir de ["oso", "oso hormiguero"].
Devuelve verdadero si s es un acrónimo de palabras y falso en caso contrario.

Ejemplo 1:

Entrada: words = ["alice","bob","charlie"], s = "abc"
Salida: verdadero
Explicación: El primer carácter de las palabras "alice", "bob" y "charlie" son 'a', 'b' y 'c', respectivamente. Por lo tanto, s = "abc" es el acrónimo.

Ejemplo 2:

Entrada: words = ["an","apple"], s = "a"
Salida: false
Explicación: El primer carácter de las palabras "an" y "apple" son 'a' y 'a', respectivamente.
El acrónimo formado al concatenar estos caracteres es "aa".
Por lo tanto, s = "a" no es el acrónimo.

Ejemplo 3:

Entrada: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Salida: true
Explicación: Al concatenar el primer carácter de las palabras en la matriz, obtenemos la cadena "ngguoy".
Por lo tanto, s = "ngguoy" es el acrónimo.

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] y s constan de letras minúsculas en inglés.

Dado un arreglo de cadenas de words y una cadena de caracteres s, determine si s es un acrónimo de words.
La cadena de caracteres s se considera un acrónimo de words si se puede formar concatenando el primer carácter de cada cadena de caracteres en words en orden. Por ejemplo, "ab" se puede formar a partir de ["apple", "banana"], pero no se puede formar a partir de ["bear", "aardvark"].
Devuelve verdadero si s es un acrónimo de palabras y falso en caso contrario.

Ejemplo 1:

Entrada: words = ["alice","bob","charlie"], s = "abc"
Salida: true
Explicación: El primer carácter de las palabras "alice", "bob" y "charlie" son 'a', 'b' y 'c', respectivamente. Por lo tanto, s = "abc" es el acrónimo.

Ejemplo 2:

Entrada: words = ["an","apple"], s = "a"
Salida: false
Explicación: El primer carácter de las palabras "an" y "apple" son 'a' y 'a', respectivamente.
El acrónimo formado al concatenar estos caracteres es "aa".
Por lo tanto, s = "a" no es el acrónimo.

Ejemplo 3:

Entrada: words = ["never", "gonna", "give", "up", "on", "you"], s = "ngguoy"
Salida: true
Explicación: Al concatenar el primer carácter de las palabras en la matriz, obtenemos la cadena "ngguoy".
Por lo tanto, s = "ngguoy" es el acrónimo.

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] y s consisten en letras minúsculas inglesas.


Se te da un entero n que representa el número de casas en una línea numérica, numeradas de 0 a n - 1.
Además, se te da un array de enteros 2D offers donde offers[i] = [start_i, end_i, gold_i], indicando que el comprador i quiere comprar todas las casas desde start_i hasta end_i por una cantidad de gold_i en oro.
Como vendedor, tu objetivo es maximizar tus ganancias seleccionando y vendiendo casas estratégicamente a los compradores.
Devuelve la cantidad máxima de oro que puedes ganar.
Ten en cuenta que diferentes compradores no pueden comprar la misma casa, y algunas casas pueden quedarse sin vender.

Ejemplo 1:

Entrada: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Salida: 3
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas en el rango [0,0] al 1^er comprador por 1 oro y las casas en el rango [1,3] al 3^er comprador por 2 oros.
Se puede demostrar que 3 es la cantidad máxima de oro que podemos lograr.

Ejemplo 2:

Entrada: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Salida: 10
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas en el rango [0,2] al 2^do comprador por 10 oros.
Se puede demostrar que 10 es la cantidad máxima de oro que podemos lograr.

Restricciones:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

Se te da un número entero n que representa el número de casas en una línea numérica, numeradas de 0 a n - 1.
Además, se te da una matriz de números enteros 2D offers donde offers[i] = [start_i, end_i, gold_i], indicando que el comprador i quiere comprar todas las casas desde start_i hasta end_i por una cantidad de gold_i en oro.
Como vendedor, tu objetivo es maximizar tus resultados seleccionando y vendiendo casas estratégicamente a los compradores.
Devuelve la cantidad máxima de oro que puedes ganar.
Ten en cuenta que diferentes compradores no pueden comprar la misma casa, y algunas casas pueden quedarse sin vender.

Ejemplo 1:

Entrada: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Salida: 3
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas en el rango [0,0] al 1^er comprador por 1 oro y las casas en el rango [1,3] al 3^er comprador por 2 oros.
Se puede demostrar que 3 es la cantidad máxima de oro que podemos lograr.

Ejemplo 2:

Entrada: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Salida: 10
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas en el rango [0,2] al 2^do comprador por 10 oros.
Se puede demostrar que 10 es la cantidad máxima de oro que podemos lograr.

Restricciones:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

Se le da un número entero n que representa el número de casas en una recta numérica, numerada de 0 a n - 1.
Además, se le da una matriz de enteros 2D ofertas donde ofertas[i] = [inicio_i, fin_i, oro_i], lo que indica que i^th comprador quiere comprar todas las casas de inicio_i a fin_i para oro_i cantidad de oro.
Como vendedor, tu objetivo es maximizar tus ganancias seleccionando y vendiendo estratégicamente las casas a los compradores.
Devuelve la máxima cantidad de oro que puedas ganar.
Tenga en cuenta que diferentes compradores no pueden comprar la misma casa, y algunas casas pueden quedar sin vender.

Ejemplo 1:

Entrada: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Salida: 3
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas del rango [0,0] al 1^er comprador por 1 oro y las casas del rango [1,3] al 3^er comprador por 2 oros.
Se puede demostrar que 3 es la cantidad máxima de oro que podemos conseguir.

Ejemplo 2:

Entrada: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Salida: 10
Explicación: Hay 5 casas numeradas del 0 al 4 y hay 3 ofertas de compra.
Vendemos las casas del rango [0,2] al 2^º comprador por 10 oros.
Se puede demostrar que 10 es la cantidad máxima de oro que podemos conseguir.

Restricciones:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3


Se te dan dos enteros positivos low y high.
Un entero x que consiste en 2 * n dígitos es simétrico si la suma de los primeros n dígitos de x es igual a la suma de los últimos n dígitos de x. Los números con un número impar de dígitos nunca son simétricos.
Devuelve la cantidad de enteros simétricos en el rango [low, high].

Ejemplo 1:

Entrada: low = 1, high = 100
Salida: 9
Explicación: Hay 9 enteros simétricos entre 1 y 100: 11, 22, 33, 44, 55, 66, 77, 88 y 99.

Ejemplo 2:

Entrada: low = 1200, high = 1230
Salida: 4
Explicación: Hay 4 enteros simétricos entre 1200 y 1230: 1203, 1212, 1221 y 1230.

Restricciones:

1 <= low <= high <= 10^4

Se le proporcionan dos números enteros positivos, bajo y alto.
Un número entero x que consta de 2 * n dígitos es simétrico si la suma de los primeros n dígitos de x es igual a la suma de los últimos n dígitos de x. Los números con un número impar de dígitos nunca son simétricos.
Devuelve el número de números enteros simétricos en el rango [bajo, alto].

Ejemplo 1:

Entrada: low = 1, high = 100
Salida: 9
Explicación: Hay 9 números enteros simétricos entre 1 y 100: 11, 22, 33, 44, 55, 66, 77, 88 y 99.

Ejemplo 2:

Entrada: low = 1200, high = 1230
Salida: 4
Explicación: Hay 4 números enteros simétricos entre 1200 y 1230: 1203, 1212, 1221 y 1230.

Restricciones:

1 <= low <= high <= 10^4


Se te dan dos cadenas s1 y s2, ambas de longitud 4, compuestas por letras minúsculas del alfabeto inglés.
Puedes aplicar la siguiente operación en cualquiera de las dos cadenas cualquier cantidad de veces:

Elige dos índices i y j tal que j - i = 2, luego intercambia los dos caracteres en esos índices en la cadena.

Devuelve true si puedes hacer que las cadenas s1 y s2 sean iguales, y false en caso contrario.

Ejemplo 1:

Entrada: s1 = "abcd", s2 = "cdab"
Salida: true
Explicación: Podemos hacer las siguientes operaciones en s1:
- Elige los índices i = 0, j = 2. La cadena resultante es s1 = "cbad".
- Elige los índices i = 1, j = 3. La cadena resultante es s1 = "cdab" = s2.

Ejemplo 2:

Entrada: s1 = "abcd", s2 = "dacb"
Salida: false
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

s1.length == s2.length == 4
s1 y s2 consisten solo de letras minúsculas del alfabeto inglés.

Se le proporcionan dos cadenas s1 y s2, ambas de longitud 4, que constan de letras minúsculas en inglés.
Puede aplicar la siguiente operación en cualquiera de las dos cadenas cualquier cantidad de veces:

Elija dos índices i y j de manera que j - i = 2, luego intercambie los dos caracteres en esos índices en la cadena.

Devuelva true si puede hacer que las cadenas s1 y s2 sean iguales, y false en caso contrario.

Ejemplo 1:

Entrada: s1 = "abcd", s2 = "cdab"
Salida: true
Explicación: Podemos realizar las siguientes operaciones en s1:
- Elija los índices i = 0, j = 2. La cadena resultante es s1 = "cbad".
- Elija los índices i = 1, j = 3. La cadena resultante es s1 = "cdab" = s2.

Ejemplo 2:

Entrada: s1 = "abcd", s2 = "dacb"
Salida: false
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

s1.length == s2.length == 4
s1 y s2 constan únicamente de letras minúsculas del alfabeto inglés.

Se le proporcionan dos cadenas s1 y s2, ambas de longitud 4, que constan de letras minúsculas en inglés.
Puede aplicar la siguiente operación en cualquiera de las dos cadenas cualquier cantidad de veces:

Elija dos índices i y j de manera que j - i = 2, luego intercambie los dos caracteres en esos índices en la cadena.

Devuelva verdadero si puede hacer que las cadenas s1 y s2 sean iguales, y falso en caso contrario.

Ejemplo 1:

Entrada: s1 = "abcd", s2 = "cdab"
Salida: verdadero
Explicación: Podemos realizar las siguientes operaciones en s1:
- Elija los índices i = 0, j = 2. La cadena resultante es s1 = "cbad".
- Elija los índices i = 1, j = 3. La cadena resultante es s1 = "cdab" = s2.

Ejemplo 2:

Entrada: s1 = "abcd", s2 = "dacb"
Salida: false
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

s1.length == s2.length == 4
s1 y s2 constan únicamente de letras minúsculas del alfabeto inglés.


Se te da un array de enteros indexado desde 0, llamado `nums`, y un entero `x`.
Encuentra la diferencia mínima absoluta entre dos elementos en el array que estén al menos a `x` índices de distancia.
En otras palabras, encuentra dos índices `i` y `j` tales que `abs(i - j) >= x` y `abs(nums[i] - nums[j])` sea minimizada.
Devuelve un entero que denote la diferencia absoluta mínima entre dos elementos que estén al menos a `x` índices de distancia.

Ejemplo 1:

Entrada: nums = [4,3,2,4], x = 2
Salida: 0
Explicación: Podemos seleccionar nums[0] = 4 y nums[3] = 4.
Están al menos a 2 índices de distancia, y su diferencia absoluta es la mínima, 0.
Se puede demostrar que 0 es la respuesta óptima.

Ejemplo 2:

Entrada: nums = [5,3,2,10,15], x = 1
Salida: 1
Explicación: Podemos seleccionar nums[1] = 3 y nums[2] = 2.
Están al menos a 1 índice de distancia, y su diferencia absoluta es la mínima, 1.
Se puede demostrar que 1 es la respuesta óptima.

Ejemplo 3:

Entrada: nums = [1,2,3,4], x = 3
Salida: 3
Explicación: Podemos seleccionar nums[0] = 1 y nums[3] = 4.
Están al menos a 3 índices de distancia, y su diferencia absoluta es la mínima, 3.
Se puede demostrar que 3 es la respuesta óptima.

Restricciones:

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

Se le da una matriz de números enteros con índice 0 y un número entero x.
Hallar la diferencia absoluta mínima entre dos elementos de la matriz que estén separados por al menos x índices.
En otras palabras, encontrar dos índices i y j tales que abs(i - j) >= x y abs(nums[i] - nums[j]) se minimiza.
Devuelve un entero que denota la diferencia absoluta mínima entre dos elementos que están separados por al menos x índices.

Ejemplo 1:

Entrada: nums = [4,3,2,4], x = 2
Salida: 0
Explicación: Podemos seleccionar nums[0] = 4 y nums[3] = 4.
Están separados por al menos 2 índices y su diferencia absoluta es el mínimo, 0.
Se puede demostrar que 0 es la respuesta óptima.

Ejemplo 2:

Entrada: nums = [5,3,2,10,15], x = 1
Salida: 1
Explicación: Podemos seleccionar nums[1] = 3 y nums[2] = 2. Están separados por al menos 1 índice.
Están separados por al menos 1 índice, y su diferencia absoluta es la mínima, 1.
Se puede demostrar que 1 es la respuesta óptima.

Ejemplo 3:

Entrada: nums = [1,2,3,4], x = 3
Salida: 3
Explicación: Podemos seleccionar nums[0] = 1 y nums[3] = 4. Están separados por al menos 3 índices.
Están separados por al menos 3 índices, y su diferencia absoluta es la mínima, 3.
Se puede demostrar que 3 es la respuesta óptima.

Restricciones:

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

Se te da un arreglo de enteros indexado desde 0, llamado nums, y un entero x.
Encuentra la diferencia mínima absoluta entre dos elementos en el arreglo que estén al menos a x índices de distancia.
En otras palabras, encuentra dos índices i y j tales que abs(i - j) >= x y abs(nums[i] - nums[j]) sea minimizada.
Devuelve un entero que denote la diferencia absoluta mínima entre dos elementos que estén al menos a x índices de distancia.

Ejemplo 1:

Entrada: nums = [4,3,2,4], x = 2
Salida: 0
Explicación: Podemos seleccionar nums[0] = 4 y nums[3] = 4.
Están al menos a 2 índices de distancia, y su diferencia absoluta es la mínima, 0.
Se puede demostrar que 0 es la respuesta óptima.

Ejemplo 2:

Entrada: nums = [5,3,2,10,15], x = 1
Salida: 1
Explicación: Podemos seleccionar nums[1] = 3 y nums[2] = 2.
Están al menos a 1 índice de distancia, y su diferencia absoluta es la mínima, 1.
Se puede demostrar que 1 es la respuesta óptima.

Ejemplo 3:

Entrada: nums = [1,2,3,4], x = 3
Salida: 3
Explicación: Podemos seleccionar nums[0] = 1 y nums[3] = 4.
Están al menos a 3 índices de distancia, y su diferencia absoluta es la mínima, 3.
Se puede demostrar que 3 es la respuesta óptima.

Restricciones:

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


Se te dan enteros positivos low, high y k.
Un número es hermoso si cumple ambas condiciones:

La cantidad de dígitos pares en el número es igual a la cantidad de dígitos impares.
El número es divisible por k.

Devuelve la cantidad de enteros hermosos en el rango [low, high].

Ejemplo 1:

Entrada: low = 10, high = 20, k = 3
Salida: 2
Explicación: Hay 2 enteros hermosos en el rango dado: [12,18].
- 12 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 3.
- 18 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 3.
Además, podemos ver que:
- 16 no es hermoso porque no es divisible por k = 3.
- 15 no es hermoso porque no contiene igual cantidad de dígitos pares e impares.
Se puede demostrar que solo hay 2 enteros hermosos en el rango dado.

Ejemplo 2:

Entrada: low = 1, high = 10, k = 1
Salida: 1
Explicación: Hay 1 entero hermoso en el rango dado: [10].
- 10 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 1.
Se puede demostrar que solo hay 1 entero hermoso en el rango dado.

Ejemplo 3:

Entrada: low = 5, high = 5, k = 2
Salida: 0
Explicación: Hay 0 enteros hermosos en el rango dado.
- 5 no es hermoso porque no es divisible por k = 2 y no contiene igual cantidad de dígitos pares e impares.

Restricciones:

0 < low <= high <= 10^9
0 < k <= 20

Se dan números enteros positivos bajo, alto y k.
Un número es bello si cumple las dos condiciones siguientes:

El número de cifras pares es igual al número de cifras impares.
El número es divisible por k.

Devuelve el número de números enteros hermosos en el intervalo [bajo, alto].

Ejemplo 1:

Entrada: low = 10, high = 20, k = 3
Salida 2
Explicación: Hay 2 bellos enteros en el rango dado: [12,18].
- 12 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 3.
- 18 es bello porque contiene 1 cifra impar y 1 cifra par, y es divisible por k = 3.
Además podemos ver que
- 16 no es bello porque no es divisible por k = 3.
- 15 no es bello porque no contiene el mismo número de cifras pares e impares.
Se puede demostrar que sólo hay 2 números enteros bonitos en el intervalo dado.

Ejemplo 2:

Entrada: low = 1, high = 10, k = 1
Salida: 1
Explicación: Hay 1 entero bello en el rango dado: [10].
- 10 es bello porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 1.
Se puede demostrar que sólo hay 1 entero bonito en el intervalo dado.

Ejemplo 3:

Entrada: low = 5, high = 5, k = 2
Salida: 0
Explicación: Hay 0 números enteros hermosos en el rango dado.
- 5 no es bello porque no es divisible por k = 2 y no contiene dígitos pares e impares iguales.

Restricciones:

0 < low <= high <= 10^9
0 < k <= 20

Se te dan enteros positivos low, high y k.
Un número es hermoso si cumple ambas condiciones:

La cantidad de dígitos pares en el número es igual a la cantidad de dígitos impares.
El número es divisible por k.

Devuelve la cantidad de enteros hermosos en el rango [low, high].

Ejemplo 1:

Entada: low = 10, high = 20, k = 3
Salida: 2
Explicación: Hay 2 enteros hermosos en el rango dado: [12,18].
- 12 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 3.
- 18 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 3.
Además, podemos ver que:
- 16 no es hermoso porque no es divisible por k = 3.
- 15 no es hermoso porque no contiene igual cantidad de dígitos pares e impares.
Se puede demostrar que solo hay 2 enteros hermosos en el rango dado.

Ejemplo 2:

Entrada: low = 1, high = 10, k = 1
Salida: 1
Explicación: Hay 1 entero hermoso en el rango dado: [10].
- 10 es hermoso porque contiene 1 dígito impar y 1 dígito par, y es divisible por k = 1.
Se puede demostrar que solo hay 1 entero hermoso en el rango dado.

Ejemplo 3:

Entrada: low = 5, high = 5, k = 2
Salida: 0
Explicación: Hay 0 enteros hermosos en el rango dado.
- 5 no es hermoso porque no es divisible por k = 2 y no contiene igual cantidad de dígitos pares e impares.

Restricciones:

0 < low <= high <= 10^9
0 < k <= 20


Se te dan dos cadenas 0-indexadas str1 y str2.
En una operación, seleccionas un conjunto de índices en str1 y, para cada índice i en el conjunto, incrementas str1[i] al siguiente carácter cíclicamente. Es decir, 'a' se convierte en 'b', 'b' se convierte en 'c', y así sucesivamente, y 'z' se convierte en 'a'.
Devuelve true si es posible hacer que str2 sea una subsecuencia de str1 realizando la operación como máximo una vez, y false en caso contrario.
Nota: Una subsecuencia de una cadena es una nueva cadena que se forma a partir de la cadena original eliminando algunos (posiblemente ninguno) de los caracteres sin alterar las posiciones relativas de los caracteres restantes.

Ejemplo 1:

Entrada: str1 = "abc", str2 = "ad"
Salida: true
Explicación: Seleccionar el índice 2 en str1.
Incrementar str1[2] para convertirse en 'd'.
Por lo tanto, str1 se convierte en "abd" y str2 ahora es una subsecuencia. Por lo tanto, se devuelve true.
Ejemplo 2:

Entrada: str1 = "zc", str2 = "ad"
Salida: true
Explicación: Seleccionar los índices 0 y 1 en str1.
Incrementar str1[0] para convertirse en 'a'.
Incrementar str1[1] para convertirse en 'd'.
Por lo tanto, str1 se convierte en "ad" y str2 ahora es una subsecuencia. Por lo tanto, se devuelve true.
Ejemplo 3:

Entrada: str1 = "ab", str2 = "d"
Salida: false
Explicación: En este ejemplo, se puede demostrar que es imposible hacer que str2 sea una subsecuencia de str1 utilizando la operación como máximo una vez.
Por lo tanto, se devuelve false.

Restricciones:

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 y str2 consisten solo en letras minúsculas del inglés.

Se le dan dos cadenas con índice 0 str1 y str2.
En una operación, seleccionas un conjunto de índices en str1, y por cada índice i en el conjunto, incrementas str1[i] al siguiente carácter cíclicamente. Es decir, 'a' se convierte en 'b', 'b' se convierte en 'c', y así sucesivamente, y 'z' se convierte en 'a'.
Devuelve true si es posible convertir str2 en una subsecuencia de str1 realizando la operación como máximo una vez, y false en caso contrario.
Nota: Una subsecuencia de una cadena es una cadena nueva que se forma a partir de la cadena original eliminando algunos caracteres (posiblemente ninguno) sin alterar las posiciones relativas de los caracteres restantes.

Ejemplo 1

Entrada: str1 = "abc", str2 = "ad"
Salida: true
Explicación: Selecciona el índice 2 en str1.
Incrementa str1[2] para que se convierta en 'd'.
Por lo tanto, str1 se convierte en "abd" y str2 es ahora una subsecuencia. Por lo tanto, se devuelve true.
Ejemplo 2:

Entrada: str1 = "zc", str2 = "ad"
Salida: true
Explicación: Selecciona los índices 0 y 1 en str1.
Incrementa str1[0] para que sea 'a'.
Incrementa str1[1] para que sea 'd'.
Por lo tanto, str1 se convierte en "ad" y str2 es ahora una subsecuencia. Por lo tanto, se devuelve verdadero.
Ejemplo 3:

Entrada: str1 = "ab", str2 = "d"
Salida: false
Explicación: En este ejemplo, se puede demostrar que es imposible hacer de str2 una subsecuencia de str1 utilizando la operación como máximo una vez.
Por lo tanto, se devuelve false.

Restricciones:

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 y str2 constan sólo de letras minúsculas inglesas.

Se te dan dos cadenas 0-indexadas str1 y str2.
En una operación, seleccionas un conjunto de índices en str1 y, para cada índice i en el conjunto, incrementas str1[i] al siguiente carácter cíclicamente. Es decir, 'a' se convierte en 'b', 'b' se convierte en 'c', y así sucesivamente, y 'z' se convierte en 'a'.
Devuelve true si es posible hacer que str2 sea una subsecuencia de str1 realizando la operación como máximo una vez, y false en caso contrario.
Nota: Una subsecuencia de una cadena es una nueva cadena que se forma a partir de la cadena original eliminando algunos (posiblemente ninguno) de los caracteres sin alterar las posiciones relativas de los caracteres restantes.

Ejemplo 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Explicación: Seleccionar el índice 2 en str1.
Incrementar str1[2] para convertirse en 'd'.
Por lo tanto, str1 se convierte en "abd" y str2 ahora es una subsecuencia. Por lo tanto, se devuelve true.
Ejemplo 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Explicación: Seleccionar los índices 0 y 1 en str1.
Incrementar str1[0] para convertirse en 'a'.
Incrementar str1[1] para convertirse en 'd'.
Por lo tanto, str1 se convierte en "ad" y str2 ahora es una subsecuencia. Por lo tanto, se devuelve true.
Ejemplo 3:

Input: str1 = "ab", str2 = "d"
Output: false
Explicación: En este ejemplo, se puede demostrar que es imposible hacer que str2 sea una subsecuencia de str1 utilizando la operación como máximo una vez.
Por lo tanto, se devuelve false.

Restricciones:

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 y str2 consisten solo en letras minúsculas del inglés.


Se le proporciona una cadena de movimientos de longitud n que consta únicamente de los caracteres 'L', 'R' y '_'. La cadena representa su movimiento en una línea numérica que comienza desde el origen 0.
En el i^ésimo movimiento, puede elegir una de las siguientes direcciones:

mover hacia la izquierda si moves[i] = 'L' o moves[i] = '_'
mover hacia la derecha si moves[i] = 'R' o moves[i] = '_'

Devuelve la distancia desde el origen del punto más lejano al que puede llegar después de n movimientos.

Ejemplo 1:

Entrada: moves = "L_RL__R"
Salida: 3
Explicación: El punto más lejano al que podemos llegar desde el origen 0 es el punto -3 a través de la siguiente secuencia de movimientos "LLRLLLR".

Ejemplo 2:

Entrada: moves = "_R__LL_"
Salida: 5
Explicación: El punto más lejano al que podemos llegar desde el origen 0 es el punto -5 a través de la siguiente secuencia de movimientos "LRLLLLL".

Ejemplo 3:

Entrada: moves = "_______"
Salida: 7
Explicación: El punto más lejano al que podemos llegar desde el origen 0 es el punto 7 a través de la siguiente secuencia de movimientos "RRRRRRR".

Restricciones:

1 <= moves.length == n <= 50
moves consta únicamente de los caracteres 'L', 'R' y '_'.

Se le da una cadena de movimientos de longitud n formada sólo por los caracteres 'L', 'R', y '_'. La cadena representa tu movimiento sobre una recta numérica que parte del origen 0.
En el i^ésimo movimiento, puedes elegir una de las siguientes direcciones:

mover a la izquierda si moves[i] = 'L' o moves[i] = '_'
mover a la derecha si moves[i] = 'R' o moves[i] = '_'

Devuelve la distancia desde el origen del punto más lejano al que puede llegar después de n movimientos.

Ejemplo 1:

Entrada: moves = "L_RL__R"
Salida: 3
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto -3 mediante la siguiente secuencia de movimientos "LLRLLLR".

Ejemplo 2:

Entrada: moves = "_R__LL_"
Salida: 5
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto -5 mediante la siguiente secuencia de movimientos "LRLLLLL".

Ejemplo 3:

Entrada: moves = "_______"
Salida: 7
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto 7 mediante la siguiente secuencia de movimientos "RRRRRRR".

Restricciones:

1 <= moves.length == n <= 50
moves consta sólo de los caracteres 'L', 'R' y '_'.

Se te da una cadena moves de longitud n que consiste solo en caracteres 'L', 'R' y '_'. La cadena representa tu movimiento en una línea numérica comenzando desde el origen 0.
En el i-ésimo movimiento, puedes elegir una de las siguientes direcciones:

moverte a la izquierda si moves[i] = 'L' o moves[i] = '_'
moverte a la derecha si moves[i] = 'R' o moves[i] = '_'

Devuelve la distancia desde el origen del punto más alejado al que puedes llegar después de n movimientos.

Ejemplo 1:

Entrada: moves = "L_RL__R"
Salida: 3
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto -3 a través de la siguiente secuencia de movimientos "LLRLLLR".

Ejemplo 2:

Entrada: moves = "_R__LL_"
Salida: 5
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto -5 a través de la siguiente secuencia de movimientos "LRLLLLL".

Ejemplo 3:

Entrada: moves = "_______"
Salida: 7
Explicación: El punto más alejado que podemos alcanzar desde el origen 0 es el punto 7 a través de la siguiente secuencia de movimientos "RRRRRRR".

Restricciones:

1 <= moves.length == n <= 50
moves consiste solo en caracteres 'L', 'R' y '_'.


Dadas dos cadenas s y t de igual longitud n, puedes realizar la siguiente operación en la cadena s:

Eliminar un sufijo de s de longitud l donde 0 < l < n y añadirlo al inicio de s.
Por ejemplo, si s = 'abcd', en una operación puedes eliminar el sufijo 'cd' y añadirlo al inicio de s, convirtiendo s en 'cdab'.

También se te da un entero k. Devuelve el número de formas en las que s puede transformarse en t en exactamente k operaciones.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: s = "abcd", t = "cdab", k = 2
Salida: 2
Explicación:
Primera forma:
En la primera operación, elige el sufijo desde el índice = 3, así que s resultante = "dabc".
En la segunda operación, elige el sufijo desde el índice = 3, así que s resultante = "cdab".

Segunda forma:
En la primera operación, elige el sufijo desde el índice = 1, así que s resultante = "bcda".
En la segunda operación, elige el sufijo desde el índice = 1, así que s resultante = "cdab".

Ejemplo 2:

Entrada: s = "ababab", t = "ababab", k = 1
Salida: 2
Explicación:
Primera forma:
Elige el sufijo desde el índice = 2, así que s resultante = "ababab".

Segunda forma:
Elige el sufijo desde el índice = 4, así que s resultante = "ababab".

Restricciones:

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s y t consisten solo de letras minúsculas del alfabeto inglés.

Tienes dos cadenas s y t de igual longitud n. Puedes realizar la siguiente operación en la cadena s:

Elimina un sufijo de s de longitud l donde 0 < l < n y añádelo al comienzo de s.
	Por ejemplo, si s = 'abcd', en una operación puedes eliminar el sufijo 'cd' y añadirlo delante de s, lo que hace que s = 'cdab'.

También tienes un entero k. Devuelve la cantidad de formas en las que s se puede transformar en t en exactamente k operaciones.
Como la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: s = "abcd", t = "cdab", k = 2
Salida: 2
Explicación:
Primera forma:
En la primera operación, elige el sufijo del índice = 3, por lo que el resultado es s = "dabc".
En la segunda operación, elija el sufijo del índice = 3, por lo que el resultado s = "cdab".

Segunda forma:
En la primera operación, elija el sufijo del índice = 1, por lo que el resultado s = "bcda".
En la segunda operación, elija el sufijo del índice = 1, por lo que el resultado s = "cdab".

Ejemplo 2:

Entrada: s = "ababab", t = "ababab", k = 1
Salida: 2
Explicación:
Primera forma:
Elija el sufijo del índice = 2, por lo que el resultado s = "ababab".

Segunda forma:
Elija el sufijo del índice = 4, por lo que el resultado s = "ababab".

Restricciones:

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s y t constan solo de letras minúsculas del alfabeto inglés.


Se te da un array indexado desde 0, `nums`, compuesto de potencias no negativas de 2, y un entero `target`.
En una operación, debes aplicar los siguientes cambios al array:

Elige cualquier elemento del array `nums[i]` tal que `nums[i] > 1`.
Elimina `nums[i]` del array.
Agrega dos ocurrencias de `nums[i] / 2` al final de `nums`.

Devuelve el número mínimo de operaciones que necesitas realizar para que `nums` contenga una subsecuencia cuyos elementos sumen `target`. Si es imposible obtener tal subsecuencia, devuelve -1.
Una subsecuencia es un array que puede derivarse de otro array eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,8], target = 7
Salida: 1
Explicación: En la primera operación, elegimos el elemento `nums[2]`. El array se convierte en `nums = [1,2,4,4]`.
En este punto, `nums` contiene la subsecuencia `[1,2,4]` que suma 7.
Se puede demostrar que no hay una secuencia más corta de operaciones que resulte en una subsecuencia que sume 7.

Ejemplo 2:

Entrada: nums = [1,32,1,2], target = 12
Salida: 2
Explicación: En la primera operación, elegimos el elemento `nums[1]`. El array se convierte en `nums = [1,1,2,16,16]`.
En la segunda operación, elegimos el elemento `nums[3]`. El array se convierte en `nums = [1,1,2,16,8,8]`.
En este punto, `nums` contiene la subsecuencia `[1,1,2,8]` que suma 12.
Se puede demostrar que no hay una secuencia más corta de operaciones que resulte en una subsecuencia que sume 12.

Ejemplo 3:

Entrada: nums = [1,32,1], target = 35
Salida: -1
Explicación: Se puede demostrar que ninguna secuencia de operaciones resulta en una subsecuencia que sume 35.

Restricciones:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
`nums` consiste solo de potencias no negativas de dos.
1 <= target < 2^31

Se le da un array nums con índice 0 formado por potencias no negativas de 2, y un entero objetivo.
En una operación, debe aplicar los siguientes cambios a la matriz:

Elegir cualquier elemento del array nums[i] tal que nums[i] > 1.
Elimine núms[i] de la matriz.
Añadir dos veces nums[i] / 2 al final de nums.

Devuelve el número mínimo de operaciones que hay que realizar para que nums contenga una subsecuencia cuyos elementos sumen objetivo. Si es imposible obtener tal subsecuencia, devuelve -1.
Una subsecuencia es una matriz que puede derivarse de otra matriz eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1

Entrada: nums = [1,2,8], target = 7
Salida: 1
Explicación: En la primera operación, elegimos el elemento nums[2]. El array pasa a ser igual a nums = [1,2,4,4].
En este momento, nums contiene la subsecuencia [1,2,4] que suma 7.
Se puede demostrar que no existe una secuencia de operaciones más corta que dé como resultado una subsecuencia que sume 7.

Ejemplo 2:

Entrada: nums = [1,32,1,2], target = 12
Salida: 2
Explicación: En la primera operación, elegimos el elemento nums[1]. La matriz se hace igual a nums = [1,1,2,16,16].
En la segunda operación, elegimos el elemento nums[3]. La matriz pasa a ser igual a nums = [1,1,2,16,8,8].
En este momento, nums contiene la subsecuencia [1,1,2,8] que suma 12.
Se puede demostrar que no existe una secuencia de operaciones más corta que dé como resultado una subsecuencia que sume 12.
Ejemplo 3:

Entrada: números = [1,32,1], objetivo = 35
Salida: -1
Explicación: Se puede demostrar que ninguna secuencia de operaciones da como resultado una subsecuencia que sume 35.

Restricciones:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums consta sólo de potencias no negativas de dos.
1 <= objetivo < 2^31

Se le proporciona una matriz de números indexada 0 que consta de potencias no negativas de 2 y un destino entero.
En una operación, debe aplicar los siguientes cambios a la matriz:

Elija cualquier elemento de la matriz nums[i] tal que nums[i] > 1.
Elimine nums[i] de la matriz.
Agregue dos apariciones de nums[i] / 2 al final de nums.

Devuelve el número mínimo de operaciones que debe realizar para que nums contenga una subsecuencia cuyos elementos se sumen al destino. Si es imposible obtener dicha subsecuencia, retorna -1.
Una subsecuencia es una matriz que se puede derivar de otra matriz eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,8], target = 7
Salida: 1
Explicación: En la primera operación, elegimos el elemento nums[2]. La matriz se vuelve igual a nums = [1,2,4,4].
En esta etapa, nums contiene la subsecuencia [1,2,4] que suma 7.
Se puede demostrar que no hay una secuencia más corta de operaciones que dé como resultado una subsecución que sume 7.

Ejemplo 2:

Entrada: nums = [1,32,1,2], target = 12
Salida: 2
Explicación: En la primera operación, elegimos el elemento nums[1]. La matriz se vuelve igual a nums = [1,1,2,16,16].
En la segunda operación, elegimos el elemento nums[3]. La matriz se vuelve igual a nums = [1,1,2,16,8,8]
En esta etapa, nums contiene la subsecuencia [1,1,2,8] que suma 12.
Se puede demostrar que no hay una secuencia más corta de operaciones que dé como resultado una subsecuencia que sume 12.
Ejemplo 3:

Entrada: nums = [1,32,1], target = 35
Salida: -1
Explicación: Se puede demostrar que ninguna secuencia de operaciones da como resultado una subsecuencia que sume 35.

Restricciones:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums consta solo de potencias no negativas de dos.
1 <= target < 2^31


Dada una matriz de enteros bidimensional indexada desde cero, grid, de tamaño n * m, definimos una matriz bidimensional indexada desde cero, p, de tamaño n * m como la matriz de productos de grid si se cumple la siguiente condición:

Cada elemento p[i][j] se calcula como el producto de todos los elementos en grid excepto el elemento grid[i][j]. Este producto se toma luego módulo 12345.

Devuelve la matriz de productos de grid.

Ejemplo 1:

Entrada: grid = [[1,2],[3,4]]
Salida: [[24,12],[8,6]]
Explicación: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Así que la respuesta es [[24,12],[8,6]].
Ejemplo 2:

Entrada: grid = [[12345],[2],[1]]
Salida: [[2],[0],[0]]
Explicación: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Así que p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Así que p[0][2] = 0.
Así que la respuesta es [[2],[0],[0]].

Restricciones:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Dada una matriz de enteros bidimensionales indexada en 0 de tamaño n * m, definimos una matriz bidimensional indexada en 0 p de tamaño n * m como la matriz producto de la cuadrícula si se cumple la siguiente condición:

Cada elemento p[i][j] se calcula como el producto de todos los elementos de la cuadrícula, excepto el elemento grid[i][j]. Luego, este producto se toma como módulo 12345.

Devuelve la matriz producto de la cuadrícula.

Ejemplo 1:

Entrada: grid = [[1,2],[3,4]]
Salida: [[24,12],[8,6]]
Explicación: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Por lo tanto, la respuesta es [[24,12],[8,6]].
Ejemplo 2:

Entrada: grid = [[12345],[2],[1]]
Salida: [[2],[0],[0]]
Explicación: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Así que p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Así que p[0][2] = 0.
Por lo tanto, la respuesta es [[2],[0],[0]].

Restricciones:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


Tienes un array de enteros receiver de longitud n y un entero k.
Hay n jugadores con un id único en el rango [0, n - 1] que jugarán un juego de pasar la pelota, y receiver[i] es el id del jugador que recibe los pases del jugador con id i. Los jugadores pueden pasar a sí mismos, es decir, receiver[i] puede ser igual a i.
Debes elegir uno de los n jugadores como el jugador inicial para el juego, y la pelota se pasará exactamente k veces comenzando desde el jugador elegido.
Para un jugador inicial elegido con id x, definimos una función f(x) que denota la suma de x y los ids de todos los jugadores que reciben la pelota durante los k pases, incluyendo repeticiones. En otras palabras, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Tu tarea es elegir un jugador inicial con id x que maximice el valor de f(x).
Devuelve un entero que denote el valor máximo de la función.

Nota: receiver puede contener duplicados.

Ejemplo 1:

Número de Pase
ID del Remitente
ID del Receptor
x + IDs de Receptores

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrada: receiver = [2,0,1], k = 4
Salida: 6
Explicación: La tabla arriba muestra una simulación del juego comenzando con el jugador con id x = 2.
De la tabla, f(2) es igual a 6.
Se puede demostrar que 6 es el valor máximo posible de la función.
Por lo tanto, la salida es 6.

Ejemplo 2:

Número de Pase
ID del Remitente
ID del Receptor
x + IDs de Receptores

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrada: receiver = [1,1,1,2,3], k = 3
Salida: 10
Explicación: La tabla arriba muestra una simulación del juego comenzando con el jugador con id x = 4.
De la tabla, f(4) es igual a 10.
Se puede demostrar que 10 es el valor máximo posible de la función.
Por lo tanto, la salida es 10.

Restricciones:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Se le proporciona una matriz de enteros indexada en 0, receptor, de longitud n, y un entero k.
Hay n jugadores que tienen un id único en el rango [0, n - 1] que jugarán un juego de pases de pelota, y receptor[i] es el id del jugador que recibe pases del jugador con id i. Los jugadores pueden pasarse la pelota a sí mismos, es decir, receptor[i] puede ser igual a i.
Debe elegir a uno de los n jugadores como el jugador inicial para el juego, y la pelota se pasará exactamente k veces comenzando desde el jugador elegido.
Para un jugador inicial elegido que tiene id x, definimos una función f(x) que denota la suma de x y los id de todos los jugadores que reciben la pelota durante los k pases, incluidas las repeticiones. En otras palabras, f(x) = x + receptor[x] + receptor[receptor[x]] + ... + receptor^(k)[x].
Su tarea es elegir un jugador inicial que tenga id x que maximice el valor de f(x).
Devuelve un entero que denota el valor máximo de la función.
Nota: el receptor puede contener duplicados.

Ejemplo 1:

Número de pase
ID del remitente
ID del receptor
x + ID del receptor

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrada: receptor = [2,0,1], k = 4
Salida: 6
Explicación: La tabla anterior muestra una simulación del juego que comienza con el jugador que tiene id x = 2.
De la tabla, f(2) es igual a 6.
Se puede demostrar que 6 es el valor máximo alcanzable de la función. Por lo tanto, la salida es 6.

Ejemplo 2:

Número de pase
ID del remitente
ID del receptor
x + ID del receptor

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrada: receptor = [1,1,1,2,3], k = 3
Salida: 10
Explicación: La tabla anterior muestra una simulación del juego que comienza con el jugador que tiene id x = 4.
De la tabla, f(4) es igual a 10.
Se puede demostrar que 10 es el valor máximo alcanzable de la función.
Por lo tanto, la salida es 10.

Restricciones:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Tienes un conjunto de enteros receiver de longitud n y un entero k. Hay n jugadores con un id único en el rango [0, n - 1] que jugarán un juego de pasar la pelota, y receiver[i] es el id del jugador que recibe los pases del jugador con id i. Los jugadores pueden pasar a sí mismos, es decir, receiver[i] puede ser igual a i. Debes elegir uno de los n jugadores como el jugador inicial para el juego, y la pelota se pasará exactamente k veces comenzando desde el jugador elegido.

Para un jugador inicial elegido con id x, definimos una función f(x) que denota la suma de x y los ids de todos los jugadores que reciben la pelota durante los k pases, incluyendo repeticiones. En otras palabras, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].

Tu tarea es elegir un jugador inicial con id x que maximice el valor de f(x). Devuelve un entero que denote el valor máximo de la función.

Nota: receiver puede contener duplicados.

Ejemplo 1:

Número de Pase
ID del Remitente
ID del Receptor
x + IDs de Receptores

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrada: receiver = [2,0,1], k = 4
Salida: 6
Explicación: La tabla arriba muestra una simulación del juego comenzando con el jugador con id x = 2.
De la tabla, f(2) es igual a 6.
Se puede demostrar que 6 es el valor máximo posible de la función.
Por lo tanto, la salida es 6.

Ejemplo 2:

Número de Pase
ID del Remitente
ID del Receptor
x + IDs de Receptores

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrada: receiver = [1,1,1,2,3], k = 3
Salida: 10
Explicación: La tabla arriba muestra una simulación del juego comenzando con el jugador con id x = 4.
De la tabla, f(4) es igual a 10.
Se puede demostrar que 10 es el valor máximo posible de la función.
Por lo tanto, la salida es 10.

Restricciones:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10


Se te dan dos cadenas binarias indexadas desde 0, s1 y s2, ambas de longitud n, y un entero positivo x.
Puedes realizar cualquiera de las siguientes operaciones en la cadena s1 cualquier número de veces:

Elige dos índices i y j, y volteas tanto s1[i] como s1[j]. El costo de esta operación es x.
Elige un índice i tal que i < n - 1 y volteas tanto s1[i] como s1[i + 1]. El costo de esta operación es 1.

Devuelve el costo mínimo necesario para hacer que las cadenas s1 y s2 sean iguales, o devuelve -1 si es imposible.
Ten en cuenta que voltear un carácter significa cambiarlo de 0 a 1 o viceversa.

Ejemplo 1:

Entrada: s1 = "1100011000", s2 = "0101001010", x = 2
Salida: 4
Explicación: Podemos realizar las siguientes operaciones:
- Elegir i = 3 y aplicar la segunda operación. La cadena resultante es s1 = "1101111000".
- Elegir i = 4 y aplicar la segunda operación. La cadena resultante es s1 = "1101001000".
- Elegir i = 0 y j = 8 y aplicar la primera operación. La cadena resultante es s1 = "0101001010" = s2.
El costo total es 1 + 1 + 2 = 4. Se puede demostrar que es el costo mínimo posible.

Ejemplo 2:

Entrada: s1 = "10110", s2 = "00011", x = 4
Salida: -1
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

n == s1.length == s2.length
1 <= n, x <= 500
s1 y s2 consisten solo de los caracteres '0' y '1'.

Se te dan dos cadenas binarias indexadas desde 0, s1 y s2, ambas de longitud n, y un entero positivo x.
Puedes realizar cualquiera de las siguientes operaciones en la cadena s1 cualquier número de veces:

Elige dos índices i y j, y volteas tanto s1[i] como s1[j]. El costo de esta operación es x.
Elige un índice i tal que i < n - 1 y volteas tanto s1[i] como s1[i + 1]. El costo de esta operación es 1.

Devuelve el costo mínimo necesario para hacer que las cadenas s1 y s2 sean iguales, o devuelve -1 si es imposible.
Ten en cuenta que voltear un carácter significa cambiarlo de 0 a 1 o viceversa.

Ejemplo 1:

Input: s1 = "1100011000", s2 = "0101001010", x = 2
Output: 4
Explicación: Podemos realizar las siguientes operaciones:
- Elege i = 3 y aplica la segunda operación. La cadena resultante es s1 = "1101111000".
- Elege i = 4 y aplica la segunda operación. La cadena resultante es s1 = "1101001000".
- Elege i = 0 y j = 8 y aplica la primera operación. La cadena resultante es s1 = "0101001010" = s2.
El costo total es 1 + 1 + 2 = 4. Se puede demostrar que es el costo mínimo posible.

Ejemplo 2:

Input: s1 = "10110", s2 = "00011", x = 4
Output: -1
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

n == s1.length == s2.length
1 <= n, x <= 500
s1 y s2 consisten solo de los caracteres '0' y '1'.

Se le proporcionan dos cadenas binarias indexadas en 0 s1 y s2, ambas de longitud n, y un entero positivo x.
Puede realizar cualquiera de las siguientes operaciones en la cadena s1 cualquier número de veces:

Elija dos índices i y j, e invierta tanto s1[i] como s1[j]. El costo de esta operación es x.
Elija un índice i tal que i < n - 1 e invierta tanto s1[i] como s1[i + 1]. El costo de esta operación es 1.

Devuelva el costo mínimo necesario para que las cadenas s1 y s2 sean iguales, o devuelva -1 si es imposible.
Tenga en cuenta que invertir un carácter significa cambiarlo de 0 a 1 o viceversa.

Ejemplo 1:

Entrada: s1 = "1100011000", s2 = "0101001010", x = 2
Salida: 4
Explicación: Podemos realizar las siguientes operaciones:
- Elegir i = 3 y aplicar la segunda operación. La cadena resultante es s1 = "1101111000".
- Elegir i = 4 y aplicar la segunda operación. La cadena resultante es s1 = "1101001000".
- Elegir i = 0 y j = 8 y aplicar la primera operación. La cadena resultante es s1 = "0101001010" = s2.
El coste total es 1 + 1 + 2 = 4. Se puede demostrar que es el coste mínimo posible.

Ejemplo 2:

Entrada: s1 = "10110", s2 = "00011", x = 4
Salida: -1
Explicación: No es posible hacer que las dos cadenas sean iguales.

Restricciones:

n == s1.length == s2.length
1 <= n, x <= 500
s1 y s2 constan únicamente de los caracteres '0' y '1'.


Se te da un array 2D de enteros nums indexado desde 0 que representa las coordenadas de los coches estacionados en una línea numérica. Para cualquier índice i, nums[i] = [start_i, end_i] donde start_i es el punto de inicio del i-ésimo coche y end_i es el punto final del i-ésimo coche.
Devuelve el número de puntos enteros en la línea que están cubiertos por cualquier parte de un coche.

Ejemplo 1:

Entrada: nums = [[3,6],[1,5],[4,7]]
Salida: 7
Explicación: Todos los puntos desde 1 hasta 7 intersectan al menos un coche, por lo tanto la respuesta sería 7.

Ejemplo 2:

Entrada: nums = [[1,3],[5,8]]
Salida: 7
Explicación: Los puntos que intersectan al menos un coche son 1, 2, 3, 5, 6, 7, 8. Hay un total de 7 puntos, por lo tanto la respuesta sería 7.

Restricciones:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

Se le da una matriz de números enteros 2D de índice 0 que representa las coordenadas de los coches que aparcan en una recta numérica. Para cualquier índice i, nums[i] = [start_i, end_i] donde start_i es el punto inicial del i^ésimo coche y end_i es el punto final del i^ésimo coche.
Devuelve el número de puntos enteros de la línea que están cubiertos por alguna parte de un coche.

Ejemplo 1:

Entrada: nums = [[3,6],[1,5],[4,7]]
Salida: 7
Explicación: Todos los puntos del 1 al 7 intersecan al menos un coche, por lo tanto la respuesta sería 7.

Ejemplo 2:

Entrada: nums = [[1,3],[5,8]]
Salida: 7
Explicación: Los puntos que intersecan al menos un coche son 1, 2, 3, 5, 6, 7, 8. Hay un total de 7 puntos, por lo tanto la respuesta sería 7.

Restricciones:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

Se le proporciona una matriz de números enteros 2D indexada en 0, nums, que representa las coordenadas de los automóviles estacionados en una línea numérica. Para cualquier índice i, nums[i] = [start_i, end_i], donde start_i es el punto de inicio del i^th automóvil y end_i es el punto final del i^th automóvil.
Devuelve la cantidad de puntos enteros en la línea que están cubiertos por cualquier parte de un automóvil.

Ejemplo 1:

Entrada: nums = [[3,6],[1,5],[4,7]]
Salida: 7
Explicación: Todos los puntos del 1 al 7 intersecan al menos un automóvil, por lo tanto, la respuesta sería 7.

Ejemplo 2:

Entrada: nums = [[1,3],[5,8]]
Salida: 7
Explicación: Los puntos que intersecan al menos un automóvil son 1, 2, 3, 5, 6, 7, 8. Hay un total de 7 puntos, por lo tanto, la respuesta sería 7.

Restricciones:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100


Se te proporciona un arreglo nums de enteros positivos y un entero k.
En una operación, puedes eliminar el último elemento del arreglo y añadirlo a tu colección.
Devuelve el número mínimo de operaciones necesarias para recolectar los elementos 1, 2, ..., k.

Ejemplo 1:

Entrada: nums = [3,1,5,4,2], k = 2
Salida: 4
Explicación: Después de 4 operaciones, recolectamos los elementos 2, 4, 5 y 1, en este orden. Nuestra colección contiene los elementos 1 y 2. Por lo tanto, la respuesta es 4.

Ejemplo 2:

Entrada: nums = [3,1,5,4,2], k = 5
Salida: 5
Explicación: Después de 5 operaciones, recolectamos los elementos 2, 4, 5, 1 y 3, en este orden. Nuestra colección contiene los elementos del 1 al 5. Por lo tanto, la respuesta es 5.

Ejemplo 3:

Entrada: nums = [3,2,5,3,1], k = 3
Salida: 4
Explicación: Después de 4 operaciones, recolectamos los elementos 1, 3, 5 y 2, en este orden. Nuestra colección contiene los elementos del 1 al 3. Por lo tanto, la respuesta es 4.

Restricciones:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
La entrada se genera de tal manera que puedes recolectar los elementos 1, 2, ..., k.

Se te da un array nums de enteros positivos y un entero k.
En una operación, puede eliminar el último elemento de la matriz y añadirlo a su colección.
Devuelve el número mínimo de operaciones necesarias para recoger los elementos 1, 2, ..., k.

Ejemplo 1:

Entrada: nums = [3,1,5,4,2], k = 2
Salida: 4
Explicación: Después de 4 operaciones, recogemos los elementos 2, 4, 5 y 1, en este orden. Nuestra colección contiene los elementos 1 y 2. Por lo tanto, la respuesta es 4.

Ejemplo 2:

Entrada: nums = [3,1,5,4,2], k = 5
Salida: 5
Explicación: Después de 5 operaciones, recogemos los elementos 2, 4, 5, 1 y 3, en este orden. Nuestra colección contiene los elementos 1 a 5. Por lo tanto, la respuesta es 5.

Ejemplo 3:

Entrada: nums = [3,2,5,3,1], k = 3
Salida: 4
Explicación: Después de 4 operaciones, recogemos los elementos 1, 3, 5 y 2, en este orden. Nuestra colección contiene los elementos 1 a 3. Por lo tanto, la respuesta es 4.

Restricciones:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
La entrada se genera de tal manera que puede recoger los elementos 1, 2, ..., k.

Se le proporciona una matriz nums de números enteros positivos y un número entero k.
En una operación, puede eliminar el último elemento de la matriz y agregarlo a su colección.
Devuelva la cantidad mínima de operaciones necesarias para recopilar los elementos 1, 2, ..., k.

Ejemplo 1:

Entrada: nums = [3,1,5,4,2], k = 2
Salida: 4
Explicación: Después de 4 operaciones, recopilamos los elementos 2, 4, 5 y 1, en este orden. Nuestra colección contiene los elementos 1 y 2. Por lo tanto, la respuesta es 4.

Ejemplo 2:

Entrada: nums = [3,1,5,4,2], k = 5
Salida: 5
Explicación: Después de 5 operaciones, recopilamos los elementos 2, 4, 5, 1 y 3, en este orden. Nuestra colección contiene los elementos del 1 al 5. Por lo tanto, la respuesta es 5.

Ejemplo 3:

Entrada: nums = [3,2,5,3,1], k = 3
Salida: 4
Explicación: Después de 4 operaciones, recopilamos los elementos 1, 3, 5 y 2, en este orden. Nuestra colección contiene los elementos del 1 al 3. Por lo tanto, la respuesta es 4.

Restricciones:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
La entrada se genera de modo que pueda recopilar los elementos 1, 2, ..., k.


Se le da un array nums de longitud n con índice 0 que contiene enteros positivos distintos. Devuelve el número mínimo de desplazamientos a la derecha necesarios para ordenar nums y -1 si no es posible.
Un desplazamiento a la derecha se define como el desplazamiento del elemento en el índice i al índice (i + 1) % n, para todos los índices.

Ejemplo 1

Entrada: nums = [3,4,5,1,2]
Salida: 2
Explicación:
Después del primer desplazamiento a la derecha, nums = [2,3,4,5,1].
Después del segundo desplazamiento a la derecha, nums = [1,2,3,4,5].
Ahora nums está ordenado; por lo tanto la respuesta es 2.

Ejemplo 2:

Entrada: nums = [1,3,5]
Salida: 0
Explicación: nums ya está ordenado, por lo tanto, la respuesta es 0.
Ejemplo 3:

Entrada: nums = [2,1,4]
Salida: -1
Explicación: Es imposible ordenar el array usando desplazamientos a la derecha.

Restricciones:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contiene enteros distintos.

Se te da un conjunto indexado al 0 de nums de longitud n que contiene enteros positivos distintos. Devuelve el número mínimo de desplazamientos a la derecha necesarios para ordenar nums y -1 si no es posible.
Un desplazamiento a la derecha se define como mover el elemento en el índice i al índice (i + 1) % n, para todos los índices.

Ejemplo 1:

Entrada: nums = [3,4,5,1,2]
Salida: 2
Explicación:
Después del primer desplazamiento a la derecha, nums = [2,3,4,5,1].
Después del segundo desplazamiento a la derecha, nums = [1,2,3,4,5].
Ahora nums está ordenado; por lo tanto, la respuesta es 2.

Ejemplo 2:

Entrada: nums = [1,3,5]
Salida: 0
Explicación: nums ya está ordenado, por lo tanto, la respuesta es 0.

Ejemplo 3:

Entrada: nums = [2,1,4]
Salida: -1
Explicación: Es imposible ordenar el conjunto usando desplazamientos a la derecha.

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contiene enteros distintos.

Se te da un arreglo índice 0 nums de longitud n que contiene enteros positivos distintos. Devuelve el número mínimo de desplazamientos a la derecha necesarios para ordenar nums y -1 si no es posible.
Un desplazamiento a la derecha se define como mover el elemento en el índice i al índice (i + 1) % n, para todos los índices.

Ejemplo 1:

Entrada: nums = [3,4,5,1,2]
Salida: 2
Explicación:
Después del primer desplazamiento a la derecha, nums = [2,3,4,5,1].
Después del segundo desplazamiento a la derecha, nums = [1,2,3,4,5].
Ahora nums está ordenado; por lo tanto, la respuesta es 2.

Ejemplo 2:

Entrada: nums = [1,3,5]
Salida: 0
Explicación: nums ya está ordenado, por lo tanto, la respuesta es 0.

Ejemplo 3:

Entrada: nums = [2,1,4]
Salida: -1
Explicación: Es imposible ordenar el arreglo usando desplazamientos a la derecha.

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contiene enteros distintos.


Se te da una cadena num con índice 0 que representa un entero no negativo.
En una operación, puedes elegir cualquier dígito de num y eliminarlo. Ten en cuenta que si eliminas todos los dígitos de num, num se convierte en 0.
Devuelve el número mínimo de operaciones requeridas para hacer que num sea especial.
Un entero x se considera especial si es divisible por 25.

Ejemplo 1:

Entrada: num = "2245047"
Salida: 2
Explicación: Elimina los dígitos num[5] y num[6]. El número resultante es "22450" que es especial ya que es divisible por 25.
Se puede demostrar que 2 es el número mínimo de operaciones requeridas para obtener un número especial.

Ejemplo 2:

Entrada: num = "2908305"
Salida: 3
Explicación: Elimina los dígitos num[3], num[4] y num[6]. El número resultante es "2900" que es especial ya que es divisible por 25.
Se puede demostrar que 3 es el número mínimo de operaciones requeridas para obtener un número especial.

Ejemplo 3:

Entrada: num = "10"
Salida: 1
Explicación: Elimina el dígito num[0]. El número resultante es "0" que es especial ya que es divisible por 25.
Se puede demostrar que 1 es el número mínimo de operaciones requeridas para obtener un número especial.

Condiciones:

1 <= num.length <= 100
num solo consta de dígitos del '0' al '9'.
num no contiene ceros a la izquierda.

Se le proporciona una cadena indexada en 0 num que representa un entero no negativo.
En una operación, puede elegir cualquier dígito de num y eliminarlo. Tenga en cuenta que si elimina todos los dígitos de num, num se convierte en 0.
Devuelve la cantidad mínima de operaciones necesarias para que num sea especial.
Un entero x se considera especial si es divisible por 25.

Ejemplo 1:

Entrada: num = "2245047"
Salida: 2
Explicación: elimine los dígitos num[5] y num[6]. El número resultante es "22450", que es especial ya que es divisible por 25.
Se puede demostrar que 2 es la cantidad mínima de operaciones necesarias para obtener un número especial.
Ejemplo 2:

Entrada: num = "2908305"
Salida: 3
Explicación: elimine los dígitos num[3], num[4] y num[6]. El número resultante es "2900", que es especial porque es divisible por 25.
Se puede demostrar que 3 es el número mínimo de operaciones necesarias para obtener un número especial.
Ejemplo 3:

Entrada: num = "10"
Salida: 1
Explicación: Eliminar el dígito num[0]. El número resultante es "0", que es especial porque es divisible por 25.
Se puede demostrar que 1 es el número mínimo de operaciones necesarias para obtener un número especial.

Restricciones:

1 <= num.length <= 100
num solo consta de los dígitos del '0' al '9'.
num no contiene ningún cero inicial.


Se te da un array nums indexado desde 1 de n enteros.
Un conjunto de números es completo si el producto de cada par de sus elementos es un cuadrado perfecto.
Para un subconjunto del conjunto de índices {1, 2, ..., n} representado como {i_1, i_2, ..., i_k}, definimos su suma de elementos como: nums[i_1] + nums[i_2] + ... + nums[i_k].
Devuelve la máxima suma de elementos de un subconjunto completo del conjunto de índices {1, 2, ..., n}.
Un cuadrado perfecto es un número que puede expresarse como el producto de un entero consigo mismo.

Ejemplo 1:

Entrada: nums = [8,7,3,5,7,2,4,9]
Salida: 16
Explicación: Además de los subconjuntos que consisten en un solo índice, hay otros dos subconjuntos completos de índices: {1,4} y {2,8}.
La suma de los elementos correspondientes a los índices 1 y 4 es igual a nums[1] + nums[4] = 8 + 5 = 13.
La suma de los elementos correspondientes a los índices 2 y 8 es igual a nums[2] + nums[8] = 7 + 9 = 16.
Por lo tanto, la máxima suma de elementos de un subconjunto completo de índices es 16.

Ejemplo 2:

Entrada: nums = [5,10,3,10,1,13,7,9,4]
Salida: 19
Explicación: Además de los subconjuntos que consisten en un solo índice, hay otros cuatro subconjuntos completos de índices: {1,4}, {1,9}, {2,8}, {4,9}, y {1,4,9}.
La suma de los elementos correspondientes a los índices 1 y 4 es igual a nums[1] + nums[4] = 5 + 10 = 15.
La suma de los elementos correspondientes a los índices 1 y 9 es igual a nums[1] + nums[9] = 5 + 4 = 9.
La suma de los elementos correspondientes a los índices 2 y 8 es igual a nums[2] + nums[8] = 10 + 9 = 19.
La suma de los elementos correspondientes a los índices 4 y 9 es igual a nums[4] + nums[9] = 10 + 4 = 14.
La suma de los elementos correspondientes a los índices 1, 4, y 9 es igual a nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Por lo tanto, la máxima suma de elementos de un subconjunto completo de índices es 19.

Restricciones:

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

Se le proporciona una matriz indexada en 1 nums de n números enteros.
Un conjunto de números está completo si el producto de cada par de sus elementos es un cuadrado perfecto.
Para un subconjunto del conjunto de índices {1, 2, ..., n} representado como {i_1, i_2, ..., i_k}, definimos su suma de elementos como: nums[i_1] + nums[i_2] + ... + nums[i_k].
Devuelve la suma máxima de elementos de un subconjunto completo del conjunto de índices {1, 2, ..., n}.
Un cuadrado perfecto es un número que se puede expresar como el producto de un entero por sí mismo.

Ejemplo 1:

Entrada: nums = [8,7,3,5,7,2,4,9]
Salida: 16
Explicación: Además de los subconjuntos que constan de un único índice, hay otros dos subconjuntos completos de índices: {1,4} y {2,8}.
La suma de los elementos correspondientes a los índices 1 y 4 es igual a nums[1] + nums[4] = 8 + 5 = 13.
La suma de los elementos correspondientes a los índices 2 y 8 es igual a nums[2] + nums[8] = 7 + 9 = 16.
Por lo tanto, la suma máxima de elementos de un subconjunto completo de índices es 16.

Ejemplo 2:

Entrada: nums = [5,10,3,10,1,13,7,9,4]
Salida: 19
Explicación: Además de los subconjuntos que constan de un único índice, hay otros cuatro subconjuntos completos de índices: {1,4}, {1,9}, {2,8}, {4,9} y {1,4,9}.
La suma de los elementos correspondientes a los índices 1 y 4 es igual a nums[1] + nums[4] = 5 + 10 = 15.
La suma de los elementos correspondientes a los índices 1 y 9 es igual a nums[1] + nums[9] = 5 + 4 = 9.
La suma de los elementos correspondientes a los índices 2 y 8 es igual a nums[2] + nums[8] = 10 + 9 = 19.
La suma de los elementos correspondientes a los índices 4 y 9 es igual a nums[4] + nums[9] = 10 + 4 = 14.
La suma de los elementos correspondientes a los índices 1, 4 y 9 es igual a nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Por lo tanto, la suma máxima de elementos de un El subconjunto de índices es 19.

Restricciones:

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


Se le proporciona una cadena binaria s que contiene al menos un '1'.
Debe reorganizar los bits de tal manera que el número binario resultante sea el número binario impar máximo que se puede crear a partir de esta combinación.
Devuelva una cadena que represente el número binario impar máximo que se puede crear a partir de la combinación dada.
Tenga en cuenta que la cadena resultante puede tener ceros a la izquierda.

Ejemplo 1:

Entrada: s = "010"
Salida: "001"
Explicación: Como solo hay un '1', debe estar en la última posición. Por lo tanto, la respuesta es "001".

Ejemplo 2:

Entrada: s = "0101"
Salida: "1001"
Explicación: Uno de los '1' debe estar en la última posición. El número máximo que se puede formar con los dígitos restantes es "100". Por lo tanto, la respuesta es "1001".

Restricciones:

1 <= s.length <= 100
s consta únicamente de '0' y '1'.
s contiene al menos un '1'.

Se te da una cadena binaria s que contiene al menos un '1'.
Debes reorganizar los bits de tal manera que el número binario resultante sea el número binario impar máximo que se pueda crear a partir de esta combinación.
Devuelve una cadena que represente el máximo número binario impar que se puede crear a partir de la combinación dada.
Ten en cuenta que la cadena resultante puede tener ceros a la izquierda.

Ejemplo 1:

Entrada: s = "010"
Salida: "001"
Explicación: Debido a que solo hay un '1', debe estar en la última posición. Entonces, la respuesta es "001".

Ejemplo 2:

Entrada: s = "0101"
Salida: "1001"
Explicación: Uno de los '1' debe estar en la última posición. El número máximo que se puede formar con los dígitos restantes es "100". Entonces, la respuesta es "1001".

Restricciones:

1 <= s.length <= 100
s solo consiste en '0' y '1'.
s contiene al menos un '1'.

Se le da una cadena binaria s que contiene al menos un '1'.
Hay que reorganizar los bits de tal manera que el número binario resultante sea el número binario impar máximo que se puede crear a partir de esta combinación.
Devuelve una cadena que representa el número binario impar máximo que se puede crear a partir de la combinación dada.
Tenga en cuenta que la cadena resultante puede tener ceros a la izquierda.

Ejemplo 1:

Entrada: s = "010"
Salida: "001"
Explicación: Debido a que solo hay un '1', debe estar en la última posición. Así que la respuesta es "001".

Ejemplo 2:

Entrada: s = "0101"
Salida: "1001"
Explicación: Uno de los '1' debe estar en la última posición. El número máximo que se puede hacer con los dígitos restantes es "100". Así que la respuesta es "1001".

Restricciones:

1 <= s.length <= 100
s consta solo de '0' y '1'.
s contiene al menos un '1'.


Dado un array nums que consiste en enteros no negativos.
Definimos la puntuación del subarray nums[l..r] tal que l <= r como nums[l] AND nums[l + 1] AND ... AND nums[r] donde AND es la operación AND bit a bit.
Considera dividir el array en uno o más subarrays de modo que se cumplan las siguientes condiciones:

Cada elemento del array pertenece a exactamente un subarray.
La suma de las puntuaciones de los subarrays es la mínima posible.

Devuelve el número máximo de subarrays en una división que satisfaga las condiciones anteriores.
Un subarray es una parte contigua de un array.

Ejemplo 1:

Entrada: nums = [1,0,2,0,1,2]
Salida: 3
Explicación: Podemos dividir el array en los siguientes subarrays:
- [1,0]. La puntuación de este subarray es 1 AND 0 = 0.
- [2,0]. La puntuación de este subarray es 2 AND 0 = 0.
- [1,2]. La puntuación de este subarray es 1 AND 2 = 0.
La suma de puntuaciones es 0 + 0 + 0 = 0, que es la mínima puntuación posible que podemos obtener.
Se puede demostrar que no podemos dividir el array en más de 3 subarrays con una puntuación total de 0. Entonces devolvemos 3.

Ejemplo 2:

Entrada: nums = [5,7,1,3]
Salida: 1
Explicación: Podemos dividir el array en un subarray: [5,7,1,3] con una puntuación de 1, que es la mínima puntuación posible que podemos obtener.
Se puede demostrar que no podemos dividir el array en más de 1 subarray con una puntuación total de 1. Entonces devolvemos 1.

Restricciones:

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

Se le proporciona una matriz nums que consta de números enteros no negativos.
Definimos la puntuación de la submatriz nums[l..r] de modo que l <= r como nums[l] AND nums[l + 1] AND ... AND nums[r] donde AND es la operación AND bit a bit.
Considere dividir la matriz en una o más submatrices de modo que se cumplan las siguientes condiciones:

Cada elemento de la matriz pertenece exactamente a una submatriz.
La suma de las puntuaciones de las submatrices es el mínimo posible.

Devuelva la cantidad máxima de submatrices en una división que cumpla las condiciones anteriores.
Una submatriz es una parte contigua de una matriz.

Ejemplo 1:

Entrada: nums = [1,0,2,0,1,2]
Salida: 3
Explicación: Podemos dividir la matriz en las siguientes submatrices:
- [1,0]. La puntuación de esta submatriz es 1 Y 0 = 0.
- [2,0]. La puntuación de esta submatriz es 2 Y 0 = 0.
- [1,2]. La puntuación de esta submatriz es 1 Y 2 = 0.
La suma de las puntuaciones es 0 + 0 + 0 = 0, que es la puntuación mínima posible que podemos obtener.
Se puede demostrar que no podemos dividir la matriz en más de 3 submatrices con una puntuación total de 0. Por lo tanto, devolvemos 3.

Ejemplo 2:

Entrada: nums = [5,7,1,3]
Salida: 1
Explicación: Podemos dividir la matriz en una submatriz: [5,7,1,3] con una puntuación de 1, que es la puntuación mínima posible que podemos obtener.
Se puede demostrar que no podemos dividir la matriz en más de una submatriz con una puntuación total de 1. Por lo tanto, devolvemos 1.

Restricciones:

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


Se te da un arreglo de enteros ordenados con índice 0 llamado nums.
Puedes realizar la siguiente operación cualquier número de veces:

Elige dos índices, i y j, donde i < j, tal que nums[i] < nums[j].
Luego, elimina los elementos en los índices i y j de nums. Los elementos restantes conservan su orden original y el arreglo se re-indexa.

Devuelve un entero que denote la longitud mínima de nums después de realizar la operación cualquier número de veces (incluyendo cero).
Ten en cuenta que nums está ordenado en orden no decreciente.

Ejemplo 1:

Entrada: nums = [1,3,4,9]
Salida: 0
Explicación: Inicialmente, nums = [1, 3, 4, 9].
En la primera operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 1 < 3.
Elimina los índices 0 y 1, y nums se convierte en [4, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 4 < 9.
Elimina los índices 0 y 1, y nums se convierte en un arreglo vacío [].
Por lo tanto, la longitud mínima alcanzable es 0.
Ejemplo 2:

Entrada: nums = [2,3,6,9]
Salida: 0
Explicación: Inicialmente, nums = [2, 3, 6, 9].
En la primera operación, podemos elegir el índice 0 y 2 porque nums[0] < nums[2] <=> 2 < 6.
Elimina los índices 0 y 2, y nums se convierte en [3, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 3 < 9.
Elimina los índices 0 y 1, y nums se convierte en un arreglo vacío [].
Por lo tanto, la longitud mínima alcanzable es 0.

Ejemplo 3:

Entrada: nums = [1,1,2]
Salida: 1
Explicación: Inicialmente, nums = [1, 1, 2].
En una operación, podemos elegir el índice 0 y 2 porque nums[0] < nums[2] <=> 1 < 2.
Elimina los índices 0 y 2, y nums se convierte en [1].
Ya no es posible realizar una operación en el arreglo.
Por lo tanto, la longitud mínima alcanzable es 1.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums está ordenado en orden no decreciente.

Se te da un array de enteros ordenados con índice 0 llamado nums.
Puedes realizar la siguiente operación cualquier número de veces:

Elige dos índices, i y j, donde i < j, tal que nums[i] < nums[j].
Luego, elimina los elementos en los índices i y j de nums. Los elementos restantes conservan su orden original y el array se re-indexa.

Devuelve un entero que denote la longitud mínima de nums después de realizar la operación cualquier número de veces (incluyendo cero).
Ten en cuenta que nums está ordenado en orden no decreciente.

Ejemplo 1:

Entrada: nums = [1,3,4,9]
Salida: 0
Explicación: Inicialmente, nums = [1, 3, 4, 9].
En la primera operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 1 < 3.
Elimina los índices 0 y 1, y nums se convierte en [4, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 4 < 9.
Elimina los índices 0 y 1, y nums se convierte en un array vacío [].
Por lo tanto, la longitud mínima alcanzable es 0.

Ejemplo 2:

Entrada: nums = [2,3,6,9]
Salida: 0
Explicación: Inicialmente, nums = [2, 3, 6, 9].
En la primera operación, podemos elegir el índice 0 y 2 porque nums[0] < nums[2] <=> 2 < 6.
Elimina los índices 0 y 2, y nums se convierte en [3, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 3 < 9.
Elimina los índices 0 y 1, y nums se convierte en un array vacío [].
Por lo tanto, la longitud mínima alcanzable es 0.

Ejemplo 3:

Entrada: nums = [1,1,2]
Salida: 1
Explicación: Inicialmente, nums = [1, 1, 2].
En una operación, podemos elegir el índice 0 y 2 porque nums[0] < nums[2] <=> 1 < 2.
Elimina los índices 0 y 2, y nums se convierte en [1].
Ya no es posible realizar una operación en el array.
Por lo tanto, la longitud mínima alcanzable es 1.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums está ordenado en orden no decreciente.

Se le proporciona una matriz ordenada con índice 0 de números enteros nums.
Puede realizar la siguiente operación cualquier cantidad de veces:

Elija dos índices, i y j, donde i < j, de modo que nums[i] < nums[j].
A continuación, elimine los elementos en los índices i y j de nums. Los elementos restantes conservan su orden original y la matriz se vuelve a indexar.

Devuelva un entero que denote la longitud mínima de nums después de realizar la operación cualquier cantidad de veces (incluido cero).
Tenga en cuenta que nums se ordena en orden no decreciente.

Ejemplo 1:

Entrada: nums = [1,3,4,9]
Salida: 0
Explicación: Inicialmente, nums = [1, 3, 4, 9].
En la primera operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 1 < 3.
Elimine los índices 0 y 1, y nums se convierte en [4, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 4 < 9.
Elimine los índices 0 y 1, y nums se convierte en una matriz vacía [].
Por lo tanto, la longitud mínima alcanzable es 0.
Ejemplo 2:

Entrada: nums = [2,3,6,9]
Salida: 0
Explicación: Inicialmente, nums = [2, 3, 6, 9]. En la primera operación, podemos elegir el índice 0 y 2 porque nums[0] < nums[2] <=> 2 < 6.
Elimine los índices 0 y 2, y nums se convierte en [3, 9].
Para la siguiente operación, podemos elegir el índice 0 y 1 porque nums[0] < nums[1] <=> 3 < 9.
Elimine los índices 0 y 1, y nums se convierte en una matriz vacía [].
Por lo tanto, la longitud mínima alcanzable es 0.

Ejemplo 3:

Entrada: nums = [1,1,2]
Salida: 1
Explicación: Inicialmente, nums = [1, 1, 2].
En una operación, podemos elegir los índices 0 y 2 porque nums[0] < nums[2] <=> 1 < 2.
Si eliminamos los índices 0 y 2, nums se convierte en [1].
Ya no es posible realizar una operación en la matriz.
Por lo tanto, la longitud mínima alcanzable es 1.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums se ordena en orden no decreciente.


Se le proporciona una matriz indexada en 0 nums de números enteros no negativos y dos números enteros l y r.
Devuelve el recuento de subconjuntos múltiples dentro de nums donde la suma de los elementos en cada subconjunto cae dentro del rango inclusivo de [l, r].
Dado que la respuesta puede ser grande, devuélvala módulo 10^9 + 7.
Un subconjunto múltiple es una colección desordenada de elementos de la matriz en la que un valor dado x puede aparecer 0, 1, ..., occ[x] veces, donde occ[x] es la cantidad de ocurrencias de x en la matriz.
Tenga en cuenta que:

Dos subconjuntos múltiples son iguales si al ordenar ambos subconjuntos múltiples se obtienen conjuntos múltiples idénticos.
La suma de un multiconjunto vacío es 0.

Ejemplo 1:

Entrada: nums = [1,2,2,3], l = 6, r = 6
Salida: 1
Explicación: El único subconjunto de nums que tiene una suma de 6 es {1, 2, 3}.

Ejemplo 2:

Entrada: nums = [2,1,4,2,7], l = 1, r = 5
Salida: 7
Explicación: Los subconjuntos de nums que tienen una suma dentro del rango [1, 5] son {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} y {1, 2, 2}.

Ejemplo 3:

Entrada: nums = [1,2,1,3,5,2], l = 3, r = 5
Salida: 9
Explicación: Los subconjuntos de nums que tienen una suma dentro del rango [3, 5] son {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} y {1, 2, 2}.

Restricciones:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
La suma de nums no excede 2 * 10^4.
0 <= l <= r <= 2 * 10^4

Se te da un arreglo nums de enteros no negativos indexado desde 0, y dos enteros l y r.
Devuelve la cantidad de submulticonjuntos dentro de nums donde la suma de los elementos en cada subconjunto cae dentro del rango inclusivo de [l, r].
Dado que la respuesta puede ser grande, devuélvela modo 10^9 + 7.
Un submulticonjunto es una colección no ordenada de elementos del arreglo en la que un valor dado x puede ocurrir 0, 1, ..., occ[x] veces, donde occ[x] es el número de ocurrencias de x en el arreglo.
Nota que:

Dos submulticonjuntos son iguales si al ordenar ambos submulticonjuntos se obtienen multiconjuntos idénticos.
La suma de un multiconjunto vacío es 0.

Ejemplo 1:

Entrada: nums = [1,2,2,3], l = 6, r = 6
Salida: 1
Explicación: El único subconjunto de nums que tiene una suma de 6 es {1, 2, 3}.

Ejemplo 2:

Entrada: nums = [2,1,4,2,7], l = 1, r = 5
Salida: 7
Explicación: Los subconjuntos de nums que tienen una suma dentro del rango [1, 5] son {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} y {1, 2, 2}.

Ejemplo 3:

Entrada: nums = [1,2,1,3,5,2], l = 3, r = 5
Salida: 9
Explicación: Los subconjuntos de nums que tienen una suma dentro del rango [3, 5] son {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} y {1, 2, 2}.

Restricciones:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
La suma de nums no excede 2 * 10^4.
0 <= l <= r <= 2 * 10^4


Se te da un array de enteros 0-indexado `nums` y un entero `k`.
Devuelve un entero que denote la suma de los elementos en `nums` cuyos índices correspondientes tienen exactamente `k` bits establecidos en su representación binaria.
Los bits establecidos en un entero son los 1s presentes cuando se escribe en binario.

Por ejemplo, la representación binaria de 21 es 10101, que tiene 3 bits establecidos.

Ejemplo 1:

Entrada: nums = [5,10,1,5,2], k = 1
Salida: 13
Explicación: La representación binaria de los índices es:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Los índices 1, 2 y 4 tienen k = 1 bits establecidos en su representación binaria.
Por lo tanto, la respuesta es nums[1] + nums[2] + nums[4] = 13.

Ejemplo 2:

Entrada: nums = [4,3,2,1], k = 2
Salida: 1
Explicación: La representación binaria de los índices es:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Solo el índice 3 tiene k = 2 bits establecidos en su representación binaria.
Por lo tanto, la respuesta es nums[3] = 1.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums y un entero k.
Devuelve un entero que denota la suma de elementos en nums cuyos índices correspondientes tienen exactamente k bits establecidos en su representación binaria.
Los bits establecidos en un entero son los 1 presentes cuando se escribe en binario.

Por ejemplo, la representación binaria de 21 es 10101, que tiene 3 bits establecidos.

Ejemplo 1:

Entrada: nums = [5,10,1,5,2], k = 1
Salida: 13
Explicación: La representación binaria de los índices es:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Los índices 1, 2 y 4 tienen k = 1 bits establecidos en su representación binaria.
Por lo tanto, la respuesta es nums[1] + nums[2] + nums[4] = 13.
Ejemplo 2:

Entrada: nums = [4,3,2,1], k = 2
Salida: 1
Explicación: La representación binaria de los índices es:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Solo el índice 3 tiene k = 2 bits establecidos en su representación binaria.
Por lo tanto, la respuesta es nums[3] = 1.

Restricciones:

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

Se le da una matriz de enteros con índice 0 nums y un entero k.
Devuelve un entero que denota la suma de elementos en nums cuyos índices correspondientes tienen exactamente k bits de conjunto en su representación binaria.
Los bits de conjunto de un entero son los 1 presentes cuando se escribe en binario.

Por ejemplo, la representación binaria de 21 es 10101, que tiene 3 bits de conjunto.

Ejemplo 1

Entrada: nums = [5,10,1,5,2], k = 1
Salida: 13
Explicación: La representación binaria de los índices son:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Los índices 1, 2 y 4 tienen k = 1 bits fijos en su representación binaria.
Por tanto, la respuesta es nums[1] + nums[2] + nums[4] = 13.
Ejemplo 2:

Entrada: nums = [4,3,2,1], k = 2
Salida: 1
Explicación: La representación binaria de los índices son:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Sólo el índice 3 tiene k = 2 bits ajustados en su representación binaria.
Por lo tanto, la respuesta es nums[3] = 1.

Restricciones:

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


Se te da un array indexado desde 0, nums, compuesto por enteros positivos. Hay dos tipos de operaciones que puedes aplicar en el array cualquier número de veces:

Elige dos elementos con valores iguales y elimínalos del array.
Elige tres elementos con valores iguales y elimínalos del array.

Devuelve el número mínimo de operaciones necesarias para vaciar el array, o -1 si no es posible.

Ejemplo 1:

Entrada: nums = [2,3,3,2,2,4,2,3,4]
Salida: 4
Explicación: Podemos aplicar las siguientes operaciones para vaciar el array:
- Aplica la primera operación en los elementos en los índices 0 y 3. El array resultante es nums = [3,3,2,4,2,3,4].
- Aplica la primera operación en los elementos en los índices 2 y 4. El array resultante es nums = [3,3,4,3,4].
- Aplica la segunda operación en los elementos en los índices 0, 1 y 3. El array resultante es nums = [4,4].
- Aplica la primera operación en los elementos en los índices 0 y 1. El array resultante es nums = [].
Se puede demostrar que no podemos vaciar el array en menos de 4 operaciones.

Ejemplo 2:

Entrada: nums = [2,1,2,2,3,3]
Salida: -1
Explicación: Es imposible vaciar el array.

Restricciones:

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

Se te da un array indexado desde 0, nums, compuesto por enteros positivos.
Hay dos tipos de operaciones que puedes aplicar en el array cualquier número de veces:

Elige dos elementos con valores iguales y elimínalos del array.
Elige tres elementos con valores iguales y elimínalos del array.

Devuelve el número mínimo de operaciones necesarias para vaciar el array, o -1 si no es posible.

Ejemplo 1:

Input: nums = [2,3,3,2,2,4,2,3,4]
Output: 4
Explicación: Podemos aplicar las siguientes operaciones para vaciar el array:
Aplica la primera operación en los elementos en los índices 0 y 3. El array resultante es nums = [3,3,2,4,2,3,4].
Aplica la primera operación en los elementos en los índices 2 y 4. El array resultante es nums = [3,3,4,3,4].
Aplica la segunda operación en los elementos en los índices 0, 1 y 3. El array resultante es nums = [4,4].
Aplica la primera operación en los elementos en los índices 0 y 1. El array resultante es nums = [].
Se puede demostrar que no podemos vaciar el array en menos de 4 operaciones.

Ejemplo 2:

Input: nums = [2,1,2,2,3,3]
Output: -1
Explicación: Es imposible vaciar el array.

Restricciones:

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

Se le da un array nums con índice 0 formado por enteros positivos.
Hay dos tipos de operaciones que puede aplicar sobre la array cualquier número de veces:

Elegir dos elementos con valores iguales y borrarlos de la array.
Elegir tres elementos con valores iguales y borrarlos de la array.

Devuelve el número mínimo de operaciones necesarias para vaciar la array, o -1 si no es posible.

Ejemplo 1:

Entrada: nums = [2,3,3,2,2,4,2,3,4]
Salida: 4
Explicación: Podemos aplicar las siguientes operaciones para vaciar el array:
- Aplicar la primera operación sobre los elementos en los índices 0 y 3. El array resultante es nums = [3,3,2,4,2,3,4].
- Aplica la primera operación a los elementos de los índices 2 y 4. La array resultante es números = [3,3,2,4,2,3,4]. La array resultante es números = [3,3,4,3,4].
- Aplica la segunda operación a los elementos de los índices 0, 1 y 3. La array resultante es nums = [3,3,4,3,4]. La array resultante es números = [4,4].
- Aplicamos la primera operación sobre los elementos de los índices 0 y 1. La array resultante es nums = [].
Se puede demostrar que no se puede vaciar la array en menos de 4 operaciones.

Ejemplo 2:

Entrada: nums = [2,1,2,2,3,3]
Salida: -1
Explicación: Es imposible vaciar el array.

Restricciones:

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


Se te da un array de enteros de índice 0 llamado nums de longitud n, donde n es el número total de estudiantes en la clase. El profesor intenta seleccionar un grupo de estudiantes para que todos los estudiantes permanezcan felices.
El estudiante numero i será feliz si se cumple una de las dos condiciones siguientes:

El estudiante es seleccionado y el número total de estudiantes seleccionados es estrictamente mayor que nums[i].
El estudiante no es seleccionado y el número total de estudiantes seleccionados es estrictamente menor que nums[i].

Devuelve el número de formas de seleccionar un grupo de estudiantes para que todos estén felices.

Ejemplo 1:

Input: nums = [1,1]
Output: 2
Explicación:
Las dos formas posibles son:
El profesor no selecciona a ningún estudiante.
El profesor selecciona a ambos estudiantes para formar el grupo.
Si el profesor selecciona solo a un estudiante para formar un grupo, ambos estudiantes no estarán felices. Por lo tanto, solo hay dos formas posibles.

Ejemplo 2:

Input: nums = [6,0,3,3,6,7,2,7]
Output: 3
Explicación:
Las tres formas posibles son:
El profesor selecciona al estudiante con índice = 1 para formar el grupo.
El profesor selecciona a los estudiantes con índice = 1, 2, 3, 6 para formar el grupo.
El profesor selecciona a todos los estudiantes para formar el grupo.

Restricciones:

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

Se le proporciona una matriz de enteros indexada 0 nums de longitud n donde n es el número total de estudiantes en la clase. El profesor de la clase intenta seleccionar un grupo de estudiantes para que todos los estudiantes permanezcan felices.
El i^ésimo estudiante será feliz si se cumple una de estas dos condiciones:

El estudiante es seleccionado y el número total de estudiantes seleccionados es estrictamente mayor que nums[i].
El estudiante no está seleccionado y el número total de estudiantes seleccionados es estrictamente menor que nums[i].

Devuelve el número de formas de seleccionar un grupo de alumnos para que todos estén contentos.

Ejemplo 1:

Entrada: nums = [1,1]
Salida: 2
Explicación:
Las dos formas posibles son:
El profesor de la clase no selecciona a ningún alumno.
El profesor de la clase selecciona a ambos estudiantes para formar el grupo.
Si el maestro de la clase selecciona solo un estudiante para formar un grupo, entonces ambos estudiantes no estarán contentos. Por lo tanto, solo hay dos formas posibles.

Ejemplo 2:

Entrada: nums = [6,0,3,3,6,7,2,7]
Salida: 3
Explicación:
Las tres formas posibles son:
El profesor de la clase selecciona al alumno con índice = 1 para formar el grupo.
El profesor de la clase selecciona a los estudiantes con índice = 1, 2, 3, 6 para formar el grupo.
El profesor de la clase selecciona a todos los alumnos para formar el grupo.

Restricciones:

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

Se le da una matriz de números enteros con índice 0 de longitud n, donde n es el número total de alumnos de la clase. El profesor de la clase intenta seleccionar un grupo de alumnos de forma que todos los alumnos queden contentos.
El i^ésimo alumno será feliz si se cumple una de estas dos condiciones:

El alumno es seleccionado y el número total de alumnos seleccionados es estrictamente mayor que nums[i].
El alumno no es seleccionado y el número total de alumnos seleccionados es estrictamente menor que nums[i].

Devuelve el número de formas de seleccionar un grupo de alumnos para que todos queden contentos.

Ejemplo 1:

Entrada: núms = [1,1]
Salida: 2
Explicación:
Las dos formas posibles son:
El profesor de la clase no selecciona a ningún alumno.
El profesor selecciona a los dos alumnos para formar el grupo.
Si el profesor selecciona a un solo alumno para formar el grupo, los dos alumnos no estarán contentos. Por lo tanto, sólo hay dos posibilidades.

Ejemplo 2:

Entrada: nums = [6,0,3,3,6,7,2,7]
Salida: 3
Explicación:
Las tres formas posibles son:
El profesor de la clase selecciona al alumno con índice = 1 para formar el grupo.
El profesor selecciona a los alumnos con índice = 1, 2, 3, 6 para formar el grupo.
El profesor selecciona a todos los alumnos para formar el grupo.

Restricciones:

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