On vous donne un tableau binaire nums.
Vous pouvez effectuer l'opération suivante sur le tableau un nombre quelconque de fois (possiblement zéro) :

Choisissez n'importe quels 3 éléments consécutifs du tableau et inversez-les tous.

Inverser un élément signifie changer sa valeur de 0 à 1 et de 1 à 0.
Retournez le nombre minimum d'opérations nécessaires pour que tous les éléments de nums soient égaux à 1. S'il est impossible, retournez -1.

Exemple 1 :

Entrée : nums = [0,1,1,1,0,0]
Sortie : 3
Explication :
Nous pouvons effectuer les opérations suivantes :

Choisissez les éléments aux indices 0, 1 et 2. Le tableau résultant est nums = [1,0,0,1,0,0].
Choisissez les éléments aux indices 1, 2 et 3. Le tableau résultant est nums = [1,1,1,0,0,0].
Choisissez les éléments aux indices 3, 4 et 5. Le tableau résultant est nums = [1,1,1,1,1,1].

Exemple 2 :

Entrée : nums = [0,1,1,1]
Sortie : -1
Explication :
Il est impossible de rendre tous les éléments égaux à 1.

Contraintes :

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

On vous donne un tableau binaire nums.
Vous pouvez effectuer l'opération suivante sur le tableau un nombre quelconque de fois (éventuellement zéro) :

Choisissez n'importe quels 3 éléments consécutifs du tableau et inversez-les tous.

Inverser un élément signifie changer sa valeur de 0 à 1, et de 1 à 0.
Retournez le nombre minimum d'opérations nécessaires pour que tous les éléments de nums soient égaux à 1. Si c'est impossible, retournez -1.

Exemple 1 :

Entrée : nums = [0,1,1,1,0,0]
Sortie : 3
Explication :
Nous pouvons effectuer les opérations suivantes :

Choisissez les éléments aux indices 0, 1 et 2. Le tableau résultant est nums = [1,0,0,1,0,0].
Choisissez les éléments aux indices 1, 2 et 3. Le tableau résultant est nums = [1,1,1,0,0,0].
Choisissez les éléments aux indices 3, 4 et 5. Le tableau résultant est nums = [1,1,1,1,1,1].

Exemple 2 :

Entrée : nums = [0,1,1,1]
Sortie : -1
Explication :
Il est impossible de rendre tous les éléments égaux à 1.

Contraintes :

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

Vous avez un tableau binaire.
Vous pouvez effectuer l'opération suivante sur le tableau du nombre de fois (éventuellement zéro):

Choisissez 3 éléments consécutifs dans le tableau et retournez tous.

Le renversement d'un élément signifie changer sa valeur de 0 à 1 et de 1 à 0.
Renvoie le nombre minimum d'opérations nécessaires pour rendre tous les éléments égaux à 1. S'il est impossible, retournez -1.

Exemple 1:

Entrée: nums = [0,1,1,1,0,0]
Sortie: 3
Explication:
Nous pouvons effectuer les opérations suivantes:

Choisissez les éléments aux indices 0, 1 et 2. Le tableau résultant est nums = [1,0,0,1,0,0].
Choisissez les éléments aux indices 1, 2 et 3. Le tableau résultant est nums = [1,1,1,0,0,0].
Choisissez les éléments aux indices 3, 4 et 5. Le tableau résultant est nums = [1,1,1,1,1,1].

Exemple 2:

Entrée: nums = [0,1,1,1]
Sortie: -1
Explication:
Il est impossible de rendre tous les éléments égaux à 1.

Contraintes:

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


On donne un entier n et un tableau 2D requirements, où requirements[i] = [end_i, cnt_i] représente l'indice de fin et le nombre d'inversions de chaque contrainte.
Une paire d'indices (i, j) d'un tableau d'entiers nums est appelée une inversion si :

i < j et nums[i] > nums[j]

Retournez le nombre de permutations perm de [0, 1, 2, ..., n - 1] telles que pour toutes les requirements[i], perm[0..end_i] ait exactement cnt_i inversions.
Étant donné que la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 3, requirements = [[2,2],[0,0]]
Sortie : 2
Explication :
Les deux permutations sont :

[2, 0, 1]

Le préfixe [2, 0, 1] a les inversions (0, 1) et (0, 2).
Le préfixe [2] n’a aucune inversion.

[1, 2, 0]

Le préfixe [1, 2, 0] a les inversions (0, 2) et (1, 2).
Le préfixe [1] n’a aucune inversion.

Exemple 2 :

