Se te da un array indexado desde 0 de números enteros llamado nums, y un número entero target.
Devuelve la longitud de la subsecuencia más larga de nums que suma el valor target. Si no existe tal subsecuencia, devuelve -1.
Una subsecuencia es un array que puede derivarse de otro array eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5], target = 9
Salida: 3
Explicación: Hay 3 subsecuencias con una suma igual a 9: [4,5], [1,3,5] y [2,3,4]. Las subsecuencias más largas son [1,3,5] y [2,3,4]. Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: nums = [4,1,3,2,1,5], target = 7
Salida: 4
Explicación: Hay 5 subsecuencias con una suma igual a 7: [4,3], [4,1,2], [4,2,1], [1,1,5] y [1,3,2,1]. La subsecuencia más larga es [1,3,2,1]. Por lo tanto, la respuesta es 4.

Ejemplo 3:

Entrada: nums = [1,1,5,4,5], target = 3
Salida: -1
Explicación: Se puede demostrar que nums no tiene una subsecuencia que sume 3.

Restricciones:

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

Se le proporciona una matriz indexada en 0 de números enteros nums y un objetivo entero.
Devuelve la longitud de la subsecuencia más larga de nums que suma el objetivo. Si no existe dicha subsecuencia, devuelve -1.
Una subsecuencia es una matriz que se puede derivar de otra matriz eliminando algunos elementos o ninguno sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5], target = 9
Salida: 3
Explicación: Hay 3 subsecuencias con una suma igual a 9: [4,5], [1,3,5] y [2,3,4]. Las subsecuencias más largas son [1,3,5] y [2,3,4]. Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: nums = [4,1,3,2,1,5], target = 7
Salida: 4
Explicación: Hay 5 subsecuencias con una suma igual a 7: [4,3], [4,1,2], [4,2,1], [1,1,5] y [1,3,2,1]. La subsecuencia más larga es [1,3,2,1]. Por lo tanto, la respuesta es 4.

Ejemplo 3:

Entrada: nums = [1,1,5,4,5], target = 3
Salida: -1
Explicación: Se puede demostrar que nums no tiene ninguna subsecuencia que sume 3.

Restricciones:

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

Se te da un arreglo indexado desde 0 de números enteros llamado nums, y un número entero target.
Devuelve la longitud de la subsecuencia más larga de nums que suma el valor target. Si no existe tal subsecuencia, devuelve -1.
Una subsecuencia es un arreglo que puede derivarse de otro arreglo eliminando algunos o ningún elemento sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5], target = 9
Salida: 3
Explicación: Hay 3 subsecuencias con una suma igual a 9: [4,5], [1,3,5] y [2,3,4]. Las subsecuencias más largas son [1,3,5] y [2,3,4]. Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: nums = [4,1,3,2,1,5], target = 7
Salida: 4
Explicación: Hay 5 subsecuencias con una suma igual a 7: [4,3], [4,1,2], [4,2,1], [1,1,5] y [1,3,2,1]. La subsecuencia más larga es [1,3,2,1]. Por lo tanto, la respuesta es 4.

Ejemplo 3:

Entrada: nums = [1,1,5,4,5], target = 3
Salida: -1
Explicación: Se puede demostrar que nums no tiene una subsecuencia que sume 3.

Restricciones:

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


Se le proporciona una matriz indexada en 0 maxHeights de n enteros.
Se le ha encomendado la tarea de construir n torres en la línea de coordenadas. La i^ésima torre se construye en la coordenada i y tiene una altura de heights[i].
Una configuración de torres es hermosa si se cumplen las siguientes condiciones:

1 <= heights[i] <= maxHeights[i]
heights es una matriz de montaña.

La matriz heights es una montaña si existe un índice i tal que:

Para todos los 0 < j <= i, heights[j - 1] <= heights[j]
Para todos los i <= k < n - 1, heights[k + 1] <= heights[k]

Devuelva la suma máxima posible de alturas de una hermosa configuración de torres.

Ejemplo 1:

Entrada: maxHeights = [5,3,4,1,1]
Salida: 13
Explicación: Una hermosa configuración con una suma máxima es alturas = [5,3,3,1,1]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña con un pico i = 0.
Se puede demostrar que no existe otra hermosa configuración con una suma de alturas mayor que 13.
Ejemplo 2:

Entrada: maxHeights = [6,5,3,9,2,7]
Salida: 22
Explicación: Una hermosa configuración con una suma máxima es alturas = [3,3,3,9,2,2]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña de pico i = 3.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 22.
Ejemplo 3:

Entrada: maxHeights = [3,2,5,5,2,3]
Salida: 18
Explicación: Una configuración hermosa con una suma máxima es alturas = [2,2,5,5,2,2]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña de pico i = 2.
Obsérvese que, para esta configuración, i = 3 también puede considerarse un pico.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 18.

Restricciones:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Se te da un conjunto maxHeights de n enteros indexado desde 0.
Tienes la tarea de construir n torres en la línea de coordenadas. La torre i-ésima se construye en la coordenada i y tiene una altura de heights[i].
Una configuración de torres es hermosa si se cumplen las siguientes condiciones:

1 <= heights[i] <= maxHeights[i]
heights es un conjunto montaña.

El conjunto heights es una montaña si existe un índice i tal que:

Para todo 0 < j <= i, heights[j - 1] <= heights[j]
Para todo i <= k < n - 1, heights[k + 1] <= heights[k]

Devuelve la suma máxima posible de alturas de una configuración hermosa de torres.

Ejemplo 1:

Entrada: maxHeights = [5,3,4,1,1]
Salida: 13
Explicación: Una configuración hermosa con una suma máxima es heights = [5,3,3,1,1]. Esta configuración es hermosa ya que:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña con pico i = 0.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 13.
Ejemplo 2:

Entrada: maxHeights = [6,5,3,9,2,7]
Salida: 22
Explicación: Una configuración hermosa con una suma máxima es heights = [3,3,3,9,2,2]. Esta configuración es hermosa ya que:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña con pico i = 3.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 22.
Ejemplo 3:

Entrada: maxHeights = [3,2,5,5,2,3]
Salida: 18
Explicación: Una configuración hermosa con una suma máxima es heights = [2,2,5,5,2,2]. Esta configuración es hermosa ya que:
- 1 <= heights[i] <= maxHeights[i]
- heights es una montaña con pico i = 2.
Tenga en cuenta que, para esta configuración, i = 3 también puede ser considerado un pico.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 18.

Restricciones:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Se le proporciona una matriz indexada en 0 maxHeights de n enteros.
Se le ha encomendado la tarea de construir n torres en la línea de coordenadas. La i^ésima torre se construye en la coordenada i y tiene una altura de heights[i].
Una configuración de torres es hermosa si se cumplen las siguientes condiciones:

1 <= heights[i] <= maxHeights[i]
heights es una matriz de montaña.

La matriz heights es una montaña si existe un índice i tal que:

Para todos los 0 < j <= i, heights[j - 1] <= heights[j]
Para todos los i <= k < n - 1, heights[k + 1] <= heights[k]

Devuelva la suma máxima posible de alturas de una hermosa configuración de torres.

Ejemplo 1:

Entrada: maxHeights = [5,3,4,1,1]
Salida: 13
Explicación: Una hermosa configuración con una suma máxima es alturas = [5,3,3,1,1]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- alturas es una montaña con un pico i = 0.
Se puede demostrar que no existe otra hermosa configuración con una suma de alturas mayor que 13.
Ejemplo 2:

Entrada: maxHeights = [6,5,3,9,2,7]
Salida: 22
Explicación: Una hermosa configuración con una suma máxima es alturas = [3,3,3,9,2,2]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- alturas es una montaña de pico i = 3.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 22.
Ejemplo 3:

Entrada: alturasmáximas = [3,2,5,5,2,3]
Salida: 18
Explicación: Una configuración hermosa con una suma máxima es alturas = [2,2,5,5,2,2]. Esta configuración es hermosa porque:
- 1 <= heights[i] <= maxHeights[i]
- alturas es una montaña de pico i = 2.
Obsérvese que, para esta configuración, i = 3 también puede considerarse un pico.
Se puede demostrar que no existe otra configuración hermosa con una suma de alturas mayor que 18.

Restricciones:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9


Se te da un array nums indexado desde cero y un entero target.
Un array infinite_nums indexado desde cero se genera al agregar infinitamente los elementos de nums sobre sí mismo.
Devuelve la longitud del subarray más corto del array infinite_nums con una suma igual a target. Si no existe tal subarray, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,2,3], target = 5
Salida: 2
Explicación: En este ejemplo infinite_nums = [1,2,3,1,2,3,1,2,...].
El subarray en el rango [1,2], tiene la suma igual a target = 5 y longitud = 2.
Se puede demostrar que 2 es la longitud más corta de un subarray con suma igual a target = 5.

Ejemplo 2:

Entrada: nums = [1,1,1,2,3], target = 4
Salida: 2
Explicación: En este ejemplo infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
El subarray en el rango [4,5], tiene la suma igual a target = 4 y longitud = 2.
Se puede demostrar que 2 es la longitud más corta de un subarray con suma igual a target = 4.

Ejemplo 3:

Entrada: nums = [2,4,6,8], target = 3
Salida: -1
Explicación: En este ejemplo infinite_nums = [2,4,6,8,2,4,6,8,...].
Se puede demostrar que no existe ningún subarray con suma igual a target = 3.

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums y un entero target.
Una matriz indexada en 0 infinite_nums se genera añadiendo infinitamente los elementos de nums a sí misma.
Devuelve la longitud de la submatriz más corta de la matriz infinite_nums con una suma igual a target. Si no existe dicha submatriz, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,2,3], target = 5
Salida: 2
Explicación: En este ejemplo infinite_nums = [1,2,3,1,2,3,1,2,...].
El subarreglo en el rango [1,2] tiene una suma igual a target = 5 y una longitud = 2.
Se puede demostrar que 2 es la longitud más corta de un subarreglo con una suma igual a target = 5.

Ejemplo 2:

Entrada: nums = [1,1,1,2,3], target = 4
Salida: 2
Explicación: En este ejemplo, infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
El subarreglo en el rango [4,5] tiene una suma igual a target = 4 y una longitud = 2.
Se puede demostrar que 2 es la longitud más corta de un subarreglo con una suma igual a target = 4.

Ejemplo 3:

Entrada: nums = [2,4,6,8], target = 3
Salida: -1
Explicación: En este ejemplo, infinite_nums = [2,4,6,8,2,4,6,8,...].
Se puede demostrar que no existe ningún subarreglo con una suma igual a target = 3.

Restricciones:

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


Se le proporciona una cadena binaria s y un entero positivo k.
Una subcadena de s es hermosa si la cantidad de 1 que contiene es exactamente k.
Sea len la longitud de la subcadena hermosa más corta.
Devuelva la subcadena hermosa lexicográficamente más pequeña de la cadena s con una longitud igual a len. Si s no contiene una subcadena hermosa, devuelva una cadena vacía.
Una cadena a es lexicográficamente más grande que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, a tiene un carácter estrictamente más grande que el carácter correspondiente en b.

Por ejemplo, "abcd" es lexicográficamente más grande que "abcc" porque la primera posición en la que difieren es en el cuarto carácter, y d es mayor que c.

Ejemplo 1:

Entrada: s = "100011001", k = 3
Salida: "11001"
Explicación: Hay 7 subcadenas hermosas en este ejemplo:
1. La subcadena "100011001".
2. La subcadena "100011001".
3. La subcadena "100011001".
4. La subcadena "100011001".
5. La subcadena "100011001".
6. La subcadena "100011001".
7. La subcadena "100011001".
La longitud de la subcadena hermosa más corta es 5.
La subcadena hermosa lexicográficamente más pequeña con una longitud de 5 es la subcadena "11001".

Ejemplo 2:

Entrada: s = "1011", k = 2
Salida: "11"
Explicación: Hay 3 subcadenas hermosas en este ejemplo:
1. La subcadena "1011".
2. La subcadena "1011".
3. La subcadena "1011".
La longitud de la subcadena hermosa más corta es 2.
La subcadena hermosa lexicográficamente más pequeña con una longitud de 2 es la subcadena "11".

Ejemplo 3:

Entrada: s = "000", k = 1
Salida: ""
Explicación: No hay subcadenas hermosas en este ejemplo.

Restricciones:

1 <= s.length <= 100
1 <= k <= s.length

Se te da una cadena binaria s y un entero positivo k.
Una subcadena de s es hermosa si el número de 1's en ella es exactamente k.
Sea len la longitud de la subcadena hermosa más corta.
Devuelve la subcadena hermosa más pequeña lexicográficamente de la cadena s con longitud igual a len. Si s no contiene una subcadena hermosa, devuelve una cadena vacía.
Una cadena a es lexicográficamente mayor que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, a tiene un carácter estrictamente mayor que el correspondiente carácter en b.

