Se te da una cadena binaria s.
Devuelve el número de subcadenas con unos dominantes.
Una cadena tiene unos dominantes si el número de unos en la cadena es mayor o igual al cuadrado del número de ceros en la cadena.

Ejemplo 1:

Entrada: s = "00011"
Salida: 5
Explicación:
Las subcadenas con unos dominantes se muestran en la tabla a continuación.

| i | j | s[i..j] | Número de Ceros | Número de Unos |
|---|---|---------|-----------------|----------------|
| 3 | 3 |     1   |       0         |      1         |
| 4 | 4 |     1   |       0         |      1         |
| 2 | 3 |    01   |       1         |      1         |
| 3 | 4 |    11   |       0         |      2         |
| 2 | 4 |   011   |       1         |      2         |

Ejemplo 2:

Entrada: s = "101101"
Salida: 16
Explicación:
Las subcadenas con unos no dominantes se muestran en la tabla a continuación.
Como hay 21 subcadenas en total y 5 de ellas tienen unos no dominantes, se deduce que hay 16 subcadenas con unos dominantes.

| i | j |  s[i..j]  | Número de Ceros | Número de Unos |
|---|---|-----------|-----------------|----------------|
| 1 | 1 |     0     |       1         |      0         |
| 4 | 4 |     0     |       1         |      0         |
| 1 | 4 |   0110    |       2         |      2         |
| 0 | 4 |  10110    |       2         |      3         |
| 1 | 5 |  01101    |       2         |      3         |

Restricciones:

1 <= s.length <= 4 * 10^4
s consiste solo de caracteres '0' y '1'.

Se le da una cadena binaria s.
Devuelve el número de subcadenas con unos dominantes.
Una cadena tiene unos dominantes si el número de unos de la cadena es mayor o igual que el cuadrado del número de ceros de la cadena.

Ejemplo 1

Entrada: s = "00011"
Salida: 5
Explicación:
Las subcadenas con dominantes se muestran en la siguiente tabla.

i
j
s[i..j]
Número de ceros
Número de unos

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Ejemplo 2:

Entrada: s = "101101"
Salida: 16
Explicación:
Las subcadenas con no dominantes se muestran en la siguiente tabla.
Como hay 21 subcadenas en total y 5 de ellas tienen no dominantes, se deduce que hay 16 subcadenas con dominantes.

i
j
s[i..j]
Número de ceros
Número de unos

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Restricciones:

1 <= s.length <= 4 * 10^4
s sólo consta de los caracteres «0» y «1».

Se le proporciona una cadena binaria s.
Devuelve el número de subcadenas con dominantes unos.
Una cadena tiene dominantes unos si el número de unos en la cadena es mayor o igual que el cuadrado del número de ceros en la cadena.

Ejemplo 1:

Entrada: s = "00011"
Salida: 5
Explicación:
Las subcadenas con dominantes unos se muestran en la tabla a continuación.

i
j
s[i..j]
Número de ceros
Número de unos

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Ejemplo 2:

Entrada: s = "101101"
Salida: 16
Explicación:
Las subcadenas con unos no dominantes se muestran en la tabla a continuación.
Dado que hay 21 subcadenas en total y 5 de ellas tienen unos no dominantes, se deduce que hay 16 subcadenas con unos dominantes.

i
j
s[i..j]
Número de ceros
Número de unos

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Restricciones:

1 <= s.length <= 4 * 10^4
s consta únicamente de los caracteres '0' y '1'.


Se te dan dos enteros positivos xCorner y yCorner, y un array 2D circles, donde circles[i] = [x_i, y_i, r_i] denota un círculo con centro en (x_i, y_i) y radio r_i.
Hay un rectángulo en el plano de coordenadas con su esquina inferior izquierda en el origen y la esquina superior derecha en la coordenada (xCorner, yCorner). Necesitas verificar si existe un camino desde la esquina inferior izquierda hasta la esquina superior derecha de manera que todo el camino esté dentro del rectángulo, no toque ni se encuentre dentro de ningún círculo, y toque el rectángulo solo en los dos vértices.
Devuelve true si existe tal camino y false si no.

Ejemplo 1:

Entrada: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Salida: true
Explicación:

La curva negra muestra un camino posible entre (0, 0) y (3, 4).

Ejemplo 2:

Entrada: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Salida: false
Explicación:

No existe un camino de (0, 0) a (3, 3).

Ejemplo 3:

Entrada: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Salida: false
Explicación:

No existe un camino de (0, 0) a (3, 3).

Ejemplo 4:

Entrada: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Salida: true
Explicación:

Restricciones:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Se le proporcionan dos números enteros positivos xCorner e yCorner, y una matriz 2D circles, donde circles[i] = [x_i, y_i, r_i] denota un círculo con centro en (x_i, y_i) y radio r_i.
Hay un rectángulo en el plano de coordenadas con su esquina inferior izquierda en el origen y su esquina superior derecha en la coordenada (xCorner, yCorner). Debe comprobar si existe una ruta desde la esquina inferior izquierda hasta la esquina superior derecha de modo que toda la ruta se encuentre dentro del rectángulo, no toque ni se encuentre dentro de ningún círculo y toque el rectángulo solo en las dos esquinas.
Devuelve verdadero si existe dicha ruta y falso en caso contrario.

Ejemplo 1:

Entrada: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Salida: verdadero
Explicación:

La curva negra muestra una ruta posible entre (0, 0) y (3, 4).

Ejemplo 2:

Entrada: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Salida: false
Explicación:

No existe ninguna ruta de (0, 0) a (3, 3).

Ejemplo 3:

Entrada: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Salida: false
Explicación:

No existe ninguna ruta de (0, 0) a (3, 3).

Ejemplo 4:

Entrada: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Salida: true
Explicación:

Restricciones:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Se le proporcionan dos números enteros positivos xCorner e yCorner, y una matriz 2D circles, donde circles[i] = [x_i, y_i, r_i] denota un círculo con centro en (x_i, y_i) y radio r_i.
Hay un rectángulo en el plano de coordenadas con su esquina inferior izquierda en el origen y su esquina superior derecha en la coordenada (xCorner, yCorner). Debe comprobar si existe una ruta desde la esquina inferior izquierda hasta la esquina superior derecha de modo que toda la ruta se encuentre dentro del rectángulo, no toque ni se encuentre dentro de ningún círculo y toque el rectángulo solo en las dos esquinas.
Devuelve true si existe dicha ruta y false en caso contrario.

Ejemplo 1:

Entrada: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Salida: true
Explicación:

La curva negra muestra una ruta posible entre (0, 0) y (3, 4).

Ejemplo 2:

Entrada: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Salida: false
Explicación:

No existe ninguna ruta de (0, 0) a (3, 3).

Ejemplo 3:

Entrada: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Salida: false
Explicación:

No existe ninguna ruta de (0, 0) a (3, 3).

Ejemplo 4:

Entrada: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Salida: true
Explicación:

Restricciones:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9


Se le proporciona un entero n y una matriz de enteros 2D consultas.
Hay n ciudades numeradas de 0 a n - 1. Inicialmente, hay una carretera unidireccional de la ciudad i a la ciudad i + 1 para todos los 0 <= i < n - 1.
queries[i] = [u_i, v_i] representa la adición de una nueva carretera unidireccional de la ciudad u_i a la ciudad v_i. Después de cada consulta, debe encontrar la longitud de la ruta más corta de la ciudad 0 a la ciudad n - 1.
Devuelva una matriz respuesta donde para cada i en el rango [0, queries.length - 1], respuesta[i] es la longitud de la ruta más corta de la ciudad 0 a la ciudad n - 1 después de procesar las primeras i + 1 consultas.

Ejemplo 1:

Entrada: n = 5, queries = [[2,4],[0,2],[0,4]]
Salida: [3,2,1]
Explicación:

Después de la suma de la carretera de 2 a 4, la longitud del camino más corto de 0 a 4 es 3.

Después de la suma de la carretera de 0 a 2, la longitud del camino más corto de 0 a 4 es 2.

Después de la suma de la carretera de 0 a 4, la longitud del camino más corto de 0 a 4 es 1.

Ejemplo 2:

Entrada: n = 4, queries = [[0,3],[0,2]]
Salida: [1,1]
Explicación:

Después de la suma de la carretera de 0 a 3, la longitud del camino más corto de 0 a 3 es 1.

Después de la suma de la carretera de 0 a 2, la longitud de la ruta más corta sigue siendo 1.

Restricciones:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
No hay rutas repetidas entre las consultas.

Se le proporciona un entero n y una matriz de enteros 2D consultas.
Hay n ciudades numeradas de 0 a n - 1. Inicialmente, hay una carretera unidireccional de la ciudad i a la ciudad i + 1 para todos los 0 <= i < n - 1.
queries[i] = [u_i, v_i] representa la adición de una nueva carretera unidireccional de la ciudad u_i a la ciudad v_i. Después de cada consulta, debe encontrar la longitud de la ruta más corta de la ciudad 0 a la ciudad n - 1.
Devuelva una matriz respuesta donde para cada i en el rango [0, queries.length - 1], respuesta[i] es la longitud de la ruta más corta de la ciudad 0 a la ciudad n - 1 después de procesar las primeras i + 1 consultas.

Ejemplo 1:

Entrada: n = 5, consultas = [[2,4],[0,2],[0,4]]
Salida: [3,2,1]
Explicación:

Después de la suma de la carretera de 2 a 4, la longitud del camino más corto de 0 a 4 es 3.

Después de la suma de la carretera de 0 a 2, la longitud del camino más corto de 0 a 4 es 2.

Después de la suma de la carretera de 0 a 4, la longitud del camino más corto de 0 a 4 es 1.

Ejemplo 2:

Entrada: n = 4, consultas = [[0,3],[0,2]]
Salida: [1,1]
Explicación:

Después de la suma de la carretera de 0 a 3, la longitud del camino más corto de 0 a 3 es 1.

Después de la suma de la carretera de 0 a 2, la longitud de la ruta más corta sigue siendo 1.

Restricciones:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
No hay rutas repetidas entre las consultas.

Se te da un número entero n y un arreglo 2D de enteros queries.
Hay n ciudades numeradas del 0 al n - 1. Inicialmente, hay un camino unidireccional desde la ciudad i a la ciudad i + 1 para todo 0 <= i < n - 1.
queries[i] = [u_i, v_i] representa la adición de un nuevo camino unidireccional desde la ciudad u_i a la ciudad v_i. Después de cada consulta, necesitas encontrar la longitud del camino más corto desde la ciudad 0 a la ciudad n - 1.
Devuelve un arreglo answer donde para cada i en el rango [0, queries.length - 1], answer[i] es la longitud del camino más corto desde la ciudad 0 a la ciudad n - 1 después de procesar las primeras i + 1 consultas.

Ejemplo 1:

Entrada: n = 5, queries = [[2,4],[0,2],[0,4]]
Salida: [3,2,1]
Explicación:

Después de la adición del camino de 2 a 4, la longitud del camino más corto de 0 a 4 es 3.

Después de la adición del camino de 0 a 2, la longitud del camino más corto de 0 a 4 es 2.

Después de la adición del camino de 0 a 4, la longitud del camino más corto de 0 a 4 es 1.

Ejemplo 2:

Entrada: n = 4, queries = [[0,3],[0,2]]
Salida: [1,1]
Explicación:

Después de la adición del camino de 0 a 3, la longitud del camino más corto de 0 a 3 es 1.

Después de la adición del camino de 0 a 2, la longitud del camino más corto sigue siendo 1.

Restricciones:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
No hay caminos repetidos entre las consultas.


Hay algunas baldosas rojas y azules dispuestas circularmente. Se te da un arreglo de enteros colors y un arreglo 2D de enteros queries.
El color de la baldosa i está representado por colors[i]:

colors[i] == 0 significa que la baldosa i es roja.
colors[i] == 1 significa que la baldosa i es azul.

Un grupo alternante es un subconjunto contiguo de baldosas en el círculo con colores alternantes (cada baldosa en el grupo, excepto la primera y la última, tiene un color diferente de sus baldosas adyacentes en el grupo).
Tienes que procesar consultas de dos tipos:

queries[i] = [1, size_i], determina el conteo de grupos alternantes con tamaño size_i.
queries[i] = [2, index_i, color_i], cambia colors[index_i] a color_i.

Devuelve un arreglo answer que contenga los resultados de las consultas del primer tipo en orden.
Nota que dado que colors representa un círculo, las primeras y las últimas baldosas se consideran próximas entre sí.

Ejemplo 1:

Entrada: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Salida: [2]
Explicación:

Primera consulta:
Cambia colors[1] a 0.

Segunda consulta:
Conteo de grupos alternantes con tamaño 4:

Ejemplo 2:

Entrada: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Salida: [2,0]
Explicación:

Primera consulta:
Conteo de grupos alternantes con tamaño 3:

Segunda consulta: colors no cambiará.
Tercera consulta: No hay grupo alternante con tamaño 5.

Restricciones:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 o queries[i][0] == 2
Para todo i que:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Hay algunas fichas rojas y azules dispuestas de forma circular. Se le proporciona una matriz de colores enteros y una matriz de consultas de enteros 2D.
El color de la ficha i está representado por colors[i]:

colors[i] == 0 significa que la ficha i es roja.
colors[i] == 1 significa que la ficha i es azul.

