Se le proporcionan dos matrices de enteros indexados en 0, nums1 y nums2, de tamaños n y m, respectivamente.
Considere calcular los siguientes valores:

La cantidad de índices i tales que 0 <= i < n y nums1[i] aparece al menos una vez en nums2.
La cantidad de índices i tales que 0 <= i < m y nums2[i] aparece al menos una vez en nums1.

Devuelva una matriz de enteros respuesta de tamaño 2 que contenga los dos valores en el orden anterior.

Ejemplo 1:

Entrada: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Salida: [3,4]
Explicación: Calculamos los valores de la siguiente manera:
- Los elementos en los índices 1, 2 y 3 en nums1 aparecen al menos una vez en nums2. Por lo tanto, el primer valor es 3.
- Los elementos en los índices 0, 1, 3 y 4 en nums2 aparecen al menos una vez en nums1. Por lo tanto, el segundo valor es 4.

Ejemplo 2:

Entrada: nums1 = [3,4,2,3], nums2 = [1,5]
Salida: [0,0]
Explicación: No hay elementos comunes entre las dos matrices, por lo que los dos valores serán 0.

Restricciones:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Se te proporcionan dos arreglos enteros indexados desde 0, nums1 y nums2, de tamaños n y m, respectivamente. Considera calcular los siguientes valores:

El número de índices i tal que 0 <= i < n y nums1[i] aparece al menos una vez en nums2.
El número de índices i tal que 0 <= i < m y nums2[i] aparece al menos una vez en nums1.

Devuelve un arreglo entero answer de tamaño 2 que contenga los dos valores en el orden anterior.

Ejemplo 1:

Entrada: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Salida: [3,4]
Explicación: Calculamos los valores de la siguiente manera:
- Los elementos en los índices 1, 2 y 3 en nums1 aparecen al menos una vez en nums2. Así que el primer valor es 3.
- Los elementos en los índices 0, 1, 3 y 4 en nums2 aparecen al menos una vez en nums1. Así que el segundo valor es 4.

Ejemplo 2:

Entrada: nums1 = [3,4,2,3], nums2 = [1,5]
Salida: [0,0]
Explicación: No hay elementos comunes entre los dos arreglos, por lo que los dos valores serán 0.

Restricciones:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100


Tienes tres cadenas s1, s2 y s3. Tienes que realizar la siguiente operación en estas tres cadenas tantas veces como quieras.
En una operación puedes elegir una de estas tres cadenas de manera que su longitud sea al menos 2 y eliminar el carácter más a la derecha de la misma.
Devuelve la cantidad mínima de operaciones que necesitas realizar para que las tres cadenas sean iguales si hay una manera de hacerlas iguales, de lo contrario, devuelve -1.

Ejemplo 1:

Entrada: s1 = "abc", s2 = "abb", s3 = "ab"
Salida: 2
Explicación: Realizar operaciones en s1 y s2 una vez dará como resultado tres cadenas iguales.
Se puede demostrar que no hay manera de hacerlas iguales con menos de dos operaciones.
Ejemplo 2:

Entrada: s1 = "dac", s2 = "bac", s3 = "cac"
Salida: -1
Explicación: Debido a que las letras más a la izquierda de s1 y s2 no son iguales, no podrían ser iguales después de cualquier cantidad de operaciones. Por lo tanto, la respuesta es -1.

Restricciones:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 y s3 constan únicamente de letras minúsculas del alfabeto inglés.

Se te dan tres cadenas s1, s2 y s3. Debes realizar la siguiente operación en estas tres cadenas tantas veces como quieras.
En una operación, puedes elegir una de estas tres cadenas que tenga al menos una longitud de 2 y eliminar el carácter más a la derecha.
Devuelve el número mínimo de operaciones que necesitas realizar para que las tres cadenas sean iguales si es que hay una manera de hacerlas iguales, de lo contrario, devuelve -1.

Ejemplo 1:

Entrada: s1 = "abc", s2 = "abb", s3 = "ab"
Salida: 2
Explicación: Realizar operaciones en s1 y s2 una vez dará como resultado tres cadenas iguales.
Se puede demostrar que no hay manera de hacerlas iguales con menos de dos operaciones.

Ejemplo 2:

Entrada: s1 = "dac", s2 = "bac", s3 = "cac"
Salida: -1
Explicación: Debido a que las letras más a la izquierda de s1 y s2 no son iguales, no podrían ser iguales después de cualquier número de operaciones. Así que la respuesta es -1.

Restricciones:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 y s3 consisten solo en letras minúsculas inglesas.

Se te dan tres cadenas s1, s2 y s3. Debes realizar la siguiente operación en estas tres cadenas tantas veces como quieras.
En una operación, puedes elegir una de estas tres cadenas que tenga al menos una longitud de 2 y eliminar el carácter más a la derecha.
Devuelve el número mínimo de operaciones que necesitas realizar para que las tres cadenas sean iguales si hay una manera de hacerlas iguales, de lo contrario, devuelve -1.

Ejemplo 1:

Entrada: s1 = "abc", s2 = "abb", s3 = "ab"
Salida: 2
Explicación: Realizar operaciones en s1 y s2 una vez dará como resultado tres cadenas iguales.
Se puede demostrar que no hay manera de hacerlas iguales con menos de dos operaciones.

Ejemplo 2:

Entrada: s1 = "dac", s2 = "bac", s3 = "cac"
Salida: -1
Explicación: Debido a que las letras más a la izquierda de s1 y s2 no son iguales, no podrían ser iguales después de cualquier número de operaciones. Así que la respuesta es -1.

Condiciones:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 y s3 consisten solo en letras minúsculas inglesas.


Estás en un mercado de frutas con diferentes tipos de frutas exóticas en exhibición.
Se te da un array indexado desde 1 llamado prices, donde prices[i] denota el número de monedas necesarias para comprar la i-ésima fruta.
El mercado de frutas tiene la siguiente oferta:

Si compras la i-ésima fruta a precios[i] monedas, puedes obtener las siguientes i frutas gratis.

Ten en cuenta que incluso si puedes llevarte la fruta j gratis, aún puedes comprarla por precios[j] monedas para recibir una nueva oferta.
Devuelve el número mínimo de monedas necesarias para adquirir todas las frutas.

Ejemplo 1:

Entrada: prices = [3,1,2]
Salida: 4
Explicación: Puedes adquirir las frutas de la siguiente manera:
- Compra la 1-ª fruta por 3 monedas, se te permite llevar la 2-ª fruta gratis.
- Compra la 2-ª fruta por 1 moneda, se te permite llevar la 3-ª fruta gratis.
- Lleva la 3-ª fruta gratis.
Ten en cuenta que aunque se te permitió llevar la 2-ª fruta gratis, la compraste porque es más óptimo.
Se puede demostrar que 4 es el número mínimo de monedas necesarias para adquirir todas las frutas.

Ejemplo 2:

Entrada: prices = [1,10,1,1]
Salida: 2
Explicación: Puedes adquirir las frutas de la siguiente manera:
- Compra la 1-ª fruta por 1 moneda, se te permite llevar la 2-ª fruta gratis.
- Lleva la 2-ª fruta gratis.
- Compra la 3-ª fruta por 1 moneda, se te permite llevar la 4-ª fruta gratis.
- Lleva la 4-ª fruta gratis.
Se puede demostrar que 2 es el número mínimo de monedas necesarias para adquirir todas las frutas.

Restricciones:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Estás en un mercado de frutas con diferentes tipos de frutas exóticas en exhibición.
Se te da una matriz indexada en 1, prices, donde prices[i] denota la cantidad de monedas necesarias para comprar la i^th fruta.
El mercado de frutas tiene la siguiente oferta:

Si compras la i^th fruta con prices[i] monedas, puedes obtener las siguientes i frutas gratis.

Ten en cuenta que incluso si puedes tomar la fruta j gratis, aún puedes comprarla con prices[j] monedas para recibir una nueva oferta.
Devuelve la cantidad mínima de monedas necesarias para adquirir todas las frutas.

Ejemplo 1:

Entrada: prices = [3,1,2]
Salida: 4
Explicación: Puedes adquirir las frutas de la siguiente manera:
- Compra la 1^st fruta con 3 monedas, puedes tomar la 2^nd fruta gratis.
- Compra la 2^nd fruta con 1 moneda, puedes tomar la 3^rd fruta gratis.
- Toma la 3^rd fruta gratis.
Tenga en cuenta que, aunque se le permitió tomar la 2.ª fruta gratis, la compró porque es más óptimo.
Se puede demostrar que 4 es la cantidad mínima de monedas necesarias para adquirir todas las frutas.

Ejemplo 2:

Entrada: precios = [1,10,1,1]
Salida: 2
Explicación: Puede adquirir las frutas de la siguiente manera:
- Compre la 1.ª fruta con 1 moneda, se le permite tomar la 2.ª fruta gratis.
- Tome la 2.ª fruta gratis.
- Compre la 3.ª fruta por 1 moneda, se le permite tomar la 4.ª fruta gratis.
- Tome la 4.ª fruta gratis.
Se puede demostrar que 2 es la cantidad mínima de monedas necesarias para adquirir todas las frutas.

Restricciones:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


Se te da una cadena s y un entero positivo k.
Sean vocales y consonantes el número de vocales y consonantes en una cadena.
Una cadena es hermosa si:

vocales == consonantes.
(vocales * consonantes) % k == 0, en otras palabras, la multiplicación de vocales y consonantes es divisible por k.

Devuelve el número de subcadenas hermosas no vacías en la cadena dada s.
Una subcadena es una secuencia contigua de caracteres en una cadena.
Las letras vocales en inglés son 'a', 'e', 'i', 'o' y 'u'.
Las letras consonantes en inglés son todas las letras excepto las vocales.

Ejemplo 1:

Entrada: s = "baeyh", k = 2
Salida: 2
Explicación: Hay 2 subcadenas hermosas en la cadena dada.
- Subcadena "baeyh", vocales = 2 (["a",e"]), consonantes = 2 (["y","h"]).
Puedes ver que la cadena "aeyh" es hermosa ya que vocales == consonantes y vocales * consonantes % k == 0.
- Subcadena "baeyh", vocales = 2 (["a",e"]), consonantes = 2 (["b","y"]).
Puedes ver que la cadena "baey" es hermosa ya que vocales == consonantes y vocales * consonantes % k == 0.
Se puede demostrar que solo hay 2 subcadenas hermosas en la cadena dada.

Ejemplo 2:

Entrada: s = "abba", k = 1
Salida: 3
Explicación: Hay 3 subcadenas hermosas en la cadena dada.
- Subcadena "abba", vocales = 1 (["a"]), consonantes = 1 (["b"]).
- Subcadena "abba", vocales = 1 (["a"]), consonantes = 1 (["b"]).
- Subcadena "abba", vocales = 2 (["a","a"]), consonantes = 2 (["b","b"]).
Se puede demostrar que solo hay 3 subcadenas hermosas en la cadena dada.

Ejemplo 3:

Entrada: s = "bcdf", k = 1
Salida: 0
Explicación: No hay subcadenas hermosas en la cadena dada.

Restricciones:

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

Se le proporciona una cadena s y un entero positivo k.
Sea vocales y consonantes la cantidad de vocales y consonantes en una cadena.
Una cadena es hermosa si:

vocales == consonantes.
(vocales * consonantes) % k == 0, en otros términos, la multiplicación de vocales y consonantes es divisible por k.

Devuelve la cantidad de subcadenas hermosas no vacías en la cadena dada s.
Una subcadena es una secuencia contigua de caracteres en una cadena.
Las letras vocálicas en inglés son 'a', 'e', 'i', 'o' y 'u'.
Las letras consonánticas en inglés son todas las letras excepto las vocales.

Ejemplo 1:

Entrada: s = "baeyh", k = 2
Salida: 2
Explicación: Hay 2 subcadenas hermosas en la cadena dada.
- Subcadena "baeyh", vocales = 2 (["a",e"]), consonantes = 2 (["y", "h"]).
Puedes ver que la cadena "aeyh" es hermosa ya que vocales == consonantes y vocales * consonantes % k == 0.
- Subcadena "baeyh", vocales = 2 (["a",e"]), consonantes = 2 (["b", "y"]).
Puedes ver que la cadena "baey" es hermosa ya que vocales == consonantes y vocales * consonantes % k == 0.
Se puede demostrar que solo hay 2 subcadenas hermosas en la cadena dada.

Ejemplo 2:

Entrada: s = "abba", k = 1
Salida: 3
Explicación: Hay 3 subcadenas hermosas en la cadena dada.
- Subcadena "abba", vocales = 1 (["a"]), consonantes = 1 (["b"]).
- Subcadena "abba", vocales = 1 (["a"]), consonantes = 1 (["b"]).
- Subcadena "abba", vocales = 2 (["a", "a"]), consonantes = 2 (["b", "b"]).
Se puede demostrar que solo hay 3 subcadenas hermosas en la cadena dada.

Ejemplo 3:

Entrada: s = "bcdf", k = 1
Salida: 0
Explicación: No hay subcadenas hermosas en la cadena dada.

Restricciones:

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

Se te da una cadena s y un entero positivo k.
Sean vowels y consonants el número de vocales y consonantes en una cadena.
Una cadena es hermosa si:

vowels == consonants.
(vowels * consonants) % k == 0, en otras palabras, la multiplicación de vocales y consonantes es divisible por k.

Devuelve el número de subcadenas hermosas no vacías en la cadena dada s.
Una subcadena es una secuencia contigua de caracteres en una cadena.
Las letras vocales en inglés son 'a', 'e', 'i', 'o' y 'u'.
Las letras consonantes en inglés son todas las letras excepto las vocales.

Ejemplo 1:

Entrada: s = "baeyh", k = 2
Salida: 2
Explicación: Hay 2 subcadenas hermosas en la cadena dada.
- Subcadena "baeyh", vocales = 2 (["a",e"]), consonantes = 2 (["y","h"]).
Puedes ver que la cadena "aeyh" es hermosa ya que vowels == consonants y vowels * consonants % k == 0.
- Subcadena "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["b","y"]).
Puedes ver que la cadena "baey" es hermosa ya que vowels == consonants y vowels * consonants % k == 0.
Se puede demostrar que solo hay 2 subcadenas hermosas en la cadena dada.

Ejemplo 2:

Entrada: s = "abba", k = 1
Salida: 3
Explicación: Hay 3 subcadenas hermosas en la cadena dada.

Subcadena "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
Subcadena "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
Subcadena "abba", vowels = 2 (["a","a"]), consonants = 2 (["b","b"]).
Se puede demostrar que solo hay 3 subcadenas hermosas en la cadena dada.

Ejemplo 3:

Entrada: s = "bcdf", k = 1
Salida: 0
Explicación: No hay subcadenas hermosas en la cadena dada.

Restricciones:

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


Se te da un array de enteros indexado desde 0 llamado nums.
Puedes realizar cualquier número de operaciones, donde cada operación involucra seleccionar una subarray del array y reemplazarla con la suma de sus elementos. Por ejemplo, si el array dado es [1,3,5,6] y seleccionas la subarray [3,5], el array se convertirá en [1,8,6].
Devuelve la longitud máxima de un array no decreciente que se puede hacer después de aplicar operaciones.
Una subarray es una secuencia continua no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [5,2,2]
Salida: 1
Explicación: Este array con longitud 3 no es no decreciente.
Tenemos dos formas de hacer que la longitud del array sea dos.
Primero, elegir la subarray [2,2] convierte el array en [5,4].
Segundo, elegir la subarray [5,2] convierte el array en [7,2].
De estas dos maneras, el array no es no decreciente.
Y si elegimos la subarray [5,2,2] y la reemplazamos con [9], se convierte en no decreciente.
Así que la respuesta es 1.

Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación: El array es no decreciente. Así que la respuesta es 4.

Ejemplo 3:

Entrada: nums = [4,3,2,6]
Salida: 3
Explicación: Reemplazar [3,2] con [5] convierte el array dado en [4,5,6] que es no decreciente.
Debido a que el array dado no es no decreciente, la respuesta máxima posible es 3.

Restricciones:

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

Se le proporciona una matriz de enteros indexada 0 nums.
Puede realizar cualquier número de operaciones, donde cada operación implica seleccionar una submatriz de la matriz y reemplazarla por la suma de sus elementos. Por ejemplo, si la matriz dada es [1,3,5,6] y selecciona la submatriz [3,5], la matriz se convertirá en [1,8,6].
Devuelve la longitud máxima de una matriz no decreciente que se puede crear después de aplicar operaciones.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [5,2,2]
Salida: 1
Explicación: Esta matriz con longitud 3 no es no decreciente.
Tenemos dos formas de hacer que la longitud de la matriz sea dos.
En primer lugar, al elegir la submatriz [2,2] se convierte la matriz en [5,4].
En segundo lugar, si eliges la submatriz [5,2], la matriz se convierte en [7,2].
De estas dos maneras, la matriz no es no decreciente.
Y si elegimos el subarray [5,2,2] y lo reemplazamos con [9], se convierte en no decreciente.
Así que la respuesta es 1.

Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación: La matriz no disminuye. Así que la respuesta es 4.

Ejemplo 3:

Entrada: nums = [4,3,2,6]
Salida: 3
Explicación: Al reemplazar [3,2] por [5], se convierte la matriz dada en [4,5,6] que no disminuye.
Dado que la matriz dada no es decreciente, la respuesta máxima posible es 3.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums.
Puede realizar cualquier cantidad de operaciones, donde cada operación implica seleccionar una submatriz de la matriz y reemplazarla con la suma de sus elementos. Por ejemplo, si la matriz dada es [1,3,5,6] y selecciona la submatriz [3,5], la matriz se convertirá en [1,8,6].
Devuelve la longitud máxima de una matriz no decreciente que se puede crear después de aplicar operaciones.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [5,2,2]
Salida: 1
Explicación: Esta matriz con longitud 3 no es no decreciente.
Tenemos dos formas de hacer que la longitud de la matriz sea dos.
Primero, elegir la submatriz [2,2] convierte la matriz en [5,4].
Segundo, elegir la submatriz [5,2] convierte la matriz en [7,2].
De estas dos maneras, la matriz no es no decreciente.
Y si elegimos la submatriz [5,2,2] y la reemplazamos por [9], se vuelve no decreciente.
Por lo tanto, la respuesta es 1.

Ejemplo 2:

Entrada: nums = [1,2,3,4]
Salida: 4
Explicación: La matriz no es decreciente. Por lo tanto, la respuesta es 4.

Ejemplo 3:

Entrada: nums = [4,3,2,6]
Salida: 3
Explicación: Reemplazar [3,2] por [5] convierte la matriz dada en [4,5,6], que no es decreciente.
Debido a que la matriz dada no es no decreciente, la respuesta máxima posible es 3.

Restricciones:

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


Se te da un array indexado desde cero `nums` que consiste en enteros positivos.
Una partición de un array en uno o más subarrays contiguos se llama buena si no hay dos subarrays que contengan el mismo número.
Devuelve el número total de buenas particiones de `nums`.
Debido a que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: `nums = [1,2,3,4]`
Salida: `8`
Explicación: Las 8 posibles buenas particiones son: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), y ([1,2,3,4]).

Ejemplo 2:

Entrada: `nums = [1,1,1,1]`
Salida: `1`
Explicación: La única posible buena partición es: ([1,1,1,1]).

Ejemplo 3:

Entrada: `nums = [1,2,1,3]`
Salida: `2`
Explicación: Las 2 posibles buenas particiones son: ([1,2,1], [3]) y ([1,2,1,3]).

Restricciones:

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

Se le proporciona una matriz indexada en 0 nums que consta de números enteros positivos.
Una partición de una matriz en una o más submatrices contiguas se considera correcta si no hay dos submatrices que contengan el mismo número.
Devuelve la cantidad total de particiones correctas de nums.
Como la respuesta puede ser grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 8
Explicación: Las 8 particiones buenas posibles son: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) y ([1,2,3,4]).

Ejemplo 2:

Entrada: nums = [1,1,1,1]
Salida: 1
Explicación: La única partición buena posible es: ([1,1,1,1]).

Ejemplo 3:

Entrada: nums = [1,2,1,3]
Salida: 2
Explicación: Las 2 particiones posibles son: ([1,2,1], [3]) y ([1,2,1,3]).

Restricciones:

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


Se te da un array de enteros nums y un entero positivo k.
Devuelve el número de subarrays donde el elemento máximo de nums aparece al menos k veces en ese subarray.
Un subarray es una secuencia continua de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [1,3,2,3,3], k = 2
Salida: 6
Explicación: Los subarrays que contienen el elemento 3 al menos 2 veces son: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] y [3,3].

Ejemplo 2:

Entrada: nums = [1,4,2,1], k = 3
Salida: 0
Explicación: Ningún subarray contiene el elemento 4 al menos 3 veces.

Restricciones:

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

Se le da una matriz de enteros nums y un entero positivo k.
Devuelve el número de submatrices en las que el elemento máximo de nums aparece al menos k veces en esa submatriz.
Una submatriz es una secuencia contigua de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,3,2,3,3], k = 2
Salida: 6
Explicación: Las submatrices que contienen el elemento 3 al menos 2 veces son: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] y [3,3].

Ejemplo 2:

Entrada: nums = [1,4,2,1], k = 3
Salida: 0
Explicación: Ninguna submatriz contiene el elemento 4 al menos 3 veces.

Restricciones:

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

Se le proporciona una matriz de enteros nums y un entero positivo k.
Devuelve la cantidad de submatrices donde el elemento máximo de nums aparece al menos k veces en esa submatriz.
Una submatriz es una secuencia contigua de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,3,2,3,3], k = 2
Salida: 6
Explicación: Las submatrices que contienen el elemento 3 al menos 2 veces son: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] y [3,3].

Ejemplo 2:

Entrada: nums = [1,4,2,1], k = 3
Salida: 0
Explicación: Ninguna submatriz contiene el elemento 4 al menos 3 veces.

Restricciones:

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


Se te da un array de enteros positivos indexado desde 0 llamado nums y un entero positivo límite.
En una operación, puedes elegir dos índices i y j y cambiar nums[i] y nums[j] si |nums[i] - nums[j]| <= limit.
Devuelve el array más pequeño lexicográficamente que se pueda obtener realizando la operación cualquier cantidad de veces.
Un array a es lexicográficamente menor que un array b si en la primera posición donde a y b difieren, el array a tiene un elemento que es menor que el elemento correspondiente en b. Por ejemplo, el array [2,10,3] es lexicográficamente menor que el array [10,2,3] porque difieren en el índice 0 y 2 < 10.

Ejemplo 1:

Entrada: nums = [1,5,3,9,8], limit = 2
Salida: [1,3,5,8,9]
Explicación: Aplica la operación 2 veces:
Cambia nums[1] con nums[2]. El array se convierte en [1,3,5,9,8]
Cambia nums[3] con nums[4]. El array se convierte en [1,3,5,8,9]
No podemos obtener un array lexicográficamente más pequeño aplicando más operaciones.
Nótese que puede ser posible obtener el mismo resultado haciendo diferentes operaciones.

Ejemplo 2:

Entrada: nums = [1,7,6,18,2,1], limit = 3
Salida: [1,6,7,18,1,2]
Explicación: Aplica la operación 3 veces:
Cambia nums[1] con nums[2]. El array se convierte en [1,6,7,18,2,1]
Cambia nums[0] con nums[4]. El array se convierte en [2,6,7,18,1,1]
Cambia nums[0] con nums[5]. El array se convierte en [1,6,7,18,1,2]
No podemos obtener un array lexicográficamente más pequeño aplicando más operaciones.

Ejemplo 3:

Entrada: nums = [1,7,28,19,10], limit = 3
Salida: [1,7,28,19,10]
Explicación: [1,7,28,19,10] es el array lexicográficamente más pequeño que podemos obtener porque no se puede aplicar la operación en ningún par de índices.

Restricciones:

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

Se le proporciona una matriz indexada en 0 de números enteros positivos nums y un número entero positivo limit.
En una operación, puede elegir dos índices i y j e intercambiar nums[i] y nums[j] si |nums[i] - nums[j]| <= limit.
Devuelve la matriz lexicográficamente más pequeña que se puede obtener al realizar la operación cualquier número de veces.
Una matriz a es lexicográficamente más pequeña que una matriz b si en la primera posición donde a y b difieren, la matriz a tiene un elemento que es menor que el elemento correspondiente en b. Por ejemplo, la matriz [2,10,3] es lexicográficamente más pequeña que la matriz [10,2,3] porque difieren en el índice 0 y 2 < 10.

Ejemplo 1:

Entrada: nums = [1,5,3,9,8], limit = 2
Salida: [1,3,5,8,9]
Explicación: Aplicar la operación 2 veces:
- Intercambiar nums[1] con nums[2]. La matriz se convierte en [1,3,5,9,8]
- Intercambiar nums[3] con nums[4]. La matriz se convierte en [1,3,5,8,9]
No podemos obtener una matriz lexicográficamente más pequeña aplicando más operaciones.
Tenga en cuenta que es posible obtener el mismo resultado realizando diferentes operaciones.

Ejemplo 2:

Entrada: nums = [1,7,6,18,2,1], limit = 3
Salida: [1,6,7,18,1,2]
Explicación: Aplicar la operación 3 veces:
- Intercambiar nums[1] con nums[2]. La matriz se convierte en [1,6,7,18,2,1]
- Intercambiar nums[0] con nums[4]. La matriz se convierte en [2,6,7,18,1,1]
- Intercambiar nums[0] con nums[5]. La matriz se convierte en [1,6,7,18,1,2]
No podemos obtener una matriz lexicográficamente más pequeña aplicando más operaciones.

Ejemplo 3:

Entrada: nums = [1,7,28,19,10], limit = 3
Salida: [1,7,28,19,10]
Explicación: [1,7,28,19,10] es la matriz lexicográficamente más pequeña que podemos obtener porque no podemos aplicar la operación a ninguno de los dos índices.

Restricciones:

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


Se te da un array de enteros batteryPercentages indexado desde 0 con longitud n, que representa los porcentajes de batería de n dispositivos indexados desde 0.

Tu tarea es probar cada dispositivo i en orden de 0 a n - 1, realizando las siguientes operaciones de prueba:

Si batteryPercentages[i] es mayor que 0:

Incrementa el conteo de dispositivos probados.
Disminuye el porcentaje de batería de todos los dispositivos con índices j en el rango [i + 1, n - 1] en 1, asegurándote de que su porcentaje de batería nunca sea inferior a 0, es decir, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Pasa al siguiente dispositivo.

De lo contrario, pasa al siguiente dispositivo sin realizar ninguna prueba.

Devuelve un entero que denote el número de dispositivos que serán probados después de realizar las operaciones de prueba en orden.

Ejemplo 1:

Entrada: batteryPercentages = [1,1,2,1,3]
Salida: 3
Explicación: Realizando las operaciones de prueba en orden comenzando desde el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages se convierte en [1,0,1,0,2].
En el dispositivo 1, batteryPercentages[1] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages se convierte en [1,0,1,0,1].
En el dispositivo 3, batteryPercentages[3] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 4, batteryPercentages[4] > 0, por lo que ahora hay 3 dispositivos probados, y batteryPercentages se mantiene igual.
Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: batteryPercentages = [0,1,2]
Salida: 2
Explicación: Realizando las operaciones de prueba en orden comenzando desde el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 1, batteryPercentages[1] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages se convierte en [0,1,1].
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages se mantiene igual.
Por lo tanto, la respuesta es 2.

Restricciones:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Se te da un arreglo de enteros batteryPercentages indexado desde 0 con longitud n, que representa los porcentajes de batería de n dispositivos indexados desde 0.
Tu tarea es probar cada dispositivo i en orden de 0 a n - 1, realizando las siguientes operaciones de prueba:

Si batteryPercentages[i] es mayor que 0:

Incrementa el conteo de dispositivos probados.
Disminuye el porcentaje de batería de todos los dispositivos con índices j en el rango [i + 1, n - 1] en 1, asegurándote de que su porcentaje de batería nunca sea inferior a 0, es decir, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Pasa al siguiente dispositivo.

De lo contrario, pasa al siguiente dispositivo sin realizar ninguna prueba.

Devuelve un entero que denote el número de dispositivos que serán probados después de realizar las operaciones de prueba en orden.

Ejemplo 1:

Entrada: batteryPercentages = [1,1,2,1,3]
Salida: 3
Explicación: Realizando las operaciones de prueba en orden comenzando desde el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages se convierte en [1,0,1,0,2].
En el dispositivo 1, batteryPercentages[1] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages se convierte en [1,0,1,0,1].
En el dispositivo 3, batteryPercentages[3] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 4, batteryPercentages[4] > 0, por lo que ahora hay 3 dispositivos probados, y batteryPercentages se mantiene igual.
Por lo tanto, la respuesta es 3.

Ejemplo 2:

Entrada: batteryPercentages = [0,1,2]
Salida: 2
Explicación: Realizando las operaciones de prueba en orden comenzando desde el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 1, batteryPercentages[1] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages se convierte en [0,1,1].
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages se mantiene igual.
Por lo tanto, la respuesta es 2.

Restricciones:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Se le da una matriz de enteros con índice 0 batteryPercentages de longitud n, que denota los porcentajes de batería de n dispositivos con índice 0. Su tarea consiste en probar cada dispositivo i en orden de 0 a n - 1 realizando las siguientes operaciones de prueba
Su tarea consiste en probar cada dispositivo i en orden de 0 a n - 1, realizando las siguientes operaciones de prueba:

Si batteryPercentages[i] es mayor que 0:

Incrementa el recuento de dispositivos probados.
Disminuye el porcentaje de batería de todos los dispositivos con índices j en el intervalo [i + 1, n - 1] en 1, asegurándote de que su porcentaje de batería nunca sea inferior a 0, es decir, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Pasa al siguiente dispositivo.

En caso contrario, pasa al siguiente dispositivo sin realizar ninguna prueba.

Devuelve un número entero que denota el número de dispositivos que se probarán después de realizar las operaciones de prueba en orden.

Ejemplo 1:

Entrada: batteryPercentages = [1,1,2,1,3]
Salida: 3
Explicación: Realizando las operaciones de prueba en orden empezando por el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages se convierte en [1,0,1,0,2].
En el dispositivo 1, batteryPercentages[1] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages pasa a ser [1,0,1,0,1].
En el dispositivo 3, batteryPercentages[3] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 4, batteryPercentages[4] > 0, por lo que ahora hay 3 dispositivos probados, y batteryPercentages permanece igual.
Por tanto, la respuesta es 3.

Ejemplo 2:

Entrada: batteryPercentages = [0,1,2]
Salida: 2
Explicación: Realización de las operaciones de prueba en orden empezando por el dispositivo 0:
En el dispositivo 0, batteryPercentages[0] == 0, por lo que pasamos al siguiente dispositivo sin probar.
En el dispositivo 1, batteryPercentages[1] > 0, por lo que ahora hay 1 dispositivo probado, y batteryPercentages pasa a ser [0,1,1].
En el dispositivo 2, batteryPercentages[2] > 0, por lo que ahora hay 2 dispositivos probados, y batteryPercentages permanece igual.
Por tanto, la respuesta es 2.

Restricciones:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100


Se te da un arreglo indexado desde 0 llamado mountain. Tu tarea es encontrar todos los picos en el arreglo mountain.
Devuelve un arreglo que consiste en los índices de los picos en el arreglo dado en cualquier orden.
Notas:

Un pico se define como un elemento que es estrictamente mayor que sus elementos vecinos.
Los primeros y últimos elementos del arreglo no son un pico.

Ejemplo 1:

Entrada: mountain = [2,4,4]
Salida: []
Explicación: mountain[0] y mountain[2] no pueden ser un pico porque son los primeros y últimos elementos del arreglo.
mountain[1] tampoco puede ser un pico porque no es estrictamente mayor que mountain[2].
Así que la respuesta es [].

Ejemplo 2:

Entrada: mountain = [1,4,3,8,5]
Salida: [1,3]
Explicación: mountain[0] y mountain[4] no pueden ser un pico porque son los primeros y últimos elementos del arreglo.
mountain[2] tampoco puede ser un pico porque no es estrictamente mayor que mountain[3] y mountain[1].
Pero mountain[1] y mountain[3] son estrictamente mayores que sus elementos vecinos.
Así que la respuesta es [1,3].

Restricciones:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Se le proporciona una matriz de índice 0 llamada montaña. Su tarea es encontrar todos los picos de la matriz de montaña.
Devuelve una matriz que consta de índices de picos en la matriz dada en cualquier orden.
Notas:

Un pico se define como un elemento que es estrictamente mayor que sus elementos vecinos.
El primer y el último elemento de la matriz no son un pico.

Ejemplo 1:

Entrada: mountain = [2,4,4]
Salida: []
Explicación: montaña[0] y montaña[2] no pueden ser un pico porque son el primer y el último elemento de la matriz.
montaña[1] tampoco puede ser un pico porque no es estrictamente mayor que montaña[2].
Por lo tanto, la respuesta es [].

Ejemplo 2:

Entrada: mountain = [1,4,3,8,5]
Salida: [1,3]
Explicación: montaña[0] y montaña[4] no pueden ser un pico porque son el primer y el último elemento de la matriz.
mountain[2] tampoco puede ser un pico porque no es estrictamente mayor que mountain[3] y mountain[1].
Pero mountain[1] y mountain[3] son estrictamente mayores que sus elementos vecinos.
Por lo tanto, la respuesta es [1,3].

Restricciones:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


////
Se le da una cadena palabra y un número entero k.
Una subcadena s de palabra es completa si:

Cada carácter de s aparece exactamente k veces.
La diferencia entre dos caracteres adyacentes es como máximo 2. Es decir, para dos caracteres adyacentes c1 y c2 en s, la diferencia absoluta en sus posiciones en el alfabeto es como máximo 2.

Devuelve el número de subcadenas completas de palabra.
Una subcadena es una secuencia contigua no vacía de caracteres de una cadena.

Ejemplo 1

Entrada: word = "igigee", k = 2
Salida: 3
Explicación: Las subcadenas completas en las que cada carácter aparece exactamente dos veces y la diferencia entre caracteres adyacentes es como máximo 2 son: igigee, igigee, igigee.

Ejemplo 2:

Entrada: word = "aaabbbccc", k = 3
Salida: 6
Explicación: Las subcadenas completas en las que cada carácter aparece exactamente tres veces y la diferencia entre caracteres adyacentes es como máximo 2 son: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Restricciones:

1 <= word.length <= 10^5
palabra sólo consta de letras minúsculas inglesas.
1 <= k <= word.length

Se te da una cadena llamada word y un entero k.
Una subcadena de word es completa si:

Cada carácter en s aparece exactamente k veces.
La diferencia entre dos caracteres adyacentes es como máximo 2. Es decir, para cualquier par de caracteres adyacentes c1 y c2 en s, la diferencia absoluta en sus posiciones en el alfabeto es como máximo 2.

Devuelve el número de subcadenas completas de word.
Una subcadena es una secuencia contigua de caracteres en una cadena que no está vacía.

Ejemplo 1:

Entrada: word = "igigee", k = 2
Salida: 3
Explicación: Las subcadenas completas donde cada carácter aparece exactamente dos veces y la diferencia entre caracteres adyacentes es como máximo 2 son: igigee, igigee, igigee.

Ejemplo 2:

Entrada: word = "aaabbbccc", k = 3
Salida: 6
Explicación: Las subcadenas completas donde cada carácter aparece exactamente tres veces y la diferencia entre caracteres adyacentes es como máximo 2 son: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Restricciones:

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


Se te da un entero n y un array de enteros sick indexado desde 0, que está ordenado en orden creciente.
Hay n niños parados en una fila con posiciones de 0 a n - 1 asignadas a ellos. El array sick contiene las posiciones de los niños que están infectados con una enfermedad contagiosa. Un niño infectado en la posición i puede propagar la enfermedad a cualquiera de sus vecinos inmediatos en las posiciones i - 1 e i + 1 si existen y actualmente no están infectados. A lo sumo, un niño que no estaba previamente infectado puede infectarse con la enfermedad en un segundo.
Se puede demostrar que después de un número finito de segundos, todos los niños en la fila se infectarán con la enfermedad. Una secuencia de infección es el orden secuencial de posiciones en el que todos los niños no infectados se infectan con la enfermedad. Devuelve el número total de posibles secuencias de infección.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Ten en cuenta que una secuencia de infección no contiene posiciones de niños que ya estaban infectados con la enfermedad al principio.

Ejemplo 1:

Entrada: n = 5, sick = [0,4]
Salida: 4
Explicación: Los niños en las posiciones 1, 2 y 3 no están infectados al principio. Hay 4 posibles secuencias de infección:
- Los niños en las posiciones 1 y 3 pueden infectarse ya que sus posiciones son adyacentes a los niños infectados 0 y 4. El niño en la posición 1 se infecta primero.
Ahora, el niño en la posición 2 está adyacente al niño en la posición 1 quien está infectado y el niño en la posición 3 está adyacente al niño en la posición 4 quien está infectado, por lo tanto, cualquiera de ellos puede infectarse. El niño en la posición 2 se infecta.
Finalmente, el niño en la posición 3 se infecta porque está adyacente a los niños en las posiciones 2 y 4 quienes están infectados. La secuencia de infección es [1,2,3].
- Los niños en las posiciones 1 y 3 pueden infectarse porque sus posiciones son adyacentes a los niños infectados 0 y 4. El niño en la posición 1 se infecta primero.
Ahora, el niño en la posición 2 está adyacente al niño en la posición 1 quien está infectado y el niño en la posición 3 está adyacente al niño en la posición 4 quien está infectado, por lo tanto, cualquiera de ellos puede infectarse. El niño en la posición 3 se infecta.
Finalmente, el niño en la posición 2 se infecta porque está adyacente a los niños en las posiciones 1 y 3 quienes están infectados. La secuencia de infección es [1,3,2].
- La secuencia de infección es [3,1,2]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- La secuencia de infección es [3,2,1]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Ejemplo 2:

Entrada: n = 4, sick = [1]
Salida: 3
Explicación: Los niños en las posiciones 0, 2 y 3 no están infectados al principio. Hay 3 posibles secuencias de infección:
- La secuencia de infección es [0,2,3]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,0,3]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,3,0]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Restricciones:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick está ordenado en orden creciente.

Se le da un entero n y una matriz de enteros con índice 0 sick que está ordenada en orden creciente.
Hay n niños en una cola con las posiciones 0 a n - 1 asignadas. La matriz enfermos contiene las posiciones de los niños infectados por una enfermedad infecciosa. Un niño infectado en la posición i puede contagiar la enfermedad a cualquiera de sus niños vecinos inmediatos en las posiciones i - 1 e i + 1 si existen y no están infectados en ese momento. Como máximo, un niño que antes no estaba infectado puede contagiarse la enfermedad en un segundo.
Se puede demostrar que después de un número finito de segundos, todos los niños de la cola se infectarán con la enfermedad. Una secuencia de infección es el orden secuencial de posiciones en el que todos los niños no infectados se infectan con la enfermedad. Devuelve el número total de secuencias de infección posibles.
Dado que la respuesta puede ser grande, devuélvala en módulo 10^9 + 7.
Tenga en cuenta que una secuencia de infección no contiene posiciones de niños que ya estaban infectados por la enfermedad al principio.

Ejemplo 1:

Entrada: n = 5, sick = [0,4]
Salida: 4
Explicación: Los niños de las posiciones 1, 2 y 3 no están infectados al principio. Hay 4 posibles secuencias de infección:
- Los niños en las posiciones 1 y 3 pueden infectarse ya que sus posiciones son adyacentes a los niños infectados 0 y 4. El niño de la posición 1 se infecta primero.
Ahora, el niño en la posición 2 es adyacente al niño en la posición 1 que está infectado y el niño en la posición 3 es adyacente al niño en la posición 4 que está infectado, por lo tanto cualquiera de ellos puede infectarse. El niño de la posición 2 se infecta.
Por último, el niño de la posición 3 se infecta porque es adyacente a los niños de las posiciones 2 y 4 que están infectados. La secuencia de infección es [1,2,3].
- Los niños de las posiciones 1 y 3 pueden infectarse porque sus posiciones son adyacentes a las de los niños 0 y 4 infectados. El niño de la posición 1 se infecta primero.
Ahora, el niño en la posición 2 es adyacente al niño en la posición 1 que está infectado y el niño en la posición 3 es adyacente al niño en la posición 4 que está infectado, por lo tanto cualquiera de ellos puede infectarse. El niño de la posición 3 se infecta.
Por último, el niño de la posición 2 se infecta porque es adyacente a los niños de las posiciones 1 y 3 que están infectados. La secuencia de infección es [1,3,2].
- La secuencia de infección es [3,1,2]. El orden de infección de la enfermedad en los niños puede verse como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- La secuencia de infección es [3,2,1]. El orden de infección de la enfermedad en los niños puede verse como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Ejemplo 2:

Entrada: n = 4, sick = [1]
Salida: 3
Explicación: Los niños en las posiciones 0, 2 y 3 no están infectados al principio. Hay 3 posibles secuencias de infección:
- La secuencia de infección es [0,2,3]. El orden de infección de la enfermedad en los niños puede verse como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,0,3]. El orden de infección de la enfermedad en los niños puede verse como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,3,0]. El orden de infección de la enfermedad en los niños puede verse como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Restricciones:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick se ordena en orden creciente.