Por ejemplo, "abcd" es lexicográficamente mayor que "abcc" porque la primera posición donde difieren es en el cuarto carácter, y d es mayor que c.

Ejemplo 1:

Entrada: s = "100011001", k = 3
Salida: "11001"
Explicación: Hay 7 subcadenas hermosas en este ejemplo:
1. La subcadena "100011001".
2. La subcadena "100011001".
3. La subcadena "100011001".
4. La subcadena "100011001".
5. La subcadena "100011001".
6. La subcadena "100011001".
7. La subcadena "100011001".
La longitud de la subcadena hermosa más corta es 5.
La subcadena hermosa más pequeña lexicográficamente con longitud 5 es la subcadena "11001".

Ejemplo 2:

Entrada: s = "1011", k = 2
Salida: "11"
Explicación: Hay 3 subcadenas hermosas en este ejemplo:
1. La subcadena "1011".
2. La subcadena "1011".
3. La subcadena "1011".
La longitud de la subcadena hermosa más corta es 2.
La subcadena hermosa más pequeña lexicográficamente con longitud 2 es la subcadena "11".

Ejemplo 3:

Entrada: s = "000", k = 1
Salida: ""
Explicación: No hay subcadenas hermosas en este ejemplo.

Restricciones:

1 <= s.length <= 100
1 <= k <= s.length

Se le da una cadena binaria s y un entero positivo k.
Una subcadena de s es hermosa si el número de 1 en ella es exactamente k.
Sea len la longitud de la subcadena más corta y hermosa.
Devuelva la hermosa subcadena lexicográficamente más pequeña de la cadena s con una longitud igual a len. Si s no contiene una subcadena hermosa, devuelve una cadena vacía.
Una cadena a es lexicográficamente más grande que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, a tiene un carácter estrictamente mayor que el carácter correspondiente en b.

Por ejemplo, "abcd" es lexicográficamente mayor que "abcc" porque la primera posición en la que difieren es en el cuarto carácter, y d es mayor que c.

Ejemplo 1:

Entrada: s = "100011001", k = 3
Salida: "11001"
Explicación: Hay 7 hermosas subcadenas en este ejemplo:
1. La subcadena "100011001".
2. La subcadena "100011001".
3. La subcadena "100011001".
4. La subcadena "100011001".
5. La subcadena "100011001".
6. La subcadena "100011001".
7. La subcadena "100011001".
La longitud de la subcuerda hermosa más corta es 5.
La subcadena hermosa lexicográficamente más pequeña con una longitud de 5 es la subcadena "11001".

Ejemplo 2:

Entrada: s = "1011", k = 2
Salida: "11"
Explicación: Hay 3 hermosas subcadenas en este ejemplo:
1. La subcadena "1011".
2. La subcadena "1011".
3. La subcadena "1011".
La longitud de la subcadena más corta es 2.
La hermosa subcadena lexicográficamente más pequeña con una longitud de 2 es la subcadena "11".

Ejemplo 3:

Entrada: s = "000", k = 1
Producción: ""
Explicación: No hay subcadenas hermosas en este ejemplo.

Restricciones:

1 <= s.longitud <= 100
1 <= k <= s.longitud


Tiene n procesadores, cada uno con 4 núcleos y n * 4 tareas que deben ejecutarse de modo que cada núcleo debe realizar solo una tarea.
Dado un arreglo de enteros indexado en 0, processorTime, que representa el momento en el que cada procesador se vuelve disponible por primera vez, y un arreglo de enteros indexado en 0, tasks, que representa el tiempo que lleva ejecutar cada tarea, devuelva el tiempo mínimo en el que todos los procesadores han ejecutado las tareas.
Nota: Cada núcleo ejecuta la tarea independientemente de los demás.

Ejemplo 1:

Entrada: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Salida: 16
Explicación:
Es óptimo asignar las tareas en los índices 4, 5, 6, 7 al primer procesador que esté disponible en el tiempo = 8, y las tareas en los índices 0, 1, 2, 3 al segundo procesador que esté disponible en el tiempo = 10.
Tiempo que tarda el primer procesador en terminar la ejecución de todas las tareas = máx(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Tiempo que tarda el segundo procesador en terminar la ejecución de todas las tareas = máx(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Por lo tanto, se puede demostrar que el tiempo mínimo que tarda en ejecutarse todas las tareas es 16.
Ejemplo 2:

Entrada: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Salida: 23
Explicación:
Es óptimo asignar las tareas en los índices 1, 4, 5, 6 al primer procesador que esté disponible en el tiempo = 10, y las tareas en los índices 0, 2, 3, 7 al segundo procesador que esté disponible en el tiempo = 20.
Tiempo que tarda el primer procesador en terminar la ejecución de todas las tareas = máx(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Tiempo que tarda el segundo procesador en terminar la ejecución de todas las tareas = máx(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Por lo tanto, se puede demostrar que el tiempo mínimo que se tarda en ejecutar todas las tareas es 23.

Restricciones:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

Tiene n procesadores, cada uno con 4 núcleos y n * 4 tareas que deben ejecutarse de modo que cada núcleo debe realizar solo una tarea.
Dado un arreglo de enteros indexado en 0, processTime, que representa el momento en el que cada procesador se vuelve disponible por primera vez, y un arreglo de enteros indexado en 0, task, que representa el tiempo que lleva ejecutar cada tarea, devuelva el tiempo mínimo en el que todos los procesadores han ejecutado las tareas.
Nota: Cada núcleo ejecuta la tarea independientemente de los demás.

Ejemplo 1:

Entrada: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Salida: 16
Explicación:
Es óptimo asignar las tareas en los índices 4, 5, 6, 7 al primer procesador que esté disponible en el tiempo = 8, y las tareas en los índices 0, 1, 2, 3 al segundo procesador que esté disponible en el tiempo = 10.
Tiempo que tarda el primer procesador en terminar la ejecución de todas las tareas = máx(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Tiempo que tarda el segundo procesador en terminar la ejecución de todas las tareas = máx(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Por lo tanto, se puede demostrar que el tiempo mínimo que tarda en ejecutarse todas las tareas es 16.
Ejemplo 2:

Entrada: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Salida: 23
Explicación:
Es óptimo asignar las tareas en los índices 1, 4, 5, 6 al primer procesador que se vuelve disponible en el tiempo = 10, y las tareas en los índices 0, 2, 3, 7 al segundo procesador que se vuelve disponible en el tiempo = 20.
Tiempo que tarda el primer procesador en terminar la ejecución de todas las tareas = máx(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Tiempo que tarda el segundo procesador en terminar la ejecución de todas las tareas = máx(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Por lo tanto, se puede demostrar que el tiempo mínimo que se tarda en ejecutar todas las tareas es 23.

Restricciones:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

Tienes n procesadores, cada uno con 4 núcleos y n * 4 tareas que necesitan ser ejecutadas de tal manera que cada núcleo realice solo una tarea.
Dado un array de enteros indexado desde 0, processorTime, que representa el momento en que cada procesador se convierte en disponible por primera vez, y un array de enteros indexado desde 0, tasks, que representa el tiempo que lleva ejecutar cada tarea, devuelve el tiempo mínimo en el que todas las tareas han sido ejecutadas por los procesadores.
Nota: Cada núcleo ejecuta la tarea de manera independiente de los demás.

Ejemplo 1:

Entrada: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Salida: 16
Explicación:
Es óptimo asignar las tareas en los índices 4, 5, 6, 7 al primer procesador, que se hace disponible en el tiempo = 8, y las tareas en los índices 0, 1, 2, 3 al segundo procesador, que se hace disponible en el tiempo = 10.
Tiempo tomado por el primer procesador para terminar la ejecución de todas las tareas = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Tiempo tomado por el segundo procesador para terminar la ejecución de todas las tareas = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Por lo tanto, se puede demostrar que el tiempo mínimo para ejecutar todas las tareas es 16.

Ejemplo 2:

Entrada: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Salida: 23
Explicación:
Es óptimo asignar las tareas en los índices 1, 4, 5, 6 al primer procesador, que se hace disponible en el tiempo = 10, y las tareas en los índices 0, 2, 3, 7 al segundo procesador, que se hace disponible en el tiempo = 20.
Tiempo tomado por el primer procesador para terminar la ejecución de todas las tareas = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Tiempo tomado por el segundo procesador para terminar la ejecución de todas las tareas = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Por lo tanto, se puede demostrar que el tiempo mínimo para ejecutar todas las tareas es 23.

Restricciones:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


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

Elige dos índices distintos i y j y actualiza simultáneamente los valores de nums[i] a (nums[i] AND nums[j]) y nums[j] a (nums[i] OR nums[j]). Aquí, OR denota la operación bitwise OR, y AND denota la operación bitwise AND.

Debes elegir k elementos del arreglo final y calcular la suma de sus cuadrados.
Devuelve la suma máxima de cuadrados que puedes lograr.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,6,5,8], k = 2
Salida: 261
Explicación: Podemos hacer las siguientes operaciones en el arreglo:
- Elige i = 0 y j = 3, luego cambia nums[0] a (2 AND 8) = 0 y nums[3] a (2 OR 8) = 10. El arreglo resultante es nums = [0,6,5,10].
- Elige i = 2 y j = 3, luego cambia nums[2] a (5 AND 10) = 0 y nums[3] a (5 OR 10) = 15. El arreglo resultante es nums = [0,6,0,15].
Podemos elegir los elementos 15 y 6 del arreglo final. La suma de los cuadrados es 15^2 + 6^2 = 261.
Se puede demostrar que este es el valor máximo que podemos obtener.

Ejemplo 2:

Entrada: nums = [4,5,4,7], k = 3
Salida: 90
Explicación: No necesitamos aplicar ninguna operación.
Podemos elegir los elementos 7, 5 y 4 con una suma de cuadrados: 7^2 + 5^2 + 4^2 = 90.
Se puede demostrar que este es el valor máximo que podemos obtener.

Restricciones:

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

Se le proporciona una matriz de enteros indexada 0 nums y un entero positivo k.
Puede realizar la siguiente operación en la matriz cualquier número de veces:

Elija dos índices distintos i y j y actualice simultáneamente los valores de nums[i] a (nums[i] AND nums[j]) y nums[j] a (nums[i] OR nums[j]). Aquí, OR denota la operación OR bit a bit, y AND denota la operación AND bit a bit.

Tienes que elegir k elementos de la matriz final y calcular la suma de sus cuadrados.
Devuelve la suma máxima de cuadrados que puedes lograr.
Dado que la respuesta puede ser muy grande, devuélvala módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,6,5,8], k = 2
Salida: 261
Explicación: Podemos hacer las siguientes operaciones en la matriz:
- Elija i = 0 y j = 3, luego cambie nums[0] a (2 AND 8) = 0 y nums[3] a (2 OR 8) = 10. La matriz resultante es nums = [0,6,5,10].
- Elija i = 2 y j = 3, luego cambie nums[2] a (5 AND 10) = 0 y nums[3] a (5 OR 10) = 15. La matriz resultante es nums = [0,6,0,15].
Podemos elegir los elementos 15 y 6 de la matriz final. La suma de cuadrados es 15^2 + 6^2 = 261.
Se puede demostrar que este es el valor máximo que podemos obtener.

Ejemplo 2:

Entrada: nums = [4,5,4,7], k = 3
Salida: 90
Explicación: No necesitamos aplicar ninguna operación.
Podemos elegir los elementos 7, 5 y 4 con una suma de cuadrados: 7^2 + 5^2 + 4^2 = 90.
Se puede demostrar que este es el valor máximo que podemos obtener.

Restricciones:

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


Se te da un array de enteros indexado desde 0, nums.
Devuelve el valor máximo de todos los tríos de índices (i, j, k) tal que i < j < k. Si todos esos tríos tienen un valor negativo, devuelve 0.
El valor de un trío de índices (i, j, k) es igual a (nums[i] - nums[j]) * nums[k].

Ejemplo 1:

Entrada: nums = [12,6,1,2,7]
Salida: 77
Explicación: El valor del trío (0, 2, 4) es (nums[0] - nums[2]) * nums[4] = 77.
Se puede demostrar que no hay tríos ordenados de índices con un valor mayor que 77.

Ejemplo 2:

Entrada: nums = [1,10,3,4,19]
Salida: 133
Explicación: El valor del trío (1, 2, 4) es (nums[1] - nums[2]) * nums[4] = 133.
Se puede demostrar que no hay tríos ordenados de índices con un valor mayor que 133.

Ejemplo 3:

Entrada: nums = [1,2,3]
Salida: 0
Explicación: El único trío ordenado de índices (0, 1, 2) tiene un valor negativo de (nums[0] - nums[1]) * nums[2] = -3. Por lo tanto, la respuesta sería 0.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0, nums.
Devuelve el valor máximo de todos los tripletes de índices (i, j, k) tales que i < j < k. Si todos esos tripletes tienen un valor negativo, devuelve 0.
El valor de un triplete de índices (i, j, k) es igual a (nums[i] - nums[j]) * nums[k].

Ejemplo 1:

Entrada: nums = [12,6,1,2,7]
Salida: 77
Explicación: El valor del triplete (0, 2, 4) es (nums[0] - nums[2]) * nums[4] = 77.
Se puede demostrar que no hay tripletes ordenados de índices con un valor mayor que 77.

Ejemplo 2:

Entrada: nums = [1,10,3,4,19]
Salida: 133
Explicación: El valor del triplete (1, 2, 4) es (nums[1] - nums[2]) * nums[4] = 133.
Se puede demostrar que no hay tripletes ordenados de índices con un valor mayor que 133.

Ejemplo 3:

Entrada: nums = [1,2,3]
Salida: 0
Explicación: El único triplete ordenado de índices (0, 1, 2) tiene un valor negativo de (nums[0] - nums[1]) * nums[2] = -3. Por lo tanto, la respuesta sería 0.

Restricciones:

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


Se te da un array de enteros nums indexado a partir de 0.
El recuento distinto de un subarray de nums se define como:

Sea nums[i..j] un subarray de nums que consiste en todos los índices desde i hasta j tal que 0 <= i <= j < nums.length. Entonces, el número de valores distintos en nums[i..j] se llama el recuento distinto de nums[i..j].

Devuelve la suma de los cuadrados de los recuentos distintos de todos los subarrays de nums.
Un subarray es una secuencia contigua no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [1,2,1]
Salida: 15
Explicación: Seis subarrays posibles son:
[1]: 1 valor distinto
[2]: 1 valor distinto
[1]: 1 valor distinto
[1,2]: 2 valores distintos
[2,1]: 2 valores distintos
[1,2,1]: 2 valores distintos
La suma de los cuadrados de los recuentos distintos en todos los subarrays es igual a 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Ejemplo 2:

Entrada: nums = [1,1]
Salida: 3
Explicación: Tres subarrays posibles son:
[1]: 1 valor distinto
[1]: 1 valor distinto
[1,1]: 1 valor distinto
La suma de los cuadrados de los recuentos distintos en todos los subarrays es igual a 1^2 + 1^2 + 1^2 = 3.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums.
El recuento distinto de una submatriz de nums se define como:

Sea nums[i..j] una submatriz de nums que consta de todos los índices de i a j tales que 0 <= i <= j < nums.length. Entonces, la cantidad de valores distintos en nums[i..j] se denomina recuento distinto de nums[i..j].

Devuelve la suma de los cuadrados de los recuentos distintos de todas las submatrices de nums.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,2,1]
Salida: 15
Explicación: Seis subarreglos posibles son:
[1]: 1 valor distinto
[2]: 1 valor distinto
[1]: 1 valor distinto
[1,2]: 2 valores distintos
[2,1]: 2 valores distintos
[1,2,1]: 2 valores distintos
La suma de los cuadrados de los recuentos distintos en todos los subarreglos es igual a 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Ejemplo 2:

Entrada: nums = [1,1]
Salida: 3
Explicación: Tres subarreglos posibles son:
[1]: 1 valor distinto
[1]: 1 valor distinto
[1,1]: 1 valor distinto
La suma de los cuadrados de los recuentos distintos en todos Los subconjuntos son iguales a 1^2 + 1^2 + 1^2 = 3.

Restricciones:

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


Dado un array de cadenas words de índice 0 donde words[i] es un número entero positivo representado como una cadena o la cadena "prev". Comienza a iterar desde el principio del array; por cada cadena "prev" vista en words, encuentra el último entero visitado en words que se define de la siguiente manera:

Sea k el número de cadenas consecutivas "prev" vistas hasta ahora (incluida la cadena actual). Sea nums el array de enteros vistos hasta ahora y nums_reverse el inverso de nums, entonces el entero en el índice (k - 1) de nums_reverse será el último entero visitado para este "prev". Si k es mayor que el total de enteros visitados, entonces el último entero visitado será -1.

Devuelve un array de enteros que contiene los últimos enteros visitados.

Ejemplo 1:

Entrada: words = ["1","2","prev","prev","prev"]
Salida: [2,1,-1]
Explicación:
Para "prev" en el índice = 2, el último entero visitado será 2 ya que el número de cadenas consecutivas "prev" es 1, y en el array reverse_nums, 2 será el primer elemento.
Para "prev" en el índice = 3, el último entero visitado será 1 ya que hay un total de dos cadenas consecutivas "prev" incluidas en este "prev" que se visitan, y 1 es el segundo último entero visitado.
Para "prev" en el índice = 4, el último entero visitado será -1 ya que hay un total de tres cadenas consecutivas "prev" incluidas en este "prev" que se visitan, pero el número total de enteros visitados es dos.

Ejemplo 2:

Entrada: words = ["1","prev","2","prev","prev"]
Salida: [1,2,1]
Explicación:
Para "prev" en el índice = 1, el último entero visitado será 1.
Para "prev" en el índice = 3, el último entero visitado será 2.
Para "prev" en el índice = 4, el último entero visitado será 1 ya que hay un total de dos cadenas consecutivas "prev" incluidas en este "prev" que se visitan, y 1 es el segundo último entero visitado.

Restricciones:

1 <= words.length <= 100
words[i] == "prev" o 1 <= int(words[i]) <= 100

Dado un arreglo de cadenas de caracteres con índice 0, donde words[i] es un entero positivo representado como una cadena o la cadena "prev".
Comience a iterar desde el principio del arreglo; para cada cadena "prev" vista en words, encuentre el último entero visitado en words, que se define de la siguiente manera:

Sea k el número de cadenas "prev" consecutivas vistas hasta ahora (que contienen la cadena actual). Sea nums el arreglo de caracteres con índice 0 de enteros vistos hasta ahora y nums_reverse el inverso de nums, entonces el entero en el índice (k - 1)^th de nums_reverse será el último entero visitado para este "prev".
Si k es mayor que el total de enteros visitados, entonces el último entero visitado será -1.

Devuelva un arreglo de enteros que contiene los últimos enteros visitados.

Ejemplo 1:

Entrada: palabras = ["1","2","prev","prev","prev"]
Salida: [2,1,-1]
Explicación:
Para "prev" en el índice = 2, el último entero visitado será 2, ya que aquí el número de cadenas "prev" consecutivas es 1, y en la matriz reverse_nums, 2 será el primer elemento.
Para "prev" en el índice = 3, el último entero visitado será 1, ya que hay un total de dos cadenas "prev" consecutivas que incluyen esta "prev" que se visitan, y 1 es el segundo último entero visitado.
Para "prev" en el índice = 4, el último entero visitado será -1, ya que hay un total de tres cadenas "prev" consecutivas que incluyen esta "prev" que se visitan, pero el número total de enteros visitados es dos.

Ejemplo 2:

Entrada: palabras = ["1", "prev", "2", "prev", "prev"]
Salida: [1,2,1]
Explicación:
Para "prev" en el índice = 1, el último entero visitado será 1.
Para "prev" en el índice = 3, el último entero visitado será 2.
Para "prev" en el índice = 4, el último entero visitado será 1, ya que hay un total de dos cadenas "prev" consecutivas que incluyen este "prev" que se visitan, y 1 es el segundo último entero visitado.

Restricciones:

1 <= words.length <= 100
words[i] == "prev" or 1 <= int(words[i]) <= 100

Dado un conjunto de cadenas palabras de índice 0 donde palabras[i] es un número entero positivo representado como una cadena o la cadena "prev". Comienza a iterar desde el principio del conjunto; por cada cadena "prev" vista en palabras, encuentra el último entero visitado en palabras que se define de la siguiente manera:

Sea k el número de cadenas consecutivas "prev" vistas hasta ahora (incluida la cadena actual). Sea nums el conjunto de enteros vistos hasta ahora y nums_reverse el inverso de nums, entonces el entero en el índice (k - 1) de nums_reverse será el último entero visitado para este "prev". Si k es mayor que el total de enteros visitados, entonces el último entero visitado será -1.

Devuelve un conjunto de enteros que contiene los últimos enteros visitados.

Ejemplo 1:

Entrada: palabras = ["1","2","prev","prev","prev"]
Salida: [2,1,-1]
Explicación:
Para "prev" en el índice = 2, el último entero visitado será 2 ya que el número de cadenas consecutivas "prev" es 1, y en el conjunto reverse_nums, 2 será el primer elemento.
Para "prev" en el índice = 3, el último entero visitado será 1 ya que hay un total de dos cadenas consecutivas "prev" incluidas en este "prev" que se visitan, y 1 es el segundo último entero visitado.
Para "prev" en el índice = 4, el último entero visitado será -1 ya que hay un total de tres cadenas consecutivas "prev" incluidas en este "prev" que se visitan, pero el número total de enteros visitados es dos.

Ejemplo 2:

Entrada: palabras = ["1","prev","2","prev","prev"]
Salida: [1,2,1]
Explicación:
Para "prev" en el índice = 1, el último entero visitado será 1.
Para "prev" en el índice = 3, el último entero visitado será 2.
Para "prev" en el índice = 4, el último entero visitado será 1 ya que hay un total de dos cadenas consecutivas "prev" incluidas en este "prev" que se visitan, y 1 es el segundo último entero visitado.

Restricciones:

1 <= palabras.length <= 100
palabras[i] == "prev" o 1 <= int(palabras[i]) <= 100


Dado un array de enteros nums indexado desde 0 de longitud n.
Queremos agrupar los índices de manera que, para cada índice i en el rango [0, n - 1], esté asignado exactamente a un grupo.
Una asignación de grupo es válida si se cumplen las siguientes condiciones:

Para cada grupo g, todos los índices i asignados al grupo g tienen el mismo valor en nums.
Para cualquier par de grupos g_1 y g_2, la diferencia entre el número de índices asignados a g_1 y g_2 no debe exceder 1.

Devuelve un entero que denota el número mínimo de grupos necesarios para crear una asignación de grupos válida.

Ejemplo 1:

Entrada: nums = [3,2,3,2,3]
Salida: 2
Explicación: Una forma de asignar los índices a 2 grupos es la siguiente, donde los valores entre corchetes son índices:
grupo 1 -> [0,2,4]
grupo 2 -> [1,3]
Todos los índices están asignados a un grupo.
En el grupo 1, nums[0] == nums[2] == nums[4], por lo que todos los índices tienen el mismo valor.
En el grupo 2, nums[1] == nums[3], por lo que todos los índices tienen el mismo valor.
El número de índices asignados al grupo 1 es 3, y el número de índices asignados al grupo 2 es 2.
Su diferencia no excede 1.
No es posible usar menos de 2 grupos porque, para usar solo 1 grupo, todos los índices asignados a ese grupo deben tener el mismo valor.
Por lo tanto, la respuesta es 2.
Ejemplo 2:

Entrada: nums = [10,10,10,3,1,1]
Salida: 4
Explicación: Una forma de asignar los índices a 4 grupos es la siguiente, donde los valores entre corchetes son índices:
grupo 1 -> [0]
grupo 2 -> [1,2]
grupo 3 -> [3]
grupo 4 -> [4,5]
La asignación de grupos anterior cumple ambas condiciones.
Se puede demostrar que no es posible crear una asignación válida utilizando menos de 4 grupos.
Por lo tanto, la respuesta es 4.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums de longitud n.
Queremos agrupar los índices de modo que para cada índice i en el rango [0, n - 1], se le asigne exactamente a un grupo.
Una asignación de grupo es válida si se cumplen las siguientes condiciones:

Para cada grupo g, todos los índices i asignados al grupo g tienen el mismo valor en nums.
Para dos grupos cualesquiera g_1 y g_2, la diferencia entre la cantidad de índices asignados a g_1 y g_2 no debe superar 1.

Devuelve un entero que denota la cantidad mínima de grupos necesarios para crear una asignación de grupo válida.

Ejemplo 1:

Entrada: nums = [3,2,3,2,3]
Salida: 2
Explicación: Una forma de asignar los índices a 2 grupos es la siguiente, donde los valores entre corchetes son índices:
grupo 1 -> [0,2,4]
grupo 2 -> [1,3]
Todos los índices se asignan a un grupo.
En el grupo 1, nums[0] == nums[2] == nums[4], por lo que todos los índices tienen el mismo valor.
En el grupo 2, nums[1] == nums[3], por lo que todos los índices tienen el mismo valor.
El número de índices asignados al grupo 1 es 3 y el número de índices asignados al grupo 2 es 2.
Su diferencia no supera 1.
No es posible utilizar menos de 2 grupos porque, para utilizar solo 1 grupo, todos los índices asignados a ese grupo deben tener el mismo valor.
Por lo tanto, la respuesta es 2.
Ejemplo 2:

Entrada: nums = [10,10,10,3,1,1]
Salida: 4
Explicación: Una forma de asignar los índices a 4 grupos es la siguiente, donde los valores entre corchetes son índices:
grupo 1 -> [0]
grupo 2 -> [1,2]
grupo 3 -> [3]
grupo 4 -> [4,5]
La asignación de grupo anterior satisface ambas condiciones.
Se puede demostrar que no es posible crear una asignación válida utilizando menos de 4 grupos.
Por lo tanto, la respuesta es 4.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums de longitud n.
Queremos agrupar los índices de modo que para cada índice i en el rango [0, n - 1], se le asigne exactamente a un grupo.
Una asignación de grupo es válida si se cumplen las siguientes condiciones:

Para cada grupo g, todos los índices i asignados al grupo g tienen el mismo valor en nums.
Para dos grupos cualesquiera g_1 y g_2, la diferencia entre la cantidad de índices asignados a g_1 y g_2 no debe superar 1.

Devuelve un entero que denota la cantidad mínima de grupos necesarios para crear una asignación de grupo válida.

Ejemplo 1:

Entrada: nums = [3,2,3,2,3]
Salida: 2
Explicación: Una forma de asignar los índices a 2 grupos es la siguiente, donde los valores entre corchetes son índices:
group 1 -> [0,2,4]
group 2 -> [1,3]
Todos los índices se asignan a un grupo.
En el grupo 1, nums[0] == nums[2] == nums[4], por lo que todos los índices tienen el mismo valor.
En el grupo 2, nums[1] == nums[3], por lo que todos los índices tienen el mismo valor.
El número de índices asignados al grupo 1 es 3 y el número de índices asignados al grupo 2 es 2.
Su diferencia no supera 1.
No es posible utilizar menos de 2 grupos porque, para utilizar solo 1 grupo, todos los índices asignados a ese grupo deben tener el mismo valor.
Por lo tanto, la respuesta es 2.
Ejemplo 2:

Entrada: nums = [10,10,10,3,1,1]
Salida: 4
Explicación: Una forma de asignar los índices a 4 grupos es la siguiente, donde los valores entre corchetes son índices:
group 1 -> [0]
group 2 -> [1,2]
group 3 -> [3]
group 4 -> [4,5]
La asignación de grupo anterior satisface ambas condiciones.
Se puede demostrar que no es posible crear una asignación válida utilizando menos de 4 grupos.
Por lo tanto, la respuesta es 4.

Restricciones:

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


Se te dan dos vectores nums1 y nums2 que consisten en enteros positivos.
Debes reemplazar todos los 0's en ambos vectores con enteros estrictamente positivos de manera que la suma de los elementos de ambos vectores se vuelva igual.
Devuelve la suma mínima igual que puedas obtener, o -1 si es imposible.

Ejemplo 1:

Entrada: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Salida: 12
Explicación: Podemos reemplazar los 0's de la siguiente manera:
- Reemplaza los dos 0's en nums1 con los valores 2 y 4. El vector resultante es nums1 = [3,2,2,1,4].
- Reemplaza el 0 en nums2 con el valor 1. El vector resultante es nums2 = [6,5,1].
Ambos vectores tienen una suma igual de 12. Se puede demostrar que es la suma mínima que podemos obtener.

Ejemplo 2:

Entrada: nums1 = [2,0,2,0], nums2 = [1,4]
Salida: -1
Explicación: Es imposible igualar la suma de ambos vectores.

Restricciones:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Tienes dos matrices nums1 y nums2 que constan de números enteros positivos.
Tienes que reemplazar todos los 0 en ambas matrices con números enteros estrictamente positivos de modo que la suma de los elementos de ambas matrices sea igual.
Devuelve la suma mínima que puedes obtener, o -1 si es imposible.

Ejemplo 1:

Entrada: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Salida: 12
Explicación: Podemos reemplazar 0 de la siguiente manera:
- Reemplaza los dos 0 en nums1 con los valores 2 y 4. La matriz resultante es nums1 = [3,2,2,1,4].
- Reemplaza el 0 en nums2 con el valor 1. La matriz resultante es nums2 = [6,5,1].
Ambas matrices tienen una suma igual de 12. Se puede demostrar que es la suma mínima que podemos obtener.

Ejemplo 2:

Entrada: nums1 = [2,0,2,0], nums2 = [1,4]
Salida: -1
Explicación: Es imposible hacer que la suma de ambas matrices sea igual.

Restricciones:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


Se te dan dos enteros positivos n y m.
Define dos enteros, num1 y num2, de la siguiente manera:

num1: La suma de todos los enteros en el rango [1, n] que no son divisibles por m.
num2: La suma de todos los enteros en el rango [1, n] que son divisibles por m.

Devuelve el entero num1 - num2.

Ejemplo 1:

Entrada: n = 10, m = 3
Salida: 19
Explicación: En el ejemplo dado:
- Los enteros en el rango [1, 10] que no son divisibles por 3 son [1,2,4,5,7,8,10], num1 es la suma de esos enteros = 37.
- Los enteros en el rango [1, 10] que son divisibles por 3 son [3,6,9], num2 es la suma de esos enteros = 18.
Devolvemos 37 - 18 = 19 como la respuesta.

Ejemplo 2:

Entrada: n = 5, m = 6
Salida: 15
Explicación: En el ejemplo dado:
- Los enteros en el rango [1, 5] que no son divisibles por 6 son [1,2,3,4,5], num1 es la suma de esos enteros = 15.
- Los enteros en el rango [1, 5] que son divisibles por 6 son [], num2 es la suma de esos enteros = 0.
Devolvemos 15 - 0 = 15 como la respuesta.

Ejemplo 3:

Entrada: n = 5, m = 1
Salida: -15
Explicación: En el ejemplo dado:
- Los enteros en el rango [1, 5] que no son divisibles por 1 son [], num1 es la suma de esos enteros = 0.
- Los enteros en el rango [1, 5] que son divisibles por 1 son [1,2,3,4,5], num2 es la suma de esos enteros = 15.
Devolvemos 0 - 15 = -15 como la respuesta.

Restricciones:

1 <= n, m <= 1000

Se le proporcionan los números enteros positivos n y m.
Defina dos números enteros, num1 y num2, de la siguiente manera:

num1: la suma de todos los números enteros en el rango [1, n] que no son divisibles por m.
num2: la suma de todos los números enteros en el rango [1, n] que son divisibles por m.

Devuelva el número entero num1 - num2.

Ejemplo 1:

Entrada: n = 10, m = 3
Salida: 19
Explicación: En el ejemplo dado:
- Los números enteros en el rango [1, 10] que no son divisibles por 3 son [1,2,4,5,7,8,10], num1 es la suma de esos números enteros = 37.
- Los números enteros en el rango [1, 10] que son divisibles por 3 son [3,6,9], num2 es la suma de esos números enteros = 18.
Devolvemos 37 - 18 = 19 como respuesta.

Ejemplo 2:

Entrada: n = 5, m = 6
Salida: 15
Explicación: En el ejemplo dado:
- Los números enteros en el rango [1, 5] que no son divisibles por 6 son [1,2,3,4,5], num1 es la suma de esos números enteros = 15.
- Los números enteros en el rango [1, 5] que son divisibles por 6 son [], num2 es la suma de esos números enteros = 0.
Devolvemos 15 - 0 = 15 como respuesta.

Ejemplo 3:

Entrada: n = 5, m = 1
Salida: -15
Explicación: En el ejemplo dado:
- Los números enteros en el rango [1, 5] que no son divisibles por 1 son [], num1 es la suma de esos números enteros = 0.
- Los números enteros en el rango [1, 5] que son divisibles por 1 son [1,2,3,4,5], num2 es la suma de esos números enteros = 15.
Devolvemos 0 - 15 = -15 como respuesta.

Restricciones:

1 <= n, m <= 1000


Se te da una cadena binaria s indexada desde cero con una longitud par.
Una cadena es hermosa si es posible dividirla en una o más subcadenas de tal manera que:

Cada subcadena tiene una longitud par.
Cada subcadena contiene solo 1's o solo 0's.

Puedes cambiar cualquier carácter en s a 0 o 1.
Devuelve el número mínimo de cambios necesarios para hacer que la cadena s sea hermosa.

Ejemplo 1:

Entrada: s = "1001"
Salida: 2
Explicación: Cambiamos s[1] a 1 y s[3] a 0 para obtener la cadena "1100".
Se puede ver que la cadena "1100" es hermosa porque podemos dividirla en "11|00".
Se puede demostrar que 2 es el número mínimo de cambios necesarios para hacer la cadena hermosa.

Ejemplo 2:

Entrada: s = "10"
Salida: 1
Explicación: Cambiamos s[1] a 1 para obtener la cadena "11".
Se puede ver que la cadena "11" es hermosa porque podemos dividirla en "11".
Se puede demostrar que 1 es el número mínimo de cambios necesarios para hacer la cadena hermosa.

Ejemplo 3:

Entrada: s = "0000"
Salida: 0
Explicación: No necesitamos hacer ningún cambio ya que la cadena "0000" ya es hermosa.

Restricciones:

2 <= s.length <= 10^5
s tiene una longitud par.
s[i] es '0' o '1'.

Se te da una cadena binaria `s` indexada desde cero con una longitud par.
Una cadena es hermosa si es posible dividirla en una o más subcadenas de tal manera que:

Cada subcadena tiene una longitud par.
Cada subcadena contiene solo 1's o solo 0's.

Puedes cambiar cualquier carácter en `s` a 0 o 1.
Devuelve el número mínimo de cambios necesarios para hacer que la cadena `s` sea hermosa.

Ejemplo 1:

Entrada: s = "1001"
Salida: 2
Explicación: Cambiamos s[1] a 1 y s[3] a 0 para obtener la cadena "1100".
Se puede ver que la cadena "1100" es hermosa porque podemos dividirla en "11|00".
Se puede demostrar que 2 es el número mínimo de cambios necesarios para hacer la cadena hermosa.

Ejemplo 2:

Entrada: s = "10"
Salida: 1
Explicación: Cambiamos s[1] a 1 para obtener la cadena "11".
Se puede ver que la cadena "11" es hermosa porque podemos dividirla en "11".
Se puede demostrar que 1 es el número mínimo de cambios necesarios para hacer la cadena hermosa.

Ejemplo 3:

Entrada: s = "0000"
Salida: 0
Explicación: No necesitamos hacer ningún cambio ya que la cadena "0000" ya es hermosa.

Condiciones:

2 <= s.length <= 10^5
s tiene una longitud par.
s[i] es '0' o '1'.

Se le proporciona una cadena binaria indexada en 0 que tiene una longitud par.
Una cadena es hermosa si es posible dividirla en una o más subcadenas de manera que:

Cada subcadena tiene una longitud par.
Cada subcadena contiene solo 1 o solo 0.

Puede cambiar cualquier carácter en s a 0 o 1.
Devuelva la cantidad mínima de cambios necesarios para que la cadena s sea hermosa.

Ejemplo 1:

Entrada: s = "1001"
Salida: 2
Explicación: Cambiamos s[1] a 1 y s[3] a 0 para obtener la cadena "1100".
Se puede ver que la cadena "1100" es hermosa porque podemos dividirla en "11|00".
Se puede demostrar que 2 es la cantidad mínima de cambios necesarios para que la cadena sea hermosa.

Ejemplo 2:

Entrada: s = "10"
Salida: 1
Explicación: Cambiamos s[1] por 1 para obtener la cadena "11".
Se puede ver que la cadena "11" es hermosa porque podemos dividirla en "11".
Se puede demostrar que 1 es la cantidad mínima de cambios necesarios para que la cadena sea hermosa.

Ejemplo 3:

Entrada: s = "0000"
Salida: 0
Explicación: No necesitamos hacer ningún cambio ya que la cadena "0000" ya es hermosa.

Restricciones:

2 <= s.length <= 10^5
s tiene una longitud par.
s[i] es '0' o '1'.


Dada una matriz de enteros nums indexada desde 0.
Un triplete de índices (i, j, k) es una montaña si:

i < j < k
nums[i] < nums[j] y nums[k] < nums[j]

Devuelve la suma mínima posible de un triplete de montaña de nums. Si no existe tal triplete, devuelve -1.

Ejemplo 1:

Entrada: nums = [8,6,1,5,3]
Salida: 9
Explicación: El triplete (2, 3, 4) es un triplete de montaña con suma 9 ya que:
- 2 < 3 < 4
- nums[2] < nums[3] y nums[4] < nums[3]
Y la suma de este triplete es nums[2] + nums[3] + nums[4] = 9. Se puede demostrar que no hay tripletes de montaña con una suma menor a 9.

Ejemplo 2:

Entrada: nums = [5,4,8,7,10,2]
Salida: 13
Explicación: El triplete (1, 3, 5) es un triplete de montaña con suma 13 ya que:
- 1 < 3 < 5
- nums[1] < nums[3] y nums[5] < nums[3]
Y la suma de este triplete es nums[1] + nums[3] + nums[5] = 13. Se puede demostrar que no hay tripletes de montaña con una suma menor a 13.

Ejemplo 3:

Entrada: nums = [6,5,4,3,4,5]
Salida: -1
Explicación: Se puede demostrar que no hay tripletes de montaña en nums.

Restricciones:

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

Se le proporciona una matriz nums de números enteros con índice 0.
Un triplete de índices (i, j, k) es una montaña si:

i < j < k
nums[i] < nums[j] y nums[k] < nums[j]

Devuelve la suma mínima posible de un triplete de montaña de nums. Si no existe dicho triplete, devuelve -1.

Ejemplo 1:

Entrada: nums = [8,6,1,5,3]
Salida: 9
Explicación: El triplete (2, 3, 4) es un triplete montaña de suma 9 ya que:
- 2 < 3 < 4
- nums[2] < nums[3] y nums[4] < nums[3]
Y la suma de este triplete es nums[2] + nums[3] + nums[4] = 9. Se puede demostrar que no hay tripletes montaña con una suma menor que 9.

Ejemplo 2:

Entrada: nums = [5,4,8,7,10,2]
Salida: 13
Explicación: El triplete (1, 3, 5) es un triplete montaña de suma 13 ya que:
- 1 < 3 < 5
- nums[1] < nums[3] y nums[5] < nums[3]
Y la suma de este triplete es nums[1] + nums[3] + nums[5] = 13. Se puede demostrar que no hay tripletes de montaña con una suma menor que 13.

Ejemplo 3:

Entrada: nums = [6,5,4,3,4,5]
Salida: -1
Explicación: Se puede demostrar que no hay tripletes de montaña en nums.

Restricciones:

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

Se le da una matriz de números enteros con índice 0.
Un triplete de índices (i, j, k) es una montaña si

i < j < k
nums[i] < nums[j] and nums[k] < nums[j]

Devuelve la suma mínima posible de un triplete de nums montaña. Si no existe tal triplete, devuelve -1.

Ejemplo 1:

Entrada: nums = [8,6,1,5,3]
Salida: 9
Explicación: El triplete (2, 3, 4) es un triplete de montaña de suma 9 ya que:
- 2 < 3 < 4
- nums[2] < nums[3] y nums[4] < nums[3]
Y la suma de este triplete es nums[2] + nums[3] + nums[4] = 9. Se puede demostrar que no hay tripletes de montaña con una suma menor que 9.

Ejemplo 2:

Entrada: nums = [5,4,8,7,10,2]
Salida: 13
Explicación: El triplete (1, 3, 5) es un triplete de montaña de suma 13 ya que:
- 1 < 3 < 5
- nums[1] < nums[3] y nums[5] < nums[3]
Y la suma de este triplete es números[1] + números[3] + números[5] = 13. Se puede demostrar que no hay tripletas de montañas cuya suma sea menor que 13.

Ejemplo 3:

Entrada: nums = [6,5,4,3,4,5]
Salida: -1
Explicación: Se puede demostrar que no hay tripletes de montañas en nums.

Restricciones:

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


Tienes un array de enteros nums indexado a partir de 0, y un entero k.
El K-or de nums es un entero no negativo que satisface lo siguiente:

El bit i-ésimo está configurado en el K-or si y solo si hay al menos k elementos de nums en los que el bit i está configurado.

Devuelve el K-or de nums.
Ten en cuenta que un bit i está configurado en x si (2^i AND x) == 2^i, donde AND es el operador AND bit a bit.

Ejemplo 1:

Entrada: nums = [7,12,9,8,9,15], k = 4
Salida: 9
Explicación: El bit 0 está configurado en nums[0], nums[2], nums[4], y nums[5].
El bit 1 está configurado en nums[0], y nums[5].
El bit 2 está configurado en nums[0], nums[1], y nums[5].
El bit 3 está configurado en nums[1], nums[2], nums[3], nums[4], y nums[5].
Solo los bits 0 y 3 están configurados en al menos k elementos del array, y los bits i >= 4 no están configurados en ninguno de los elementos del array. Por lo tanto, la respuesta es 2^0 + 2^3 = 9.

Ejemplo 2:

Entrada: nums = [2,12,1,11,4,5], k = 6
Salida: 0
Explicación: Como k == 6 == nums.length, el 6-or del array es igual al AND bit a bit de todos sus elementos. Por lo tanto, la respuesta es 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Ejemplo 3:

Entrada: nums = [10,8,5,9,11,6,8], k = 1
Salida: 15
Explicación: Como k == 1, el 1-or del array es igual al OR bit a bit de todos sus elementos. Por lo tanto, la respuesta es 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

Restricciones:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Se le da una matriz de números enteros con índice 0 y un número entero k.
El K-or de nums es un entero no negativo que satisface lo siguiente:

El bit i^ está puesto en la K-or si y sólo si hay al menos k elementos de nums en los que el bit i está puesto.

Devuelve el K-or de nums.
Nótese que un bit i está puesto en x si (2^i AND x) == 2^i, donde AND es el operador AND a nivel de bit.

Ejemplo 1

Entrada: números = [7,12,9,8,9,15], k = 4
Salida: 9
Explicación: El bit 0 se establece en nums[0], nums[2], nums[4], y nums[5].
El bit 1 se establece en nums[0] y nums[5].
El bit 2 se establece en nums[0], nums[1] y nums[5].
El bit 3 se establece en los números[1],[2],[3],[4] y[5].
Sólo los bits 0 y 3 están fijados en al menos k elementos de la matriz, y los bits i >= 4 no están fijados en ninguno de los elementos de la matriz. Por lo tanto, la respuesta es 2^0 + 2^3 = 9.

Segundo ejemplo:

Entrada: nums = [2,12,1,11,4,5], k = 6
Salida: 0
Explicación: Como k == 6 == nums.length, el 6-o de la matriz es igual al AND bitwise de todos sus elementos. Por lo tanto, la respuesta es 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Ejemplo 3:

Entrada: nums = [10,8,5,9,11,6,8], k = 1
Salida: 15
Explicación: Puesto que k == 1, el 1-o de la matriz es igual al OR bitwise de todos sus elementos. Por lo tanto, la respuesta es 10 O 8 O 5 O 9 O 11 O 6 O 8 = 15.

Restricciones:

1 <= nums.length <= 50
0 <= números[i] < 2^31
1 <= k <= nums.length

Se le proporciona una matriz de enteros indexada en 0 nums y un entero k.
El K-or de nums es un entero no negativo que satisface lo siguiente:

El bit i^th se establece en el K-or si y solo si hay al menos k elementos de nums en los que el bit i está establecido.

Devuelve el K-or de nums.
Tenga en cuenta que un bit i se establece en x si (2^i AND x) == 2^i, donde AND es el operador AND bit a bit.

Ejemplo 1:

Entrada: nums = [7,12,9,8,9,15], k = 4
Salida: 9
Explicación: El bit 0 se establece en nums[0], nums[2], nums[4] y nums[5].
El bit 1 se establece en nums[0] y nums[5].
El bit 2 se establece en nums[0], nums[1] y nums[5].
El bit 3 se establece en nums[1], nums[2], nums[3], nums[4] y nums[5].
Solo los bits 0 y 3 se establecen en al menos k elementos de la matriz, y los bits i >= 4 no se establecen en ninguno de los elementos de la matriz. Por lo tanto, la respuesta es 2^0 + 2^3 = 9.

Ejemplo 2:

Entrada: nums = [2,12,1,11,4,5], k = 6
Salida: 0
Explicación: Dado que k == 6 == nums.length, el 6-o de la matriz es igual al AND bit a bit de todos sus elementos. Por lo tanto, la respuesta es 2 Y 12 Y 1 Y 11 Y 4 Y 5 = 0.

Ejemplo 3:

Entrada: nums = [10,8,5,9,11,6,8], k = 1
Salida: 15
Explicación: Como k == 1, el 1-o de la matriz es igual al OR bit a bit de todos sus elementos. Por lo tanto, la respuesta es 10 O 8 O 5 O 9 O 11 O 6 O 8 = 15.

Restricciones:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length


Se te da un array de enteros indexado desde 0 llamado nums.
Una subsecuencia de nums de longitud k y que consiste en índices i_0 < i_1 < ... < i_k-1 es balanceada si se cumple lo siguiente:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, para cada j en el rango [1, k - 1].

Una subsecuencia de nums de longitud 1 se considera balanceada.
Devuelve un entero que denote la suma máxima posible de elementos en una subsecuencia balanceada de nums.
Una subsecuencia de un array es un nuevo array no vacío que se forma a partir del array original eliminando algunos (posiblemente ninguno) de los elementos sin alterar las posiciones relativas de los elementos restantes.

Ejemplo 1:

Entrada: nums = [3,3,5,6]
Salida: 14
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [3,5,6] que consiste en los índices 0, 2 y 3.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Por lo tanto, es una subsecuencia balanceada, y su suma es la máxima entre las subsecuencias balanceadas de nums.
La subsecuencia que consiste en los índices 1, 2 y 3 también es válida.
Se puede demostrar que no es posible obtener una subsecuencia balanceada con una suma mayor que 14.
Ejemplo 2:

Entrada: nums = [5,-1,-3,8]
Salida: 13
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [5,8] que consiste en los índices 0 y 3.
nums[3] - nums[0] >= 3 - 0.
Por lo tanto, es una subsecuencia balanceada, y su suma es la máxima entre las subsecuencias balanceadas de nums.
Se puede demostrar que no es posible obtener una subsecuencia balanceada con una suma mayor que 13.

Ejemplo 3:

Entrada: nums = [-2,-1]
Salida: -1
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [-1].
Es una subsecuencia balanceada, y su suma es la máxima entre las subsecuencias balanceadas de nums.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums.
Una subsecuencia de nums que tiene una longitud k y que consta de índices i_0 < i_1 < ... < i_k-1 está equilibrada si se cumple lo siguiente:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, para cada j en el rango [1, k - 1].

Una subsecuencia de nums que tiene una longitud de 1 se considera equilibrada.
Devuelve un entero que denota la suma máxima posible de elementos en una subsecuencia equilibrada de nums.
Una subsecuencia de una matriz es una nueva matriz no vacía que se forma a partir de la matriz original eliminando algunos (posiblemente ninguno) de los elementos sin alterar las posiciones relativas de los elementos restantes.

Ejemplo 1:

Entrada: nums = [3,3,5,6]
Salida: 14
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [3,5,6] que consta de los índices 0, 2 y 3.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Por lo tanto, es una subsecuencia balanceada y su suma es la máxima entre las subsecuencias balanceadas de nums.
La subsecuencia que consta de los índices 1, 2 y 3 también es válida.
Se puede demostrar que no es posible obtener una subsecuencia balanceada con una suma mayor que 14.
Ejemplo 2:

Entrada: nums = [5,-1,-3,8]
Salida: 13
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [5,8] que consta de los índices 0 y 3.
nums[3] - nums[0] >= 3 - 0.
Por lo tanto, es una subsecuencia balanceada y su suma es la máxima entre las subsecuencias balanceadas de nums.
Se puede demostrar que no es posible obtener una subsecuencia balanceada con una suma mayor que 13.

Ejemplo 3:

Entrada: nums = [-2,-1]
Salida: -1
Explicación: En este ejemplo, se puede seleccionar la subsecuencia [-1].
Es una subsecuencia balanceada y su suma es la máxima entre las subsecuencias balanceadas de nums.

Restricciones:

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


Hay n equipos numerados del 0 al n - 1 en un torneo.
Dada una matriz booleana bidimensional indexada por 0, grid de tamaño n * n. Para todos i, j que 0 <= i, j <= n - 1 e i != j, el equipo i es más fuerte que el equipo j si grid[i][j] == 1, de lo contrario, el equipo j es más fuerte que el equipo i.
El equipo a será el campeón del torneo si no hay ningún equipo b que sea más fuerte que el equipo a.
Devuelve el equipo que será el campeón del torneo.

Ejemplo 1:

Input: grid = [[0,1],[0,0]]
Output: 0
Explicación: Hay dos equipos en este torneo.
grid[0][1] == 1 significa que el equipo 0 es más fuerte que el equipo 1. Así que el equipo 0 será el campeón.

Ejemplo 2:

Input: grid = [[0,0,1],[1,0,1],[0,0,0]]
Output: 1
Explicación: Hay tres equipos en este torneo.
grid[1][0] == 1 significa que el equipo 1 es más fuerte que el equipo 0.
grid[1][2] == 1 significa que el equipo 1 es más fuerte que el equipo 2.
Así que el equipo 1 será el campeón.

Restricciones:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] es 0 o 1.
Para todo i, grid[i][i] es 0.
Para todos i, j que i != j, grid[i][j] != grid[j][i].
La entrada se genera de tal manera que si el equipo a es más fuerte que el equipo b y el equipo b es más fuerte que el equipo c, entonces el equipo a es más fuerte que el equipo c.

Hay n equipos numerados del 0 al n - 1 en un torneo.
Dada una matriz booleana bidimensional indexada por 0, cuadrícula de tamaño n * n. Para todos i, j que 0 <= i, j <= n - 1 e i != j, el equipo i es más fuerte que el equipo j si grid[i][j] == 1, de lo contrario, el equipo j es más fuerte que el equipo i.
El equipo a será el campeón del torneo si no hay ningún equipo b que sea más fuerte que el equipo a.
Devuelve el equipo que será el campeón del torneo.

Ejemplo 1:

Input: grid = [[0,1],[0,0]]
Output: 0
Explicación: Hay dos equipos en este torneo.
grid[0][1] == 1 significa que el equipo 0 es más fuerte que el equipo 1. Así que el equipo 0 será el campeón.

Ejemplo 2:

Input: grid = [[0,0,1],[1,0,1],[0,0,0]]
Output: 1
Explicación: Hay tres equipos en este torneo.
grid[1][0] == 1 significa que el equipo 1 es más fuerte que el equipo 0.
grid[1][2] == 1 significa que el equipo 1 es más fuerte que el equipo 2.
Así que el equipo 1 será el campeón.

Condiciones:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] es 0 o 1.
Para todo i, grid[i][i] es 0.
Para todos i, j que i != j, grid[i][j] != grid[j][i].
La entrada se genera de tal manera que si el equipo a es más fuerte que el equipo b y el equipo b es más fuerte que el equipo c, entonces el equipo a es más fuerte que el equipo c.

Hay n equipos numerados de 0 a n - 1 en un torneo.
Dada una matriz booleana 2D indexada en 0 de tamaño n * n. Para todos los i, j que 0 <= i, j <= n - 1 e i != j el equipo i es más fuerte que el equipo j si grid[i][j] == 1, de lo contrario, el equipo j es más fuerte que el equipo i.
El equipo a será el campeón del torneo si no hay ningún equipo b que sea más fuerte que el equipo a.
Devuelve el equipo que será el campeón del torneo.

Ejemplo 1:

Entrada: grid = [[0,1],[0,0]]
Salida: 0
Explicación: Hay dos equipos en este torneo.
grid[0][1] == 1 significa que el equipo 0 es más fuerte que el equipo 1. Por lo tanto, el equipo 0 será el campeón.

Ejemplo 2:

Entrada: grid = [[0,0,1],[1,0,1],[0,0,0]]
Salida: 1
Explicación: Hay tres equipos en este torneo.
grid[1][0] == 1 significa que el equipo 1 es más fuerte que el equipo 0.
grid[1][2] == 1 significa que el equipo 1 es más fuerte que el equipo 2.
Por lo tanto, el equipo 1 será el campeón.

Restricciones:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] es 0 o 1.
Para todos los i, grid[i][i] es 0.
Para todos los i, j, i != j, grid[i][j] != grid[j][i].
La entrada se genera de modo que si el equipo a es más fuerte que el equipo b y el equipo b es más fuerte que el equipo c, entonces el equipo a es más fuerte que el equipo c.


Se te dan dos arreglos de enteros con índice 0, nums1 y nums2, ambos de longitud n.
Puedes realizar una serie de operaciones (posiblemente ninguna).
En una operación, seleccionas un índice i en el rango [0, n - 1] e intercambias los valores de nums1[i] y nums2[i].
Tu tarea es encontrar el número mínimo de operaciones requeridas para satisfacer las siguientes condiciones:

nums1[n - 1] es igual al valor máximo entre todos los elementos de nums1, es decir, nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] es igual al valor máximo entre todos los elementos de nums2, es decir, nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Devuelve un entero que denote el número mínimo de operaciones necesarias para cumplir con ambas condiciones, o -1 si es imposible satisfacer ambas condiciones.

Ejemplo 1:

Entrada: nums1 = [1,2,7], nums2 = [4,5,3]
Salida: 1
Explicación: En este ejemplo, se puede realizar una operación usando el índice i = 2.
Cuando nums1[2] y nums2[2] se intercambian, nums1 se convierte en [1,2,3] y nums2 se convierte en [4,5,7].
Ambas condiciones ahora se satisfacen.
Se puede demostrar que el número mínimo de operaciones necesarias es 1.
Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Salida: 2
Explicación: En este ejemplo, se pueden realizar las siguientes operaciones:
Primera operación usando el índice i = 4.
Cuando nums1[4] y nums2[4] se intercambian, nums1 se convierte en [2,3,4,5,4], y nums2 se convierte en [8,8,4,4,9].
Otra operación usando el índice i = 3.
Cuando nums1[3] y nums2[3] se intercambian, nums1 se convierte en [2,3,4,4,4], y nums2 se convierte en [8,8,4,5,9].
Ambas condiciones ahora se satisfacen.
Se puede demostrar que el número mínimo de operaciones necesarias es 2.
Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: nums1 = [1,5,4], nums2 = [2,5,3]
Salida: -1
Explicación: En este ejemplo, no es posible satisfacer ambas condiciones.
Por lo tanto, la respuesta es -1.

Restricciones:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Se le proporcionan dos matrices de enteros indexados en 0, nums1 y nums2, ambas con una longitud n.
Se le permite realizar una serie de operaciones (posiblemente ninguna).
En una operación, selecciona un índice i en el rango [0, n - 1] e intercambia los valores de nums1[i] y nums2[i].
Su tarea es encontrar la cantidad mínima de operaciones necesarias para satisfacer las siguientes condiciones:

nums1[n - 1] es igual al valor máximo entre todos los elementos de nums1, es decir, nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] es igual al valor máximo entre todos los elementos de nums2, es decir, nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Devuelve un entero que indica la cantidad mínima de operaciones necesarias para cumplir ambas condiciones, o -1 si es imposible satisfacer ambas condiciones.

