Se te da un arreglo binario nums.
Un subarreglo de un arreglo es bueno si contiene exactamente un elemento con el valor 1.
Devuelve un número entero que denote la cantidad de formas de dividir el arreglo nums en subarreglos buenos. Como el número puede ser demasiado grande, devuélvelo módulo 10^9 + 7.
Un subarreglo es una secuencia contigua y no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums = [0,1,0,0,1]
Salida: 3
Explicación: Hay 3 formas de dividir nums en subarreglos buenos:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Ejemplo 2:

Entrada: nums = [0,1,0]
Salida: 1
Explicación: Hay 1 forma de dividir nums en subarreglos buenos:
- [0,1,0]

Restricciones:

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

Se te da un array binario nums.
Un subarray de un array es bueno si contiene exactamente un elemento con el valor 1.
Devuelve un número entero que denote la cantidad de formas de dividir el array nums en subarrays buenos. Como el número puede ser demasiado grande, devuélvelo módulo 10^9 + 7.
Un subarray es una secuencia contigua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [0,1,0,0,1]
Salida: 3
Explicación: Hay 3 formas de dividir nums en subarrays buenos:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Ejemplo 2:

Entrada: nums = [0,1,0]
Salida: 1
Explicación: Hay 1 forma de dividir nums en subarrays buenos:
- [0,1,0]

Restricciones:

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

Se le proporciona una matriz binaria nums.
Una submatriz de una matriz es buena si contiene exactamente un elemento con el valor 1.
Devuelve un entero que indica la cantidad de formas de dividir la matriz nums en submatrices buenas. Como el número puede ser demasiado grande, devuélvalo módulo 10^9 + 7.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [0,1,0,0,1]
Salida: 3
Explicación: Hay 3 formas de dividir nums en submatrices adecuadas:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Ejemplo 2:

Entrada: nums = [0,1,0]
Salida: 1
Explicación: Hay 1 forma de dividir nums en submatrices adecuadas:
- [0,1,0]

Restricciones:

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


Se te da una matriz de enteros indexada desde 0 llamado nums. Una submatriz de nums se llama continuo si:

Sean i, i + 1, ..., j_ los índices en la submatriz. Entonces, para cada par de índices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Devuelve el número total de submatrices  continuas.
Una submatriz es una secuencia no vacía y contigua de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [5,4,2,4]
Salida: 8
Explicación:
Subarray continuo de tamaño 1: [5], [4], [2], [4].
Subarray continuo de tamaño 2: [5,4], [4,2], [2,4].
Subarray continuo de tamaño 3: [4,2,4].
No hay subarrays de tamaño 4.
Total de subarrays continuos = 4 + 3 + 1 = 8.
Se puede demostrar que no hay más subarrays continuos.

Ejemplo 2:

Entrada: nums = [1,2,3]
Salida: 6
Explicación:
Subarray continuo de tamaño 1: [1], [2], [3].
Subarray continuo de tamaño 2: [1,2], [2,3].
Subarray continuo de tamaño 3: [1,2,3].
Total de subarrays continuos = 3 + 2 + 1 = 6.

Restricciones:

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

Se le da una matriz de números enteros con índice 0. Una submatriz de nums se llama continua si:

Sean i, i + 1, ..., j_ los índices de la submatriz. Entonces, para cada par de índices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Devuelve el número total de submatrices continuas.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [5,4,2,4]
Salida: 8
Explicación:
Subarray continuo de tamaño 1: [5], [4], [2], [4].
Subarray continuo de tamaño 2: [5,4], [4,2], [2,4].
Submatriz continua de tamaño 3: [4,2,4].
No hay submatrices de tamaño 4.
Total submatrices continuas = 4 + 3 + 1 = 8.
Se puede demostrar que no hay más submatrices continuas.

Ejemplo 2:

Entrada: nums = [1,2,3]
Salida: 6
Explicación:
Subarray continuo de tamaño 1: [1], [2], [3].
Subarray continuo de tamaño 2: [1,2], [2,3].
Submatriz continua de tamaño 3: [1,2,3].
Total de submatrices continuas = 3 + 2 + 1 = 6.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums. Una submatriz de nums se denomina continua si:

Sean i, i + 1, ..., j_ los índices de la submatriz. Entonces, para cada par de índices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Devuelve el número total de submatrices continuas.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [5,4,2,4]
Salida: 8
Explicación:
Submatriz continua de tamaño 1: [5], [4], [2], [4].
Submatriz continua de tamaño 2: [5,4], [4,2], [2,4].
Subarreglo continuo de tamaño 3: [4,2,4].
No hay ningún subarreglo de tamaño 4.
Total de subarreglos continuos = 4 + 3 + 1 = 8.
Se puede demostrar que no hay más subarreglos continuos.

Ejemplo 2:

Entrada: nums = [1,2,3]
Salida: 6
Explicación:
Subarreglo continuo de tamaño 1: [1], [2], [3].
Subarreglo continuo de tamaño 2: [1,2], [2,3].
Subarreglo continuo de tamaño 3: [1,2,3].
Total de subarreglos continuos = 3 + 2 + 1 = 6.

Restricciones:

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


Se te dan dos arreglos de enteros nums1 y nums2 de longitud n, indexados desde cero.
Definamos otro arreglo de enteros, nums3, de longitud n. Para cada índice i en el rango [0, n - 1], puedes asignar nums1[i] o nums2[i] a nums3[i].
Tu tarea es maximizar la longitud del subarreglo no decreciente más largo en nums3 eligiendo sus valores de manera óptima.
Devuelve un entero que representa la longitud del subarreglo no decreciente más largo en nums3.
Nota: Un subarreglo es una secuencia contigua no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums1 = [2,3,1], nums2 = [1,2,1]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
El subarreglo que comienza en el índice 0 y termina en el índice 1, [2,2], forma un subarreglo no decreciente de longitud 2.
Podemos demostrar que 2 es la longitud máxima alcanzable.
Ejemplo 2:

Entrada: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Salida: 4
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Todo el arreglo forma un subarreglo no decreciente de longitud 4, siendo esta la longitud máxima alcanzable.

Ejemplo 3:

Entrada: nums1 = [1,1], nums2 = [2,2]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums1[1]] => [1,1].
Todo el arreglo forma un subarreglo no decreciente de longitud 2, siendo esta la longitud máxima alcanzable.

Restricciones:

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

Se le proporcionan dos matrices de enteros indexados en 0, nums1 y nums2, de longitud n.
Definamos otra matriz de enteros indexada en 0, nums3, de longitud n. Para cada índice i en el rango [0, n - 1], puede asignar nums1[i] o nums2[i] a nums3[i].
Su tarea es maximizar la longitud de la submatriz no decreciente más larga en nums3 eligiendo sus valores de manera óptima.
Devuelva un entero que represente la longitud de la submatriz no decreciente más larga en nums3.
Nota: Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums1 = [2,3,1], nums2 = [1,2,1]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
El subarreglo que comienza en el índice 0 y termina en el índice 1, [2,2], forma un subarreglo no decreciente de longitud 2.
Podemos demostrar que 2 es la longitud máxima alcanzable.
Ejemplo 2:

Entrada: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Salida: 4
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
La matriz completa forma una submatriz no decreciente de longitud 4, lo que la convierte en la longitud máxima alcanzable.

Ejemplo 3:

Entrada: nums1 = [1,1], nums2 = [2,2]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums1[1]] => [1,1].
La matriz completa forma una submatriz no decreciente de longitud 2, lo que la convierte en la longitud máxima alcanzable.

Restricciones:

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

Se te dan dos arreglos de enteros nums1 y nums2 de longitud n, indexados desde cero.
Definamos otro arreglo de enteros, nums3, de longitud n. Para cada índice i en el rango [0, n - 1], puedes asignar nums1[i] o nums2[i] a nums3[i].
Tu tarea es maximizar la longitud de la subarreglo no decreciente más larga en nums3 eligiendo sus valores de manera óptima.
Devuelve un entero que representa la longitud de la subarreglo no decreciente más larga en nums3.
Nota: Un subarreglo es una secuencia contigua no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums1 = [2,3,1], nums2 = [1,2,1]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
El subarreglo que comienza en el índice 0 y termina en el índice 1, [2,2], forma un subarreglo no decreciente de longitud 2.
Podemos demostrar que 2 es la longitud máxima alcanzable.

Ejemplo 2:

Entrada: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Salida: 4
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Todo el arreglo forma un subarreglo no decreciente de longitud 4, siendo esta la longitud máxima alcanzable.

Ejemplo 3:

Entrada: nums1 = [1,1], nums2 = [2,2]
Salida: 2
Explicación: Una forma de construir nums3 es:
nums3 = [nums1[0], nums1[1]] => [1,1].
Todo el arreglo forma un subarreglo no decreciente de longitud 2, siendo esta la longitud máxima alcanzable.

Restricciones:

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


Se te da un arreglo de enteros indexado desde 0, nums. Un subarreglo s de longitud m se llama alternante si:

