Pour les chaînes x et y, définissez f(x, y) comme suit :

- f(x, y) est la longueur du plus long préfixe commun de x et y.

On vous donne N chaînes (S_1, \ldots, S_N) composées de lettres minuscules anglaises. Déterminez la valeur de l’expression suivante :
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(S_i,S_j).

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
N
S_1 \ldots S_N

Sortie

Imprimez la réponse.

Contraintes

- 2 \leq N \leq 3\times 10^5
- S_i est une chaîne composée de lettres anglaises minuscules.
- 1 \leq |S_i|
- |S_1|+|S_2|+\ldots+|S_N|\leq 3\times 10^5
- Tous les nombres d’entrée sont des nombres entiers.

Exemple d’entrée 1

3
ab abc arc

Sortie de l'exemple 1

4

- f(S_1,S_2)=2
- f(S_1,S_3)=1
- f(S_2,S_3)=1

Ainsi, la réponse est f(S_1,S_2) + f(S_1,S_3) + f(S_2,S_3) = 4.

Exemple d’entrée 2

11
ab bb aaa bba baba babb aaaba aabbb a a b

Exemple de sortie 2

32

Pour les chaînes x et y, définissez f(x, y) comme suit :

- f(x, y) est la longueur du plus long préfixe commun de x et y.

On vous donne N chaînes (S_1, \ldots, S_N) composées de lettres minuscules anglaises. Trouvez la valeur de l'expression suivante :
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(S_i,S_j).

Entrée

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

Sortie

Affichez la réponse.

Contraintes

- 2 \leq N \leq 3\times 10^5
- S_i est une chaîne composée de lettres minuscules anglaises.
- 1 \leq |S_i|
- |S_1|+|S_2|+\ldots+|S_N|\leq 3\times 10^5
- Tous les nombres d'entrée sont des entiers.

Exemple d'entrée 1

3
ab abc arc

Exemple de sortie 1

4

- f(S_1,S_2)=2
- f(S_1,S_3)=1
- f(S_2,S_3)=1

Ainsi, la réponse est f(S_1,S_2) + f(S_1,S_3) + f(S_2,S_3) = 4.

Exemple d'entrée 2

11
ab bb aaa bba baba babb aaaba aabbb a a b

Exemple de sortie 2

32


Pour les entiers positifs x et y, définissez f(x, y) comme suit :

- Interprétez les représentations décimales de x et y comme des chaînes de caractères et concaténez-les dans cet ordre pour obtenir une chaîne z. La valeur de f(x, y) est la valeur de z lorsqu'elle est interprétée comme un entier décimal.

Par exemple, f(3, 14) = 314 et f(100, 1) = 1001.
On vous donne une séquence d'entiers positifs A = (A_1, \ldots, A_N) de longueur N. Trouvez la valeur de l'expression suivante modulo 998244353 :
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(A_i,A_j).

Entrée

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

Sortie

Affichez la réponse.

Contraintes

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

Exemple d'entrée 1

3
3 14 15

Exemple de sortie 1

2044

- f(A_1, A_2) = 314
- f(A_1, A_3) = 315
- f(A_2, A_3) = 1415

Ainsi, la réponse est f(A_1, A_2) + f(A_1, A_3) + f(A_2, A_3) = 2044.

Exemple d'entrée 2

5
1001 5 1000000 1000000000 100000

Exemple de sortie 2

625549048

Assurez-vous de calculer la valeur modulo 998244353.

Pour les entiers positifs x et y, définissez f(x, y) comme suit :

- Interprétez les représentations décimales de x et y comme des chaînes et concaténez-les dans cet ordre pour obtenir une chaîne z. La valeur de f(x, y) est la valeur de z lorsqu'elle est interprétée comme un entier décimal.

Par exemple, f(3, 14) = 314 et f(100, 1) = 1001.
On vous donne une séquence d'entiers positifs A = (A_1, \ldots, A_N) de longueur N. Trouvez la valeur de l'expression suivante modulo 998244353 :
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(A_i,A_j).

Entrée

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

Sortie

Imprimer la réponse.

Contraintes

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

Exemple d'entrée 1

3
3 14 15

Exemple de sortie 1

2044

- f(A_1, A_2) = 314
- f(A_1, A_3) = 315
- f(A_2, A_3) = 1415

Ainsi, la réponse est f(A_1, A_2) + f(A_1, A_3) + f(A_2, A_3) = 2044.

Exemple d'entrée 2

5
1001 5 1000000 1000000000 100000

Exemple de sortie 2

625549048

Assurez-vous de calculer la valeur modulo 998244353.


N utilisateurs d'AtCoder se sont réunis pour jouer à AtCoder RPS 2. Le nom du i-ème utilisateur est S_i et sa cote est C_i.
AtCoder RPS 2 se joue comme suit :

- Assignez les nombres 0, 1, \dots, N - 1 aux utilisateurs selon l'ordre lexicographique de leurs noms d'utilisateur.
- Soit T la somme des cotes des N utilisateurs. L'utilisateur auquel le nombre T \bmod N est attribué est le gagnant.

Affichez le nom d'utilisateur du gagnant.

Qu'est-ce que l'ordre lexicographique ?

L'ordre lexicographique, en termes simples, signifie "l'ordre dans lequel les mots apparaissent dans un dictionnaire." Plus précisément, l'algorithme pour déterminer l'ordre de deux chaînes distinctes S et T composées de lettres minuscules anglaises est le suivant :

Ici, "le i-ème caractère de S" est noté S_i. Si S est lexicographiquement plus petit que T, on écrit S \lt T, et si S est plus grand, on écrit S \gt T.

-  Soit L la longueur de la chaîne la plus courte parmi S et T. Vérifiez si S_i et T_i correspondent pour i=1,2,\dots,L.
-  S'il existe un i tel que S_i \neq T_i, soit j le plus petit de ces i. Comparez S_j et T_j. Si S_j est alphabétiquement plus petit que T_j, alors S \lt T. Sinon, S \gt T. L'algorithme s'arrête ici.

-  S'il n'existe pas de i tel que S_i \neq T_i, comparez les longueurs de S et T. Si S est plus court que T, alors S \lt T. Si S est plus long, alors S \gt T. L'algorithme s'arrête ici.

Entrée

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

Sortie

Affichez la réponse sur une seule ligne.

Contraintes

- 1 \leq N \leq 100
- S_i est une chaîne composée de lettres minuscules anglaises d'une longueur de 3 à 16, inclus.
- S_1, S_2, \dots, S_N sont tous distincts.
- 1 \leq C_i \leq 4229
- C_i est un entier.

Exemple d'entrée 1

3
takahashi 2
aoki 6
snuke 5

Exemple de sortie 1

snuke

La somme des cotes des trois utilisateurs est 13. Trier leurs noms par ordre lexicographique donne aoki, snuke, takahashi, donc aoki se voit attribuer le numéro 0, snuke le 1, et takahashi le 2.
Puisque 13 \bmod 3 = 1, affichez snuke, à qui est assigné le numéro 1.

Exemple d'entrée 2

3
takahashi 2813
takahashixx 1086
takahashix 4229

Exemple de sortie 2

takahashix

N utilisateurs d'AtCoder se sont réunis pour jouer à AtCoder RPS 2. Le nom du i-ème utilisateur est S_i et sa cote est C_i.
AtCoder RPS 2 se joue comme suit :

- Assignez les nombres 0, 1, \dots, N - 1 aux utilisateurs selon l'ordre lexicographique de leurs noms d'utilisateur.
- Soit T la somme des cotes des N utilisateurs. L'utilisateur auquel le nombre T \bmod N est attribué est le gagnant.

Affichez le nom d'utilisateur du gagnant.

Qu'est-ce que l'ordre lexicographique ?

L'ordre lexicographique, en termes simples, signifie "l'ordre dans lequel les mots apparaissent dans un dictionnaire." Plus précisément, l'algorithme pour déterminer l'ordre de deux chaînes distinctes S et T composées de lettres minuscules anglaises est le suivant :

Ici, "le i-ème caractère de S" est noté S_i. Si S est lexicographiquement plus petit que T, on écrit S \lt T, et si S est plus grand, on écrit S \gt T.

-  Soit L la longueur de la chaîne la plus courte parmi S et T. Vérifiez si S_i et T_i correspondent pour i=1,2,\dots,L.
-  S'il existe un i tel que S_i \neq T_i, soit j le plus petit de ces i. Comparez S_j et T_j. Si S_j est alphabétiquement plus petit que T_j, alors S \lt T. Sinon, S \gt T. L'algorithme s'arrête ici.

-  S'il n'existe pas de i tel que S_i \neq T_i, comparez les longueurs de S et T. Si S est plus court que T, alors S \lt T. Si S est plus long, alors S \gt T. L'algorithme s'arrête ici.

Entrée

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

Sortie

Affichez la réponse sur une seule ligne.

Contraintes

- 1 \leq N \leq 100
- S_i est une chaîne composée de lettres minuscules anglaises d'une longueur de 3 à 16, inclus.
- S_1, S_2, \dots, S_N sont tous distincts.
- 1 \leq C_i \leq 4229
- C_i est un entier.

Exemple d'entrée 1

3
takahashi 2
aoki 6
snuke 5

Exemple de sortie 1

snuke

La somme des cotes des trois utilisateurs est 13. Trier leurs noms par ordre lexicographique donne aoki, snuke, takahashi, donc aoki se voit attribuer le numéro 0, snuke est 1, et takahashi est 2.
Puisque 13 \bmod 3 = 1, imprimez snuke, qui est assigné au numéro 1.

Exemple d'entrée 2

3
takahashi 2813
takahashixx 1086
takahashix 4229

Exemple de sortie 2

takahashix

N utilisateurs d’AtCoder se sont rassemblés pour jouer à AtCoder RPS 2. Le ième utilisateur s’appelle S_i et sa note est C_i.
AtCoder RPS 2 se joue comme suit :

- Attribuez les numéros 0, 1, \dots, N - 1 aux utilisateurs dans l’ordre lexicographique de leurs noms d’utilisateur.
- Soit T la somme des évaluations des N utilisateurs. L’utilisateur ayant reçu le numéro T \bmod N est le gagnant.

Imprimez le nom d’utilisateur du gagnant.

Qu’est-ce que l’ordre lexicographique ?

L’ordre lexicographique, en termes simples, signifie "l'ordre dans lequel les mots apparaissent dans un dictionnaire." Plus précisément, l’algorithme permettant de déterminer l’ordre de deux chaînes distinctes S et T composées de lettres anglaises minuscules est le suivant :

Ici, "le i-ème caractère de S" est noté S_i. Si S est lexicographiquement plus petit que T, nous écrivons S \lt T, et si S est plus grand, nous écrivons S gt T.

- Soit L la longueur de la chaîne la plus courte entre S et T. Vérifiez si S_i et T_i correspondent pour i=1,2,\dots,L.
- S’il existe un i tel que S_i \neq T_i, soit j le plus petit i. Comparez S_j et T_j. Si S_j est alphabétiquement plus petit que T_j, alors S \lt T. Sinon, S \gt T. L’algorithme s’arrête là.

- S’il n’y a pas de i tel que S_i \neq T_i, comparez les longueurs de S et de T. Si S est plus court que T, alors S \lt T. Si S est plus long, alors S \gt T. L’algorithme s’arrête là.

Entrée

L’entrée est fournie à partir de l’entrée standard au format suivant :
N
S_1 C_1
S_2 C_2
\vdots
S_N C_N

Sortie

Imprimez la réponse sur une seule ligne.

Contraintes

- 1 \leq N \leq 100
- S_i est une chaîne composée de lettres anglaises minuscules d’une longueur comprise entre 3 et 16, inclus.
- S_1, S_2, \dots, S_N sont tous distincts.
- 1 \leq C_i \leq 4229
- C_i est un entier.

