Se te da un array nums que consiste en enteros positivos.
Devuelve las frecuencias totales de los elementos en nums tales que esos elementos tienen la máxima frecuencia.
La frecuencia de un elemento es el número de ocurrencias de ese elemento en el array.

Ejemplo 1:

Entrada: nums = [1,2,2,3,1,4]
Salida: 4
Explicación: Los elementos 1 y 2 tienen una frecuencia de 2, que es la máxima frecuencia en el array.
Por lo tanto, el número de elementos en el array con la máxima frecuencia es 4.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5]
Salida: 5
Explicación: Todos los elementos del array tienen una frecuencia de 1, que es la máxima.
Por lo tanto, el número de elementos en el array con la máxima frecuencia es 5.

Restricciones:

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

Se le da una matriz nums formada por enteros positivos.
Devuelve las frecuencias totales de los elementos de nums de forma que todos esos elementos tengan la frecuencia máxima.
La frecuencia de un elemento es el número de apariciones de ese elemento en la matriz.

Ejemplo 1

Entrada: nums = [1,2,2,3,1,4]
Salida: 4
Explicación: Los elementos 1 y 2 tienen una frecuencia de 2 que es la frecuencia máxima en la matriz.
Así que el número de elementos en el array con frecuencia máxima es 4.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5]
Salida: 5
Explicación: Todos los elementos del array tienen una frecuencia de 1 que es la máxima.
Así que el número de elementos de la matriz con frecuencia máxima es 5.

Restricciones:

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

Se te da un array nums que consiste en enteros positivos.
Devuelve las frecuencias totales de los elementos en nums tales que esos elementos tienen la máxima frecuencia.
La frecuencia de un elemento es el número de ocurrencias de ese elemento en el array.

Ejemplo 1:

Input: nums = [1,2,2,3,1,4]
Output: 4
Explicación: Los elementos 1 y 2 tienen una frecuencia de 2, que es la máxima frecuencia en el array.
Por lo tanto, el número de elementos en el array con la máxima frecuencia es 4.

Ejemplo 2:

Input: nums = [1,2,3,4,5]
Output: 5
Explicación: Todos los elementos del array tienen una frecuencia de 1, que es la máxima.
Por lo tanto, el número de elementos en el array con la máxima frecuencia es 5

Restricciones:

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


Se te dan tres enteros: inicio, fin y límite. También se te da una cadena s indexada en 0 que representa un entero positivo.
Un entero positivo x se llama poderoso si termina con s (en otras palabras, s es un sufijo de x) y cada dígito en x es como mucho límite.
Devuelve el número total de enteros poderosos en el rango [inicio..fin].
Una cadena x es un sufijo de una cadena y si y solo si x es una subcadena de y que comienza desde algún índice (incluyendo 0) en y y se extiende hasta el índice y.length - 1. Por ejemplo, 25 es un sufijo de 5125, mientras que 512 no lo es.

Ejemplo 1:

Entrada: inicio = 1, fin = 6000, límite = 4, s = "124"
Salida: 5
Explicación: Los enteros poderosos en el rango [1..6000] son 124, 1124, 2124, 3124, y 4124. Todos estos enteros tienen cada dígito <= 4, y "124" como sufijo. Nota que 5124 no es un entero poderoso porque el primer dígito es 5, que es mayor que 4.
Se puede demostrar que hay solo 5 enteros poderosos en este rango.

Ejemplo 2:

Entrada: inicio = 15, fin = 215, límite = 6, s = "10"
Salida: 2
Explicación: Los enteros poderosos en el rango [15..215] son 110 y 210. Todos estos enteros tienen cada dígito <= 6, y "10" como sufijo.
Se puede demostrar que hay solo 2 enteros poderosos en este rango.

Ejemplo 3:

Entrada: inicio = 1000, fin = 2000, límite = 4, s = "3000"
Salida: 0
Explicación: Todos los enteros en el rango [1000..2000] son menores que 3000, por lo tanto, "3000" no puede ser un sufijo de ningún entero en este rango.

Restricciones:

1 <= inicio <= fin <= 10^15
1 <= límite <= 9
1 <= s.length <= floor(log_10(fin)) + 1
s solo consiste en dígitos numéricos que son como mucho límite.
s no tiene ceros a la izquierda.

Se le proporcionan tres números enteros: inicio, fin y límite. También se le proporciona una cadena s indexada en 0 que representa un número entero positivo.
Un número entero positivo x se denomina potente si termina en s (en otras palabras, s es un sufijo de x) y cada dígito de x es, como máximo, el límite.
Devuelve el número total de números enteros potentes en el rango [start..finish].
Una cadena x es un sufijo de una cadena y si y solo si x es una subcadena de y que comienza en algún índice (incluido 0) en y y se extiende hasta el índice y.length - 1. Por ejemplo, 25 es un sufijo de 5125, mientras que 512 no lo es.

Ejemplo 1:

Entrada: start = 1, finish = 6000, limit = 4, s = "124"
Salida: 5
Explicación: Los enteros potentes en el rango [1..6000] son 124, 1124, 2124, 3124 y 4124. Todos estos enteros tienen cada dígito <= 4 y "124" como sufijo. Tenga en cuenta que 5124 no es un entero potente porque el primer dígito es 5, que es mayor que 4.
Se puede demostrar que solo hay 5 enteros potentes en este rango.

Ejemplo 2:

Entrada: start = 15, finish = 215, limit = 6, s = "10"
Salida: 2
Explicación: Los enteros potentes en el rango [15..215] son 110 y 210. Todos estos enteros tienen cada dígito <= 6 y "10" como sufijo.
Se puede demostrar que solo hay 2 enteros potentes en este rango.

Ejemplo 3:

Entrada: start = 1000, finish = 2000, limit = 4, s = "3000"
Salida: 0
Explicación: Todos los enteros en el rango [1000..2000] son menores que 3000, por lo tanto, "3000" no puede ser un sufijo de ningún entero en este rango.

Restricciones:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s solo consta de dígitos numéricos que son como máximo el límite.
s no tiene ceros a la izquierda.

Se le dan tres enteros start, finish y limit. También se le da una cadena s con índice 0 que representa un número entero positivo.
Un entero positivo x se llama potente si termina con s (en otras palabras, s es un sufijo de x) y cada dígito de x es como máximo límite.
Devuelve el número total de enteros potentes en el rango [inicio..fin].
Una cadena x es un sufijo de una cadena y si y sólo si x es una subcadena de y que comienza en algún índice (incluido 0) de y y se extiende hasta el índice y.length - 1. Por ejemplo, 25 es un sufijo de 5125 mientras que 512 no lo es.

Ejemplo 1

Entrada: start = 1, finish = 6000, limit = 4, s = "124"
Salida: 5
Explicación: Los enteros potentes en el rango [1..6000] son 124, 1124, 2124, 3124, y, 4124. Todos estos enteros tienen cada dígito <= 4, y "124" como sufijo. Nótese que 5124 no es un entero potente porque el primer dígito es 5, que es mayor que 4.
Se puede demostrar que sólo hay 5 enteros potentes en este rango.

Ejemplo 2:

Entrada: start = 15, finish = 215, limit = 6, s = "10"
Salida: 2
Explicación: Los enteros potentes en el rango [15..215] son 110 y 210. Todos estos enteros tienen cada dígito <= 6, y "10" como sufijo.
Se puede demostrar que sólo hay 2 enteros potentes en este rango.

Ejemplo 3:

Entrada: start = 1000, finish = 2000, limit = 4, s = "3000"
Salida: 0
Explicación: Todos los enteros del intervalo [1000..2000] son menores que 3000, por lo que "3000" no puede ser sufijo de ningún entero de este intervalo.

Restricciones:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s sólo consta de dígitos numéricos que son como máximo límite.
s no tiene ceros a la izquierda.


Se te da un array de enteros indexado desde 0 llamado nums que contiene números enteros positivos.
Tu tarea es minimizar la longitud de nums realizando las siguientes operaciones cualquier cantidad de veces (incluyendo cero):

Selecciona dos índices distintos i y j de nums, tales que nums[i] > 0 y nums[j] > 0.
Inserta el resultado de nums[i] % nums[j] al final de nums.
Elimina los elementos en los índices i y j de nums.

Devuelve un entero que denote la longitud mínima de nums después de realizar la operación cualquier cantidad de veces.

Ejemplo 1:

Entrada: nums = [1,4,3,1]
Salida: 1
Explicación: Una forma de minimizar la longitud del array es la siguiente:
Operación 1: Selecciona los índices 2 y 1, inserta nums[2] % nums[1] al final y se convierte en [1,4,3,1,3], luego elimina los elementos en los índices 2 y 1.
nums se convierte en [1,1,3].
Operación 2: Selecciona los índices 1 y 2, inserta nums[1] % nums[2] al final y se convierte en [1,1,3,1], luego elimina los elementos en los índices 1 y 2.
nums se convierte en [1,1].
Operación 3: Selecciona los índices 1 y 0, inserta nums[1] % nums[0] al final y se convierte en [1,1,0], luego elimina los elementos en los índices 1 y 0.
nums se convierte en [0].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.
Ejemplo 2:

Entrada: nums = [5,5,5,10,5]
Salida: 2
Explicación: Una forma de minimizar la longitud del array es la siguiente:
Operación 1: Selecciona los índices 0 y 3, inserta nums[0] % nums[3] al final y se convierte en [5,5,5,10,5,5], luego elimina los elementos en los índices 0 y 3.
nums se convierte en [5,5,5,5].
Operación 2: Selecciona los índices 2 y 3, inserta nums[2] % nums[3] al final y se convierte en [5,5,5,5,0], luego elimina los elementos en los índices 2 y 3.
nums se convierte en [5,5,0].
Operación 3: Selecciona los índices 0 y 1, inserta nums[0] % nums[1] al final y se convierte en [5,5,0,0], luego elimina los elementos en los índices 0 y 1.
nums se convierte en [0,0].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 2.
Se puede demostrar que 2 es la longitud mínima alcanzable.
Ejemplo 3:

Entrada: nums = [2,3,4]
Salida: 1
Explicación: Una forma de minimizar la longitud del array es la siguiente:
Operación 1: Selecciona los índices 1 y 2, inserta nums[1] % nums[2] al final y se convierte en [2,3,4,3], luego elimina los elementos en los índices 1 y 2.
nums se convierte en [2,3].
Operación 2: Selecciona los índices 1 y 0, inserta nums[1] % nums[0] al final y se convierte en [2,3,1], luego elimina los elementos en los índices 1 y 0.
nums se convierte en [1].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.

Restricciones:

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

Se te da un conjunto de enteros indexado desde 0 llamado nums que contiene números enteros positivos.
Tu tarea es minimizar la longitud de nums realizando las siguientes operaciones cualquier cantidad de veces (incluyendo cero):

Selecciona dos índices distintos i y j de nums, tales que nums[i] > 0 y nums[j] > 0.
Inserta el resultado de nums[i] % nums[j] al final de nums.
Elimina los elementos en los índices i y j de nums.

Devuelve un entero que denote la longitud mínima de nums después de realizar la operación cualquier cantidad de veces.

Ejemplo 1:

Input: nums = [1,4,3,1]
Output: 1
Explicación: Una forma de minimizar la longitud del conjunto es la siguiente:
Operación 1: Selecciona los índices 2 y 1, inserta nums[2] % nums[1] al final y se convierte en [1,4,3,1,3], luego elimina los elementos en los índices 2 y 1.
nums se convierte en [1,1,3].
Operación 2: Selecciona los índices 1 y 2, inserta nums[1] % nums[2] al final y se convierte en [1,1,3,1], luego elimina los elementos en los índices 1 y 2.
nums se convierte en [1,1].
Operación 3: Selecciona los índices 1 y 0, inserta nums[1] % nums[0] al final y se convierte en [1,1,0], luego elimina los elementos en los índices 1 y 0.
nums se convierte en [0].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.
Ejemplo 2:

Input: nums = [5,5,5,10,5]
Output: 2
Explicación: Una forma de minimizar la longitud del conjunto es la siguiente:
Operación 1: Selecciona los índices 0 y 3, inserta nums[0] % nums[3] al final y se convierte en [5,5,5,10,5,5], luego elimina los elementos en los índices 0 y 3.
nums se convierte en [5,5,5,5].
Operación 2: Selecciona los índices 2 y 3, inserta nums[2] % nums[3] al final y se convierte en [5,5,5,5,0], luego elimina los elementos en los índices 2 y 3.
nums se convierte en [5,5,0].
Operación 3: Selecciona los índices 0 y 1, inserta nums[0] % nums[1] al final y se convierte en [5,5,0,0], luego elimina los elementos en los índices 0 y 1.
nums se convierte en [0,0].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 2.
Se puede demostrar que 2 es la longitud mínima alcanzable.
Ejemplo 3:

Input: nums = [2,3,4]
Output: 1
Explicación: Una forma de minimizar la longitud del conjunto es la siguiente:
Operación 1: Selecciona los índices 1 y 2, inserta nums[1] % nums[2] al final y se convierte en [2,3,4,3], luego elimina los elementos en los índices 1 y 2.
nums se convierte en [2,3].
Operación 2: Selecciona los índices 1 y 0, inserta nums[1] % nums[0] al final y se convierte en [2,3,1], luego elimina los elementos en los índices 1 y 0.
nums se convierte en [1].
La longitud de nums no puede reducirse más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 que contiene números enteros positivos.
Su tarea es minimizar la longitud de nums realizando las siguientes operaciones cualquier cantidad de veces (incluido cero):

Seleccione dos índices distintos i y j de nums, de modo que nums[i] > 0 y nums[j] > 0.
Inserte el resultado de nums[i] % nums[j] al final de nums.
Elimine los elementos en los índices i y j de nums.

Devuelva un número entero que denote la longitud mínima de nums después de realizar la operación cualquier cantidad de veces.

Ejemplo 1:

Entrada: nums = [1,4,3,1]
Salida: 1
Explicación: Una forma de minimizar la longitud de la matriz es la siguiente:
Operación 1: Seleccione los índices 2 y 1, inserte nums[2] % nums[1] al final y se convierte en [1,4,3,1,3], luego elimine los elementos en los índices 2 y 1.
nums se convierte en [1,1,3].
Operación 2: Seleccione los índices 1 y 2, inserte nums[1] % nums[2] al final y se convierte en [1,1,3,1], luego elimine los elementos en los índices 1 y 2.
nums se convierte en [1,1].
Operación 3: Seleccione los índices 1 y 0, inserte nums[1] % nums[0] al final y se convierte en [1,1,0], luego elimine los elementos en los índices 1 y 0.
nums se convierte en [0].
La longitud de nums no se puede reducir más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.
Ejemplo 2:

Entrada: nums = [5,5,5,10,5]
Salida: 2
Explicación: Una forma de minimizar la longitud de la matriz es la siguiente:
Operación 1: Seleccione los índices 0 y 3, inserte nums[0] % nums[3] al final y se convierte en [5,5,5,10,5,5], luego elimine los elementos en los índices 0 y 3.
nums se convierte en [5,5,5,5]. Operación 2: Seleccione los índices 2 y 3, inserte nums[2] % nums[3] al final y se convierte en [5,5,5,5,0], luego elimine los elementos en los índices 2 y 3.
nums se convierte en [5,5,0].
Operación 3: Seleccione los índices 0 y 1, inserte nums[0] % nums[1] al final y se convierte en [5,5,0,0], luego elimine los elementos en los índices 0 y 1.
nums se convierte en [0,0].
La longitud de nums no se puede reducir más. Por lo tanto, la respuesta es 2.
Se puede demostrar que 2 es la longitud mínima alcanzable.
Ejemplo 3:

Entrada: nums = [2,3,4]
Salida: 1
Explicación: Una forma de minimizar la longitud de la matriz es la siguiente:
Operación 1: Seleccione los índices 1 y 2, inserte nums[1] % nums[2] al final y se convierte en [2,3,4,3], luego elimine los elementos en los índices 1 y 2.
nums se convierte en [2,3].
Operación 2: Seleccione los índices 1 y 0, inserte nums[1] % nums[0] al final y se convierte en [2,3,1], luego elimine los elementos en los índices 1 y 0.
nums se convierte en [1].
La longitud de nums no se puede reducir más. Por lo tanto, la respuesta es 1.
Se puede demostrar que 1 es la longitud mínima alcanzable.

Restricciones:

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


Se te da una cadena s indexada desde 0, una cadena a, una cadena b, y un entero k.
Un índice i es hermoso si:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Existe un índice j tal que:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Devuelve el arreglo que contiene los índices hermosos en orden ascendente de menor a mayor.

Ejemplo 1:

Entrada: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Salida: [16,33]
Explicación: Hay 2 índices hermosos: [16,33].
- El índice 16 es hermoso ya que s[16..17] == "my" y existe un índice 4 con s[4..11] == "squirrel" y |16 - 4| <= 15.
- El índice 33 es hermoso ya que s[33..34] == "my" y existe un índice 18 con s[18..25] == "squirrel" y |33 - 18| <= 15.
Por lo tanto, devolvemos [16,33] como resultado.

Ejemplo 2:

Entrada: s = "abcd", a = "a", b = "a", k = 4
Salida: [0]
Explicación: Hay 1 índice hermoso: [0].
- El índice 0 es hermoso ya que s[0..0] == "a" y existe un índice 0 con s[0..0] == "a" y |0 - 0| <= 4.
Por lo tanto, devolvemos [0] como resultado.

Restricciones:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, y b contienen solo letras minúsculas en inglés.

Se le proporciona una cadena s indexada en 0, una cadena a, una cadena b y un entero k.
Un índice i es bello si:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Existe un índice j tal que:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Devuelva la matriz que contiene índices bellos ordenados del más pequeño al más grande.

Ejemplo 1:

Entrada: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Salida: [16,33]
Explicación: Hay 2 índices bellos: [16,33].
- El índice 16 es bello porque s[16..17] == "my" y existe un índice 4 con s[4..11] == "squirrel" y |16 - 4| <= 15.
- El índice 33 es bello porque s[33..34] == "my" y existe un índice 18 con s[18..25] == "squirrel" y |33 - 18| <= 15.
Por lo tanto, devolvemos [16,33] como resultado.

Ejemplo 2:

Entrada: s = "abcd", a = "a", b = "a", k = 4
Salida: [0]
Explicación: Hay 1 índice bello: [0].
- El índice 0 es hermoso ya que s[0..0] == "a" y existe un índice 0 con s[0..0] == "a" y |0 - 0| <= 4.
Por lo tanto, devolvemos [0] como resultado.

Restricciones:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a y b contienen solo letras minúsculas en inglés.


Se te da un array de enteros positivos nums.
Tienes que verificar si es posible seleccionar dos o más elementos en el array tal que el OR a nivel de bits de los elementos seleccionados tenga al menos un cero final en su representación binaria.
Por ejemplo, la representación binaria de 5, que es "101", no tiene ceros finales, mientras que la representación binaria de 4, que es "100", tiene dos ceros finales.
Devuelve true si es posible seleccionar dos o más elementos cuyo OR a nivel de bits tenga ceros finales, devuelve false en caso contrario.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: true
Explicación: Si seleccionamos los elementos 2 y 4, su OR a nivel de bits es 6, que tiene la representación binaria "110" con un cero final.

Ejemplo 2:

Entrada: nums = [2,4,8,16]
Salida: true
Explicación: Si seleccionamos los elementos 2 y 4, su OR a nivel de bits es 6, que tiene la representación binaria "110" con un cero final.
Otras formas posibles de seleccionar elementos para tener ceros finales en la representación binaria de su OR a nivel de bits son: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), y (2, 4, 8, 16).

Ejemplo 3:

Entrada: nums = [1,3,5,7,9]
Salida: false
Explicación: No hay forma posible de seleccionar dos o más elementos para tener ceros finales en la representación binaria de su OR a nivel de bits.

Restricciones:

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

Se le proporciona una matriz de números enteros positivos nums.
Debe comprobar si es posible seleccionar dos o más elementos de la matriz de modo que el OR bit a bit de los elementos seleccionados tenga al menos un cero final en su representación binaria.
Por ejemplo, la representación binaria de 5, que es "101", no tiene ningún cero final, mientras que la representación binaria de 4, que es "100", tiene dos ceros finales.
Devuelve true si es posible seleccionar dos o más elementos cuyo OR bit a bit tiene ceros finales; devuelve false en caso contrario.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: true
Explicación: Si seleccionamos los elementos 2 y 4, su OR bit a bit es 6, que tiene la representación binaria "110" con un cero final.

Ejemplo 2:

Entrada: nums = [2,4,8,16]
Salida: true
Explicación: Si seleccionamos los elementos 2 y 4, su OR bit a bit es 6, que tiene la representación binaria "110" con un cero al final.
Otras formas posibles de seleccionar elementos para que tengan ceros al final en la representación binaria de su OR bit a bit son: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) y (2, 4, 8, 16).

Ejemplo 3:

Entrada: nums = [1,3,5,7,9]
Salida: false
Explicación: No hay forma posible de seleccionar dos o más elementos para que tengan ceros al final en la representación binaria de su OR bit a bit.

Restricciones:

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


Se te da un arreglo de enteros nums indexado desde 0 y un entero positivo k.
Puedes aplicar la siguiente operación en el arreglo cualquier número de veces:

Elige cualquier elemento del arreglo y cambia un bit en su representación binaria. Cambiar un bit significa convertir un 0 en 1 o viceversa.

Devuelve el número mínimo de operaciones necesarias para que el XOR bit a bit de todos los elementos del arreglo final sea igual a k.
Ten en cuenta que puedes cambiar bits de ceros iniciales en la representación binaria de los elementos. Por ejemplo, para el número (101)_2 puedes cambiar el cuarto bit y obtener (1101)_2.

Ejemplo 1:

Entrada: nums = [2,1,3,4], k = 1
Salida: 2
Explicación: Podemos hacer las siguientes operaciones:
- Elegir el elemento 2 que es 3 == (011)_2, cambiamos el primer bit y obtenemos (010)_2 == 2. nums se convierte en [2,1,2,4].
- Elegir el elemento 0 que es 2 == (010)_2, cambiamos el tercer bit y obtenemos (110)_2 = 6. nums se convierte en [6,1,2,4].
El XOR de los elementos del arreglo final es (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Se puede demostrar que no podemos hacer que el XOR sea igual a k en menos de 2 operaciones.

Ejemplo 2:

Entrada: nums = [2,0,2,0], k = 0
Salida: 0
Explicación: El XOR de los elementos del array es (2 XOR 0 XOR 2 XOR 0) == 0 == k. Así que no se necesita ninguna operación.

Restricciones:

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

Se te da un array de enteros nums indexado desde 0 y un entero positivo k.
Puedes aplicar la siguiente operación en el array cualquier número de veces:

Elige cualquier elemento del array y cambia un bit en su representación binaria. Cambiar un bit significa convertir un 0 en 1 o viceversa.

Devuelve el número mínimo de operaciones necesarias para que el XOR bit a bit de todos los elementos del array final sea igual a k.
Ten en cuenta que puedes cambiar bits de ceros iniciales en la representación binaria de los elementos. Por ejemplo, para el número (101)_2 puedes cambiar el cuarto bit y obtener (1101)_2.

Ejemplo 1:

Entrada: nums = [2,1,3,4], k = 1
Salida: 2
Explicación: Podemos hacer las siguientes operaciones:
- Elegir el elemento 2 que es 3 == (011)_2, cambiamos el primer bit y obtenemos (010)_2 == 2. nums se convierte en [2,1,2,4].
- Elegir el elemento 0 que es 2 == (010)_2, cambiamos el tercer bit y obtenemos (110)_2 = 6. nums se convierte en [6,1,2,4].
El XOR de los elementos del array final es (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Se puede demostrar que no podemos hacer que el XOR sea igual a k en menos de 2 operaciones.

Ejemplo 2:

Entrada: nums = [2,0,2,0], k = 0
Salida: 0
Explicación: El XOR de los elementos del array es (2 XOR 0 XOR 2 XOR 0) == 0 == k. Así que no se necesita ninguna operación.

Restricciones:

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

Se le da una matriz de nums enteros con índice 0 y un número entero positivo k.
Puede aplicar la siguiente operación en la matriz cualquier número de veces:

Elija cualquier elemento de la matriz y voltear un bit en su representación binaria. Voltear un bit significa cambiar un 0 por un 1 o viceversa.

Devuelve el número mínimo de operaciones necesarias para que el XOR bit a bit de todos los elementos de la matriz final sea igual a k.
Tenga en cuenta que puede voltear los bits cero a la izquierda en la representación binaria de los elementos. Por ejemplo, para el número (101)_2 puede voltear el cuarto bit y obtener (1101)_2.

Ejemplo 1

Entrada: nums = [2,1,3,4], k = 1
Salida: 2
Explicación: Podemos hacer las siguientes operaciones:
- Elegimos el elemento 2 que es 3 == (011)_2, volteamos el primer bit y obtenemos (010)_2 == 2. nums se convierte en [2,1,2,4].
- Elegimos el elemento 0 que es 2 == (010)_2, volteamos el tercer bit y obtenemos (110)_2 = 6. nums se convierte en [6,1,2,4].
El XOR de los elementos de la matriz final es (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Se puede demostrar que no podemos hacer el XOR igual a k en menos de 2 operaciones.

Ejemplo 2:

Entrada: nums = [2,0,2,0], k = 0
Salida: 0
Explicación: El XOR de los elementos de la matriz es (2 XOR 0 XOR 2 XOR 0) == 0 == k. Así que no se necesita ninguna operación.

Restricciones:

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


Se le proporciona una matriz de enteros indexada en 0 en 2D, dimensions.
Para todos los índices i, 0 <= i < dimensions.length, dimensions[i][0] representa la longitud y dimensions[i][1] representa el ancho del rectángulo i.
Devuelve el área del rectángulo que tiene la diagonal más larga. Si hay varios rectángulos con la diagonal más larga, devuelve el área del rectángulo que tiene el área máxima.

Ejemplo 1:

Entrada: dimensions = [[9,3],[8,6]]
Salida: 48
Explicación:
Para index = 0, length = 9 y width = 3. Longitud diagonal = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Para índice = 1, longitud = 8 y ancho = 6. Longitud diagonal = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Por lo tanto, el rectángulo en el índice 1 tiene una longitud diagonal mayor, por lo tanto, devolvemos área = 8 * 6 = 48.

Ejemplo 2:

Entrada: dimensions = [[3,4],[4,3]]
Salida: 12
Explicación: La longitud de la diagonal es la misma para ambos, es decir, 5, por lo que el área máxima = 12.

Restricciones:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Se le da un array 2D de dimensiones enteras con índice 0.
Para todos los índices i, 0 <= i < dimensiones.longitud, dimensiones[i][0] representa la longitud y dimensiones[i][1] representa la anchura del rectángulo i.
Devuelve el área del rectángulo que tiene la diagonal más larga. Si hay varios rectángulos con la diagonal más larga, devuelve el área del rectángulo que tenga el área máxima.

Ejemplo 1

Entrada: dimensiones = [[9,3],[8,6]]
Salida: 48
Explicación:
Para índice = 0, longitud = 9 y anchura = 3. Longitud diagonal = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9,487.
Para índice = 1, longitud = 8 y anchura = 6. Longitud de la diagonal = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Por lo tanto, el rectángulo en el índice 1 tiene una mayor longitud diagonal por lo tanto devolvemos área = 8 * 6 = 48.

Ejemplo 2:

Entrada: dimensiones = [[3,4],[4,3]]
Salida: 12
Explicación: La longitud de la diagonal es la misma para ambos, que es 5, por lo que el área máxima = 12.

Restricciones:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Se te da un array 2D de enteros indexado desde 0 llamado dimensions.
Para todos los índices i, 0 <= i < dimensions.length, dimensions[i][0] representa la longitud y dimensions[i][1] representa el ancho del rectángulo i.
Devuelve el área del rectángulo con la diagonal más larga. Si hay varios rectángulos con la diagonal más larga, devuelve el área del rectángulo con el área máxima.

Ejemplo 1:

Input: dimensions = [[9,3],[8,6]]
Output: 48
Explicación:
Para index = 0, longitud = 9 y ancho = 3. Longitud de la diagonal = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Para index = 1, longitud = 8 y ancho = 6. Longitud de la diagonal = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Entonces, el rectángulo en el índice 1 tiene una longitud de diagonal mayor, por lo tanto devolvemos área = 8 * 6 = 48.

Ejemplo 2:

Input: dimensions = [[3,4],[4,3]]
Output: 12
Explicación: La longitud de la diagonal es la misma para ambos, que es 5, así que el área máxima = 12.

Restricciones:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100


Se te da un arreglo de enteros positivos indexado desde 0 llamado nums.
Un subarreglo de nums se llama irremovible si nums se vuelve estrictamente creciente al eliminar el subarreglo. Por ejemplo, el subarreglo [3, 4] es un subarreglo irremovible de [5, 3, 4, 6, 7] porque al eliminar este subarreglo se cambia el arreglo [5, 3, 4, 6, 7] a [5, 6, 7], que es estrictamente creciente.
Devuelve el número total de subarreglos irremovibles de nums.
Observa que un arreglo vacío se considera estrictamente creciente.
Un subarreglo es una secuencia contigua y no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 10
Explicación: Los 10 subarreglos irremovibles son: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] y [1,2,3,4], porque al eliminar cualquiera de estos subarreglos, nums se vuelve estrictamente creciente. Nota que no puedes seleccionar un subarreglo vacío.

Ejemplo 2:

Entrada: nums = [6,5,7,8]
Salida: 7
Explicación: Los 7 subarreglos irremovibles son: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] y [6,5,7,8].
Se puede demostrar que solo hay 7 subarreglos irremovibles en nums.

Ejemplo 3:

Entrada: nums = [8,7,6,6]
Salida: 3
Explicación: Los 3 subarreglos irremovibles son: [8,7,6], [7,6,6] y [8,7,6,6]. Nota que [8,7] no es un subarreglo irremovible porque después de eliminar [8,7], nums se convierte en [6,6], que está ordenado en orden ascendente pero no estrictamente creciente.

Restricciones:

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

Se te da un arreglo de enteros positivos indexado desde 0 llamado nums.
Un subarreglos de nums se llama increliminar si nums se vuelve estrictamente creciente al eliminar el subarreglo. Por ejemplo, el subarreglo [3, 4] es un subarreglo increliminar de [5, 3, 4, 6, 7] porque al eliminar este subarreglo se cambia el arreglo [5, 3, 4, 6, 7] a [5, 6, 7], que es estrictamente creciente.
Devuelve el número total de subarreglos increliminares de nums.
Observa que un arreglo vacío se considera estrictamente creciente.
Un subarreglo es una secuencia contigua y no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 10
Explicación: Los 10 subarreglos increliminares son: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] y [1,2,3,4], porque al eliminar cualquiera de estos subarreglo, nums se vuelve estrictamente creciente. Nota que no puedes seleccionar un subarreglo vacío.

Ejemplo 2:

Entrada: nums = [6,5,7,8]
Salida: 7
Explicación: Los 7 subarreglos increliminares son: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] y [6,5,7,8].
Se puede demostrar que solo hay 7 subarreglos increliminares en nums.

Ejemplo 3:

Entrada: nums = [8,7,6,6]
Salida: 3
Explicación: Los 3 subarreglos increliminares son: [8,7,6], [7,6,6] y [8,7,6,6]. Nota que [8,7] no es un subarreglo increliminare porque después de eliminar [8,7], nums se convierte en [6,6], que está ordenado en orden ascendente pero no estrictamente creciente.

Restricciones:

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

Se le proporciona una matriz indexada en 0 de números enteros positivos nums.
Una submatriz de nums se denomina incremovible si nums se vuelve estrictamente creciente al eliminar la submatriz. Por ejemplo, la submatriz [3, 4] es una submatriz incremovible de [5, 3, 4, 6, 7] porque al eliminar esta submatriz se cambia la matriz [5, 3, 4, 6, 7] a [5, 6, 7], que es estrictamente creciente.
Devuelve el número total de submatrices incremovibles de nums.
Tenga en cuenta que una matriz vacía se considera estrictamente creciente.
Una submatriz es una secuencia no vacía contigua de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 10
Explicación: Los 10 subarreglos incremizables son: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] y [1,2,3,4], porque al eliminar cualquiera de estos subarreglos, nums se vuelve estrictamente creciente. Tenga en cuenta que no puede seleccionar un subarreglo vacío.

Ejemplo 2:

Entrada: nums = [6,5,7,8]
Salida: 7
Explicación: Los 7 subarreglos incremizables son: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] y [6,5,7,8].
Se puede demostrar que solo hay 7 submatrices incremizables en nums.

Ejemplo 3:

Entrada: nums = [8,7,6,6]
Salida: 3
Explicación: Las 3 submatrices incremizables son: [8,7,6], [7,6,6] y [8,7,6,6]. Nótese que [8,7] no es una submatriz incremizable porque después de eliminar [8,7] nums se convierte en [6,6], que se ordena en orden ascendente pero no estrictamente creciente.

Restricciones:

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


Tienes un array de enteros indexado desde cero, llamado nums, y un entero k.
En una operación, puedes elegir cualquier índice i de nums tal que 0 <= i < nums.length - 1 y reemplazar nums[i] y nums[i + 1] con una sola aparición de nums[i] & nums[i + 1], donde & representa el operador AND bit a bit.
Devuelve el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 1:

Entrada: nums = [3,5,3,2,7], k = 2
Salida: 3
Explicación: Realicemos las siguientes operaciones:
1. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [1,3,2,7].
2. Reemplaza nums[2] y nums[3] con (nums[2] & nums[3]) para que nums sea igual a [1,3,2].
El OR bit a bit del array final es 3.
Se puede demostrar que 3 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 2:

Entrada: nums = [7,3,15,14,2,8], k = 4
Salida: 2
Explicación: Realicemos las siguientes operaciones:
1. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [3,15,14,2,8].
2. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [3,14,2,8].
3. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [2,2,8].
4. Reemplaza nums[1] y nums[2] con (nums[1] & nums[2]) para que nums sea igual a [2,0].
El OR bit a bit del array final es 2.
Se puede demostrar que 2 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 3:

Entrada: nums = [10,7,10,3,9,14,9,4], k = 1
Salida: 15
Explicación: Sin aplicar ninguna operación, el OR bit a bit de nums es 15.
Se puede demostrar que 15 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Restricciones:

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

Tienes un arreglo de enteros indexado desde cero, llamado nums, y un entero k.
En una operación, puedes elegir cualquier índice i de nums tal que 0 <= i < nums.length - 1 y reemplazar nums[i] y nums[i + 1] con una sola aparición de nums[i] & nums[i + 1], donde & representa el operador AND bit a bit.
Devuelve el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 1:

Entrada: nums = [3,5,3,2,7], k = 2
Salida: 3
Explicación: Realicemos las siguientes operaciones:
1. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [1,3,2,7].
2. Reemplaza nums[2] y nums[3] con (nums[2] & nums[3]) para que nums sea igual a [1,3,2].
El OR bit a bit del arreglo final es 3.
Se puede demostrar que 3 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.
Ejemplo 2:

Entrada: nums = [7,3,15,14,2,8], k = 4
Salida: 2
Explicación: Realicemos las siguientes operaciones:
1. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [3,15,14,2,8].
2. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [3,14,2,8].
3. Reemplaza nums[0] y nums[1] con (nums[0] & nums[1]) para que nums sea igual a [2,2,8].
4. Reemplaza nums[1] y nums[2] con (nums[1] & nums[2]) para que nums sea igual a [2,0].
El OR bit a bit del arreglo final es 2.
Se puede demostrar que 2 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 3:

Entrada: nums = [10,7,10,3,9,14,9,4], k = 1
Salida: 15
Explicación: Sin aplicar ninguna operación, el OR bit a bit de nums es 15.
Se puede demostrar que 15 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Restricciones:

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

Se le proporciona una matriz de enteros indexada desde 0, nums y un entero k.
En una operación, puede elegir cualquier índice i de nums tal que 0 <= i < nums.length - 1 y reemplazar nums[i] y nums[i + 1] con una única ocurrencia de nums[i] y nums[i + 1], donde y representa el operador AND bit a bit.
Devuelve el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 1:

Entrada: nums = [3,5,3,2,7], k = 2
Salida: 3
Explicación: Realicemos las siguientes operaciones:
1. Reemplace nums[0] y nums[1] con (nums[0] y nums[1]) de modo que nums sea igual a [1,3,2,7].
2. Reemplace nums[2] y nums[3] con (nums[2] y nums[3]) de modo que nums sea igual a [1,3,2].
El OR bit a bit de la matriz final es 3.
Se puede demostrar que 3 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.
Ejemplo 2:

Entrada: nums = [7,3,15,14,2,8], k = 4
Salida: 2
Explicación: Hagamos las siguientes operaciones:
1. Reemplace nums[0] y nums[1] con (nums[0] y nums[1]) de modo que nums sea igual a [3,15,14,2,8].
2. Reemplace nums[0] y nums[1] con (nums[0] y nums[1]) de modo que nums sea igual a [3,14,2,8].
3. Reemplace nums[0] y nums[1] con (nums[0] y nums[1]) de modo que nums sea igual a [2,2,8].
4. Reemplace nums[1] y nums[2] con (nums[1] y nums[2]) de modo que nums sea igual a [2,0].
El OR bit a bit de la matriz final es 2.
Se puede demostrar que 2 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Ejemplo 3:

Entrada: nums = [10,7,10,3,9,14,9,4], k = 1
Salida: 15
Explicación: Sin aplicar ninguna operación, el OR bit a bit de nums es 15.
Se puede demostrar que 15 es el valor mínimo posible del OR bit a bit de los elementos restantes de nums después de aplicar como máximo k operaciones.

Restricciones:

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


Dado un array de enteros positivos nums de longitud n.
Un polígono es una figura plana cerrada que tiene al menos 3 lados. El lado más largo de un polígono es menor que la suma de sus otros lados.
Inversamente, si tienes k (k >= 3) números reales positivos a_1, a_2, a_3, ..., a_k donde a_1 <= a_2 <= a_3 <= ... <= a_k y a_1 + a_2 + a_3 + ... + a_k-1 > a_k, entonces siempre existe un polígono con k lados cuyas longitudes son a_1, a_2, a_3, ..., a_k.
El perímetro de un polígono es la suma de las longitudes de sus lados.
Devuelve el perímetro más grande posible de un polígono cuyos lados pueden formarse a partir de nums, o -1 si no es posible crear un polígono.

Ejemplo 1:

Entrada: nums = [5,5,5]
Salida: 15
Explicación: El único polígono posible que se puede formar a partir de nums tiene 3 lados: 5, 5 y 5. El perímetro es 5 + 5 + 5 = 15.

Ejemplo 2:

Entrada: nums = [1,12,1,2,5,50,3]
Salida: 12
Explicación: El polígono con el perímetro más grande que se puede formar a partir de nums tiene 5 lados: 1, 1, 2, 3 y 5. El perímetro es 1 + 1 + 2 + 3 + 5 = 12.
No podemos tener un polígono con 12 o 50 como el lado más largo porque no es posible incluir 2 o más lados más pequeños que tengan una suma mayor que cualquiera de ellos.
Se puede demostrar que el perímetro más grande posible es 12.

Ejemplo 3:

Entrada: nums = [5,5,50]
Salida: -1
Explicación: No hay forma posible de formar un polígono a partir de nums, ya que un polígono tiene al menos 3 lados y 50 > 5 + 5.

Restricciones:

3 <= n <= 10^5
1 <= nums[i] <= 10^9

Se le proporciona una matriz de números enteros positivos de longitud n.
Un polígono es una figura plana cerrada que tiene al menos 3 lados. El lado más largo de un polígono es menor que la suma de sus otros lados.
Por el contrario, si tiene k (k >= 3) números reales positivos a_1, a_2, a_3, ..., a_k donde a_1 <= a_2 <= a_3 <= ... <= a_k y a_1 + a_2 + a_3 + ... + a_k-1 > a_k, entonces siempre existe un polígono con k lados cuyas longitudes son a_1, a_2, a_3, ..., a_k.
El perímetro de un polígono es la suma de las longitudes de sus lados.
Devuelve el perímetro más grande posible de un polígono cuyos lados se pueden formar a partir de números, o -1 si no es posible crear un polígono.

Ejemplo 1:

Entrada: nums = [5,5,5]
Salida: 15
Explicación: El único polígono posible que se puede hacer a partir de nums tiene 3 lados: 5, 5 y 5. El perímetro es 5 + 5 + 5 = 15.

Ejemplo 2:

Entrada: nums = [1,12,1,2,5,50,3]
Salida: 12
Explicación: El polígono con el perímetro más grande que se puede hacer a partir de nums tiene 5 lados: 1, 1, 2, 3 y 5. El perímetro es 1 + 1 + 2 + 3 + 5 = 12.
No podemos tener un polígono con 12 o 50 como el lado más largo porque no es posible incluir 2 o más lados más pequeños que tengan una suma mayor que cualquiera de ellos.
Se puede demostrar que el perímetro más grande posible es 12.

Ejemplo 3:

Entrada: nums = [5,5,50]
Salida: -1
Explicación: No hay forma posible de formar un polígono a partir de nums, ya que un polígono tiene al menos 3 lados y 50 > 5 + 5.

Restricciones:

3 <= n <= 10^5
1 <= nums[i] <= 10^9


Se te da un array de enteros nums de longitud n.
El costo de un array es el valor de su primer elemento. Por ejemplo, el costo de [1,2,3] es 1, mientras que el costo de [3,4,1] es 3.
Necesitas dividir nums en 3 subarrays contiguos y disjuntos.
Devuelve la suma mínima posible del costo de estos subarrays.

Ejemplo 1:

Entrada: nums = [1,2,3,12]
Salida: 6
Explicación: La mejor manera posible de formar 3 subarrays es: [1], [2] y [3,12] con un costo total de 1 + 2 + 3 = 6.
Las otras formas posibles de formar 3 subarrays son:
- [1], [2,3] y [12] con un costo total de 1 + 2 + 12 = 15.
- [1,2], [3] y [12] con un costo total de 1 + 3 + 12 = 16.

Ejemplo 2:

Entrada: nums = [5,4,3]
Salida: 12
Explicación: La mejor manera posible de formar 3 subarrays es: [5], [4] y [3] con un costo total de 5 + 4 + 3 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Ejemplo 3:

Entrada: nums = [10,3,1,1]
Salida: 12
Explicación: La mejor manera posible de formar 3 subarrays es: [10,3], [1] y [1] con un costo total de 10 + 1 + 1 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Condiciones:

3 <= n <= 50
1 <= nums[i] <= 50

Se le proporciona una matriz de números enteros nums de longitud n.
El costo de una matriz es el valor de su primer elemento. Por ejemplo, el costo de [1,2,3] es 1 mientras que el costo de [3,4,1] es 3.
Debe dividir nums en 3 submatrices contiguas disjuntas.
Devuelva la suma mínima posible del costo de estas submatrices.

Ejemplo 1:

Entrada: nums = [1,2,3,12]
Salida: 6
Explicación: La mejor forma posible de formar 3 subarreglos es: [1], [2] y [3,12] con un costo total de 1 + 2 + 3 = 6.
Las otras formas posibles de formar 3 subarreglos son:
- [1], [2,3] y [12] con un costo total de 1 + 2 + 12 = 15.
- [1,2], [3] y [12] con un costo total de 1 + 3 + 12 = 16.

Ejemplo 2:

Entrada: nums = [5,4,3]
Salida: 12
Explicación: La mejor forma posible de formar 3 subarreglos es: [5], [4] y [3] con un costo total de 5 + 4 + 3 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Ejemplo 3:

Entrada: nums = [10,3,1,1]
Salida: 12
Explicación: La mejor manera posible de formar 3 submatrices es: [10,3], [1] y [1] con un costo total de 10 + 1 + 1 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Restricciones:

3 <= n <= 50
1 <= nums[i] <= 50

Se te da un conjunto de enteros nums de longitud n.
El costo de un conjunto es el valor de su primer elemento. Por ejemplo, el costo de [1,2,3] es 1, mientras que el costo de [3,4,1] es 3.
Necesitas dividir nums en 3 subconjuntos contiguos y disjuntos.
Devuelve la suma mínima posible del costo de estos subconjuntos.

Ejemplo 1:

Entrada: nums = [1,2,3,12]
Salida: 6
Explicación: La mejor manera posible de formar 3 subconjuntos es: [1], [2] y [3,12] con un costo total de 1 + 2 + 3 = 6.
Las otras formas posibles de formar 3 subconjuntos son:
- [1], [2,3] y [12] con un costo total de 1 + 2 + 12 = 15.
- [1,2], [3] y [12] con un costo total de 1 + 3 + 12 = 16.

Ejemplo 2:

Entrada: nums = [5,4,3]
Salida: 12
Explicación: La mejor manera posible de formar 3 subconjuntos es: [5], [4] y [3] con un costo total de 5 + 4 + 3 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Ejemplo 3:

Entrada: nums = [10,3,1,1]
Salida: 12
Explicación: La mejor manera posible de formar 3 subconjuntos es: [10,3], [1] y [1] con un costo total de 10 + 1 + 1 = 12.
Se puede demostrar que 12 es el costo mínimo alcanzable.

Condiciones:

3 <= n <= 50
1 <= nums[i] <= 50


Se te da un arreglo nums de longitud n y un entero positivo k.
Se llama subarreglo bueno de nums si la diferencia absoluta entre su primer y último elemento es exactamente k, en otras palabras, el subarreglo nums[i..j] es bueno si |nums[i] - nums[j]| == k.
Devuelve la suma máxima de un subarreglo bueno de nums. Si no hay subarreglos buenos, devuelve 0.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], k = 1
Salida: 11
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 1 para un subarreglo bueno. Todos los subarreglos buenos son: [1,2], [2,3], [3,4], [4,5], y [5,6]. La suma máxima del subarreglo es 11 para el subarreglo [5,6].

Ejemplo 2:

Entrada: nums = [-1,3,2,4,5], k = 3
Salida: 11
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 3 para un subarreglo bueno. Todos los subarreglos buenos son: [-1,3,2], y [2,4,5]. La suma máxima del subarreglo es 11 para el subarreglo [2,4,5].

Ejemplo 3:

Entrada: nums = [-1,-2,-3,-4], k = 2
Salida: -6
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 2 para un subarreglo bueno. Todos los subarreglos buenos son: [-1,-2,-3], y [-2,-3,-4]. La suma máxima del subarreglo es -6 para el subarreglo [-1,-2,-3].

Restricciones:

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

Se te da un conjunto nums de longitud n y un entero positivo k.
Se le llama subconjunto bueno de nums si la diferencia absoluta entre su primer y último elemento es exactamente k, en otras palabras, el subconjunto nums[i..j] es bueno si |nums[i] - nums[j]| == k.
Devuelve la suma máxima de un subconjunto bueno de nums. Si no hay subconjuntos buenos, devuelve 0.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], k = 1
Salida: 11
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 1 para un subconjunto bueno. Todos los subconjuntos buenos son: [1,2], [2,3], [3,4], [4,5], y [5,6]. La suma máxima del subconjunto es 11 para el subconjunto [5,6].

Ejemplo 2:

Entrada: nums = [-1,3,2,4,5], k = 3
Salida: 11
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 3 para un subconjunto bueno. Todos los subconjuntos buenos son: [-1,3,2], y [2,4,5]. La suma máxima del subconjunto es 11 para el subconjunto [2,4,5].

Ejemplo 3:

Entrada: nums = [-1,-2,-3,-4], k = 2
Salida: -6
Explicación: La diferencia absoluta entre el primer y último elemento debe ser 2 para un subconjunto bueno. Todos los subconjuntos buenos son: [-1,-2,-3], y [-2,-3,-4]. La suma máxima del subconjunto es -6 para el subconjunto [-1,-2,-3].

Restricciones:

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