Ejemplo 1:

Entrada: nums1 = [1,2,7], nums2 = [4,5,3]
Salida: 1
Explicación: En este ejemplo, se puede realizar una operación utilizando el índice i = 2.
Cuando se intercambian nums1[2] y nums2[2], nums1 se convierte en [1,2,3] y nums2 en [4,5,7].
Ahora se cumplen ambas condiciones.
Se puede demostrar que el número mínimo de operaciones que se deben realizar es 1.
Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Salida: 2
Explicación: En este ejemplo, se pueden realizar las siguientes operaciones:
Primera operación que utiliza el índice i = 4.
Cuando se intercambian nums1[4] y nums2[4], nums1 se convierte en [2,3,4,5,4] y nums2 se convierte en [8,8,4,4,9].
Otra operación que utiliza el índice i = 3.
Cuando se intercambian nums1[3] y nums2[3], nums1 se convierte en [2,3,4,4,4] y nums2 se convierte en [8,8,4,5,9].
Ahora se cumplen ambas condiciones.
Se puede demostrar que el número mínimo de operaciones que se deben realizar es 2.
Por lo tanto, la respuesta es 2.

Ejemplo 3:

Entrada: nums1 = [1,5,4], nums2 = [2,5,3]
Salida: -1
Explicación: En este ejemplo, no es posible satisfacer ambas condiciones.
Por lo tanto, la respuesta es -1.