m es mayor que 1.
s_1 = s_0 + 1.
El subarreglo indexado desde 0, s, tiene la forma de [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. En otras palabras, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, y así sucesivamente hasta s[m - 1] - s[m - 2] = (-1)^m.

Devuelve la longitud máxima de todos los subarreglos alternantes presentes en nums o -1 si no existe tal subarreglo.
Un subarreglo es una secuencia contigua y no vacía de elementos dentro de un arreglo.

Ejemplo 1:

Entrada: nums = [2,3,4,3,4]
Salida: 4
Explicación: Los subarreglos alternantes son [3,4], [3,4,3], y [3,4,3,4]. El más largo de estos es [3,4,3,4], que tiene longitud 4.

Ejemplo 2:

Entrada: nums = [4,5,6]
Salida: 2
Explicación: [4,5] y [5,6] son los únicos dos subarreglos alternantes. Ambos tienen longitud 2.

Restricciones:

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

Se te da un array de enteros indexado desde 0, nums. Un subarray s de longitud m se llama alternante si:

m es mayor que 1.
s_1 = s_0 + 1.
El subarray indexado desde 0, s, luce como [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. En otras palabras, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, y así sucesivamente hasta s[m - 1] - s[m - 2] = (-1)^m.

Devuelve la longitud máxima de todos los subarrays alternantes presentes en nums o -1 si no existe tal subarray.
Un subarray es una secuencia contigua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [2,3,4,3,4]
Salida: 4
Explicación: Los subarrays alternantes son [3,4], [3,4,3], y [3,4,3,4]. El más largo de estos es [3,4,3,4], que tiene longitud 4.

Ejemplo 2:

Entrada: nums = [4,5,6]
Salida: 2
Explicación: [4,5] y [5,6] son los únicos dos subarrays alternantes. Ambos tienen longitud 2.

Restricciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums. Una submatriz s de longitud m se denomina alterna si:

m es mayor que 1.
s_1 = s_0 + 1.
La submatriz indexada en 0 s se ve así: [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. En otras palabras, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, y así sucesivamente hasta s[m - 1] - s[m - 2] = (-1)^m.

Devuelve la longitud máxima de todas las submatrices alternas presentes en nums o -1 si no existe ninguna submatriz de este tipo.

Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [2,3,4,3,4]
Salida: 4
Explicación: Los subconjuntos alternos son [3,4], [3,4,3] y [3,4,3,4]. El más largo de estos es [3,4,3,4], que tiene una longitud de 4.

Ejemplo 2:

Entrada: nums = [4,5,6]
Salida: 2
Explicación: [4,5] y [5,6] son los únicos dos subconjuntos alternos. Ambos tienen una longitud de 2.

Restricciones:

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


Se te da un array indexado a 0 nums que consiste en enteros positivos. Puedes realizar la siguiente operación en el array un número cualquiera de veces:

Elige un entero i tal que 0 <= i < nums.length - 1 y nums[i] <= nums[i + 1]. Reemplaza el elemento nums[i + 1] por nums[i] + nums[i + 1] y elimina el elemento nums[i] del array.

Devuelve el valor del elemento más grande que puedas obtener en el array final.

Ejemplo 1:

Entrada: nums = [2,3,7,9,3]
Salida: 21
Explicación: Podemos aplicar las siguientes operaciones en el array:
- Elegir i = 0. El array resultante será nums = [5,7,9,3].
- Elegir i = 1. El array resultante será nums = [5,16,3].
- Elegir i = 0. El array resultante será nums = [21,3].
El elemento más grande en el array final es 21. Se puede demostrar que no se puede obtener un elemento más grande.

Ejemplo 2:

Entrada: nums = [5,3,3]
Salida: 11
Explicación: Podemos hacer las siguientes operaciones en el array:
- Elegir i = 1. El array resultante será nums = [5,6].
- Elegir i = 0. El array resultante será nums = [11].
Solo hay un elemento en el array final, que es 11.

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums que consta de números enteros positivos.
Puede realizar la siguiente operación en la matriz cualquier cantidad de veces:

Elija un número entero i tal que 0 <= i < nums.length - 1 y nums[i] <= nums[i + 1]. Reemplace el elemento nums[i + 1] con nums[i] + nums[i + 1] y elimine el elemento nums[i] de la matriz.

Devuelva el valor del elemento más grande que pueda obtener en la matriz final.

Ejemplo 1:

Entrada: nums = [2,3,7,9,3]
Salida: 21
Explicación: Podemos aplicar las siguientes operaciones en la matriz:
- Elija i = 0. La matriz resultante será nums = [5,7,9,3].
- Elija i = 1. La matriz resultante será nums = [5,16,3].
- Elija i = 0. La matriz resultante será nums = [21,3].
El elemento más grande de la matriz final es 21. Se puede demostrar que no podemos obtener un elemento más grande.

Ejemplo 2:

Entrada: nums = [5,3,3]
Salida: 11
Explicación: Podemos realizar las siguientes operaciones en la matriz:
- Elija i = 1. La matriz resultante será nums = [5,6].
- Elija i = 0. La matriz resultante será nums = [11].
Solo hay un elemento en la matriz final, que es 11.

Restricciones:

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

Se le da un array nums con índice 0 formado por enteros positivos.
Puede realizar la siguiente operación en la matriz cualquier número de veces:

Elija un número entero i tal que 0 <= i < nums.length - 1 y nums[i] <= nums[i + 1]. Sustituya el elemento números[i + 1] por nums[i] + nums[i + 1] y elimine el elemento nums[i] de la matriz.

Devuelve el valor del elemento más grande que puedas obtener en el array final.

Ejemplo 1:

Entrada: nums = [2,3,7,9,3]
Salida: 21
Explicación: Podemos aplicar las siguientes operaciones sobre el array:
- Elegir i = 0. El array resultante será nums = [5,7,9,3].
- Elegir i = 1. La matriz resultante será nums = [5,16,3].
- Elige i = 0. La matriz resultante será nums = [21,3].
El elemento mayor de la matriz final es 21. Se puede demostrar que no se puede obtener un elemento mayor.

Ejemplo 2:

Entrada: nums = [5,3,3]
Salida: 11
Explicación: Podemos hacer las siguientes operaciones sobre el array:
- Elegir i = 1. El array resultante será nums = [5,6].
- Elegir i = 0. La matriz resultante será números = [11].
Sólo hay un elemento en la matriz final, que es 11.

Restricciones:

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


Se te da un entero n. Decimos que dos enteros x e y forman un par de números primos si:

1 <= x <= y <= n
x + y == n
x e y son números primos

Devuelve la lista 2D ordenada de pares de números primos [x_i, y_i]. La lista debe estar ordenada en orden creciente de x_i. Si no hay pares de números primos, devuelve un arreglo vacío.
Nota: Un número primo es un número natural mayor que 1 con solo dos factores: él mismo y 1.

Ejemplo 1:

Entrada: n = 10
Salida: [[3,7],[5,5]]
Explicación: En este ejemplo, hay dos pares primos que cumplen con los criterios.
Estos pares son [3,7] y [5,5], y los devolvemos en el orden indicado en el enunciado del problema.

Ejemplo 2:

Entrada: n = 2
Salida: []
Explicación: Podemos mostrar que no hay ningún par de números primos que dé una suma de 2, por lo que devolvemos un arreglo vacío.

Restricciones:

1 <= n <= 10^6

Se le proporciona un número entero n. Decimos que dos números enteros x e y forman un par de números primos si:

1 <= x <= y <= n
x + y == n
x e y son números primos

Devuelva la lista ordenada en 2D de pares de números primos [x_i, y_i]. La lista debe ordenarse en orden creciente de x_i. Si no hay ningún par de números primos, devuelva una matriz vacía.
Nota: Un número primo es un número natural mayor que 1 con solo dos factores, él mismo y 1.

Ejemplo 1:

Entrada: n = 10
Salida: [[3,7],[5,5]]
Explicación: En este ejemplo, hay dos pares de números primos que satisfacen los criterios.
Estos pares son [3,7] y [5,5], y los devolvemos en el orden ordenado como se describe en el enunciado del problema.

Ejemplo 2:

Entrada: n = 2
Salida: []
Explicación: Podemos demostrar que no existe ningún par de números primos que dé como resultado 2, por lo que devolvemos una matriz vacía.

Restricciones:

1 <= n <= 10^6


Hay n empleados en una empresa, numerados del 0 al n - 1. Cada empleado i ha trabajado horas[i] horas en la empresa.
La empresa requiere que cada empleado trabaje al menos target horas.
Se te da un arreglo 0-indexado de enteros no negativos hours de longitud n y un entero no negativo target.
Devuelve el entero que indica el número de empleados que trabajaron al menos target horas.

Ejemplo 1:

Entrada: hours = [0,1,2,3,4], target = 2
Salida: 3
Explicación: La empresa quiere que cada empleado trabaje al menos 2 horas.
- El empleado 0 trabajó 0 horas y no cumplió con el objetivo.
- El empleado 1 trabajó 1 hora y no cumplió con el objetivo.
- El empleado 2 trabajó 2 horas y cumplió con el objetivo.
- El empleado 3 trabajó 3 horas y cumplió con el objetivo.
- El empleado 4 trabajó 4 horas y cumplió con el objetivo.
Hay 3 empleados que cumplieron con el objetivo.

Ejemplo 2:

Entrada: hours = [5,1,4,2,2], target = 6
Salida: 0
Explicación: La empresa quiere que cada empleado trabaje al menos 6 horas.
Hay 0 empleados que cumplieron con el objetivo.

Restricciones:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Hay n empleados en una empresa, numerados del 0 al n - 1. Cada empleado i ha trabajado horas[i] horas en la empresa.
La empresa requiere que cada empleado trabaje al menos las horas objetivo.
Se te da un arreglo 0-indexado de enteros no negativos hours de longitud n y un entero no negativo target.
Devuelve el entero que indica el número de empleados que trabajaron al menos las horas objetivo.

Ejemplo 1:

Entrada: hours = [0,1,2,3,4], target = 2
Salida: 3
Explicación: La empresa quiere que cada empleado trabaje al menos 2 horas.
- El empleado 0 trabajó 0 horas y no cumplió con el objetivo.
- El empleado 1 trabajó 1 hora y no cumplió con el objetivo.
- El empleado 2 trabajó 2 horas y cumplió con el objetivo.
- El empleado 3 trabajó 3 horas y cumplió con el objetivo.
- El empleado 4 trabajó 4 horas y cumplió con el objetivo.
Hay 3 empleados que cumplieron con el objetivo.

Ejemplo 2:

Entrada: hours = [5,1,4,2,2], target = 6
Salida: 0
Explicación: La empresa quiere que cada empleado trabaje al menos 6 horas.
Hay 0 empleados que cumplieron con el objetivo.

Restricciones:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

En una empresa hay n empleados, numerados de 0 a n - 1. Cada empleado i ha trabajado durante horas[i] horas en la empresa.
La empresa exige que cada empleado trabaje un mínimo de horas objetivo.
Se le da un array de enteros no negativos horas de longitud n y un entero no negativo objetivo.
Devuelva el entero que denota el número de empleados que trabajaron al menos las horas objetivo.

Ejemplo 1

Entrada: hours = [0,1,2,3,4], target = 2
Salida: 3
Explicación: La empresa quiere que cada empleado trabaje al menos 2 horas.
- El empleado 0 trabajó 0 horas y no cumplió el objetivo.
- El empleado 1 trabajó 1 hora y no cumplió el objetivo.
- El empleado 2 ha trabajado 2 horas y ha cumplido el objetivo.
- El empleado 3 trabajó 3 horas y cumplió el objetivo.
- El empleado 4 trabajó 4 horas y cumplió el objetivo.
Hay 3 empleados que cumplieron el objetivo.

Ejemplo 2. Horas

Entrada: hours = [5,1,4,2,2], target = 6
Salida: 0
Explicación: La empresa quiere que cada empleado trabaje al menos 6 horas.
Hay 0 empleados que cumplen el objetivo.

Restricciones:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5


Dadas tres cadenas a, b y c, tu tarea es encontrar una cadena que tenga la longitud mínima y contenga las tres cadenas como subcadenas.
Si hay múltiples cadenas posibles, devuelve la menor lexicográficamente.
Devuelve una cadena que denote la respuesta al problema.
Notas

Una cadena a es lexicográficamente menor que una cadena b (de la misma longitud) si, en la primera posición donde a y b difieren, a tiene una letra que aparece antes en el alfabeto que la letra correspondiente en b.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: a = "abc", b = "bca", c = "aaa"
Salida: "aaabca"
Explicación: Mostramos que "aaabca" contiene todas las cadenas dadas: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Se puede demostrar que la longitud de la cadena resultante sería al menos 6 y "aaabca" es la menor lexicográficamente.
Ejemplo 2:

Entrada: a = "ab", b = "ba", c = "aba"
Salida: "aba"
Explicación: Mostramos que la cadena "aba" contiene todas las cadenas dadas: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Dado que la longitud de c es 3, la longitud de la cadena resultante sería al menos 3. Se puede demostrar que "aba" es la menor lexicográficamente.

Restricciones:

1 <= a.length, b.length, c.length <= 100
a, b, c consisten solo de letras minúsculas del alfabeto inglés.

Dadas tres cadenas a, b y c, su tarea es encontrar una cadena que tenga la longitud mínima y contenga las tres cadenas como subcadenas.
Si hay varias cadenas de este tipo, devuelva la más pequeña lexicográficamente.
Devuelva una cadena que denote la respuesta al problema.
Notas

Una cadena a es lexicográficamente más pequeña que una cadena b (de la misma longitud) si en la primera posición donde a y b difieren, la cadena a tiene una letra que aparece antes en el alfabeto que la letra correspondiente en b.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: a = "abc", b = "bca", c = "aaa"
Salida: "aaabca"
Explicación: Demostramos que "aaabca" contiene todas las cadenas dadas: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Se puede demostrar que la longitud de la cadena resultante sería al menos 6 y "aaabca" es la más pequeña lexicográficamente.
Ejemplo 2:

Entrada: a = "ab", b = "ba", c = "aba"
Salida: "aba"
Explicación: Demostramos que la cadena "aba" contiene todas las cadenas dadas: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Como la longitud de c es 3, la longitud de la cadena resultante sería al menos 3. Se puede demostrar que "aba" es la más pequeña lexicográficamente.

Restricciones:

1 <= a.length, b.length, c.length <= 100
a, b, c constan únicamente de letras minúsculas del inglés.


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

Elige cualquier subarreglo de tamaño k del conjunto y disminuye todos sus elementos en 1.

Devuelve true si puedes hacer que todos los elementos del arreglo sean iguales a 0, o false en caso contrario.
Un subarreglo es una parte contigua y no vacía de un arreglo.

Ejemplo 1:

Entrada: nums = [2,2,3,1,1,0], k = 3
Salida: true
Explicación: Podemos hacer las siguientes operaciones:
- Elige el subarreglo [2,2,3]. El conjunto resultante será nums = [1,1,2,1,1,0].
- Elige el subarreglo [2,1,1]. El conjunto resultante será nums = [1,1,1,0,0,0].
- Elige el subarreglo [1,1,1]. El conjunto resultante será nums = [0,0,0,0,0,0].

Ejemplo 2:

Entrada: nums = [1,3,1,1], k = 2
Salida: false
Explicación: No es posible hacer que todos los elementos del arreglo sean iguales a 0.

Restricciones:

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

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

Elige cualquier subarreglo de tamaño k del arreglo y disminuye todos sus elementos en 1.

Devuelve true si puedes hacer que todos los elementos del arreglo sean iguales a 0, o false en caso contrario.
Un subarreglo es una parte contigua y no vacía de un arreglo.

Ejemplo 1:

Entrada: nums = [2,2,3,1,1,0], k = 3
Salida: true
Explicación: Podemos hacer las siguientes operaciones:
- Elige el subarreglo [2,2,3]. El arreglo resultante será nums = [1,1,2,1,1,0].
- Elige el subarreglo [2,1,1]. El arreglo resultante será nums = [1,1,1,0,0,0].
- Elige el subarreglo [1,1,1]. El arreglo resultante será nums = [0,0,0,0,0,0].

Ejemplo 2:

Entada: nums = [1,3,1,1], k = 2
Salida: false
Explicación: No es posible hacer que todos los elementos del arreglo sean iguales a 0.

Restricciones:

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

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

Elija cualquier submatriz de tamaño k de la matriz y disminuya todos sus elementos en 1.

Devuelva verdadero si puede hacer que todos los elementos de la matriz sean iguales a 0, o falso en caso contrario.
Una submatriz es una parte contigua no vacía de una matriz.

Ejemplo 1:

Entrada: nums = [2,2,3,1,1,0], k = 3
Salida: true
Explicación: Podemos realizar las siguientes operaciones:
- Elija la submatriz [2,2,3]. La matriz resultante será nums = [1,1,2,1,1,0].
- Elija la submatriz [2,1,1]. La matriz resultante será nums = [1,1,1,0,0,0].
- Elija la submatriz [1,1,1]. La matriz resultante será nums = [0,0,0,0,0,0].

Ejemplo 2:

Entrada: nums = [1,3,1,1], k = 2
Salida: false
Explicación: No es posible hacer que todos los elementos de la matriz sean iguales a 0.

Restricciones:

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


Dada una cadena s y un entero k, divide s en k subcadenas de manera que la suma del número de cambios de letras necesarios para convertir cada subcadena en un semi-palíndromo se minimice.
Devuelve un entero que denota el número mínimo de cambios de letras requeridos.
Notas

Una cadena es un palíndromo si se puede leer de la misma manera de izquierda a derecha y de derecha a izquierda.
Una cadena con una longitud de len se considera un semi-palíndromo si existe un entero positivo d tal que 1 <= d < len y len % d == 0, y si tomamos índices que tienen el mismo módulo por d, forman un palíndromo. Por ejemplo, "aa", "aba", "adbgad" y "abab" son semi-palíndromos y "a", "ab" y "abca" no lo son.
Una subcadena es una secuencia continua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "abcac", k = 2
Salida: 1
Explicación: Podemos dividir s en subcadenas "ab" y "cac". La cadena "cac" ya es un semi-palíndromo. Si cambiamos "ab" a "aa", se convierte en un semi-palíndromo con d = 1.
Se puede mostrar que no hay forma de dividir la cadena "abcac" en dos subcadenas de semi-palíndromo. Por lo tanto, la respuesta sería al menos 1.
Ejemplo 2:

Entrada: s = "abcdef", k = 2
Salida: 2
Explicación: Podemos dividirla en subcadenas "abc" y "def". Cada una de las subcadenas "abc" y "def" requiere un cambio para convertirse en un semi-palíndromo, por lo que necesitamos 2 cambios en total para que todas las subcadenas sean semi-palíndromas.
Se puede mostrar que no podemos dividir la cadena dada en dos subcadenas de una manera que requiera menos de 2 cambios.
Ejemplo 3:

Entrada: s = "aabbaa", k = 3
Salida: 0
Explicación: Podemos dividirla en subcadenas "aa", "bb" y "aa".
Las cadenas "aa" y "bb" ya son semi-palíndromos. Por lo tanto, la respuesta es cero.

Restricciones:

2 <= s.length <= 200
1 <= k <= s.length / 2
s consiste solo en letras minúsculas del alfabeto inglés.

Dada una cadena s y un entero k, particione s en k subcadenas de modo que se minimice la suma del número de cambios de letras necesarios para convertir cada subcadena en un semipalíndromo.
Devuelva un entero que denote el número mínimo de cambios de letras necesarios.
Notas

Una cadena es un palíndromo si se puede leer de la misma manera de izquierda a derecha y de derecha a izquierda.
Una cadena con una longitud de len se considera un semipalíndromo si existe un entero positivo d tal que 1 <= d < len y len % d == 0, y si tomamos índices que tienen el mismo módulo por d, forman un palíndromo. Por ejemplo, "aa", "aba", "adbgad" y "abab" son semipalíndromos y "a", "ab" y "abca" no lo son.
Una subcadena es una secuencia contigua de caracteres dentro de una cadena.

Ejemplo 1:

Entrada: s = "abcac", k = 2
Salida: 1
Explicación: Podemos dividir s en las subcadenas "ab" y "cac". La cadena "cac" ya es un semipalíndromo. Si cambiamos "ab" por "aa", se convierte en un semipalíndromo con d = 1.
Se puede demostrar que no hay forma de dividir la cadena "abcac" en dos subcadenas semipalíndromo. Por lo tanto, la respuesta sería al menos 1.
Ejemplo 2:

Entrada: s = "abcdef", k = 2
Salida: 2
Explicación: Podemos dividirla en las subcadenas "abc" y "def". Cada una de las subcadenas "abc" y "def" requiere un cambio para convertirse en un semipalíndromo, por lo que necesitamos 2 cambios en total para hacer que todas las subcadenas sean semipalíndromo.
Se puede demostrar que no podemos dividir la cadena dada en dos subcadenas de una manera que requiera menos de 2 cambios.
Ejemplo 3:

Entrada: s = "aabbaa", k = 3
Salida: 0
Explicación: Podemos dividirla en las subcadenas "aa", "bb" y "aa".
Las cadenas "aa" y "bb" ya son semipalíndromos. Por lo tanto, la respuesta es cero.

Restricciones:

2 <= s.length <= 200
1 <= k <= s.length / 2
s consta únicamente de letras minúsculas en inglés.


Dada una matriz de cadenas words y un carácter separator, divide cada cadena en words usando separator.
Devuelve una matriz de cadenas que contiene las nuevas cadenas formadas después de las divisiones, excluyendo las cadenas vacías.
Notas

separator se utiliza para determinar dónde debe ocurrir la división, pero no se incluye como parte de las cadenas resultantes.
Una división puede resultar en más de dos cadenas.
Las cadenas resultantes deben mantener el mismo orden en que se dieron inicialmente.

Ejemplo 1:

Entrada: words = ["one.two.three","four.five","six"], separator = "."
Salida: ["one","two","three","four","five","six"]
Explicación: En este ejemplo dividimos de la siguiente manera:

"one.two.three" se divide en "one", "two", "three"
"four.five" se divide en "four", "five"
"six" se divide en "six"

Por lo tanto, la matriz resultante es ["one","two","three","four","five","six"].

Ejemplo 2:

Entrada: words = ["$easy$","$problem$"], separator = "$"
Salida: ["easy","problem"]
Explicación: En este ejemplo dividimos de la siguiente manera:

"$easy$" se divide en "easy" (excluyendo cadenas vacías)
"$problem$" se divide en "problem" (excluyendo cadenas vacías)

Por lo tanto, la matriz resultante es ["easy","problem"].

Ejemplo 3:

Entrada: words = ["|||"], separator = "|"
Salida: []
Explicación: En este ejemplo, la división resultante de "|||" contendrá solo cadenas vacías, por lo que devolvemos una matriz vacía [].

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 20
los caracteres en words[i] son letras minúsculas del alfabeto inglés o caracteres de la cadena ".,|$#@" (excluyendo las comillas)
separator es un carácter de la cadena ".,|$#@" (excluyendo las comillas)

Dada un conjunto de cadenas words y un carácter separator, divide cada cadena en words usando separator.
Devuelve un conjunto de cadenas que contiene las nuevas cadenas formadas después de las divisiones, excluyendo las cadenas vacías.
Notas

separator se utiliza para determinar dónde debe ocurrir la división, pero no se incluye como parte de las cadenas resultantes.
Una división puede resultar en más de dos cadenas.
Las cadenas resultantes deben mantener el mismo orden en que se dieron inicialmente.

Ejemplo 1:

Entrada: words = ["one.two.three","four.five","six"], separator = "."
Salida: ["one","two","three","four","five","six"]
Explicación: En este ejemplo dividimos de la siguiente manera:

"one.two.three" se divide en "one", "two", "three"
"four.five" se divide en "four", "five"
"six" se divide en "six"

Por lo tanto, el conjunto resultante es ["one","two","three","four","five","six"].
Ejemplo 2:

Entrada: words = ["$easy$","$problem$"], separator = "$"
Salida: ["easy","problem"]
Explicación: En este ejemplo dividimos de la siguiente manera:

"$easy$" se divide en "easy" (excluyendo cadenas vacías)
"$problem$" se divide en "problem" (excluyendo cadenas vacías)

Por lo tanto, el conjunto resultante es ["easy","problem"].

Ejemplo 3:

Entrada: words = ["|||"], separator = "|"
Salida: []
Explicación: En este ejemplo, la división resultante de "|||" contendrá solo cadenas vacías, por lo que devolvemos un conjunto vacía [].

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 20
los caracteres en words[i] son letras minúsculas del alfabeto inglés o caracteres de la cadena ".,|$#@" (excluyendo las comillas)
separator es un carácter de la cadena ".,|$#@" (excluyendo las comillas)

Dado un conjunto de cadenas de palabras y un separador de caracteres, divide cada cadena en palabras por separador.
Devuelve un conjunto de cadenas que contienen las nuevas cadenas formadas después de las divisiones, excluyendo las cadenas vacías.
Notas

separator se utiliza para determinar dónde debe ocurrir la división, pero no se incluye como parte de las cadenas resultantes.
Una división puede dar como resultado más de dos cadenas.
Las cadenas resultantes deben mantener el mismo orden en el que se proporcionaron inicialmente.

Ejemplo 1:

Entrada: palabras = ["uno.dos.tres", "cuatro.cinco", "seis"], separador = "."
Salida: ["uno", "dos", "tres", "cuatro", "cinco", "seis"]
Explicación: En este ejemplo, dividimos de la siguiente manera:

"uno.dos.tres" se divide en "uno", "dos", "tres"
"cuatro.cinco" se divide en "cuatro", "cinco"
"seis" se divide en "seis"

Por lo tanto, la matriz resultante es ["uno", "dos", "tres", "cuatro", "cinco", "seis"].
Ejemplo 2:

Entrada: palabras = ["$easy$", "$problem$"], separador = "$"
Salida: ["easy", "problem"]
Explicación: En este ejemplo, dividimos de la siguiente manera:

"$easy$" se divide en "easy" (excluyendo cadenas vacías)
"$problem$" se divide en "problem" (excluyendo cadenas vacías)

Por lo tanto, la matriz resultante es ["easy", "problem"].

Ejemplo 3:

Entrada: words = ["|||"], separator = "|"
Salida: []
Explicación: En este ejemplo, la división resultante de "|||" contendrá solo cadenas vacías, por lo que devolvemos una matriz vacía [].

Restricciones:

1 <= words.length <= 100
1 <= words[i].length <= 20
Los caracteres en words[i] son letras minúsculas en inglés o caracteres de la cadena ".,|$#@" (excluyendo las comillas)
separator es un carácter de la cadena ".,|$#@" (excluyendo las comillas)


Dado dos enteros positivos n y x.
Devuelve el número de formas en que n puede expresarse como la suma de la x-ésima potencia de enteros positivos únicos, en otras palabras, el número de conjuntos de enteros únicos [n_1, n_2, ..., n_k] donde n = n_1^x + n_2^x + ... + n_k^x.
Dado que el resultado puede ser muy grande, devuélvelo módulo 10^9 + 7.
Por ejemplo, si n = 160 y x = 3, una forma de expresar n es n = 2^3 + 3^3 + 5^3.

Ejemplo 1:

Entrada: n = 10, x = 2
Salida: 1
Explicación: Podemos expresar n de la siguiente manera: n = 3^2 + 1^2 = 10.
Se puede demostrar que es la única forma de expresar 10 como la suma de la 2ª potencia de enteros únicos.

Ejemplo 2:

Entrada: n = 4, x = 1
Salida: 2
Explicación: Podemos expresar n de las siguientes maneras:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Restricciones:

1 <= n <= 300
1 <= x <= 5

Dados dos números enteros positivos n y x.
Devuelve la cantidad de formas en que n se puede expresar como la suma de la potencia x^ésima de números enteros positivos únicos, en otras palabras, la cantidad de conjuntos de números enteros únicos [n_1, n_2, ..., n_k] donde n = n_1^x + n_2^x + ... + n_k^x.
Dado que el resultado puede ser muy grande, devuélvelo módulo 10^9 + 7.
Por ejemplo, si n = 160 y x = 3, una forma de expresar n es n = 2^3 + 3^3 + 5^3.

Ejemplo 1:

Entrada: n = 10, x = 2
Salida: 1
Explicación: Podemos expresar n de la siguiente manera: n = 3^2 + 1^2 = 10.
Se puede demostrar que es la única forma de expresar 10 como la suma de la 2.ª potencia de números enteros únicos.

Ejemplo 2:

Entrada: n = 4, x = 1
Salida: 2
Explicación: Podemos expresar n de las siguientes maneras:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Restricciones:

1 <= n <= 300
1 <= x <= 5


Dada una cadena binaria s, divide la cadena en una o más subcadenas de modo que cada subcadena sea hermosa.
Una cadena es hermosa si:

No contiene ceros a la izquierda.
Es la representación binaria de un número que es una potencia de 5.

Devuelve el número mínimo de subcadenas en tal partición. Si es imposible dividir la cadena s en subcadenas hermosas, devuelve -1.
Una subcadena es una secuencia continua de caracteres en una cadena.

Ejemplo 1:

Entrada: s = "1011"
Salida: 2
Explicación: Podemos dividir la cadena dada en ["101", "1"].
- La cadena "101" no contiene ceros a la izquierda y es la representación binaria del entero 5^1 = 5.
- La cadena "1" no contiene ceros a la izquierda y es la representación binaria del entero 5^0 = 1.
Se puede demostrar que 2 es el número mínimo de subcadenas hermosas en las que s puede ser dividida.

Ejemplo 2:

Entrada: s = "111"
Salida: 3
Explicación: Podemos dividir la cadena dada en ["1", "1", "1"].
- La cadena "1" no contiene ceros a la izquierda y es la representación binaria del entero 5^0 = 1.
Se puede demostrar que 3 es el número mínimo de subcadenas hermosas en las que s puede ser dividida.

Ejemplo 3:

Entrada: s = "0"
Salida: -1
Explicación: No podemos dividir la cadena dada en subcadenas hermosas.

Condiciones:

1 <= s.length <= 15
s[i] es '0' o '1'.

Dada una cadena binaria s, particione la cadena en una o más subcadenas de modo que cada subcadena sea hermosa.
Una cadena es hermosa si:

No contiene ceros a la izquierda.
Es la representación binaria de un número que es una potencia de 5.

Devuelva el número mínimo de subcadenas en dicha partición. Si es imposible particionar la cadena s en subcadenas hermosas, devuelva -1.
Una subcadena es una secuencia contigua de caracteres en una cadena.

Ejemplo 1:

Entrada: s = "1011"
Salida: 2
Explicación: Podemos particionar la cadena dada en ["101", "1"].
- La cadena "101" no contiene ceros a la izquierda y es la representación binaria del entero 5^1 = 5.
- La cadena "1" no contiene ceros a la izquierda y es la representación binaria del entero 5^0 = 1.
Se puede demostrar que 2 es el número mínimo de subcadenas hermosas en las que se puede dividir s.

Ejemplo 2:

Entrada: s = "111"
Salida: 3
Explicación: Podemos dividir la cadena dada en ["1", "1", "1"].
- La cadena "1" no contiene ceros a la izquierda y es la representación binaria del entero 5^0 = 1.
Se puede demostrar que 3 es el número mínimo de subcadenas hermosas en las que se puede dividir s.

Ejemplo 3:

Entrada: s = "0"
Salida: -1
Explicación: No podemos dividir la cadena dada en subcadenas hermosas.

Restricciones:

1 <= s.length <= 15
s[i] es '0' o '1'.


Se te da una cadena de caracteres word y un arreglo de cadenas forbidden.
Una cadena se considera válida si ninguna de sus subcadenas está presente en forbidden.
Devuelve la longitud de la subcadena válida más larga de la cadena word.
Una subcadena es una secuencia continua de caracteres en una cadena, posiblemente vacía.

Ejemplo 1:

Entrada: word = "cbaaaabc", forbidden = ["aaa","cb"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" y "aabc". La longitud de la subcadena válida más larga es 4. Puede demostrarse que todas las demás subcadenas contienen "aaa" o "cb" como subcadena.

Ejemplo 2:

Entrada: word = "leetcode", forbidden = ["de","le","e"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" y "tcod". La longitud de la subcadena válida más larga es 4. Puede demostrarse que todas las demás subcadenas contienen "de", "le" o "e" como subcadena.

Restricciones:

1 <= word.length <= 10^5
word consiste solo en letras minúsculas inglesas.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] consiste solo en letras minúsculas inglesas.

Se le proporciona una cadena de caracteres word y una matriz de cadenas de caracteres forbidden.
Una cadena se considera válida si ninguna de sus subcadenas está presente en forbidden.
Devuelve la longitud de la subcadena válida más larga de la cadena de caracteres word.
Una subcadena es una secuencia contigua de caracteres en una cadena, posiblemente vacía.

Ejemplo 1:

Entrada: word = "cbaaaabc", forbidden = ["aaa", "cb"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" y "aabc". La longitud de la subcadena válida más larga es 4.

Se puede demostrar que todas las demás subcadenas contienen "aaa" o "cb" como subcadena. Ejemplo 2:

Entrada: word = "leetcode", forbidden = ["de", "le", "e"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" y "tcod". La longitud de la subcadena válida más larga es 4.
Se puede demostrar que todas las demás subcadenas contienen "de", "le" o "e" como subcadena.

Restricciones:

1 <= word.length <= 10^5
word consta únicamente de letras minúsculas en inglés.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] consta únicamente de letras minúsculas en inglés.

Se le proporciona una cadena de caracteres word y una matriz de cadenas de caracteres forbidden.
Una cadena se considera válida si ninguna de sus subcadenas está presente en forbidden.
Devuelve la longitud de la subcadena válida más larga de la cadena de caracteres word.
Una subcadena es una secuencia contigua de caracteres en una cadena, posiblemente vacía.

Ejemplo 1:

Entrada: word = "cbaaaabc", forbidden = ["aaa", "cb"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" y "aabc". La longitud de la subcadena válida más larga es 4.
Se puede demostrar que todas las demás subcadenas contienen "aaa" o "cb" como subcadena.
Ejemplo 2:

Entrada: word = "leetcode", forbidden = ["de", "le", "e"]
Salida: 4
Explicación: Hay 11 subcadenas válidas en word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" y "tcod". La longitud de la subcadena válida más larga es 4.
Se puede demostrar que todas las demás subcadenas contienen "de", "le" o "e" como subcadena.

Restricciones:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] consta únicamente de letras minúsculas en inglés.


El teclado de tu laptop está defectuoso, y cada vez que escribes un carácter 'i', invierte la cadena que has escrito. Escribir otros caracteres funciona como se espera.
Se te da una cadena `s` indexada desde 0, y escribes cada carácter de `s` usando tu teclado defectuoso.
Devuelve la cadena final que estará presente en la pantalla de tu laptop.

Ejemplo 1:

Entrada: s = "string"
Salida: "rtsng"
Explicación:
Después de escribir el primer carácter, el texto en la pantalla es "s".
Después del segundo carácter, el texto es "st".
Después del tercer carácter, el texto es "str".
Como el cuarto carácter es una 'i', el texto se invierte y se convierte en "rts".
Después del quinto carácter, el texto es "rtsn".
Después del sexto carácter, el texto es "rtsng".
Por lo tanto, devolvemos "rtsng".

Ejemplo 2:

Entrada: s = "poiinter"
Salida: "ponter"
Explicación:
Después del primer carácter, el texto en la pantalla es "p".
Después del segundo carácter, el texto es "po".
Como el tercer carácter que escribes es una 'i', el texto se invierte y se convierte en "op".
Como el cuarto carácter que escribes es una 'i', el texto se invierte y se convierte en "po".
Después del quinto carácter, el texto es "pon".
Después del sexto carácter, el texto es "pont".
Después del séptimo carácter, el texto es "ponte".
Después del octavo carácter, el texto es "ponter".
Por lo tanto, devolvemos "ponter".

Restricciones:

1 <= s.length <= 100
s consiste en letras minúsculas inglesas.
s[0] != 'i'

El teclado de su computadora portátil está defectuoso y, cada vez que escribe un carácter "i", se invierte la cadena que ha escrito. Escribir otros caracteres funciona como se espera.
Se le proporciona una cadena indexada en 0 s y usted escribe cada carácter de s utilizando su teclado defectuoso.
Devuelve la cadena final que estará presente en la pantalla de su computadora portátil.

Ejemplo 1:

Entrada: s = "string"
Salida: "rtsng"
Explicación:
Después de escribir el primer carácter, el texto en la pantalla es "s".
Después del segundo carácter, el texto es "st".
Después del tercer carácter, el texto es "str".
Como el cuarto carácter es una "i", el texto se invierte y se convierte en "rts".
Después del quinto carácter, el texto es "rtsn".
Después del sexto carácter, el texto es "rtsng".
Por lo tanto, devolvemos "rtsng".

Ejemplo 2:

Entrada: s = "poiinter"
Salida: "ponter"
Explicación:
Después del primer carácter, el texto en la pantalla es "p".
Después del segundo carácter, el texto es "po".
Como el tercer carácter que escribe es una "i", el texto se invierte y se convierte en "op".
Como el cuarto carácter que escribe es una "i", el texto se invierte y se convierte en "po".
Después del quinto carácter, el texto es "pon".
Después del sexto carácter, el texto es "pont".
Después del séptimo carácter, el texto es "ponte".
Después del octavo carácter, el texto es "ponter".
Por lo tanto, devolvemos "ponter".

Restricciones:

1 <= s.length <= 100
s consta de letras minúsculas en inglés.
s[0] != 'i'

El teclado de su computadora portátil está defectuoso y, cada vez que escribe un carácter 'i', se invierte la cadena que ha escrito. Escribir otros caracteres funciona como se espera.
Se le proporciona una cadena indexada en 0 s y usted escribe cada carácter de s utilizando su teclado defectuoso.
Devuelve la cadena final que estará presente en la pantalla de su computadora portátil.

Ejemplo 1:

Entrada: s = "string"
Salida: "rtsng"
Explicación:
Después de escribir el primer carácter, el texto en la pantalla es "s".
Después del segundo carácter, el texto es "st".
Después del tercer carácter, el texto es "str".
Como el cuarto carácter es una 'i', el texto se invierte y se convierte en "rts".
Después del quinto carácter, el texto es "rtsn".
Después del sexto carácter, el texto es "rtsng".
Por lo tanto, devolvemos "rtsng".

Ejemplo 2:

Entrada: s = "poiinter"
Salida: "ponter"
Explicación:
Después del primer carácter, el texto en la pantalla es "p".
Después del segundo carácter, el texto es "po".
Como el tercer carácter que escribe es una 'i', el texto se invierte y se convierte en "op".
Como el cuarto carácter que escribe es una 'i', el texto se invierte y se convierte en "po".
Después del quinto carácter, el texto es "pon".
Después del sexto carácter, el texto es "pont".
Después del séptimo carácter, el texto es "ponte".
Después del octavo carácter, el texto es "ponter".
Por lo tanto, devolvemos "ponter".

Restricciones:

1 <= s.length <= 100
s consta de letras minúsculas en inglés.
s[0] != 'i'


Dada una cadena s indexada desde 0, permuta s para obtener una nueva cadena t tal que:

Todas las consonantes permanezcan en sus lugares originales. Más formalmente, si hay un índice i con 0 <= i < s.length tal que s[i] es una consonante, entonces t[i] = s[i].
Las vocales deben estar ordenadas en orden no decreciente de sus valores ASCII. Más formalmente, para pares de índices i, j con 0 <= i < j < s.length tal que s[i] y s[j] son vocales, entonces t[i] no debe tener un valor ASCII mayor que t[j].

Devuelve la cadena resultante.
Las vocales son 'a', 'e', 'i', 'o' y 'u', y pueden aparecer en minúsculas o mayúsculas. Las consonantes comprenden todas las letras que no son vocales.

Ejemplo 1:

Entrada: s = "lEetcOde"
Salida: "lEOtcede"
Explicación: 'E', 'O' y 'e' son las vocales en s; 'l', 't', 'c' y 'd' son todas consonantes. Las vocales se ordenan según sus valores ASCII, y las consonantes permanecen en los mismos lugares.

Ejemplo 2:

Entrada: s = "lYmpH"
Salida: "lYmpH"
Explicación: No hay vocales en s (todos los caracteres en s son consonantes), por lo que devolvemos "lYmpH".

Restricciones:

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

Dada una cadena s indexada en 0, permuta s para obtener una nueva cadena t tal que:

Todas las consonantes permanecen en sus lugares originales. Más formalmente, si hay un índice i con 0 <= i < s.length tal que s[i] es una consonante, entonces t[i] = s[i].
Las vocales deben ordenarse en orden no decreciente de sus valores ASCII. Más formalmente, para pares de índices i, j con 0 <= i < j < s.length tales que s[i] y s[j] son vocales, entonces t[i] no debe tener un valor ASCII mayor que t[j].

Devuelve la cadena resultante.
Las vocales son 'a', 'e', 'i', 'o' y 'u', y pueden aparecer en minúsculas o mayúsculas. Las consonantes comprenden todas las letras que no son vocales.

Ejemplo 1:

Entrada: s = "lEetcOde"
Salida: "lEOtcede"
Explicación: 'E', 'O' y 'e' son las vocales en s; 'l', 't', 'c' y 'd' son todas consonantes. Las vocales se ordenan según sus valores ASCII y las consonantes permanecen en los mismos lugares.

Ejemplo 2:

Entrada: s = "lYmpH"
Salida: "lYmpH"
Explicación: No hay vocales en s (todos los caracteres en s son consonantes), por lo que devolvemos "lYmpH".

Restricciones:

1 <= s.length <= 10^5
s consta únicamente de letras del alfabeto inglés en mayúsculas y minúsculas.

Dada una cadena s indexada 0, permute s para obtener una nueva cadena t tal que:

Todas las consonantes permanecen en sus lugares originales. Más formalmente, si hay un índice i con 0 <= i < s.longitud tal que s[i] es una consonante, entonces t[i] = s[i].
Las vocales deben ordenarse en el orden no decreciente de sus valores ASCII. Más formalmente, para pares de índices i, j con 0 <= i < j < s.longitud tal que s[i] y s[j] sean vocales, entonces t[i] no debe tener un valor ASCII mayor que t[j].

Devuelve la cadena resultante.
Las vocales son 'a', 'e', 'i', 'o' y 'u', y pueden aparecer en minúsculas o mayúsculas. Las consonantes comprenden todas las letras que no son vocales.

Ejemplo 1:

Entrada: s = "lEetcOde"
Salida: "lEOtcede"
Explicación: 'E', 'O' y 'e' son las vocales de la s; 'L', 'T', 'C' y 'D' son todas consonantes. Las vocales se ordenan según sus valores ASCII y las consonantes permanecen en los mismos lugares.

Ejemplo 2:

Entrada: s = "lYmpH"
Salida: "lYmpH"
Explicación: No hay vocales en s (todos los caracteres en s son consonantes), por lo que devolvemos "lYmpH".

Restricciones:

1 <= s.length <= 10^5
s consta solo de letras del alfabeto inglés en mayúsculas y minúsculas.


Un elemento x de un arreglo de enteros arr de longitud m es dominante si freq(x) * 2 > m, donde freq(x) es el número de ocurrencias de x en arr. Note que esta definición implica que arr puede tener como mucho un elemento dominante.
Te dan un arreglo de enteros nums de longitud n indexado desde 0 con un elemento dominante.
Puedes dividir nums en un índice i en dos arreglos nums[0, ..., i] y nums[i + 1, ..., n - 1], pero la división solo es válida si:

0 <= i < n - 1
nums[0, ..., i], y nums[i + 1, ..., n - 1] tienen el mismo elemento dominante.

Aquí, nums[i, ..., j] denota el subarreglo de nums que comienza en el índice i y termina en el índice j, ambos extremos son inclusivos. Particularmente, si j < i entonces nums[i, ..., j] denota un subarreglo vacío. Devuelve el índice mínimo de una división válida. Si no existe una división válida, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,2,2,2]
Salida: 2
Explicación: Podemos dividir el arreglo en el índice 2 para obtener los arreglos [1,2,2] y [2].
En el arreglo [1,2,2], el elemento 2 es dominante ya que ocurre dos veces en el arreglo y 2 * 2 > 3.
En el arreglo [2], el elemento 2 es dominante ya que ocurre una vez en el arreglo y 1 * 2 > 1.
Tanto [1,2,2] como [2] tienen el mismo elemento dominante que nums, por lo que esta es una división válida.
Se puede demostrar que el índice 2 es el índice mínimo de una división válida.
Ejemplo 2:

Entrada: nums = [2,1,3,1,1,1,7,1,2,1]
Salida: 4
Explicación: Podemos dividir el arreglo en el índice 4 para obtener los arreglos [2,1,3,1,1] y [1,7,1,2,1].
En el arreglo [2,1,3,1,1], el elemento 1 es dominante ya que ocurre tres veces en el arreglo y 3 * 2 > 5.
En el arreglo [1,7,1,2,1], el elemento 1 es dominante ya que ocurre tres veces en el arreglo y 3 * 2 > 5.
Tanto [2,1,3,1,1] como [1,7,1,2,1] tienen el mismo elemento dominante que nums, por lo que esta es una división válida.
Se puede demostrar que el índice 4 es el índice mínimo de una división válida.
Ejemplo 3:

Entrada: nums = [3,3,3,3,7,2,2]
Salida: -1
Explicación: Se puede demostrar que no hay una división válida.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums tiene exactamente un elemento dominante.

Un elemento x de una matriz de enteros arr de longitud m es dominante si freq(x) * 2 > m, donde freq(x) es el número de apariciones de x en arr. Observe que esta definición implica que arr puede tener como máximo un elemento dominante.
Se le da una matriz de números enteros con índice 0 de longitud n con un elemento dominante.
Puede dividir nums en un índice i en dos matrices nums[0, ..., i] y nums[i + 1, ..., n - 1], pero la división sólo es válida si:

0 <= i < n - 1
nums[0, ..., i], y nums[i + 1, ..., n - 1] tienen el mismo elemento dominante.

Aquí, nums[i, ..., j] denota la submatriz de nums que comienza en el índice i y termina en el índice j, siendo ambos extremos inclusivos. En particular, si j < i entonces nums[i, ..., j] denota una submatriz vacía.
Devuelve el índice mínimo de una división válida. Si no existe ninguna división válida, devuelve -1.

Ejemplo 1

Entrada: nums = [1,2,2,2]
Salida: 2
Explicación: Podemos dividir la matriz en el índice 2 para obtener las matrices [1,2,2] y [2].
En la matriz [1,2,2], el elemento 2 es dominante ya que aparece dos veces en la matriz y 2 * 2 > 3.
En la matriz [2], el elemento 2 es dominante, ya que aparece una vez en la matriz y 1 * 2 > 1.
Tanto [1,2,2] como [2] tienen el mismo elemento dominante que nums, por lo que se trata de una división válida.
Se puede demostrar que el índice 2 es el índice mínimo de una división válida.
Ejemplo 2:

Entrada: nums = [2,1,3,1,1,1,7,1,2,1]
Salida: 4
Explicación: Podemos dividir la matriz en el índice 4 para obtener las matrices [2,1,3,1,1] y [1,7,1,2,1].
En la matriz [2,1,3,1,1], el elemento 1 es dominante ya que aparece tres veces en la matriz y 3 * 2 > 5.
En la matriz [1,7,1,2,1], el elemento 1 es dominante porque aparece tres veces en la matriz y 3 * 2 > 5.
Tanto [2,1,3,1,1] como [1,7,1,2,1] tienen el mismo elemento dominante que nums, por lo que se trata de una división válida.
Se puede demostrar que el índice 4 es el índice mínimo de una división válida.
Ejemplo 3:

Entrada: nums = [3,3,3,3,7,2,2]
Salida: -1
Explicación: Se puede demostrar que no hay ninguna división válida.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums tiene exactamente un elemento dominante.

Un elemento x de un conjunto de enteros arr de longitud m es dominante si freq(x) * 2 > m, donde freq(x) es el número de ocurrencias de x en arr. Note que esta definición implica que arr puede tener como mucho un elemento dominante. Te dan un conjunto de enteros nums de longitud n indexado desde 0 con un elemento dominante.

Puedes dividir nums en un índice i en dos conjuntos nums[0, ..., i] y nums[i + 1, ..., n - 1], pero la división solo es válida si:

0 <= i < n - 1
nums[0, ..., i], y nums[i + 1, ..., n - 1] tienen el mismo elemento dominante.

Aquí, nums[i, ..., j] denota el subconjunto de nums que comienza en el índice i y termina en el índice j, ambos extremos son inclusivos. Particularmente, si j < i entonces nums[i, ..., j] denota un subconjunto vacío.
Devuelve el índice mínimo de una división válida. Si no existe una división válida, devuelve -1.

Ejemplo 1:

Entrada: nums = [1,2,2,2]
Salida: 2
Explicación: Podemos dividir el conjunto en el índice 2 para obtener los conjuntos [1,2,2] y [2].
En el conjunto [1,2,2], el elemento 2 es dominante ya que ocurre dos veces en el conjunto y 2 * 2 > 3.
En el conjunto [2], el elemento 2 es dominante ya que ocurre una vez en el conjunto y 1 * 2 > 1.
Tanto [1,2,2] como [2] tienen el mismo elemento dominante que nums, por lo que esta es una división válida.
Se puede demostrar que el índice 2 es el índice mínimo de una división válida.
Ejemplo 2:

Entrada: nums = [2,1,3,1,1,1,7,1,2,1]
Salida: 4
Explicación: Podemos dividir el conjunto en el índice 4 para obtener los conjuntos [2,1,3,1,1] y [1,7,1,2,1].
En el conjunto [2,1,3,1,1], el elemento 1 es dominante ya que ocurre tres veces en el conjunto y 3 * 2 > 5.
En el conjunto [1,7,1,2,1], el elemento 1 es dominante ya que ocurre tres veces en el conjunto y 3 * 2 > 5.
Tanto [2,1,3,1,1] como [1,7,1,2,1] tienen el mismo elemento dominante que nums, por lo que esta es una división válida.
Se puede demostrar que el índice 4 es el índice mínimo de una división válida.
Ejemplo 3:

Entrada: nums = [3,3,3,3,7,2,2]
Salida: -1
Explicación: Se puede demostrar que no hay una división válida.

Restricciones:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums tiene exactamente un elemento dominante.


Se te da un array indexado desde 0 `nums` y un entero no negativo `k`.
En una operación, puedes hacer lo siguiente:

Elige un índice `i` que no haya sido elegido antes del rango [0, nums.length - 1].
Reemplaza `nums[i]` con cualquier entero del rango [nums[i] - k, nums[i] + k].

La belleza del array es la longitud de la subsecuencia más larga que consiste en elementos iguales.
Devuelve la máxima belleza posible del array `nums` después de aplicar la operación cualquier número de veces.
Ten en cuenta que puedes aplicar la operación a cada índice una sola vez.
Una subsecuencia de un array es un nuevo array generado a partir del array original eliminando algunos elementos (posiblemente ninguno) sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [4,6,1,2], k = 2
Salida: 3
Explicación: En este ejemplo, aplicamos las siguientes operaciones:
- Elegimos el índice 1, lo reemplazamos con 4 (del rango [4,8]), nums = [4,4,1,2].
- Elegimos el índice 3, lo reemplazamos con 4 (del rango [0,4]), nums = [4,4,1,4].
Después de las operaciones aplicadas, la belleza del array `nums` es 3 (subsecuencia que consiste en los índices 0, 1 y 3).
Se puede demostrar que 3 es la máxima longitud posible que se puede lograr.

Ejemplo 2:

Entrada: nums = [1,1,1,1], k = 10
Salida: 4
Explicación: En este ejemplo no tenemos que aplicar ninguna operación.
La belleza del array `nums` es 4 (todo el array).

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums y un entero no negativo k.
En una operación, puede hacer lo siguiente:

Elija un índice i que no haya sido elegido antes del rango [0, nums.length - 1].
Reemplace nums[i] con cualquier entero del rango [nums[i] - k, nums[i] + k].

La belleza de la matriz es la longitud de la subsecuencia más larga que consta de elementos iguales.
Devuelva la belleza máxima posible de la matriz nums después de aplicar la operación cualquier número de veces.
Tenga en cuenta que puede aplicar la operación a cada índice solo una vez.
Una subsecuencia de una matriz es una nueva matriz generada a partir de la matriz original eliminando algunos elementos (posiblemente ninguno) sin cambiar el orden de los elementos restantes.

Ejemplo 1:

Entrada: nums = [4,6,1,2], k = 2
Salida: 3
Explicación: En este ejemplo, aplicamos las siguientes operaciones:
- Elegimos el índice 1, lo reemplazamos por 4 (del rango [4,8]), nums = [4,4,1,2].
- Elegimos el índice 3, lo reemplazamos por 4 (del rango [0,4]), nums = [4,4,1,4].
Después de las operaciones aplicadas, la belleza de la matriz nums es 3 (subsecuencia que consta de los índices 0, 1 y 3).
Se puede demostrar que 3 es la longitud máxima posible que podemos lograr.

Ejemplo 2:

Entrada: nums = [1,1,1,1], k = 10
Salida: 4
Explicación: En este ejemplo no tenemos que aplicar ninguna operación.
La belleza de la matriz nums es 4 (toda la matriz).

Restricciones:

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


Se te da un array de enteros nums. Consideramos un array bueno si es una permutación de un array base[n].
base[n] = [1, 2, ..., n - 1, n, n] (en otras palabras, es un array de longitud n + 1 que contiene del 1 al n - 1 exactamente una vez, más dos ocurrencias de n). Por ejemplo, base[1] = [1, 1] y base[3] = [1, 2, 3, 3].
Devuelve true si el array dado es bueno, de lo contrario devuelve false.
Nota: Una permutación de enteros representa una disposición de estos números.

Ejemplo 1:

Entrada: nums = [2, 1, 3]
Salida: false
Explicación: Dado que el elemento máximo del array es 3, el único candidato n para el cual este array podría ser una permutación de base[n], es n = 3. Sin embargo, base[3] tiene cuatro elementos pero el array nums tiene tres. Por lo tanto, no puede ser una permutación de base[3] = [1, 2, 3, 3]. Así que la respuesta es false.

Ejemplo 2:

Entrada: nums = [1, 3, 3, 2]
Salida: true
Explicación: Dado que el elemento máximo del array es 3, el único candidato n para el cual este array podría ser una permutación de base[n], es n = 3. Se puede ver que nums es una permutación de base[3] = [1, 2, 3, 3] (intercambiando el segundo y el cuarto elemento en nums, obtenemos base[3]). Por lo tanto, la respuesta es true.

Ejemplo 3:

Entrada: nums = [1, 1]
Salida: true
Explicación: Dado que el elemento máximo del array es 1, el único candidato n para el cual este array podría ser una permutación de base[n], es n = 1. Se puede ver que nums es una permutación de base[1] = [1, 1]. Por lo tanto, la respuesta es true.

Ejemplo 4:

Entrada: nums = [3, 4, 4, 1, 2, 1]
Salida: false
Explicación: Dado que el elemento máximo del array es 4, el único candidato n para el cual este array podría ser una permutación de base[n], es n = 4. Sin embargo, base[4] tiene cinco elementos pero el array nums tiene seis. Por lo tanto, no puede ser una permutación de base[4] = [1, 2, 3, 4, 4]. Así que la respuesta es false.

Condiciones:

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

Se le proporciona una matriz de números enteros nums. Consideramos que una matriz es buena si es una permutación de una matriz base[n].
base[n] = [1, 2, ..., n - 1, n, n] (en otras palabras, es una matriz de longitud n + 1 que contiene de 1 a n - 1 exactamente una vez, más dos ocurrencias de n). Por ejemplo, base[1] = [1, 1] y base[3] = [1, 2, 3, 3].
Devuelve verdadero si la matriz dada es buena; de lo contrario, devuelve falso.
Nota: Una permutación de números enteros representa una disposición de estos números.

Ejemplo 1:

Entrada: nums = [2, 1, 3]
Salida: false
Explicación: dado que el elemento máximo de la matriz es 3, el único candidato n para el cual esta matriz podría ser una permutación de base[n] es n = 3. Sin embargo, base[3] tiene cuatro elementos, pero la matriz nums tiene tres. Por lo tanto, no puede ser una permutación de base[3] = [1, 2, 3, 3]. Por lo tanto, la respuesta es falsa.

Ejemplo 2:

Entrada: nums = [1, 3, 3, 2]
Salida: true
Explicación: Dado que el elemento máximo de la matriz es 3, el único candidato n para el cual esta matriz podría ser una permutación de base[n], es n = 3. Se puede ver que nums es una permutación de base[3] = [1, 2, 3, 3] (al intercambiar el segundo y cuarto elemento en nums, llegamos a base[3]). Por lo tanto, la respuesta es verdadera.
Ejemplo 3:

Entrada: nums = [1, 1]
Salida: true
Explicación: Dado que el elemento máximo de la matriz es 1, el único candidato n para el cual esta matriz podría ser una permutación de base[n], es n = 1. Se puede ver que nums es una permutación de base[1] = [1, 1]. Por lo tanto, la respuesta es verdadera.
Ejemplo 4:

Entrada: nums = [3, 4, 4, 1, 2, 1]
Salida: false
Explicación: dado que el elemento máximo de la matriz es 4, el único candidato n para el cual esta matriz podría ser una permutación de base[n] es n = 4. Sin embargo, base[4] tiene cinco elementos, pero la matriz nums tiene seis. Por lo tanto, no puede ser una permutación de base[4] = [1, 2, 3, 4, 4]. Por lo tanto, la respuesta es falsa.

Restricciones:

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

Se te da un arreglo de enteros nums. Consideramos un arreglo bueno si es una permutación de un arreglo base[n].
base[n] = [1, 2, ..., n - 1, n, n] (en otras palabras, es un arreglo de longitud n + 1 que contiene del 1 al n - 1 exactamente una vez, más dos ocurrencias de n). Por ejemplo, base[1] = [1, 1] y base[3] = [1, 2, 3, 3].
Devuelve true si el arreglo dado es bueno, de lo contrario devuelve false.
Nota: Una permutación de enteros representa una disposición de estos números.

Ejemplo 1:

Entrada: nums = [2, 1, 3]
Salida: false
Explicación: Dado que el elemento máximo del arreglo es 3, el único candidato n para el cual este arreglo podría ser una permutación de base[n], es n = 3. Sin embargo, base[3] tiene cuatro elementos pero el arreglo nums tiene tres. Por lo tanto, no puede ser una permutación de base[3] = [1, 2, 3, 3]. Así que la respuesta es false.

Ejemplo 2:

Entrada: nums = [1, 3, 3, 2]
Salida: true
Explicación: Dado que el elemento máximo del arreglo es 3, el único candidato n para el cual este arreglo podría ser una permutación de base[n], es n = 3. Se puede ver que nums es una permutación de base[3] = [1, 2, 3, 3] (intercambiando el segundo y el cuarto elemento en nums, obtenemos base[3]). Por lo tanto, la respuesta es true.
Ejemplo 3:

Entrada: nums = [1, 1]
Salida: true
Explicación: Dado que el elemento máximo del arreglo es 1, el único candidato n para el cual este arreglo podría ser una permutación de base[n], es n = 1. Se puede ver que nums es una permutación de base[1] = [1, 1]. Por lo tanto, la respuesta es true.
Ejemplo 4:

Entrada: nums = [3, 4, 4, 1, 2, 1]
Salida: false
Explicación: Dado que el elemento máximo del arreglo es 4, el único candidato n para el cual este arreglo podría ser una permutación de base[n], es n = 4. Sin embargo, base[4] tiene cinco elementos pero el arreglo nums tiene seis. Por lo tanto, no puede ser una permutación de base[4] = [1, 2, 3, 4, 4]. Así que la respuesta es false.

Restricciones:

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


Se te da un array de enteros nums indexado desde 0 y un entero positivo x.
Inicialmente te encuentras en la posición 0 del array y puedes visitar otras posiciones de acuerdo con las siguientes reglas:

Si actualmente estás en la posición i, entonces puedes moverte a cualquier posición j tal que i < j.
Por cada posición i que visites, obtienes una puntuación de nums[i].
Si te mueves de una posición i a una posición j y las paridades de nums[i] y nums[j] difieren, entonces pierdes una puntuación de x.

Devuelve la puntuación total máxima que puedes obtener.
Ten en cuenta que inicialmente tienes nums[0] puntos.

Ejemplo 1:

Entrada: nums = [2,3,6,1,9,2], x = 5
Salida: 13
Explicación: Podemos visitar las siguientes posiciones en el array: 0 -> 2 -> 3 -> 4.
Los valores correspondientes son 2, 6, 1 y 9. Como los enteros 6 y 1 tienen paridades diferentes, el movimiento 2 -> 3 te hará perder una puntuación de x = 5.
La puntuación total será: 2 + 6 + 1 + 9 - 5 = 13.

Ejemplo 2:

Entrada: nums = [2,4,6,8], x = 3
Salida: 20
Explicación: Todos los enteros en el array tienen las mismas paridades, por lo que podemos visitarlos todos sin perder ninguna puntuación.
La puntuación total es: 2 + 4 + 6 + 8 = 20.

Restricciones:

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

Se te da un arreglo de enteros nums indexado desde 0 y un entero positivo x.
Inicialmente te encuentras en la posición 0 del arreglo y puedes visitar otras posiciones de acuerdo con las siguientes reglas:

Si actualmente estás en la posición i, entonces puedes moverte a cualquier posición j tal que i < j.
Por cada posición i que visites, obtienes una puntuación de nums[i].
Si te mueves de una posición i a una posición j y las paridades de nums[i] y nums[j] difieren, entonces pierdes una puntuación de x.

Devuelve la puntuación total máxima que puedes obtener.
Ten en cuenta que inicialmente tienes nums[0] puntos.

Ejemplo 1:

Entrada: nums = [2,3,6,1,9,2], x = 5
Salida: 13
Explicación: Podemos visitar las siguientes posiciones en el arreglo: 0 -> 2 -> 3 -> 4.
Los valores correspondientes son 2, 6, 1 y 9. Como los enteros 6 y 1 tienen paridades diferentes, el movimiento 2 -> 3 te hará perder una puntuación de x = 5.
La puntuación total será: 2 + 6 + 1 + 9 - 5 = 13.

Ejemplo 2:

Entrada: nums = [2,4,6,8], x = 3
Salida: 20
Explicación: Todos los enteros en el arreglo tienen las mismas paridades, por lo que podemos visitarlos todos sin perder ninguna puntuación.
La puntuación total es: 2 + 4 + 6 + 8 = 20.

Restricciones:

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

Se le proporciona una matriz de enteros indexada 0 nums y un entero positivo x.
Inicialmente se encuentra en la posición 0 de la matriz y puede visitar otras posiciones de acuerdo con las siguientes reglas:

Si actualmente se encuentra en la posición i, puede moverse a cualquier posición j tal que i < j.
Por cada posición i que visite, obtendrá una puntuación de nums[i].
Si te mueves de una posición i a una posición j y las paridades de nums[i] y nums[j] difieren, entonces pierdes una puntuación de x.

Devuelve la puntuación total máxima que puedes obtener.
Tenga en cuenta que inicialmente tiene puntos nums[0].

Ejemplo 1:

Entrada: nums = [2,3,6,1,9,2], x = 5
Salida: 13
Explicación: Podemos visitar las siguientes posiciones en la matriz: 0 -> 2 -> 3 -> 4.
Los valores correspondientes son 2, 6, 1 y 9. Dado que los números enteros 6 y 1 tienen paridades diferentes, el movimiento 2 -> 3 te hará perder una puntuación de x = 5.
La puntuación total será: 2 + 6 + 1 + 9 - 5 = 13.

Ejemplo 2:

Entrada: nums = [2,4,6,8], x = 3
Salida: 20
Explicación: Todos los enteros de la matriz tienen las mismas paridades, por lo que podemos visitarlos todos sin perder ninguna puntuación.
La puntuación total es: 2 + 4 + 6 + 8 = 20.

Restricciones:

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


Se le proporciona una matriz de números enteros indexada en 0, nums. Debe encontrar la suma máxima de un par de números de nums de modo que el dígito máximo en ambos números sea igual.
Devuelve la suma máxima o -1 si no existe dicho par.

Ejemplo 1:

Entrada: nums = [51,71,17,24,42]
Salida: 88
Explicación:
Para i = 1 y j = 2, nums[i] y nums[j] tienen dígitos máximos iguales con una suma de pares de 71 + 17 = 88.
Para i = 3 y j = 4, nums[i] y nums[j] tienen dígitos máximos iguales con una suma de pares de 24 + 42 = 66.
Se puede demostrar que no hay otros pares con dígitos máximos iguales, por lo que la respuesta es 88.
Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: -1
Explicación: No existe ningún par en nums con dígitos máximos iguales.

Restricciones:

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

Se te da un array de enteros nums indexado desde 0. Debes encontrar la suma máxima de un par de números de nums tal que el dígito máximo en ambos números sea igual.
Devuelve la suma máxima o -1 si no existe tal par.

Ejemplo 1:

Entrada: nums = [51,71,17,24,42]
Salida: 88
Explicación:
Para i = 1 y j = 2, nums[i] y nums[j] tienen dígitos máximos iguales con una suma de par de 71 + 17 = 88.
Para i = 3 y j = 4, nums[i] y nums[j] tienen dígitos máximos iguales con una suma de par de 24 + 42 = 66.
Se puede demostrar que no hay otros pares con dígitos máximos iguales, por lo que la respuesta es 88.
Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: -1
Explicación: No existe ningún par en nums con dígitos máximos iguales.

Restricciones:

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


Se te da un array de enteros indexado desde 0, `nums`, un entero `modulo` y un entero `k`.
Tu tarea es encontrar la cantidad de subarrays que son interesantes.
Un subarray `nums[l..r]` es interesante si se cumple la siguiente condición:

Sea `cnt` el número de índices `i` en el rango `[l, r]` tal que `nums[i] % modulo == k`. Entonces, `cnt % modulo == k`.

Devuelve un entero que representa la cantidad de subarrays interesantes.
Nota: Un subarray es una secuencia contigua no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [3,2,4], modulo = 2, k = 1
Salida: 3
Explicación: En este ejemplo, los subarrays interesantes son:
El subarray nums[0..0] que es [3].
- Hay solo un índice, i = 0, en el rango [0, 0] que satisface nums[i] % modulo == k.
- Entonces, cnt = 1 y cnt % modulo == k.
El subarray nums[0..1] que es [3,2].
- Hay solo un índice, i = 0, en el rango [0, 1] que satisface nums[i] % modulo == k.
- Entonces, cnt = 1 y cnt % modulo == k.
El subarray nums[0..2] que es [3,2,4].
- Hay solo un índice, i = 0, en el rango [0, 2] que satisface nums[i] % modulo == k.
- Entonces, cnt = 1 y cnt % modulo == k.
Se puede demostrar que no hay otros subarrays interesantes. Por lo tanto, la respuesta es 3.
Ejemplo 2:

Entrada: nums = [3,1,9,6], modulo = 3, k = 0
Salida: 2
Explicación: En este ejemplo, los subarrays interesantes son:
El subarray nums[0..3] que es [3,1,9,6].
- Hay tres índices, i = 0, 2, 3, en el rango [0, 3] que satisfacen nums[i] % modulo == k.
- Entonces, cnt = 3 y cnt % modulo == k.
El subarray nums[1..1] que es [1].
- No hay ningún índice, i, en el rango [1, 1] que satisfaga nums[i] % modulo == k.
- Entonces, cnt = 0 y cnt % modulo == k.
Se puede demostrar que no hay otros subarrays interesantes. Por lo tanto, la respuesta es 2.

Restricciones:

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

Se le da una matriz de números enteros con índice 0, un módulo entero y un k entero.
Su tarea es encontrar el número de submatrices que son interesantes.
Una submatriz nums[l..r] es interesante si se cumple la siguiente condición:

Sea cnt el número de índices i en el rango [l, r] tal que nums[i] % modulo == k. Entonces, cnt % modulo == k.

Devuelve un entero que denota el número de submatrices interesantes.
Nota: Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1

Entrada: nums = [3,2,4], modulo = 2, k = 1
Salida: 3
Explicación: En este ejemplo las submatrices interesantes son:
La submatriz nums[0..0] que es [3].
- Sólo hay un índice, i = 0, en el rango [0, 0] que satisface nums[i] % modulo == k.
- Por lo tanto, cnt = 1 y cnt % modulo == k.
La submatriz nums[0..1] que es [3,2].
- Sólo hay un índice, i = 0, en el intervalo [0, 1] que satisface nums[i] % modulo == k.
- Por lo tanto, cnt = 1 y cnt % modulo == k.
La submatriz nums[0..2] que es [3,2,4].
- Sólo hay un índice, i = 0, en el intervalo [0, 2] que satisface nums[i] % modulo == k.
- Por lo tanto, cnt = 1 y cnt % modulo == k.
Se puede demostrar que no hay otras submatrices interesantes. Por tanto, la respuesta es 3.
Ejemplo 2:

Entrada: nums = [3,1,9,6], modulo = 3, k = 0
Salida: 2
Explicación: En este ejemplo las submatrices interesantes son:
La submatriz nums[0..3] que es [3,1,9,6].
- Hay tres índices, i = 0, 2, 3, en el rango [0, 3] que satisfacen nums[i] % modulo == k.
- Por lo tanto, cnt = 3 y cnt % modulo == k.
La submatriz nums[1..1] que es [1].
- No hay ningún índice, i, en el rango [1, 1] que satisfaga nums[i] % modulo == k.
- Por lo tanto, cnt = 0 y cnt % modulo == k.
Se puede demostrar que no hay otras submatrices interesantes. Por tanto, la respuesta es 2.

Restricciones:

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


Tienes un array nums de longitud n y un entero m. Necesitas determinar si es posible dividir el array en n subarrays no vacíos realizando una serie de pasos.
En cada paso, puedes seleccionar un array existente (que puede ser el resultado de pasos anteriores) con una longitud de al menos dos y dividirlo en dos subarrays, si para cada subarray resultante se cumple al menos una de las siguientes condiciones:

La longitud del subarray es uno, o
La suma de los elementos del subarray es mayor o igual a m.

Devuelve true si puedes dividir el array dado en n subarrays, de lo contrario devuelve false.
Nota: Un subarray es una secuencia contigua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [2, 2, 1], m = 4
Salida: true
Explicación: Podemos dividir el array en [2, 2] y [1] en el primer paso. Luego, en el segundo paso, podemos dividir [2, 2] en [2] y [2]. Como resultado, la respuesta es true.
Ejemplo 2:

Entrada: nums = [2, 1, 3], m = 5
Salida: false
Explicación: Podemos intentar dividir el array de dos maneras: la primera manera es tener [2, 1] y [3], y la segunda manera es tener [2] y [1, 3]. Sin embargo, ambas maneras no son válidas. Así que, la respuesta es false.
Ejemplo 3:

Entrada: nums = [2, 3, 3, 2, 3], m = 6
Salida: true
Explicación: Podemos dividir el array en [2, 3, 3, 2] y [3] en el primer paso. Luego, en el segundo paso, podemos dividir [2, 3, 3, 2] en [2, 3, 3] y [2]. Luego, en el tercer paso, podemos dividir [2, 3, 3] en [2] y [3, 3]. Y en el último paso podemos dividir [3, 3] en [3] y [3]. Como resultado, la respuesta es true.

Restricciones:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Se le da una matriz nums de longitud n y un número entero m. Debe determinar si es posible dividir la matriz en n matrices no vacías realizando una serie de pasos.
En cada paso, puede seleccionar una matriz existente (que puede ser el resultado de pasos anteriores) con una longitud de al menos dos y dividirla en dos submatrices, si, para cada submatriz resultante, se cumple al menos una de las siguientes condiciones:

La longitud de la submatriz es uno, o
La suma de los elementos de la submatriz es mayor o igual que m.

Devuelve verdadero si se puede dividir la matriz dada en n matrices, en caso contrario devuelve falso.
Nota: Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [2, 2, 1], m = 4
Salida: true
Explicación: Podemos dividir la matriz en [2, 2] y [1] en el primer paso. Luego, en el segundo paso, podemos dividir [2, 2] en [2] y [2]. Como resultado, la respuesta es verdadera.
Ejemplo 2:

Entrada: nums = [2, 1, 3], m = 5
Salida: false
Explicación: Podemos intentar dividir el array de dos formas diferentes: la primera forma es tener [2, 1] y [3], y la segunda forma es tener [2] y [1, 3]. Sin embargo, ambas formas no son válidas. Por tanto, la respuesta es falsa.
Ejemplo 3:

Entrada: nums = [2, 3, 3, 2, 3], m = 6
Salida: true
Explicación: Podemos dividir la matriz en [2, 3, 3, 2] y [3] en el primer paso. Luego, en el segundo paso, podemos dividir [2, 3, 3, 2] en [2, 3, 3] y [2]. En el tercer paso, podemos dividir [2, 3, 3] en [2] y [3, 3]. Y en el último paso podemos dividir [3, 3] en [3] y [3]. Como resultado, la respuesta es verdadera.

Restricciones:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Dado un array de enteros nums indexado desde 0 de longitud n y un entero target, devuelve el número de pares (i, j) donde 0 <= i < j < n y nums[i] + nums[j] < target.

Ejemplo 1:

Entrada: nums = [-1,1,2,3,1], target = 2
Salida: 3
Explicación: Hay 3 pares de índices que satisfacen las condiciones enunciadas:
- (0, 1) ya que 0 < 1 y nums[0] + nums[1] = 0 < target
- (0, 2) ya que 0 < 2 y nums[0] + nums[2] = 1 < target
- (0, 4) ya que 0 < 4 y nums[0] + nums[4] = 0 < target
Nótese que (0, 3) no se cuenta ya que nums[0] + nums[3] no es estrictamente menor que el target.

Ejemplo 2:

Entrada: nums = [-6,2,5,-2,-7,-1,3], target = -2
Salida: 10
Explicación: Hay 10 pares de índices que satisfacen las condiciones enunciadas:
- (0, 1) ya que 0 < 1 y nums[0] + nums[1] = -4 < target
- (0, 3) ya que 0 < 3 y nums[0] + nums[3] = -8 < target
- (0, 4) ya que 0 < 4 y nums[0] + nums[4] = -13 < target
- (0, 5) ya que 0 < 5 y nums[0] + nums[5] = -7 < target
- (0, 6) ya que 0 < 6 y nums[0] + nums[6] = -3 < target
- (1, 4) ya que 1 < 4 y nums[1] + nums[4] = -5 < target
- (3, 4) ya que 3 < 4 y nums[3] + nums[4] = -9 < target
- (3, 5) ya que 3 < 5 y nums[3] + nums[5] = -3 < target
- (4, 5) ya que 4 < 5 y nums[4] + nums[5] = -8 < target
- (4, 6) ya que 4 < 6 y nums[4] + nums[6] = -4 < target

Restricciones:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Dado un array de enteros nums, indexado desde 0 y de longitud n y un entero objetivo, devuelve el número de pares (i, j) donde 0 <= i < j < n y nums[i] + nums[j] < destino.

Ejemplo 1:

Entrada: nums = [-1,1,2,3,1], target = 2
Salida: 3
Explicación: Hay 3 pares de índices que satisfacen las condiciones de la declaración:
- (0, 1) desde 0 < 1 y nums[0] + nums[1] = 0 < objetivo
- (0, 2) desde 0 < 2 y nums[0] + nums[2] = 1 < objetivo
- (0, 4) desde 0 < 4 y nums[0] + nums[4] = 0 < objetivo
Tenga en cuenta que (0, 3) no se cuenta ya que nums[0] + nums[3] no es estrictamente menor que el objetivo.

Ejemplo 2:

Entrada: nums = [-6,2,5,-2,-7,-1,3], target = -2
Salida: 10
Explicación: Hay 10 pares de índices que satisfacen las condiciones de la declaración:
- (0, 1) desde 0 < 1 y nums[0] + nums[1] = -4 < objetivo
- (0, 3) desde 0 < 3 y nums[0] + nums[3] = -8 < objetivo
- (0, 4) desde 0 < 4 y nums[0] + nums[4] = -13 < objetivo
- (0, 5) desde 0 < 5 y nums[0] + nums[5] = -7 < objetivo
- (0, 6) desde 0 < 6 y nums[0] + nums[6] = -3 < objetivo
- (1, 4) desde 1 < 4 y nums[1] + nums[4] = -5 < objetivo
- (3, 4) desde 3 < 4 y nums[3] + nums[4] = -9 < objetivo
- (3, 5) ya que 3 < 5 y nums[3] + nums[5] = -3 < objetivo
- (4, 5) desde 4 < 5 y nums[4] + nums[5] = -8 < objetivo
- (4, 6) desde 4 < 6 y nums[4] + nums[6] = -4 < objetivo

Restricciones:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Dado un arreglo de enteros indexado en 0 nums de longitud n y un objetivo entero, devuelve el número de pares (i, j) donde 0 <= i < j < n y nums[i] + nums[j] < target.

Ejemplo 1:

Entrada: nums = [-1,1,2,3,1], target = 2
Salida: 3
Explicación: Hay 3 pares de índices que satisfacen las condiciones de la declaración:
- (0, 1) ya que 0 < 1 y nums[0] + nums[1] = 0 < target
- (0, 2) ya que 0 < 2 y nums[0] + nums[2] = 1 < target
- (0, 4) ya que 0 < 4 y nums[0] + nums[4] = 0 < target
Tenga en cuenta que (0, 3) no se cuenta ya que nums[0] + nums[3] no es estrictamente menor que el target.

Ejemplo 2:

Entrada: nums = [-6,2,5,-2,-7,-1,3], target = -2
Salida: 10
Explicación: Hay 10 pares de índices que satisfacen las condiciones de la declaración:
- (0, 1) ya que 0 < 1 y nums[0] + nums[1] = -4 < target
- (0, 3) ya que 0 < 3 y nums[0] + nums[3] = -8 < target
- (0, 4) ya que 0 < 4 y nums[0] + nums[4] = -13 < target
- (0, 5) ya que 0 < 5 y nums[0] + nums[5] = -7 < target
- (0, 6) ya que 0 < 6 y nums[0] + nums[6] = -3 < target
- (1, 4) ya que 1 < 4 y nums[1] + nums[4] = -5 < target
- (3, 4) ya que 3 < 4 y nums[3] + nums[4] = -9 < target
- (3, 5) ya que 3 < 5 y nums[3] + nums[5] = -3 < target
- (4, 5) ya que 4 < 5 y nums[4] + nums[5] = -8 < target
- (4, 6) ya que 4 < 6 y nums[4] + nums[6] = -4 < target

Restricciones:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50


Se te da un array indexado desde 0 llamado usageLimits de longitud n.
Tu tarea es crear grupos utilizando números del 0 al n - 1, asegurando que cada número, i, se use no más de usageLimits[i] veces en total a través de todos los grupos. También debes cumplir con las siguientes condiciones:

Cada grupo debe consistir en números distintos, lo que significa que no se permiten números duplicados dentro de un solo grupo.
Cada grupo (excepto el primero) debe tener una longitud estrictamente mayor que el grupo anterior.

Devuelve un entero que denote el número máximo de grupos que puedes crear mientras se satisfacen estas condiciones.

Ejemplo 1:

Entrada: usageLimits = [1,2,5]
Salida: 3
Explicación: En este ejemplo, podemos usar el 0 como máximo una vez, el 1 como máximo dos veces, y el 2 como máximo cinco veces.
Una forma de crear el número máximo de grupos cumpliendo con las condiciones es:
El grupo 1 contiene el número [2].
El grupo 2 contiene los números [1,2].
El grupo 3 contiene los números [0,1,2].
Se puede demostrar que el número máximo de grupos es 3.
Por lo tanto, la salida es 3.
Ejemplo 2:

Entrada: usageLimits = [2,1,2]
Salida: 2
Explicación: En este ejemplo, podemos usar el 0 como máximo dos veces, el 1 como máximo una vez, y el 2 como máximo dos veces.
Una forma de crear el número máximo de grupos cumpliendo con las condiciones es:
El grupo 1 contiene el número [0].
El grupo 2 contiene los números [1,2].
Se puede demostrar que el número máximo de grupos es 2.
Por lo tanto, la salida es 2.

Ejemplo 3:

Entrada: usageLimits = [1,1]
Salida: 1
Explicación: En este ejemplo, podemos usar tanto el 0 como el 1 como máximo una vez.
Una forma de crear el número máximo de grupos cumpliendo con las condiciones es:
El grupo 1 contiene el número [0].
Se puede demostrar que el número máximo de grupos es 1.
Por lo tanto, la salida es 1.

Restricciones:

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

Se le proporciona una matriz de índice 0 usageLimits de longitud n.
Su tarea es crear grupos utilizando números del 0 al n - 1, asegurándose de que cada número, i, no se utilice más de usageLimits[i] veces en total en todos los grupos. También debe satisfacer las siguientes condiciones:

Cada grupo debe constar de números distintos, lo que significa que no se permiten números duplicados dentro de un solo grupo.
Cada grupo (excepto el primero) debe tener una longitud estrictamente mayor que el grupo anterior.

Devuelva un entero que indique la cantidad máxima de grupos que puede crear mientras se satisfacen estas condiciones.

Ejemplo 1:

Entrada: usageLimits = [1,2,5]
Salida: 3
Explicación: En este ejemplo, podemos utilizar 0 como máximo una vez, 1 como máximo dos veces y 2 como máximo cinco veces.
Una forma de crear la cantidad máxima de grupos mientras se satisfacen las condiciones es:
El grupo 1 contiene el número [2].
El grupo 2 contiene los números [1,2].
El grupo 3 contiene los números [0,1,2].
Se puede demostrar que el número máximo de grupos es 3.
Por lo tanto, la salida es 3.
Ejemplo 2:

Entrada: usageLimits = [2,1,2]
Salida: 2
Explicación: En este ejemplo, podemos usar 0 como máximo dos veces, 1 como máximo una vez y 2 como máximo dos veces.
Una forma de crear el número máximo de grupos mientras se satisfacen las condiciones es:
El grupo 1 contiene el número [0].
El grupo 2 contiene los números [1,2].
Se puede demostrar que el número máximo de grupos es 2.
Por lo tanto, la salida es 2.

Ejemplo 3:

Entrada: usageLimits = [1,1]
Salida: 1
Explicación: En este ejemplo, podemos usar tanto 0 como 1 como máximo una vez.
Una forma de crear el número máximo de grupos mientras se satisfacen las condiciones es:
El grupo 1 contiene el número [0].
Se puede demostrar que el número máximo de grupos es 1.
Por lo tanto, el resultado es 1.

Restricciones:

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


Se te da un array indexado desde 0, `nums`, que contiene `n` enteros.
Cada segundo, realizas la siguiente operación en el array:

Para cada índice `i` en el rango [0, n - 1], reemplaza `nums[i]` con `nums[i]`, `nums[(i - 1 + n) % n]` o `nums[(i + 1) % n]`.

Nota que todos los elementos se reemplazan simultáneamente.
Devuelve el número mínimo de segundos necesarios para que todos los elementos en el array `nums` sean iguales.

Ejemplo 1:

Entrada: nums = [1,2,1,2]
Salida: 1
Explicación: Podemos igualar el array en 1 segundo de la siguiente manera:
- En el primer segundo, reemplaza los valores en cada índice con [nums[3], nums[1], nums[3], nums[3]]. Después del reemplazo, nums = [2,2,2,2].
Se puede demostrar que 1 segundo es la cantidad mínima de segundos necesaria para igualar el array.

Ejemplo 2:

Entrada: nums = [2,1,3,3,2]
Salida: 2
Explicación: Podemos igualar el array en 2 segundos de la siguiente manera:
- En el primer segundo, reemplaza los valores en cada índice con [nums[0], nums[2], nums[2], nums[2], nums[3]]. Después del reemplazo, nums = [2,3,3,3,3].
- En el segundo segundo, reemplaza los valores en cada índice con [nums[1], nums[1], nums[2], nums[3], nums[4]]. Después del reemplazo, nums = [3,3,3,3,3].
Se puede demostrar que 2 segundos es la cantidad mínima de segundos necesaria para igualar el array.

Ejemplo 3:

Entrada: nums = [5,5,5,5]
Salida: 0
Explicación: No necesitamos realizar ninguna operación ya que todos los elementos del array inicial son iguales.

Restricciones:

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

Se te da un conjunto indexado desde 0, nums, que contiene n enteros.
En cada segundo, realizas la siguiente operación en el conjunto:

Para cada índice i en el rango [0, n - 1], reemplaza nums[i] con nums[i], nums[(i - 1 + n) % n] o nums[(i + 1) % n].

Nota que todos los elementos se reemplazan simultáneamente.
Devuelve el número mínimo de segundos necesarios para que todos los elementos en el conjunto nums sean iguales.

Ejemplo 1:

Entrada: nums = [1,2,1,2]
Salida: 1
Explicación: Podemos igualar el conjunto en 1 segundo de la siguiente manera:
- En el primer segundo, reemplaza los valores en cada índice con [nums[3], nums[1], nums[3], nums[3]]. Después del reemplazo, nums = [2,2,2,2].
Se puede demostrar que 1 segundo es la cantidad mínima de segundos necesaria para igualar el conjunto.

Ejemplo 2:

Entrada: nums = [2,1,3,3,2]
Salida: 2
Explicación: Podemos igualar el conjunto en 2 segundos de la siguiente manera:
- En el primer segundo, reemplaza los valores en cada índice con [nums[0], nums[2], nums[2], nums[2], nums[3]]. Después del reemplazo, nums = [2,3,3,3,3].
- En el segundo segundo, reemplaza los valores en cada índice con [nums[1], nums[1], nums[2], nums[3], nums[4]]. Después del reemplazo, nums = [3,3,3,3,3].
Se puede demostrar que 2 segundos es la cantidad mínima de segundos necesaria para igualar el conjunto.

Ejemplo 3:

Entrada: nums = [5,5,5,5]
Salida: 0
Explicación: No necesitamos realizar ninguna operación ya que todos los elementos del conjunto inicial son iguales.

Restricciones:

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

Se te da un arreglo indexado desde 0 llamado nums que contiene n enteros.
Cada segundo, realizas la siguiente operación en el arreglo:

Para cada índice i en el rango [0, n - 1], reemplaza nums[i] con nums[i], nums[(i - 1 + n) % n] o nums[(i + 1) % n].

Nota que todos los elementos se reemplazan simultáneamente.
Devuelve el número mínimo de segundos necesarios para que todos los elementos en el arreglo nums sean iguales.

Ejemplo 1:

Entrada: nums = [1,2,1,2]
Salida: 1
Explicación: Podemos igualar el arreglo en 1 segundo de la siguiente manera:
- En el 1.er segundo, reemplaza los valores en cada índice con [nums[3],nums[1],nums[3],nums[3]]. Después del reemplazo, nums = [2,2,2,2].
Se puede demostrar que 1 segundo es la cantidad mínima de segundos necesaria para igualar el arreglo.

Ejemplo 2:

Entrada: nums = [2,1,3,3,2]
Salida: 2
Explicación: Podemos igualar el arreglo en 2 segundos de la siguiente manera:
- En el 1.er segundo, reemplaza los valores en cada índice con [nums[0],nums[2],nums[2],nums[2],nums[3]]. Después del reemplazo, nums = [2,3,3,3,3].
- En el 2.º segundo, reemplaza los valores en cada índice con [nums[1],nums[1],nums[2],nums[3],nums[4]]. Después del reemplazo, nums = [3,3,3,3,3].
Se puede demostrar que 2 segundos es la cantidad mínima de segundos necesaria para igualar el arreglo.

Ejemplo 3:

Entrada: nums = [5,5,5,5]
Salida: 0
Explicación: No necesitamos realizar ninguna operación, ya que todos los elementos del arreglo inicial son iguales.

Restricciones:

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


Dadas dos enteros positivos low y high representados como cadenas, encuentra la cantidad de números escalonados en el rango inclusivo [low, high].
Un número escalonado es un entero tal que todos sus dígitos adyacentes tienen una diferencia absoluta de exactamente 1.
Devuelve un entero que denote la cantidad de números escalonados en el rango inclusivo [low, high].
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.
Nota: Un número escalonado no debe tener un cero a la izquierda.

Ejemplo 1:

Entrada: low = "1", high = "11"
Salida: 10
Explicación: Los números stepping en el rango [1,11] son 1, 2, 3, 4, 5, 6, 7, 8, 9 y 10. Hay un total de 10 números stepping en el rango. Por lo tanto, la salida es 10.
Ejemplo 2:

Entrada: low = "90", high = "101"
Salida: 2
Explicación: Los números stepping en el rango [90,101] son 98 y 101. Hay un total de 2 números stepping en el rango. Por lo tanto, la salida es 2.

Restricciones:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low y high consisten solo en dígitos.
low y high no tienen ceros a la izquierda.

Dadas dos enteros positivos low y high representados como cadenas, encuentra la cantidad de números stepping en el rango inclusivo [low, high].
Un número stepping es un entero tal que todos sus dígitos adyacentes tienen una diferencia absoluta de exactamente 1.
Devuelve un entero que denote la cantidad de números stepping en el rango inclusivo [low, high].
Dado que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.
Nota: Un número stepping no debe tener un cero a la izquierda.

Ejemplo 1:

Input: low = "1", high = "11"
Output: 10
Explicación: Los números stepping en el rango [1,11] son 1, 2, 3, 4, 5, 6, 7, 8, 9 y 10. Hay un total de 10 números stepping en el rango. Por lo tanto, la salida es 10.
Ejemplo 2:

Input: low = "90", high = "101"
Output: 2
Explicación: Los números stepping en el rango [90,101] son 98 y 101. Hay un total de 2 números stepping en el rango. Por lo tanto, la salida es 2.

Restricciones:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low y high consisten solo en dígitos.
low y high no tienen ceros a la izquierda.

Dados dos números enteros positivos low y high representados como cadenas, encuentre el recuento de números escalonados en el rango inclusivo [low, high].
Un número escalonado es un número entero tal que todos sus dígitos adyacentes tienen una diferencia absoluta de exactamente 1.
Devuelva un número entero que denote el recuento de números escalonados en el rango inclusivo [low, high].
Como la respuesta puede ser muy grande, devuélvala módulo 10^9 + 7.
Nota: Un número escalonado no debe tener un cero inicial.

Ejemplo 1:

Entrada: low = "1", high = "11"
Salida: 10
Explicación: Los números escalonados en el rango [1,11] son 1, 2, 3, 4, 5, 6, 7, 8, 9 y 10. Hay un total de 10 números escalonados en el rango. Por lo tanto, la salida es 10.
Ejemplo 2:

Entrada: low = "90", high = "101"
Salida: 2
Explicación: Los números de paso en el rango [90,101] son 98 y 101. Hay un total de 2 números de paso en el rango. Por lo tanto, la salida es 2.

Restricciones:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low y high constan solo de dígitos.
low y high no tienen ceros a la izquierda.


Se te proporcionan dos arreglos de enteros nums1 y nums2 de igual longitud con índice inicial 0. Cada segundo, para todos los índices 0 <= i < nums1.length, el valor de nums1[i] se incrementa en nums2[i]. Después de esto, puedes realizar la siguiente operación:

Elige un índice 0 <= i < nums1.length y haz nums1[i] = 0.

También se te proporciona un entero x.
Devuelve el tiempo mínimo en el que puedes hacer que la suma de todos los elementos de nums1 sea menor o igual a x, o -1 si esto no es posible.

Ejemplo 1:

Entrada: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Salida: 3
Explicación:
En el 1er segundo, aplicamos la operación en i = 0. Por lo tanto nums1 = [0,2+2,3+3] = [0,4,6].
En el 2do segundo, aplicamos la operación en i = 1. Por lo tanto nums1 = [0+1,0,6+3] = [1,0,9].
En el 3er segundo, aplicamos la operación en i = 2. Por lo tanto nums1 = [1+1,0+2,0] = [2,2,0].
Ahora la suma de nums1 = 4. Se puede mostrar que estas operaciones son óptimas, por lo que devolvemos 3.

Ejemplo 2:

Entrada: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Salida: -1
Explicación: Se puede demostrar que la suma de nums1 siempre será mayor que x, sin importar qué operaciones se realicen.

Restricciones:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Se le proporcionan dos matrices de enteros indexados en 0, nums1 y nums2, de igual longitud. Cada segundo, para todos los índices 0 <= i < nums1.length, el valor de nums1[i] se incrementa en nums2[i]. Una vez hecho esto, puede realizar la siguiente operación:

Elija un índice 0 <= i < nums1.length y haga que nums1[i] sea 0.

También se le proporciona un entero x.
Devuelva el tiempo mínimo en el que puede hacer que la suma de todos los elementos de nums1 sea menor o igual a x, o -1 si esto no es posible.

Ejemplo 1:

Entrada: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Salida: 3
Explicación:
Para el 1.er segundo, aplicamos la operación sobre i = 0. Por lo tanto, nums1 = [0,2+2,3+3] = [0,4,6].
Para el 2.º segundo, aplicamos la operación sobre i = 1. Por lo tanto, nums1 = [0+1,0,6+3] = [1,0,9].
Para el 3.er segundo, aplicamos la operación sobre i = 2. Por lo tanto, nums1 = [1+1,0+2,0] = [2,2,0].
Ahora, la suma de nums1 = 4. Se puede demostrar que estas operaciones son óptimas, por lo que devolvemos 3.

Ejemplo 2:

Entrada: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Salida: -1
Explicación: Se puede demostrar que la suma de nums1 siempre será mayor que x, sin importar qué operaciones se realicen.

Restricciones:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6