Se da una matriz nums de longitud n y un número entero positivo k.
Una submatriz de nums se llama buena si la diferencia absoluta entre su primer y último elemento es exactamente k, es decir, la submatriz nums[i..j] es buena si |nums[i] - nums[j]| == k.
Devuelve la suma máxima de una submatriz buena de nums. Si no hay submatrices buenas, devuelve 0.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], k = 1
Salida: 11
Explicación: La diferencia absoluta entre el primer y el último elemento debe ser 1 para que una submatriz sea buena. Todas las submatrices buenas son: [1,2], [2,3], [3,4], [4,5] y [5,6]. La suma máxima de submatrices es 11 para la submatriz [5,6].

Ejemplo 2:

Entrada: nums = [-1,3,2,4,5], k = 3
Salida: 11
Explicación: La diferencia absoluta entre el primer y el último elemento debe ser 3 para que la submatriz sea buena. Todas las submatrices buenas son: [-1,3,2], y [2,4,5]. La suma máxima de la submatriz es 11 para la submatriz [2,4,5].

Ejemplo 3:

Entrada: nums = [-1,-2,-3,-4], k = 2
Salida: -6
Explicación: La diferencia absoluta entre el primer y el último elemento debe ser 2 para un buen subarray. Todas las submatrices buenas son: [-1,-2,-3], y [-2,-3,-4]. La suma máxima de la submatriz es -6 para la submatriz [-1,-2,-3].

Restricciones:

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


Se le proporciona una cadena s que consta de letras minúsculas del alfabeto inglés.
Una cadena se denomina especial si está formada por un solo carácter. Por ejemplo, la cadena "abc" no es especial, mientras que las cadenas "ddd", "zz" y "f" sí lo son.
Devuelve la longitud de la subcadena especial más larga de s que aparece al menos tres veces, o -1 si no aparece ninguna subcadena especial al menos tres veces.
Una subcadena es una secuencia contigua no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "aaaa"
Salida: 2
Explicación: La subcadena especial más larga que aparece tres veces es "aa": subcadenas "aaaa", "aaaa" y "aaaa".
Se puede demostrar que la longitud máxima alcanzable es 2.

Ejemplo 2:

Entrada: s = "abcdef"
Salida: -1
Explicación: No existe ninguna subcadena especial que aparezca al menos tres veces. Por lo tanto, se devuelve -1.

Ejemplo 3:

Entrada: s = "abcaba"
Salida: 1
Explicación: La subcadena especial más larga que aparece tres veces es "a": subcadenas "abcaba", "abcaba" y "abcaba".
Se puede demostrar que la longitud máxima alcanzable es 1.

Restricciones:

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

Se te da una cadena s que consiste en letras minúsculas del alfabeto inglés.
Una cadena se llama especial si está compuesta únicamente por un solo carácter. Por ejemplo, la cadena "abc" no es especial, mientras que las cadenas "ddd", "zz" y "f" son especiales.
Devuelve la longitud de la subcadena especial más larga de s que ocurre al menos tres veces, o -1 si no hay ninguna subcadena especial que ocurra al menos tres veces.
Una subcadena es una secuencia contigua y no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "aaaa"
Salida: 2
Explicación: La subcadena especial más larga que ocurre tres veces es "aa": subcadenas "aaaa", "aaaa" y "aaaa".
Se puede demostrar que la longitud máxima alcanzable es 2.

Ejemplo 2:

Entrada: s = "abcdef"
Salida: -1
Explicación: No existe ninguna subcadena especial que ocurra al menos tres veces. Por lo tanto, devuelve -1.

Ejemplo 3:

Entrada: s = "abcaba"
Salida: 1
Explicación: La subcadena especial más larga que ocurre tres veces es "a": subcadenas "abcaba", "abcaba" y "abcaba".
Se puede demostrar que la longitud máxima alcanzable es 1.

Restricciones:

3 <= s.length <= 50
s consiste únicamente en letras minúsculas del alfabeto inglés.

Se te da una cadena s que consiste en letras minúsculas del alfabeto inglés.
Una cadena se llama especial si está compuesta únicamente por un solo carácter. Por ejemplo, la cadena "abc" no es especial, mientras que las cadenas "ddd", "zz" y "f" son especiales.
Devuelve la longitud de la subcadena especial más larga de s que aparece al menos tres veces, o -1 si no hay ninguna subcadena especial que aparezca al menos tres veces.
Una subcadena es una secuencia contigua y no vacía de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "aaaa"
Salida: 2
Explicación: La subcadena especial más larga que aparece tres veces es "aa": subcadenas "aaaa", "aaaa" y "aaaa".
Se puede demostrar que la longitud máxima alcanzable es 2.

Ejemplo 2:

Entrada: s = "abcdef"
Salida: -1
Explicación: No existe ninguna subcadena especial que aparezca al menos tres veces. Por lo tanto, devuelve -1.

Ejemplo 3:

Entrada: s = "abcaba"
Salida: 1
Explicación: La subcadena especial más larga que aparece tres veces es "a": subcadenas "abcaba", "abcaba" y "abcaba".
Se puede demostrar que la longitud máxima alcanzable es 1.

Restricciones:

3 <= s.length <= 50
s consiste únicamente en letras minúsculas del alfabeto inglés.


Se te da un array de enteros nums indexado desde 0 de tamaño n, y un array de enteros pattern indexado desde 0 de tamaño m que consiste en los enteros -1, 0, y 1.
Se dice que un subarray nums[i..j] de tamaño m + 1 coincide con el patrón si se cumplen las siguientes condiciones para cada elemento pattern[k]:

nums[i + k + 1] > nums[i + k] si pattern[k] == 1.
nums[i + k + 1] == nums[i + k] si pattern[k] == 0.
nums[i + k + 1] < nums[i + k] si pattern[k] == -1.

Devuelve el conteo de los subarrays en nums que coinciden con el patrón.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], pattern = [1,1]
Salida: 4
Explicación: El patrón [1,1] indica que estamos buscando subarrays estrictamente crecientes de tamaño 3. En el array nums, los subarrays [1,2,3], [2,3,4], [3,4,5], y [4,5,6] coinciden con este patrón.
Por lo tanto, hay 4 subarrays en nums que coinciden con el patrón.

Ejemplo 2:

Entrada: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Salida: 2
Explicación: Aquí, el patrón [1,0,-1] indica que estamos buscando una secuencia donde el primer número sea menor que el segundo, el segundo sea igual al tercero, y el tercero sea mayor que el cuarto. En el array nums, los subarrays [1,4,4,1], y [3,5,5,3] coinciden con este patrón.
Por lo tanto, hay 2 subarrays en nums que coinciden con el patrón.

Restricciones:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

Se le proporciona una matriz de enteros indexada en 0 nums de tamaño n, y una matriz de enteros indexada en 0 pattern de tamaño m que consta de los enteros -1, 0 y 1.
Se dice que una submatriz nums[i..j] de tamaño m + 1 coincide con el patrón si se cumplen las siguientes condiciones para cada elemento pattern[k]:

nums[i + k + 1] > nums[i + k] si pattern[k] == 1.
nums[i + k + 1] == nums[i + k] si pattern[k] == 0.
nums[i + k + 1] < nums[i + k] si pattern[k] == -1.

Devuelve el recuento de submatrices en nums que coinciden con el patrón.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], pattern = [1,1]
Salida: 4
Explicación: El patrón [1,1] indica que estamos buscando submatrices estrictamente crecientes de tamaño 3. En la matriz nums, las submatrices [1,2,3], [2,3,4], [3,4,5] y [4,5,6] coinciden con este patrón.
Por lo tanto, hay 4 submatrices en nums que coinciden con el patrón.

Ejemplo 2:

Entrada: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Salida: 2
Explicación: Aquí, el patrón [1,0,-1] indica que estamos buscando una secuencia donde el primer número sea menor que el segundo, el segundo sea igual al tercero y el tercero sea mayor que el cuarto. En la matriz nums, las submatrices [1,4,4,1] y [3,5,5,3] coinciden con este patrón.
Por lo tanto, hay 2 submatrices en nums que coinciden con el patrón.

Restricciones:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

Se da una matriz de enteros de tamaño n e índice 0, y una matriz de enteros de tamaño m e índice 0, formada por los enteros -1, 0 y 1. Se dice que una submatriz nums[i..j] de tamaño m + 1 coincide con el patrón si se cumplen las siguientes condiciones para cada elemento patrón[k].
Se dice que una submatriz nums[i..j] de tamaño m + 1 coincide con el patrón si se cumplen las siguientes condiciones para cada elemento patrón[k]:

nums[i + k + 1] > nums[i + k] si patrón[k] == 1.
nums[i + k + 1] == nums[i + k] si patrón[k] == 0.
nums[i + k + 1] < nums[i + k] si patrón[k] == -1.

Devuelve la cuenta de submatrices en nums que coinciden con el patrón.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5,6], pattern = [1,1]
Salida: 4
Explicación: El patrón [1,1] indica que estamos buscando submatrices estrictamente crecientes de tamaño 3. En la matriz nums, las submatrices [1,2,3], [2,3,4], [3,4,5] y [4,5,6] coinciden con este patrón.
Por lo tanto, hay 4 submatrices en nums que coinciden con el patrón.

Ejemplo 2:

Entrada: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Salida: 2
Explicación: Aquí, el patrón [1,0,-1] indica que estamos buscando una secuencia donde el primer número es menor que el segundo, el segundo es igual al tercero, y el tercero es mayor que el cuarto. En la matriz nums, las submatrices [1,4,4,1] y [3,5,5,3] coinciden con este patrón.
Por lo tanto, hay 2 submatrices en nums que coinciden con el patrón.

Restricciones:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1


Alice y Bob están jugando a un juego por turnos en un campo circular rodeado de flores. El círculo representa el campo, y hay x flores en la dirección de las agujas del reloj entre Alice y Bob, y y flores en la dirección contraria a las agujas del reloj entre ellos.
El juego procede de la siguiente manera:

Alice toma el primer turno.
En cada turno, un jugador debe elegir ya sea la dirección de las agujas del reloj o la dirección contraria y recoger una flor de ese lado.
Al final del turno, si no quedan flores, el jugador actual captura a su oponente y gana el juego.

Dados dos enteros, n y m, la tarea es calcular el número de pares posibles (x, y) que satisfacen las condiciones:

Alice debe ganar el juego según las reglas descritas.
El número de flores x en la dirección de las agujas del reloj debe estar en el rango [1,n].
El número de flores y en la dirección contraria a las agujas del reloj debe estar en el rango [1,m].

Devuelve el número de pares posibles (x, y) que cumplen las condiciones mencionadas en el enunciado.

Ejemplo 1:

Entrada: n = 3, m = 2
Salida: 3
Explicación: Los siguientes pares satisfacen las condiciones descritas en el enunciado: (1,2), (3,2), (2,1).

Ejemplo 2:

Entrada: n = 1, m = 1
Salida: 0
Explicación: Ningún par satisface las condiciones descritas en el enunciado.

Restricciones:

1 <= n, m <= 10^5

Alice y Bob están jugando un juego por turnos en un campo circular rodeado de flores. El círculo representa el campo y hay x flores en el sentido de las agujas del reloj entre Alice y Bob, e y flores en el sentido contrario a las agujas del reloj entre ellos.
El juego se desarrolla de la siguiente manera:

Alice toma el primer turno.
En cada turno, un jugador debe elegir la dirección en el sentido de las agujas del reloj o en el sentido contrario a las agujas del reloj y tomar una flor de ese lado.
Al final del turno, si no quedan flores, el jugador actual captura a su oponente y gana el juego.

Dados dos números enteros, n y m, la tarea es calcular la cantidad de pares posibles (x, y) que satisfacen las condiciones:

Alice debe ganar el juego de acuerdo con las reglas descritas.
La cantidad de flores x en el sentido de las agujas del reloj debe estar en el rango [1,n].
La cantidad de flores y en el sentido contrario a las agujas del reloj debe estar en el rango [1,m].

Devuelve la cantidad de pares posibles (x, y) que satisfacen las condiciones mencionadas en la declaración.

Ejemplo 1:

Entrada: n = 3, m = 2
Salida: 3
Explicación: Los siguientes pares satisfacen las condiciones descritas en la declaración: (1,2), (3,2), (2,1).

Ejemplo 2:

Entrada: n = 1, m = 1
Salida: 0
Explicación: Ningún par satisface las condiciones descritas en la declaración.

Restricciones:

1 <= n, m <= 10^5