Exemple d’entrée 1

3
takahashi 2
aoki 6
snuke 5

Exemple de sortie 1

snuke

La somme des notes des trois utilisateurs est de 13. En triant leurs noms par ordre lexicographique, on obtient aoki, snuke, takahashi, de sorte que aoki se voit attribuer le numéro 0, snuke est 1 et takahashi est 2.
Puisque 13 \bmod 3 = 1, print snuke, qui se voit attribuer le numéro 1.

Exemple d’entrée 2

3
takahashi 2813
takahashixx 1086
takahashix 4229

Exemple de sortie 2

takahashix


Takahashi fait pousser une plante. Sa hauteur au moment de la germination est de 0\,\mathrm{cm}. En considérant le jour de la germination comme le jour 0, sa hauteur augmente de 2^i\,\mathrm{cm} chaque nuit du jour i (0 \le i).
La hauteur de Takahashi est H\,\mathrm{cm}.
Chaque matin, Takahashi mesure sa hauteur par rapport à cette plante.  Trouvez le premier jour où la hauteur de la plante est strictement supérieure à la hauteur de Takahashi le matin.

Entrée

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

Sortie

Affichez un entier représentant le premier jour où la hauteur de la plante est supérieure à la hauteur de Takahashi le matin.

Contraintes

- 1 \leq H \leq 10^{9}
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

54

Exemple de sortie 1

6

La hauteur de la plante le matin des jours 1, 2, 3, 4, 5, 6 sera de 1\,\mathrm{cm}, 3\,\mathrm{cm}, 7\,\mathrm{cm}, 15\,\mathrm{cm}, 31\,\mathrm{cm}, 63\,\mathrm{cm}, respectivement. La plante devient plus haute que Takahashi le matin du jour 6, donc affichez 6.

Exemple d'entrée 2

7

Exemple de sortie 2

4

La hauteur de la plante sera de 7\,\mathrm{cm} le matin du jour 3 et de 15\,\mathrm{cm} le matin du jour 4. La plante devient plus grande que Takahashi le matin du jour 4, donc affichez 4. Notez que, le matin du jour 3, la plante est aussi grande que Takahashi, mais pas plus grande.

Exemple d'entrée 3

262144

Exemple de sortie 3

19

Takahashi fait pousser une plante. Sa hauteur au moment de la germination est de 0\,\mathrm{cm}. Considérant le jour de la germination comme le jour 0, sa hauteur augmente de 2^i\,\mathrm{cm} la nuit du jour i (0 \le i).
La hauteur de Takahashi est H\,\mathrm{cm}.
Chaque matin, Takahashi mesure sa hauteur par rapport à cette plante. Trouvez le premier jour où la hauteur de la plante est strictement supérieure à la hauteur de Takahashi le matin.

Entrée

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

Sortie

Affichez un entier représentant le premier jour où la hauteur de la plante est supérieure à la hauteur de Takahashi le matin.

Contraintes

- 1 \leq H \leq 10^{9}
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

54

Exemple de sortie 1

6

La hauteur de la plante le matin des jours 1, 2, 3, 4, 5, 6 sera de 1\,\mathrm{cm}, 3\,\mathrm{cm}, 7\,\mathrm{cm}, 15\,\mathrm{cm}, 31\,\mathrm{cm}, 63\,\mathrm{cm}, respectivement. La plante devient plus haute que Takahashi le matin du jour 6, donc imprimez 6.

Exemple d'entrée 2

7

Exemple de sortie 2

4

La hauteur de la plante sera de 7\,\mathrm{cm} le matin du jour 3 et de 15\,\mathrm{cm} le matin du jour 4. La plante devient plus grande que Takahashi le matin du jour 4, donc imprimez 4. Notez que, le matin du jour 3, la plante est aussi grande que Takahashi, mais pas plus grande.

Exemple d'entrée 3

262144

Exemple de sortie 3

19

Takahashi cultive une plante. Sa hauteur au moment de la germination est de 0 \, \ mathrm {cm}. Compte tenu du jour de la germination comme le jour 0, sa hauteur augmente de 2 ^ i \, \ mathrm {cm} la nuit du jour (i) (0 \ le i).
La hauteur de Takahashi est H \, \ Mathrm {cm}.
Chaque matin, Takahashi mesure sa taille contre cette plante. Trouvez le premier jour où la hauteur de la plante est strictement supérieure à celle de Takahashi le matin.

Saisir

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

Sortir

Imprimez un entier représentant le premier jour de telle sorte que la hauteur de la plante soit supérieure à la hauteur de Takahashi le matin.

Contraintes

- 1 \leq H \leq 10^{9}
- Toutes les valeurs d'entrée sont des entiers.

Échantillon d'entrée 1

54

Échantillon de sortie 1

6

La hauteur de l'usine le matin des jours 1, 2, 3, 4, 5, 6 sera 1 \, \ mathrm {cm}, 3 \, \ mathrm {cm}, 7 \, \ mathrm {cm}, 15 \ , \ mathrm {cm}, 31 \, \ mathrm {cm}, 63 \, \ mathrm {cm}, respectivement. La plante devient plus grande que Takahashi le jour du matin 6, alors imprimez 6.

Échantillon d'entrée 2

7

Échantillon de sortie 2

4

La hauteur de l'usine sera de 7 \, \ mathrm {cm} le matin du jour 3 et 15 \, \ mathrm {cm} le jour du matin 4. La plante devient plus grande que Takahashi le matin du jour 4, alors imprimez 4 . Notez que, le matin du jour 3, la plante est aussi grande que Takahashi, mais pas plus grande.

Exemple d'entrée 3

262144

Exemple de sortie 3

19


Takahashi et Aoki jouent à un jeu avec N cartes. Le recto de la i-ème carte porte l'inscription A_i et le verso porte l'inscription B_i. Au départ, les N cartes sont disposées sur la table. Takahashi jouant en premier, les deux joueurs effectuent à tour de rôle l'opération suivante :

- Choisissez une paire de cartes sur la table de telle sorte que les numéros sur leur recto ou leur verso soient identiques, et retirez ces deux cartes de la table. Si aucune paire de cartes de ce type n'existe, le joueur ne peut pas effectuer l'opération.

Le joueur qui est le premier à ne pas pouvoir effectuer l'opération perd et l'autre joueur gagne.
Déterminez qui gagne si les deux joueurs jouent de manière optimale.

Entrée

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

Sortie

Affichez Takahashi si Takahashi gagne lorsque les deux joueurs jouent de manière optimale, et Aoki dans le cas contraire.

Contraintes

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5
1 9
2 5
4 9
1 4
2 5

Exemple de sortie 1

Aoki

Si Takahashi retire d'abord

-
la première et la troisième carte : Aoki peut gagner en retirant la deuxième et la cinquième carte.

-
la première et la quatrième carte : Aoki peut gagner en retirant la deuxième et la cinquième carte.

-
la deuxième et la cinquième carte : Aoki peut gagner en retirant la première et la troisième carte.

Ce sont les trois seules paires de cartes que Takahashi peut retirer lors de son premier coup, et Aoki peut gagner dans tous les cas. Par conséquent, la réponse est Aoki.

Exemple d'entrée 2

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

Exemple de sortie 2

Takahashi

Takahashi et Aoki jouent à un jeu avec N cartes. Le recto de la i-ème carte a A_i écrit dessus, et le verso a B_i écrit dessus. Initialement, les N cartes sont disposées sur la table. Takahashi commence, les deux joueurs font à tour de rôle l'opération suivante :

- Choisir une paire de cartes de la table de manière sachant que les nombres sur leurs rectos soient identiques ou que les nombres sur leurs versos soient identiques, et enlever ces deux cartes de la table. Si aucune telle paire de cartes n'existe, le joueur ne peut pas effectuer l'opération.

Le premier joueur incapable d'effectuer l'opération perd, et l'autre joueur gagne.
Déterminez qui gagne si les deux joueurs jouent de manière optimale.

Entrée

L'entrée est fournie depuis l'entrée standard dans le format suivant :
N
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Sortie

Imprimez Takahashi si Takahashi gagne lorsque les deux joueurs jouent de manière optimale, et Aoki sinon.

Contraintes

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5
1 9
2 5
4 9
1 4
2 5

Exemple de sortie 1

Aoki

Si Takahashi enlève d'abord

-
la première et la troisième cartes : Aoki peut gagner en enlevant la deuxième et la cinquième cartes.

-
la première et la quatrième cartes : Aoki peut gagner en enlevant la deuxième et la cinquième cartes.

-
la deuxième et la cinquième cartes : Aoki peut gagner en enlevant la première et la troisième cartes.

Ce sont les seules trois paires de cartes que Takahashi peut enlever lors de son premier mouvement, et Aoki peut gagner dans tous les cas. Par conséquent, la réponse est Aoki.

Exemple d'entrée 2

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

Exemple de sortie 2

Takahashi

Takahashi et Aoki jouent à un jeu avec N cartes. Le recto de la i-ème carte a A_i écrit dessus, et le verso a B_i écrit dessus. Initialement, les N cartes sont disposées sur la table. Takahashi commence, les deux joueurs font à tour de rôle l'opération suivante :

- Choisir une paire de cartes de la table de manière que soit les nombres sur leurs rectos soient identiques, soit les nombres sur leurs versos soient identiques, et enlever ces deux cartes de la table. Si aucune telle paire de cartes n'existe, le joueur ne peut pas effectuer l'opération.

Le premier joueur incapable d'effectuer l'opération perd, et l'autre joueur gagne.
Déterminez qui gagne si les deux joueurs jouent de manière optimale.

Entrée

L'entrée est fournie depuis l'entrée standard dans le format suivant :
N
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Sortie

Affichez Takahashi si Takahashi gagne lorsque les deux joueurs jouent de manière optimale, et Aoki sinon.

Contraintes

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5
1 9
2 5
4 9
1 4
2 5

Exemple de sortie 1

Aoki

Si Takahashi enlève d'abord

-
la première et la troisième cartes : Aoki peut gagner en enlevant la deuxième et la cinquième cartes.

-
la première et la quatrième cartes : Aoki peut gagner en enlevant la deuxième et la cinquième cartes.

-
la deuxième et la cinquième cartes : Aoki peut gagner en enlevant la première et la troisième cartes.

Ce sont les seules trois paires de cartes que Takahashi peut enlever lors de son premier mouvement, et Aoki peut gagner dans tous les cas. Par conséquent, la réponse est Aoki.

Exemple d'entrée 2

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

Exemple de sortie 2

Takahashi


Takahashi a N cartes du jeu de cartes "AtCoder Magics". La i-ème carte sera appelée carte i. Chaque carte a deux paramètres : puissance et coût. La carte i a une puissance de A_i et un coût de C_i.
Il n'aime pas les cartes faibles, il va donc les jeter. Plus précisément, il va répéter l'opération suivante jusqu'à ce qu'elle ne puisse plus être réalisée :

- Choisir deux cartes x et y telles que A_x > A_y et C_x < C_y. Jeter la carte y.

On peut prouver que l'ensemble des cartes restantes lorsque les opérations ne peuvent plus être réalisées est déterminé de manière unique. Trouver cet ensemble de cartes.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Sortie

Soit m le nombre de cartes restantes, cartes i_1, i_2, \dots, i_m, par ordre croissant. Affichez-les dans le format suivant :
m
i_1 i_2 \cdots i_m

Contraintes

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- A_1, A_2, \dots ,A_N sont tous distincts.
- C_1, C_2, \dots ,C_N sont tous distincts.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
2 4
1 1
3 2

Exemple de sortie 1

2
2 3

En examinant les cartes 1 et 3, nous avons A_1 < A_3 et C_1 > C_3, donc la carte 1 peut être jetée.
Aucune autre opération ne peut être réalisée. À ce stade, les cartes 2 et 3 restent, donc affichez-les.