Un grupo alterno es un subconjunto contiguo de fichas en el círculo con colores alternos (cada ficha del grupo, excepto la primera y la última, tiene un color diferente al de las fichas adyacentes en el grupo).
Debe procesar consultas de dos tipos:

queries[i] = [1, size_i], determine la cantidad de grupos alternos con tamaño size_i.
queries[i] = [2, index_i, color_i], cambie colors[index_i] a color_i.

Devuelva una respuesta de matriz que contenga los resultados de las consultas del primer tipo en orden.
Tenga en cuenta que, dado que colors representa un círculo, se considera que el primer y el último mosaico están uno al lado del otro.

Ejemplo 1:

Entrada: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Salida: [2]
Explicación:

Primera consulta:
Cambie colors[1] a 0.

Segunda consulta:
Recuento de grupos alternos con tamaño 4:

Ejemplo 2:

Entrada: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Salida: [2,0]
Explicación:

Primera consulta:
Recuento de grupos alternados con tamaño 3:

Segunda consulta: colors no cambiará.
Tercera consulta: No hay ningún grupo alterno con tamaño 5.

Restricciones:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Para todos los i que:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Hay algunas baldosas rojas y azules dispuestas circularmente. Se te da un conjunto de enteros colors y un conjunto 2D de enteros queries.
El color de la baldosa i está representado por colors[i]:

colors[i] == 0 significa que la baldosa i es roja.
colors[i] == 1 significa que la baldosa i es azul.

Un grupo alternante es un subconjunto contiguo de baldosas en el círculo con colores alternantes (cada baldosa en el grupo, excepto la primera y la última, tiene un color diferente de sus baldosas adyacentes en el grupo).
Tienes que procesar consultas de dos tipos:

queries[i] = [1, size_i], determina el conteo de grupos alternantes con tamaño size_i.
queries[i] = [2, index_i, color_i], cambia colors[index_i] a color_i.

Devuelve un conjunto answer que contenga los resultados de las consultas del primer tipo en orden.
Nota que dado que colors representa un círculo, las primeras y las últimas baldosas se consideran próximas entre sí.

Ejemplo 1:

Input: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Output: [2]
Explicación:

Primera consulta:
Cambia colors[1] a 0.

Segunda consulta:
Conteo de grupos alternantes con tamaño 4:

Ejemplo 2:

Input: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Output: [2,0]
Explicación:

Primera consulta:
Conteo de grupos alternantes con tamaño 3:

Segunda consulta: colors no cambiará.
Tercera consulta: No hay grupo alternante con tamaño 5.

Restricciones:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 o queries[i][0] == 2
Para todo i que:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1


Hay una serpiente en una cuadrícula de matriz n x n y puede moverse en cuatro direcciones posibles. Cada celda de la cuadrícula se identifica por la posición: cuadrícula[i][j] = (i * n) + j.
La serpiente comienza en la celda 0 y sigue una secuencia de comandos.
Se le proporciona un entero n que representa el tamaño de la cuadrícula y una matriz de cadenas de comandos donde cada comando[i] es "ARRIBA", "DERECHA", "ABAJO" e "IZQUIERDA". Se garantiza que la serpiente permanecerá dentro de los límites de la cuadrícula durante todo su movimiento.
Devuelve la posición de la celda final donde termina la serpiente después de ejecutar los comandos.

Ejemplo 1:

Entrada: n = 2, comandos = ["DERECHA", "ABAJO"]
Salida: 3
Explicación:

0
1

2
3

0
1

2
3

0
1

2
3

Ejemplo 2:

Entrada: n = 3, comandos = ["ABAJO", "DERECHA", "ARRIBA"]
Salida: 1
Explicación:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Restricciones:

2 <= n <= 10
1 <= commands.length <= 100
commands consta solo de "ARRIBA", "DERECHA", "ABAJO" e "IZQUIERDA".
La entrada se genera de manera que la serpiente no se mueva fuera de los límites.

Hay una serpiente en una cuadrícula de matriz n x n y puede moverse en cuatro direcciones posibles. Cada celda de la cuadrícula se identifica por la posición: grid[i][j] = (i * n) + j.
La serpiente comienza en la celda 0 y sigue una secuencia de comandos.
Se le proporciona un entero n que representa el tamaño de la cuadrícula y una matriz de cadenas de comandos donde cada comando[i] es "UP", "RIGHT", "DOWN" e "LEFT". Se garantiza que la serpiente permanecerá dentro de los límites de la cuadrícula durante todo su movimiento.
Devuelve la posición de la celda final donde termina la serpiente después de ejecutar los comandos.

Ejemplo 1:

Entrada: n = 2, commands = ["RIGHT","DOWN"]
Salida: 3
Explicación:

0
1

2
3

0
1

2
3

0
1

2
3

Ejemplo 2:

Entrada: n = 3, commands = ["DOWN","RIGHT","UP"]
Salida: 1
Explicación:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

 Restricciones:

2 <= n <= 10
1 <= commands.length <= 100
commands consta solo de "UP", "RIGHT", "DOWN",  e "LEFT".
La entrada se genera de manera que la serpiente no se mueva fuera de los límites.

Hay una serpiente en una cuadrícula de matriz n x n que puede moverse en cuatro direcciones posibles. Cada celda de la cuadrícula está identificada por la posición: grid[i][j] = (i * n) + j.
La serpiente comienza en la celda 0 y sigue una secuencia de comandos.
Se te da un entero n que representa el tamaño de la cuadrícula y un arreglo de cadenas commands donde cada command[i] es "UP", "RIGHT", "DOWN" y "LEFT". Se garantiza que la serpiente permanecerá dentro de los límites de la cuadrícula durante su movimiento.
Devuelve la posición de la celda final donde la serpiente termina después de ejecutar los comandos.

Ejemplo 1:

Entrada: n = 2, commands = ["RIGHT","DOWN"]
Salida: 3
Explicación:

0
1

2
3

0
1

2
3

0
1

2
3

Ejemplo 2:

Entrada: n = 3, commands = ["DOWN","RIGHT","UP"]
Salida: 1
Explicación:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Restricciones:

2 <= n <= 10
1 <= commands.length <= 100
commands consiste solo de "UP", "RIGHT", "DOWN" y "LEFT".
La entrada está generada de tal manera que la serpiente no se moverá fuera de los límites.


Se te da un arreglo de enteros positivos nums de longitud n.
Llamamos a un par de arreglos de enteros no negativos (arr1, arr2) monótono si:

Las longitudes de ambos arreglos son n.
arr1 es monótonamente no decreciente, en otras palabras, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 es monótonamente no creciente, en otras palabras, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] para todo 0 <= i <= n - 1.

Devuelve el conteo de pares monótonos.
Dado que la respuesta puede ser muy grande, devuélvela modulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,3,2]
Salida: 4
Explicación:
Los pares válidos son:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Ejemplo 2:

Entrada: nums = [5,5,5,5]
Salida: 126

Restricciones:

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

Se da una matriz de números enteros positivos de longitud n.
Llamamos monótona a una pareja de matrices de enteros no negativos (arr1, arr2) si:

Las longitudes de ambas matrices son n.
arr1 es monotónicamente no decreciente, es decir, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 es monotónicamente no creciente, es decir, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] para todo 0 <= i <= n - 1.

Devuelve el recuento de pares monótonos.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: nums = [2,3,2]
Salida: 4
Explicación:
Los pares buenos son:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Ejemplo 2:

Entrada: nums = [5,5,5,5]
Salida: 126

Restricciones:

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


Se te da una cadena s.
Tu tarea es eliminar todos los dígitos realizando esta operación repetidamente:

Elimina el primer dígito y el carácter no numérico más cercano a su izquierda.

Devuelve la cadena resultante después de eliminar todos los dígitos.

Ejemplo 1:

Entrada: s = "abc"
Salida: "abc"
Explicación:
No hay ningún dígito en la cadena.

Ejemplo 2:

Entrada: s = "cb34"
Salida: ""
Explicación:
Primero, aplicamos la operación en s[2], y s se convierte en "c4".
Luego aplicamos la operación en s[1], y s se convierte en "".

Restricciones:

1 <= s.length <= 100
s consiste solo en letras minúsculas del inglés y dígitos.
La entrada se genera de manera que es posible eliminar todos los dígitos.

Se te da una cadena s.
Su tarea consiste en eliminar todos los dígitos realizando esta operación repetidamente:

Elimine el primer dígito y el carácter no dígito más cercano a su izquierda.

Devuelve la cadena resultante después de eliminar todos los dígitos.

Ejemplo 1

Entrada: s = "abc"
Salida: "abc"
Explicación:
No hay ningún dígito en la cadena.

Ejemplo 2:

Entrada: s = "cb34"
Salida: ""
Explicación:
Primero, aplicamos la operación sobre s[2], y s se convierte en "c4".
Luego aplicamos la operación sobre s[1], y s se convierte en "".

Restricciones:

1 <= s.length <= 100
s se compone sólo de letras minúsculas y cifras.
La entrada se genera de forma que sea posible eliminar todos los dígitos.


Una competición consta de n jugadores numerados de 0 a n - 1.
Se le da una matriz de enteros skills de tamaño n y un entero positivo k, donde skills[i] es el nivel de habilidad del jugador i. Todos los enteros en skills son únicos.
Todos los jugadores están en una cola en orden desde el jugador 0 al jugador n - 1.
El proceso de competición es el siguiente:

Los dos primeros jugadores de la cola juegan una partida, y gana el jugador con mayor nivel de habilidad.
Tras la partida, el ganador se queda al inicio de la cola, y el perdedor pasa al final de la misma.

El ganador de la competición es el primer jugador que gana k partidas seguidas.
Devuelve el índice inicial del jugador ganador.

Ejemplo 1:

Entrada: skills = [4,2,6,3,9], k = 2
Salida: 2
Explicación:
Inicialmente, la cola de jugadores es [0,1,2,3,4]. Se produce el siguiente proceso:

Los jugadores 0 y 1 juegan una partida, como la habilidad del jugador 0 es mayor que la del jugador 1, gana el jugador 0. La cola resultante es [0,2,3,4,1].
Los jugadores 0 y 2 juegan una partida, como la habilidad del jugador 2 es mayor que la del jugador 0, gana el jugador 2. La cola resultante es [2,3,4,1,0].
Los jugadores 2 y 3 juegan una partida, como la habilidad del jugador 2 es mayor que la del jugador 3, gana el jugador 2. La cola resultante es [2,3,4,1,0]. La cola resultante es [2,4,1,0,3].

El jugador 2 ganó k = 2 partidas seguidas, por lo que el ganador es el jugador 2.

Ejemplo 2:

Entrada: skills = [2,5,4], k = 3
Salida: 1
Explicación:
Inicialmente, la cola de jugadores es [0,1,2]. Se produce el siguiente proceso:

Los jugadores 0 y 1 juegan una partida, como la habilidad del jugador 1 es mayor que la del jugador 0, gana el jugador 1. La cola resultante es [1,2,0].
Los jugadores 1 y 2 juegan una partida, como la habilidad del jugador 1 es mayor que la del jugador 2, gana el jugador 1. La cola resultante es [1,2,0]. La cola resultante es [1,0,2].
Los jugadores 1 y 0 juegan una partida, como la habilidad del jugador 1 es mayor que la del jugador 0, gana el jugador 1. La cola resultante es [1,0,2]. La cola resultante es [1,2,0].

El jugador 1 ganó k = 3 partidas seguidas, por lo que el ganador es el jugador 1.

Restricciones:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Todos los enteros en skills son únicos.

Una competición consta de n jugadores numerados del 0 al n - 1.
Se le proporciona una matriz de enteros skills de tamaño n y un entero positivo k, donde skills[i] es el nivel de habilidad del jugador i. Todos los enteros en skills son únicos.
Todos los jugadores están en una cola en orden desde el jugador 0 al jugador n - 1.
El proceso de la competición es el siguiente:

Los dos primeros jugadores de la cola juegan un juego y el jugador con el nivel de habilidad más alto gana.
Después del juego, el ganador se queda al principio de la cola y el perdedor va al final de la misma.

El ganador de la competición es el primer jugador que gana k juegos seguidos.
Devuelve el índice inicial del jugador ganador.

Ejemplo 1:

Entrada: skills = [4,2,6,3,9], k = 2
Salida: 2
Explicación:
Inicialmente, la cola de jugadores es [0,1,2,3,4]. El siguiente proceso ocurre:

Los jugadores 0 y 1 juegan un juego, ya que la habilidad del jugador 0 es mayor que la del jugador 1, el jugador 0 gana. La cola resultante es [0,2,3,4,1].
Los jugadores 0 y 2 juegan un juego, ya que la habilidad del jugador 2 es mayor que la del jugador 0, el jugador 2 gana. La cola resultante es [2,3,4,1,0].
Los jugadores 2 y 3 juegan un juego, ya que la habilidad del jugador 2 es mayor que la del jugador 3, el jugador 2 gana. La cola resultante es [2,4,1,0,3].

El jugador 2 ganó k = 2 juegos seguidos, por lo que el ganador es el jugador 2.

Ejemplo 2:

Entrada: habilidades = [2,5,4], k = 3
Salida: 1
Explicación:
Inicialmente, la cola de jugadores es [0,1,2]. El siguiente proceso ocurre:

Los jugadores 0 y 1 juegan un juego, ya que la habilidad del jugador 1 es mayor que la del jugador 0, el jugador 1 gana. La cola resultante es [1,2,0].
Los jugadores 1 y 2 juegan un juego, ya que la habilidad del jugador 1 es mayor que la del jugador 2, el jugador 1 gana. La cola resultante es [1,0,2].
Los jugadores 1 y 0 juegan un juego, ya que la habilidad del jugador 1 es mayor que la del jugador 0, el jugador 1 gana. La cola resultante es [1,2,0].

El jugador 1 ganó k = 3 juegos seguidos, por lo que el ganador es el jugador 1.

Restricciones:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Todos los números enteros en skills son únicos.

Una competencia consiste en n jugadores numerados del 0 al n - 1.
Se te da un array de enteros skills de tamaño n y un entero positivo k, donde skills[i] es el nivel de habilidad del jugador i. Todos los enteros en skills son únicos.
Todos los jugadores están haciendo cola en orden desde el jugador 0 hasta el jugador n - 1.
El proceso de la competencia es el siguiente:

Los primeros dos jugadores en la cola juegan un juego, y el jugador con el nivel de habilidad más alto gana.
Después del juego, el ganador se queda al principio de la cola y el perdedor va al final de la misma.

El ganador de la competencia es el primer jugador que gana k juegos consecutivos.
Devuelve el índice inicial del jugador ganador.

Ejemplo 1:

Entrada: skills = [4,2,6,3,9], k = 2
Salida: 2
Explicación:
Inicialmente, la cola de jugadores es [0,1,2,3,4]. El siguiente proceso ocurre:

Los jugadores 0 y 1 juegan un juego, dado que la habilidad del jugador 0 es mayor que la del jugador 1, el jugador 0 gana. La cola resultante es [0,2,3,4,1].
Los jugadores 0 y 2 juegan un juego, dado que la habilidad del jugador 2 es mayor que la del jugador 0, el jugador 2 gana. La cola resultante es [2,3,4,1,0].
Los jugadores 2 y 3 juegan un juego, dado que la habilidad del jugador 2 es mayor que la del jugador 3, el jugador 2 gana. La cola resultante es [2,4,1,0,3].

El jugador 2 ganó k = 2 juegos consecutivos, por lo que el ganador es el jugador 2.

Ejemplo 2:

Entrada: skills = [2,5,4], k = 3
Salida: 1
Explicación:
Inicialmente, la cola de jugadores es [0,1,2]. El siguiente proceso ocurre:

Los jugadores 0 y 1 juegan un juego, dado que la habilidad del jugador 1 es mayor que la del jugador 0, el jugador 1 gana. La cola resultante es [1,2,0].
Los jugadores 1 y 2 juegan un juego, dado que la habilidad del jugador 1 es mayor que la del jugador 2, el jugador 1 gana. La cola resultante es [1,0,2].
Los jugadores 1 y 0 juegan un juego, dado que la habilidad del jugador 1 es mayor que la del jugador 0, el jugador 1 gana. La cola resultante es [1,2,0].

El jugador 1 ganó k = 3 juegos consecutivos, por lo que el ganador es el jugador 1.

Condiciones:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Todos los enteros en skills son únicos.


Se te da un array de enteros nums y un entero no negativo k. Una secuencia de enteros seq se llama buena si hay como máximo k índices i en el rango [0, seq.length - 2] tal que seq[i] != seq[i + 1].
Devuelve la longitud máxima posible de una subsecuencia buena de nums.

Ejemplo 1:

Entrada: nums = [1,2,1,1,3], k = 2
Salida: 4
Explicación:
La subsecuencia de longitud máxima es [1,2,1,1,3].

Ejemplo 2:

Entrada: nums = [1,2,3,4,5,1], k = 0
Salida: 2
Explicación:
La subsecuencia de longitud máxima es [1,2,3,4,5,1].

Condiciones:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

Se le proporciona una matriz de números enteros nums y un número entero no negativo k. Una secuencia de números enteros seq se denomina buena si hay como máximo k índices i en el rango [0, seq.length - 2] tales que seq[i] != seq[i + 1].
Devuelve la longitud máxima posible de una subsecuencia buena de números.

Ejemplo 1:

Entrada: nums = [1,2,1,1,3], k = 2
Salida: 4
Explicación:
La subsecuencia de longitud máxima es [1,2,1,1,3].

Ejemplo 2:

Entrada: nums = [1,2,3,4,5,1], k = 0
Salida: 2
Explicación:
La subsecuencia de longitud máxima es [1,2,3,4,5,1].

Restricciones:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


Se te da un array de enteros nums. En una operación, puedes sumar o restar 1 a cualquier elemento de nums.
Devuelve el número mínimo de operaciones para hacer que todos los elementos de nums sean divisibles por 3.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 3
Explicación:
Todos los elementos del array pueden hacerse divisibles por 3 usando 3 operaciones:

Restar 1 de 1.
Sumar 1 a 2.
Restar 1 de 4.

Ejemplo 2:

Entrada: nums = [3,6,9]
Salida: 0

Restricciones:

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

Se le proporciona una matriz de números enteros nums. En una operación, puede sumar o restar 1 de cualquier elemento de nums.
Devuelve el nums mínimo de operaciones para hacer que todos los elementos de nums sean divisibles por 3.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 3
Explicación:
Todos los elementos de la matriz se pueden hacer divisibles por 3 utilizando 3 operaciones:

Restar 1 de 1.
Sumar 1 a 2.
Restar 1 de 4.

Ejemplo 2:

Entrada: nums = [3,6,9]
Salida: 0

Restricciones:

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

Se te da un conjunto de enteros nums. En una operación, puedes sumar o restar 1 a cualquier elemento de nums.
Devuelve el número mínimo de operaciones para hacer que todos los elementos de nums sean divisibles por 3.

Ejemplo 1:

Entrada: nums = [1,2,3,4]
Salida: 3
Explicación:
Todos los elementos del conjunto pueden hacerse divisibles por 3 usando 3 operaciones:

Restar 1 de 1.
Sumar 1 a 2.
Restar 1 de 4.

Ejemplo 2:

Entrada: nums = [3,6,9]
Salida: 0

Restricciones:

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


Se le proporciona una matriz binaria nums.
Puede realizar la siguiente operación en la matriz cualquier cantidad de veces (posiblemente cero):

Elija 3 elementos consecutivos de la matriz y voltéelos todos.

Voltear un elemento significa cambiar su valor de 0 a 1 y de 1 a 0.
Devuelva la cantidad mínima de operaciones necesarias para que todos los elementos de nums sean iguales a 1. Si es imposible, devuelva -1.

Ejemplo 1:

Entrada: nums = [0,1,1,1,0,0]
Salida: 3
Explicación:
Podemos realizar las siguientes operaciones:

Elija los elementos en los índices 0, 1 y 2. La matriz resultante es nums = [1,0,0,1,0,0].
Elija los elementos en los índices 1, 2 y 3. La matriz resultante es nums = [1,1,1,0,0,0].
Elija los elementos en los índices 3, 4 y 5. La matriz resultante es nums = [1,1,1,1,1,1].

Ejemplo 2:

Entrada: nums = [0,1,1,1]
Salida: -1
Explicación:
Es imposible hacer que todos los elementos sean iguales a 1.

Restricciones:

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

Se le da una matriz binaria nums.
Puede realizar la siguiente operación en la matriz cualquier número de veces (posiblemente cero):

Elige 3 elementos consecutivos cualesquiera de la matriz y voltéalos todos.

Voltear un elemento significa cambiar su valor de 0 a 1, y de 1 a 0.
Devuelve el número mínimo de operaciones necesarias para que todos los elementos de nums sean iguales a 1. Si es imposible, devuelve -1.

Ejemplo 1:

Entrada: nums = [0,1,1,1,0,0]
Salida: 3
Explicación:
Podemos hacer las siguientes operaciones:

Elegir los elementos en los índices 0, 1 y 2. El array resultante es nums = [1,0,0,1,0,0].
Elegir los elementos en los índices 1, 2 y 3. La matriz resultante es nums = [1,1,1,0,0,0].
Elige los elementos en los índices 3, 4 y 5. La matriz resultante es nums = [1,1,1,1,1,1].

Ejemplo 2:

Entrada: nums = [0,1,1,1]
Salida: -1
Explicación:
Es imposible que todos los elementos sean iguales a 1.

Restricciones:

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

Dado un arreglo binario nums.
Puedes realizar la siguiente operación en el arreglo cualquier número de veces (posiblemente cero):

Elige cualquier 3 elementos consecutivos del arreglo y cámbialos.

Cambiar un elemento significa alterar su valor de 0 a 1, y de 1 a 0.
Devuelve el número mínimo de operaciones necesarias para hacer que todos los elementos en nums sean iguales a 1. Si es imposible, devuelve -1.

Ejemplo 1:

Entrada: nums = [0,1,1,1,0,0]
Salida: 3
Explicación:
Podemos realizar las siguientes operaciones:

Elige los elementos en los índices 0, 1 y 2. El arreglo resultante es nums = [1,0,0,1,0,0].
Elige los elementos en los índices 1, 2 y 3. El arreglo resultante es nums = [1,1,1,0,0,0].
Elige los elementos en los índices 3, 4 y 5. El arreglo resultante es nums = [1,1,1,1,1,1].

Ejemplo 2:

Entrada: nums = [0,1,1,1]
Salida: -1
Explicación:
Es imposible hacer que todos los elementos sean iguales a 1.

Restricciones:

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


Se te da un número entero n y un arreglo 2D requirements, donde requirements[i] = [end_i, cnt_i] representa el índice final y el conteo de inversiones de cada requisito. Un par de índices (i, j) de un arreglo de enteros nums se llama una inversión si:

i < j y nums[i] > nums[j]

Devuelve el número de permutaciones perm de [0, 1, 2, ..., n - 1] tal que, para todos los requirements[i], perm[0..end_i] tenga exactamente cnt_i inversiones. Ya que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 3, requisitos = [[2,2],[0,0]]
Salida: 2
Explicación:
Las dos permutaciones son:

[2, 0, 1]

El prefijo [2, 0, 1] tiene las inversiones (0, 1) y (0, 2).
El prefijo [2] tiene 0 inversiones.

[1, 2, 0]

El prefijo [1, 2, 0] tiene las inversiones (0, 2) y (1, 2).
El prefijo [1] tiene 0 inversiones.

Ejemplo 2:

Entrada: n = 3, requisitos = [[2,2],[1,1],[0,0]]
Salida: 1
Explicación:
La única permutación que satisface los requisitos es [2, 0, 1]:

El prefijo [2, 0, 1] tiene las inversiones (0, 1) y (0, 2).
El prefijo [2, 0] tiene una inversión (0, 1).
El prefijo [2] tiene 0 inversiones.

Ejemplo 3:

Entrada: n = 2, requirements = [[0,0],[1,0]]
Salida: 1
Explicación:
La única permutación que satisface es [0, 1]:

El prefijo [0] tiene 0 inversiones.
El prefijo [0, 1] tiene una inversión (0, 1).

Restricciones:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
La entrada se genera de tal manera que hay al menos un i tal que end_i == n - 1.
La entrada se genera de tal manera que todos los end_i son únicos.

Se le proporciona un entero n y una matriz 2D requirements, donde requirements[i] = [end_i, cnt_i] representa el índice final y el recuento de inversiones de cada requisito.
Un par de índices (i, j) de una matriz de enteros nums se denomina inversión si:

i < j y nums[i] > nums[j]

Devuelve la cantidad de permutaciones perm de [0, 1, 2, ..., n - 1] de manera que para todos los requirements[i], perm[0..end_i] tenga exactamente cnt_i inversiones.
Como la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 3, requirements = [[2,2],[0,0]]
Salida: 2
Explicación:
Las dos permutaciones son:

[2, 0, 1]

El prefijo [2, 0, 1] tiene inversiones (0, 1) y (0, 2).
El prefijo [2] tiene 0 inversiones.

[1, 2, 0]

El prefijo [1, 2, 0] tiene inversiones (0, 2) y (1, 2).
El prefijo [1] tiene 0 inversiones.

Ejemplo 2:

Entrada: n = 3, requirements = [[2,2],[1,1],[0,0]]
Salida: 1
Explicación:
La única permutación satisfactoria es [2, 0, 1]:

El prefijo [2, 0, 1] tiene inversiones (0, 1) y (0, 2).
El prefijo [2, 0] tiene una inversión (0, 1).
El prefijo [2] tiene 0 inversiones.

Ejemplo 3:

Entrada: n = 2, requirements = [[0,0],[1,0]]
Salida: 1
Explicación:
La única permutación satisfactoria es [0, 1]:

El prefijo [0] tiene 0 inversiones.
El prefijo [0, 1] tiene una inversión (0, 1).

Restricciones:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
La entrada se genera de manera que haya al menos un i tal que end_i == n - 1.
La entrada se genera de manera que todos los end_i sean únicos.

Se te da un número entero n y un conjunto 2D requisitos, donde requisitos[i] = [end_i, cnt_i] representa el índice final y el conteo de inversiones de cada requisito.
Un par de índices (i, j) de un conjunto de enteros nums se llama una inversión si:

i < j y nums[i] > nums[j]

Devuelve el número de permutaciones perm de [0, 1, 2, ..., n - 1] tal que para todos los requisitos[i], perm[0..end_i] tenga exactamente cnt_i inversiones.
Ya que la respuesta puede ser muy grande, devuélvela módulo 10^9 + 7.

Ejemplo 1:

Entrada: n = 3, requisitos = [[2,2],[0,0]]
Salida: 2
Explicación:
Las dos permutaciones son:

[2, 0, 1]

El prefijo [2, 0, 1] tiene inversiones (0, 1) y (0, 2).
El prefijo [2] tiene 0 inversiones.

[1, 2, 0]

El prefijo [1, 2, 0] tiene inversiones (0, 2) y (1, 2).
El prefijo [1] tiene 0 inversiones.

Ejemplo 2:

Entrada: n = 3, requisitos = [[2,2],[1,1],[0,0]]
Salida: 1
Explicación:
La única permutación que satisface los requisitos es [2, 0, 1]:

El prefijo [2, 0, 1] tiene inversiones (0, 1) y (0, 2).
El prefijo [2, 0] tiene una inversión (0, 1).
El prefijo [2] tiene 0 inversiones.

Ejemplo 3:

Entrada: n = 2, requisitos = [[0,0],[1,0]]
Salida: 1
Explicación:
La única permutación que satisface los requisitos es [0, 1]:

El prefijo [0] tiene 0 inversiones.
El prefijo [0, 1] tiene una inversión (0, 1).

Restricciones:

2 <= n <= 300
1 <= requisitos.length <= n
requisitos[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
La entrada se genera de tal manera que hay al menos un i tal que end_i == n - 1.
La entrada se genera de tal manera que todos los end_i son únicos.


Hay un círculo de fichas rojas y azules. Se le proporciona una matriz de colores enteros. El color de la ficha i está representado por colors[i]:

colors[i] == 0 significa que la ficha i es roja.
colors[i] == 1 significa que la ficha i es azul.

Cada 3 fichas contiguas en el círculo con colores alternos (la ficha del medio tiene un color diferente al de las fichas izquierda y derecha) se denomina grupo alterno.
Devuelve el número de grupos alternos.
Tenga en cuenta que, dado que colors representa un círculo, se considera que la primera y la última ficha están una al lado de la otra.

Ejemplo 1:

Entrada: colors = [1,1,1]
Salida: 0
Explicación:

Ejemplo 2:

Entrada: colors = [0,1,0,0,1]
Salida: 3
Explicación:

Grupos alternados:

Restricciones:

3 <= colors.length <= 100
0 <= colors[i] <= 1

Hay un círculo de fichas rojas y azules. Se te proporciona un arreglo de enteros colors. El color de la ficha i está representado por colors[i]:

colors[i] == 0 significa que la ficha i es roja.
colors[i] == 1 significa que la ficha i es azul.

Cada 3 fichas contiguas en el círculo con colores alternos (la ficha del medio tiene un color diferente al de sus fichas izquierda y derecha) se llama un grupo alterno. Devuelve el número de grupos alternos. Ten en cuenta que dado que colors representa un círculo, las primeras y las últimas fichas se consideran contiguas.

Ejemplo 1:

Entrada: colors = [1,1,1]
Salida: 0
Explicación:

Ejemplo 2:

Entrada: colors = [0,1,0,0,1]
Salida: 3
Explicación:

Grupos alternos:

Restricciones:

3 <= colors.length <= 100
0 <= colors[i] <= 1


Se te da un array de enteros enemyEnergies que denota los valores de energía de varios enemigos.
También se te da un entero currentEnergy que indica la cantidad de energía que tienes inicialmente.
Comienzas con 0 puntos, y todos los enemigos están sin marcar inicialmente.
Puedes realizar cualquiera de las siguientes operaciones cero o múltiples veces para ganar puntos:

Elige un enemigo no marcado, i, tal que currentEnergy >= enemyEnergies[i]. Al elegir esta opción:

Ganas 1 punto.
Tu energía se reduce por la energía del enemigo, es decir, currentEnergy = currentEnergy - enemyEnergies[i].

Si tienes al menos 1 punto, puedes elegir un enemigo no marcado, i. Al elegir esta opción:

Tu energía aumenta por la energía del enemigo, es decir, currentEnergy = currentEnergy + enemyEnergies[i].
El enemigo i se marca.

Devuelve un entero que denote el número máximo de puntos que puedes obtener al final realizando operaciones óptimamente.

Ejemplo 1:

Entrada: enemyEnergies = [3,2,2], currentEnergy = 2
Salida: 3
Explicación:
Las siguientes operaciones se pueden realizar para obtener 3 puntos, que es el máximo:

Primera operación en el enemigo 1: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 1, y currentEnergy = 0.
Segunda operación en el enemigo 0: currentEnergy aumenta en 3, y el enemigo 0 se marca. Entonces, puntos = 1, currentEnergy = 3, y enemigos marcados = [0].
Primera operación en el enemigo 2: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 2, currentEnergy = 1, y enemigos marcados = [0].
Segunda operación en el enemigo 2: currentEnergy aumenta en 2, y el enemigo 2 se marca. Entonces, puntos = 2, currentEnergy = 3, y enemigos marcados = [0, 2].
Primera operación en el enemigo 1: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 3, currentEnergy = 1, y enemigos marcados = [0, 2].

Ejemplo 2:

Entrada: enemyEnergies = [2], currentEnergy = 10
Salida: 5
Explicación:
Realizar la primera operación 5 veces en el enemigo 0 da como resultado el número máximo de puntos.

Restricciones:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

Se te da un conjunto de enteros enemyEnergies que denota los valores de energía de varios enemigos.
También se te da un entero currentEnergy que indica la cantidad de energía que tienes inicialmente.
Comienzas con 0 puntos, y todos los enemigos están sin marcar inicialmente.
Puedes realizar cualquiera de las siguientes operaciones cero o múltiples veces para ganar puntos:

Elige un enemigo no marcado, i, tal que currentEnergy >= enemyEnergies[i]. Al elegir esta opción:

Ganas 1 punto.
Tu energía se reduce por la energía del enemigo, es decir, currentEnergy = currentEnergy - enemyEnergies[i].

Si tienes al menos 1 punto, puedes elegir un enemigo no marcado, i. Al elegir esta opción:

Tu energía aumenta por la energía del enemigo, es decir, currentEnergy = currentEnergy + enemyEnergies[i].
El enemigo i se marca.

Devuelve un entero que denote el número máximo de puntos que puedes obtener al final realizando operaciones óptimamente.

Ejemplo 1:

Input: enemyEnergies = [3,2,2], currentEnergy = 2
Output: 3
Explicación:
Las siguientes operaciones se pueden realizar para obtener 3 puntos, que es el máximo:

Primera operación en el enemigo 1: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 1, y currentEnergy = 0.
Segunda operación en el enemigo 0: currentEnergy aumenta en 3, y el enemigo 0 se marca. Entonces, puntos = 1, currentEnergy = 3, y enemigos marcados = [0].
Primera operación en el enemigo 2: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 2, currentEnergy = 1, y enemigos marcados = [0].
Segunda operación en el enemigo 2: currentEnergy aumenta en 2, y el enemigo 2 se marca. Entonces, puntos = 2, currentEnergy = 3, y enemigos marcados = [0, 2].
Primera operación en el enemigo 1: los puntos aumentan en 1, y currentEnergy disminuye en 2. Entonces, puntos = 3, currentEnergy = 1, y enemigos marcados = [0, 2].

Ejemplo 2:

Input: enemyEnergies = [2], currentEnergy = 10
Output: 5
Explicación:
Realizar la primera operación 5 veces en el enemigo 0 da como resultado el número máximo de puntos.

Restricciones:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

Se te da una matriz de enteros enemyEnergies que denota los valores de energía de varios enemigos.
También se te da un entero EnergíaActual que denota la cantidad de energía que tienes inicialmente.
Empiezas con 0 puntos, y todos los enemigos están sin marcar inicialmente.
Puedes realizar cualquiera de las siguientes operaciones cero o múltiples veces para ganar puntos:

Elige un enemigo sin marcar, i, tal que Energíaactual >=Energíaenemigo[i]. Al elegir esta opción

Ganas 1 punto.
Tu energía se reduce por la energía del enemigo, es decir, Energíaactual = Energíaactual -Energíasenemigo[i].

Si tienes al menos 1 punto, puedes elegir un enemigo no marcado, i. Al elegir esta opción:

Tu energía aumenta por la energía del enemigo, es decir, Energíaactual = Energíaactual +Energíasenemigo[i].
El enemigo i queda marcado.

Devuelve un entero que denota el máximo de puntos que puedes conseguir al final realizando las operaciones de forma óptima.

Ejemplo 1:

Entrada: enemyEnergies = [3,2,2], currentEnergy = 2
Salida: 3
Explicación:
Se pueden realizar las siguientes operaciones para obtener 3 puntos, que es el máximo:

Primera operación en el enemigo 1: los puntos aumentan en 1, y la energía actual disminuye en 2. Por lo tanto, puntos = 1, y energía actual = 0.
Segunda operación sobre el enemigo 0: la energía actual aumenta en 3 y el enemigo 0 queda marcado. Entonces, puntos = 1, energía actual = 3, y enemigos marcados = [0].
Primera operación sobre el enemigo 2: los puntos aumentan en 1, y la energía actual disminuye en 2. Por tanto, puntos = 2, energía actual = 1, y enemigos marcados = [0].
Segunda operación sobre el enemigo 2: la energía actual aumenta en 2, y el enemigo 2 está marcado. Entonces, puntos = 2, energía actual = 3, y enemigos marcados = [0, 2].
Primera operación sobre el enemigo 1: los puntos aumentan en 1, y la energía actual disminuye en 2. Por tanto, puntos = 3, energía actual = 1, y enemigos marcados = [0, 2].

Ejemplo 2:

Entrada: enemyEnergies = [2], currentEnergy = 10
Salida: 5
Explicación:
Realizando la primera operación 5 veces sobre el enemigo 0 se obtiene el máximo número de puntos.

Restricciones:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9


Dado un arreglo de enteros `nums` y un entero `k`, devuelve el número de subarreglos de `nums` donde el AND bit a bit de los elementos del subarreglo es igual a `k`.

Ejemplo 1:

Entrada: `nums = [1,1,1]`, `k = 1`
Salida: 6
Explicación:
Todos los subarreglos contienen solo 1's.

Ejemplo 2:

Entrada: `nums = [1,1,2]`, `k = 1`
Salida: 3
Explicación:
Los subarreglos que tienen un valor AND de 1 son: `[1,1,2]`, `[1,1,2]`, `[1,1,2]`.

Ejemplo 3:

Entrada: `nums = [1,2,3]`, `k = 2`
Salida: 2
Explicación:
Los subarreglos que tienen un valor AND de 2 son: `[1,2,3]`, `[1,2,3]`.

Restricciones:

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

Dado un arreglo de números enteros nums y un número entero k, devuelve el número de submatrices de nums donde la operación AND bit a bit de los elementos de la submatriz es igual a k.

Ejemplo 1:

Entrada: nums = [1,1,1], k = 1
Salida: 6
Explicación:
Todas las submatrices contienen solo 1.

Ejemplo 2:

Entrada: nums = [1,1,2], k = 1
Salida: 3
Explicación:
Las submatrices que tienen un valor AND de 1 son: [1,1,2], [1,1,2], [1,1,2].

Ejemplo 3:

Entrada: nums = [1,2,3], k = 2
Salida: 2
Explicación:
Las submatrices que tienen un valor AND de 2 son: [1,2,3], [1,2,3].

Restricciones:

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


Se te dan dos enteros positivos x e y, que denotan el número de monedas con valores de 75 y 10 respectivamente.
Alicia y Bob están jugando un juego. En cada turno, comenzando con Alicia, el jugador debe recoger monedas con un valor total de 115. Si el jugador no puede hacerlo, pierde el juego.
Devuelve el nombre del jugador que gana el juego si ambos juegan de manera óptima.

Ejemplo 1:

Entrada: x = 2, y = 7
Salida: "Alice"
Explicación:
El juego termina en un solo turno:

Alicia toma 1 moneda con un valor de 75 y 4 monedas con un valor de 10.

Ejemplo 2:

Entrada: x = 4, y = 11
Salida: "Bob"
Explicación:
El juego termina en 2 turnos:

Alicia toma 1 moneda con un valor de 75 y 4 monedas con un valor de 10.
Bob toma 1 moneda con un valor de 75 y 4 monedas con un valor de 10.

Restricciones:

1 <= x, y <= 100

Se dan dos enteros positivos x e y, que denotan el número de monedas con valores 75 y 10 respectivamente.
Alice y Bob están jugando a un juego. En cada turno, empezando por Alice, el jugador debe recoger monedas con un valor total de 115. Si el jugador no puede hacerlo, pierde la partida.
Devuelve el nombre del jugador que gana la partida si ambos juegan de forma óptima.

Ejemplo 1:

Entrada: x = 2, y = 7
Salida: "Alicia"
Explicación:
El juego termina en un solo turno:

Alice coge 1 moneda de valor 75 y 4 monedas de valor 10.

Ejemplo 2:

Entrada: x = 4, y = 11
Salida: "Bob"
Explicación:
El juego termina en 2 turnos:

Alice elige 1 moneda de valor 75 y 4 monedas de valor 10.
Bob elige 1 moneda de valor 75 y 4 monedas de valor 10.

Restricciones:

1 <= x, y <= 100


Se te da una cadena s.
Puedes realizar el siguiente proceso en s cualquier número de veces:

Elige un índice i en la cadena tal que haya al menos un carácter a la izquierda del índice i que sea igual a s[i], y al menos un carácter a la derecha que también sea igual a s[i].
Elimina el carácter más cercano a la izquierda del índice i que sea igual a s[i].
Elimina el carácter más cercano a la derecha del índice i que sea igual a s[i].

Devuelve la longitud mínima de la cadena final s que puedes lograr.

Ejemplo 1:

Entrada: s = "abaacbcbb"
Salida: 5
Explicación:
Realizamos las siguientes operaciones:

Elige el índice 2, luego elimina los caracteres en los índices 0 y 3. La cadena resultante es s = "bacbcbb".
Elige el índice 3, luego elimina los caracteres en los índices 0 y 5. La cadena resultante es s = "acbcb".

Ejemplo 2:

Entrada: s = "aa"
Salida: 2
Explicación:
No podemos realizar ninguna operación, por lo que devolvemos la longitud de la cadena original.

Restricciones:

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

Se le proporciona una cadena s.
Puede realizar el siguiente proceso en s cualquier número de veces:

Elija un índice i en la cadena de modo que haya al menos un carácter a la izquierda del índice i que sea igual a s[i], y al menos un carácter a la derecha que también sea igual a s[i].
Elimine el carácter más cercano a la izquierda del índice i que sea igual a s[i].
Elimine el carácter más cercano a la derecha del índice i que sea igual a s[i].

Devuelva la longitud mínima de la cadena final s que puede lograr.

Ejemplo 1:

Entrada: s = "abaacbcbb"
Salida: 5
Explicación:
Realizamos las siguientes operaciones:

Elija el índice 2, luego elimine los caracteres en los índices 0 y 3. La cadena resultante es s = "bacbcbb".
Elija el índice 3, luego elimine los caracteres en los índices 0 y 5. La cadena resultante es s = "acbcb".

Ejemplo 2:

Entrada: s = "aa"
Salida: 2
Explicación:
No podemos realizar ninguna operación, por lo que devolvemos la longitud de la cadena original.

Restricciones:

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


Se te da un arreglo de enteros llamado nums de tamaño n donde n es par, y un entero k.
Puedes realizar algunos cambios en el arreglo, donde en un cambio puedes reemplazar cualquier elemento del arreglo con cualquier entero en el rango de 0 a k.
Necesitas realizar algunos cambios (posiblemente ninguno) de manera que el arreglo final satisfaga la siguiente condición:

Existe un entero X tal que abs(a[i] - a[n - i - 1]) = X para todo (0 <= i < n).

Devuelve el número mínimo de cambios requeridos para satisfacer la condición anterior.

Ejemplo 1:

Entrada: nums = [1,0,1,2,4,3], k = 4
Salida: 2
Explicación:
Podemos realizar los siguientes cambios:

Reemplazar nums[1] por 2. El arreglo resultante es nums = [1,2,1,2,4,3].
Reemplazar nums[3] por 3. El arreglo resultante es nums = [1,2,1,3,4,3].

El entero X será 2.

Ejemplo 2:

Entrada: nums = [0,1,2,3,3,6,5,4], k = 6
Salida: 2
Explicación:
Podemos realizar las siguientes operaciones:

Reemplazar nums[3] por 0. El arreglo resultante es nums = [0,1,2,0,3,6,5,4].
Reemplazar nums[4] por 4. El arreglo resultante es nums = [0,1,2,0,4,6,5,4].

El entero X será 4.

Restricciones:

2 <= n == nums.length <= 10^5
n es par.
0 <= nums[i] <= k <= 10^5

Se le da una matriz de números enteros de tamaño n donde n es par, y un número entero k.
Puede realizar algunos cambios en la matriz, donde en un cambio puede sustituir cualquier elemento de la matriz con cualquier número entero en el intervalo de 0 a k.
Es necesario realizar algunos cambios (posiblemente ninguno) para que la matriz final satisfaga la siguiente condición:

Existe un entero X tal que abs(a[i] - a[n - i - 1]) = X para todo (0 <= i < n).

Devuelve el número mínimo de cambios necesarios para satisfacer la condición anterior.

Ejemplo 1:

Entrada: nums = [1,0,1,2,4,3], k = 4
Salida: 2
Explicación:
Podemos realizar los siguientes cambios:

Sustituir nums[1] por 2. La matriz resultante es nums = [1,2,1,2,4,3].
Sustituir nums[3] por 3. La matriz resultante es nums = [1,2,1,3,4,3].

El entero X será 2.

Ejemplo 2:

Entrada: nums = [0,1,2,3,3,6,5,4], k = 6
Salida: 2
Explicación:
Podemos realizar las siguientes operaciones:

Sustituir nums[3] por 0. La matriz resultante es nums = [0,1,2,0,3,6,5,4].
Sustituir núm[4] por 4. La matriz resultante es núm = [0,1,2,0,4,6,5,4].

El número entero X será 4.

Restricciones:

2 <= n == nums.length <= 10^5
n es par.
0 <= nums[i] <= k <= 10^5

Se le proporciona una matriz de números enteros nums de tamaño n, donde n es par, y un número entero k.
Puede realizar algunos cambios en la matriz, donde en un cambio puede reemplazar cualquier elemento de la matriz con cualquier número entero en el rango de 0 a k.
Debe realizar algunos cambios (posiblemente ninguno) de modo que la matriz final satisfaga la siguiente condición:

Existe un número entero X tal que abs(a[i] - a[n - i - 1]) = X para todo (0 <= i < n).

Devuelve la cantidad mínima de cambios necesarios para satisfacer la condición anterior.

Ejemplo 1:

Entrada: nums = [1,0,1,2,4,3], k = 4
Salida: 2
Explicación:
Podemos realizar los siguientes cambios:

Reemplazar nums[1] por 2. La matriz resultante es nums = [1,2,1,2,4,3].
Reemplace nums[3] por 3. La matriz resultante es nums = [1,2,1,3,4,3].

El entero X será 2.

Ejemplo 2:

Entrada: nums = [0,1,2,3,3,6,5,4], k = 6
Salida: 2
Explicación:
Podemos realizar las siguientes operaciones:

Reemplace nums[3] por 0. La matriz resultante es nums = [0,1,2,0,3,6,5,4].
Reemplace nums[4] por 4. La matriz resultante es nums = [0,1,2,0,4,6,5,4].

El entero X será 4.

Restricciones:

2 <= n == nums.length <= 10^5
n es par.
0 <= nums[i] <= k <= 10^5


Se te da un entero n que representa el número de jugadores en un juego y un array 2D pick donde pick[i] = [x_i, y_i] representa que el jugador x_i eligió una bola de color y_i.
El jugador i gana el juego si elige estrictamente más de i bolas del mismo color. En otras palabras,

El jugador 0 gana si elige cualquier bola.
El jugador 1 gana si elige al menos dos bolas del mismo color.
...
El jugador i gana si elige al menos i + 1 bolas del mismo color.

Devuelve el número de jugadores que ganan el juego.
Ten en cuenta que múltiples jugadores pueden ganar el juego.

Ejemplo 1:

Entrada: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Salida: 2
Explicación:
El jugador 0 y el jugador 1 ganan el juego, mientras que los jugadores 2 y 3 no ganan.

Ejemplo 2:

Entrada: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Salida: 0
Explicación:
Ningún jugador gana el juego.

Ejemplo 3:

Entrada: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Salida: 1
Explicación:
El jugador 2 gana el juego al elegir 3 bolas de color 4.

Restricciones:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10

Se te da un entero n que representa el número de jugadores en un juego y un array 2D pick donde pick[i] = [x_i, y_i] representa que el jugador x_i eligió una bola de color y_i.
El jugador i gana el juego si selecciona estrictamente más de i bolas del mismo color. En otras palabras,

El jugador 0 gana si selecciona cualquier bola.
El jugador 1 gana si selecciona al menos dos bolas del mismo color.
...
El jugador i gana si selecciona al menos i + 1 bolas del mismo color.

Devuelve el número de jugadores que ganan el juego.
Ten en cuenta que múltiples jugadores pueden ganar el juego.

Ejemplo 1:

Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Output: 2
Explicación:
El jugador 0 y el jugador 1 ganan el juego, mientras que los jugadores 2 y 3 no ganan.

Ejemplo 2:

Input: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Output: 0
Explicación:
Ningún jugador gana el juego.

Ejemplo 3:

Input: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Output: 1
Explicación:
El jugador 2 gana el juego al elegir 3 bolas de color 4

Restricciones:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10

Se le proporciona un entero n que representa la cantidad de jugadores en un juego y una matriz 2D pick donde pick[i] = [x_i, y_i] representa que el jugador x_i eligió una bola de color y_i.
El jugador i gana el juego si elige estrictamente más de i bolas del mismo color. En otras palabras,

El jugador 0 gana si elige cualquier bola.
El jugador 1 gana si elige al menos dos bolas del mismo color.
...
El jugador i gana si elige al menos i + 1 bolas del mismo color.

Devuelve la cantidad de jugadores que ganan el juego.
Tenga en cuenta que varios jugadores pueden ganar el juego.

Ejemplo 1:

Entrada: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Salida: 2
Explicación:
El jugador 0 y el jugador 1 ganan el juego, mientras que los jugadores 2 y 3 no ganan.

Ejemplo 2:

Entrada: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Salida: 0
Explicación:
Ningún jugador gana el juego.

Ejemplo 3:

Entrada: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Salida: 1
Explicación:
El jugador 2 gana el juego al elegir 3 bolas de color 4.

Restricciones:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10


Se te da una matriz binaria de m x n, grid.
Una fila o columna se considera palindrómica si sus valores se leen igual de adelante hacia atrás y viceversa.
Puedes voltear cualquier número de celdas en grid de 0 a 1, o de 1 a 0.
Devuelve el número mínimo de celdas que deben voltearse para que todas las filas o todas las columnas sean palindrómicas.

Ejemplo 1:

Entrada: grid = [[1,0,0],[0,0,0],[0,0,1]]
Salida: 2
Explicación:

Volteando las celdas resaltadas se hace que todas las filas sean palindrómicas.

Ejemplo 2:

Entrada: grid = [[0,1],[0,1],[0,0]]
Salida: 1
Explicación:

Volteando la celda resaltada se hace que todas las columnas sean palindrómicas.

Ejemplo 3:

Entrada: grid = [[1],[0]]
Salida: 0
Explicación:
Todas las filas ya son palindrómicas.

Restricciones:

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

Se le proporciona una cuadrícula de matriz binaria de m x n.
Una fila o columna se considera palindrómica si sus valores se leen de la misma manera hacia adelante y hacia atrás.
Puede invertir cualquier cantidad de celdas en la cuadrícula de 0 a 1 o de 1 a 0.
Devuelve la cantidad mínima de celdas que se deben invertir para que todas las filas o todas las columnas sean palindrómicas.

Ejemplo 1:

Entrada: grid = [[1,0,0],[0,0,0],[0,0,1]]
Salida: 2
Explicación:

Invertir las celdas resaltadas hace que todas las filas sean palindrómicas.

Ejemplo 2:

Entrada: grid = [[0,1],[0,1],[0,0]]
Salida: 1
Explicación:

Invertir la celda resaltada hace que todas las columnas sean palindrómicas.

Ejemplo 3:

Entrada: grid = [[1],[0]]
Salida: 0
Explicación:
Todas las filas ya son palindrómicas.

Restricciones:

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

Se le da una rejilla de matriz binaria de m x n.
Una fila o columna se considera palindrómica si sus valores se leen igual hacia delante y hacia atrás.
Puede voltear cualquier número de celdas en la cuadrícula de 0 a 1, o de 1 a 0.
Devuelve el número mínimo de celdas que hay que voltear para que todas las filas o todas las columnas sean palindrómicas.

Ejemplo 1

Entrada: grid = [[1,0,0],[0,0,0],[0,0,1]]
Salida: 2
Explicación:

Al voltear las celdas resaltadas todas las filas quedan palindrómicas.

Ejemplo 2:

Entrada: grid = [[0,1],[0,1],[0,0]]
Salida: 1
Explicación:

Al voltear la celda resaltada todas las columnas quedan palindrómicas.

Ejemplo 3:

Entrada: grid = [[1],[0]]
Salida: 0
Explicación:
Todas las filas ya son palindrómicas.

Restricciones:

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


Existe un árbol no dirigido con n nodos numerados de 0 a n - 1. Se te da un array 2D de enteros llamado edges de longitud n - 1, donde edges[i] = [u_i, v_i] indica que hay un borde entre los nodos u_i y v_i en el árbol.
Inicialmente, todos los nodos no están marcados. Para cada nodo i:

Si i es impar, el nodo se marcará en el tiempo x si hay al menos un nodo adyacente a él que fue marcado en el tiempo x - 1.
Si i es par, el nodo se marcará en el tiempo x si hay al menos un nodo adyacente a él que fue marcado en el tiempo x - 2.

Devuelve un array times donde times[i] es el tiempo en el que todos los nodos se marcan en el árbol, si marcas el nodo i en el tiempo t = 0.
Nota que la respuesta para cada times[i] es independiente, es decir, cuando marcas el nodo i, todos los demás nodos están sin marcar.

Ejemplo 1:

Entrada: edges = [[0,1],[0,2]]
Salida: [2,4,3]
Explicación:

Para i = 0:

El nodo 1 se marca en t = 1, y el nodo 2 en t = 2.

Para i = 1:

El nodo 0 se marca en t = 2, y el nodo 2 en t = 4.

Para i = 2:

El nodo 0 se marca en t = 2, y el nodo 1 en t = 3.

Ejemplo 2:

Entrada: edges = [[0,1]]
Salida: [1,2]
Explicación:

Para i = 0:

El nodo 1 se marca en t = 1.

Para i = 1:

El nodo 0 se marca en t = 2.

Ejemplo 3:

Entrada: edges = [[2,4],[0,1],[2,3],[0,2]]
Salida: [4,6,3,5,5]
Explicación:

Restricciones:

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
La salida se genera de manera que edges representa un árbol válido.

Existe un árbol no dirigido con n nodos numerados de 0 a n - 1. Se le da un array entero 2D aristas de longitud n - 1, donde edges[i] = [u_i, v_i] indica que existe una arista entre los nodos u_i y v_i en el árbol.
Inicialmente, todos los nodos están sin marcar. Para cada nodo i

Si i es impar, el nodo se marcará en el momento x si hay al menos un nodo adyacente que se marcó en el momento x - 1.
Si i es par, el nodo se marcará en el momento x si hay al menos un nodo adyacente que se marcó en el momento x - 2.

Devuelve un array times donde times[i] es el momento en que se marcan todos los nodos del árbol, si se marca el nodo i en el tiempo t = 0.
Nótese que la respuesta para cada times[i] es independiente, es decir, cuando marcas el nodo i todos los demás nodos quedan sin marcar.

Ejemplo 1

Entrada: edges = [[0,1],[0,2]]
Salida: [2,4,3]
Explicación:

Para i = 0

El nodo 1 se marca en t = 1, y el nodo 2 en t = 2.

Para i = 1:

El nodo 0 se marca en t = 2, y el nodo 2 en t = 4.

Para i = 2:

El nodo 0 se marca en t = 2 y el nodo 1 en t = 3.

Ejemplo 2:

Entrada: edges = [[0,1]]
Salida: [1,2]
Explicación:

Para i = 0:

El nodo 1 se marca en t = 1.

Para i = 1:

El nodo 0 está marcado en t = 2.

Ejemplo 3:

Entrada: edges = [[2,4],[0,1],[2,3],[0,2]]
Salida: [4,6,3,5,5]
Explicación:

Restricciones:

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
La entrada se genera de forma que las aristas representen un árbol válido.

Existe un árbol no dirigido con n nodos numerados de 0 a n - 1. Se le proporciona una matriz de enteros 2D edges de longitud n - 1, donde edges[i] = [u_i, v_i] indica que hay una arista entre los nodos u_i y v_i en el árbol.
Inicialmente, todos los nodos están desmarcados. Para cada nodo i:

Si i es impar, el nodo se marcará en el momento x si hay al menos un nodo adyacente a él que se marcó en el momento x - 1.
Si i es par, el nodo se marcará en el momento x si hay al menos un nodo adyacente a él que se marcó en el momento x - 2.

Devuelva una matriz times donde times[i] es el momento en el que se marcan todos los nodos en el árbol, si marca el nodo i en el momento t = 0.
Tenga en cuenta que la respuesta para cada times[i] es independiente, es decir, cuando marca el nodo i, todos los demás nodos quedan desmarcados.

Ejemplo 1:

Entrada: edges = [[0,1],[0,2]]
Salida: [2,4,3]
Explicación:

Para i = 0:

El nodo 1 está marcado en t = 1 y el nodo 2 en t = 2.

Para i = 1:

El nodo 0 está marcado en t = 2 y el nodo 2 en t = 4.

Para i = 2:

El nodo 0 está marcado en t = 2 y el nodo 1 en t = 3.

Ejemplo 2:

Entrada: edges = [[0,1]]
Salida: [1,2]
Explicación:

Para i = 0:

El nodo 1 está marcado en t = 1.

Para i = 1:

El nodo 0 está marcado en t = 2.

Ejemplo 3:

Entrada: edges = [[2,4],[0,1],[2,3],[0,2]]
Salida: [4,6,3,5,5]
Explicación:

Restricciones:

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
La entrada se genera de modo que edges represente un árbol válido.


Se te dan \(N\) funciones lineales \(f_1, f_2, \ldots, f_N\), donde \(f_i(x) = A_i x + B_i\).
Encuentra el valor máximo posible de \(f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots ))\) para una secuencia \(p = (p_1, p_2, \ldots, p_K)\) de \(K\) enteros distintos entre 1 y \(N\), inclusive.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
\(N\) \(K\)
\(A_1\) \(B_1\)
\(A_2\) \(B_2\)
\vdots
\(A_N\) \(B_N\)