Se te da un entero n y una cadena de enteros sick indexado desde 0, que está ordenado en orden creciente.
Hay n niños parados en una fila con posiciones de 0 a n - 1 asignadas a ellos. La cadena sick contiene las posiciones de los niños que están infectados con una enfermedad contagiosa. Un niño infectado en la posición i puede propagar la enfermedad a cualquiera de sus vecinos inmediatos en las posiciones i - 1 e i + 1 si existen y actualmente no están infectados. A lo sumo, un niño que no estaba previamente infectado puede infectarse con la enfermedad en un segundo.
Se puede demostrar que después de un número finito de segundos, todos los niños en la fila se infectarán con la enfermedad. Una secuencia de infección es el orden secuencial de posiciones en el que todos los niños no infectados se infectan con la enfermedad. Devuelve el número total de posibles secuencias de infección.
Dado que la respuesta puede ser grande, devuélvela módulo 10^9 + 7.
Ten en cuenta que una secuencia de infección no contiene posiciones de niños que ya estaban infectados con la enfermedad al principio.

Ejemplo 1:

Input: n = 5, sick = [0,4]
Output: 4
Explicación: Los niños en las posiciones 1, 2 y 3 no están infectados al principio. Hay 4 posibles secuencias de infección:
- Los niños en las posiciones 1 y 3 pueden infectarse ya que sus posiciones son adyacentes a los niños infectados 0 y 4. El niño en la posición 1 se infecta primero.
Ahora, el niño en la posición 2 está adyacente al niño en la posición 1 quien está infectado y el niño en la posición 3 está adyacente al niño en la posición 4 quien está infectado, por lo tanto, cualquiera de ellos puede infectarse. El niño en la posición 2 se infecta.
Finalmente, el niño en la posición 3 se infecta porque está adyacente a los niños en las posiciones 2 y 4 quienes están infectados. La secuencia de infección es [1,2,3].
- Los niños en las posiciones 1 y 3 pueden infectarse porque sus posiciones son adyacentes a los niños infectados 0 y 4. El niño en la posición 1 se infecta primero.
Ahora, el niño en la posición 2 está adyacente al niño en la posición 1 quien está infectado y el niño en la posición 3 está adyacente al niño en la posición 4 quien está infectado, por lo tanto, cualquiera de ellos puede infectarse. El niño en la posición 3 se infecta.
Finalmente, el niño en la posición 2 se infecta porque está adyacente a los niños en las posiciones 1 y 3 quienes están infectados. La secuencia de infección es [1,3,2].
- La secuencia de infección es [3,1,2]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- La secuencia de infección es [3,2,1]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Ejemplo 2:

Input: n = 4, sick = [1]
Output: 3
Explicación: Los niños en las posiciones 0, 2 y 3 no están infectados al principio. Hay 3 posibles secuencias de infección:
- La secuencia de infección es [0,2,3]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,0,3]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La secuencia de infección es [2,3,0]. El orden de infección de la enfermedad en los niños se puede ver como: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Restricciones:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick está ordenado en orden creciente.


Se te da un array de enteros `nums` y un entero `k`. La frecuencia de un elemento `x` es el número de veces que aparece en un array. Un array se llama bueno si la frecuencia de cada elemento en este array es menor o igual a `k`. Devuelve la longitud del subarray bueno más largo de `nums`. Un subarray es una secuencia continua y no vacía de elementos dentro de un array.

Ejemplo 1:

Entrada: nums = [1,2,3,1,2,3,1,2], k = 2
Salida: 6
Explicación: El subarray bueno más largo posible es `[1,2,3,1,2,3]` ya que los valores 1, 2 y 3 aparecen como máximo dos veces en este subarray. Ten en cuenta que los subarrays `[2,3,1,2,3,1]` y `[3,1,2,3,1,2]` también son buenos. Se puede demostrar que no hay subarrays buenos con una longitud mayor de 6.

Ejemplo 2:

Entrada: nums = [1,2,1,2,1,2,1,2], k = 1
Salida: 2
Explicación: El subarray bueno más largo posible es `[1,2]` ya que los valores 1 y 2 aparecen como máximo una vez en este subarray. Ten en cuenta que el subarray `[2,1]` también es bueno. Se puede demostrar que no hay subarrays buenos con una longitud mayor de 2.

Ejemplo 3:

Entrada: nums = [5,5,5,5,5,5,5], k = 4
Salida: 4
Explicación: El subarray bueno más largo posible es `[5,5,5,5]` ya que el valor 5 aparece 4 veces en este subarray. Se puede demostrar que no hay subarrays buenos con una longitud mayor de 4.

Restricciones:

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

Se le proporciona una matriz de números enteros nums y un número entero k.
La frecuencia de un elemento x es la cantidad de veces que aparece en una matriz.
Una matriz se denomina buena si la frecuencia de cada elemento de esta matriz es menor o igual a k.
Devuelve la longitud de la submatriz buena más larga de nums.
Una submatriz es una secuencia contigua no vacía de elementos dentro de una matriz.

Ejemplo 1:

Entrada: nums = [1,2,3,1,2,3,1,2], k = 2
Salida: 6
Explicación: La submatriz buena más larga posible es [1,2,3,1,2,3] ya que los valores 1, 2 y 3 aparecen como máximo dos veces en esta submatriz. Tenga en cuenta que las submatrices [2,3,1,2,3,1] y [3,1,2,3,1,2] también son buenas.
Se puede demostrar que no existen submatrices buenas con una longitud mayor que 6.

Ejemplo 2:

Entrada: nums = [1,2,1,2,1,2,1,2], k = 1
Salida: 2
Explicación: La submatriz buena más larga posible es [1,2] ya que los valores 1 y 2 aparecen como máximo una vez en esta submatriz. Nótese que la submatriz [2,1] también es buena.
Se puede demostrar que no existen submatrices buenas con una longitud mayor que 2.

Ejemplo 3:

Entrada: nums = [5,5,5,5,5,5,5], k = 4
Salida: 4
Explicación: La submatriz buena más larga posible es [5,5,5,5] ya que el valor 5 aparece 4 veces en esta submatriz.
Se puede demostrar que no existen submatrices buenas con una longitud mayor que 4.