Exemple d'entrée 2

5
1 1
10 2
100 3
1000 4
10000 5

Exemple de sortie 2

5
1 2 3 4 5

Dans ce cas, aucune carte ne peut être jetée.

Exemple d'entrée 3

6
32 101
65 78
2 29
46 55
103 130
52 40

Exemple de sortie 3

4
2 3 5 6

Takahashi a N cartes du jeu de cartes "AtCoder Magics". La i-ème carte sera appelée carte i. Chaque carte a deux paramètres : puissance et coût. La carte i a une puissance de A_i et un coût de C_i.
Il n'aime pas les cartes faibles, donc il va les jeter. Plus précisément, il va répéter l'opération suivante jusqu'à ce qu'elle ne puisse plus être réalisée :

- Choisir deux cartes x et y telles que A_x > A_y et C_x < C_y. Jeter la carte y.

On peut prouver que l'ensemble des cartes restantes lorsque les opérations ne peuvent plus être réalisées est déterminé de manière unique. Trouver cet ensemble de cartes.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Sortie

Soit m étant le nombre de cartes restantes, cartes i_1, i_2, \dots, i_m, par ordre croissant. Affichez-les dans le format suivant :
m
i_1 i_2 \cdots i_m

Contraintes

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- A_1, A_2, \dots ,A_N sont tous distincts.
- C_1, C_2, \dots ,C_N sont tous distincts.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
2 4
1 1
3 2

Exemple de sortie 1

2
2 3

En se concentrant sur les cartes 1 et 3, nous avons A_1 < A_3 et C_1 > C_3, donc la carte 1 peut être jetée.
Aucune autre opération ne peut être réalisée. À ce stade, les cartes 2 et 3 restent, donc affichez-les.

Exemple d'entrée 2

5
1 1
10 2
100 3
1000 4
10000 5

Exemple de sortie 2

5
1 2 3 4 5

Dans ce cas, aucune carte ne peut être jetée.

Exemple d'entrée 3

6
32 101
65 78
2 29
46 55
103 130
52 40

Exemple de sortie 3

4
2 3 5 6

Takahashi possède N cartes du jeu de cartes « AtCoder Magics ». La i-ème carte sera appelée carte i. Chaque carte a deux paramètres : force et coût. La carte i a une force de A_i et un coût de C_i.
Il n'aime pas les cartes faibles, il va donc les défausser. Plus précisément, il va répéter l'opération suivante jusqu'à ce qu'elle ne puisse plus être effectuée :

- Choisissez deux cartes x et y telles que A_x > A_y et C_x < C_y. Défaussez la carte y.

Il peut être prouvé que l'ensemble des cartes restantes lorsque les opérations ne peuvent plus être effectuées est déterminé de manière unique. Trouvez cet ensemble de cartes.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Sortie

Soit m cartes restantes, cartes i_1, i_2, \dots, i_m, dans l'ordre croissant. Imprimez-les au format suivant :
m
i_1 i_2 \cdots i_m

Contraintes

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- A_1, A_2, \dots ,A_N sont tous distincts.
- C_1, C_2, \dots ,C_N sont tous distincts.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
2 4
1 1
3 2

Exemple de sortie 1

2
2 3

En nous concentrant sur les cartes 1 et 3, nous avons A_1 < A_3 et C_1 > C_3, donc la carte 1 peut être écartée.
Aucune autre opération ne peut être effectuée. À ce stade, les cartes 2 et 3 restent, alors imprimez-les.

Exemple d'entrée 2

5
1 1
10 2
100 3
1000 4
10000 5

Exemple de sortie 2

5
1 2 3 4 5

Dans ce cas, aucune carte ne peut être défaussée.

Exemple d'entrée 3

6
32 101
65 78
2 29
46 55
103 130
52 40

Exemple de sortie 3

4
2 3 5 6


Le motif du papier peint d'AtCoder peut être représenté sur le plan xy comme suit :

-
Le plan est divisé par les trois types de lignes suivants :

-
x = n (où n est un entier)

-
y = n (où n est un nombre pair)

-
x + y = n (où n est un nombre pair)

-
Chaque région est peinte en noir ou en blanc. Deux régions adjacentes le long de l'une de ces lignes sont peintes de couleurs différentes.

-
La région contenant (0.5, 0.5) est peinte en noir.

La figure suivante montre une partie du motif.

On vous donne les entiers A, B, C, D. Considérez un rectangle dont les côtés sont parallèles aux axes x et y, avec son sommet inférieur gauche au point (A, B) et son sommet supérieur droit au point (C, D). Calculez l'aire des régions peintes en noir à l'intérieur de ce rectangle, et imprimez deux fois cette aire. Il peut être prouvé que la valeur de sortie sera un entier.

Entrée

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

Sortie

Affichez la réponse sur une seule ligne.

Contraintes

- -10^9 \leq A, B, C, D \leq 10^9
- A < C et B < D.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'Entrée 1

0 0 3 3

Exemple de Sortie 1

10

Nous devons trouver l'aire de la région peinte en noir à l'intérieur du carré suivant :

L'aire est 5, donc affichez deux fois cette valeur : 10.

Exemple d'Entrée 2

-1 -2 1 3

Exemple de Sortie 2

11

L'aire est 5.5, ce qui n'est pas un entier, mais la valeur de sortie est un entier.

Exemple d'Entrée 3

-1000000000 -1000000000 1000000000 1000000000

Exemple de Sortie 3

4000000000000000000

C'est le cas avec le plus grand rectangle, où la sortie tient toujours dans un entier signé de 64 bits.

Le motif du papier peint d'AtCoder peut être représenté sur le plan xy comme suit :

-
Le plan est divisé par les trois types de lignes suivants :

-
x = n (où n est un entier)

-
y = n (où n est un nombre pair)

-
x + y = n (où n est un nombre pair)

-
Chaque région est peinte en noir ou en blanc. Deux régions adjacentes le long de l'une de ces lignes sont peintes de couleurs différentes.

-
La région contenant (0.5, 0.5) est peinte en noir.

La figure suivante montre une partie du motif.

On vous donne les entiers A, B, C, D. Considérez un rectangle dont les côtés sont parallèles aux axes x et y, avec son sommet inférieur gauche au point (A, B) et son sommet supérieur droit au point (C, D). Calculez l'aire des régions peintes en noir à l'intérieur de ce rectangle, et affichez deux fois cette aire.
Il peut être prouvé que la valeur de sortie sera un entier.

Entrée

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

Sortie

Affichez la réponse sur une seule ligne.

Contraintes

- -10^9 \leq A, B, C, D \leq 10^9
- A < C et B < D.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'Entrée 1

0 0 3 3

Exemple de Sortie 1

10

Nous devons trouver l'aire de la région peinte en noir à l'intérieur du carré suivant :

L'aire est 5, donc imprimez deux fois cette valeur : 10.

Exemple d'Entrée 2

-1 -2 1 3

Exemple de Sortie 2

11

L'aire est 5.5, ce qui n'est pas un entier, mais la valeur de sortie est un entier.

Exemple d'Entrée 3

-1000000000 -1000000000 1000000000 1000000000

Exemple de Sortie 3

4000000000000000000

C'est le cas avec le plus grand rectangle, où la sortie tient toujours dans un entier signé de 64 bits.

Le motif du papier peint d'AtCoder peut être représenté sur le plan xy comme suit :

-
Le plan est divisé par les trois types de lignes suivants :

-
x = n (où n est un entier)

-
y = n (où n est un nombre pair)

-
x + y = n (où n est un nombre pair)

-
Chaque région est peinte en noir ou en blanc. Toutes régions adjacentes le long de l'une de ces lignes sont peintes de couleurs différentes.

-
La région contenant (0.5, 0.5) est peinte en noir.

La figure suivante montre une partie du motif.

On vous donne les entiers A, B, C, D. Considérez un rectangle dont les côtés sont parallèles aux axes x et y, avec son sommet inférieur gauche au point (A, B) et son sommet supérieur droit au point (C, D). Calculez l'aire des régions peintes en noir à l'intérieur de ce rectangle, et imprimez deux fois cette aire.
Il peut être prouvé que la valeur de sortie sera un entier.

Entrée

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

Sortie

Affichez la réponse sur une seule ligne.

Contraintes

- -10^9 \leq A, B, C, D \leq 10^9
- A < C et B < D.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'Entrée 1

0 0 3 3

Exemple de Sortie 1

10

Nous devons trouver l'aire de la région peinte en noir à l'intérieur du carré suivant :

L'aire est 5, donc imprimez deux fois cette valeur : 10.

Exemple d'Entrée 2

-1 -2 1 3

Exemple de Sortie 2

11

L'aire est 5.5, ce qui n'est pas un entier, mais la valeur de sortie est un entier.

Exemple d'Entrée 3

-1000000000 -1000000000 1000000000 1000000000

Exemple de Sortie 3

4000000000000000000

C'est le cas avec le plus grand rectangle, où le résultat tient toujours dans un entier signé de 64 bits.


Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
On vous donne un entier positif N et des entiers L et R tels que 0 \leq L \leq R < 2^N. Le juge a une séquence cachée A = (A_0, A_1, \dots, A_{2^N-1}) composée d'entiers entre 0 et 99 inclus.
Votre objectif est de trouver le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Cependant, vous ne pouvez pas connaître directement les valeurs des éléments dans la séquence A. À la place, vous pouvez poser la question suivante au juge :

- Choisissez des entiers non négatifs i et j tels que 2^i(j+1) \leq 2^N. Soit l = 2^i j et r = 2^i (j+1) - 1. Demandez le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100.

Soit m le nombre minimum de questions nécessaires pour déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100 pour toute séquence A. Vous devez trouver ce reste en m questions.

Entrée et Sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez les questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être affichée au format suivant :
? i j

Ici, i et j doivent satisfaire les contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne respectent pas les contraintes, ou si le nombre de questions dépasse m, alors T sera -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, affichez le reste S au format suivant et terminez immédiatement le programme :
! S

Entrée et Sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez les questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être affichée au format suivant :
? i j

Ici, i et j doivent satisfaire les contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne respectent pas les contraintes, ou si le nombre de questions dépasse m, alors T sera -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, affichez le reste S au format suivant et terminez immédiatement le programme :
! S

Contraintes

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Toutes les valeurs d'entrée sont des entiers.

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et des sorties).
On vous donne un entier positif N et des entiers L et R tels que 0 \leq L \leq R < 2^N. Le juge a une séquence cachée A = (A_0, A_1, \dots, A_{2^N-1}) composée d'entiers compris entre 0 et 99, inclus.
Votre objectif est de trouver le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Cependant, vous ne pouvez pas connaître directement les valeurs des éléments de la séquence A. Au lieu de cela, vous pouvez poser au juge la question suivante :

- Choisissez des entiers non négatifs i et j tels que 2^i(j+1) \leq 2^N. Soit l = 2^i j et r = 2^i (j+1) - 1. Demandez le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100.

Soit m le nombre minimum de questions nécessaires pour déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100 pour toute séquence A. Vous devez trouver ce reste en m questions.

Entrée et sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via l'entrée et la sortie).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez la pose de questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être imprimée au format suivant :
? i j

Ici, i et j doivent satisfaire les contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne satisfont pas les contraintes, ou si le nombre de questions dépasse m, alors T sera -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, imprimez le reste S au format suivant et terminez immédiatement le programme :
! S

Entrée et sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via l'entrée et la sortie).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez les questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être imprimée au format suivant :
? i j

Ici, i et j doivent satisfaire aux contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne satisfont pas les contraintes, ou si le nombre de questions dépasse m, alors T sera -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, imprimez le reste S au format suivant et terminez immédiatement le programme :
! S