Salida

Imprime la respuesta como un entero.

Restricciones

- \(1 \leq N \leq 2 \times 10^{5}\)
- \(1 \leq K \leq \text{min}(N,10)\)
- \(1 \leq A_i, B_i \leq 50\) \( (1 \leq i \leq N) \)
- Todos los valores de entrada son enteros.

Entrada de muestra 1

3 2
2 3
1 5
4 2

Salida de muestra 1

26

Aquí están todos los posibles \(p\) y los valores correspondientes de \(f_{p_1}(f_{p_2}(1))\):

- \(p= ( 1,2 )\) : \(f_1(f_2(1))=15\)
- \(p= ( 1,3 )\) : \(f_1(f_3(1))=15\)
- \(p= ( 2,1 )\) : \(f_2(f_1(1))=10\)
- \(p= ( 2,3 )\) : \(f_2(f_3(1))=11\)
- \(p= ( 3,1 )\) : \(f_3(f_1(1))=22\)
- \(p= ( 3,2 )\) : \(f_3(f_2(1))=26\)

Por lo tanto, imprime 26.

Entrada de muestra 2

10 3
48 40
34 22
24 37
45 40
48 31
49 44
45 40
44 6
35 22
39 28

Salida de muestra 2

216223

Se te dan N funciones lineales f_1, f_2, \ldots, f_N, donde f_i(x) = A_i x + B_i.
Encuentra el valor máximo posible de f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) para una secuencia p = (p_1, p_2, \ldots, p_K) de K enteros distintos entre 1 y N, inclusive.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Salida