Restricciones:

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


Tienes un array de enteros nums indexado desde 0 y de longitud par, y también un array vacío arr. Alice y Bob decidieron jugar un juego en el que en cada ronda, Alice y Bob harán un movimiento. Las reglas del juego son las siguientes:

En cada ronda, primero Alice eliminará el elemento mínimo de nums, y luego Bob hará lo mismo.
Ahora, primero Bob añadirá el elemento eliminado en el array arr, y luego Alice hará lo mismo.
El juego continúa hasta que nums esté vacío.

Devuelve el array resultante arr.

Ejemplo 1:

Entrada: nums = [5,4,2,3]
Salida: [3,2,5,4]
Explicación: En la primera ronda, primero Alice elimina 2 y luego Bob elimina 3. Luego en arr, primero Bob añade 3 y luego Alice añade 2. Así que arr = [3,2].
Al inicio de la segunda ronda, nums = [5,4]. Ahora, primero Alice elimina 4 y luego Bob elimina 5. Ambos añaden en arr que se convierte en [3,2,5,4].

Ejemplo 2:

Entrada: nums = [2,5]
Salida: [5,2]
Explicación: En la primera ronda, primero Alice elimina 2 y luego Bob elimina 5. Luego en arr, primero Bob añade y luego Alice añade. Así que arr = [5,2].

Condiciones:

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

Se le proporciona una matriz de enteros indexada en 0 nums de longitud par y también hay una matriz vacía arr. Alice y Bob decidieron jugar un juego en el que en cada ronda Alice y Bob harán un movimiento. Las reglas del juego son las siguientes:

En cada ronda, primero Alice eliminará el elemento mínimo de nums y luego Bob hará lo mismo.
Ahora, primero Bob agregará el elemento eliminado en la matriz arr y luego Alice hará lo mismo.
El juego continúa hasta que nums se vacíe.

Devuelve la matriz resultante arr.

Ejemplo 1:

Entrada: nums = [5,4,2,3]
Salida: [3,2,5,4]
Explicación: En la primera ronda, primero Alice elimina 2 y luego Bob elimina 3. Luego, en arr, primero Bob agrega 3 y luego Alice agrega 2. Entonces arr = [3,2].
Al comienzo de la segunda ronda, nums = [5,4]. Ahora, primero Alice elimina 4 y luego Bob elimina 5. Luego, ambos agregan en arr, que se convierte en [3,2,5,4].

Ejemplo 2:

Entrada: nums = [2,5]
Salida: [5,2]
Explicación: En la primera ronda, primero Alice elimina 2 y luego Bob elimina 5. Luego, en arr, primero Bob agrega y luego Alice. Por lo tanto, arr = [5,2].

Restricciones:

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


Se te da una matriz entera bidimensional indexada desde 0, `grid`, de tamaño `n * n` con valores en el rango [1, n^2]. Cada entero aparece exactamente una vez, excepto `a` que aparece dos veces y `b` que falta. La tarea es encontrar los números repetido y faltante `a` y `b`.
Devuelve una matriz entera indexada desde 0, `ans`, de tamaño 2 donde `ans[0]` es igual a `a` y `ans[1]` es igual a `b`.

Ejemplo 1:

Entrada: grid = [[1,3],[2,2]]
Salida: [2,4]
Explicación: El número 2 está repetido y el número 4 falta, así que la respuesta es [2,4].

Ejemplo 2:

Entrada: grid = [[9,1,7],[8,9,2],[3,4,6]]
Salida: [9,5]
Explicación: El número 9 está repetido y el número 5 falta, así que la respuesta es [9,5].

Restricciones:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Para todo `x` tal que 1 <= x <= n * n, hay exactamente un `x` que no es igual a ninguno de los miembros de `grid`.
Para todo `x` tal que 1 <= x <= n * n, hay exactamente un `x` que es igual a exactamente dos de los miembros de `grid`.
Para todo `x` tal que 1 <= x <= n * n excepto dos de ellos, hay exactamente un par de `i, j` donde 0 <= i, j <= n - 1 y grid[i][j] == x.

Se le proporciona una matriz de enteros 2D indexada en 0 de tamaño n * n con valores en el rango [1, n^2]. Cada entero aparece exactamente una vez excepto a que aparece dos veces y b que falta. La tarea es encontrar los números repetidos y faltantes a y b.
Devuelve una matriz de enteros indexada en 0 ans de tamaño 2 donde ans[0] es igual a a y ans[1] es igual a b.

Ejemplo 1:

Entrada: grid = [[1,3],[2,2]]
Salida: [2,4]
Explicación: El número 2 se repite y el número 4 falta, por lo que la respuesta es [2,4].

Ejemplo 2:

Entrada: grid = [[9,1,7],[8,9,2],[3,4,6]]
Salida: [9,5]
Explicación: El número 9 se repite y el número 5 falta, por lo que la respuesta es [9,5].

Restricciones:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Para todo x que 1 <= x <= n * n hay exactamente un x que no es igual a ninguno de los miembros de la cuadrícula.
Para todo x que 1 <= x <= n * n hay exactamente un x que es igual a exactamente dos de los miembros de la cuadrícula.
Para todo x que 1 <= x <= n * n excepto dos de ellos hay exactamente un par de i, j que 0 <= i, j <= n - 1 y grid[i][j] == x.

Se te da una matriz entera bidimensional indexada desde 0, grid, de tamaño n * n con valores en el rango [1, n^2]. Cada entero aparece exactamente una vez, excepto a que aparece dos veces y b que falta. La tarea es encontrar los números repetido y faltante a y b.
Devuelve una matriz entera indexada desde 0, ans, de tamaño 2 donde ans[0] es igual a a y ans[1] es igual a b.

Ejemplo 1:

Entrada: grid = [[1,3],[2,2]]
Salida: [2,4]
Explicación: El número 2 está repetido y el número 4 falta, así que la respuesta es [2,4].

Ejemplo 2:

Entrada: grid = [[9,1,7],[8,9,2],[3,4,6]]
Salida: [9,5]
Explicación: El número 9 está repetido y el número 5 falta, así que la respuesta es [9,5].

Restricciones:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Para todo x tal que 1 <= x <= n * n, hay exactamente un x que no es igual a ninguno de los miembros de grid.
Para todo x tal que 1 <= x <= n * n, hay exactamente un x que es igual a exactamente dos de los miembros de grid.
Para todo x tal que 1 <= x <= n * n excepto dos de ellos, hay exactamente un par de i, j donde 0 <= i, j <= n - 1 y grid[i][j] == x.


Se te dan dos arreglos de enteros indexados desde 0, nums1 y nums2, de longitud par n.
Debes eliminar n / 2 elementos de nums1 y n / 2 elementos de nums2. Después de las eliminaciones, insertas los elementos restantes de nums1 y nums2 en un conjunto s.
Devuelve el tamaño máximo posible del conjunto s.

Ejemplo 1:

Entrada: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Salida: 2
Explicación: Eliminamos dos ocurrencias de 1 de nums1 y nums2. Después de las eliminaciones, los arreglos se vuelven nums1 = [2,2] y nums2 = [1,1]. Por lo tanto, s = {1,2}.
Se puede demostrar que 2 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Ejemplo 2:

Entrada: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Salida: 5
Explicación: Eliminamos 2, 3 y 6 de nums1, así como 2 y dos ocurrencias de 3 de nums2. Después de las eliminaciones, los arreglos se vuelven nums1 = [1,4,5] y nums2 = [2,3,2]. Por lo tanto, s = {1,2,3,4,5}.
Se puede demostrar que 5 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Ejemplo 3:

Entrada: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Salida: 6
Explicación: Eliminamos 1, 2 y 3 de nums1, así como 4, 5 y 6 de nums2. Después de las eliminaciones, los arreglos se vuelven nums1 = [1,2,3] y nums2 = [4,5,6]. Por lo tanto, s = {1,2,3,4,5,6}.
Se puede demostrar que 6 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Condiciones:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n es par.
1 <= nums1[i], nums2[i] <= 10^9

Se le proporcionan dos matrices de números enteros indexados en 0, nums1 y nums2, de longitud par n.
Debe eliminar n/2 elementos de nums1 y n/2 elementos de nums2. Después de las eliminaciones, inserte los elementos restantes de nums1 y nums2 en un conjunto s.
Devuelva el tamaño máximo posible del conjunto s.

Ejemplo 1:

Entrada: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Salida: 2
Explicación: Eliminamos dos ocurrencias de 1 de nums1 y nums2. Después de las eliminaciones, las matrices se vuelven iguales a nums1 = [2,2] y nums2 = [1,1]. Por lo tanto, s = {1,2}.
Se puede demostrar que 2 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Ejemplo 2:

Entrada: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Salida: 5
Explicación: Eliminamos 2, 3 y 6 de nums1, así como 2 y dos ocurrencias de 3 de nums2. Después de las eliminaciones, las matrices se vuelven iguales a nums1 = [1,4,5] y nums2 = [2,3,2]. Por lo tanto, s = {1,2,3,4,5}.
Se puede demostrar que 5 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Ejemplo 3:

Entrada: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Salida: 6
Explicación: Eliminamos 1, 2 y 3 de nums1, así como 4, 5 y 6 de nums2. Después de las eliminaciones, las matrices se vuelven iguales a nums1 = [1,2,3] y nums2 = [4,5,6]. Por lo tanto, s = {1,2,3,4,5,6}.
Se puede demostrar que 6 es el tamaño máximo posible del conjunto s después de las eliminaciones.

Restricciones:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n es par.
1 <= nums1[i], nums2[i] <= 10^9


Se te da un array de enteros nums indexado desde 0 con longitud n. Puedes realizar un movimiento especial cualquier número de veces (incluyendo cero) en nums. En un movimiento especial realizas los siguientes pasos en orden:

Elige un índice i en el rango [0, n - 1], y un entero positivo x.
Suma |nums[i] - x| al costo total.
Cambia el valor de nums[i] a x.

Un número palindrómico es un entero positivo que sigue siendo el mismo cuando sus dígitos se invierten. Por ejemplo, 121, 2552 y 65756 son números palindrómicos, mientras que 24, 46, 235 no lo son. Un array se considera igualindrómico si todos los elementos del array son iguales a un entero y, donde y es un número palindrómico menor que 10^9. Devuelve un entero que denote el costo total mínimo posible para hacer nums igualindrómico realizando cualquier número de movimientos especiales.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 6
Explicación: Podemos hacer que el array sea igualindrómico cambiando todos los elementos a 3, que es un número palindrómico. El costo de cambiar el array a [3,3,3,3,3] usando 4 movimientos especiales se da por |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6. Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico diferente de 3 no se puede lograr con un costo menor.

Ejemplo 2:

Entrada: nums = [10,12,13,14,15]
Salida: 11
Explicación: Podemos hacer que el array sea igualindrómico cambiando todos los elementos a 11, que es un número palindrómico. El costo de cambiar el array a [11,11,11,11,11] usando 5 movimientos especiales se da por |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11. Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico diferente de 11 no se puede lograr con un costo menor.

Ejemplo 3:

Entrada: nums = [22,33,22,33,22]
Salida: 22
Explicación: Podemos hacer que el array sea igualindrómico cambiando todos los elementos a 22, que es un número palindrómico. El costo de cambiar el array a [22,22,22,22,22] usando 2 movimientos especiales se da por |33 - 22| + |33 - 22| = 22. Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico diferente de 22 no se puede lograr con un costo menor.

Restricciones:

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

Se le proporciona una matriz de enteros indexada 0 nums que tiene una longitud n.
Se le permite realizar un movimiento especial cualquier número de veces (incluido cero) en nums. En un movimiento especial, realiza los siguientes pasos en orden:

Elija un índice i en el intervalo [0, n - 1] y un entero positivo x.
Suma |nums[i] - x| al costo total.
Cambie el valor de nums[i] a x.