Contraintes

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Toutes les valeurs d'entrée sont des entiers.

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
On vous donne un entier positif N et des entiers L et R tels que 0 \leq L \leq R < 2^N. Le juge a une séquence cachée A = (A_0, A_1, \dots, A_{2^N-1}) composée d'entiers compris entre 0 et 99, inclus.
Votre objectif est de trouver le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Cependant, vous ne pouvez pas connaître directement les valeurs des éléments dans la séquence A. À la place, vous pouvez poser la question suivante au juge :

- Choisissez des entiers non négatifs i et j tels que 2^i(j+1) \leq 2^N. Soit l = 2^i j et r = 2^i (j+1) - 1. Demandez le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100.

Soit m le nombre minimum de questions nécessaires pour déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100 pour toute séquence A. Vous devez trouver ce reste en m questions.

Entrée et Sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez les questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être affichée au format suivant :
? i j

Ici, i et j doivent satisfaire les contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne respectent pas les contraintes, ou si le nombre de questions dépasse m, alors T prendra la valeur -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, affichez le reste S au format suivant et terminez immédiatement le programme :
! S

Entrée et Sortie

Il s'agit d'un problème interactif (où votre programme interagit avec le juge via des entrées et sorties).
Tout d'abord, lisez les entiers N, L et R à partir de l'entrée standard :
N L R

Ensuite, répétez les questions jusqu'à ce que vous puissiez déterminer le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100. Chaque question doit être imprimée au format suivant :
? i j

Ici, i et j doivent satisfaire les contraintes suivantes :

- i et j sont des entiers non négatifs.
- 2^i(j+1) \leq 2^N

La réponse à la question sera donnée au format suivant à partir de l'entrée standard :
T

Ici, T est la réponse à la question, qui est le reste lorsque A_l + A_{l+1} + \dots + A_r est divisé par 100, où l = 2^i j et r = 2^i (j+1) - 1.
Si i et j ne respectent pas les contraintes, ou si le nombre de questions dépasse m, alors T prendra la valeur -1.
Si le juge renvoie -1, votre programme est déjà considéré comme incorrect. Dans ce cas, terminez immédiatement le programme.
Une fois que vous avez déterminé le reste lorsque A_L + A_{L+1} + \dots + A_R est divisé par 100, affichez le reste S au format suivant et terminez immédiatement le programme :
! S

Contraintes

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Toutes les valeurs d'entrée sont des entiers.


On vous donne une séquence A=(A_1,A_2,\dots,A_N) de longueur N et une séquence B=(B_1,B_2,\dots,B_M) de longueur M. Ici, tous les éléments de A et B sont distincts deux à deux. Déterminez si la séquence C=(C_1,C_2,\dots,C_{N+M}), formée en triant tous les éléments de A et B par ordre croissant, contient deux éléments consécutifs apparaissant dans A.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Sortie

Si C contient deux éléments consécutifs apparaissant dans A, affichez Yes; sinon, affichez No.

Contraintes

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M sont distincts.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
3 2 5
4 1

Exemple de sortie 1

Yes

C=(1,2,3,4,5). Puisque 2 et 3 de A apparaissent consécutivement dans C, affichez Yes.

Exemple d'entrée 2

3 2
3 1 5
4 2

Exemple de sortie 2

No

C=(1,2,3,4,5). Puisqu'aucun élément de A n'apparaît consécutivement dans C, affichez No.

Exemple d'entrée 3

1 1
1
2

Exemple de sortie 3

No

On vous donne une suite A=(A_1,A_2,\dots,A_N) de longueur N et une suite B=(B_1,B_2,\dots,B_M) de longueur M. Ici, tous les éléments de  et B sont distincts par paires. Déterminer si la sequence C=(C_1,C_2,\dots,C_{N+M}) formée par le tri de tous les éléments de A et de B en ordre croissant contient deux éléments consécutifs apparaissant dans A.

Entrée en ligne

L’entrée est donnée à partir de l’entrée Standard dans le format suivant:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

La production

Si C contient deux éléments consécutifs apparaissant en A, imprimer Yes; Sinon, imprimez No.

Les contraintes

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M sont distincts.
- toutes les valeurs d’entrée sont des entiers.

Entrée d’échantillon 1

3 2
3 2 5
4 1

Exemple de sortie 1

Yes

C=(1,2,3,4,5). Puisque 2 et 3 de A se produisent consécutivement en C, imprimer Yes.

Saisie de l’échantillon 2

3 2
3 1 5
4 2

Sortie de l’échantillon 2

No

C=(1,2,3,4,5). Comme aucun couple d'éléments de A ne se produit consécutivement en C, imprimer No.

Entrée de l’échantillon 3

1 1
1
2

Sortie de l’échantillon 3

No


Il y a une grille de N \times N, où la cellule à la i-ème ligne à partir du haut et la j-ème colonne à partir de la gauche contient l'entier N \times (i-1) + j.
Sur T tours, des entiers seront annoncés. Au tour i, l'entier A_i est annoncé, et la cellule contenant A_i est marquée. Déterminez le tour au cours duquel le Bingo est atteint pour la première fois. Si le Bingo n'est pas atteint en T tours, affichez -1.
Ici, réaliser un Bingo signifie satisfaire au moins une des conditions suivantes :

- Il existe une ligne où toutes les N cellules sont marquées.
- Il existe une colonne où toutes les N cellules sont marquées.
- Il existe une diagonale (de haut-gauche à bas-droite ou de haut-droite à bas-gauche) dans laquelle toutes les N cellules sont marquées.

Entrée

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

Sortie

Si le Bingo est atteint en T tours, affichez le numéro du tour au cours duquel le Bingo est atteint pour la première fois ; sinon, affichez -1.

Contraintes

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j si i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 5
5 1 8 9 7

Exemple de sortie 1

4

L'état de la grille change comme suit. Le Bingo est atteint pour la première fois au Tour 4.

Exemple d'entrée 2

3 5
4 2 9 7 5

Exemple de sortie 2

-1

Le Bingo n'est pas atteint en cinq tours, donc affichez -1.

Exemple d'entrée 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Exemple de sortie 3

9

On a a une grille de N \times N, où la cellule à la i-ème ligne à partir du haut et la j-ème colonne à partir de la gauche contient l'entier N \times (i-1) + j.
Au cours de T tours, des entiers seront annoncés. Au tour i, l'entier A_i est annoncé, et la cellule contenant A_i est marquée. Déterminez le tour au cours duquel le Bingo est atteint pour la première fois. Si le Bingo n'est pas atteint en T tours, affichez -1.
Ici, réaliser un Bingo signifie satisfaire au moins une des conditions suivantes :

- Il existe une ligne où toutes les N cellules sont marquées.
- Il existe une colonne où toutes les N cellules sont marquées.
- Il existe une diagonale (du haut à gauche vers le bas à droite ou de haut à droite vers le bas à gauche) dans laquelle toutes les N cellules sont marquées.

Entrée

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

Sortie

Si le Bingo est atteint en T tours, affichez le numéro du tour au cours duquel le Bingo est atteint pour la première fois ; sinon, affichez -1.

Contraintes

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j si i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 5
5 1 8 9 7

Exemple de sortie 1

4

L'état de la grille change comme suit. Le Bingo est atteint pour la première fois au Tour 4.

Exemple d'entrée 2

3 5
4 2 9 7 5

Exemple de sortie 2

-1

Le Bingo n'est pas atteint en cinq tours, donc affichez -1.

Exemple d'entrée 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Exemple de sortie 3

9

Il y a une grille N fois N, où la cellule à la i-ième ligne en partant du haut et à la j-ième colonne en partant de la gauche contient l'entier N fois (i-1) + j.
Au cours de T tours, des nombres entiers seront annoncés. Au tour i, l'entier A_i est annoncé et la cellule contenant A_i est marquée. Déterminez le tour au cours duquel le Bingo est atteint pour la première fois. Si Bingo n'est pas atteint en T tours, imprimer -1.
Ici, atteindre Bingo signifie satisfaire au moins l'une des conditions suivantes :

- Il existe une ligne dans laquelle toutes les N cellules sont marquées.
- Il existe une colonne dans laquelle toutes les N cellules sont marquées.
- Il existe une ligne diagonale (de haut en gauche à bas en droite ou de haut en droite à bas en gauche) dans laquelle toutes les N cellules sont marquées.

Entrée

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

Résultat

Si le Bingo est atteint dans T tours, imprimer le numéro du tour où le Bingo est atteint pour la première fois ; sinon, imprimer -1.

Contraintes

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 5
5 1 8 9 7

Exemple de sortie 1

4

L'état de la grille change comme suit. Le Bingo est obtenu pour la première fois au tour 4.

Exemple d'entrée 2

3 5
4 2 9 7 5

Exemple de sortie 2

-1

Le Bingo n'est pas atteint dans les cinq tours, alors imprimez -1.

Exemple d'entrée 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Exemple de sortie 3

9


Le gâteau de Takahashi a été mangé par quelqu'un. Il y a trois suspects : personne 1, personne 2 et personne 3.
Il y a deux témoins, Ringo et Snuke. Ringo se souvient que la personne A n'est pas le coupable, et Snuke se souvient que la personne B n'est pas le coupable.
Déterminez si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins. Si le coupable peut être identifié, affichez le numéro de la personne.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
A B

Sortie

Si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins, affichez le numéro de la personne ; sinon, affichez -1.

Contraintes

- 1 \leq A, B \leq 3
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

1 2

Exemple de sortie 1

3

D'après les souvenirs des deux témoins, on peut déterminer que la personne 3 est le coupable.

Exemple d'entrée 2

1 1

Exemple de sortie 2

-1

D'après les souvenirs des deux témoins, on ne peut pas déterminer si la personne 2 ou la personne 3 est le coupable. Par conséquent, affichez -1.

Exemple d'entrée 3

3 1

Exemple de sortie 3

2

Le gâteau de Takahashi a été mangé par quelqu'un. Il y a trois suspects : personne 1, personne 2 et personne 3.
Il y a deux témoins, Ringo et Snuke. Ringo se souvient que la personne A n'est pas le coupable, et Snuke se souvient que la personne B n'est pas le coupable.
Déterminez si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins. Si le coupable peut être identifié, affichez le numéro de la personne.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
A B

Sortie

Si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins, affichez le numéro de la personne ; sinon, affichez -1.

Contraintes

- 1 \leq A, B \leq 3
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

1 2

Exemple de sortie 1

3

D'après les souvenirs des deux témoins, on peut déterminer que la personne 3 est le coupable.

Exemple d'entrée 2

1 1

Exemple de sortie 2

-1

D'après les souvenirs des deux témoins, on ne peut pas déterminer si la personne 2 ou la personne 3 est le coupable. Par conséquent, affichez-1.

Exemple d'entrée 3

3 1

Exemple de sortie 3

2

Le gâteau de Takahashi a été mangé par quelqu'un. Il y a trois suspects : personne 1, personne 2 et personne 3.
Il y a deux témoins, Ringo et Snuke. Ringo se souvient que la personne A n'est pas le coupable, et Snuke se souvient que la personne B n'est pas le coupable.
Déterminez si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins. Si le coupable peut être identifié, imprimez le numéro de la personne.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
A B

Sortie

Si le coupable peut être identifié de manière unique en se basant sur les souvenirs des deux témoins, imprimez le numéro de la personne ; sinon, imprimez -1.

Contraintes

- 1 \leq A, B \leq 3
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

1 2

Exemple de sortie 1

3

D'après les souvenirs des deux témoins, on peut déterminer que la personne 3 est le coupable.

Exemple d'entrée 2

1 1

Exemple de sortie 2

-1

D'après les souvenirs des deux témoins, on ne peut pas déterminer si la personne 2 ou la personne 3 est le coupable. Par conséquent, imprimez -1.

Exemple d'entrée 3

3 1

Exemple de sortie 3

2