Restricciones:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9


Dados tres enteros a, b y n, devuelva el valor máximo de (a XOR x) * (b XOR x) donde 0 <= x < 2^n.
Como la respuesta puede ser demasiado grande, devuélvala en módulo 10^9 + 7.
Tenga en cuenta que XOR es la operación XOR a nivel de bits.

Ejemplo 1:

Entrada: a = 12, b = 5, n = 4
Salida: 98
Explicación: Para x = 2, (a XOR x) = 14 y (b XOR x) = 7. Por lo tanto, (a XOR x) * (b XOR x) = 98.
Se puede demostrar que 98 es el valor máximo de (a XOR x) * (b XOR x) para todo 0 <= x < 2^n.

Ejemplo 2:

Entrada: a = 6, b = 7 , n = 5
Salida: 930
Explicación: Para x = 25, (a XOR x) = 31 y (b XOR x) = 30. Por lo tanto, (a XOR x) * (b XOR x) = 930.
Se puede demostrar que 930 es el valor máximo de (a XOR x) * (b XOR x) para todo 0 <= x < 2^n.
Ejemplo 3:

Entrada: a = 1, b = 6, n = 3
Salida: 12
Explicación: Para x = 5, (a XOR x) = 4 y (b XOR x) = 3. Por lo tanto, (a XOR x) * (b XOR x) = 12.
Se puede demostrar que 12 es el valor máximo de (a XOR x) * (b XOR x) para todo 0 <= x < 2^n.