Un número palindrómico es un número entero positivo que permanece igual cuando se invierten sus dígitos. Por ejemplo, 121, 2552 y 65756 son números palindrómicos, mientras que 24, 46, 235 no son números palindrómicos.
Una matriz se considera igualindrómica si todos los elementos de la matriz son iguales a un número entero y, donde y es un número palindrómico menor que 10^9.
Devuelve un número entero que denota el coste total mínimo posible para hacer que los números sean igualesindrómicos realizando cualquier número de movimientos especiales.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 6
Explicación: Podemos hacer que la matriz sea igualindrómica cambiando todos los elementos a 3, que es un número palindrómico. El costo de cambiar la matriz a [3,3,3,3,3] usando 4 movimientos especiales viene dado por |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico que no sea 3 no se puede lograr a un costo menor.

Ejemplo 2:

Entrada: nums = [10,12,13,14,15]
Salida: 11
Explicación: Podemos hacer que la matriz sea igualindrómica cambiando todos los elementos a 11, que es un número palindrómico. El costo de cambiar la matriz a [11,11,11,11,11] usando 5 movimientos especiales viene dado por |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico que no sea 11 no se puede lograr a un costo menor.

Ejemplo 3:

Entrada: nums = [22,33,22,33,22]
Salida: 22
Explicación: Podemos hacer que la matriz sea igualindrómica cambiando todos los elementos a 22, que es un número palindrómico. El costo de cambiar la matriz a [22,22,22,22,22] usando 2 movimientos especiales viene dado por |33 - 22| + |33 - 22| = 22.
Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico que no sea 22 no se puede lograr a un costo menor.

Restricciones:

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

Se le da una matriz de números enteros con índice 0 y longitud n.
Se le permite realizar un movimiento especial cualquier número de veces (incluyendo cero) en nums. En un movimiento especial se realizan los siguientes pasos en orden:

Elija un índice i en el intervalo [0, n - 1], y un número entero positivo x.
Suma |números[i] - x| al coste total.
Cambie el valor de núm[i] a x.

Un número palindrómico es un número entero positivo que sigue siendo el mismo cuando se invierten sus dígitos. Por ejemplo, 121, 2552 y 65756 son números palindrómicos, mientras que 24, 46, 235 no lo son.
Una matriz se considera igualindrómica si todos los elementos de la matriz son iguales a un número entero y, donde y es un número palindrómico menor que 10^9.
Devuelve un número entero que denota el mínimo coste total posible para hacer que nums sea igualindrómico realizando cualquier número de movimientos especiales.

Ejemplo 1:

Entrada: nums = [1,2,3,4,5]
Salida: 6
Explicación: Podemos hacer el array igualindrómico cambiando todos los elementos a 3 que es un número palindrómico. El coste de cambiar la matriz a [3,3,3,3,3] usando 4 movimientos especiales viene dado por |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Se puede demostrar que cambiar todos los elementos a cualquier número palindrómico distinto de 3 no se puede conseguir con un coste menor.

Ejemplo 2:

Entrada: nums = [10,12,13,14,15]
Salida: 11
Explicación: Podemos hacer el array igualindrómico cambiando todos los elementos a 11 que es un número palindrómico. El coste de cambiar la matriz a [11,11,11,11,11] utilizando 5 movimientos especiales viene dado por |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Se puede demostrar que el cambio de todos los elementos a cualquier número palindrómico que no sea 11 no se puede lograr a un costo menor.

Ejemplo 3:

Entrada: nums = [22,33,22,33,22]
Salida: 22
Explicación: Podemos hacer el array igualindrómico cambiando todos los elementos a 22 que es un número palindrómico. El coste de cambiar la matriz a [22,22,22,22,22] usando 2 movimientos especiales viene dado por |33 - 22| + |33 - 22| = 22.
Se puede demostrar que el cambio de todos los elementos a cualquier número palindrómico distinto de 22 no se puede lograr a un costo menor.

Restricciones:

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


Tienes una cadena word indexada desde 0.
En una operación, puedes elegir cualquier índice i de word y cambiar word[i] a cualquier letra minúscula del alfabeto inglés.
Devuelve el número mínimo de operaciones necesarias para eliminar todos los caracteres casi iguales adyacentes de word.
Dos caracteres a y b son casi iguales si a == b o a y b son adyacentes en el alfabeto.

Ejemplo 1:

Entrada: word = "aaaaa"
Salida: 2
Explicación: Podemos cambiar word a "acaca" que no tiene caracteres casi iguales adyacentes.
Se puede demostrar que el número mínimo de operaciones necesarias para eliminar todos los caracteres casi iguales adyacentes de word es 2.

Ejemplo 2:

Entrada: word = "abddez"
Salida: 2
Explicación: Podemos cambiar word a "ybdoez" que no tiene caracteres casi iguales adyacentes.
Se puede demostrar que el número mínimo de operaciones necesarias para eliminar todos los caracteres casi iguales adyacentes de word es 2.

Ejemplo 3:

Entrada: word = "zyxyxyz"
Salida: 3
Explicación: Podemos cambiar word a "zaxaxaz" que no tiene caracteres casi iguales adyacentes.
Se puede demostrar que el número mínimo de operaciones necesarias para eliminar todos los caracteres casi iguales adyacentes de word es 3.

Restricciones:

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

Se le proporciona una cadena de caracteres indexada en 0, palabra.
En una operación, puede elegir cualquier índice i de palabra y cambiar palabra[i] a cualquier letra minúscula del inglés.
Devuelve la cantidad mínima de operaciones necesarias para eliminar todos los caracteres adyacentes casi iguales de palabra.
Dos caracteres a y b son casi iguales si a == b o a y b son adyacentes en el alfabeto.

Ejemplo 1:

Entrada: word = "aaaaa"
Salida: 2
Explicación: Podemos cambiar palabra por "acaca", que no tiene ningún carácter adyacente casi igual.
Se puede demostrar que la cantidad mínima de operaciones necesarias para eliminar todos los caracteres adyacentes casi iguales de palabra es 2.

Ejemplo 2:

Entrada: word = "abddez"
Salida: 2
Explicación: Podemos cambiar palabra por "ybdoez", que no tiene ningún carácter adyacente casi igual.
Se puede demostrar que la cantidad mínima de operaciones necesarias para eliminar todos los caracteres adyacentes casi iguales de una palabra es 2.
Ejemplo 3:

Entrada: word = "zyxyxyz"
Salida: 3
Explicación: Podemos cambiar palabra por "zaxaxaz" que no tiene ningún carácter adyacente casi igual.
Se puede demostrar que la cantidad mínima de operaciones necesarias para eliminar todos los caracteres adyacentes casi iguales de una palabra es 3.

Restricciones:

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


Se le proporciona una matriz de números enteros indexada en 0, monedas, que representa los valores de las monedas disponibles, y un número entero objetivo.
Se puede obtener un número entero x si existe una subsecuencia de monedas que sume x.
Devuelve la cantidad mínima de monedas de cualquier valor que se deben agregar a la matriz para que se pueda obtener cada número entero en el rango [1, objetivo].
Una subsecuencia de una matriz es una nueva matriz no vacía que se forma a partir de la matriz original eliminando algunos (posiblemente ninguno) de los elementos sin alterar las posiciones relativas de los elementos restantes.

Ejemplo 1:

Entrada: coins = [1,4,10], target = 19
Salida: 2
Explicación: Necesitamos sumar las monedas 2 y 8. La matriz resultante será [1,2,4,8,10].
Se puede demostrar que todos los números enteros del 1 al 19 se pueden obtener de la matriz resultante, y que 2 es el número mínimo de monedas que se deben agregar a la matriz.

Ejemplo 2:

Entrada: coins = [1,4,10,5,7,19], target = 19
Salida: 1
Explicación: Solo necesitamos agregar la moneda 2. La matriz resultante será [1,2,4,5,7,10,19].
Se puede demostrar que todos los números enteros del 1 al 19 se pueden obtener de la matriz resultante, y que 1 es el número mínimo de monedas que se deben agregar a la matriz.

Ejemplo 3:

Entrada: coins = [1,1,1], target = 20
Salida: 3
Explicación: Necesitamos agregar las monedas 4, 8 y 16. La matriz resultante será [1,1,1,4,8,16].
Se puede demostrar que todos los números enteros del 1 al 20 se pueden obtener de la matriz resultante y que 3 es el número mínimo de monedas que se deben agregar a la matriz.

Restricciones:

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

Tienes un array de enteros coins indexado desde cero, que representa los valores de las monedas disponibles, y un entero target.

Un entero x es obtenible si existe una subsecuencia de coins que suma x.

Devuelve el número mínimo de monedas de cualquier valor que necesita añadirse al array para que cada entero en el rango [1, target] sea obtenible. Una subsecuencia de un array es un nuevo array no vacío que se forma a partir del array original eliminando algunos (posiblemente ninguno) de los elementos sin alterar las posiciones relativas de los elementos restantes.

Ejemplo 1:

Entrada: coins = [1,4,10], target = 19
Salida: 2
Explicación: Necesitamos añadir las monedas 2 y 8. El array resultante será [1,2,4,8,10].
Se puede demostrar que todos los enteros del 1 al 19 son obtenibles del array resultante, y que 2 es el número mínimo de monedas que se necesitan añadir al array.

Ejemplo 2:

Entrada: coins = [1,4,10,5,7,19], target = 19
Salida: 1
Explicación: Solo necesitamos añadir la moneda 2. El array resultante será [1,2,4,5,7,10,19].
Se puede demostrar que todos los enteros del 1 al 19 son obtenibles del array resultante, y que 1 es el número mínimo de monedas que se necesitan añadir al array.

Ejemplo 3:

Entrada: coins = [1,1,1], target = 20
Salida: 3
Explicación: Necesitamos añadir las monedas 4, 8 y 16. El array resultante será [1,1,1,4,8,16].
Se puede demostrar que todos los enteros del 1 al 20 son obtenibles del array resultante, y que 3 es el número mínimo de monedas que se necesitan añadir al array.

Condiciones:

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


Tienes una cadena indexada desde 0, s, y un entero k.
Debes realizar las siguientes operaciones de particionado hasta que s esté vacía:

Elige el prefijo más largo de s que contenga como máximo k caracteres distintos.
Elimina el prefijo de s y aumenta el número de particiones en uno. Los caracteres restantes (si los hay) en s mantienen su orden inicial.

Antes de las operaciones, se te permite cambiar como máximo un índice en s a otra letra minúscula del alfabeto inglés.
Devuelve un entero que denota el número máximo de particiones resultantes después de las operaciones al elegir óptimamente como máximo un índice para cambiar.

Ejemplo 1:

Entrada: s = "accca", k = 2
Salida: 3
Explicación: En este ejemplo, para maximizar el número de particiones resultantes, s[2] se puede cambiar a 'b'.
s se convierte en "acbca".
Las operaciones ahora se pueden realizar de la siguiente manera hasta que s quede vacía:
- Elige el prefijo más largo que contiene como máximo 2 caracteres distintos, "acbca".
- Elimina el prefijo, y s se convierte en "bca". El número de particiones ahora es 1.
- Elige el prefijo más largo que contiene como máximo 2 caracteres distintos, "bca".
- Elimina el prefijo, y s se convierte en "a". El número de particiones ahora es 2.
- Elige el prefijo más largo que contiene como máximo 2 caracteres distintos, "a".
- Elimina el prefijo, y s queda vacía. El número de particiones ahora es 3.
Por lo tanto, la respuesta es 3.
Se puede demostrar que no es posible obtener más de 3 particiones.

Ejemplo 2:

Entrada: s = "aabaab", k = 3
Salida: 1
Explicación: En este ejemplo, para maximizar el número de particiones resultantes podemos dejar s como está.
Las operaciones ahora se pueden realizar de la siguiente manera hasta que s quede vacía:
- Elige el prefijo más largo que contiene como máximo 3 caracteres distintos, "aabaab".
- Elimina el prefijo, y s queda vacía. El número de particiones se convierte en 1.
Por lo tanto, la respuesta es 1.
Se puede demostrar que no es posible obtener más de 1 partición.