On vous donne N intervalles de nombres réels. Le i-ème (1 \leq i \leq N) intervalle est [l_i, r_i]. Trouvez le nombre de paires (i, j)\,(1 \leq i < j \leq N) telles que les i-ème et j-ème intervalles s'intersectent.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Sortie

Affichez la réponse.

Contraintes

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
1 5
7 8
3 7

Exemple de sortie 1

2

Les intervalles donnés sont [1,5], [7,8], [3,7]. Parmi ceux-ci, les 1er et 3e intervalles s'intersectent, ainsi que les 2e et 3e intervalles, donc la réponse est 2.

Exemple d'entrée 2

3
3 4
2 5
1 6

Exemple de sortie 2

3

Exemple d'entrée 3

2
1 2
3 4

Exemple de sortie 3

0

On donne N intervalles de nombres réels. Le i-ème (1 \leq i \leq N) intervalle est [l_i, r_i]. Trouvez le nombre de paires (i, j)\,(1 \leq i < j \leq N) telles que les i-ème et j-ème intervalles s'intersectent.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Sortie

Affichez la réponse.

Contraintes

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
1 5
7 8
3 7

Exemple de sortie 1

2

Les intervalles donnés sont [1,5], [7,8], [3,7]. Parmi ceux-ci, les 1er et 3e intervalles s'intersectent, ainsi que les 2e et 3e intervalles, donc la réponse est 2.

Exemple d'entrée 2

3
3 4
2 5
1 6

Exemple de sortie 2

3

Exemple d'entrée 3

2
1 2
3 4

Exemple de sortie 3

0

On vous donne N intervalles de nombres réels. Le i-ième (1 \leq i \leq N) intervalle est [l_i, r_i]. Trouvez le nombre de paires (i, j)\,(1 \leq i < j \leq N) telles que les i-ème et j-ème intervalles se coupent.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Sortie

Imprimer la réponse.

Contraintes

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Toutes les valeurs d'entrée sont des nombres entiers.

Exemple d'entrée 1

3
1 5
7 8
3 7

Exemple de sortie 1

2

Les intervalles donnés sont [1,5], [7,8], [3,7]. Parmi ces intervalles, le premier et le troisième se croisent, ainsi que le deuxième et le troisième. La réponse est donc 2.

Exemple d'entrée 2

3
3 4
2 5
1 6

Exemple de sortie 2

3

Exemple d'entrée 3

2
1 2
3 4

Exemple de sortie 3

0


Vous disposez d'un tableau apple de taille n et d'un tableau capacity de taille m.
Il y a n paquets où le i^ème paquet contient apple[i] pommes. Il y a également m boîtes, et la i^ème boîte a une capacité de capacity[i] pommes.
Retournez le nombre minimum de boîtes dont vous avez besoin pour redistribuer ces n paquets de pommes dans les boîtes. Notez que les pommes d'un même paquet peuvent être réparties dans différentes boîtes.

Exemple 1 :

Entrée : apple = [1,3,2], capacity = [4,3,1,5,2]
Sortie : 2
Explication: Nous utiliserons les boîtes avec des capacités de 4 et 5.
Il est possible de distribuer les pommes car la capacité totale est supérieure ou égale au nombre total de pommes.

Exemple 2 :

Entrée : apple = [5,5,5], capacity = [2,4,2,7]
Sortie : 4
Explication: Nous devrons utiliser toutes les boîtes.

Contraintes :

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
L’entrée est générée de telle sorte qu'il est possible de redistribuer les paquets de pommes dans des boîtes.

On vous donne un tableau apple de taille n et une capacité de tableau de taille m.
Il y a n paquets où le i^ème paquet contient apple[i] pommes. Il y a également m boîtes, et la i^ème boîte a une capacité de capacity[i] pommes.
Renvoie le nombre minimum de boîtes que vous devez sélectionner pour redistribuer ces n paquets de pommes dans des boîtes.
Notez que les pommes du même paquet peuvent être distribuées dans différentes boîtes.

Exemple 1 :

Entrée : apple = [1,3,2], capacity = [4,3,1,5,2]
Sortie : 2
Explication : Nous utiliserons des boîtes de capacités 4 et 5.
Il est possible de distribuer les pommes car la capacité totale est supérieure ou égale au nombre total de pommes.

Exemple 2 :

Entrée : apple = [5,5,5], capacity = [2,4,2,7]
Sortie : 4
Explication : Nous devrons utiliser toutes les boîtes.

Contraintes :

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
L'entrée est générée de telle sorte qu'il soit possible de redistribuer les paquets de pommes dans des boîtes.

On vous donne tableau apple de taille n et d'un tableau capacity de taille m. Il y a n paquets où le i^ème paquet contient apple[i] pommes. Il y a également m boîtes, et la i^ème boîte a une capacité de capacity[i] pommes. Retournez le nombre minimum de boîtes dont vous avez besoin pour redistribuer ces n paquets de pommes dans des boîtes. Notez que les pommes d'un même paquet peuvent être réparties dans différentes boîtes.

Exemple 1 :

Entrée: apple = [1,3,2], capacity = [4,3,1,5,2]
Sortie: 2
Explication: Nous utiliserons les boîtes avec des capacités de 4 et 5. Il est possible de distribuer les pommes car la capacité totale est supérieure ou égale au nombre total de pommes.

Exemple 2 :

Entrée: apple = [5,5,5], capacity = [2,4,2,7]
Sortie: 4
Explication: Nous devrons utiliser toutes les boîtes.

Contraintes :

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
L’entrée est générée de telle sorte qu'il est possible de redistribuer les paquets de pommes dans des boîtes.


On vous donne un tableau happiness de longueur n, et un entier positif k.
Il y a n enfants alignés dans une file, où le i^ème enfant a la valeur de bonheur happiness[i]. Vous souhaitez sélectionner k enfants parmi ces n enfants en k tours.
À chaque tour, lorsque vous sélectionnez un enfant, la valeur de bonheur de tous les enfants qui n'ont pas encore été sélectionnés diminue de 1. Notez que la valeur de bonheur ne peut pas devenir négative et est décrémentée uniquement si elle est positive.
Retournez la somme maximale des valeurs de bonheur des enfants sélectionnés que vous pouvez atteindre en sélectionnant k enfants.

Exemple 1 :

Entrée : happiness = [1,2,3], k = 2
Sortie : 4
Explication : Nous pouvons choisir 2 enfants de la manière suivante :
- Choisissez l'enfant avec la valeur de bonheur == 3. La valeur de bonheur des enfants restants devient [0,1].
- Choisissez l'enfant avec la valeur de bonheur == 1. La valeur de bonheur de l'enfant restant devient [0]. Notez que la valeur de bonheur ne peut pas être inférieure à 0.
La somme des valeurs de bonheur des enfants sélectionnés est 3 + 1 = 4.

Exemple 2 :

Entrée : happiness = [1,1,1,1], k = 2
Sortie : 1
Explication : Nous pouvons choisir 2 enfants de la manière suivante :
- Choisissez n'importe quel enfant avec la valeur de bonheur == 1. La valeur de bonheur des enfants restants devient [0,0,0].
- Choisissez l'enfant avec la valeur de bonheur == 0. La valeur de bonheur de l'enfant restant devient [0,0].
La somme des valeurs de bonheur des enfants sélectionnés est 1 + 0 = 1.

Exemple 3 :

Entrée : happiness = [2,3,4,5], k = 1
Sortie : 5
Explication : Nous pouvons choisir 1 enfant de la manière suivante :
- Choisissez l'enfant avec la valeur de bonheur == 5. La valeur de bonheur des enfants restants devient [1,2,3].
La somme des valeurs de bonheur des enfants sélectionnés est 5.

Contraintes :

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n

On vous donne un tableau bonheur de longueur n, et un entier positif k.
Il y a n enfants debout dans une file d’attente, où le i^ème enfant a la valeur bonheur bonheur[i]. Vous voulez sélectionner k enfants parmi ces n enfants à k tours.
À chaque tour, lorsque vous sélectionnez un enfant, la valeur de bonheur de tous les enfants qui n’ont pas été sélectionnés jusqu’à présent diminue de 1. Notez que la valeur du bonheur ne peut pas devenir négative et n’est décrémentée que si elle est positive.
Renvoie la somme maximale des valeurs de bonheur des enfants sélectionnés que vous pouvez obtenir en sélectionnant k enfants.

Exemple 1 :

Entrée : bonheur = [1,2,3], k = 2
Sortie : 4
Explication : Nous pouvons choisir 2 enfants de la manière suivante :
- Choisissez l’enfant avec la valeur de bonheur == 3. La valeur de bonheur des enfants restants devient [0,1].
- Choisissez l’enfant avec la valeur de bonheur == 1. La valeur de bonheur de l’enfant restant devient [0]. Notez que la valeur du bonheur ne peut pas devenir inférieure à 0.
La somme des valeurs de bonheur des enfants sélectionnés est de 3 + 1 = 4.

Exemple 2 :

Entrée : bonheur = [1,1,1,1], k = 2
Sortie : 1
Explication : Nous pouvons choisir 2 enfants de la manière suivante :
- Choisissez n’importe quel enfant avec la valeur de bonheur == 1. La valeur de bonheur des enfants restants devient [0,0,0].
- Choisissez l’enfant avec la valeur de bonheur == 0. La valeur de bonheur de l’enfant restant devient [0,0].
La somme des valeurs de bonheur des enfants sélectionnés est de 1 + 0 = 1.

Exemple 3 :

Entrée : bonheur = [2,3,4,5], k = 1
Sortie : 5
Explication : Nous pouvons choisir 1 enfant de la manière suivante :
- Choisissez l’enfant avec la valeur de bonheur == 5. La valeur de bonheur des enfants restants devient [1,2,3].
La somme des valeurs de bonheur des enfants sélectionnés est de 5.

Contraintes:

1 <= n == bonheur.longueur <= 2 * 10^5
1 <= bonheur[i] <= 10^8
1 <= k <= n


On vous donne un tableau arr de taille n composé de chaînes non vides.
Trouvez un tableau de chaînes answer de taille n tel que :

answer[i] est la sous-chaîne la plus courte de arr[i] qui n'apparaît pas comme sous-chaîne dans une autre chaîne de arr. Si plusieurs de ces sous-chaînes existent, answer[i] doit être la plus petite lexicographiquement. Et si aucune sous-chaîne de ce type n'existe, answer[i] doit être une chaîne vide.

Renvoyer le tableau answer.

Exemple 1 :

Entrée : arr = ["cab","ad","bad","c"]
Sortie : ["ab","","ba",""]
Explication : Nous avons ce qui suit :
- Pour la chaîne "cab", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est soit "ca" soit "ab", nous choisissons la sous-chaîne lexicographiquement la plus petite, qui est "ab".
- Pour la chaîne "ad", il n'y a pas de sous-chaîne qui n'apparaisse dans aucune autre chaîne.
- Pour la chaîne "bad", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "ba".
- Pour la chaîne "c", il n'existe aucune sous-chaîne qui n'apparaisse dans aucune autre chaîne.

Exemple 2 :

Entrée : arr = ["abc","bcd","abcd"]
Sortie : ["","","abcd"]
Explication : Nous avons ce qui suit :
- Pour la chaîne "abc", il n'existe aucune sous-chaîne qui n'apparaisse dans aucune autre chaîne.
- Pour la chaîne "bcd", il n'existe aucune sous-chaîne qui n'apparaisse dans aucune autre chaîne.
- Pour la chaîne "abcd", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "abcd".

Contraintes :

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] se compose uniquement de lettres minuscules anglaises.

On vous donne un tableau arr de taille n composé de chaînes de caractères non vides.
Trouvez un tableau de chaînes de caractères answer de taille n tel que :

answer[i] est la sous-chaîne la plus courte de arr[i] qui n’apparaît pas comme une sous-chaîne dans une autre chaîne de arr. Si plusieurs de ces sous-chaînes existent, answer[i] doit être la plus petite lexicographiquement. Et si aucune sous-chaîne de ce type n'existe, answer[i] doit être une chaîne vide.