Imprime la respuesta como un entero.

Restricciones

- 1 \leq N \leq 2 \times 10^{5}
- 1 \leq K \leq \text{min}(N,10)
- 1 \leq A_i, B_i \leq 50  (1 \leq i \leq N)
- Todos los valores de entrada son enteros.

Entrada de Ejemplo 1

3 2
2 3
1 5
4 2

Salida de Ejemplo 1

26

Aquí están todos los posibles p y los valores correspondientes de f_{p_1}(f_{p_2}(1)):

- p= ( 1,2 ) : f_1(f_2(1))=15
- p= ( 1,3 ) : f_1(f_3(1))=15
- p= ( 2,1 ) : f_2(f_1(1))=10
- p= ( 2,3 ) : f_2(f_3(1))=11
- p= ( 3,1 ) : f_3(f_1(1))=22
- p= ( 3,2 ) : f_3(f_2(1))=26

Por lo tanto, imprime 26.

Entrada de Ejemplo 2

10 3
48 40
34 22
24 37
45 40
48 31
49 44
45 40
44 6
35 22
39 28

Salida de Ejemplo 2

216223

Se le proporcionan N funciones lineales f_1, f_2, \ldots, f_N, donde f_i(x) = A_i x + B_i.
Encuentre el valor máximo posible de f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) para una secuencia p = (p_1, p_2, \ldots, p_K) de K enteros distintos entre 1 y N, inclusive.

Entrada

La entrada se proporciona desde la Entrada estándar en el siguiente formato:
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Salida

Imprima la respuesta como un entero.

Restricciones

- 1 \leq N \leq 2 \times 10^{5}
- 1 \leq K \leq \text{min}(N,10)
- 1 \leq A_i, B_i \leq 50 (1 \leq i \leq N)
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

3 2
2 3
1 5
4 2

Salida de muestra 1

26

A continuación se muestran todos los valores p posibles y los valores correspondientes de f_{p_1}(f_{p_2}(1)):

- p= ( 1,2 ) : f_1(f_2(1))=15
- p= ( 1,3 ) : f_1(f_3(1))=15
- p= ( 2,1 ) : f_2(f_1(1))=10
- p= ( 2,3 ) : f_2(f_3(1))=11
- p= ( 3,1 ) : f_3(f_1(1))=22
- p= ( 3,2 ) : f_3(f_2(1))=26

Por lo tanto, imprima 26.

Entrada de muestra 2

10 3
48 40
34 22
24 37
45 40
48 31
49 44
45 40
44 6
35 22
39 28

Salida de muestra 2

216223


Se te da un texto escrito horizontalmente. Conviértelo en escritura vertical, llenando espacios con *.

Se te dan N cadenas S_1, S_2, \dots, S_N que consisten en letras minúsculas en inglés. Sea M la longitud máxima de estas cadenas.
Imprime M cadenas T_1, T_2, \dots, T_M que satisfacen las siguientes condiciones:

- Cada T_i consta de letras minúsculas en inglés y *.
- Ninguna T_i termina con *.
- Para cada 1 \leq i \leq N, se cumple lo siguiente:
- Para cada 1 \leq j \leq |S_i|, el (N-i+1)-ésimo carácter de T_j existe, y la concatenación de los (N-i+1)-ésimos caracteres de T_1, T_2, \dots, T_{|S_i|} en este orden es igual a S_i.
- Para cada |S_i| + 1 \leq j \leq M, el (N-i+1)-ésimo carácter de T_j o no existe o es *.

Aquí, |S_i| denota la longitud de la cadena S_i.

Entrada

La entrada se da desde la entrada estándar en el siguiente formato:
N
S_1
S_2
\vdots
S_N

Salida

Imprime la respuesta en el siguiente formato:
T_1
T_2
\vdots
T_M

Restricciones

- N es un entero entre 1 y 100, inclusive.
- Cada S_i es una cadena de letras minúsculas en inglés con una longitud entre 1 y 100, inclusive.

Ejemplo de entrada 1

3
abc
de
fghi

Ejemplo de salida 1

fda
geb
h*c
i

Colocar * como el segundo carácter de T_3 pone la c en la posición correcta.
Por otro lado, colocar * como los caracteres segundo y tercero de T_4 haría que T_4 termine con *, lo cual viola la condición.

Ejemplo de entrada 2

3
atcoder
beginner
contest

Ejemplo de salida 2

cba
oet
ngc
tio
end
sne
ter
*r

Se le proporciona un texto escrito horizontalmente. Conviértalo a escritura vertical, llenando los espacios con *.

Se le proporcionan N cadenas S_1, S_2, \dots, S_N que consisten en letras minúsculas en inglés. Sea M la longitud máxima de estas cadenas.
Imprima M cadenas T_1, T_2, \dots, T_M que satisfacen las siguientes condiciones:

- Cada T_i consiste en letras minúsculas en inglés y *.
- Cada T_i no termina con *.
- Para cada 1 \leq i \leq N, se cumple lo siguiente:
- Para cada 1 \leq j \leq |S_i|, existe el (N-i+1)-ésimo carácter de T_j, y la concatenación de los (N-i+1)-ésimos caracteres de T_1, T_2, \dots, T_{|S_i|} en este orden es igual a S_i.
- Para cada |S_i| + 1 \leq j \leq M, el carácter (N-i+1)-ésimo de T_j no existe o es *.

Aquí, |S_i| denota la longitud de la cadena S_i.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N
S_1
S_2
\vdots
S_N

Salida

Imprima la respuesta en el siguiente formato:
T_1
T_2
\vdots
T_M

Restricciones

- N es un entero entre 1 y 100, inclusive.
- Cada S_i es una cadena de letras minúsculas en inglés con una longitud entre 1 y 100, inclusive.

Entrada de muestra 1

3
abc
de
fghi

Salida de muestra 1

fda
geb
h*c
i

Colocar * como el segundo carácter de T_3 coloca la c en la posición correcta.
Por otro lado, si se coloca * como el segundo y tercer carácter de T_4, T_4 terminaría con *, lo que viola la condición.

Entrada de muestra 2

3
atcoder
beginner
contest

Salida de muestra 2

cba
oet
ngc
tio
end
sne
ter
*r