Restricciones:

0 <= a, b < 2^50
0 <= n <= 50

Dados tres enteros a, b y n, devuelve el valor máximo de (a XOR x) * (b XOR x) donde 0 <= x < 2^n.
Como la respuesta puede ser demasiado grande, devuélvela módulo 10^9 + 7.
Ten en cuenta que XOR es la operación XOR bit a bit.

Ejemplo 1:

Entrada: a = 12, b = 5, n = 4
Salida: 98
Explicación: Para x = 2, (a XOR x) = 14 y (b XOR x) = 7. Por lo tanto, (a XOR x) * (b XOR x) = 98.
Se puede demostrar que 98 es el valor máximo de (a XOR x) * (b XOR x) para todos los 0 <= x < 2^n.

Ejemplo 2:

Entrada: a = 6, b = 7, n = 5
Salida: 930
Explicación: Para x = 25, (a XOR x) = 31 y (b XOR x) = 30. Por lo tanto, (a XOR x) * (b XOR x) = 930.
Se puede demostrar que 930 es el valor máximo de (a XOR x) * (b XOR x) para todos los 0 <= x < 2^n.
Ejemplo 3:

Entrada: a = 1, b = 6, n = 3
Salida: 12
Explicación: Para x = 5, (a XOR x) = 4 y (b XOR x) = 3. Por lo tanto, (a XOR x) * (b XOR x) = 12.
Se puede demostrar que 12 es el valor máximo de (a XOR x) * (b XOR x) para todos los 0 <= x < 2^n.

Restricciones:

0 <= a, b < 2^50
0 <= n <= 50

Dados tres enteros a, b y n, devuelve el valor máximo de (a XOR x) * (b XOR x) donde 0 <= x < 2^n.
Dado que la respuesta puede ser demasiado grande, devuélvela módulo 10^9 + 7.
Ten en cuenta que XOR es la operación bitwise XOR.

Ejemplo 1:

Entrada: a = 12, b = 5, n = 4
Salida: 98
Explicación: Para x = 2, (a XOR x) = 14 y (b XOR x) = 7. Por lo tanto, (a XOR x) * (b XOR x) = 98.
Se puede demostrar que 98 es el valor máximo de (a XOR x) * (b XOR x) para todos 0 <= x < 2^n.

Ejemplo 2:

Entrada: a = 6, b = 7, n = 5
Salida: 930
Explicación: Para x = 25, (a XOR x) = 31 y (b XOR x) = 30. Por lo tanto, (a XOR x) * (b XOR x) = 930.
Se puede demostrar que 930 es el valor máximo de (a XOR x) * (b XOR x) para todos 0 <= x < 2^n.

Ejemplo 3:

Entrada: a = 1, b = 6, n = 3
Salida: 12
Explicación: Para x = 5, (a XOR x) = 4 y (b XOR x) = 3. Por lo tanto, (a XOR x) * (b XOR x) = 12.
Se puede demostrar que 12 es el valor máximo de (a XOR x) * (b XOR x) para todos 0 <= x < 2^n.

Restricciones:

0 <= a, b < 2^50
0 <= n <= 50


Se te da un array de enteros nums indexado desde 0. Un par de enteros x e y se denomina un par fuerte si satisface la condición:

|x - y| <= min(x, y)

Necesitas seleccionar dos enteros de nums de tal manera que formen un par fuerte y su XOR bit a bit sea el máximo entre todos los pares fuertes en el array.
Devuelve el valor máximo de XOR de todos los pares fuertes posibles en el array nums.
Ten en cuenta que puedes elegir el mismo entero dos veces para formar un par.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 7
Explicación: Hay 11 pares fuertes en el array nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) y (5, 5).
El máximo XOR posible de estos pares es 3 XOR 4 = 7.

Ejemplo 2:

Entrada: nums = [10,100]
Salida: 0
Explicación: Hay 2 pares fuertes en el array nums: (10, 10) y (100, 100).
El máximo XOR posible de estos pares es 10 XOR 10 = 0 ya que el par (100, 100) también da 100 XOR 100 = 0.

Ejemplo 3:

Entrada: nums = [5,6,25,30]
Salida: 7
Explicación: Hay 6 pares fuertes en el array nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) y (30, 30).
El máximo XOR posible de estos pares es 25 XOR 30 = 7 ya que el único otro valor de XOR diferente de cero es 5 XOR 6 = 3.

Restricciones:

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

Se le da una matriz de números enteros con índice 0. Un par de enteros x e y se llama par fuerte si satisface la condición

|x - y| <= min(x, y)