Ejemplo 3:

Entrada: s = "xxyz", k = 1
Salida: 4
Explicación: En este ejemplo, para maximizar el número de particiones resultantes, s[1] se puede cambiar a 'a'.
s se convierte en "xayz".
Las operaciones ahora se pueden realizar de la siguiente manera hasta que s quede vacía:
- Elige el prefijo más largo que contiene como máximo 1 caracter distinto, "xayz".
- Elimina el prefijo, y s se convierte en "ayz". El número de particiones ahora es 1.
- Elige el prefijo más largo que contiene como máximo 1 caracter distinto, "ayz".
- Elimina el prefijo, y s se convierte en "yz". El número de particiones ahora es 2.
- Elige el prefijo más largo que contiene como máximo 1 caracter distinto, "yz".
- Elimina el prefijo, y s se convierte en "z". El número de particiones ahora es 3.
- Elige el prefijo más largo que contiene como máximo 1 caracter distinto, "z".
- Elimina el prefijo, y s queda vacía. El número de particiones ahora es 4.
Por lo tanto, la respuesta es 4.
Se puede demostrar que no es posible obtener más de 4 particiones.

Restricciones:

1 <= s.length <= 10^4
s consiste solo de letras minúsculas del alfabeto inglés.
1 <= k <= 26

Se le proporciona una cadena indexada en 0 s y un entero k.
Debe realizar las siguientes operaciones de partición hasta que s esté vacío:

Elija el prefijo más largo de s que contenga como máximo k caracteres distintos.
Elimine el prefijo de s y aumente el número de particiones en uno. Los caracteres restantes (si los hay) en s mantienen su orden inicial.

Antes de las operaciones, se le permite cambiar como máximo un índice en s por otra letra minúscula del inglés.
Devuelva un entero que denote el número máximo de particiones resultantes después de las operaciones eligiendo de manera óptima como máximo un índice para cambiar.

Ejemplo 1:

Entrada: s = "accca", k = 2
Salida: 3
Explicación: En este ejemplo, para maximizar el número de particiones resultantes, s[2] se puede cambiar a 'b'.
s se convierte en "acbca".
Las operaciones se pueden realizar ahora de la siguiente manera hasta que s quede vacío:
- Elija el prefijo más largo que contenga como máximo 2 caracteres distintos, "acbca".
- Elimine el prefijo y s se convierte en "bca". El número de particiones ahora es 1.
- Elija el prefijo más largo que contenga como máximo 2 caracteres distintos, "bca".
- Elimine el prefijo y s se convierte en "a". El número de particiones ahora es 2.
- Elija el prefijo más largo que contenga como máximo 2 caracteres distintos, "a".
- Elimine el prefijo y s queda vacío. El número de particiones ahora es 3.
Por lo tanto, la respuesta es 3.
Se puede demostrar que no es posible obtener más de 3 particiones.
Ejemplo 2:

Entrada: s = "aabaab", k = 3
Salida: 1
Explicación: En este ejemplo, para maximizar el número de particiones resultantes podemos dejar s como está.
Ahora las operaciones se pueden realizar de la siguiente manera hasta que s quede vacío:
- Elija el prefijo más largo que contenga como máximo 3 caracteres distintos, "aabaab".
- Elimine el prefijo y s quedará vacío. El número de particiones será 1.
Por lo tanto, la respuesta es 1.
Se puede demostrar que no es posible obtener más de 1 partición.

Ejemplo 3:

Entrada: s = "xxyz", k = 1
Salida: 4
Explicación: En este ejemplo, para maximizar el número de particiones resultantes, s[1] se puede cambiar a 'a'.
s se convierte en "xayz".
Ahora las operaciones se pueden realizar de la siguiente manera hasta que s quede vacío:
- Elija el prefijo más largo que contenga como máximo 1 carácter distinto, "xayz".
- Elimine el prefijo y s se convierte en "ayz". El número de particiones ahora es 1.
- Elija el prefijo más largo que contenga como máximo 1 carácter distinto, "ayz".
- Borre el prefijo y s se convierte en "yz". El número de particiones ahora es 2.
- Elija el prefijo más largo que contenga como máximo 1 carácter distinto, "yz".
- Borre el prefijo y s se convierte en "z". El número de particiones ahora es 3.
- Elija el prefijo más largo que contenga como máximo 1 carácter distinto, "z".
- Borre el prefijo y s queda vacío. El número de particiones ahora es 4.
Por lo tanto, la respuesta es 4.
Se puede demostrar que no es posible obtener más de 4 particiones.

Restricciones:

1 <= s.length <= 10^4
s consta únicamente de letras minúsculas en inglés.
1 <= k <= 26


Se te da un arreglo 2D indexado desde cero llamado variables, donde variables[i] = [a_i, b_i, c_i, m_i], y un entero objetivo.
Un índice i es bueno si se cumple la siguiente fórmula:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == objetivo

Devuelve un arreglo que consista en los índices buenos en cualquier orden.

Ejemplo 1:

Entrada: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], objetivo = 2
Salida: [0,2]
Explicación: Para cada índice i en el arreglo variables:
1) Para el índice 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Para el índice 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Para el índice 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Por lo tanto, devolvemos [0,2] como respuesta.

Ejemplo 2:

Entrada: variables = [[39,3,1000,1000]], objetivo = 17
Salida: []
Explicación: Para cada índice i en el arreglo variables:
1) Para el índice 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Por lo tanto, devolvemos [] como respuesta.

Restricciones:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= objetivo <= 10^3

Se te da un array 2D indexado desde cero llamado variables, donde variables[i] = [a_i, b_i, c_i, m_i], y un entero objetivo.
Un índice i es bueno si se cumple la siguiente fórmula:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == objetivo

Devuelve un array que consista en los índices buenos en cualquier orden.

Ejemplo 1:

Entrada: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], objetivo = 2
Salida: [0,2]
Explicación: Para cada índice i en el array variables:
1) Para el índice 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Para el índice 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Para el índice 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Por lo tanto, devolvemos [0,2] como respuesta.

Ejemplo 2:

Entrada: variables = [[39,3,1000,1000]], objetivo = 17
Salida: []
Explicación: Para cada índice i en el array variables:
1) Para el índice 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Por lo tanto, devolvemos [] como respuesta.

Restricciones:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= objetivo <= 10^3

Se le proporciona una matriz 2D indexada en 0 variables donde variables[i] = [a_i, b_i, c_i, m_i] y un objetivo entero.
Un índice i es bueno si se cumple la siguiente fórmula:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Devuelve una matriz que consta de índices buenos en cualquier orden.

Ejemplo 1:

Entrada: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], objetivo = 2
Salida: [0,2]
Explicación: Para cada índice i en la matriz de variables:
1) Para el índice 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Para el índice 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Para el índice 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Por lo tanto, devolvemos [0,2] como respuesta.

Ejemplo 2:

Entrada: variables = [[39,3,1000,1000]], objetivo = 17
Salida: []
Explicación: Para cada índice i en la matriz de variables:
1) Para el índice 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Por lo tanto, devolvemos [] como respuesta.

Restricciones:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= objetivo <= 10^3


Se te dan dos cadenas indexadas desde 0, source y target, ambas de longitud n y compuestas de letras minúsculas en inglés.
También se te dan dos arreglos de caracteres indexados desde 0, original y changed, y un arreglo de enteros cost, donde cost[i] representa el costo de cambiar el carácter original[i] al carácter changed[i].
Comienzas con la cadena source. En una operación, puedes elegir un carácter x de la cadena y cambiarlo al carácter y con un costo de z si existe algún índice j tal que cost[j] == z, original[j] == x, y changed[j] == y.
Devuelve el costo mínimo para convertir la cadena source en la cadena target usando cualquier número de operaciones. Si es imposible convertir source en target, devuelve -1.
Ten en cuenta que pueden existir índices i, j tales que original[j] == original[i] y changed[j] == changed[i].

Ejemplo 1:

Entrada: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Salida: 28
Explicación: Para convertir la cadena "abcd" en la cadena "acbe":
- Cambia el valor en el índice 1 de 'b' a 'c' con un costo de 5.
- Cambia el valor en el índice 2 de 'c' a 'e' con un costo de 1.
- Cambia el valor en el índice 2 de 'e' a 'b' con un costo de 2.
- Cambia el valor en el índice 3 de 'd' a 'e' con un costo de 20.
El costo total incurrido es 5 + 1 + 2 + 20 = 28.
Se puede demostrar que este es el costo mínimo posible.

Ejemplo 2:

Entrada: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Salida: 12
Explicación: Para cambiar el carácter 'a' a 'b', cambia el carácter 'a' a 'c' con un costo de 1, seguido de cambiar el carácter 'c' a 'b' con un costo de 2, para un costo total de 1 + 2 = 3. Para cambiar todas las ocurrencias de 'a' a 'b', se incurre un costo total de 3 * 4 = 12.

Ejemplo 3:

Entrada: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Salida: -1
Explicación: Es imposible convertir source en target porque el valor en el índice 3 no se puede cambiar de 'd' a 'e'.

Condiciones:

1 <= source.length == target.length <= 10^5
source, target consisten en letras minúsculas en inglés.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] son letras minúsculas en inglés.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Se le proporcionan dos cadenas indexadas en 0, source y target, ambas de longitud n y compuestas de letras minúsculas en inglés. También se le proporcionan dos matrices de caracteres indexadas en 0, original y changed, y una matriz de enteros cost, donde cost[i] representa el costo de cambiar el carácter original[i] al carácter changed[i].
Empiece con la cadena source. En una operación, puede elegir un carácter x de la cadena y cambiarlo al carácter y a un costo de z si existe algún índice j tal que cost[j] == z, original[j] == x y changed[j] == y.
Devuelva el costo mínimo para convertir la cadena source en la cadena target utilizando cualquier número de operaciones. Si es imposible convertir source en target, devuelva -1.
Tenga en cuenta que pueden existir índices i, j tales que original[j] == original[i] y changed[j] == changed[i].

Ejemplo 1:

Entrada: origen = "abcd", destino = "acbe", original = ["a", "b", "c", "c", "e", "d"], modificado = ["b", "c", "b", "e", "b", "e"], coste = [2,5,5,1,2,20]
Salida: 28
Explicación: Para convertir la cadena "abcd" en la cadena "acbe":
- Cambiar el valor en el índice 1 de 'b' a 'c' con un coste de 5.
- Cambiar el valor en el índice 2 de 'c' a 'e' con un coste de 1.
- Cambiar el valor en el índice 2 de 'e' a 'b' con un coste de 2.
- Cambiar el valor en el índice 3 de 'd' a 'e' con un coste de 20.
El coste total incurrido es 5 + 1 + 2 + 20 = 28.
Se puede demostrar que este es el coste mínimo posible.

Ejemplo 2:

Entrada: origen = "aaaa", destino = "bbbb", original = ["a", "c"], modificado = ["c", "b"], costo = [1,2]
Salida: 12
Explicación: Para cambiar el carácter "a" a "b", cambie el carácter "a" a "c" con un costo de 1, seguido por el cambio del carácter "c" a "b" con un costo de 2, para un costo total de 1 + 2 = 3. Para cambiar todas las ocurrencias de "a" a "b", se incurre en un costo total de 3 * 4 = 12.

Ejemplo 3:

Entrada: origen = "abcd", destino = "abce", original = ["a"], modificado = ["e"], costo = [10000]
Salida: -1
Explicación: Es imposible convertir el origen al destino porque el valor en el índice 3 no se puede cambiar de "d" a "e".

Restricciones:

1 <= source.length == target.length <= 10^5
source, target consisten en letras minúsculas en inglés.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] son letras minúsculas en inglés.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Se le proporcionan dos cadenas indexadas en 0, source y target, ambas de longitud n y compuestas de letras minúsculas en inglés. También se le proporcionan dos matrices de caracteres indexadas en 0, original y changed, y una matriz de enteros cost, donde cost[i] representa el costo de cambiar el carácter original[i] al carácter changed[i].
Empiece con la cadena source. En una operación, puede elegir un carácter x de la cadena y cambiarlo al carácter y a un costo de z si existe algún índice j tal que cost[j] == z, original[j] == x y changed[j] == y.
Devuelva el costo mínimo para convertir la cadena source en la cadena target utilizando cualquier número de operaciones. Si es imposible convertir source en target, devuelva -1.
Tenga en cuenta que pueden existir índices i, j tales que original[j] == original[i] y changed[j] == changed[i].