Retournez le tableau answer.

Exemple 1 :

Entrée : arr = ["cab","ad","bad","c"]
Sortie : ["ab","","ba",""]
Explication : Nous avons les cas suivants :
- Pour la chaîne "cab", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est soit "ca" soit "ab", nous choisissons la sous-chaîne la plus petite lexicographiquement, qui est "ab".
- Pour la chaîne "ad", il n'y a pas de sous-chaîne qui n'apparaît dans aucune autre chaîne.
- Pour la chaîne "bad", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "ba".
- Pour la chaîne "c", il n'y a pas de sous-chaîne qui n'apparaît dans aucune autre chaîne.

Exemple 2 :

Entrée : arr = ["abc","bcd","abcd"]
Sortie : ["","","abcd"]
Explication : Nous avons les cas suivants :
- Pour la chaîne "abc", il n'y a pas de sous-chaîne qui n'apparaît dans aucune autre chaîne.
- Pour la chaîne "bcd", il n'y a pas de sous-chaîne qui n'apparaît dans aucune autre chaîne.
- Pour la chaîne "abcd", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "abcd".

Contraintes :

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] ne contient que des lettres minuscules anglaises.

On vous donne un tableau arr de taille n composé de chaînes de caractères non vides.
Trouvez un tableau de chaînes de caractères answer de taille n tel que :

answer[i] est la sous-chaîne la plus courte de arr[i] qui n’apparaît pas comme une sous-chaîne dans une autre chaîne de arr. Si plusieurs de ces sous-chaînes existent, answer[i] doit être la plus petite lexicographiquement. Et si aucune sous-chaîne de ce type n'existe, answer[i] doit être une chaîne vide.

Affichez le tableau answer.

Exemple 1 :

Entrée: arr = ["cab","ad","bad","c"]
Sortie: ["ab","","ba",""]
Explication : Nous avons les cas suivants :
- Pour la chaîne "cab", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est soit "ca" soit "ab", nous choisissons la sous-chaîne la plus petite lexicographiquement, qui est "ab".
- Pour la chaîne "ad", il n'y a pas de sous-chaîne qui n'apparaît dans aucune autre chaîne.
- Pour la chaîne "bad", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "ba".
- Pour la chaîne "c", il n'y a pas de sous-chaîne qui n'apparaît pas dans une autre chaîne.

Exemple 2 :

Entrée: arr = ["abc","bcd","abcd"]
Sortie: ["","","abcd"]
Explication : Nous avons les cas suivants :
- Pour la chaîne "abc", il n'y a pas de sous-chaîne qui n'apparaît pas dans une autre chaîne.
- Pour la chaîne "bcd", il n'y a pas de sous-chaîne qui n'apparaît pas dans une autre chaîne.
- Pour la chaîne "abcd", la sous-chaîne la plus courte qui n'apparaît dans aucune autre chaîne est "abcd".

Contraintes :

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] ne contient que des lettres minuscules anglaises.


Vous disposez d'un tableau d'entiers à indice 0, nommé `nums`, de longueur `n`, et d'un entier positif impair `k`.
La force de `x` sous-tableaux est définie comme suit : force = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, où sum[i] est la somme des éléments dans le i^ème sous-tableau. Formellement, la force est la somme de (-1)^i+1 * sum[i] * (x - i + 1) pour tous les i tels que 1 <= i <= x.
Vous devez sélectionner `k` sous-tableaux disjoints de `nums`, de manière à maximiser leur force.
Renvoyez la force maximale possible pouvant être obtenue.
Notez que les sous-tableaux sélectionnés n’ont pas besoin de couvrir l'ensemble du tableau.

Exemple 1 :