Tienes que seleccionar dos enteros de nums de forma que formen un par fuerte y su XOR bit a bit sea el máximo entre todos los pares fuertes de la matriz.
Devuelve el valor XOR máximo de todos los pares fuertes posibles de la matriz nums.
Tenga en cuenta que puede elegir el mismo número entero dos veces para formar un par.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 7
Explicación: Hay 11 pares fuertes en el array nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) y (5, 5).
El máximo XOR posible de estos pares es 3 XOR 4 = 7.

Ejemplo 2:

Entrada: números = [10,100]
Salida: 0
Explicación: Hay 2 pares fuertes en el array nums: (10, 10) y (100, 100).
El máximo XOR posible de estos pares es 10 XOR 10 = 0 ya que el par (100, 100) también da 100 XOR 100 = 0.

Ejemplo 3:

Entrada: nums = [5,6,25,30]
Salida: 7
Explicación: Hay 6 pares fuertes en el array nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) y (30, 30).
El máximo XOR posible de estos pares es 25 XOR 30 = 7, ya que el único otro valor XOR distinto de cero es 5 XOR 6 = 3.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums. Un par de números enteros x e y se denomina par fuerte si satisface la condición:

|x - y| <= min(x, y)

Debe seleccionar dos números enteros de nums de modo que formen un par fuerte y su XOR bit a bit sea el máximo entre todos los pares fuertes de la matriz.
Devuelva el valor XOR máximo de todos los pares fuertes posibles en la matriz nums.
Tenga en cuenta que puede elegir el mismo número entero dos veces para formar un par.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 7
Explicación: Hay 11 pares fuertes en la matriz nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) y (5, 5).
El XOR máximo posible a partir de estos pares es 3 XOR 4 = 7.

Ejemplo 2:

Entrada: nums = [10,100]
Salida: 0
Explicación: Hay 2 pares fuertes en la matriz nums: (10, 10) y (100, 100).
El XOR máximo posible a partir de estos pares es 10 XOR 10 = 0 ya que el par (100, 100) también da 100 XOR 100 = 0.

Ejemplo 3:

Entrada: nums = [5,6,25,30]
Salida: 7
Explicación: Hay 6 pares fuertes en la matriz nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) y (30, 30).
El XOR máximo posible a partir de estos pares es 25 XOR 30 = 7 ya que el único otro valor XOR distinto de cero es 5 XOR 6 = 3.

Restricciones:

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


Se te da un array de strings indexado desde 0 llamado words y un carácter x.
Devuelve un array de índices que representan las palabras que contienen el carácter x.
Ten en cuenta que el array devuelto puede estar en cualquier orden.

Ejemplo 1:

Entrada: words = ["leet","code"], x = "e"
Salida: [0,1]
Explicación: "e" aparece en ambas palabras: "leet" y "code". Por lo tanto, devolvemos los índices 0 y 1.

Ejemplo 2:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "a"
Salida: [0,2]
Explicación: "a" aparece en "abc" y "aaaa". Por lo tanto, devolvemos los índices 0 y 2.

Ejemplo 3:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "z"
Salida: []
Explicación: "z" no aparece en ninguna de las palabras. Por lo tanto, devolvemos un array vacío.

Restricciones:

1 <= words.length <= 50
1 <= words[i].length <= 50
x es una letra minúscula en inglés.
words[i] consiste solo en letras minúsculas en inglés.

Se le proporciona una matriz indexada en 0 de cadenas de palabras y un carácter x.
Devuelve una matriz de índices que representan las palabras que contienen el carácter x.
Tenga en cuenta que la matriz devuelta puede estar en cualquier orden.

Ejemplo 1:

Entrada: words = ["leet","code"], x = "e"
Salida: [0,1]
Explicación: "e" aparece en ambas palabras: "leet" y "código". Por lo tanto, devolvemos los índices 0 y 1.

Ejemplo 2:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "a"
Salida: [0,2]
Explicación: "a" aparece en "abc" y "aaaa". Por lo tanto, devolvemos los índices 0 y 2.

Ejemplo 3:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "z"
Salida: []
Explicación: "z" no aparece en ninguna de las palabras. Por lo tanto, devolvemos una matriz vacía.

Restricciones:

1 <= words.length <= 50
1 <= words[i].length <= 50
x es una letra minúscula del inglés.
words[i] consta únicamente de letras minúsculas del inglés.

Se le proporciona una arreglo indexada 0 de cadenas, palabras y un carácter x.
Devuelve una arreglo de índices que representan las palabras que contienen el carácter x.
Tenga en cuenta que la arreglo devuelta puede estar en cualquier orden.

Ejemplo 1:

Entrada: words = ["leet","code"], x = "e"
Salida: [0,1]
Explicación: "e" aparece en ambas palabras: "leet" y "code". Por lo tanto, devolvemos los índices 0 y 1.

Ejemplo 2:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "a"
Salida: [0,2]
Explicación: "a" aparece en "abc" y "aaaa". Por lo tanto, devolvemos los índices 0 y 2.

Ejemplo 3:

Entrada: words = ["abc","bcd","aaaa","cbc"], x = "z"
Producción: []
Explicación: la "z" no aparece en ninguna de las palabras. Por lo tanto, devolvemos una arreglo vacía.

Restricciones:

1 <= palabras.longitud <= 50
1 <= palabras[i].longitud <= 50
x es una letra inglesa minúscula.
words[i] consta solo de letras inglesas minúsculas.


Hay n bolas en una mesa, cada bola tiene un color negro o blanco.
Se te proporciona una cadena binaria s indexada desde 0 de longitud n, donde 1 y 0 representan bolas negras y blancas, respectivamente.
En cada paso, puedes elegir dos bolas adyacentes y cambiarlas.
Devuelve el número mínimo de pasos para agrupar todas las bolas negras a la derecha y todas las bolas blancas a la izquierda.

Ejemplo 1:

Entrada: s = "101"
Salida: 1
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambiar s[0] y s[1], s = "011".
Inicialmente, los 1 no están agrupados, lo que requiere al menos 1 paso para agruparlos a la derecha.

Ejemplo 2:

Entrada: s = "100"
Salida: 2
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambiar s[0] y s[1], s = "010".
- Intercambiar s[1] y s[2], s = "001".
Se puede probar que el número mínimo de pasos necesarios es 2.

Ejemplo 3:

Entrada: s = "0111"
Salida: 0
Explicación: Todas las bolas negras ya están agrupadas a la derecha.

Restricciones:

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

Hay n bolas sobre una mesa, cada bola tiene un color negro o blanco.
Se le proporciona una cadena binaria s indexada en 0 de longitud n, donde 1 y 0 representan bolas negras y blancas, respectivamente.
En cada paso, puede elegir dos bolas adyacentes e intercambiarlas.
Devuelva el número mínimo de pasos para agrupar todas las bolas negras a la derecha y todas las bolas blancas a la izquierda.

Ejemplo 1:

Entrada: s = "101"
Salida: 1
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambie s[0] y s[1], s = "011".
Inicialmente, los 1 no están agrupados, por lo que se requiere al menos 1 paso para agruparlos a la derecha. Ejemplo 2:

Entrada: s = "100"
Salida: 2
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambiamos s[0] y s[1], s = "010".
- Intercambiamos s[1] y s[2], s = "001".
Se puede demostrar que el número mínimo de pasos necesarios es 2.

Ejemplo 3:

Entrada: s = "0111"
Salida: 0
Explicación: Todas las bolas negras ya están agrupadas a la derecha.

Restricciones:

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

Hay n bolas en una mesa, cada bola tiene un color negro o blanco.
Se te proporciona una cadena binaria s indexada desde 0 de longitud n, donde 1 y 0 representan bolas negras y blancas, respectivamente.
En cada paso, puedes elegir dos bolas adyacentes y cambiarlas.
Devuelve el número mínimo de pasos para agrupar todas las bolas negras a la derecha y todas las bolas blancas a la izquierda.

Ejemplo 1:

Input: s = "101"
Output: 1
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambiar s[0] y s[1], s = "011".
Inicialmente, los 1 no están agrupados, lo que requiere al menos 1 paso para agruparlos a la derecha.

Ejemplo 2:

Input: s = "100"
Output: 2
Explicación: Podemos agrupar todas las bolas negras a la derecha de la siguiente manera:
- Intercambiar s[0] y s[1], s = "010".
- Intercambiar s[1] y s[2], s = "001".
Se puede probar que el número mínimo de pasos necesarios es 2.

Ejemplo 3:

Input: s = "0111"
Output: 0
Explicación: Todas las bolas negras ya están agrupadas a la derecha.

Restricciones:

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


Dada una matriz de enteros nums indexada desde 0 y un entero k.
Puedes realizar la siguiente operación en la matriz como máximo k veces:

Elige cualquier índice i de la matriz y aumenta o disminuye nums[i] en 1.

La puntuación de la matriz final es la frecuencia del elemento más frecuente en la matriz.
Devuelve la puntuación máxima que puedes lograr.
La frecuencia de un elemento es el número de ocurrencias de ese elemento en la matriz.

Ejemplo 1:

Entrada: nums = [1,2,6,4], k = 3
Salida: 3
Explicación: Podemos realizar las siguientes operaciones en la matriz:
- Elige i = 0, y aumenta el valor de nums[0] en 1. La matriz resultante es [2,2,6,4].
- Elige i = 3, y disminuye el valor de nums[3] en 1. La matriz resultante es [2,2,6,3].
- Elige i = 3, y disminuye el valor de nums[3] en 1. La matriz resultante es [2,2,6,2].
El elemento 2 es el más frecuente en la matriz final, así que nuestra puntuación es 3.
Se puede demostrar que no podemos lograr una mejor puntuación.

Ejemplo 2:

Entrada: nums = [1,4,4,2,4], k = 0
Salida: 3
Explicación: No podemos aplicar ninguna operación, por lo que nuestra puntuación será la frecuencia del elemento más frecuente en la matriz original, que es 3.

Restricciones:

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

Dada una matriz de enteros nums indexada desde 0 y un entero k.
Puedes realizar la siguiente operación en la matriz como máximo k veces:

Elige cualquier índice i de la matriz y aumenta o disminuye nums[i] en 1.

La puntuación de la matriz final es la frecuencia del elemento más frecuente en la matriz.
Devuelve la puntuación máxima que puedes lograr.
La frecuencia de un elemento es el número de veces de ese elemento en la matriz.

Ejemplo 1:

Entrada: nums = [1,2,6,4], k = 3
Salida: 3
Explicación: Podemos realizar las siguientes operaciones en la matriz:
Elige i = 0, y aumenta el valor de nums[0] en 1. La matriz resultante es [2,2,6,4].
Elige i = 3, y disminuye el valor de nums[3] en 1. La matriz resultante es [2,2,6,3].
Elige i = 3, y disminuye el valor de nums[3] en 1. La matriz resultante es [2,2,6,2].
El elemento 2 es el más frecuente en la matriz final, así que nuestra puntuación es 3.
Se puede demostrar que no podemos lograr una mejor puntuación.

Ejemplo 2:

Entrada: nums = [1,4,4,2,4], k = 0
Salida: 3
Explicación: No podemos aplicar ninguna operación, por lo que nuestra puntuación será la frecuencia del elemento más frecuente en la matriz original, que es 3.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums y un número entero k.
Puede realizar la siguiente operación en la matriz como máximo k veces:

Elija cualquier índice i de la matriz y aumente o disminuya nums[i] en 1.

La puntuación de la matriz final es la frecuencia del elemento más frecuente en la matriz.
Devuelva la puntuación máxima que puede lograr.
La frecuencia de un elemento es la cantidad de ocurrencias de ese elemento en la matriz.

Ejemplo 1:

Entrada: nums = [1,2,6,4], k = 3
Salida: 3
Explicación: Podemos realizar las siguientes operaciones en la matriz:
- Elija i = 0 y aumente el valor de nums[0] en 1. La matriz resultante es [2,2,6,4].
- Elija i = 3 y disminuya el valor de nums[3] en 1. La matriz resultante es [2,2,6,3].
- Elija i = 3 y disminuya el valor de nums[3] en 1. La matriz resultante es [2,2,6,2].
El elemento 2 es el más frecuente en la matriz final, por lo que nuestra puntuación es 3.
Se puede demostrar que no podemos lograr una puntuación mejor.

Ejemplo 2:

Entrada: nums = [1,4,4,2,4], k = 0
Salida: 3
Explicación: No podemos aplicar ninguna operación, por lo que nuestra puntuación será la frecuencia del elemento más frecuente en la matriz original, que es 3.

Restricciones:

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


Se le proporcionan dos números enteros positivos n y límite.
Devuelva el número total de formas de distribuir n caramelos entre 3 niños de modo que ninguno reciba más de límite de caramelos.

Ejemplo 1:

Entrada: n = 5, límite = 2
Salida: 3
Explicación: Hay 3 formas de distribuir 5 caramelos de modo que ningún niño reciba más de 2 caramelos: (1, 2, 2), (2, 1, 2) y (2, 2, 1).