Dado un array de enteros positivos nums con índice 0.
En una operación, puedes intercambiar cualquier par de elementos adyacentes si tienen el mismo número de bits activados. Se permite hacer esta operación cualquier número de veces (incluyendo cero).
Devuelve true si puedes ordenar el array, de lo contrario devuelve false.

Ejemplo 1:

Entrada: nums = [8,4,2,30,15]
Salida: true
Explicación: Observemos la representación binaria de cada elemento. Los números 2, 4 y 8 tienen un bit activado cada uno con representación binaria "10", "100" y "1000", respectivamente. Los números 15 y 30 tienen cuatro bits activados cada uno con representación binaria "1111" y "11110".
Podemos ordenar el array usando 4 operaciones:
- Intercambiar nums[0] con nums[1]. Esta operación es válida porque 8 y 4 tienen un bit activado cada uno. El array se convierte en [4,8,2,30,15].
- Intercambiar nums[1] con nums[2]. Esta operación es válida porque 8 y 2 tienen un bit activado cada uno. El array se convierte en [4,2,8,30,15].
- Intercambiar nums[0] con nums[1]. Esta operación es válida porque 4 y 2 tienen un bit activado cada uno. El array se convierte en [2,4,8,30,15].
- Intercambiar nums[3] con nums[4]. Esta operación es válida porque 30 y 15 tienen cuatro bits activados cada uno. El array se convierte en [2,4,8,15,30].
El array se ha ordenado, por lo tanto, devolvemos true.
Tenga en cuenta que puede haber otras secuencias de operaciones que también ordenen el array.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5]
Salida: true
Explicación: El array ya está ordenado, por lo tanto, devolvemos true.

Ejemplo 3:

Entrada: nums = [3,16,8,4,2]
Salida: false
Explicación: Se puede demostrar que no es posible ordenar el array de entrada usando cualquier número de operaciones.

Condiciones:

1 <= nums.length <= 100
1 <= nums[i] <= 2^8

Se le proporciona una matriz indexada en 0 de números enteros positivos nums.
En una operación, puede intercambiar dos elementos adyacentes si tienen la misma cantidad de bits establecidos. Puede realizar esta operación cualquier cantidad de veces (incluido cero).
Devuelve verdadero si puede ordenar la matriz; de lo contrario, devuelve falso.

Ejemplo 1:

Entrada: nums = [8,4,2,30,15]
Salida: true
Explicación: observemos la representación binaria de cada elemento. Los números 2, 4 y 8 tienen un bit establecido cada uno con representación binaria "10", "100" y "1000", respectivamente. Los números 15 y 30 tienen cuatro bits establecidos cada uno con representación binaria "1111" y "11110".
Podemos ordenar la matriz utilizando 4 operaciones:
- Intercambiar nums[0] con nums[1]. Esta operación es válida porque 8 y 4 tienen un bit establecido cada uno. La matriz se convierte en [4,8,2,30,15].
- Intercambie nums[1] con nums[2]. Esta operación es válida porque 8 y 2 tienen un bit establecido cada uno. La matriz se convierte en [4,2,8,30,15].
- Intercambie nums[0] con nums[1]. Esta operación es válida porque 4 y 2 tienen un bit establecido cada uno. La matriz se convierte en [2,4,8,30,15].
- Intercambie nums[3] con nums[4]. Esta operación es válida porque 30 y 15 tienen cuatro bits establecidos cada uno. La matriz se convierte en [2,4,8,15,30].
La matriz se ha ordenado, por lo tanto, devolvemos verdadero.
Tenga en cuenta que puede haber otras secuencias de operaciones que también ordenen la matriz.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5]
Salida: true
Explicación: La matriz ya está ordenada, por lo tanto, devolvemos verdadero.

Ejemplo 3:

Entrada: nums = [3,16,8,4,2]
Salida: false
Explicación: Se puede demostrar que no es posible ordenar la matriz de entrada utilizando cualquier número de operaciones.

Restricciones:

1 <= nums.length <= 100
1 <= nums[i] <= 2^8

Se le proporciona una matriz indexada en 0 de números enteros positivos nums.
En una operación, puede intercambiar dos elementos adyacentes si tienen la misma cantidad de bits establecidos. Puede realizar esta operación cualquier cantidad de veces (incluido cero).
Devuelve verdadero si puede ordenar la matriz; de lo contrario, devuelve falso.

Ejemplo 1:

Entrada: nums = [8,4,2,30,15]
Salida: verdadero
Explicación: observemos la representación binaria de cada elemento. Los números 2, 4 y 8 tienen un bit establecido cada uno con representación binaria "10", "100" y "1000", respectivamente. Los números 15 y 30 tienen cuatro bits establecidos cada uno con representación binaria "1111" y "11110".
Podemos ordenar la matriz utilizando 4 operaciones:
- Intercambiar nums[0] con nums[1]. Esta operación es válida porque 8 y 4 tienen un bit establecido cada uno. La matriz se convierte en [4,8,2,30,15].
- Intercambie nums[1] con nums[2]. Esta operación es válida porque 8 y 2 tienen un bit establecido cada uno. La matriz se convierte en [4,2,8,30,15].
- Intercambie nums[0] con nums[1]. Esta operación es válida porque 4 y 2 tienen un bit establecido cada uno. La matriz se convierte en [2,4,8,30,15].
- Intercambie nums[3] con nums[4]. Esta operación es válida porque 30 y 15 tienen cuatro bits establecidos cada uno. La matriz se convierte en [2,4,8,15,30].
La matriz se ha ordenado, por lo tanto, devolvemos verdadero.
Tenga en cuenta que puede haber otras secuencias de operaciones que también ordenen la matriz.

Ejemplo 2:

Entrada: nums = [1,2,3,4,5]
Salida: verdadero
Explicación: La matriz ya está ordenada, por lo tanto, devolvemos verdadero.

Ejemplo 3:

Entrada: nums = [3,16,8,4,2]
Salida: false
Explicación: Se puede demostrar que no es posible ordenar la matriz de entrada utilizando cualquier número de operaciones.

Restricciones:

1 <= nums.length <= 100
1 <= nums[i] <= 2^8


Se te dan dos arreglos de enteros indexados desde 1, nums y changeIndices, con longitudes n y m, respectivamente.
Inicialmente, todos los índices en nums no están marcados. Tu tarea es marcar todos los índices en nums.
En cada segundo, s, en orden de 1 a m (incluyendo), puedes realizar una de las siguientes operaciones:

Elige un índice i en el rango [1, n] y decrementar nums[i] en 1.
Si nums[changeIndices[s]] es igual a 0, marca el índice changeIndices[s].
No hacer nada.

Devuelve un entero que denote el segundo más temprano en el rango [1, m] cuando todos los índices en nums puedan ser marcados eligiendo operaciones óptimamente, o -1 si es imposible.

Ejemplo 1:

Entrada: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Salida: 8
Explicación: En este ejemplo, tenemos 8 segundos. Las siguientes operaciones pueden realizarse para marcar todos los índices:
Segundo 1: Elige el índice 1 y decrementa nums[1] en uno. nums se convierte en [1,2,0].
Segundo 2: Elige el índice 1 y decrementa nums[1] en uno. nums se convierte en [0,2,0].
Segundo 3: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [0,1,0].
Segundo 4: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [0,0,0].
Segundo 5: Marca el índice changeIndices[5], que es marcar el índice 3, ya que nums[3] es igual a 0.
Segundo 6: Marca el índice changeIndices[6], que es marcar el índice 2, ya que nums[2] es igual a 0.
Segundo 7: No hacer nada.
Segundo 8: Marca el índice changeIndices[8], que es marcar el índice 1, ya que nums[1] es igual a 0.
Ahora todos los índices han sido marcados.
Se puede demostrar que no es posible marcar todos los índices antes del octavo segundo.
Por lo tanto, la respuesta es 8.

Ejemplo 2:

Entrada: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Salida: 6
Explicación: En este ejemplo, tenemos 7 segundos. Las siguientes operaciones pueden realizarse para marcar todos los índices:
Segundo 1: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [1,2].
Segundo 2: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [1,1].
Segundo 3: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [1,0].
Segundo 4: Marca el índice changeIndices[4], que es marcar el índice 2, ya que nums[2] es igual a 0.
Segundo 5: Elige el índice 1 y decrementa nums[1] en uno. nums se convierte en [0,0].
Segundo 6: Marca el índice changeIndices[6], que es marcar el índice 1, ya que nums[1] es igual a 0.
Ahora todos los índices han sido marcados.
Se puede demostrar que no es posible marcar todos los índices antes del sexto segundo.
Por lo tanto, la respuesta es 6.

Ejemplo 3:

Entrada: nums = [0,1], changeIndices = [2,2,2]
Salida: -1
Explicación: En este ejemplo, es imposible marcar todos los índices porque el índice 1 no está en changeIndices.
Por lo tanto, la respuesta es -1.

Restricciones:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

Se le dan dos matrices de enteros de 1 índice, nums y, changeIndices, que tienen longitudes n y m, respectivamente.
Inicialmente, todos los índices de nums están sin marcar. Su tarea es marcar todos los índices en nums.
En cada segundo, s, en orden de 1 a m (inclusive), puedes realizar una de las siguientes operaciones:

Elige un índice i en el rango [1, n] y decrementa nums[i] en 1.
Si nums[cambiarIndices[s]] es igual a 0, marque el índice cambiarIndices[s].
No hacer nada.

Devuelve un entero que denota el segundo más temprano en el rango [1, m] cuando todos los índices en nums pueden ser marcados eligiendo las operaciones óptimamente, o -1 si es imposible.

Ejemplo 1:

Entrada: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Salida: 8
Explicación: En este ejemplo, tenemos 8 segundos. Se pueden realizar las siguientes operaciones para marcar todos los índices:
Segundo 1: Elige el índice 1 y decrementa nums[1] en uno. nums pasa a ser [1,2,0].
Segundo 2: Se elige el índice 1 y se decrementa nums[1] en uno. nums pasa a ser [0,2,0].
Segundo 3: Elige el índice 2 y disminuye nums[2] en uno. nums pasa a ser [0,1,0].
Segundo 4: Elige el índice 2 y decrementa nums[2] en uno. nums pasa a ser [0,0,0].
Segundo 5: Marca el índice changeIndices[5], que está marcando el índice 3, ya que nums[3] es igual a 0.
Segundo 6: Marca el índice changeIndices[6], que está marcando el índice 2, ya que nums[2] es igual a 0.
Segundo 7: No hacemos nada.
Segundo 8: Marca el índice changeIndices[8], que está marcando el índice 1, ya que nums[1] es igual a 0.
Ahora se han marcado todos los índices.
Se puede demostrar que no es posible marcar todos los índices antes del octavo segundo.
Por lo tanto, la respuesta es 8.

Ejemplo 2:

Entrada: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Salida: 6
Explicación: En este ejemplo, tenemos 7 segundos. Se pueden realizar las siguientes operaciones para marcar todos los índices:
Segundo 1: Elige el índice 2 y decrementa nums[2] en uno. nums se convierte en [1,2].
Segundo 2: Se elige el índice 2 y se decrementa nums[2] en uno. nums pasa a ser [1,1].
Segundo 3: Elige el índice 2 y decrementa nums[2] en uno. nums pasa a ser [1,0].
Segundo 4: Marca el índice changeIndices[4], que está marcando el índice 2, ya que nums[2] es igual a 0.
Segundo 5: Elige el índice 1 y decrementa nums[1] en uno. nums pasa a ser [0,0].
Segundo 6: Marca el índice changeIndices[6], que está marcando el índice 1, ya que nums[1] es igual a 0.
Ahora se han marcado todos los índices.
Se puede demostrar que no es posible marcar todos los índices antes del sexto segundo.
Por lo tanto, la respuesta es 6.

Ejemplo 3:

Entrada: nums = [0,1], changeIndices = [2,2,2]
Salida: -1
Explicación: En este ejemplo, es imposible marcar todos los índices porque el índice 1 no está en changeIndices.
Por lo tanto, la respuesta es -1.

Restricciones:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

Se le proporcionan dos matrices de enteros indexados en 1, nums y changeIndices, que tienen longitudes n y m, respectivamente.
Inicialmente, todos los índices en nums no están marcados. Su tarea es marcar todos los índices en nums.
En cada segundo, s, en orden de 1 a m (inclusive), puede realizar una de las siguientes operaciones:

Elija un índice i en el rango [1, n] y decremente nums[i] en 1.
Si nums[changeIndices[s]] es igual a 0, marque el índice changeIndices[s].
No haga nada.

Devuelva un entero que denote el segundo más temprano en el rango [1, m] cuando todos los índices en nums se puedan marcar eligiendo operaciones de manera óptima, o -1 si es imposible.

Ejemplo 1:

Entrada: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Salida: 8
Explicación: En este ejemplo, tenemos 8 segundos. Se pueden realizar las siguientes operaciones para marcar todos los índices:
Segundo 1: Elija el índice 1 y decremente nums[1] en uno. nums se convierte en [1,2,0].
Segundo 2: Elija el índice 1 y decremente nums[1] en uno. nums se convierte en [0,2,0].
Segundo 3: Elija el índice 2 y decremente nums[2] en uno. nums se convierte en [0,1,0].
Segundo 4: Elija el índice 2 y decremente nums[2] en uno. nums se convierte en [0,0,0].
Segundo 5: Marcar el índice changeIndices[5], que marca el índice 3, ya que nums[3] es igual a 0.
Segundo 6: Marcar el índice changeIndices[6], que marca el índice 2, ya que nums[2] es igual a 0.
Segundo 7: No hacer nada.
Segundo 8: Marcar el índice changeIndices[8], que marca el índice 1, ya que nums[1] es igual a 0.
Ahora se han marcado todos los índices.
Se puede demostrar que no es posible marcar todos los índices antes del octavo segundo.
Por lo tanto, la respuesta es 8.

Ejemplo 2:

Entrada: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Salida: 6
Explicación: En este ejemplo, tenemos 7 segundos. Las siguientes operaciones se pueden realizar para marcar todos los índices:
Segundo 1: Elija el índice 2 y disminuya nums[2] en uno. nums se convierte en [1,2].
Segundo 2: Elija el índice 2 y disminuya nums[2] en uno. nums se convierte en [1,1].
Segundo 3: Elija el índice 2 y disminuya nums[2] en uno. nums se convierte en [1,0].
Segundo 4: Marque el índice changeIndices[4], que marca el índice 2, ya que nums[2] es igual a 0.
Segundo 5: Elija el índice 1 y disminuya nums[1] en uno. nums se convierte en [0,0].
Segundo 6: Marque el índice changeIndices[6], que marca el índice 1, ya que nums[1] es igual a 0.
Ahora se han marcado todos los índices.
Se puede demostrar que no es posible marcar todos los índices antes del sexto segundo.
Por lo tanto, la respuesta es 6.

Ejemplo 3:

Entrada: nums = [0,1], changeIndices = [2,2,2]
Salida: -1
Explicación: En este ejemplo, es imposible marcar todos los índices porque el índice 1 no está en changeIndices.
Por lo tanto, la respuesta es -1.

Restricciones:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n


Se te da una cadena `word` indexada en 0 y un entero `k`.
Cada segundo, debes realizar las siguientes operaciones:

Elimina los primeros `k` caracteres de `word`.
Agrega cualquier `k` caracteres al final de `word`.

Ten en cuenta que no es necesario agregar los mismos caracteres que eliminaste. Sin embargo, debes realizar ambas operaciones cada segundo.
Devuelve el tiempo mínimo mayor que cero requerido para que `word` vuelva a su estado inicial.

Ejemplo 1:

Entrada: word = "abacaba", k = 3
Salida: 2
Explicación: En el primer segundo, eliminamos los caracteres "aba" del prefijo de `word`, y agregamos los caracteres "bac" al final de `word`. Así, `word` se convierte en "cababac".
En el segundo segundo, eliminamos los caracteres "cab" del prefijo de `word`, y agregamos "aba" al final de `word`. Así, `word` se convierte en "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 2 segundos es el tiempo mínimo mayor que cero requerido para que `word` vuelva a su estado inicial.

Ejemplo 2:

Entrada: word = "abacaba", k = 4
Salida: 1
Explicación: En el primer segundo, eliminamos los caracteres "abac" del prefijo de `word`, y agregamos los caracteres "caba" al final de `word`. Así, `word` se convierte en "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 1 segundo es el tiempo mínimo mayor que cero requerido para que `word` vuelva a su estado inicial.

Ejemplo 3:

Entrada: word = "abcbabcd", k = 2
Salida: 4
Explicación: Cada segundo, eliminaremos los primeros 2 caracteres de `word`, y agregaremos los mismos caracteres al final de `word`.
Después de 4 segundos, `word` se convierte en "abcbabcd" y vuelve a su estado inicial.
Se puede demostrar que 4 segundos es el tiempo mínimo mayor que cero requerido para que `word` vuelva a su estado inicial.

Restricciones:

1 <= word.length <= 50
1 <= k <= word.length
`word` consiste solo en letras minúsculas del alfabeto inglés.

Se le proporciona una cadena indexada en 0, palabra, y un entero k.
En cada segundo, debe realizar las siguientes operaciones:

Eliminar los primeros k caracteres de palabra.
Agregar k caracteres al final de palabra.

Tenga en cuenta que no necesariamente necesita agregar los mismos caracteres que eliminó. Sin embargo, debe realizar ambas operaciones en cada segundo.
Devuelva el tiempo mínimo mayor que cero requerido para que palabra vuelva a su estado inicial.

Ejemplo 1:

Entrada: word = "abacaba", k = 3
Salida: 2
Explicación: En el primer segundo, eliminamos los caracteres "aba" del prefijo de palabra y agregamos los caracteres "bac" al final de palabra. Por lo tanto, palabra se vuelve igual a "cababac".
En el segundo segundo, eliminamos los caracteres "cab" del prefijo de palabra y agregamos "aba" al final de palabra. Por lo tanto, palabra se vuelve igual a "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 2 segundos es el tiempo mínimo mayor que cero que se requiere para que la palabra vuelva a su estado inicial.

Ejemplo 2:

Entrada: word = "abacaba", k = 4
Salida: 1
Explicación: En el primer segundo, eliminamos los caracteres "abac" del prefijo de palabra y agregamos los caracteres "caba" al final de palabra. Por lo tanto, palabra se vuelve igual a "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 1 segundo es el tiempo mínimo mayor que cero que se requiere para que palabra vuelva a su estado inicial.

Ejemplo 3:

Entrada: word = "abcbabcd", k = 2
Salida: 4
Explicación: Cada segundo, eliminaremos los primeros 2 caracteres de palabra y agregaremos los mismos caracteres al final de palabra.
Después de 4 segundos, palabra se vuelve igual a "abcbabcd" y vuelve a su estado inicial.
Se puede demostrar que 4 segundos es el tiempo mínimo mayor que cero que se requiere para que una palabra vuelva a su estado inicial.

Restricciones:

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

Se te da una cadena word indexada en 0 y un entero k.
Cada segundo, debes realizar las siguientes operaciones:

Elimina los primeros k caracteres de word.
Agrega cualquier k caracteres al final de word.

Ten en cuenta que no es necesario agregar los mismos caracteres que eliminaste. Sin embargo, debes realizar ambas operaciones cada segundo.
Devuelve el tiempo mínimo mayor que cero requerido para que word vuelva a su estado inicial.

Ejemplo 1:

Entrada: word = "abacaba", k = 3
Salida: 2
Explicación: En el primer segundo, eliminamos los caracteres "aba" del prefijo de word, y agregamos los caracteres "bac" al final de word. Así, word se convierte en "cababac".
En el segundo segundo, eliminamos los caracteres "cab" del prefijo de word, y agregamos "aba" al final de word. Así, word se convierte en "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 2 segundos es el tiempo mínimo mayor que cero requerido para que word vuelva a su estado inicial.

Ejemplo 2:

Entrada: word = "abacaba", k = 4
Salida: 1
Explicación: En el primer segundo, eliminamos los caracteres "abac" del prefijo de word, y agregamos los caracteres "caba" al final de word. Así, word se convierte en "abacaba" y vuelve a su estado inicial.
Se puede demostrar que 1 segundo es el tiempo mínimo mayor que cero requerido para que word vuelva a su estado inicial.

Ejemplo 3:

Entrada: word = "abcbabcd", k = 2
Salida: 4
Explicación: Cada segundo, eliminaremos los primeros 2 caracteres de word, y agregaremos los mismos caracteres al final de word.
Después de 4 segundos, word se convierte en "abcbabcd" y vuelve a su estado inicial.
Se puede demostrar que 4 segundos es el tiempo mínimo mayor que cero requerido para que word vuelva a su estado inicial.

Restricciones:

1 <= word.length <= 50
1 <= k <= word.length
word consiste solo en letras minúsculas del alfabeto inglés.


Dado un array indexado desde cero `nums` que consta de enteros positivos.
Inicialmente, puedes aumentar el valor de cualquier elemento del array en como máximo 1.
Después de eso, necesitas seleccionar uno o más elementos del array final de manera que esos elementos sean consecutivos cuando se ordenen en orden creciente. Por ejemplo, los elementos [3, 4, 5] son consecutivos, mientras que [3, 4, 6] y [1, 1, 2, 3] no lo son.
Devuelve el número máximo de elementos que puedes seleccionar.

Ejemplo 1:

Entrada: nums = [2,1,5,1,1]
Salida: 3
Explicación: Podemos aumentar los elementos en los índices 0 y 3. El array resultante es nums = [3,1,5,2,1].
Seleccionamos los elementos [3,1,5,2,1] y los ordenamos para obtener [1,2,3], que son consecutivos.
Se puede demostrar que no podemos seleccionar más de 3 elementos consecutivos.
Ejemplo 2:

Entrada: nums = [1,4,7,10]
Salida: 1
Explicación: El máximo de elementos consecutivos que podemos seleccionar es 1.

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums que consta de números enteros positivos.
Inicialmente, puede aumentar el valor de cualquier elemento de la matriz en 1 como máximo.
Después de eso, debe seleccionar uno o más elementos de la matriz final de modo que esos elementos sean consecutivos cuando se ordenan en orden creciente. Por ejemplo, los elementos [3, 4, 5] son consecutivos mientras que [3, 4, 6] y [1, 1, 2, 3] no lo son.
Devuelve el número máximo de elementos que puede seleccionar.

Ejemplo 1:

Entrada: nums = [2,1,5,1,1]
Salida: 3
Explicación: Podemos aumentar los elementos en los índices 0 y 3. La matriz resultante es nums = [3,1,5,2,1].
Seleccionamos los elementos [3,1,5,2,1] y los ordenamos para obtener [1,2,3], que son consecutivos.
Se puede demostrar que no podemos seleccionar más de 3 elementos consecutivos.
Ejemplo 2:

Entrada: nums = [1,4,7,10]
Salida: 1
Explicación: El máximo de elementos consecutivos que podemos seleccionar es 1.

Restricciones:

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

Dado un array indexado desde cero nums que consta de enteros positivos.
Inicialmente, puedes aumentar el valor de cualquier elemento del array en como máximo 1.
Después de eso, necesitas seleccionar uno o más elementos del array final de manera que esos elementos sean consecutivos cuando se ordenen en orden creciente. Por ejemplo, los elementos [3, 4, 5] son consecutivos, mientras que [3, 4, 6] y [1, 1, 2, 3] no lo son.
Devuelve el número máximo de elementos que puedes seleccionar.

Ejemplo 1:

Input: nums = [2,1,5,1,1]
Output: 3
Explicación: Podemos aumentar los elementos en los índices 0 y 3. El array resultante es nums = [3,1,5,2,1].
Seleccionamos los elementos [3,1,5,2,1] y los ordenamos para obtener [1,2,3], que son consecutivos.
Se puede demostrar que no podemos seleccionar más de 3 elementos consecutivos.
Ejemplo 2:

Input: nums = [1,4,7,10]
Output: 1
Explicación: El máximo de elementos consecutivos que podemos seleccionar es 1.

Restricciones:

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


Se te da un array de enteros positivos nums.
Necesitas seleccionar un subconjunto de nums que satisfaga la siguiente condición:

Puedes colocar los elementos seleccionados en un array indexado a 0 de tal manera que siga el patrón: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Nota que k puede ser cualquier potencia no negativa de 2). Por ejemplo, [2, 4, 16, 4, 2] y [3, 9, 3] siguen el patrón, mientras que [2, 4, 8, 4, 2] no lo sigue.

Devuelve el número máximo de elementos en un subconjunto que satisfaga estas condiciones.

Ejemplo 1:

Entrada: nums = [5,4,1,2,2]
Salida: 3
Explicación: Podemos seleccionar el subconjunto {4,2,2}, que puede colocarse en el array como [2,4,2], que sigue el patrón y 2^2 == 4. Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: nums = [1,3,2,4]
Salida: 1
Explicación: Podemos seleccionar el subconjunto {1}, que puede colocarse en el array como [1], que sigue el patrón. Por lo tanto, la respuesta es 1. Nota que también podríamos haber seleccionado los subconjuntos {2}, {4} o {3}, puede haber múltiples subconjuntos que proporcionen la misma respuesta.

Restricciones:

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

Se le da una matriz de números enteros positivos.
Tienes que seleccionar un subconjunto de nums que satisfaga la siguiente condición:

Puede colocar los elementos seleccionados en una matriz de índice 0 de tal manera que siga el patrón: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Tenga en cuenta que k puede ser cualquier potencia no negativa de 2). Por ejemplo, [2, 4, 16, 4, 2] y [3, 9, 3] siguen el patrón, mientras que [2, 4, 8, 4, 2] no.

Devuelve el número máximo de elementos de un subconjunto que cumpla estas condiciones.

Ejemplo 1:

Entrada: nums = [5,4,1,2,2]
Salida: 3
Explicación: Podemos seleccionar el subconjunto {4,2,2}, que se puede colocar en el array como [2,4,2] que sigue el patrón y 2^2 == 4. Por lo tanto la respuesta es 3.

Ejemplo 2:

Entrada: nums = [1,3,2,4]
Salida: 1
Explicación: Podemos seleccionar el subconjunto {1}, que se puede colocar en la matriz como [1] que sigue el patrón. Por lo tanto, la respuesta es 1. Tenga en cuenta que también podríamos haber seleccionado los subconjuntos {2}, {4}, o {3}, puede haber múltiples subconjuntos que proporcionan la misma respuesta.

Restricciones:

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

Se te da un arreglo de enteros positivos nums.
Necesitas seleccionar un subconjunto de nums que satisfaga la siguiente condición:

Puedes colocar los elementos seleccionados en un arreglo indexado a 0 de tal manera que siga el patrón: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Nota que k puede ser cualquier potencia no negativa de 2). Por ejemplo, [2, 4, 16, 4, 2] y [3, 9, 3] siguen el patrón, mientras que [2, 4, 8, 4, 2] no lo sigue.

Devuelve el número máximo de elementos en un subconjunto que satisfaga estas condiciones.

Ejemplo 1:

Entrada: nums = [5,4,1,2,2]
Salida: 3
Explicación: Podemos seleccionar el subconjunto {4,2,2}, que puede colocarse en el arreglo como [2,4,2] que sigue el patrón y 2^2 == 4. Por lo tanto la respuesta es 3.

Ejemplo 2:

Entrada: nums = [1,3,2,4]
Salida: 1
Explicación: Podemos seleccionar el subconjunto {1}, que puede colocarse en el arreglo como [1] que sigue el patrón. Por lo tanto la respuesta es 1. Nota que también podríamos haber seleccionado los subconjuntos {2}, {4} o {3}, puede haber múltiples subconjuntos que proporcionen la misma respuesta.

Restricciones:

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


Se te da una cadena s.
Considera realizar la siguiente operación hasta que s quede vacía:

Para cada carácter alfabético de 'a' a 'z', elimina la primera aparición de ese carácter en s (si existe).

Por ejemplo, inicialmente s = "aabcbbca". Realizamos las siguientes operaciones:

Elimina los caracteres subrayados s = "aabcbbca". La cadena resultante es s = "abbca".
Elimina los caracteres subrayados s = "abbca". La cadena resultante es s = "ba".
Elimina los caracteres subrayados s = "ba". La cadena resultante es s = "".

Devuelve el valor de la cadena s justo antes de aplicar la última operación. En el ejemplo anterior, la respuesta es "ba".

Ejemplo 1:

Entrada: s = "aabcbbca"
Salida: "ba"
Explicación: Explicado en el enunciado.

Ejemplo 2:

Entrada: s = "abcd"
Salida: "abcd"
Explicación: Realizamos la siguiente operación:
- Elimina los caracteres subrayados s = "abcd". La cadena resultante es s = "".
La cadena justo antes de la última operación es "abcd".

Restricciones:

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

Se le proporciona una cadena s.
Considere realizar la siguiente operación hasta que s quede vacía:

Para cada carácter del alfabeto desde 'a' hasta 'z', elimine la primera aparición de ese carácter en s (si existe).

Por ejemplo, supongamos que inicialmente s = "aabcbbca". Realizamos las siguientes operaciones:

Eliminamos los caracteres subrayados s = "aabcbbca". La cadena resultante es s = "abbca".
Eliminamos los caracteres subrayados s = "abbca". La cadena resultante es s = "ba".
Eliminamos los caracteres subrayados s = "ba". La cadena resultante es s = "".

Devuelve el valor de la cadena s justo antes de aplicar la última operación. En el ejemplo anterior, la respuesta es "ba".

Ejemplo 1:

Entrada: s = "aabcbbca"
Salida: "ba"
Explicación: Se explica en la declaración.

Ejemplo 2:

Entrada: s = "abcd"
Salida: "abcd"
Explicación: Realizamos la siguiente operación:
- Eliminamos los caracteres subrayados s = "abcd". La cadena resultante es s = "".
La cadena justo antes de la última operación es "abcd".

Restricciones:

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

Se te da una cadena s.
Considera realizar la siguiente operación hasta que s quede vacía:

Para cada carácter alfabético de 'a' a 'z', elimina la primera aparición de ese carácter en s (si existe).

Por ejemplo, inicialmente s = "aabcbbca". Realizamos las siguientes operaciones:

Elimina los caracteres subrayados s = "aabcbbca". La cadena resultante es s = "abbca".
Elimina los caracteres subrayados s = "abbca". La cadena resultante es s = "ba".
Elimina los caracteres subrayados s = "ba". La cadena resultante es s = "".

Devuelve el valor de la cadena s justo antes de aplicar la última operación. En el ejemplo anterior, la respuesta es "ba".

Ejemplo 1:

Entrada: s = "aabcbbca"
Salida: "ba"
Explicación: Explicado en el enunciado.

Ejemplo 2:

Entrada: s = "abcd"
Salida: "abcd"
Explicación: Realizamos la siguiente operación:
Elimina los caracteres subrayados s = "abcd". La cadena resultante es s = "".
La cadena justo antes de la última operación es "abcd".

Restricciones:

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


Se te da un array de cadenas indexado desde 0, `words`.
Definamos una función booleana `isPrefixAndSuffix` que toma dos cadenas, `str1` y `str2`:

`isPrefixAndSuffix(str1, str2)` devuelve verdadero si `str1` es tanto un prefijo como un sufijo de `str2`, y falso en caso contrario.

Por ejemplo, `isPrefixAndSuffix("aba", "ababa")` es verdadero porque "aba" es un prefijo de "ababa" y también un sufijo, pero `isPrefixAndSuffix("abc", "abcd")` es falso.
Devuelve un entero que indica el número de pares de índices \((i, j)\) tales que \(i < j\), y `isPrefixAndSuffix(words[i], words[j])` es verdadero.

Ejemplo 1:

Entrada: words = ["a","aba","ababa","aa"]
Salida: 4
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque `isPrefixAndSuffix("a", "aba")` es verdadero.
i = 0 y j = 2 porque `isPrefixAndSuffix("a", "ababa")` es verdadero.
i = 0 y j = 3 porque `isPrefixAndSuffix("a", "aa")` es verdadero.
i = 1 y j = 2 porque `isPrefixAndSuffix("aba", "ababa")` es verdadero.
Por lo tanto, la respuesta es 4.

Ejemplo 2:

Entrada: words = ["pa","papa","ma","mama"]
Salida: 2
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque `isPrefixAndSuffix("pa", "papa")` es verdadero.
i = 2 y j = 3 porque `isPrefixAndSuffix("ma", "mama")` es verdadero.
Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: words = ["abab","ab"]
Salida: 0
Explicación: En este ejemplo, el único par de índices válido es i = 0 y j = 1, y `isPrefixAndSuffix("abab", "ab")` es falso.
Por lo tanto, la respuesta es 0.

Restricciones:

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

Se le proporciona una matriz de cadenas indexada en 0, words.
Definamos una función booleana isPrefixAndSuffix que toma dos cadenas, str1 y str2:

isPrefixAndSuffix(str1, str2) devuelve verdadero si str1 es tanto un prefijo como un sufijo de str2, y falso en caso contrario.

Por ejemplo, isPrefixAndSuffix("aba", "ababa") es verdadero porque "aba" es un prefijo de "ababa" y también un sufijo, pero isPrefixAndSuffix("abc", "abcd") es falso.
Devuelve un entero que denota la cantidad de pares de índices (i, j) tales que i < j, e isPrefixAndSuffix(words[i], words[j]) es verdadero.

Ejemplo 1:

Entrada: palabras = ["a", "aba", "ababa", "aa"]
Salida: 4
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque isPrefixAndSuffix("a", "aba") es verdadero.
i = 0 y j = 2 porque isPrefixAndSuffix("a", "ababa") es verdadero.
i = 0 y j = 3 porque isPrefixAndSuffix("a", "aa") es verdadero.
i = 1 y j = 2 porque isPrefixAndSuffix("aba", "ababa") es verdadero.
Por lo tanto, la respuesta es 4.
Ejemplo 2:

Entrada: palabras = ["pa", "papa", "ma", "mama"]
Salida: 2
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque isPrefixAndSuffix("pa", "papa") es verdadero.
i = 2 y j = 3 porque isPrefixAndSuffix("ma", "mama") es verdadero.
Por lo tanto, la respuesta es 2.
Ejemplo 3:

Entrada: palabras = ["abab", "ab"]
Salida: 0
Explicación: En este ejemplo, el único par de índices válido es i = 0 y j = 1, e isPrefixAndSuffix("abab", "ab") es falso.
Por lo tanto, la respuesta es 0.

Restricciones:

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] consta únicamente de letras minúsculas en inglés.

Se te da un array de cadenas indexado desde 0, words.
Definamos una función booleana isPrefixAndSuffix que toma dos cadenas, str1 y str2:

isPrefixAndSuffix(str1, str2) devuelve verdadero si str1 es tanto un prefijo como un sufijo de str2, y falso en caso contrario.

Por ejemplo, isPrefixAndSuffix("aba", "ababa") es verdadero porque "aba" es un prefijo de "ababa" y también un sufijo, pero isPrefixAndSuffix("abc", "abcd") es falso.
Devuelve un entero que indica el número de pares de índices ((i, j)) tales que (i < j), y isPrefixAndSuffix(words[i], words[j]) es verdadero.

Ejemplo 1::

Entrada: words = ["a","aba","ababa","aa"]
Salida: 4
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque isPrefixAndSuffix("a", "aba") es verdadero.
i = 0 y j = 2 porque isPrefixAndSuffix("a", "ababa") es verdadero.
i = 0 y j = 3 porque isPrefixAndSuffix("a", "aa") es verdadero.
i = 1 y j = 2 porque isPrefixAndSuffix("aba", "ababa") es verdadero.
Por lo tanto, la respuesta es 4.
Ejemplo 2:

Entrada: words = ["pa","papa","ma","mama"]
Salida: 2
Explicación: En este ejemplo, los pares de índices contados son:
i = 0 y j = 1 porque isPrefixAndSuffix("pa", "papa") es verdadero.
i = 2 y j = 3 porque isPrefixAndSuffix("ma", "mama") es verdadero.
Por lo tanto, la respuesta es 2.
Ejemplo 3:

Entrada: words = ["abab","ab"]
Salida: 0
Explicación: En este ejemplo, el único par de índices válido es i = 0 y j = 1, y isPrefixAndSuffix("abab", "ab") es falso.
Por lo tanto, la respuesta es 0.

Restricciones:

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