Ejemplo 1:

Entrada: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Salida: 28
Explicación: Para convertir la cadena "abcd" en la cadena "acbe":
- Cambiar el valor en el índice 1 de 'b' a 'c' con un coste de 5.
- Cambiar el valor en el índice 2 de 'c' a 'e' con un coste de 1.
- Cambiar el valor en el índice 2 de 'e' a 'b' con un coste de 2.
- Cambiar el valor en el índice 3 de 'd' a 'e' con un coste de 20.
El coste total incurrido es 5 + 1 + 2 + 20 = 28.
Se puede demostrar que este es el coste mínimo posible.

Ejemplo 2:

Entrada: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Salida: 12
Explicación: Para cambiar el carácter "a" a "b", cambie el carácter "a" a "c" con un costo de 1, seguido por el cambio del carácter "c" a "b" con un costo de 2, para un costo total de 1 + 2 = 3. Para cambiar todas las ocurrencias de "a" a "b", se incurre en un costo total de 3 * 4 = 12.

Ejemplo 3:

Entrada: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Salida: -1
Explicación: Es imposible convertir el origen al destino porque el valor en el índice 3 no se puede cambiar de "d" a "e".

Restricciones:

1 <= source.length == target.length <= 10^5
source, target consisten en letras minúsculas en inglés.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] son letras minúsculas en inglés.
1 <= cost[i] <= 10^6
original[i] != changed[i]


Se te da un array nums de enteros indexados desde 0.
Un prefijo nums[0..i] es secuencial si, para todo 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particular, el prefijo que consiste solo en nums[0] es secuencial.
Devuelve el número entero más pequeño x que falta en nums tal que x es mayor o igual a la suma del prefijo secuencial más largo.

Ejemplo 1:

Entrada: nums = [1,2,3,2,5]
Salida: 6
Explicación: El prefijo secuencial más largo de nums es [1,2,3] con una suma de 6. 6 no está en el array, por lo tanto, 6 es el número entero más pequeño que falta y que es mayor o igual a la suma del prefijo secuencial más largo.

Ejemplo 2:

Entrada: nums = [3,4,5,1,12,14,13]
Salida: 15
Explicación: El prefijo secuencial más largo de nums es [3,4,5] con una suma de 12. 12, 13 y 14 pertenecen al array mientras que 15 no. Por lo tanto, 15 es el número entero más pequeño que falta y que es mayor o igual a la suma del prefijo secuencial más largo.

Restricciones:

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

Se le proporciona una matriz de números enteros indexada en 0 nums.
Un prefijo nums[0..i] es secuencial si, para todos los 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particular, el prefijo que consta únicamente de nums[0] es secuencial.
Devuelve el entero x más pequeño que falta en nums de modo que x sea mayor o igual que la suma del prefijo secuencial más largo.

Ejemplo 1:

Entrada: nums = [1,2,3,2,5]
Salida: 6
Explicación: El prefijo secuencial más largo de nums es [1,2,3] con una suma de 6. 6 no está en la matriz, por lo tanto, 6 es el entero faltante más pequeño mayor o igual que la suma del prefijo secuencial más largo.

Ejemplo 2:

Entrada: nums = [3,4,5,1,12,14,13]
Salida: 15
Explicación: El prefijo secuencial más largo de nums es [3,4,5] con una suma de 12. 12, 13 y 14 pertenecen a la matriz, mientras que 15 no. Por lo tanto, 15 es el entero faltante más pequeño mayor o igual a la suma del prefijo secuencial más largo.

Restricciones:

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

Se le da una matriz de nums enteros con índice 0.
Un prefijo nums[0..i] es secuencial si, para todo 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particular, el prefijo formado sólo por nums[0] es secuencial.
Devuelve el menor entero x que falte en nums tal que x sea mayor o igual que la suma del prefijo secuencial más largo.

Ejemplo 1:

Entrada: nums = [1,2,3,2,5]
Salida: 6
Explicación: El prefijo secuencial más largo de nums es [1,2,3] con una suma de 6. 6 no está en la matriz, por lo tanto 6 es el menor entero que falta mayor o igual que la suma del prefijo secuencial más largo.

Ejemplo 2:

Entrada: nums = [3,4,5,1,12,14,13]
Salida: 15
Explicación: El prefijo secuencial más largo de nums es [3,4,5] con una suma de 12. 12, 13, y 14 pertenecen a la matriz mientras que 15 no. Por lo tanto 15 es el menor entero que falta mayor o igual que la suma del prefijo secuencial más largo.

Restricciones:

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


Se te dan dos números enteros positivos x e y.
En una operación, puedes hacer una de las siguientes cuatro operaciones:

Dividir x por 11 si x es múltiplo de 11.
Dividir x por 5 si x es múltiplo de 5.
Decrementar x en 1.
Incrementar x en 1.

Devuelve el número mínimo de operaciones necesarias para hacer x e y iguales.

Ejemplo 1:

Entrada: x = 26, y = 1
Salida: 3
Explicación: Podemos hacer que 26 sea igual a 1 aplicando las siguientes operaciones:
1. Decrementar x en 1
2. Dividir x por 5
3. Dividir x por 5
Se puede demostrar que 3 es el número mínimo de operaciones necesarias para hacer que 26 sea igual a 1.

Ejemplo 2:

Entrada: x = 54, y = 2
Salida: 4
Explicación: Podemos hacer que 54 sea igual a 2 aplicando las siguientes operaciones:
1. Incrementar x en 1
2. Dividir x por 11
3. Dividir x por 5
4. Incrementar x en 1
Se puede demostrar que 4 es el número mínimo de operaciones necesarias para hacer que 54 sea igual a 2.

Ejemplo 3:

Entrada: x = 25, y = 30
Salida: 5
Explicación: Podemos hacer que 25 sea igual a 30 aplicando las siguientes operaciones:
1. Incrementar x en 1
2. Incrementar x en 1
3. Incrementar x en 1
4. Incrementar x en 1
5. Incrementar x en 1
Se puede demostrar que 5 es el número mínimo de operaciones necesarias para hacer que 25 sea igual a 30.

Restricciones:

1 <= x, y <= 10^4

Se le proporcionan dos números enteros positivos x e y.
En una operación, puede realizar una de las cuatro operaciones siguientes:

Dividir x por 11 si x es múltiplo de 11.
Dividir x por 5 si x es múltiplo de 5.
Reducir x en 1.
Incrementar x en 1.

Devuelve la cantidad mínima de operaciones necesarias para que x e y sean iguales.

Ejemplo 1:

Entrada: x = 26, y = 1
Salida: 3
Explicación: Podemos hacer que 26 sea igual a 1 aplicando las siguientes operaciones:
1. Decrementar x en 1
2. Dividir x por 5
3. Dividir x por 5
Se puede demostrar que 3 es el número mínimo de operaciones necesarias para que 26 sea igual a 1.

Ejemplo 2:

Entrada: x = 54, y = 2
Salida: 4
Explicación: Podemos hacer que 54 sea igual a 2 aplicando las siguientes operaciones:
1. Incrementar x en 1
2. Dividir x por 11
3. Dividir x por 5
4. Incrementar x por 1
Se puede demostrar que 4 es el número mínimo de operaciones necesarias para que 54 sea igual a 2.

Ejemplo 3:

Entrada: x = 25, y = 30
Salida: 5
Explicación: Podemos hacer que 25 sea igual a 30 aplicando las siguientes operaciones:
1. Incrementar x en 1
2. Incrementar x en 1
3. Incrementar x en 1
4. Incrementar x en 1
5. Incrementar x en 1
Se puede demostrar que 5 es el número mínimo de operaciones necesarias para hacer que 25 sea igual a 30.

Restricciones:

1 <= x, y <= 10^4


Se te da un entero k y un entero x.
Considera que s es la representación binaria indexada desde 1 de un entero num. El precio de un número num es la cantidad de i tales que i % x == 0 y s[i] es un bit establecido.
Devuelve el mayor entero num tal que la suma de los precios de todos los números de 1 a num sea menor o igual a k.
Nota:

En la representación binaria de un número, un bit establecido es un bit de valor 1.
La representación binaria de un número se indexará de derecha a izquierda. Por ejemplo, si s == 11100, s[4] == 1 y s[2] == 0.

Ejemplo 1:

Entrada: k = 9, x = 1
Salida: 6
Explicación: Los números 1, 2, 3, 4, 5 y 6 se pueden escribir en representación binaria como "1", "10", "11", "100", "101" y "110" respectivamente.
Dado que x es igual a 1, el precio de cada número es el número de sus bits establecidos.
El número de bits establecidos en estos números es 9. Así que la suma de los precios de los primeros 6 números es 9.
Por lo tanto, la respuesta es 6.
Ejemplo 2:

Entrada: k = 7, x = 2
Salida: 9
Explicación: Dado que x es igual a 2, solo debemos verificar bits pares.
El segundo bit de la representación binaria de los números 2 y 3 es un bit establecido. Así que la suma de sus precios es 2.
El segundo bit de la representación binaria de los números 6 y 7 es un bit establecido. Así que la suma de sus precios es 2.
El cuarto bit de la representación binaria de los números 8 y 9 es un bit establecido, pero su segundo bit no lo es. Así que la suma de sus precios es 2.
Los números 1, 4 y 5 no tienen bits establecidos en sus bits pares en su representación binaria. Así que la suma de sus precios es 0.
El segundo y el cuarto bit de la representación binaria del número 10 son bits establecidos. Así que su precio es 2.
La suma de los precios de los primeros 9 números es 6.
Debido a que la suma de los precios de los primeros 10 números es 8, la respuesta es 9.

Restricciones:

1 <= k <= 10^15
1 <= x <= 8

Se le da un número entero k y un número entero x.
Considere que s es la representación binaria indexada en 1 de un número entero num. El precio de un número num es el número de i tal que i % x == 0 y s[i] es un bit conjunto.
Devuelve el mayor número entero num tal que la suma de los precios de todos los números de 1 a num es menor o igual que k.
Nota:

En la representación binaria de un número set bit es un bit de valor 1.
La representación binaria de un número se indexará de derecha a izquierda. Por ejemplo, si s == 11100, s[4] == 1 y s[2] == 0.

Ejemplo 1

Entrada: k = 9, x = 1
Salida: 6
Explicación: Los números 1, 2, 3, 4, 5 y 6 pueden escribirse en representación binaria como "1", "10", "11", "100", "101", y "110" respectivamente.
Como x es igual a 1, el precio de cada número es el número de sus bits ajustados.
El número de bits configurados en estos números es 9. Así que la suma de los precios de los 6 primeros números es 9.
La respuesta es 6.
Ejemplo 2:

Entrada: k = 7, x = 2
Salida: 9
Explicación: Como x es igual a 2, sólo debemos comprobar los bits pares^.
El segundo bit de la representación binaria de los números 2 y 3 es un bit conjunto. Así que la suma de sus precios es 2.
El segundo bit de la representación binaria de los números 6 y 7 es un bit de conjunto. La suma de sus precios es 2.
El cuarto bit de la representación binaria de los números 8 y 9 es un bit conjunto, pero su segundo bit no lo es. La suma de sus precios es 2.
Los números 1, 4 y 5 no tienen bits conjuntos en los bits pares^ de su representación binaria. La suma de sus precios es 0.
El segundo y el cuarto bit de la representación binaria del número 10 son bits fijos. Su precio es 2.
La suma de los precios de los 9 primeros números es 6.
Como la suma de los precios de los 10 primeros números es 8, la respuesta es 9.

Restricciones:

1 <= k <= 10^15
1 <= x <= 8