Ejemplo 2:

Entrada: n = 3, límite = 3
Salida: 10
Explicación: Hay 10 maneras de distribuir 3 caramelos de manera que ningún niño reciba más de 3 caramelos: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) y (3, 0, 0).

Restricciones:

1 <= n <= 50
1 <= limit <= 50

Se te dan dos números enteros positivos n y limit.
Devuelve el número total de formas de distribuir n caramelos entre 3 niños de manera que ningún niño reciba más de limit caramelos.

Ejemplo 1:

Entrada: n = 5, limit = 2
Salida: 3
Explicación: Hay 3 formas de distribuir 5 caramelos de manera que ningún niño reciba más de 2 caramelos: (1, 2, 2), (2, 1, 2) y (2, 2, 1).

Ejemplo 2:

Entrada: n = 3, limit = 3
Salida: 10
Explicación: Hay 10 formas de distribuir 3 caramelos de manera que ningún niño reciba más de 3 caramelos: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) y (3, 0, 0).

Restricciones:

1 <= n <= 50
1 <= limit <= 50


Dado un número entero n.
Una cadena s se llama buena si contiene solo caracteres ingleses en minúscula y es posible reorganizar los caracteres de s de tal manera que la nueva cadena contenga "leet" como subcadena.
Por ejemplo:

El string "lteer" es bueno porque podemos reorganizarlo para formar "leetr".
"letl" no es bueno porque no podemos reorganizarlo para que contenga "leet" como subcadena.

Devuelve el número total de cadenas buenas de longitud n.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: n = 4
Salida: 12
Explicación: Las 12 cadenas que se pueden reorganizar para tener "leet" como subcadena son: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" y "tlee".

Ejemplo 2:

Entrada: n = 10
Salida: 83943898
Explicación: El número de cadenas de longitud 10 que se pueden reorganizar para tener "leet" como subcadena es 526083947580. Por lo tanto, la respuesta es 526083947580 % (10^9 + 7) = 83943898.

Restricciones:

1 <= n <= 10^5

Se le proporciona un entero n.
Una cadena s se considera buena si contiene solo caracteres en minúscula del inglés y es posible reorganizar los caracteres de s de modo que la nueva cadena contenga "leet" como subcadena.
Por ejemplo:

La cadena "lteer" es buena porque podemos reorganizarla para formar "leetr".
"letl" no es buena porque no podemos reorganizarla para que contenga "leet" como subcadena.

Devuelve el número total de cadenas buenas de longitud n.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: n = 4
Salida: 12
Explicación: Las 12 cadenas que se pueden reorganizar para tener "leet" como subcadena son: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" y "tlee".

Ejemplo 2:

Entrada: n = 10
Salida: 83943898
Explicación: La cantidad de cadenas con una longitud de 10 que se pueden reorganizar para tener "leet" como subcadena es 526083947580. Por lo tanto, la respuesta es 526083947580 % (10^9 + 7) = 83943898.

Restricciones:

1 <= n <= 10^5

Dado un número entero n.
Una cadena s se llama bueno si contiene solo caracteres ingleses en minúscula y es posible reorganizar los caracteres de s de tal manera que el nuevo cadena contenga "leet" como subcadena.
Por ejemplo:

La cadena "lteer" es bueno porque podemos reorganizarlo para formar "leetr".
"letl" no es bueno porque no podemos reorganizarlo para que contenga "leet" como subcadena.

Devuelve el número total de cadenas buenos de longitud n.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: n = 4
Salida: 12
Explicación: Las 12 cadenas que se pueden reorganizar para tener "leet" como subcadena son: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" y "tlee".

Ejemplo 2:

Entrada: n = 10
Salida: 83943898
Explicación: El número de cadenas de longitud 10 que se pueden reorganizar para tener "leet" como subcadena es 526083947580. Por lo tanto, la respuesta es 526083947580 % (10^9 + 7) = 83943898.

Restricciones:

1 <= n <= 10^5


Se le proporciona una cadena s indexada en 0 que tiene una longitud par n.
También se le proporciona una matriz de enteros 2D indexada en 0, consultas, donde consultas[i] = [a_i, b_i, c_i, d_i].
Para cada consulta i, se le permite realizar las siguientes operaciones:

Reorganizar los caracteres dentro de la subcadena s[a_i:b_i], donde 0 <= a_i <= b_i < n / 2.
Reorganizar los caracteres dentro de la subcadena s[c_i:d_i], donde n / 2 <= c_i <= d_i < n.

Para cada consulta, su tarea es determinar si es posible hacer que s sea un palíndromo realizando las operaciones.
Cada consulta se responde independientemente de las demás. Devuelve una matriz indexada en 0, donde answer[i] == true si es posible convertir s en un palíndromo realizando las operaciones especificadas por la consulta i^th, y false en caso contrario.

Una subcadena es una secuencia contigua de caracteres dentro de una cadena.
s[x:y] representa la subcadena que consta de caracteres desde el índice x hasta el índice y en s, ambos incluidos.

Ejemplo 1:

Entrada: s = "abcabc", consultas = [[1,1,3,5],[0,2,5,5]]
Salida: [true,true]
Explicación: En este ejemplo, hay dos consultas:
En la primera consulta:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Por lo tanto, se le permite reorganizar s[1:1] => abcabc y s[3:5] => abcabc.
- Para que s sea un palíndromo, s[3:5] se puede reorganizar para que se convierta en => abccba.
- Ahora, s es un palíndromo. Por lo tanto, answer[0] = true.
En la segunda consulta:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Por lo tanto, se le permite reorganizar s[0:2] => abcabc y s[5:5] => abcabc.
- Para que s sea un palíndromo, s[0:2] se puede reorganizar para que se convierta en => cbaabc.
- Ahora, s es un palíndromo. Por lo tanto, answer[1] = true.

Ejemplo 2:

Entrada: s = "abbcdecbba", consultas = [[0,2,7,9]]
Salida: [false]
Explicación: En este ejemplo, solo hay una consulta.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Por lo tanto, se le permite reorganizar s[0:2] => abbcdecbba y s[7:9] => abbcdecbba.
No es posible hacer que s sea un palíndromo reorganizando estas subcadenas porque s[3:6] no es un palíndromo.
Por lo tanto, answer[0] = false.
Ejemplo 3:

Entrada: s = "acbcab", consultas = [[1,2,4,5]]
Salida: [true]
Explicación: En este ejemplo, solo hay una consulta.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Por lo tanto, se le permite reorganizar s[1:2] => acbcab y s[4:5] => acbcab.
Para que s sea un palíndromo, s[1:2] se puede reorganizar para convertirse en abccab.
Luego, s[4:5] se puede reorganizar para convertirse en abccba.
Ahora, s es un palíndromo. Por lo tanto, answer[0] = true.

Restricciones:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n es par.
s consta únicamente de letras minúsculas del alfabeto inglés.

Se le proporciona una cadena s indexada en 0 que tiene una longitud par n.
También se le proporciona una matriz de enteros 2D indexada en 0, queries, donde queries[i] = [a_i, b_i, c_i, d_i].
Para cada consulta i, se le permite realizar las siguientes operaciones:

Reorganizar los caracteres dentro de la subcadena s[a_i:b_i], donde 0 <= a_i <= b_i < n / 2.
Reorganizar los caracteres dentro de la subcadena s[c_i:d_i], donde n / 2 <= c_i <= d_i < n.

Para cada consulta, su tarea es determinar si es posible hacer que s sea un palíndromo realizando las operaciones.
Cada consulta se responde independientemente de las demás. Devuelve una matriz indexada en 0, donde answer[i] == true si es posible convertir s en un palíndromo realizando las operaciones especificadas por la consulta i^th, y false en caso contrario.

Una subcadena es una secuencia contigua de caracteres dentro de una cadena.
s[x:y] representa la subcadena que consta de caracteres desde el índice x hasta el índice y en s, ambos incluidos.

Ejemplo 1:

Entrada: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Salida: [true,true]
Explicación: En este ejemplo, hay dos queries:
En la primera consulta:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Por lo tanto, se le permite reorganizar s[1:1] => abcabc y s[3:5] => abcabc.
- Para que s sea un palíndromo, s[3:5] se puede reorganizar para que se convierta en => abccba.
- Ahora, s es un palíndromo. Por lo tanto, answer[0] = true.
En la segunda consulta:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Por lo tanto, se le permite reorganizar s[0:2] => abcabc y s[5:5] => abcabc.
- Para que s sea un palíndromo, s[0:2] se puede reorganizar para que se convierta en => cbaabc.
- Ahora, s es un palíndromo. Por lo tanto, answer[1] = true.

Ejemplo 2:

Entrada: s = "abbcdecbba", queries = [[0,2,7,9]]
Salida: [false]
Explicación: En este ejemplo, solo hay una consulta.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Por lo tanto, se le permite reorganizar s[0:2] => abbcdecbba y s[7:9] => abbcdecbba.
No es posible hacer que s sea un palíndromo reorganizando estas subcadenas porque s[3:6] no es un palíndromo.
Por lo tanto, answer[0] = false.
Ejemplo 3:

Entrada: s = "acbcab", queries = [[1,2,4,5]]
Salida: [true]
Explicación: En este ejemplo, solo hay una consulta.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Por lo tanto, se le permite reorganizar s[1:2] => acbcab y s[4:5] => acbcab.
Para que s sea un palíndromo, s[1:2] se puede reorganizar para convertirse en abccab.
Luego, s[4:5] se puede reorganizar para convertirse en abccba.
Ahora, s es un palíndromo. Por lo tanto, answer[0] = true.

Restricciones:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n es par.
s consta únicamente de letras minúsculas del alfabeto inglés.

Se te da una cadena de caracteres `s` indexada desde 0, con una longitud par `n`.
También se te proporciona una matriz 2D de enteros `queries`, donde `queries[i] = [a_i, b_i, c_i, d_i]`.
Para cada consulta `i`, puedes realizar las siguientes operaciones:

Reorganizar los caracteres dentro del subcadena `s[a_i:b_i]`, donde `0 <= a_i <= b_i < n / 2`.
Reorganizar los caracteres dentro del subcadena `s[c_i:d_i]`, donde `n / 2 <= c_i <= d_i < n`.

Para cada consulta, tu tarea es determinar si es posible convertir `s` en un palíndromo realizando las operaciones.
Cada consulta se responde de forma independiente de las demás.
Devuelve una matriz indexada desde 0 `answer`, donde `answer[i] == true` si es posible hacer `s` un palíndromo realizando las operaciones especificadas por la consulta i-ésima, y `false` en caso contrario.

Un subcadena es una secuencia continua de caracteres dentro de una cadena.
`s[x:y]` representa el subcadena que consiste en caracteres desde el índice `x` hasta el índice `y` en `s`, ambos inclusivos.

Ejemplo 1:

Entrada: `s = "abcabc"`, `queries = [[1,1,3,5],[0,2,5,5]]`
Salida: `[true,true]`
Explicación: En este ejemplo, hay dos consultas:
En la primera consulta:
- `a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5`.
- Puedes reorganizar `s[1:1] => abcabc` y `s[3:5] => abcabc`.
- Para hacer `s` un palíndromo, `s[3:5]` puede reorganizarse para convertirse en => `abccba`.
- Ahora, `s` es un palíndromo. Por lo tanto, `answer[0] = true`.
En la segunda consulta:
- `a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5`.
- Puedes reorganizar `s[0:2] => abcabc` y `s[5:5] => abcabc`.
- Para hacer `s` un palíndromo, `s[0:2]` puede reorganizarse para convertirse en => `cbaabc`.
- Ahora, `s` es un palíndromo. Por lo tanto, `answer[1] = true`.

Ejemplo 2:

Entrada: `s = "abbcdecbba"`, `queries = [[0,2,7,9]]`
Salida: `[false]`
Explicación: En este ejemplo, solo hay una consulta.
`a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.`
Puedes reorganizar `s[0:2] => abbcdecbba` y `s[7:9] => abbcdecbba`.
No es posible hacer `s` un palíndromo reorganizando estos subcadenas porque `s[3:6]` no es un palíndromo.
Por lo tanto, `answer[0] = false`.

Ejemplo 3:

Entrada: `s = "acbcab"`, `queries = [[1,2,4,5]]`
Salida: `[true]`
Explicación: En este ejemplo, solo hay una consulta.
`a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.`
Puedes reorganizar `s[1:2] => acbcab` y `s[4:5] => acbcab`.
Para hacer `s` un palíndromo, `s[1:2]` puede reorganizarse para convertirse en `abccab`.
Luego, `s[4:5]` puede reorganizarse para convertirse en `abccba`.
Ahora, `s` es un palíndromo. Por lo tanto, `answer[0] = true`.

Restricciones:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n es par.
`s` consiste solo en letras minúsculas del alfabeto inglés.