Entrée : nums = [1,2,3,-1,2], k = 3
Sortie : 22
Explication : La meilleure façon possible de sélectionner 3 sous-tableaux est : nums[0..2], nums[3..3], et nums[4..4]. La force est (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Exemple 2 :

Entrée : nums = [12,-2,-2,-2,-2], k = 5
Sortie : 64
Explication : La seule façon possible de sélectionner 5 sous-tableaux disjoints est : nums[0..0], nums[1..1], nums[2..2], nums[3..3], et nums[4..4]. La force est 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Exemple 3 :

Entrée : nums = [-1,-2,-3], k = 1
Sortie : -1
Explication : La meilleure façon possible de sélectionner 1 sous-tableau est : nums[0..0]. La force est -1.

Contraintes :

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k est impair.

On vous donne un tableau indexé à 0 d'entiers nums de longueur n et un entier impair positif k.
La force de x sous-tableaux est définie comme force = somme[1] * x - somme[2] * (x - 1) + somme[3] * (x - 2) - somme[4] * (x - 3) + ... + somme[x] * 1 où somme[i] est la somme des éléments du i^ème sous-tableau. Formellement, la force est la somme de (-1)^i+1 * somme[i] * (x - i + 1) sur tous les i tels que 1 <= i <= x.
Vous devez sélectionner k sous-tableaux disjoints parmi nums, de telle sorte que leur force soit maximale.
Renvoie la force maximale possible qui peut être obtenue.
Notez que les sous-tableaux sélectionnés n'ont pas besoin de couvrir l'intégralité du tableau.

Exemple 1 :

Entrée : nums = [1,2,3,-1,2], k = 3
Sortie : 22
Explication : La meilleure façon possible de sélectionner 3 sous-tableaux est : nums[0..2], nums[3..3] et nums[4..4]. La force est (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Exemple 2 :

Entrée : nums = [12,-2,-2,-2,-2], k = 5
Sortie : 64
Explication : La seule façon possible de sélectionner 5 sous-tableaux disjoints est : nums[0..0], nums[1..1], nums[2..2], nums[3..3] et nums[4..4]. La force est 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Exemple 3 :

Entrée : nums = [-1,-2,-3], k = 1
Sortie : -1
Explication : La meilleure façon possible de sélectionner 1 sous-tableau est : nums[0..0]. La force est -1.

Contraintes :

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k est impair.

Vous disposez d'un tableau nums d'entiers indexé à partir de 0 de longueur n, et d'un entier positif impair k.
La force de x sous-tableaux est définie comme suit : force = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, où sum[i] est la somme des éléments dans le i^ème sous-tableau. Formellement, la force est la somme de (-1)^i+1 * sum[i] * (x - i + 1) pour tous les i tels que 1 <= i <= x.
Vous devez sélectionner k sous-tableaux disjoints de nums, de manière à maximiser leur force.
Retournez la force maximale possible pouvant être obtenue.
Notez que les sous-tableaux sélectionnés n’ont pas besoin de couvrir l'ensemble du tableau.

Exemple 1 :

Entrée : nums = [1,2,3,-1,2], k = 3
Sortie : 22
Explication : La meilleure façon possible de sélectionner 3 sous-tableaux est : nums[0..2], nums[3..3], et nums[4..4]. La force est (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Exemple 2 :

Entrée : nums = [12,-2,-2,-2,-2], k = 5
Sortie : 64
Explication : La seule façon possible de sélectionner 5 sous-tableaux disjoints est : nums[0..0], nums[1..1], nums[2..2], nums[3..3], et nums[4..4]. La force est 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Exemple 3 :

Entrée : nums = [-1,-2,-3], k = 1
Sortie : -1
Explication : La meilleure façon possible de sélectionner 1 sous-tableau est : nums[0..0]. La force est -1.

Contraintes :

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k est impair.


Étant donné une chaîne s, trouvez une sous-chaîne de longueur 2 qui est également présente dans l'inverse de s. Retournez vrai si une telle sous-chaîne existe, et faux sinon.

Exemple 1 :

Entrée : s = "leetcode"
Sortie : true
Explication : la sous-chaîne "ee" est de longueur 2 et est également présente dans l'inverse(s) == "edocteel".

Exemple 2 :

Entrée : s = "abcba"
Sortie : true
Explication : toutes les sous-chaînes de longueur 2 "ab", "bc", "cb", "ba" sont également présentes dans l'inverse(s) == "abcba".

Exemple 3 :

Entrée : s = "abcd"
Sortie : false
Explication : il n'y a pas de sous-chaîne de longueur 2 dans s qui est également présente dans l'inverse de s.

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres anglaises minuscules.

Étant donné une chaîne s, trouvez une sous-chaîne de longueur 2 qui est également présente dans l'inverse de s. Retournez true si une telle sous-chaîne existe, et false sinon.

Exemple 1 :

Entrée : s = "leetcode"
Sortie : true
Explanation: Substring "ee" is of length 2 which is also present in reverse(s) == "edocteel".

Exemple 2 :

Entrée : s = "abcba"
Sortie : true
Explanation: All of the substrings of length 2 "ab", "bc", "cb", "ba" are also present in reverse(s) == "abcba".

Exemple 3 :

Entrée : s = "abcd"
Sortie : false
Explication : Il n'y a pas de sous-chaîne de longueur 2 dans s qui est également présente dans l'inverse de s.

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres anglaises minuscules.

Étant donnée une chaîne s, recherchez toute sous-chaîne de longueur 2 qui est également présente dans l'inverse de s.
Renvoyer true si une telle sous-chaîne existe, et false sinon.

Exemple 1 :

Entrée : s = "leetcode"
Sortie : true
Explication : La sous-chaîne "ee" est de longueur 2 qui est également présente dans reverse(s) == "edocteel".

Exemple 2 :

Entrée : s = "abcba"
Sortie : true
Explication : Toutes les sous-chaînes de longueur 2 "ab", "bc", "cb", "ba" sont également présentes dans reverse(s) == "abcba".

Exemple 3 :

Entrée : s = "abcd"
Sortie : false
Explication : Il n'y a pas de sous-chaîne de longueur 2 dans s, qui soit également présente dans l'inverse de s.

Contraintes :

1 <= s.length <= 100
s est composé uniquement de lettres minuscules anglaises.


Étant donné une chaîne `s` et un caractère `c`, renvoyez le nombre total de sous-chaînes de `s` qui commencent et se terminent par `c`.

Exemple 1 :

Entrée : s = "abada", c = "a"
Sortie : 6
Explication : Les sous-chaînes commençant et se terminant par "a" sont : "abada", "abada", "abada", "abada", "abada", "abada".

Exemple 2 :

Entrée : s = "zzz", c = "z"
Sortie : 6
Explication : Il y a un total de 6 sous-chaînes dans `s` et toutes commencent et se terminent par "z".

Contraintes :

1 <= s.length <= 10^5
`s` et `c` sont composés uniquement de lettres minuscules anglaises.

Étant donnée une chaîne s et un caractère c, retournez le nombre total de sous-chaînes de s qui commencent et se terminent par c.

Exemple 1 :

Entrée : s = "abada", c = "a"
Sortie : 6
Explication : Les sous-chaînes commençant et se terminant par "a" sont : "a", "aba", "abada", "ada", "a", "a".

Exemple 2 :

Entrée : s = "zzz", c = "z"
Sortie : 6
Explication : Il y a un total de 6 sous-chaînes dans s et toutes commencent et se terminent par "z".

Contraintes :

1 <= s.length <= 10^5
s et c sont composés uniquement de lettres minuscules anglaises.

On vous donne une chaîne de caractères s et un caractère c. Retournez le nombre total de sous-chaînes de s qui commencent et se terminent par c.

Exemple 1 :

Entrée : s = "abada", c = "a"
Résultat : 6
Explication : Les sous-chaînes commençant et se terminant par "a" sont : "abada", "abada", "abada", "abada", "abada", "abada".

Exemple 2 :

Entrée : s = "zzz", c = "z"
Sortie : 6
Explication : Il y a un total de 6 sous-chaînes dans s et toutes commencent et se terminent par "z".

Contraintes :

1 <= s.length <= 10^5
s et c ne sont constitués que de lettres minuscules anglaises.


Vous disposez d'une chaîne de caractères word et d'un entier k.
Nous considérons que word est k-spéciale si |freq(word[i]) - freq(word[j])| <= k pour tous les indices i et j dans la chaîne.
Ici, freq(x) désigne la fréquence du caractère x dans word, et |y| désigne la valeur absolue de y.
Retournez le nombre minimum de caractères que vous devez supprimer pour rendre word k-spéciale.

Exemple 1 :

Entrée : word = "aabcaba", k = 0
Sortie : 3
Explication : Nous pouvons rendre word 0-spéciale en supprimant 2 occurrences de "a" et 1 occurrence de "c". Par conséquent, word devient égal à "baba" où freq('a') == freq('b') == 2.

Exemple 2 :

Entrée : word = "dabdcbdcdcd", k = 2
Sortie : 2
Explication : Nous pouvons rendre word 2-spéciale en supprimant 1 occurrence de "a" et 1 occurrence de "d". Par conséquent, word devient égal à "bdcbdcdcd" où freq('b') == 2, freq('c') == 3, et freq('d') == 4.

Exemple 3 :

Entrée : word = "aaabaaa", k = 2
Sortie : 1
Explication : Nous pouvons rendre word 2-spéciale en supprimant 1 occurrence de "b". Par conséquent, word devient égal à "aaaaaa" où la fréquence de chaque lettre est maintenant uniformément 6.

Contraintes :

1 <= word.length <= 10^5
0 <= k <= 10^5
word est composé uniquement de lettres minuscules anglaises.

Vous avez une chaîne de caractères et un entier k.
Nous considérons que le mot est k-spécial si |freq(word[i]) - freq(word[j])| <= k pour tous les indices i et j dans la chaîne.
Ici, freq(x) désigne la fréquence du caractère x dans le mot, et |y| indique la valeur absolue de y.
Renvoyez le nombre minimum de caractères que vous devez supprimer pour rendre le mot k-spécial.

Exemple 1:

Entrée: word = "aabcaba", k = 0
Sortie: 3
Explication: Nous pouvons rendre le mot 0 spécial en supprimant 2 occurrences de "A" et 1 occurrence de "C". Par conséquent, le mot devient égal à "baba" où freq ('a') == freq ('b') == 2.

Exemple 2:

Entrée: word = "dabdcbdcdcd", k = 2
Sortie: 2
Explication: Nous pouvons faire du mot 2-spécial en supprimant 1 occurrence de "a" et 1 occurrence de "D". Par conséquent, le mot devient égal à "bdcbdcdcd" où freq ('b') == 2, freq ('c') == 3 et freq ('d') == 4.

Exemple 3:

Entrée: word = "aaabaaa", k = 2
Sortie: 1
Explication: Nous pouvons faire du mot 2-spécial en supprimant 1 occurrence de "B". Par conséquent, le mot devient égal à "aaaaaa" où la fréquence de chaque lettre est désormais uniformément 6.

Contraintes:

1 <= word.length <= 10 ^ 5
0 <= k <= 10 ^ 5
Le mot ne se compose que de lettres anglaises minuscules.

Vous disposez d'une chaîne de caractères word et d'un entier k.
Nous considérons que word est k-spéciale si |freq(word[i]) - freq(word[j])| <= k pour tous les indices i et j dans la chaîne.
Ici, freq(x) désigne la fréquence du caractère x dans word, et |y| désigne la valeur absolue de y.
Retournez le nombre minimum de caractères que vous devez supprimer pour rendre word k-spéciale.

Exemple 1 :

Entrée : word = "aabcaba", k = 0
Sortie : 3
Explication : Nous pouvons rendre word 0-spéciale en supprimant 2 occurrences de "a" et 1 occurrence de "c". Par conséquent, word devient égal à "baba" où freq('a') == freq('b') == 2.

Exemple 2 :

Entrée : word = "dabdcbdcdcd", k = 2
Sortie : 2
Explication : Nous pouvons rendre word 2-spéciale en supprimant 1 occurrence de "a" et 1 occurrence de "d". Par conséquent, word devient égal à "bdcbdcdcd" où freq('b') == 2, freq('c') == 3, et freq('d') == 4.

Exemple 3 :

Entrée : word = "aaabaaa", k = 2
Sortie : 1
Explication : Nous pouvons rendre word 2-spéciale en supprimant 1 occurrence de "b". Par conséquent, word devient égal à "aaaaaa" où la fréquence de chaque lettre est maintenant uniformément 6.

Contraintes :

1 <= word.length <= 10^5
0 <= k <= 10^5
word est composé uniquement de lettres anglaises minuscules.


On vous donne un tableau binaire nums de longueur n, un entier positif k et un entier non négatif maxChanges.
Alice joue à un jeu où l'objectif est de récupérer k uns de nums en effectuant le nombre minimum de mouvements. Lorsque le jeu commence, Alice choisit n'importe quel indice aliceIndex dans la plage [0, n - 1] et se place à cet indice. Si nums[aliceIndex] == 1, Alice récupère le un et nums[aliceIndex] devient 0(cela ne compte pas comme un mouvement). Après cela, Alice peut effectuer un nombre quelconque de mouvements (y compris zéro) où à chaque mouvement Alice doit exécuter exactement l'une des actions suivantes :

Sélectionner un index j != aliceIndex tel que nums[j] == 0 et définir nums[j] = 1. Cette action peut être exécutée au maximum maxChanges fois.
Sélectionner deux indices adjacents x et y (|x - y| == 1) tels que nums[x] == 1, nums[y] == 0, puis échanger leurs valeurs (définir nums[y] = 1 et nums[x] = 0). Si y == aliceIndex, Alice récupère le un après ce mouvement et nums[y] devient 0.

Retournez le nombre minimum de mouvements requis par Alice pour récupérer exactement k uns.

Exemple 1 :

Entrée : nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Sortie : 3
Explication : Alice peut récupérer 3 uns en 3 mouvements, si Alice exécute les actions suivantes à chaque mouvement lorsqu'elle se trouve à aliceIndex == 1 :

Au début du jeu, Alice récupère le un et nums[1] devient 0. nums devient [1,1,1,0,0,1,1,0,0,1].
Sélectionner j == 2 et exécuter une action du premier type. nums devient [1,0,1,0,0,1,1,0,0,1]
Sélectionner x == 2 et y == 1, et exécuter une action du deuxième type. nums devient [1,1,0,0,0,1,1,0,0,1]. Comme y == aliceIndex, Alice récupère le un et nums devient [1,0,0,0,0,1,1,0,0,1].
Sélectionner x == 0 et y == 1, et exécuter une action du deuxième type. nums devient [0,1,0,0,0,1,1,0,0,1]. Comme y == aliceIndex, Alice récupère le un et nums devient [0,0,0,0,0,1,1,0,0,1].

Notez qu'il est possible qu'Alice récupère 3 uns en utilisant une autre séquence de 3 mouvements.

Exemple 2 :

Entrée : nums = [0,0,0,0], k = 2, maxChanges = 3
Sortie : 4
Explication : Alice peut récupérer 2 uns en 4 mouvements, si Alice exécute les actions suivantes à chaque mouvement lorsqu'elle se trouve à aliceIndex == 0 :

Sélectionner j == 1 et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice récupère le un et nums devient [0,0,0,0].
Sélectionner j == 1 à nouveau et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0 à nouveau, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice récupère le un et nums devient [0,0,0,0].

Contraintes :

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

On vous donne un tableau binaire nums de longueur n, un entier positif k et un entier non négatif maxChanges.
Alice joue à un jeu, où le but est qu'elle récupère k Uns de nums en utilisant le nombre minimum de coups. Lorsque le jeu commence, Alice récupère n'importe quel index aliceIndex dans la plage [0, n - 1] et s'y tient. Si nums[aliceIndex] == 1 , Alice récupère l'unité et nums[aliceIndex] devient 0 (cela ne compte pas comme un coup). Après cela, Alice peut effectuer n'importe quel nombre de coups (y compris zéro) où à chaque coup Alice doit effectuer exactement l'une des actions suivantes :

Sélectionnez n'importe quel index j != aliceIndex tel que nums[j] == 0 et définissez nums[j] = 1. Cette action peut être effectuée au plus maxChanges fois.
Sélectionnez deux indices adjacents x et y (|x - y| == 1) tels que nums[x] == 1, nums[y] == 0, puis échangez leurs valeurs (définissez nums[y] = 1 et nums[x] = 0). Si y == aliceIndex, Alice récupère celui qui suit ce déplacement et nums[y] devient 0.

Renvoie le nombre minimum de déplacements requis par Alice pour sélectionner exactement k Uns.

Exemple 1 :

Entrée : nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Sortie : 3
Explication : Alice peut prendre 3 Uns en 3 coups, si elle effectue les actions suivantes à chaque coup lorsqu'elle se trouve à aliceIndex = 1 :

Au début de la partie, Alice prend l'unité et nums[1] devient 0. nums devient [1,1,1,0,0,1,1,0,0,1].
Sélectionnez j = = 2 et effectuez une action du premier type. nums devient [1,0,1,0,0,1,1,0,0,1]
Sélectionnez x = = 2 et y = = 1, et effectuez une action du deuxième type. nums devient [1,1,0,0,1,1,0,0,1]. Comme y == aliceIndex, Alice prend le un et nums devient [1,0,0,0,0,1,1,0,0,1].
Sélectionnez x == 0 et y == 1, et effectuez une action du deuxième type. nums devient [0,1,0,0,0,1,1,0,0,1]. Puisque y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0,0,1,1,0,0,1].

Notez qu'il est possible qu'Alice prenne 3 uns en utilisant une autre séquence de 3 mouvements.

Exemple 2 :

Entrée : nums = [0,0,0,0], k = 2, maxChanges = 3
Sortie : 4
Explication : Alice peut prendre 2 Uns en 4 déplacements si elle effectue les actions suivantes à chaque déplacement lorsqu'elle se trouve à aliceIndex == 0:

Sélectionner j == 1 et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0].
Sélectionner j == 1 à nouveau et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0 à nouveau, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0].

Contraintes :

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

On vous donne un tableau binaire nums de longueur n, un entier positif k et un entier non négatif maxChanges.
Alice joue à un jeu où l'objectif est de ramasser k uns de nums en utilisant le nombre minimum de mouvements. Lorsque le jeu commence, Alice choisit n'importe quel index aliceIndex dans la plage [0, n - 1] et s'y tient. Si nums[aliceIndex] == 1, Alice ramasse le un et nums[aliceIndex] devient 0 (cela ne compte pas comme un mouvement). Après cela, Alice peut effectuer un nombre quelconque de mouvements (y compris zéro) où à chaque mouvement Alice doit exécuter exactement l'une des actions suivantes :

Sélectionner un index j != aliceIndex tel que nums[j] == 0 et définir nums[j] = 1. Cette action peut être exécutée au maximum maxChanges fois.
Sélectionner deux indices adjacents x et y (|x - y| == 1) tels que nums[x] == 1, nums[y] == 0, puis échanger leurs valeurs (définir nums[y] = 1 et nums[x] = 0). Si y == aliceIndex, Alice ramasse le un après ce mouvement et nums[y] devient 0.

Retourner le nombre minimum de mouvements requis par Alice pour ramasser exactement k uns.

Exemple 1 :

Entrée : nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Sortie : 3
Explication : Alice peut ramasser 3 uns en 3 mouvements, si Alice exécute les actions suivantes à chaque mouvement lorsqu'elle se trouve à aliceIndex == 1 :