Entrée : n = 3, requirements = [[2,2],[1,1],[0,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [2, 0, 1] :

Le préfixe [2, 0, 1] a les inversions (0, 1) et (0, 2).
Le préfixe [2, 0] a une inversion (0, 1).
Le préfixe [2] n’a aucune inversion.

Exemple 3 :

Entrée : n = 2, requirements = [[0,0],[1,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [0, 1] :

Le préfixe [0] n’a aucune inversion.
Le préfixe [0, 1] a une inversion (0, 1).

Contraintes :

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
L’entrée est générée de sorte qu’il existe au moins un i tel que end_i == n - 1.
L’entrée est générée de sorte que tous les end_i sont uniques.

On vous donne un entier n et un tableau 2D d'exigences, où exigences[i] = [end_i, cnt_i] représente l'indice de fin et le nombre d'inversions de chaque exigence.
Une paire d'indices (i, j) d'un tableau d'entiers nums est appelée une inversion si :

i < j and nums[i] > nums[j]

Renvoyer le nombre de permutations perm de [0, 1, 2, ..., n - 1] telles que pour toutes les exigences[i], perm[0..end_i] a exactement cnt_i inversions.
Comme la réponse peut être très grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 3, requirements = [[2,2],[0,0]]
Sortie : 2
Explication :
Les deux permutations sont :

[2, 0, 1]

Le préfixe [2, 0, 1] a des inversions (0, 1) et (0, 2).
Le préfixe [2] a 0 inversion.

[1, 2, 0]

Le préfixe [1, 2, 0] a les inversions (0, 2) et (1, 2).
Le préfixe [1] a 0 inversion.

Exemple 2 :

Entrée : n = 3, requirements = [[2,2],[1,1],[0,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [2, 0, 1] :

Le préfixe [2, 0, 1] a des inversions (0, 1) et (0, 2).
Le préfixe [2, 0] a une inversion (0, 1).
Le préfixe [2] a 0 inversion.

Exemple 3 :

Entrée : n = 2, requirements = [[0,0],[1,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [0, 1] :

Le préfixe [0] a 0 inversions.
Le préfixe [0, 1] a une inversion (0, 1).

Contraintes :

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
L'entrée est générée de telle sorte qu'il existe au moins un i tel que end_i == n - 1.
L'entrée est générée de telle sorte que tous les end_i sont uniques.

Vous avez un entier n et un tableau 2D requirements, où requirements[i] = [end_i, cnt_i] représente l'indice de fin et le compte des inversions de chaque exigence.
Une paire d'indices (i, j) d'un tableau d'entiers nums est appelée une inversion si :

i < j et nums[i] > nums[j]

Retournez le nombre de permutations perm de [0, 1, 2, ..., n - 1] telles que pour toutes les exigences[i], perm[0..end_i] ait exactement cnt_i inversions.
Étant donné que la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 3, requirements = [[2,2],[0,0]]
Sortie : 2
Explication :
Les deux permutations sont :

[2, 0, 1]

Le préfixe [2, 0, 1] a les inversions (0, 1) et (0, 2).
Le préfixe [2] n’a aucune inversion.

[1, 2, 0]

Le préfixe [1, 2, 0] a les inversions (0, 2) et (1, 2).
Le préfixe [1] n’a aucune inversion.

Exemple 2 :

Entrée : n = 3, requirements = [[2,2],[1,1],[0,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [2, 0, 1] :

Le préfixe [2, 0, 1] a les inversions (0, 1) et (0, 2).
Le préfixe [2, 0] a une inversion (0, 1).
Le préfixe [2] n’a aucune inversion.

Exemple 3 :

Entrée : n = 2, requirements = [[0,0],[1,0]]
Sortie : 1
Explication :
La seule permutation satisfaisante est [0, 1] :

Le préfixe [0] n’a aucune inversion.
Le préfixe [0, 1] a une inversion (0, 1).

Contraintes :

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
L’entrée est générée de sorte qu’il existe au moins un i tel que end_i == n - 1.
L’entrée est générée de sorte que tous les end_i sont uniques.


Il y a un cercle de tuiles rouges et bleues. Un tableau d'entiers colors vous est fourni. La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Chaque ensemble de 3 tuiles contiguës dans le cercle avec des couleurs alternées (la tuile du milieu a une couleur différente de ses tuiles gauche et droite) est appelé un groupe alterné.
Retournez le nombre de groupes alternés.
Notez que comme colors représente un cercle, les premières et dernières tuiles sont considérées comme étant adjacentes.

Exemple 1 :

Input: colors = [1,1,1]
Output: 0
Explication :

Exemple 2 :

Input: colors = [0,1,0,0,1]
Output: 3
Explication :

Groupes alternés :

Contraintes :

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

On a un cercle de tuiles rouges et bleues. Un tableau d'entiers colors vous est donné. La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Chaque groupe de 3 tuiles contiguës dans le cercle avec des couleurs alternées (la tuile du milieu a une couleur différente de ses tuiles voisines de gauche et de droite) est appelé un groupe alterné.
Retournez le nombre de groupes alternés.
Notez que comme colors représente un cercle, les premières et dernières tuiles sont considérées comme étant adjacentes.

Exemple 1 :

Input: colors = [1,1,1]
Output: 0
Explication :

Exemple 2 :

Input: colors = [0,1,0,0,1]
Output: 3
Explication :

Groupes alternés :

Contraintes :

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

Il y a un cercle de tuiles rouges et bleues. On vous donne un tableau de couleurs entières. La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Toutes les 3 tuiles contiguës dans le cercle avec des couleurs alternées (la tuile du milieu a une couleur différente de ses tuiles de gauche et de droite) sont appelées un groupe alterné.
Renvoie le nombre de groupes alternés.
Notez que puisque colors représente un cercle, la première et la dernière tuile sont considérées comme étant l'une à côté de l'autre.

Exemple 1 :

Entrée : colors = [1,1,1]
Sortie : 0
Explication :

Exemple 2 :

Entrée : colors = [0,1,0,0,1]
Sortie : 3
Explication :

Groupes alternés :

Contraintes :

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


On vous donne un tableau d'entiers enemyEnergies représentant les valeurs d'énergie de divers ennemis.
On vous donne également un entier currentEnergy représentant la quantité d'énergie que vous avez initialement.
Vous commencez avec 0 point, et tous les ennemis sont initialement non marqués.
Vous pouvez effectuer l'une des opérations suivantes zéro ou plusieurs fois pour gagner des points :

Choisissez un ennemi non marqué, i, tel que currentEnergy >= enemyEnergies[i]. En choisissant cette option :

Vous gagnez 1 point.
Votre énergie est réduite par l'énergie de l'ennemi, c'est-à-dire currentEnergy = currentEnergy - enemyEnergies[i].

Si vous avez au moins 1 point, vous pouvez choisir un ennemi non marqué, i. En choisissant cette option :

Votre énergie augmente de l'énergie de l'ennemi, c'est-à-dire currentEnergy = currentEnergy + enemyEnergies[i].
L'ennemi i est marqué.

Retournez un entier représentant le nombre maximum de points que vous pouvez obtenir à la fin en effectuant des opérations de manière optimale.

Exemple 1 :

Entrée : enemyEnergies = [3,2,2], currentEnergy = 2
Sortie : 3
Explication :
Les opérations suivantes peuvent être effectuées pour obtenir 3 points, ce qui est le maximum :

Première opération sur l'ennemi 1 : les points augmentent de 1 et currentEnergy diminue de 2. Donc, points = 1 et currentEnergy = 0.
Deuxième opération sur l'ennemi 0 : currentEnergy augmente de 3, et l'ennemi 0 est marqué. Donc, points = 1, currentEnergy = 3, et ennemis marqués = [0].
Première opération sur l'ennemi 2 : les points augmentent de 1 et currentEnergy diminue de 2. Donc, points = 2, currentEnergy = 1, et ennemis marqués = [0].
Deuxième opération sur l'ennemi 2 : currentEnergy augmente de 2, et l'ennemi 2 est marqué. Donc, points = 2, currentEnergy = 3, et ennemis marqués = [0, 2].
Première opération sur l'ennemi 1 : les points augmentent de 1 et currentEnergy diminue de 2. Donc, points = 3, currentEnergy = 1, et ennemis marqués = [0, 2].

Exemple 2 :

Entrée : enemyEnergies = [2], currentEnergy = 10
Sortie : 5
Explication :
Effectuer la première opération 5 fois sur l'ennemi 0 donne le nombre maximum de points.

Contraintes :

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

On vous donne un un tableau d'entiers enemyEnergies dénotant les valeurs énergétiques de divers ennemis.
On vous donne également une énergie currentEnergy désignant la quantité d'énergie que vous avez initialement.
Vous commencez avec 0 points, et tous les ennemis sont initialement non marqués.
Vous pouvez effectuer l'une des opérations suivantes zéro ou plusieurs fois pour gagner des points:

Choisissez un ennemi non marqué, i, tel quecurrentEnergy >= enemyEnergies[i]. En choisissant cette option:

Vous gagnez 1 point.
Votre énergie est réduite par l'énergie de l'ennemi, c'est-à-dire currentEnergy = currentEnergy - enemyEnergies[i].

Si vous avez au moins 1 point, vous pouvez choisir un ennemi non marqué, i. En choisissant cette option:

Votre énergie augmente par l'énergie de l'ennemi, c'est-à-dire currentEnergy = currentEnergy + enemyEnergies[i].
L'ennemi i est marqué.

Renvoie un entier indiquant les points maximaux que vous pouvez obtenir en fin de compte par des opérations de réalisation de manière optimale.

Exemple 1:

Entrée: enemyEnergies = [3,2,2], currentEnergy = 2
Sortie: 3
Explication:
Les opérations suivantes peuvent être effectuées pour obtenir 3 points, ce qui est le maximum:

Première opération sur l'ennemi 0: les points augmentent de 1, et currentEnergy diminue de 2. Donc, points = 1, et currentEnergy  = 0.
Deuxième opération sur l'ennemi 0: currentEnergy augmente de 3 et l'ennemi 0 est marqué. Ainsi, points = 1, currentEnergy = 3 et marqués ennemis = [0].
Première opération sur l'ennemi 2: les points augmentent de 1, et currentEnergy diminue de 2. Donc, points = 2, currentEnergy = 1 et marqués ennemis = [0].
Deuxième opération sur l'ennemi 2: currentEnergy augmente de 2 et l'ennemi 2 est marqué. Ainsi, points = 2, currentEnergy = 3 et marqués ennemis = [0, 2].
Première opération sur l'ennemi 0: les points augmentent de 1, et currentEnergy diminue de 2. Donc, points = 3, currentEnergy = 1 et ennemis marqués = [0, 2].

Exemple 2:

Entrée: enemyEnergies = [2], currentEnergy = 10
Sortie: 5
Explication:
Effectuer la première opération 5 fois sur l'ennemi 0 entraîne le nombre maximum de points.

Contraintes:

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


Étant donné un tableau d'entiers nums et un entier k, retournez le nombre de sous-tableaux de nums où le AND bit à bit des éléments du sous-tableau est égal à k.

Exemple 1 :

Entrée : nums = [1,1,1], k = 1
Sortie : 6
Explication :
Tous les sous-tableaux contiennent uniquement des 1.

Exemple 2 :

Entrée : nums = [1,1,2], k = 1
Sortie : 3
Explication :
Les sous-tableaux ayant une valeur AND de 1 sont : [1,1,2], [1,1,2], [1,1,2].

Exemple 3 :

Entrée : nums = [1,2,3], k = 2
Sortie : 2
Explication :
Les sous-tableaux ayant une valeur AND de 2 sont : [1,2,3], [1,2,3].

Contraintes :

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

Étant donné un tableau de nombres entiers et un entier k, renvoyez le nombre de sous-tableaux de nombres où le ET bit à bit des éléments du sous-tableau est égal à k.

Exemple 1 :

Entrée : nums = [1,1,1], k = 1
Sortie : 6
Explication :
Tous les sous-tableaux contiennent uniquement des 1.

Exemple 2 :

Entrée : nums = [1,1,2], k = 1
Sortie : 3
Explication :
Les sous-tableaux ayant une valeur AND de 1 sont : [1,1,2], [1,1,2], [1,1,2].

Exemple 3 :

Entrée : nums = [1,2,3], k = 2
Sortie : 2
Explication :
Les sous-tableaux ayant une valeur AND de 2 sont : [1,2,3], [1,2,3].

Contraintes :

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

Étant donné un tableau d’entiers nums et un entier k, renvoie le nombre de sous-tableaux de nums où le ET au niveau du bit des éléments du sous-tableau est égal à k.

Exemple 1 :

Entrée : nums = [1,1,1], k = 1
Sortie : 6
Explication:
Tous les sous-tableaux ne contiennent que des 1.

Exemple 2 :

Entrée : nums = [1,1,2], k = 1
Sortie : 3
Explication:
Les sous-tableaux ayant une valeur AND de 1 sont : [1,1,2], [1,1,2], [1,1,2].

Exemple 3 :

Entrée : nums = [1,2,3], k = 2
Sortie : 2
Explication:
Les sous-tableaux ayant une valeur AND de 2 sont : [1,2,3], [1,2,3].

Contraintes:

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


On vous donne deux entiers positifs x et y, représentant le nombre de pièces avec des valeurs de 75 et 10 respectivement.
Alice et Bob jouent à un jeu. À chaque tour, en commençant par Alice, le joueur doit prendre des pièces d'une valeur totale de 115. Si le joueur est incapable de le faire, il perd la partie.
Retournez le nom du joueur qui gagne la partie si les deux joueurs jouent de manière optimale.

Exemple 1 :

Entrée : x = 2, y = 7
Sortie : "Alice"
Explication :
La partie se termine en un seul tour :

Alice prend 1 pièce de valeur 75 et 4 pièces de valeur 10.

Exemple 2 :

Entrée : x = 4, y = 11
Sortie : "Bob"
Explication :
La partie se termine en 2 tours :

Alice prend 1 pièce de valeur 75 et 4 pièces de valeur 10.
Bob prend 1 pièce de valeur 75 et 4 pièces de valeur 10.

Contraintes :

1 <= x, y <= 100

On vous donne deux entiers positifs x et y, indiquant le nombre de pièces avec des valeurs respectives de 75 et 10.
Alice et Bob jouent à un jeu. À chaque tour, en commençant par Alice, le joueur doit ramasser des pièces d'une valeur totale de 115. Si le joueur n'y parvient pas, il perd la partie.
Renvoie le nom du joueur qui remporte la partie si les deux joueurs jouent de manière optimale.

Exemple 1 :

Entrée : x = 2, y = 7
Sortie : "Alice"
Explication :
Le jeu se termine en un seul tour :

Alice pioche 1 pièce d'une valeur de 75 et 4 pièces d'une valeur de 10.

Exemple 2 :

Entrée : x = 4, y = 11
Sortie : "Bob"
Explication :
Le jeu se termine en 2 tours :

Alice pioche 1 pièce d'une valeur de 75 et 4 pièces d'une valeur de 10.
Bob pioche 1 pièce d'une valeur de 75 et 4 pièces d'une valeur de 10.

Contraintes :

1 <= x, y <= 100

On vous donne deux entiers positifs x et y, représentant le nombre de pièces avec des valeurs de 75 et 10 respectivement.
Alice et Bob jouent à un jeu. À chaque tour, en commençant par Alice, le joueur doit prendre des pièces d'une valeur totale de 115. Si le joueur est incapable de le faire, il perd la partie.
Renvoyez le nom du joueur qui gagne la partie si les deux joueurs jouent de manière optimale.

Exemple 1 :

Input : x = 2, y = 7
Output : "Alice"
Explication :
La partie se termine en un seul tour :

Alice prend 1 pièce de valeur 75 et 4 pièces de valeur 10.

Exemple 2 :

Input : x = 4, y = 11
Output : "Bob"
Explication :
La partie se termine en 2 tours :

Alice prend 1 pièce de valeur 75 et 4 pièces de valeur 10.
Bob prend 1 pièce de valeur 75 et 4 pièces de valeur 10.

Contraintes :

1 <= x, y <= 100


On vous donne une chaîne de caractères s.
Vous pouvez effectuer le processus suivant sur s un nombre quelconque de fois :

Choisissez un indice i dans la chaîne de sorte qu'il y ait au moins un caractère à gauche de l'indice i qui soit égal à s[i], et au moins un caractère à droite qui soit également égal à s[i].
Supprimez le caractère le plus proche à gauche de l'indice i qui est égal à s[i].
Supprimez le caractère le plus proche à droite de l'indice i qui est égal à s[i].

Renvoyez la longueur minimale de la chaîne finale s que vous pouvez obtenir.

Exemple 1 :

Entrée : s = "abaacbcbb"
Sortie : 5
Explication :
Nous effectuons les opérations suivantes :

Choisissez l'indice 2, puis supprimez les caractères aux indices 0 et 3. La chaîne résultante est s = "bacbcbb".
Choisissez l'indice 3, puis supprimez les caractères aux indices 0 et 5. La chaîne résultante est s = "acbcb".

Exemple 2 :

Entrée : s = "aa"
Sortie : 2
Explication :
Nous ne pouvons effectuer aucune opération, donc nous renvoyons la longueur de la chaîne initiale.

Contraintes :

1 <= s.length <= 2 * 10^5
s se compose uniquement de lettres minuscules anglaises.

On vous donne une chaîne s.
Vous pouvez effectuer le processus suivant sur s autant de fois que vous le souhaitez :

Choisissez un index i dans la chaîne tel qu'il y ait au moins un caractère à gauche de l'index i qui soit égal à s[i], et au moins un caractère à droite qui soit également égal à s[i].
Supprimez le caractère le plus proche à gauche de l'index i qui soit égal à s[i].
Supprimez le caractère le plus proche à droite de l'index i qui soit égal à s[i].

Renvoie la longueur minimale de la chaîne finale s que vous pouvez obtenir.

Exemple 1 :

Entrée : s = "abaacbcbb"
Sortie : 5
Explication :
Nous effectuons les opérations suivantes :

Choisissez l'index 2, puis supprimez les caractères aux index 0 et 3. La chaîne résultante est s = "bacbcbb".
Choisissez l'index 3, puis supprimez les caractères aux index 0 et 5. La chaîne résultante est s = "acbcb".

Exemple 2 :

Entrée : s = "aa"
Sortie : 2
Explication :
Nous ne pouvons effectuer aucune opération, nous renvoyons donc la longueur de la chaîne d'origine.

Contraintes :

1 <= s.length <= 2 * 10^5
s est uniquement composé de lettres minuscules anglaises.

Vous avez une chaîne de caractères s.
Vous pouvez effectuer le processus suivant sur s un nombre quelconque de fois :

Choisissez un indice i dans la chaîne de sorte qu'il y ait au moins un caractère à gauche de l'indice i qui soit égal à s[i], et au moins un caractère à droite qui soit également égal à s[i].
Supprimez le caractère le plus proche à gauche de l'indice i qui est égal à s[i].
Supprimez le caractère le plus proche à droite de l'indice i qui est égal à s[i].

Retournez la longueur minimale de la chaîne finale s que vous pouvez obtenir.

Exemple 1 :

Entrée : s = "abaacbcbb"
Sortie : 5
Explication :
Nous effectuons les opérations suivantes :

Choisissez l'indice 2, puis supprimez les caractères aux indices 0 et 3. La chaîne résultante est s = "bacbcbb".
Choisissez l'indice 3, puis supprimez les caractères aux indices 0 et 5. La chaîne résultante est s = "acbcb".

Exemple 2 :

Entrée : s = "aa"
Sortie : 2
Explication :
Nous ne pouvons effectuer aucune opération, donc nous retournons la longueur de la chaîne initiale.

Contraintes :

1 <= s.length <= 2 * 10^5
s se compose uniquement de lettres minuscules anglaises.


On vous donne un tableau d'entiers nums de taille n où n est pair, et un entier k.
Vous pouvez effectuer certains changements sur le tableau, au cours desquels vous pouvez remplacer n'importe quel élément du tableau par n'importe quel entier compris entre 0 et k.
Vous devez effectuer certains changements (possiblement aucun) de manière à ce que le tableau final satisfasse la condition suivante :

Il existe un entier X tel que abs(a[i] - a[n - i - 1]) = X pour tout (0 <= i < n).

Retournez le nombre minimum de changements nécessaires pour satisfaire la condition ci-dessus.

Exemple 1 :

Entrée : nums = [1,0,1,2,4,3], k = 4
Sortie : 2
Explication :
Nous pouvons effectuer les changements suivants :

Remplacez nums[1] par 2. Le tableau résultant est nums = [1,2,1,2,4,3].
Remplacez nums[3] par 3. Le tableau résultant est nums = [1,2,1,3,4,3].

L'entier X sera 2.

Exemple 2 :

Entrée : nums = [0,1,2,3,3,6,5,4], k = 6
Sortie : 2
Explication :
Nous pouvons effectuer les opérations suivantes :

Remplacez nums[3] par 0. Le tableau résultant est nums = [0,1,2,0,3,6,5,4].
Remplacez nums[4] par 4. Le tableau résultant est nums = [0,1,2,0,4,6,5,4].

L'entier X sera 4.

Contraintes :

2 <= n == nums.length <= 10^5
n est pair.
0 <= nums[i] <= k <= 10^5

On vous donne un tableau d'entiers nums de taille n, où n est pair, et un entier k.
Vous pouvez effectuer certaines modifications sur le tableau, où dans une modification vous pouvez remplacer n'importe quel élément du tableau par n'importe quel entier dans l'intervalle de 0 à k.
Vous devez effectuer certaines modifications (éventuellement aucune) de manière à ce que le tableau final satisfasse à la condition suivante :

Il existe un entier X tel que abs(a[i] - a[n - i - 1]) = X pour tout (0 <= i < n).

Renvoyez le nombre minimum de modifications nécessaires pour satisfaire à la condition ci-dessus.

Exemple 1 :

Entrée : nums = [1,0,1,2,4,3], k = 4
Sortie : 2
Explication :
Nous pouvons effectuer les modifications suivantes :

Remplacer nums[1] par 2. Le tableau résultant est nums = [1,2,1,2,4,3].
Remplacer nums[3] par 3. Le tableau résultant est nums = [1,2,1,3,4,3].

L'entier X sera 2.

Exemple 2 :

Entrée : nums = [0,1,2,3,3,6,5,4], k = 6
Sortie : 2
Explication :
Nous pouvons effectuer les opérations suivantes :

Remplacer nums[3] par 0. Le tableau résultant est nums = [0,1,2,0,3,6,5,4].
Remplacer nums[4] par 4. Le tableau résultant est nums = [0,1,2,0,4,6,5,4].

L'entier X sera 4.

Contraintes :

2 <= n == nums.length <= 10^5
n est pair.
0 <= nums[i] <= k <= 10^5

On vous donne un tableau d'entiers nums de taille n où n est pair, et un entier k.
Vous pouvez effectuer certains changements sur le tableau, où dans un changement vous pouvez remplacer n'importe quel élément du tableau par n'importe quel entier compris entre 0 et k.
Vous devez effectuer certains changements (possiblement aucun) de manière à ce que le tableau final satisfasse la condition suivante :

Il existe un entier X tel que abs(a[i] - a[n - i - 1]) = X pour tout (0 <= i < n).

Retournez le nombre minimum de changements nécessaires pour satisfaire la condition ci-dessus.

Exemple 1 :

Entrée : nums = [1,0,1,2,4,3], k = 4
Sortie : 2
Explication :
Nous pouvons effectuer les changements suivants :

Remplacez nums[1] par 2. Le tableau résultant est nums = [1,2,1,2,4,3].
Remplacez nums[3] par 3. Le tableau résultant est nums = [1,2,1,3,4,3].

L'entier X sera 2.

Exemple 2 :

Entrée : nums = [0,1,2,3,3,6,5,4], k = 6
Sortie : 2
Explication :
Nous pouvons effectuer les opérations suivantes :

Remplacez nums[3] par 0. Le tableau résultant est nums = [0,1,2,0,3,6,5,4].
Remplacez nums[4] par 4. Le tableau résultant est nums = [0,1,2,0,4,6,5,4].

L'entier X sera 4.

Contraintes :

2 <= n == nums.length <= 10^5
n est pair.
0 <= nums[i] <= k <= 10^5


Vous avez un entier n représentant le nombre de joueurs dans un jeu et un tableau 2D pick où pick[i] = [x_i, y_i] signifie que le joueur x_i a choisi une balle de couleur y_i.
Le joueur i gagne la partie s'il choisit strictement plus de i balles de la même couleur. En d'autres termes,

Le joueur 0 gagne s'il choisit n'importe quelle balle.
Le joueur 1 gagne s'il choisit au moins deux balles de la même couleur.
...
Le joueur i gagne s'il choisit au moins i + 1 balles de la même couleur.

Retourner le nombre de joueurs qui gagnent le jeu.
Notez que plusieurs joueurs peuvent gagner le jeu.

Exemple 1 :

Entrée : n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Sortie : 2
Explication :
Les joueurs 0 et 1 gagnent le jeu, tandis que les joueurs 2 et 3 ne gagnent pas.

Exemple 2 :

Entrée : n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Sortie : 0
Explication :
Aucun joueur ne gagne le jeu.

Exemple 3 :

Entrée : n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Sortie : 1
Explication :
Le joueur 2 gagne le jeu en choisissant 3 balles de couleur 4.

Contraintes :

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

Vous avez un entier n représentant le nombre de joueurs dans un jeu et un tableau 2D pick où pick[i] = [x_i, y_i] signifie que le joueur x_i a choisi une balle de couleur y_i.
Le joueur i gagne la partie s'il choisit strictement plus de i balles de la même couleur. En d'autres termes,

Le joueur 0 gagne s'il choisit n'importe quelle balle.
Le joueur 1 gagne s'il choisit au moins deux balles de la même couleur.
...
Le joueur i gagne s'il choisit au moins i + 1 balles de la même couleur.

Renvoyer le nombre de joueurs qui gagnent le jeu.
Notez que plusieurs joueurs peuvent gagner le jeu.

Exemple 1 :

Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Output: 2
Explication :
Les joueurs 0 et 1 gagnent le jeu, tandis que les joueurs 2 et 3 ne gagnent pas.

Exemple 2 :

Input: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Output: 0
Explication :
Aucun joueur ne gagne le jeu.

Exemple 3 :

Input: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Output: 1
Explication :
Le joueur 2 gagne le jeu en choisissant 3 balles de couleur 4.

Contraintes :

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

Vous avez un entier n représentant le nombre de joueurs dans un jeu et un tableau 2D pick où pick[i] = [x_i, y_i] signifie que le joueur x_i a choisi une balle de couleur y_i.
Le joueur i gagne la partie s'il choisit strictement plus de i balles de la même couleur. En d'autres termes,

Le joueur 0 gagne s'il choisit n'importe quelle balle.
Le joueur 1 gagne s'il choisit au moins deux balles de la même couleur.
...
Le joueur i gagne s'il choisit au moins i + 1 balles de la même couleur.

Retourner le nombre de joueurs qui gagnent le jeu.
Notez que plusieurs joueurs peuvent gagner le jeu.

Exemple 1 :

Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Output: 2
Explication :
Les joueurs 0 et 1 gagnent le jeu, tandis que les joueurs 2 et 3 ne gagnent pas.

Exemple 2 :

Input: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Output: 0
Explication :
Aucun joueur ne gagne le jeu.

Exemple 3 :

Input: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Output: 1
Explication :
Le joueur 2 gagne le jeu en choisissant 3 balles de couleur 4.

Contraintes :

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


On vous donne une matrice binaire m x n appelée grid.
Une ligne ou une colonne est considérée comme palindromique si ses valeurs se lisent de la même manière dans les deux sens.
Vous pouvez inverser n'importe quel nombre de cellules dans grid de 0 à 1, ou de 1 à 0.
Retournez le nombre minimum de cellules qui doivent être inversées pour rendre soit toutes les lignes palindromiques, soit toutes les colonnes palindromiques.

Exemple 1 :

Input: grid = [[1,0,0],[0,0,0],[0,0,1]]
Output: 2
Explication :

Inverser les cellules mises en évidence rend toutes les lignes palindromiques.

Exemple 2 :

Input: grid = [[0,1],[0,1],[0,0]]
Output: 1
Explication :

Inverser la cellule mise en évidence rend toutes les colonnes palindromiques.

Exemple 3 :

Input: grid = [[1],[0]]
Output: 0
Explication :
Toutes les lignes sont déjà palindromiques.

Contraintes :

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

On vous donne une grille à matrice binaire M x n.
Une ligne ou une colonne est considérée comme palindromique si ses valeurs lisent le même avant et vers l'arrière.
Vous pouvez retourner n'importe quel nombre de cellules en grille de 0 à 1, ou de 1 à 0.
Renvoyez le nombre minimum de cellules qui doivent être retournées pour rendre toutes les lignes palindromiques ou toutes les colonnes palindromiques.

Exemple 1:

Entrée: grid = [[1,0,0], [0,0,0], [0,0,1]]
Sortie: 2
Explication:

Le retournement des cellules en surbrillance rend toutes les lignes palindromiques.

Exemple 2:

Entrée: grid = [[0,1], [0,1], [0,0]]
Sortie: 1
Explication:

Le retournement de la cellule en surbrillance rend toutes les colonnes palindromiques.

Exemple 3:

Entrée: grid = [[1], [0]]
Sortie: 0
Explication:
Toutes les lignes sont déjà palindromiques.

Contraintes:

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

On vous donne une matrice binaire grid m x n.
Une ligne ou une colonne est considérée comme palindromique si ses valeurs se lisent de la même manière dans les deux sens.
Vous pouvez inverser n'importe quel nombre de cellules dans grid de 0 à 1, ou de 1 à 0.
Retournez le nombre minimum de cellules qui doivent être inversées pour rendre soit toutes les lignes palindromiques, soit toutes les colonnes palindromiques.

Exemple 1 :

Input: grid = [[1,0,0],[0,0,0],[0,0,1]]
Output: 2
Explication :

Inverser les cellules mises en évidence rend toutes les lignes palindromiques.

Exemple 2 :

Input: grid = [[0,1],[0,1],[0,0]]
Output: 1
Explication :

Inverser la cellule mise en évidence rend toutes les colonnes palindromiques.

Exemple 3 :

Input: grid = [[1],[0]]
Output: 0
Explication :
Toutes les lignes sont déjà palindromiques.

Contraintes :

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


Il existe un arbre non orienté avec n nœuds numérotés de 0 à n - 1. On vous donne un tableau d'entiers 2D, edges, de longueur n - 1, où edges[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans l'arbre.
Initialement, tous les nœuds sont non marqués. Pour chaque nœud i :

Si i est impair, le nœud sera marqué au temps x s'il y a au moins un nœud adjacent à lui qui a été marqué au temps x - 1.
Si i est pair, le nœud sera marqué au temps x s'il y a au moins un nœud adjacent à lui qui a été marqué au temps x - 2.

Retournez un tableau times où times[i] est le temps où tous les nœuds sont marqués dans l'arbre, si vous marquez le nœud i au temps t = 0.
Notez que la réponse pour chaque times[i] est indépendante, c'est-à-dire que lorsque vous marquez le nœud i, tous les autres nœuds sont non marqués.

Exemple 1 :

Input: edges = [[0,1],[0,2]]
Output: [2,4,3]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1, et le nœud 2 à t = 2.

Pour i = 1 :

Le nœud 0 est marqué à t = 2, et le nœud 2 à t = 4.

Pour i = 2 :

Le nœud 0 est marqué à t = 2, et le nœud 1 à t = 3.

Exemple 2 :

Input: edges = [[0,1]]
Output: [1,2]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1.

Pour i = 1 :

Le nœud 0 est marqué à t = 2.

Exemple 3 :

Input: edges = [[2,4],[0,1],[2,3],[0,2]]
Output: [4,6,3,5,5]
Explication :

Contraintes :

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
L'entrée est générée de sorte que edges représente un arbre valide.

Il existe un arbre non orienté avec n nœuds numérotés de 0 à n - 1. On vous donne un tableau d'entiers 2D, edges, de longueur n - 1, où edges[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans l'arbre.
Initialement, tous les nœuds sont non marqués. Pour chaque nœud i :

Si i est impair, le nœud sera marqué au temps x s'il y a au moins un nœud adjacent à lui qui a été marqué au temps x - 1.
Si i est pair, le nœud sera marqué au temps x s'il y a au moins un nœud adjacent à lui qui a été marqué au temps x - 2.

Retournez un tableau times où times[i] est le temps où tous les nœuds sont marqués dans l'arbre, si vous marquez le nœud i au temps t = 0.
Notez que la réponse pour chaque times[i] est indépendante, c'est-à-dire que lorsque vous marquez le nœud i, tous les autres nœuds sont non marqués.

Exemple 1 :

Entrée : edges = [[0,1],[0,2]]
Sortie : [2,4,3]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1, et le nœud 2 à t = 2.

Pour i = 1 :

Le nœud 0 est marqué à t = 2, et le nœud 2 à t = 4.

Pour i = 2 :

Le nœud 0 est marqué à t = 2, et le nœud 1 à t = 3.

Exemple 2 :

Entrée : edges = [[0,1]]
Sortie : [1,2]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1.

Pour i = 1 :

Le nœud 0 est marqué à t = 2.

Exemple 3 :

Entrée : edges = [[2,4],[0,1],[2,3],[0,2]]
Sortie : [4,6,3,5,5]
Explication :

Contraintes :

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
L'entrée est générée de sorte que edges représente un arbre valide.

Il existe un arbre non orienté avec n nœuds numérotés de 0 à n - 1. On vous donne un tableau entier 2D arêtes de longueur n - 1, où arêtes[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans l'arbre.
Au départ, tous les nœuds ne sont pas marqués. Pour chaque nœud i :

Si i est impair, le nœud sera marqué à l'instant x s'il y a au moins un nœud adjacent à lui qui a été marqué à l'instant x - 1.
Si i est pair, le nœud sera marqué à l'instant x s'il y a au moins un nœud adjacent à lui qui a été marqué à l'instant x - 2.

Renvoie un tableau times où times[i] est le moment où tous les nœuds sont marqués dans l'arbre, si vous marquez le nœud i à l'instant t = 0.
Notez que la réponse pour chaque times[i] est indépendante, c'est-à-dire que lorsque vous marquez le nœud i, tous les autres nœuds ne sont pas marqués.

Exemple 1 :

Entrée : edges = [[0,1],[0,2]]
Sortie : [2,4,3]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1 et le nœud 2 à t = 2.

Pour i = 1 :

Le nœud 0 est marqué à t = 2 et le nœud 2 à t = 4.

Pour i = 2 :

Le nœud 0 est marqué à t = 2 et le nœud 1 à t = 3.

Exemple 2 :

Entrée : edges = [[0,1]]
Sortie : [1,2]
Explication :

Pour i = 0 :

Le nœud 1 est marqué à t = 1.

Pour i = 1 :

Le nœud 0 est marqué à t = 2.

Exemple 3 :

Entrée : edges = [[2,4],[0,1],[2,3],[0,2]]
Sortie : [4,6,3,5,5]
Explication :

Contraintes :

2 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= edges[i][0], edges[i][1] <= n - 1
L'entrée est générée de telle sorte que edge représente un arbre valide.


On vous donne N fonctions linéaires f_1, f_2, \ldots, f_N, où f_i(x) = A_i x + B_i.
Trouvez la valeur maximale possible de f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) pour une séquence p = (p_1, p_2, \ldots, p_K) de K entiers distincts compris entre 1 et N, inclus.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Sortie

Imprimez la réponse sous forme d'entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
2 3
1 5
4 2

Exemple de sortie 1

26

Voici tous les p possibles et les valeurs correspondantes 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

Par conséquent, imprimez 26.

Exemple d'entrée 2

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

Exemple de sortie 2

216223

Vous disposez de N fonctions linéaires f_1, f_2, \ldots, f_N, où f_i(x) = A_i x + B_i.
Trouvez la valeur maximale possible de f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) pour une séquence p = (p_1, p_2, \ldots, p_K) de K entiers distincts entre 1 et N, inclusivement.

Entrée

L'entrée est donnée depuis l'entrée standard au format suivant :
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Sortie

Affichez la réponse sous forme d'un entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
2 3
1 5
4 2

Exemple de sortie 1

26

Voici toutes les valeurs possibles de p et les valeurs correspondantes 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

Ainsi, affichez 26.

Exemple d'entrée 2

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

Exemple de sortie 2

216223

On vous donne N fonctions linéaires f_1, f_2, \ldots, f_N, où f_i(x) = A_i x + B_i.
Trouvez la valeur maximale possible de f_{p_1}(f_{p_2}(\ldots f_{p_K}(1) \ldots )) pour une séquence p = (p_1, p_2, \ldots, p_K) de K entiers distincts entre 1 et N, inclusivement.

Entrée

L'entrée est donnée depuis l'entrée standard au format suivant :
N K
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Sortie

Affichez la réponse sous forme d'un entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
2 3
1 5
4 2

Exemple de sortie 1

26

Voici toutes les valeurs possibles de p et les valeurs correspondantes 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

Par conséquent, affichez 26.

Exemple d'entrée 2

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

Exemple de sortie 2

216223


On vous donne un texte écrit horizontalement. Convertissez-le en écriture verticale, en remplissant les espaces avec des *.

Vous avez N chaînes S_1, S_2, \dots, S_N composées de lettres minuscules anglaises. Soit M la longueur maximale de ces chaînes.
Affichez M chaînes T_1, T_2, \dots, T_M qui satisfont les conditions suivantes :

- Chaque T_i est composée de lettres minuscules anglaises et de *.
- Chaque T_i ne se termine pas par *.
- Pour chaque 1 \leq i \leq N, il est vrai que :
- Pour chaque 1 \leq j \leq |S_i|, le (N-i+1)-ème caractère de T_j existe, et la concaténation des (N-i+1)-èmes caractères de T_1, T_2, \dots, T_{|S_i|} dans cet ordre est égale à S_i.
- Pour chaque |S_i| + 1 \leq j \leq M, le (N-i+1)-ème caractère de T_j n'existe pas ou est *.

Ici, |S_i| désigne la longueur de la chaîne S_i.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N
S_1
S_2
\vdots
S_N

Sortie

Affichez la réponse dans le format suivant :
T_1
T_2
\vdots
T_M

Contraintes

- N est un entier entre 1 et 100, inclus.
- Chaque S_i est une chaîne de lettres minuscules anglaises de longueur entre 1 et 100, inclus.

Exemple d'entrée 1

3
abc
de
fghi

Exemple de sortie 1

fda
geb
h*c
i

Placer * comme 2ème caractère de T_3 met le c à la position correcte.
En revanche, placer * comme 2ème et 3ème caractères de T_4 ferait que T_4 se termine par *, ce qui viole la condition.

Exemple d'entrée 2

3
atcoder
beginner
contest

Exemple de sortie 2

cba
oet
ngc
tio
end
sne
ter
*r

Vous avez un texte écrit horizontalement. Convertissez-le en écriture verticale, en remplissant les espaces avec *.

Vous avez N chaînes S_1, S_2, \dots, S_N composées de lettres minuscules anglaises. Soit M la longueur maximale de ces chaînes. Imprimez M chaînes T_1, T_2, \dots, T_M qui satisfont les conditions suivantes :

- Chaque T_i est composée de lettres minuscules anglaises et de *.
- Chaque T_i ne se termine pas par *.
- Pour chaque 1 \leq i \leq N, il est satisfait que :
- Pour chaque 1 \leq j \leq |S_i|, le (N-i+1)-ème caractère de T_j existe, et la concaténation des (N-i+1)-èmes caractères de T_1, T_2, \dots, T_{|S_i|} dans cet ordre est égale à S_i.
- Pour chaque |S_i| + 1 \leq j \leq M, le (N-i+1)-ème caractère de T_j n'existe pas ou est *.

Ici, |S_i| désigne la longueur de la chaîne S_i.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N
S_1
S_2
\vdots
S_N

Sortie

Affichez la réponse dans le format suivant :
T_1
T_2
\vdots
T_M

Contraintes

- N est un entier entre 1 et 100, inclus.
- Chaque S_i est une chaîne de lettres minuscules anglaises de longueur entre 1 et 100, inclus.

Exemple d'entrée 1

3
abc
de
fghi

Exemple de sortie 1

fda
geb
h*c
i

Placer * comme 2ème caractère de T_3 met le c à la position correcte.
En revanche, placer * comme 2ème et 3ème caractères de T_4 ferait que T_4 se termine par *, ce qui viole la condition.

Exemple d'entrée 2

3
atcoder
beginner
contest

Exemple de sortie 2

cba
oet
ngc
tio
end
sne
ter
*r

On vous donne un texte écrit horizontalement. Convertissez-le en écriture verticale, en remplissant les espaces par des *.

On vous donne N chaînes S_1, S_2, \dots, S_N composées de lettres anglaises minuscules. Soit M la longueur maximale de ces chaînes.
Imprimez M chaînes T_1, T_2, \dots, T_M qui satisfont aux conditions suivantes :

- Chaque T_i est composée de lettres minuscules anglaises et de *.
- Chaque T_i ne se termine pas par *.
- Pour chaque 1 \leq i \leq N, ce qui suit est vrai :
- Pour chaque 1 \leq j \leq |S_i|, le (N-i+1)-ème caractère de T_j existe, et la concaténation des (N-i+1)-èmes caractères de T_1, T_2, \dots, T_{|S_i|} dans cet ordre est égale à S_i.
- Pour chaque |S_i| + 1 \leq j \leq M, le (N-i+1)-ème caractère de T_j soit n'existe pas, soit est *.

Ici, |S_i| représente la longueur de la chaîne S_i.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N
S_1
S_2
\vdots
S_N

Sortie

Imprimez la réponse dans le format suivant :
T_1
T_2
\vdots
T_M

Contraintes

- N est un nombre entier compris entre 1 et 100 inclus.
- Chaque S_i est une chaîne de lettres minuscules anglaises dont la longueur est comprise entre 1 et 100 inclus.

Exemple d'entrée 1

3
abc
de
fghi

Exemple de sortie 1

fda
geb
h*c
i

Le fait de placer * comme 2e caractère de T_3 place le c à la bonne position.
En revanche, si l'on place * comme 2e et 3e caractères de T_4, T_4 se terminera par *, ce qui est contraire à la condition.

Exemple d'entrée 2

3
atcoder
débutant
concours

Exemple de sortie 2

cba
oet
ngc
tio
fin
sne
ter
*r


On donne N points (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) dans un plan bidimensionnel, et un entier non négatif D.
Trouvez le nombre de paires entières (x, y) telles que \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Sortie

Affichez la réponse.

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 3
0 0
1 0

Exemple de sortie 1

8

La figure suivante permet de visualiser l'entrée et la réponse pour l'exemple 1. Les points bleus représentent l'entrée. Les points bleus et rouges, huit au total, satisfont la condition de l'énoncé.

Exemple d'entrée 2

2 0
0 0
2 0

Exemple de sortie 2

0

Exemple d'entrée 3

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

Exemple de sortie 3

419

On vous donne N points (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) sur un plan bidimensionnel et un entier non négatif D.
Trouvez le nombre de paires entières (x, y) tel que \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Sortie

Imprimez la réponse.

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d’entrée sont des entiers.

Exemple d’entrée 1

2 3
0 0
1 0

Sortie de l’échantillon 1

8

La figure suivante visualise l’entrée et la réponse pour l’exemple 1. Les points bleus représentent l’entrée. Les points bleu et rouge, soit huit au total, satisfont à la condition de l’énoncé.

Exemple d’entrée 2

2 0
0 0
2 0

Exemple de sortie 2

0

Exemple d’entrée 3

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

Exemple de sortie 3

419

On vous donne N points (x_1, y_1), (x_2, y_2), \dots, (x_N, y_N) sur un plan bidimensionnel et un entier non négatif D.
Trouvez le nombre de paires d'entiers (x, y) telles que \displaystyle \sum_{i=1}^N (|x-x_i|+|y-y_i|) \leq D.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N D
x_1 y_1
x_2 y_2
\vdots
x_N y_N

Sortie

Imprimez la réponse.

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 3
0 0
1 0

Exemple de sortie 1

8

La figure suivante visualise l'entrée et la réponse pour l'échantillon 1. Les points bleus représentent l'entrée. Les points bleus et rouges, huit au total, satisfont la condition de l'énoncé.

Exemple d'entrée 2

2 0
0 0
2 0

Exemple de sortie 2

0

Exemple d'entrée 3

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

Exemple de sortie 3

419


On vous donne un entier positif N, et un entier A_{x,y,z} pour chaque triplet d'entiers (x, y, z) tel que 1 \leq x, y, z \leq N. Vous recevrez Q requêtes dans le format suivant, qui doivent être traitées dans l'ordre. Pour la i-ème requête (1 \leq i \leq Q), vous recevez un tuple d'entiers (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i) tel que 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N, et 1 \leq Lz_i \leq Rz_i \leq N. Trouvez :
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
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

Sortie

Affichez Q lignes.
La i-ème ligne doit contenir la réponse à la i-ème requête.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

10
26

Pour la 1ère requête, la valeur recherchée est A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Ainsi, affichez 10. Pour la 2ème requête, la valeur recherchée est A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Ainsi, affichez 26.

Exemple d'entrée 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

Exemple de sortie 2

687
3917
551
1631
5180
3311
1010
4326

On vous donne un entier positif N et un entier A_{x,y,z} pour chaque triplet d'entiers (x, y, z) tel que 1 \leq x, y, z \leq N.
On vous donne des requêtes Q au format suivant, qui doivent être traitées dans l'ordre.
Pour la i-ème requête (1 \leq i \leq Q), on vous donne un tuple d'entiers (Lx_i, Rx_i, Ly_i, Ry_i, Lz_i, Rz_i) tels que 1 \leq Lx_i \leq Rx_i \leq N, 1 \leq Ly_i \leq Ry_i \leq N et 1 \leq Lz_i \leq Rz_i \leq N. Trouvez :
\displaystyle{\sum_{x=Lx_i}^{Rx_i} \sum_{y=Ly_i}^{Ry_i} \sum_{z=Lz_i}^{Rz_i} A_{x,y,z}}.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
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

Sortie

Imprimer les lignes Q.
La i-ème ligne doit contenir la réponse à la i-ème requête.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

10
26

Pour la 1ère requête, la valeur recherchée est A_{1,2,1} + A_{2,2,1} = 3 + 7 = 10. Ainsi, imprimez 10.
Pour la 2ème requête, la valeur recherchée est A_{2,1,1} + A_{2,1,2} + A_{2,2,1} + A_{2,2,2} = 5 + 6 + 7 + 8 = 26. Ainsi, imprimez 26.

Exemple d'entrée 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

Exemple de sortie 2

687
3917
551
1631
5180
3311
1010
4326


Une élection municipale a lieu dans la ville d'AtCoder. Les candidats sont Takahashi et Aoki.
Il y a N votes valides exprimés pour l'un des deux candidats, et le dépouillement est en cours. Ici, N est un nombre impair.
Le décompte actuel des voix est de T voix pour Takahashi et A voix pour Aoki.
Déterminez si le résultat de l'élection est déjà décidé à ce stade.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N T A

Sortie

Imprimez Yes si le résultat de l'élection est déjà décidé, et No sinon.

Contraintes

- 1 \leq N \leq 99
- N est un nombre impair.
- 0 \leq T, A \leq N
- T + A \leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

7 4 2

Exemple de sortie 1

Yes

Même si la voix restante va à Aoki, Takahashi gagnera toujours. C'est-à-dire que sa victoire est décidée, donc imprimez Yes.

Exemple d'entrée 2

99 12 48

Exemple de sortie 2

No

Bien qu'Aoki ait actuellement plus de voix, Takahashi gagnerait s'il recevait les 39 voix restantes. Par conséquent, imprimez No.

Exemple d'entrée 3

1 0 0

Exemple de sortie 3

No

Une élection municipale a lieu dans la ville d'AtCoder. Les candidats sont Takahashi et Aoki.
Il y a N votes valides exprimés pour chacun des deux candidats, et le dépouillement est actuellement en cours. Ici, N est un nombre impair.
Le décompte actuel des voix est de T voix pour Takahashi et A voix pour Aoki.
Déterminez si le résultat de l'élection est déjà décidé à ce stade.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N T A

Sortie

Afficher Yes si le résultat de l'élection est déjà décidé, et No sinon.

Contraintes

- 1 \leq N \leq 99
- N est un nombre impair.
- 0 \leq T, A \leq N
- T + A \leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

7 4 2

Exemple de sortie 1

Yes

Même si le dernier vote va à Aoki, Takahashi gagnera toujours. C'est-à-dire que sa victoire est décidée, donc affichez Yes.

Exemple d'entrée 2

99 12 48

Exemple de sortie 2

No

Bien qu'Aoki ait actuellement plus de voix, Takahashi gagnerait s'il recevait les 39 voix restantes. Par conséquent,affichez No.

Exemple d'entrée 3

1 0 0

Exemple de sortie 3

No

Une élection municipale a lieu à AtCoder City. Les candidats sont Takahashi et Aoki.
Il y a N votes valides exprimés pour l'un des deux candidats, et le décompte est actuellement en cours. Ici, N est un nombre impair.
Le décompte actuel des votes est T votes pour Takahashi et A votes pour Aoki.
Déterminer si le résultat de l'élection est déjà décidé à ce stade.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N T A

Sortie

Imprimer Oui si le résultat de l'élection est déjà décidé, et Non sinon.

Contraintes

- 1 \leq N \leq 99
- N est un nombre impair.
- 0 \leq T, A \leq N
- T + A \leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

7 4 2

Exemple de sortie 1

Yes

Même si le vote restant va à Aoki, Takahashi gagnera quand même. Autrement dit, sa victoire est décidée, alors écrivez Oui.

Exemple d'entrée 2

99 12 48

Exemple de sortie 2

No

Bien qu'Aoki ait actuellement plus de voix, Takahashi gagnerait s'il recevait les 39 voix restantes. Par conséquent, écrivez Non.

Exemple d'entrée 3

1 0 0

Exemple de sortie 3

No


Vous avez un sac vide.
Vous recevez Q requêtes, qui doivent être traitées dans l'ordre.
Il existe trois types de requêtes.

- 1 x : Mettez une balle avec l'entier x écrit dessus dans le sac.
- 2 x : Retirez une balle avec l'entier x écrit dessus du sac et jetez-la. Il est garanti que le sac possède une balle avec l'entier x écrit dessus lorsque cette requête est donnée.
- 3 : Affichez le nombre d'entiers différents écrits sur les balles dans le sac.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant :
Q
\text{requête}_1
\text{requête}_2
\vdots
\text{requête}_Q

La i-ème requête \text{requête}_i est donnée dans l'un des trois formats suivants :
1 x

2 x

3

Sortie

S'il y a K requêtes du troisième type, affichez K lignes.
La i-ème ligne (1 \leq i \leq K) doit contenir la réponse à la i-ème requête du troisième type.

Contraintes

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Lorsqu'une requête du deuxième type est donnée, le sac possède une balle avec l'entier x écrit dessus.
- Il y a au moins une requête du troisième type.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

3
2
3

Initialement, le sac est vide.
Pour la première requête 1 3, une balle avec l'entier 3 écrit dessus est mise dans le sac.
Pour la deuxième requête 1 1, une balle avec l'entier 1 écrit dessus est mise dans le sac.
Pour la troisième requête 1 4, une balle avec l'entier 4 écrit dessus est mise dans le sac.
Pour la quatrième requête 3, le sac a des balles avec les entiers 1, 3, 4, donc affichez 3.
Pour la cinquième requête 2 1, une balle avec l'entier 1 écrit dessus est retirée du sac.
Pour la sixième requête 3, le sac a des balles avec les entiers 3, 4, donc affichez 2.
Pour la septième requête 1 5, une balle avec l'entier 5 écrit dessus est mise dans le sac.
Pour la huitième requête 3, le sac a des balles avec les entiers 3, 4, 5, donc affichez 3.

Exemple d'entrée 2

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

Exemple de sortie 2

1
1

Vous avez un sac vide.
Vous recevez Q requêtes, qui doivent être traitées dans l'ordre.
Il existe trois types de requêtes.

- 1 x : Mettez une balle avec l'entier x écrit dessus dans le sac.
- 2 x : Retirez une balle avec l'entier x écrit dessus du sac et jetez-la. Il est garanti que le sac possède une balle avec l'entier x écrit dessus lorsque cette requête est donnée.
- 3 : Imprimez le nombre d'entiers différents écrits sur les balles dans le sac.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant :
Q
\text{requête}_1
\text{requête}_2
\vdots
\text{requête}_Q

La i-ème requête \text{requête}_i est donnée dans l'un des trois formats suivants :
1 x

2 x

3

Sortie

S'il y a K requêtes du troisième type, imprimez K lignes.
La i-ème ligne (1 \leq i \leq K) doit contenir la réponse à la i-ème requête du troisième type.

Contraintes

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Lorsqu'une requête du deuxième type est donnée, le sac possède une balle avec l'entier x écrit dessus.
- Il y a au moins une requête du troisième type.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

3
2
3

Initialement, le sac est vide.
Pour la première requête 1 3, une balle avec l'entier 3 écrit dessus entre dans le sac.
Pour la deuxième requête 1 1, une balle avec l'entier 1 écrit dessus entre dans le sac.
Pour la troisième requête 1 4, une balle avec l'entier 4 écrit dessus entre dans le sac.
Pour la quatrième requête 3, le sac a des balles avec les entiers 1, 3, 4, donc imprimez 3.
Pour la cinquième requête 2 1, une balle avec l'entier 1 écrit dessus est retirée du sac.
Pour la sixième requête 3, le sac a des balles avec les entiers 3, 4, donc imprimez 2.
Pour la septième requête 1 5, une balle avec l'entier 5 écrit dessus entre dans le sac.
Pour la huitième requête 3, le sac a des balles avec les entiers 3, 4, 5, donc imprimez 3.

Exemple d'entrée 2

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

Exemple de sortie 2

1
1

Vous avez un sac vide.
Vous recevez Q requêtes, qui doivent être traitées dans l'ordre.
Il existe trois types de requêtes.

- 1 x : Mettez une balle avec l'entier x écrit dessus dans le sac.
- 2 x : Retirez une balle avec l'entier x écrit dessus du sac et jetez-la. Il est garanti que le sac possède une balle avec l'entier x écrit dessus lorsque cette requête est donnée.
- 3 : Affichez le nombre d'entiers différents écrits sur les balles dans le sac.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant :
Q
\text{requête}_1
\text{requête}_2
\vdots
\text{requête}_Q

La i-ème requête \text{requête}_i est donnée dans l'un des trois formats suivants :
1 x

2 x

3

Sortie

S'il y a K requêtes du troisième type, affichez K lignes.
La i-ème ligne (1 \leq i \leq K) doit contenir la réponse à la i-ème requête du troisième type.

Contraintes

- 1 \leq Q \leq 2 \times 10^{5}
- 1 \leq x \leq 10^{6}
- Lorsqu'une requête du deuxième type est donnée, le sac possède une balle avec l'entier x écrit dessus.
- Il y a au moins une requête du troisième type.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

3
2
3

Initialement, le sac est vide.
Pour la première requête 1 3, une balle avec l'entier 3 écrit dessus entre dans le sac.
Pour la deuxième requête 1 1, une balle avec l'entier 1 écrit dessus entre dans le sac.
Pour la troisième requête 1 4, une balle avec l'entier 4 écrit dessus entre dans le sac.
Pour la quatrième requête 3, le sac a des balles avec les entiers 1, 3, 4, donc affichez 3.
Pour la cinquième requête 2 1, une balle avec l'entier 1 écrit dessus est retirée du sac.
Pour la sixième requête 3, le sac a des balles avec les entiers 3, 4, donc affichez 2.
Pour la septième requête 1 5, une balle avec l'entier 5 écrit dessus entre dans le sac.
Pour la huitième requête 3, le sac a des balles avec les entiers 3, 4, 5, donc affichez 3.

Exemple d'entrée 2

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

Exemple de sortie 2

1
1


On vous donne un graphe simple non orienté avec N sommets et M arêtes. La ième arête relie les sommets u_i et v_i de manière bidirectionnelle.
Déterminez s’il existe un moyen d’écrire un entier entre 1 et 2^{60} - 1, inclus, sur chaque sommet de ce graphe afin que la condition suivante soit satisfaite :

- Pour chaque sommet v de degré au moins 1, le XOR total des nombres inscrits sur ses sommets adjacents (à l’exclusion de v lui-même) est égal à 0.

Qu’est-ce que XOR ?

Le XOR de deux entiers non négatifs A et B, noté A oplus B, est défini comme suit :

- Dans la représentation binaire de A \oplus B, le bit à la position 2^k , (k \geq 0) est 1 si et seulement si exactement l’un des bits à la position 2^k dans les représentations binaires de A et B est 1. Sinon, il est égal à 0.

Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110).

En général, le XOR au niveau du bit de k entiers p_1, \dots p_k est défini comme suit (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k).  On peut prouver que cela est indépendant de l’ordre des p_1, \dots, p_k.

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Sortie

S’il n’y a aucun moyen d’écrire des entiers satisfaisant à la condition, imprimez No.
Sinon, X_v soit l’entier écrit sur le sommet v et imprimez votre solution au format suivant. S’il existe plusieurs solutions, n’importe laquelle d’entre elles sera acceptée.
Yes
X_1 X_2 \dots X_N

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d’entrée sont des entiers.

Exemple d’entrée 1

3 3
1 2
1 3
2 3

Sortie de l’échantillon 1

Yes
4 4 4

D’autres solutions acceptables incluent l’écriture (2,2,2) ou (3,3,3).

Exemple d’entrée 2

2 1
1 2

Exemple de sortie 2

No

Exemple d’entrée 3

1 0

Exemple de sortie 3

Yes
1

Tout entier compris entre 1 et 2^{60} - 1 peut être écrit.

Entrée d’échantillon 4

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

Exemple de sortie 4

Yes
12 4 4 8

Vous avez un graphe non orienté simple avec N sommets et M arêtes. La i-ème arête connecte les sommets u_i et v_i bidirectionnellement.
Déterminez s'il existe un moyen d'écrire un entier entre 1 et 2^{60} - 1, inclus, sur chaque sommet de ce graphe de telle sorte que la condition suivante soit satisfaite :

- Pour chaque sommet v avec un degré d'au moins 1, le total XOR des nombres écrits sur ses sommets adjacents (excluant v lui-même) est 0.

Qu'est-ce que le XOR ?

Le XOR de deux entiers non négatifs A et B, noté A \oplus B, est défini comme suit :

- Dans la représentation binaire de A \oplus B, le bit à la position 2^k \, (k \geq 0) est 1 si et seulement si exactement l'un des bits à la position 2^k dans les représentations binaires de A et B est 1. Sinon, il est 0.

Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110).

En général, le XOR bit à bit de k entiers p_1, \dots, p_k est défini comme (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k). Il peut être prouvé que cela est indépendant de l'ordre des p_1, \dots, p_k.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Sortie

S'il n'y a pas de moyen d'écrire des entiers satisfaisant la condition, imprimez No.
Sinon, soit X_v l'entier écrit sur le sommet v, et imprimez votre solution dans le format suivant. Si plusieurs solutions existent, l'une d'elles sera acceptée.
Yes
X_1 X_2 \dots X_N

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 3
1 2
1 3
2 3

Exemple de sortie 1

Yes
4 4 4

D'autres solutions acceptables incluent écrire (2,2,2) ou (3,3,3).

Exemple d'entrée 2

2 1
1 2

Exemple de sortie 2

No

Exemple d'entrée 3

1 0

Exemple de sortie 3

Yes
1

N'importe quel entier entre 1 et 2^{60} - 1 peut être écrit.

Exemple d'entrée 4

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

Exemple de sortie 4

Yes
12 4 4 8

Vous avez un graphe non orienté simple avec N sommets et M arêtes. La i-ème arête relie les sommets u_i et v_i bidirectionnellement.
Déterminez s'il existe un moyen d'écrire un entier entre 1 et 2^{60} - 1, inclus, sur chaque sommet de ce graphe de telle sorte que la condition suivante soit satisfaite :

- Pour chaque sommet v avec un degré d'au moins 1, le total XOR des nombres écrits sur ses sommets adjacents (excluant v lui-même) est 0.

Qu'est-ce que le XOR ?

Le XOR de deux entiers non négatifs A et B, noté A \oplus B, est défini comme suit :

- Dans la représentation binaire de A \oplus B, le bit à la position 2^k \, (k \geq 0) est 1 si et seulement si exactement l'un des bits à la position 2^k dans les représentations binaires de A et B est 1. Sinon, il est 0.

Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110).

En général, le XOR bit à bit de k entiers p_1, \dots, p_k est défini comme (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k).  Il peut être prouvé que cela est indépendant de l'ordre des p_1, \dots, p_k.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M
u_1 v_1
u_2 v_2
\vdots
u_M v_M

Sortie

S'il n'y a pas de moyen d'écrire des entiers satisfaisant la condition, affichez No.
Sinon, soit X_v l'entier écrit sur le sommet v, et affichez votre solution dans le format suivant. Si plusieurs solutions existent, l'une d'elles sera acceptée.
Yes
X_1 X_2 \dots X_N

Contraintes

- 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) pour i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 3
1 2
1 3
2 3

Exemple de sortie 1

Yes
4 4 4

D'autres solutions acceptables incluent d'écrire (2,2,2) ou (3,3,3).

Exemple d'entrée 2

2 1
1 2

Exemple de sortie 2

No

Exemple d'entrée 3

1 0

Exemple de sortie 3

Yes
1

N'importe quel entier entre 1 et 2^{60} - 1 peut être écrit.

Exemple d'entrée 4

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

Exemple de sortie 4

Yes
12 4 4 8


Vous avez une séquence X de longueur N où chaque élément est compris entre 1 et N, inclus, et une séquence A de longueur N. Affichez le résultat de l'opération suivante effectuée K fois sur A.

- Remplacez A par B tel que B_i = A_{X_i}.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N K
X_1 X_2 \dots X_N
A_1 A_2 \dots A_N

Sortie

Soit A' la séquence A après les opérations. Affichez-la dans le format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \le N \le 2 \times 10^5
- 0 \le K \le 10^{18}
- 1 \le X_i \le N
- 1 \le A_i \le 2 \times 10^5

Exemple d'entrée 1

7 3
5 2 6 3 1 4 6
1 2 3 5 7 9 11

Exemple de sortie 1

7 2 3 5 1 9 3

Dans cette entrée, X=(5,2,6,3,1,4,6) et la séquence initiale est A=(1,2,3,5,7,9,11).

- Après une opération, la séquence est (7,2,9,3,1,5,9).
- Après deux opérations, la séquence est (1,2,5,9,7,3,5).
- Après trois opérations, la séquence est (7,2,3,5,1,9,3).

Exemple d'entrée 2

4 0
3 4 1 2
4 3 2 1

Exemple de sortie 2

4 3 2 1

Il peut y avoir des cas où aucune opération n'est effectuée.

Exemple d'entrée 3

9 1000000000000000000
3 7 8 5 9 3 7 4 2
9 9 8 2 4 4 3 5 3

Exemple de sortie 3

3 3 3 3 3 3 3 3 3

On vous donne une séquence X de longueur N où chaque élément est compris entre 1 et N, inclus, et une séquence A de longueur N.
Imprimez le résultat de l'exécution de l'opération suivante K fois sur A.

- Remplacez A par B tel que B_i = A_{X_i}.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N K
X_1 X_2 \dots X_N
A_1 A_2 \dots A_N

Sortie

Soit A' la séquence A après les opérations. Imprimez-la au format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \le N \le 2 \times 10^5
- 0 \le K \le 10^{18}
- 1 \le X_i \le N
- 1 \le A_i \le 2 \times 10^5

Exemple d'entrée 1

7 3
5 2 6 3 1 4 6
1 2 3 5 7 9 11

Exemple de sortie 1

7 2 3 5 1 9 3

Dans cette entrée, X=(5,2,6,3,1,4,6) et la séquence initiale est A=(1,2,3,5,7,9,11).

- Après une opération, la séquence est (7,2,9,3,1,5,9).
- Après deux opérations, la séquence est (1,2,5,9,7,3,5).
- Après trois opérations, la séquence est (7,2,3,5,1,9,3).

Exemple d'entrée 2

4 0
3 4 1 2
4 3 2 1

Exemple de sortie 2

4 3 2 1

Il peut y avoir des cas où aucune opération n'est effectuée.

Exemple d'entrée 3

9 1000000000000000000
3 7 8 5 9 3 7 4 2
9 9 8 2 4 4 3 5 3

Exemple de sortie 3

3 3 3 3 3 3 3 3

Vous avez une séquence X de longueur N où chaque élément est compris entre 1 et N, inclus, et une séquence A de longueur N.
Affichez le résultat de l'opération suivante effectuée K fois sur A.

- Remplacez A par B tel que B_i = A_{X_i}.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N K
X_1 X_2 \dots X_N
A_1 A_2 \dots A_N

Sortie

Soit A' la séquence A après les opérations. Imprimez-la dans le format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \le N \le 2 \times 10^5
- 0 \le K \le 10^{18}
- 1 \le X_i \le N
- 1 \le A_i \le 2 \times 10^5

Exemple d'entrée 1

7 3
5 2 6 3 1 4 6
1 2 3 5 7 9 11

Exemple de sortie 1

7 2 3 5 1 9 3

Dans cette entrée, X=(5,2,6,3,1,4,6) et la séquence initiale est A=(1,2,3,5,7,9,11).

- Après une opération, la séquence est (7,2,9,3,1,5,9).
- Après deux opérations, la séquence est (1,2,5,9,7,3,5).
- Après trois opérations, la séquence est (7,2,3,5,1,9,3).

Exemple d'entrée 2

4 0
3 4 1 2
4 3 2 1

Exemple de sortie 2

4 3 2 1

Il peut y avoir des cas où aucune opération n'est effectuée.

Exemple d'entrée 3

9 1000000000000000000
3 7 8 5 9 3 7 4 2
9 9 8 2 4 4 3 5 3

Exemple de sortie 3

3 3 3 3 3 3 3 3 3


On vous donne deux séquences d'entiers positifs de longueur N : A=(A_1,A_2,\ldots,A_N) et B=(B_1,B_2,\ldots,B_N).
On vous donne Q requêtes à traiter dans l'ordre. La i-ème requête est expliquée ci-dessous.

- On vous donne des entiers positifs l_i, r_i, L_i, R_i. Affichez Yes s'il est possible de réarranger la sous-séquence (A_{l_i},A_{l_i+1},\ldots,A_{r_i}) pour qu'elle corresponde à la sous-séquence (B_{L_i},B_{L_i+1},\ldots,B_{R_i}), et No sinon.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N Q
A_1 A_2 \ldots A_N
B_1 B_2 \ldots B_N
l_1 r_1 L_1 R_1
l_2 r_2 L_2 R_2
\vdots
l_Q r_Q L_Q R_Q

Sortie

Affichez Q lignes. La i-ème ligne doit contenir la réponse à la i-ème requête.

Contraintes

-  1\leq N,Q\leq 2\times 10^5
-  1\leq A_i,B_i\leq N
-  1\leq l_i \leq r_i\leq N
-  1\leq L_i \leq R_i\leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

Yes
No
No
Yes

- Pour la 1ère requête, il est possible de réarranger (1,2,3) pour qu'elle corresponde à (2,3,1). On affiche donc Yes.
- Pour la 2ème requête, il est impossible de réarranger (1,2) de quelque façon que ce soit pour qu'elle corresponde à (1,4,2). On affiche donc No.
- Pour la 3ème requête, il est impossible de réarranger (1,2,3,2) de quelque façon que ce soit pour qu'elle corresponde à (3,1,4,2). On affiche donc No.
- Pour la 4ème requête, il est possible de réarranger (1,2,3,2,4) pour qu'elle corresponde à (2,3,1,4,2). On affiche donc Yes.

Exemple d'entrée 2

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

Exemple de sortie 2

Yes
Yes
No
No

On vous donne deux séquences d'entiers positifs de longueur N : A=(A_1,A_2,\ldots,A_N) et B=(B_1,B_2,\ldots,B_N).
On vous donne Q requêtes à traiter dans l'ordre. La i-ème requête est expliquée ci-dessous.

- On vous donne des entiers positifs l_i, r_i, L_i, R_i. Imprimez Yes s'il est possible de réarranger la sous-séquence (A_{l_i},A_{l_i+1},\ldots,A_{r_i}) pour qu'elle corresponde à la sous-séquence (B_{L_i},B_{L_i+1},\ldots,B_{R_i}), et No sinon.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N Q
A_1 A_2 \ldots A_N
B_1 B_2 \ldots B_N
l_1 r_1 L_1 R_1
l_2 r_2 L_2 R_2
\vdots
l_Q r_Q L_Q R_Q

Sortie

Imprimez Q lignes. La i-ème ligne doit contenir la réponse à la i-ème requête.

Contraintes

-  1\leq N,Q\leq 2\times 10^5
-  1\leq A_i,B_i\leq N
-  1\leq l_i \leq r_i\leq N
-  1\leq L_i \leq R_i\leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

Yes
No
No
Yes

- Pour la 1ère requête, il est possible de réarranger (1,2,3) pour qu'elle corresponde à (2,3,1). On imprime donc Yes.
- Pour la 2ème requête, il est impossible de réarranger (1,2) de quelque façon que ce soit pour qu'elle corresponde à (1,4,2). On imprime donc No.
- Pour la 3ème requête, il est impossible de réarranger (1,2,3,2) de quelque façon que ce soit pour qu'elle corresponde à (3,1,4,2). On imprime donc No.
- Pour la 4ème requête, il est possible de réarranger (1,2,3,2,4) pour qu'elle corresponde à (2,3,1,4,2). On imprime donc Yes.

Exemple d'entrée 2

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

Exemple de sortie 2

Yes
Yes
No
No

On vous donne des séquences d'entiers positifs de longueur N : A=(A_1,A_2,\ldots,A_N) et B=(B_1,B_2,\ldots,B_N).
On vous donne Q requêtes à traiter dans l'ordre. La i-ième requête est expliquée ci-dessous.

- On vous donne des entiers positifs l_i,r_i,L_i,R_i. Imprimez Yes s'il est possible de réarranger la sous-séquence (A_{l_i},A_{l_i+1},\ldots,A_{r_i}) pour qu'elle corresponde à la sous-séquence (B_{L_i},B_{L_i+1},\ldots,B_{R_i}), et No dans le cas contraire.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N Q
A_1 A_2 \ldots A_N
B_1 B_2 \ldots B_N
l_1 r_1 L_1 R_1
l_2 r_2 L_2 R_2
\vdots
l_Q r_Q L_Q R_Q

Sortie

Imprimer Q lignes. La i-ième ligne doit contenir la réponse à la i-ième requête.

Contraintes

-  1\leq N,Q\leq 2\times 10^5
-  1\leq A_i,B_i\leq N
-  1\leq l_i \leq r_i\leq N
-  1\leq L_i \leq R_i\leq N
- Toutes les valeurs d'entrée sont des nombres entiers.

Exemple d'entrée 1

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

Exemple de sortie 1

Yes
No
No
Yes

- Pour la première requête, il est possible de réarranger (1,2,3) pour qu'il corresponde à (2,3,1). Par conséquent, nous imprimons Yes.
- Pour la 2ème requête, il est impossible de réarranger (1,2) de quelque manière que ce soit pour obtenir (1,4,2). Par conséquent, nous affichons No.
- Pour la 3ème requête, il est impossible de réarranger (1,2,3,2) de quelque manière que ce soit pour obtenir (3,1,4,2). Par conséquent, nous imprimons No.
- Pour la 4ème requête, il est possible de réarranger (1,2,3,2,4) pour qu'il corresponde à (2,3,1,4,2). Par conséquent, nous affichons Yes.

Exemple d'entrée 2

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

Exemple de sortie 2

Yes
Yes
No
No


Dans le Royaume d'AtCoder, les résidents doivent crier leur amour pour le takoyaki à A heures chaque jour.
Takahashi, qui vit dans le Royaume d'AtCoder, se couche à B heures et se réveille à C heures chaque jour (dans le format 24 heures). Il peut crier son amour pour le takoyaki quand il est éveillé, mais ne peut pas le faire quand il dort. Déterminez s'il peut crier son amour pour le takoyaki tous les jours. Ici, un jour a 24 heures, et son temps de sommeil est inférieur à 24 heures.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
A B C

Sortie

Imprimez Yes si Takahashi peut crier son amour pour le takoyaki tous les jours, et No sinon.

Contraintes

- 0\leq A,B,C\lt 24
- A, B et C sont tous différents.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

21 8 14

Exemple de sortie 1

Yes

Takahashi se couche à 8 heures et se réveille à 14 heures chaque jour. Il est éveillé à 21 heures, donc il peut crier son amour pour le takoyaki tous les jours. Par conséquent, imprimez Yes.

Exemple d'entrée 2

0 21 7

Exemple de sortie 2

No

Takahashi se couche à 21 heures et se réveille à 7 heures chaque jour. Il n'est pas éveillé à 0 heure, donc il ne peut pas crier son amour pour le takoyaki tous les jours. Par conséquent, imprimez No.

Exemple d'entrée 3

10 7 17

Exemple de sortie 3

No

Dans le Royaume d'AtCoder, les habitants doivent crier leur amour pour le takoyaki à A heures chaque jour.
Takahashi, qui vit dans le Royaume d'AtCoder, se couche à B heures et se réveille à C heures chaque jour (dans le format 24 heures). Il peut crier son amour pour le takoyaki quand il est éveillé, mais ne peut pas le faire quand il dort. Déterminez s'il peut crier son amour pour le takoyaki tous les jours. Ici, un jour dure 24 heures, et son temps de sommeil est inférieur à 24 heures.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
A B C

Sortie

Affichez Yes si Takahashi peut crier son amour pour le takoyaki tous les jours, et No sinon.

Contraintes

- 0\leq A,B,C\lt 24
- A, B et C sont tous différents.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

21 8 14

Exemple de sortie 1

Yes

Takahashi se couche à 8 heures et se réveille à 14 heures chaque jour. Il est éveillé à 21 heures, donc il peut crier son amour pour le takoyaki tous les jours. Par conséquent, affichez Yes.

Exemple d'entrée 2

0 21 7

Exemple de sortie 2

No

Takahashi se couche à 21 heures et se réveille à 7 heures chaque jour. Il n'est pas éveillé à 0 heure, donc il ne peut pas crier son amour pour le takoyaki tous les jours. Par conséquent, affichez No.

Exemple d'entrée 3

10 7 17

Exemple de sortie 3

No

Dans le Royaume d'AtCoder, les habitants doivent crier leur amour pour le takoyaki à A heures tous les jours.
Takahashi, qui vit dans le Royaume d'AtCoder, se couche à B heures et se réveille à C heures tous les jours (dans l'horloge de 24 heures). Il peut crier son amour pour le takoyaki lorsqu'il est éveillé, mais pas lorsqu'il dort. Déterminez s'il peut crier son amour pour le takoyaki tous les jours. Ici, un jour a 24 heures et son temps de sommeil est inférieur à 24 heures.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
A B C

Sortie

Afficher Oui si Takahashi peut crier son amour pour le takoyaki tous les jours, et Non sinon.

Contraintes

- 0\leq A,B,C\lt 24
- A, B et C sont deux à deux différents.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

21 8 14

Exemple de sortie 1

Yes

Takahashi se couche à 8 heures et se réveille à 14 heures tous les jours. Il est réveillé à 21 heures, il peut donc crier son amour pour le takoyaki tous les jours. Par conséquent, écrivez Oui.

Exemple d'entrée 2

0 21 7

Exemple de sortie 2

No

Takahashi se couche à 21 heures et se réveille à 7 heures tous les jours. Il n'est pas réveillé à 0 heure, il ne peut donc pas crier son amour pour le takoyaki tous les jours. Par conséquent, écrivez Non.

Exemple d'entrée 3

10 7 17

Exemple de sortie 3

No


Vous avez des entiers positifs N, M, K et une séquence d'entiers non négatifs : A=(A_1,A_2,\ldots,A_N).
Pour une séquence de non-négatifs non vide B=(B_1,B_2,\ldots,B_{|B|}), nous définissons son score comme suit.

- Si la longueur de B est un multiple de M : (B_1 \oplus B_2 \oplus \dots \oplus B_{|B|})^K
- Sinon : 0

Ici, \oplus représente l'opérateur bit à bit XOR.
Trouvez la somme, modulo 998244353, des scores des 2^N-1 sous-séquences non vides de A.
Qu'est-ce que l'opérateur bit à bit XOR ? L'opérateur bit à bit XOR des entiers non négatifs A et B, noté A \oplus B, est défini comme suit : - Dans la représentation binaire de A \oplus B, le chiffre à la position 2^k (k \geq 0) est 1 si exactement un de A et B a un 1 à cette position dans leurs représentations binaires, et 0 sinon. Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110). En général, le XOR de k entiers p_1, \dots, p_k est défini comme (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k), et il peut être prouvé que cela est indépendant de l'ordre de p_1, \dots, p_k.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
A_1 A_2 \ldots A_N

Sortie

Affichez la réponse.

Contraintes

- 1 \leq N,K \leq 2 \times 10^5
- 1 \leq M \leq 100
- 0 \leq A_i < 2^{20}
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2 2
1 2 3

Exemple de sortie 1

14

Voici les scores des 2^3-1=7 sous-séquences non vides de A.

- (1) : 0
- (2) : 0
- (3) : 0
- (1,2) : (1\oplus2)^2=9
- (1,3) : (1\oplus3)^2=4
- (2,3) : (2\oplus3)^2=1
- (1,2,3) : 0

Par conséquent, la somme cherchée est 0+0+0+9+4+1+0=14.

Exemple d'entrée 2

10 5 3
100 100 100 100 100 100 100 100 100 100

Exemple de sortie 2

252000000

Exemple d'entrée 3

16 4 100
7053 3876 3178 8422 7802 5998 2334 6757 6889 6637 7365 9495 7848 9026 7312 6558

Exemple de sortie 3

432440016

Vous avez des entiers positifs N, M, K et une séquence d'entiers non négatifs : A=(A_1,A_2,\ldots,A_N).
Pour une séquence de non-négatifs non vide B=(B_1,B_2,\ldots,B_{|B|}), nous définissons son score comme suit.

- Si la longueur de B est un multiple de M : (B_1 \oplus B_2 \oplus \dots \oplus B_{|B|})^K
- Sinon : 0

Ici, \oplus représente le XOR bit à bit.
Trouvez la somme, modulo 998244353, des scores des 2^N-1 sous-séquences non vides de A.
Qu'est-ce que le XOR bit à bit ? Le XOR bit à bit des entiers non négatifs A et B, noté A \oplus B, est défini comme suit : - Dans la représentation binaire de A \oplus B, le chiffre à la position 2^k (k \geq 0) est 1 si exactement un de A et B a un 1 à cette position dans leurs représentations binaires, et 0 sinon. Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110). En général, le XOR de k entiers p_1, \dots, p_k est défini comme (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k), et il peut être prouvé que cela est indépendant de l'ordre de p_1, \dots, p_k.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
A_1 A_2 \ldots A_N

Sortie

Affichez la réponse.

Contraintes

- 1 \leq N,K \leq 2 \times 10^5
- 1 \leq M \leq 100
- 0 \leq A_i < 2^{20}
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2 2
1 2 3

Exemple de sortie 1

14

Voici les scores des 2^3-1=7 sous-séquences non vides de A.

- (1) : 0
- (2) : 0
- (3) : 0
- (1,2) : (1\oplus2)^2=9
- (1,3) : (1\oplus3)^2=4
- (2,3) : (2\oplus3)^2=1
- (1,2,3) : 0

Par conséquent, la somme cherchée est 0+0+0+9+4+1+0=14.

Exemple d'entrée 2

10 5 3
100 100 100 100 100 100 100 100 100 100

Exemple de sortie 2

252000000

Exemple d'entrée 3

16 4 100
7053 3876 3178 8422 7802 5998 2334 6757 6889 6637 7365 9495 7848 9026 7312 6558

Exemple de sortie 3

432440016

On vous donne des entiers positifs N, M, K et une séquence d’entiers non négatifs : A=(A_1,A_2,\ldots,A_N).
Pour une séquence d’entiers non vide non négatif B=(B_1,B_2,\ldots,B_{|B|}), nous définissons son score comme suit.

- Si la longueur de B est un multiple de M : (B_1 \oplus B_2 \oplus \dots \oplus B_{|B|})^K
- Sinon : 0

Ici, \oplus représente le XOR au niveau du bit.
Trouvez la somme, modulo 998244353, des scores des sous-suites non vides 2^N-1 de A.
Qu’est-ce que le XOR au niveau du bit ? Le XOR au niveau du bit des entiers non négatifs A et B, noté A \oplus B, est défini comme suit : - Dans la représentation binaire de A \oplus B, le chiffre à la position 2^k (k \geq 0) est 1 si exactement l’un des deux A et B a un 1 dans cette position dans leurs représentations binaires, et 0 sinon. Par exemple, 3 \oplus 5 = 6 (en binaire : 011 \oplus 101 = 110). En général, le XOR de k entiers p_1, \dots, p_k est défini comme (\cdots ((p_1 \oplus p_2) \oplus p_3) \oplus \cdots \oplus p_k), et il peut être prouvé que cela est indépendant de l'ordre de p_1, \dots, p_k.

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
N M K
A_1 A_2 \ldots A_N

Sortie

Imprimez la réponse.

Contraintes

- 1 \leq N,K \leq 2 \times 10^5
- 1 \leq M \leq 100
- 0 \leq A_i < 2^{20}
- Toutes les valeurs d’entrée sont des entiers.

Exemple d’entrée 1

3 2 2
1 2 3

Sortie de l’échantillon 1

14

Voici les scores des sous-suites non vides 2^3-1=7 de A.

- (1): 0
- (2): 0
- (3): 0
- (1,2): (1\oplus2)^2=9
- (1,3): (1\oplus3)^2=4
- (2,3): (2\oplus3)^2=1
- (1,2,3): 0

Par conséquent, la somme recherchée est 0+0+0+9+4+1+0=14.

Exemple d’entrée 2

10 5 3
100 100 100 100 100 100 100 100 100 100

Exemple de sortie 2

252000000

Exemple d’entrée 3

16 4 100
7053 3876 3178 8422 7802 5998 2334 6757 6889 6637 7365 9495 7848 9026 7312 6558

Exemple de sortie 3

432440016


Un nombre réel X est donné avec une précision de trois décimales.
Affichez le nombre réel X selon les conditions suivantes.

- La partie décimale ne doit pas avoir de zéros traînants.
- Il ne doit pas y avoir de point décimal inutilement traînant.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
X

Sortie

Affichez la réponse.

Contraintes

- 0 \le X < 100
- X est donné avec une précision de trois décimales.

Exemple d'entrée 1

1.012

Exemple de sortie 1

1.012

1.012 peut être imprimé tel quel est.

Exemple d'entrée 2

12.340

Exemple de sortie 2

12.34

Imprimer 12.340 sans le zéro traînant donne 12.34.

Exemple d'entrée 3

99.900

Exemple de sortie 3

99.9

Imprimer 99.900 sans les zéros traînants donne 99.9.

Exemple d'entrée 4

0.000

Exemple de sortie 4

0

Imprimer 0.000 sans 0s traînants ni un point décimal inutile donne 0.

Un nombre réel X est donné avec une précision de trois décimales.
Affichez le nombre réel X selon les conditions suivantes.

- La partie décimale ne doit pas avoir de zéros traînants.
- Il ne doit pas y avoir de point décimal inutilement traînant.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
X

Sortie

Affichez la réponse.

Contraintes

- 0 \le X < 100
- X est donné avec une précision de trois décimales.

Exemple d'entrée 1

1.012

Exemple de sortie 1

1.012

1.012 peut être affiché tel quel.

Exemple d'entrée 2

12.340

Exemple de sortie 2

12.34

Affichez 12.340 sans le zéro traînant donne 12.34.

Exemple d'entrée 3

99.900

Exemple de sortie 3

99.9

Affichez 99.900 sans les zéros traînants donne 99.9.

Exemple d'entrée 4

0.000

Exemple de sortie 4

0

Afficher 0.000 sans les zéros traînants ni point décimal inutile donne 0.

Un nombre réel X est donné à la troisième décimale.
Imprimez le nombre réel X dans les conditions suivantes.

- La partie décimale ne doit pas avoir de 0 à la fin.
- Il ne doit pas y avoir de décimale de fin inutile.

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
X

Sortie

Produisez la réponse.

Contraintes

- 0 \le X < 100
- X est donné à la troisième décimale.

Exemple d’entrée 1

1.012

Sortie de l’échantillon 1

1.012

1.012 peut être imprimé tel quel.

Exemple d’entrée 2

12.340

Exemple de sortie 2

12.34

L’impression de 12.340 sans le 0 de fin donne 12.34.

Exemple d’entrée 3

99.900

Exemple de sortie 3

99.9

L’impression de 99,900 sans les 0 de fin donne 99,9.

Entrée d’échantillon 4

0.000

Exemple de sortie 4

0

L’impression de 0,000 sans les 0 de fin ou la virgule décimale inutile donne 0.


Il y a N aires de repos autour d'un lac.
Les aires de repos sont numérotées 1, 2, ..., N dans l'ordre des aiguilles d'une montre.
Il faut A_i pas pour marcher dans le sens horaire de l'aire de repos i à l'aire de repos i+1 (où l'aire de repos N+1 désigne l'aire de repos 1).
Le nombre minimal de pas nécessaires pour marcher dans le sens horaire de l'aire de repos s à l'aire de repos t (s \neq t) est un multiple de M.
Trouver le nombre de paires possibles (s,t).

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M
A_1 A_2 \dots A_N

Sortie

Affichez la réponse en tant qu'entier.

Contraintes

- Toutes les valeurs d'entrée sont des entiers
- 2 \le N \le 2 \times 10^5
- 1 \le A_i \le 10^9
- 1 \le M \le 10^6

Exemple d'entrée 1

4 3
2 1 4 3

Exemple de sortie 1

4

- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 1 à l'aire de repos 2 est 2, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 1 à l'aire de repos 3 est 3, ce qui est un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 1 à l'aire de repos 4 est 7, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 2 à l'aire de repos 3 est 1, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 2 à l'aire de repos 4 est 5, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 2 à l'aire de repos 1 est 8, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 3 à l'aire de repos 4 est 4, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 3 à l'aire de repos 1 est 7, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 3 à l'aire de repos 2 est 9, ce qui est un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 4 à l'aire de repos 1 est 3, ce qui est un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 4 à l'aire de repos 2 est 5, ce qui n'est pas un multiple de 3.
- Le nombre minimal de pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos 4 à l'aire de repos 3 est 6, ce qui est un multiple de 3.

Par conséquent, il y a quatre paires possibles (s,t).

Exemple d'entrée 2

2 1000000
1 1

Exemple de sortie 2

0

Exemple d'entrée 3

9 5
9 9 8 2 4 4 3 5 3

Exemple de sortie 3

11

Il y a N aires de repos autour d'un lac.
Les aires de repos sont numérotées 1, 2, ..., N dans le sens des aiguilles d'une montre.
Il faut A_i pas pour marcher dans le sens des aiguilles d'une montre de l'aire de repos i à l'aire de repos i+1 (où l'aire de repos N+1 fait référence à l'aire de repos 1).
Le nombre minimum de pas requis pour marcher dans le sens des aiguilles d'une montre de l'aire de repos s à l'aire de repos t (s \neq t) est un multiple de M.
Trouver le nombre de paires possibles (s,t).

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M
A_1 A_2 \dots A_N

Sortie

Imprimer la réponse sous forme d'entier.

Contraintes

- Toutes les valeurs d'entrée sont des entiers
- 2 \le N \le 2 \times 10^5
- 1 \le A_i \le 10^9
- 1 \le M \le 10^6

Exemple d'entrée 1

4 3
2 1 4 3

Exemple de sortie 1

4

- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 1 à la zone de repos 2 est de 2, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 1 à la zone de repos 3 est de 3, ce qui est un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 1 à la zone de repos 4 est de 7, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 2 à la zone de repos 3 est de 1, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre depuis la zone de repos 2 à la zone de repos 4 est de 5, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 2 à la zone de repos 1 est de 8, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 3 à la zone de repos 4 est de 4, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 3 à la zone de repos 1 est de 7, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 3 à la zone de repos 2 est de 9, ce qui est un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 4 à la zone de repos 1 est de 3, ce qui est un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 4 à la zone de repos 2 est de 5, ce qui n'est pas un multiple de 3.
- Le nombre minimum de pas pour marcher dans le sens des aiguilles d'une montre de la zone de repos 4 à la zone de repos 3 est 6, qui est un multiple de 3.

Il y a donc quatre paires possibles (s,t).

Exemple d'entrée 2

2 1000000
1 1

Exemple de sortie 2

0

Exemple d'entrée 3

9 5
9 9 8 2 4 4 3 5 3

Exemple de sortie 3

11


Affichez toutes les séquences d'entiers de longueur N qui satisfont les conditions suivantes, dans l'ordre lexicographique croissant.

- Le i-ème élément est compris entre 1 et R_i, inclus.
- La somme de tous les éléments est un multiple de K.

Qu'est-ce que l'ordre lexicographique pour les séquences ?
Une séquence A = (A_1, \ldots, A_{|A|}) est lexicographiquement plus petite que B = (B_1, \ldots, B_{|B|}) si l'un des points 1. ou 2. ci-dessous est vérifié :

- |A|<|B| et (A_{1},\ldots,A_{|A|}) = (B_1,\ldots,B_{|A|}).
- Il existe un entier 1\leq i\leq \min\{|A|,|B|\} tel que les deux conditions suivantes soient vraies :

- (A_{1},\ldots,A_{i-1}) = (B_1,\ldots,B_{i-1})
- A_i < B_i

Entrée

L'entrée est donnée du Standard Input dans le format suivant :
N K
R_1 R_2 \dots R_N

Sortie

Imprimer la réponse dans le format suivant, où X est le nombre de séquences à imprimer, dont la i-ème est A_i=(A_{i,1},A_{i,2},\dots,A_{i,N}) :
A_{1,1} A_{1,2} \dots A_{1,N}
A_{2,1} A_{2,2} \dots A_{2,N}
\vdots
A_{X,1} A_{X,2} \dots A_{X,N}

Contraintes

- Toutes les valeurs d'entrée sont entières.
- 1 \le N \le 8
- 2 \le K \le 10
- 1 \le R_i \le 5

Exemple d'entrée 1

3 2
2 1 3

Exemple de sortie 1

1 1 2
2 1 1
2 1 3

Il y a trois séquences à afficher, qui sont (1,1,2),(2,1,1),(2,1,3) dans l'ordre lexicographique.

Exemple d'entrée 2

1 2
1

Exemple de sortie 2

Il peut n'y avoir aucune séquence à afficher.
Dans ce cas, le résultat peut être vide.

Exemple d'entrée 3

5 5
2 3 2 3 2

Exemple de sortie 3

1 1 1 1 1
1 2 2 3 2
1 3 1 3 2
1 3 2 2 2
1 3 2 3 1
2 1 2 3 2
2 2 1 3 2
2 2 2 2 2
2 2 2 3 1
2 3 1 2 2
2 3 1 3 1
2 3 2 1 2
2 3 2 2 1

Afficher toutes les séquences d'entiers de longueur N qui satisfont les conditions suivantes, dans l'ordre lexicographique croissant.

- Le i-ème élément est compris entre 1 et R_i, inclus.
- La somme de tous les éléments est un multiple de K.

 Qu'est-ce que l'ordre lexicographique pour les séquences?
Une séquence A = (A_1, \ldots, A_{|A|}) est lexicographiquement plus petite que B = (B_1, \ldots, B_{|B|}) Si l’une des conditions suivantes est vérifiée:

- |A|<|B| et (A_{1},\ldots,A_{|A|}) = (B_1,\ldots,B_{|A|}).
- Il existe un entier 1\leq i\leq \min\{|A|,|B|\} tel que les deux conditions suivantes soient vraies:

- (A_{1},\ldots,A_{i-1}) = (B_1,\ldots,B_{i-1})
- A_i < B_i

Entrée

L'information est donnée à partir de l'entrée standard dans le format suivant:
N K
R_1 R_2 \dots R_N

Sortie

Afficher la réponse dans le format suivant, where X est le nombre de séquences à afficher, dont la i-ème est A_i=(A_{i,1},A_{i,2},\dots,A_{i,N}):
A_{1,1} A_{1,2} \dots A_{1,N}
A_{2,1} A_{2,2} \dots A_{2,N}
\vdots
A_{X,1} A_{X,2} \dots A_{X,N}

Contraintes

- Toutes les valeurs d'entrée sont entières.
- 1 \le N \le 8
- 2 \le K \le 10
- 1 \le R_i \le 5

Exemple d'entrée 1

3 2
2 1 3

Exemple de sortie 1

1 1 2
2 1 1
2 1 3

Il y a trois séquences à afficher, qui sont (1,1,2),(2,1,1),(2,1,3) dans l'ordre lexicographique.

Exemple d'entrée 2

1 2
1

Exemple de sortie 2

Il peut n'y avoir aucune séquence à afficher.
Dans ce cas, la sortie peut être vide.

Exemple d'entrée 3

5 5
2 3 2 3 2

Exemple de sortie 3

1 1 1 1 1
1 2 2 3 2
1 3 1 3 2
1 3 2 2 2
1 3 2 3 1
2 1 2 3 2
2 2 1 3 2
2 2 2 2 2
2 2 2 3 1
2 3 1 2 2
2 3 1 3 1
2 3 2 1 2
2 3 2 2 1

Imprimez toutes les séquences entières de longueur N qui satisfont aux conditions suivantes, dans l'ordre lexicographique croissant.

- Le i-ème élément est compris entre 1 et R_i, inclus.
- La somme de tous les éléments est un multiple de K.

Quel est l'ordre lexicographique des séquences ?
Une séquence A = (A_1, \ldots, A_{|A|}) est lexicographiquement plus petite que B = (B_1, \ldots, B_{|B|}) si 1. ou 2. ci-dessous est vrai :

- |A|<|B| et (A_{1},\ldots,A_{|A|}) = (B_1,\ldots,B_{|A|}).
- Il existe un entier 1\leq i\leq \min\{|A|,|B|\} tel que les deux affirmations suivantes soient vraies :

- (A_{1},\ldots,A_{i-1}) = (B_1,\ldots,B_{i-1})
- A_i < B_i

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N K
R_1 R_2 \dots R_N

Sortie

Imprimez la réponse au format suivant, où X est le nombre de séquences à imprimer, dont la i-ème est A_i=(A_{i,1},A_{i,2},\dots,A_{i,N}) :
A_{1,1} A_{1,2} \dots A_{1,N}
A_{2,1} A_{2,2} \dots A_{2,N}
\vdots
A_{X,1} A_{X,2} \dots A_{X,N}

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \le N \le 8
- 2 \le K \le 10
- 1 \le R_i \le 5

Exemple d'entrée 1

3 2
2 1 3

Exemple de sortie 1

1 1 2
2 1 1
2 1 3

Il y a trois séquences à imprimer, qui sont (1,1,2),(2,1,1),(2,1,3) dans l'ordre lexicographique.

Exemple d'entrée 2

1 2
1

Exemple de sortie 2

Il peut n'y avoir aucune séquence à imprimer.
Dans ce cas, la sortie peut être vide.

Exemple d'entrée 3

5 5
2 3 2 3 2

Exemple de sortie 3

1 1 1 1 1
1 2 2 3 2
1 3 1 3 2
1 3 2 2 2
1 3 2 3 1
2 1 2 3 2
2 2 1 3 2
2 2 2 2 2
2 2 2 3 1
2 3 1 2 2
2 3 1 3 1
2 3 2 1 2
2 3 2 2 1