Se te dan N puntos (x1, y_1), (x_2, y_2), \dots, (x_N, y_N) en un plano bidimensional, y un entero no negativo D.
Encuentra el número de pares de enteros (x, y) tales que \displaystyle \sum{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Salida

Imprime la respuesta.

Restricciones

1 \leq N \leq 2 \times 10^5
0 \leq D \leq 10^6
-10^6 \leq x_i, y_i \leq 10^6
(x_i, y_i) \neq (x_j, y_j) para i \neq j.
Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

2 3
0 0
1 0

Ejemplo de Salida 1

8

La figura siguiente visualiza la entrada y la respuesta para el Ejemplo 1. Los puntos azules representan la entrada. Los puntos azules y rojos, ocho en total, satisfacen la condición en el enunciado.

Ejemplo de Entrada 2

2 0
0 0
2 0

Ejemplo de Salida 2

0

Ejemplo de Entrada 3

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

Ejemplo de Salida 3

419

Se te dan N puntos (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) en un plano bidimensional, y un entero no negativo D.
Encuentra el número de pares de enteros (x, y) tales que \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrada

La entrada se proporciona desde la Entrada Estándar en el siguiente formato:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Salida

Imprime la respuesta.

Restricciones

- 1 \leq N \leq 2 \times 10^5
- 0 \leq D \leq 10^6
- -10^6 \leq x_i, y_i \leq 10^6
- (x_i, y_i) \neq (x_j, y_j) para i \neq j.
- Todos los valores de entrada son enteros.

Ejemplo de Entrada 1

2 3
0 0
1 0

Ejemplo de Salida 1

8

La figura siguiente visualiza la entrada y la respuesta para el Ejemplo 1. Los puntos azules representan la entrada. Los puntos azules y rojos, ocho en total, satisfacen la condición en el enunciado.

Ejemplo de Entrada 2

2 0
0 0
2 0

Ejemplo de Salida 2

0

Ejemplo de Entrada 3

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

Ejemplo de Salida 3

419

Se dan N puntos (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) en un plano bidimensional, y un entero no negativo D.
Encontrar el número de pares de enteros (x, y) tal que \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrada

La entrada se da desde Standard Input en el siguiente formato:
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Salida

Imprime la respuesta.

Restricciones

- 1 \leq N \leq 2 \times 10^5
- 0 \leq D \leq 10^6
- -10^6 \leq x_i, y_i \leq 10^6
- (x_i, y_i) \neq (x_j, y_j) for i \neq j.
- Todos los valores de entrada son enteros.

Ejemplo de entrada 1

2 3
0 0
1 0

Salida de muestra 1

8

La siguiente figura visualiza la entrada y la respuesta para la Muestra 1. Los puntos azules representan la entrada. Los puntos azules y rojos, ocho en total, satisfacen la condición del enunciado.

Muestra Entrada 2

2 0
0 0
2 0

Muestra de salida 2

0

Entrada de muestra 3

6 100
9 -6
10 -1
2 10
-1 7
-7 5
-1 -4

Muestra de salida 3

419


Se le proporciona un entero positivo N y un entero A_{x,y,z} por cada triple de enteros (x, y, z) tales que 1 \leq x, y, z \leq N.
Se le proporcionarán Q consultas en el siguiente formato, que deben procesarse en orden.
Para la i-ésima consulta (1 \leq i \leq Q), se le proporciona una tupla de números enteros (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i) tales que 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, y 1 \leq Lz_i \leq Rz_i \leq N. Encuentre:
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N
A_{1,1,1} A_{1,1,2} \ldots A_{1,1,N}
A_{1,2,1} A_{1,2,2} \ldots A_{1,2,N}
\vdots
A_{1,N,1} A_{1,N,2} \ldots A_{1,N,N}
A_{2,1,1} A_{2,1,2} \ldots A_{2,1,N}
A_{2,2,1} A_{2,2,2} \ldots A_{2,2,N}
\vdots
A_{2,N,1} A_{2,N,2} \ldots A_{2,N,N}
\vdots
A_{N,1,1} A_{N,1,2} \ldots A_{N,1,N}
A_{N,2,1} A_{N,2,2} \ldots A_{N,2,N}
\vdots
A_{N,N,1} A_{N,N,2} \ldots A_{N,N,N}
Q
Lx_1 Rx_1 Ly_1 Ry_1 Lz_1 Rz_1
Lx_2 Rx_2 Ly_2 Ry_2 Lz_2 Rz_2
\vdots
Lx_Q Rx_Q Ly_Q Ry_Q Lz_Q Rz_Q

Salida

Imprime Q líneas.
La i-ésima línea debe contener la respuesta a la i-ésima consulta.

Restricciones

- 1 \leq N \leq 100
- 1 \leq Q \leq 2 \times 10^{5}
- 0 \leq A_{x,y,z} \leq 999 (1 \leq x, y, z \leq N)
- 1 \leq Lx_i \leq Rx_i \leq N (1 \leq i \leq Q)
- 1 \leq Ly_i \leq Ry_i \leq N (1 \leq i \leq Q)
- 1 \leq Lz_i \leq Rz_i \leq N (1 \leq i \leq Q)
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

2
1 2
3 4
5 6
7 8
2
1 2 2 2 1 1
2 2 1 2 1 2

Salida de muestra 1

10
26

Para la primera consulta, el valor buscado es A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Por lo tanto, imprima 10.
Para la segunda consulta, el valor buscado es A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Por lo tanto, imprima 26.

Entrada de muestra 2

3
733 857 714
956 208 257
123 719 648
840 881 245
245 112 746
306 942 694
58 870 849
13 208 789
687 906 783
8
3 3 3 3 1 1
1 3 2 3 3 3
2 2 2 3 1 1
1 3 1 1 1 1
2 3 2 3 2 3
1 2 1 1 1 2
3 3 2 2 1 3
1 2 2 3 2 3

Salida de muestra 2

687
3917
551
1631
5180
3311
1010
4326

Se te da un entero positivo N y un entero A_{x,y,z} para cada triplete de enteros (x, y, z) tal que 1 \leq x, y, z \leq N.
Se te darán Q consultas en el siguiente formato, que deben ser procesadas en orden.
Para la i-ésima consulta (1 \leq i \leq Q), se te da una tupla de enteros (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i) tal que 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, y 1 \leq Lz_i \leq Rz_i \leq N. Encontrar:
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Entrada

La entrada se da de la siguiente manera desde la Entrada Estándar:
N
A_{1,1,1} A_{1,1,2} \ldots A_{1,1,N}
A_{1,2,1} A_{1,2,2} \ldots A_{1,2,N}
\vdots
A_{1,N,1} A_{1,N,2} \ldots A_{1,N,N}
A_{2,1,1} A_{2,1,2} \ldots A_{2,1,N}
A_{2,2,1} A_{2,2,2} \ldots A_{2,2,N}
\vdots
A_{2,N,1} A_{2,N,2} \ldots A_{2,N,N}
\vdots
A_{N,1,1} A_{N,1,2} \ldots A_{N,1,N}
A_{N,2,1} A_{N,2,2} \ldots A_{N,2,N}
\vdots
A_{N,N,1} A_{N,N,2} \ldots A_{N,N,N}
Q
Lx_1 Rx_1 Ly_1 Ry_1 Lz_1 Rz_1
Lx_2 Rx_2 Ly_2 Ry_2 Lz_2 Rz_2
\vdots
Lx_Q Rx_Q Ly_Q Ry_Q Lz_Q Rz_Q

Salida

Imprimir Q líneas. La i-ésima línea debe contener la respuesta a la i-ésima consulta.

Restricciones

- 1 \leq N \leq 100
- 1 \leq Q \leq 2 \times 10^{5}
- 0 \leq A_{x,y,z} \leq 999 (1 \leq x, y, z \leq N)
- 1 \leq Lx_i \leq Rx_i \leq N (1 \leq i \leq Q)
- 1 \leq Ly_i \leq Ry_i \leq N (1 \leq i \leq Q)
- 1 \leq Lz_i \leq Rz_i \leq N (1 \leq i \leq Q)
- Todos los valores de entrada son enteros.

Entrada de ejemplo 1

2
1 2
3 4
5 6
7 8
2
1 2 2 2 1 1
2 2 1 2 1 2

Salida de ejemplo 1

10
26

Para la 1ª consulta, el valor buscado es A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Por lo tanto, imprimir 10.
Para la 2ª consulta, el valor buscado es A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Por lo tanto, imprimir 26.

Entrada de ejemplo 2

3
733 857 714
956 208 257
123 719 648
840 881 245
245 112 746
306 942 694
58 870 849
13 208 789
687 906 783
8
3 3 3 3 1 1
1 3 2 3 3 3
2 2 2 3 1 1
1 3 1 1 1 1
2 3 2 3 2 3
1 2 1 1 1 2
3 3 2 2 1 3
1 2 2 3 2 3

Salida de ejemplo 1

687
3917
551
1631
5180
3311
1010
4326

Se te da un entero positivo N y un entero A_{x,y,z} para cada triplete de enteros (x, y, z) tal que 1 \leq x, y, z \leq N.
Se te darán Q consultas en el siguiente formato, que deben ser procesadas en orden.
Para la i-ésima consulta (1 \leq i \leq Q), se te da una tupla de enteros (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i) tal que 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, y 1 \leq Lz_i \leq Rz_i \leq N. Encontrar:
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Entrada

La entrada se da de la siguiente manera desde la entrada estándar:
N
A_{1,1,1} A_{1,1,2} \ldots A_{1,1,N}
A_{1,2,1} A_{1,2,2} \ldots A_{1,2,N}
\vdots
A_{1,N,1} A_{1,N,2} \ldots A_{1,N,N}
A_{2,1,1} A_{2,1,2} \ldots A_{2,1,N}
A_{2,2,1} A_{2,2,2} \ldots A_{2,2,N}
\vdots
A_{2,N,1} A_{2,N,2} \ldots A_{2,N,N}
\vdots
A_{N,1,1} A_{N,1,2} \ldots A_{N,1,N}
A_{N,2,1} A_{N,2,2} \ldots A_{N,2,N}
\vdots
A_{N,N,1} A_{N,N,2} \ldots A_{N,N,N}
Q
Lx_1 Rx_1 Ly_1 Ry_1 Lz_1 Rz_1
Lx_2 Rx_2 Ly_2 Ry_2 Lz_2 Rz_2
\vdots
Lx_Q Rx_Q Ly_Q Ry_Q Lz_Q Rz_Q

Salida

Imprimir Q líneas. La i-ésima línea debe contener la respuesta a la i-ésima consulta.

Restricciones

- 1 \leq N \leq 100
- 1 \leq Q \leq 2 \times 10^{5}
- 0 \leq A_{x,y,z} \leq 999 (1 \leq x, y, z \leq N)
- 1 \leq Lx_i \leq Rx_i \leq N (1 \leq i \leq Q)
- 1 \leq Ly_i \leq Ry_i \leq N (1 \leq i \leq Q)
- 1 \leq Lz_i \leq Rz_i \leq N (1 \leq i \leq Q)
- Todos los valores de entrada son enteros.

Entrada de ejemplo 1

2
1 2
3 4
5 6
7 8
2
1 2 2 2 1 1
2 2 1 2 1 2

Salida de ejemplo 1

10
26

Para la 1ª consulta, el valor buscado es A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Por lo tanto, imprimir 10.
Para la 2ª consulta, el valor buscado es A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Por lo tanto, imprimir 26.

Entrada de ejemplo 2

3
733 857 714
956 208 257
123 719 648
840 881 245
245 112 746
306 942 694
58 870 849
13 208 789
687 906 783
8
3 3 3 3 1 1
1 3 2 3 3 3
2 2 2 3 1 1
1 3 1 1 1 1
2 3 2 3 2 3
1 2 1 1 1 2
3 3 2 2 1 3
1 2 2 3 2 3

Salida de ejemplo 1

687
3917
551
1631
5180
3311
1010
4326


Se está llevando a cabo una elección para alcalde en la Ciudad AtCoder. Los candidatos son Takahashi y Aoki.
Se emitieron N votos válidos para uno de los dos candidatos, y el conteo de votos está en curso. Aquí, N es un número impar.
La cuenta actual de votos es T para Takahashi y A para Aoki.
Determina si el resultado de la elección ya está decidido en este momento.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N T A

Salida

Imprime Yes si el resultado de la elección ya está decidido, y No en caso contrario.

Restricciones

- 1 \leq N \leq 99
- N es un número impar.
- 0 \leq T, A \leq N
- T + A \leq N
- Todos los valores de entrada son enteros.

Entrada de ejemplo 1

7 4 2

Salida de ejemplo 1

Yes

Incluso si el voto restante va a Aoki, Takahashi aún ganará. Es decir, su victoria está decidida, por lo que imprime Yes.

Entrada de ejemplo 2

99 12 48

Salida de ejemplo 2

No

Aunque Aoki actualmente tiene más votos, Takahashi ganaría si recibe los 39 votos restantes. Por lo tanto, imprime No.

Entrada de ejemplo 3

1 0 0

Salida de ejemplo 3

No

Se están celebrando elecciones para alcalde en AtCoder City. Los candidatos son Takahashi y Aoki.
Hay N votos válidos emitidos para cualquiera de los dos candidatos y el recuento está en curso. Aquí, N es un número impar.
El recuento de votos actual es T votos para Takahashi y A votos para Aoki.
Determina si el resultado de la elección ya está decidido en este momento.

Entrada

La entrada se proporciona a partir de la entrada estándar en el siguiente formato:
N T A

Salida

Escribe Yes si el resultado de la elección ya está decidido y No en caso contrario.

Restricciones

- 1 \leq N \leq 99
- N is an odd number.
- 0 \leq T, A \leq N
- T + A \leq N
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

7 4 2

Salida de muestra 1

Yes

Incluso si el voto restante va para Aoki, Takahashi ganará. Es decir, su victoria está decidida, por lo que se imprime Sí.

Entrada de muestra 2

99 12 48

Salida de muestra 2

No

Aunque Aoki tiene actualmente más votos, Takahashi ganaría si recibiera los 39 votos restantes. Por lo tanto, se imprime No.

Entrada de muestra 3

1 0 0

Salida de muestra 3

No


Tienes una bolsa vacía.
Se te dan Q consultas, que deben procesarse en orden.
Hay tres tipos de consultas.

- 1 x : Coloca una bola con el entero x escrito en ella dentro de la bolsa.
- 2 x : Retira una bola con el entero x escrito en ella de la bolsa y descártala. Se garantiza que la bolsa tiene una bola con el entero x escrito en ella cuando se da esta consulta.
- 3 : Imprime el número de enteros diferentes escritos en las bolas de la bolsa.

Entrada

La entrada se proporciona desde la Entrada Estándar en el siguiente formato:
Q
\text{consulta}_1
\text{consulta}_2
\vdots
\text{consulta}_Q

La i-ésima consulta \text{consulta}_i se da en uno de los siguientes tres formatos:
1 x

2 x

3

Salida

Si hay K consultas del tercer tipo, imprime K líneas.
La i-ésima línea (1 \leq i \leq K) debe contener la respuesta a la i-ésima consulta del tercer tipo.

Restricciones

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Cuando se da una consulta del segundo tipo, la bolsa tiene una bola con el entero x escrito en ella.
- Hay al menos una consulta del tercer tipo.
- Todos los valores de entrada son enteros.

Entrada de Ejemplo 1

8
1 3
1 1
1 4
3
2 1
3
1 5
3

Salida de Ejemplo 1

3
2
3

Inicialmente, la bolsa está vacía.
Para la primera consulta 1 3, una bola con el entero 3 escrito en ella entra en la bolsa.
Para la segunda consulta 1 1, una bola con el entero 1 escrito en ella entra en la bolsa.
Para la tercera consulta 1 4, una bola con el entero 4 escrito en ella entra en la bolsa.
Para la cuarta consulta 3, la bolsa tiene bolas con los enteros 1, 3, 4, por lo que imprime 3.
Para la quinta consulta 2 1, una bola con el entero 1 escrito en ella se elimina de la bolsa.
Para la sexta consulta 3, la bolsa tiene bolas con los enteros 3, 4, por lo que imprime 2.
Para la séptima consulta 1 5, una bola con el entero 5 escrito en ella entra en la bolsa.
Para la octava consulta 3, la bolsa tiene bolas con los enteros 3, 4, 5, por lo que imprime 3.

Entrada de Ejemplo 2

8
1 2
1 2
3
2 2
1 4
1 4
2 2
3

Salida de Ejemplo 2

1
1

Tienes una bolsa vacía.
Se te dan Q consultas, que deben procesarse en orden.
Hay tres tipos de consultas.

- 1 x : Coloca una bola con el entero x escrito en ella dentro de la bolsa.
- 2 x : Retira una bola con el entero x escrito en ella de la bolsa y descártala. Se garantiza que la bolsa tiene una bola con el entero x escrito en ella cuando se da esta consulta.
- 3 : Imprime el número de enteros diferentes escritos en las bolas de la bolsa.

Entrada

La entrada se proporciona desde la Entrada Estándar en el siguiente formato:
Q
\text{consulta}_1
\text{consulta}_2
\vdots
\text{consulta}_Q

La i-ésima consulta \text{consulta}_i se da en uno de los siguientes tres formatos:
1 x

2 x

3

Salida

Si hay K consultas del tercer tipo, imprime K líneas.
La i-ésima línea (1 \leq i \leq K) debe contener la respuesta a la i-ésima consulta del tercer tipo.

Restricciones

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Cuando se da una consulta del segundo tipo, la bolsa tiene una bola con el entero x escrito en ella.
- Hay al menos una consulta del tercer tipo.
- Todos los valores de entrada son enteros.

Entrada de Muestra 1

8
1 3
1 1
1 4
3
2 1
3
1 5
3

Salida de Muestra 1

3
2
3

Inicialmente, la bolsa está vacía.
Para la primera consulta 1 3, una bola con el entero 3 escrito en ella entra en la bolsa.
Para la segunda consulta 1 1, una bola con el entero 1 escrito en ella entra en la bolsa.
Para la tercera consulta 1 4, una bola con el entero 4 escrito en ella entra en la bolsa.
Para la cuarta consulta 3, la bolsa tiene bolas con los enteros 1, 3, 4, por lo que imprime 3.
Para la quinta consulta 2 1, una bola con el entero 1 escrito en ella se elimina de la bolsa.
Para la sexta consulta 3, la bolsa tiene bolas con los enteros 3, 4, por lo que imprime 2.
Para la séptima consulta 1 5, una bola con el entero 5 escrito en ella entra en la bolsa.
Para la octava consulta 3, la bolsa tiene bolas con los enteros 3, 4, 5, por lo que imprime 3.

Entrada de Muestra 2

8
1 2
1 2
3
2 2
1 4
1 4
2 2
3

Salida de Muestra 2

1
1

Tienes una bolsa vacía.
Se le dan Q consultas, que deben procesarse en orden.
Hay tres tipos de consultas.

- 1 x : Introducir en la bolsa una bola con el número entero x.
- 2 x : Sacar de la bolsa una bola con el número entero x y descartarla. Se garantiza que la bolsa tiene una bola con el entero x escrito en ella cuando se da esta consulta.
- 3 : Imprime el número de enteros diferentes escritos en las bolas de la bolsa.

Entrada

La entrada se da desde la Entrada Estándar en el siguiente formato:
Q
\texto{consulta}_1
\texto{consulta}_2
\Puntos
\text{query}_Q

La consulta i-ésima \text{query}_i se da en uno de los tres formatos siguientes:
1 x

2 x

3

Salida

Si hay K consultas del tercer tipo, imprime K líneas.
La i-ésima línea (1 \leq i \leq K) debe contener la respuesta a la i-ésima consulta del tercer tipo.

Restricciones

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Cuando se da una consulta del segundo tipo, la bolsa tiene una bola con el número entero x escrito en ella.
- Hay al menos una consulta del tercer tipo.
- Todos los valores de entrada son enteros.

Ejemplo de entrada 1

8
1 3
1 1
1 4
3
2 1
3
1 5
3

Muestra de salida 1

3
2
3

Inicialmente, la bolsa está vacía.
Para la primera consulta 1 3, entra en la bolsa una bola con el número entero 3 escrito.
Para la segunda consulta 1 1, entra en la bolsa una bola con el número entero 1 escrito.
Para la tercera consulta 1 4, entra en la bolsa una bola con el número entero 4 escrito.
Para la cuarta consulta 3, la bolsa tiene bolas con los números enteros 1, 3, 4, así que imprime 3.
Para la quinta consulta 2 1, se saca de la bolsa una bola con el número entero 1 escrito en ella.
Para la sexta consulta 3, la bolsa tiene bolas con los enteros 3, 4, así que imprime 2.
Para la séptima consulta 1 5, una bola con el número entero 5 entra en la bolsa.
Para la octava consulta 3, la bolsa tiene bolas con los enteros 3, 4, 5, así que imprime 3.

Ejemplo de entrada 2

8
1 2
1 2
3
2 2
1 4
1 4
2 2
3

Salida de muestra 2

1
1

Traducción realizada con la versión gratuita del traductor DeepL.com


Se te da un grafo no dirigido simple con N vértices y M aristas. La i-ésima arista conecta bidireccionalmente los vértices u_i y v_i.
Determina si existe una forma de escribir un entero entre 1 y 2^{60} - 1, inclusive, en cada vértice de este grafo de manera que se cumpla la siguiente condición:

- Para cada vértice v con un grado de al menos 1, el total XOR de los números escritos en sus vértices adyacentes (excluyendo al propio v) sea 0.

¿Qué es XOR?

El XOR de dos enteros no negativos A y B, denotado como A \oplus B, se define de la siguiente manera:

- En la representación binaria de A \oplus B, el bit en la posición 2^k \, (k \geq 0) es 1 si y solo si exactamente uno de los bits en la posición 2^k en las representaciones binarias de A y B es 1. De lo contrario, es 0.

Por ejemplo, 3 \oplus 5 = 6 (en binario: 011 \oplus 101 = 110).

En general, el XOR bit a bit de k enteros p_1, \dots, p_k se define como (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k). Se puede demostrar que esto es independiente del orden de p_1, \dots, p_k.

Entrada

La entrada se da desde la Entrada Estándar en el siguiente formato:
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Salida

Si no hay forma de escribir enteros que cumplan con la condición, imprime No.
De lo contrario, sea X_v el entero escrito en el vértice v, e imprime tu solución en el siguiente formato. Si existen múltiples soluciones, cualquiera de ellas será aceptada.
Yes
X_1 X_2 \dots X_N

Restricciones

- 1 \leq N \leq 60
- 0 \leq M \leq N(N-1)/2
- 1 \leq u_i < v_i \leq N
- (u_i, v_i) \neq (u_j, v_j) para i \neq j.
- Todos los valores de entrada son enteros.

Entrada de muestra 1

3 3
1 2
1 3
2 3

Salida de muestra 1

Yes
4 4 4

Otras soluciones aceptables incluyen escribir (2,2,2) o (3,3,3).

Entrada de muestra 2

2 1
1 2

Salida de muestra 2

No

Entrada de muestra 3

1 0

Salida de muestra 3

Yes
1

Se puede escribir cualquier entero entre 1 y 2^{60} - 1.

Entrada de muestra 4

4 5
1 2
1 3
2 3
2 4
3 4

Salida de muestra 4

Yes
12 4 4 8

Se le proporciona un gráfico simple no dirigido con N vértices y M aristas. La arista i-ésima conecta los vértices u_i y v_i de manera bidireccional.
Determine si existe una manera de escribir un entero entre 1 y 2^{60} - 1, inclusive, en cada vértice de este gráfico de modo que se cumpla la siguiente condición:

- Para cada vértice v con un grado de al menos 1, la suma total de los números escritos en sus vértices adyacentes (excluyendo v) es 0.

¿Qué es XOR?

La operación XOR de dos enteros no negativos A y B, denotada como A \oplus B, se define de la siguiente manera:

- En la representación binaria de A \oplus B, el bit en la posición 2^k \, (k \geq 0) es 1 si y solo si exactamente uno de los bits en la posición 2^k en las representaciones binarias de A y B es 1. De lo contrario, es 0.

Por ejemplo, 3 \oplus 5 = 6 (en binario: 011 \oplus 101 = 110).

En general, la operación XOR bit a bit de k enteros p_1, \dots, p_k se define como (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k). Se puede demostrar que esto es independiente del orden de p_1, \dots, p_k.

Entrada

La entrada se proporciona desde la entrada estándar en el siguiente formato:
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Salida

Si no hay forma de escribir números enteros que satisfagan la condición, imprima No.
De lo contrario, sea X_v el número entero escrito en el vértice v e imprima su solución en el siguiente formato. Si existen múltiples soluciones, se aceptará cualquiera de ellas.
Yes
X_1 X_2 \dots X_N

Restricciones

- 1 \leq N \leq 60
- 0 \leq M \leq N(N-1)/2
- 1 \leq u_i < v_i \leq N
- (u_i, v_i) \neq (u_j, v_j) para i \neq j.
- Todos los valores de entrada son números enteros.

Entrada de muestra 1

3 3
1 2
1 3
2 3

Salida de muestra 1

Yes
4 4 4

Otras soluciones aceptables incluyen escribir (2,2,2) o (3,3,3).

Entrada de muestra 2

2 1
1 2

Salida de muestra 2

No

Entrada de muestra 3

1 0

Salida de muestra 3

Yes
1

Se puede escribir cualquier número entero entre 1 y 2^{60} - 1.

Entrada de muestra 4

4 5
1 2
1 3
2 3
2 4
3 4

Salida de muestra 4

Yes
12 4 4 8

Se le da un grafo simple no dirigido con N vértices y M aristas. La arista i-ésima conecta los vértices u_i y v_i bidireccionalmente.
Determinar si existe una manera de escribir un número entero entre 1 y 2^{60} - 1, ambos inclusive, en cada vértice de este gráfico de manera que se cumpla la siguiente condición:

- Para cada vértice v con un grado de al menos 1, el XOR total de los números escritos en sus vértices adyacentes (excluyendo al propio v) es 0.

¿Qué es XOR?

El XOR de dos números enteros no negativos A y B, denotado como A \oplus B, se define como sigue:

- En la representación binaria de A \oplus B, el bit en la posición 2^k \, (k \geq 0) es 1 si y sólo si exactamente uno de los bits en la posición 2^k en las representaciones binarias de A y B es 1. De lo contrario, es 0.

Por ejemplo, 3 \oplus 5 = 6 (en binario: 011 \oplus 101 = 110).

En general, el XOR a nivel de bits de k enteros p_1, \oplus, p_k se define como (\oplus ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k).  Se puede demostrar que esto es independiente del orden de p_1, \dots, p_k.

Entrada

La entrada se da desde Standard Input en el siguiente formato:
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Salida

Si no hay forma de escribir enteros que satisfagan la condición, imprime No.
Si no, deja que X_v sea el entero escrito en el vértice v, e imprime tu solución en el siguiente formato. Si existen múltiples soluciones, cualquiera de ellas será aceptada.
Yes
X_1 X_2 \puntos X_N

Restricciones

- 1 \leq N \leq 60
- 0 \leq M \leq N(N-1)/2
- 1 \leq u_i < v_i \leq N
- (u_i, v_i) \neq (u_j, v_j) for i \neq j.
- Todos los valores de entrada son enteros.

Ejemplo de entrada 1

3 3
1 2
1 3
2 3

Salida de muestra 1

Yes
4 4 4

Otras soluciones aceptables son escribir (2,2,2) o (3,3,3).

Entrada de muestra 2

2 1
1 2

Muestra de salida 2

No

Entrada de muestra 3

1 0

Salida de muestra 3

Yes
1

Se puede escribir cualquier número entero entre 1 y 2^{60} - 1.

Entrada de muestra 4

4 5
1 2
1 3
2 3
2 4
3 4

Muestra Salida 4

Yes
12 4 4 8

Traducción realizada con la versión gratuita del traductor DeepL.com