Au début du jeu, Alice ramasse le un et nums[1] devient 0. nums devient [1,1,1,0,0,1,1,0,0,1].
Sélectionner j == 2 et exécuter une action du premier type. nums devient [1,0,1,0,0,1,1,0,0,1]
Sélectionner x == 2 et y == 1, et exécuter une action du deuxième type. nums devient [1,1,0,0,0,1,1,0,0,1]. Comme y == aliceIndex, Alice ramasse le un et nums devient [1,0,0,0,0,1,1,0,0,1].
Sélectionner x == 0 et y == 1, et exécuter une action du deuxième type. nums devient [0,1,0,0,0,1,1,0,0,1]. Comme y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0,0,1,1,0,0,1].

Notez qu'il est possible qu'Alice ramasse 3 uns en utilisant une autre séquence de 3 mouvements.

Exemple 2 :

Entrée : nums = [0,0,0,0], k = 2, maxChanges = 3
Sortie : 4
Explication : Alice peut ramasser 2 uns en 4 mouvements, si Alice exécute les actions suivantes à chaque mouvement lorsqu'elle se trouve à aliceIndex == 0 :

Sélectionner j == 1 et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0].
Sélectionner j == 1 à nouveau et exécuter une action du premier type. nums devient [0,1,0,0].
Sélectionner x == 1 et y == 0 à nouveau, et exécuter une action du deuxième type. nums devient [1,0,0,0]. Comme y == aliceIndex, Alice ramasse le un et nums devient [0,0,0,0].

Contraintes :

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k


Étant donné une chaîne de caractères s, retournez la longueur maximale d'une sous-chaîne telle qu'elle contienne au plus deux occurrences de chaque caractère.

Exemple 1 :

Entrée : s = "bcbbbcba"
Sortie : 4
Explication :
La sous-chaîne suivante a une longueur de 4 et contient au plus deux occurrences de chaque caractère : "bcbbbcba".
Exemple 2 :

Entrée : s = "aaaa"
Sortie : 2
Explication :
La sous-chaîne suivante a une longueur de 2 et contient au plus deux occurrences de chaque caractère : "aaaa".

Contraintes :

2 <= s.length <= 100
s est constitué uniquement de lettres minuscules anglaises.

Étant donné une chaîne de caractères s, retournez la longueur maximale d'une sous-chaîne telle qu'elle contienne au plus deux occurrences de chaque caractère.

Exemple 1:

Entrée: s = "bcbbbcba"
Sortie: 4
Explication:
La sous-chaîne suivante a une longueur de 4 et contient au plus deux occurrences de chaque caractère: "bcbbbcba".
Exemple 2:

Entrée: s = "aaaa"
Sortie: 2
Explication:
La sous-chaîne suivante a une longueur de 2 aet contient au plus deux occurrences de chaque caractère: "aaaa".

Contraintes:

2 <= s.length <= 100
s est constitué uniquement de lettres minuscules anglaises.

Étant donné une chaîne de caractères s, renvoyer la longueur maximale d'une sous-chaîne telle qu'elle contienne au plus deux occurrences de chaque caractère.

Exemple 1 :

Entrée : s = "bcbbbcba"
Sortie : 4
Explication :
La sous-chaîne suivante a une longueur de 4 et contient au plus deux occurrences de chaque caractère : "bcbbbcba".
Exemple 2 :

Entrée : s = "aaaa"
Sortie : 2
Explication :
La sous-chaîne suivante a une longueur de 2 et contient au plus deux occurrences de chaque caractère : «"aaaa".

Contraintes :

2 <= s.length <= 100
s n'est constitué que de lettres minuscules anglaises.


Vous avez un entier positif k. Initialement, vous avez un tableau nums = [1].
Vous pouvez effectuer l'une des opérations suivantes sur le tableau un nombre quelconque de fois (possiblement zéro) :

Choisir n'importe quel élément du tableau et augmenter sa valeur de 1.
Dupliquer n'importe quel élément du tableau et l'ajouter à la fin du tableau.

Retournez le nombre minimum d'opérations nécessaires pour que la somme des éléments du tableau final soit supérieure ou égale à k.

Exemple 1 :

Entrée : k = 11
Sortie : 5
Explication :
Nous pouvons effectuer les opérations suivantes sur le tableau nums = [1] :

Augmenter l'élément de 1 trois fois. Le tableau résultant est nums = [4].
Dupliquer l'élément deux fois. Le tableau résultant est nums = [4,4,4].

La somme du tableau final est 4 + 4 + 4 = 12, ce qui est supérieur ou égal à k = 11.
Le nombre total d'opérations effectuées est 3 + 2 = 5.

Exemple 2 :

Entrée : k = 1
Sortie : 0
Explication :
La somme du tableau initial est déjà supérieure ou égale à 1, donc aucune opération n'est nécessaire.

Contraintes :

1 <= k <= 10^5

On vous donne un entier positif k. Initialement, vous avez un tableau nums = [1].
Vous pouvez effectuer l'une des opérations suivantes sur le tableau du nombre de fois (éventuellement zéro):

Choisissez n'importe quel élément dans le tableau et augmentez sa valeur de 1.
Dupliquez n'importe quel élément du tableau et ajoutez-le à la fin du tableau.

Renvoie le nombre minimum d'opérations nécessaires pour rendre la somme des éléments du tableau final supérieur ou égal à k.

Exemple 1:

Entrée: k = 11
Sortie: 5
Explication:
Nous pouvons effectuer les opérations suivantes sur le tableau nums = [1]:

Augmentez l'élément de 1 trois fois. Le tableau résultant est nums = [4].
Dupliquez l'élément deux fois. Le tableau résultant est nums = [4,4,4].

La somme du tableau final est 4 + 4 + 4 = 12 qui est supérieure ou égale à k = 11.
Le nombre total d'opérations effectués est de 3 + 2 = 5.

Exemple 2:

Entrée: k = 1
Sortie: 0
Explication:
La somme du tableau d'origine est déjà supérieure ou égale à 1, donc aucune opération n'est nécessaire.

Contraintes:

1 <= k <= 10^5


Le problème consiste à suivre la fréquence des identifiants dans une collection qui change au fil du temps. Vous disposez de deux tableaux d'entiers, nums et freq, de longueur égale n. Chaque élément de nums représente un identifiant, et l'élément correspondant de freq indique combien de fois cet identifiant doit être ajouté ou supprimé de la collection à chaque étape.

Ajout d'identifiants : si freq[i] est positif, cela signifie que les identifiants freq[i] avec la valeur nums[i] sont ajoutés à la collection à l'étape i.
Suppression d'identifiants : si freq[i] est négatif, cela signifie que les identifiants -freq[i] avec la valeur nums[i] sont supprimés de la collection à l'étape i.

Renvoie un tableau ans de longueur n, où ans[i] représente le nombre d'identifiants les plus fréquents dans la collection après la i^ème étape. Si la collection est vide à une étape, ans[i] doit être 0 pour cette étape.

Exemple 1 :

Entrée : nums = [2,3,2,1], freq = [3,2,-3,1]
Sortie : [3,3,2,2]
Explication :
Après l'étape 0, nous avons 3 ID avec la valeur 2. Donc ans[0] = 3.
Après l'étape 1, nous avons 3 ID avec la valeur 2 et 2 ID avec la valeur 3. Donc ans[1] = 3.
Après l'étape 2, nous avons 2 ID avec la valeur 3. Donc ans[2] = 2.
Après l'étape 3, nous avons 2 ID avec la valeur 3 et 1 ID avec la valeur 1. Donc ans[3] = 2.

Exemple 2 :

Entrée : nums = [5,5,3], freq = [2,-2,1]
Sortie : [2,0,1]
Explication :
Après étape 0, nous avons 2 ID avec la valeur de 5. Donc ans[0] = 2.
Après l'étape 1, il n'y a plus d'ID. Donc ans[1] = 0.
Après l'étape 2, nous avons 1 ID avec la valeur de 3. Donc ans[2] = 1.

Contraintes :

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
L'entrée est générée de telle sorte que les occurrences d'un ID ne soient pas négatives à aucune étape.

Le problème consiste à suivre la fréquence des ID dans une collection qui change au fil du temps. Vous avez deux tableaux entiers, nums et freq, de longueur égale n. Chaque élément de nums représente un ID, et l'élément correspondant dans freq indique combien de fois cet ID doit être ajouté ou retiré de la collection à chaque étape.

Ajout d'ID : Si freq[i] est positif, cela signifie que freq[i] ID avec la valeur nums[i] sont ajoutés à la collection à l'étape i.
Suppression d'ID : Si freq[i] est négatif, cela signifie que -freq[i] ID avec la valeur nums[i] sont retirés de la collection à l'étape i.

Retournez un tableau ans de longueur n, où ans[i] représente le compte de l'ID le plus fréquent dans la collection après la i^ème étape. Si la collection est vide à une étape, ans[i] doit être 0 pour cette étape.

Exemple 1 :

Entrée : nums = [2,3,2,1], freq = [3,2,-3,1]
Sortie : [3,3,2,2]
Explication :
Après l'étape 0, nous avons 3 ID avec la valeur de 2. Donc ans[0] = 3.
Après l'étape 1, nous avons 3 ID avec la valeur de 2 et 2 ID avec la valeur de 3. Donc ans[1] = 3.
Après l'étape 2, nous avons 2 ID avec la valeur de 3. Donc ans[2] = 2.
Après l'étape 3, nous avons 2 ID avec la valeur de 3 et 1 ID avec la valeur de 1. Donc ans[3] = 2.

Exemple 2 :

Entrée : nums = [5,5,3], freq = [2,-2,1]
Sortie : [2,0,1]
Explication :
Après l'étape 0, nous avons 2 ID avec la valeur de 5. Donc ans[0] = 2.
Après l'étape 1, il n'y a pas d'ID. Donc ans[1] = 0.
Après l'étape 2, nous avons 1 ID avec la valeur de 3. Donc ans[2] = 1.

Contraintes :

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
L'entrée est générée de manière à ce que les occurrences d'un ID ne soient pas négatives à une étape quelconque.

Le problème consiste à suivre la fréquence des ID dans une collection qui change au fil du temps. Vous avez deux tableaux entiers, nums et freq, de longueur égale n. Chaque élément de nums représente un ID, et l'élément correspondant de freq indique combien de fois cet ID doit être ajouté ou retiré de la collection à chaque étape.

Ajout d'ID : Si freq[i] est positif, cela signifie que freq[i] ID avec la valeur nums[i] sont ajoutés à la collection à l'étape i.
Suppression d'ID : Si freq[i] est négatif, cela signifie que -freq[i] ID avec la valeur nums[i] sont retirés de la collection à l'étape i.

Retournez un tableau ans de longueur n, où ans[i] représente le compte de l'ID le plus fréquent dans la collection après la i^ème étape. Si la collection est vide à une étape, ans[i] doit être 0 pour cette étape.

Exemple 1 :

Entrée : nums = [2,3,2,1], freq = [3,2,-3,1]
Sortie : [3,3,2,2]
Explication :
Après l'étape 0, nous avons 3 ID avec la valeur de 2. Donc ans[0] = 3.
Après l'étape 1, nous avons 3 ID avec la valeur de 2 et 2 ID avec la valeur de 3. Donc ans[1] = 3.
Après l'étape 2, nous avons 2 ID avec la valeur de 3. Donc ans[2] = 2.
Après l'étape 3, nous avons 2 ID avec la valeur de 3 et 1 ID avec la valeur de 1. Donc ans[3] = 2.

Exemple 2 :

Entrée : nums = [5,5,3], freq = [2,-2,1]
Sortie : [2,0,1]
Explication :
Après l'étape 0, nous avons 2 ID avec la valeur de 5. Donc ans[0] = 2.
Après l'étape 1, il n'y a pas d'ID. Donc ans[1] = 0.
Après l'étape 2, nous avons 1 ID avec la valeur de 3. Donc ans[2] = 1.

Contraintes :

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
L'entrée est générée de manière à ce que les occurrences d'un ID ne soient pas négatives à une étape quelconque.