Il y a trois cartes avec les lettres $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ placées en ligne dans un certain ordre. Vous pouvez effectuer l'opération suivante au maximum une fois :

-  Choisissez deux cartes et échangez-les.  Est-il possible que la rangée devienne $\texttt{abc}$ après l'opération ? Indiquez "YES" si c'est possible, et "NO" sinon.

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 6$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient une seule chaîne composée exactement une fois de chacun des trois caractères $\texttt{a}$, $\texttt{b}$ et $\texttt{c}$, représentant les cartes.

Sortie

Pour chaque cas de test, indiquez "YES" si vous pouvez faire que la rangée soit $\texttt{abc}$ avec au maximum une opération, ou "NON" sinon.

Vous pouvez donner la réponse avec n'importe quelle casse (par exemple, les chaînes "yEs", "yes", "Yes" et "YES" seront reconnues comme une réponse positive). Exemple d'entrée 1 :
6

abc

acb

bac

bca

cab

cba

Exemple de sortie 1 :

YES
YES
YES
NO
NO
YES

Remarque

Dans le premier cas de test, nous n'avons pas besoin de faire d'opérations, car la rangée est déjà $\texttt{abc}$.

Dans le second cas de test, nous pouvons échanger $\texttt{c}$ et $\texttt{b}$ : $\texttt{acb} \to \texttt{abc}$.

Dans le troisième cas de test, nous pouvons échanger $\texttt{b}$ et $\texttt{a}$ : $\texttt{bac} \to \texttt{abc}$.

Dans le quatrième cas de test, il est impossible de faire $\texttt{abc}$ avec au maximum une opération.

Il y a trois cartes avec les lettres $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ placées en ligne dans un certain ordre. Vous pouvez effectuer l'opération suivante au maximum une fois :

- Choisissez deux cartes et échangez-les. Est-il possible que la rangée devienne $\texttt{abc}$ après l'opération ? Affichez "YES" si c'est possible, et "NO" dans le cas contraire.

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 6$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient une seule chaîne composée exactement une fois de chacun des trois caractères $\texttt{a}$, $\texttt{b}$ et $\texttt{c}$, représentant les cartes.

Sortie

Pour chaque cas de test, Affichez "YES" si vous pouvez faire que la rangée soit $\texttt{abc}$ avec au maximum une opération, ou "NON" dans le cas contraire.

Vous pouvez donner la réponse avec n'importe quelle casse (par exemple, les chaînes "yEs", "yes", "Yes" et "YES" seront reconnues comme une réponse positive).

Exemple d'entrée 1 :
6

abc

acb

bac

bca

cab

cba

Exemple de sortie 1 :

YES
YES
YES
NO
NO
YES

Remarque

Dans le premier cas de test, nous n'avons pas besoin de faire d'opérations, car la rangée est déjà $\texttt{abc}$.

Dans le second cas de test, nous pouvons échanger $\texttt{c}$ et $\texttt{b}$ : $\texttt{acb} \to \texttt{abc}$.

Dans le troisième cas de test, nous pouvons échanger $\texttt{b}$ et $\texttt{a}$ : $\texttt{bac} \to \texttt{abc}$.

Dans le quatrième cas de test, il est impossible de faire $\texttt{abc}$ avec au maximum une opération.

Il y a trois cartes avec les lettres $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ placées dans une rangée dans un certain ordre. Vous pouvez effectuer l'opération suivante au plus une fois :

- Choisissez deux cartes et échangez-les. Est-il possible que la rangée devienne $\texttt{abc}$ après l'opération ? Affichez "YES" si c'est possible, et "NO" sinon.

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 6$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient une seule chaîne composée de chacun des trois caractères $\texttt{a}$, $\texttt{b}$ et $\texttt{c}$ exactement une fois, représentant les cartes.

Sortie

Pour chaque cas de test, affichez "YES" si vous pouvez créer la rangée $\texttt{abc}$ avec au plus une opération, ou "NO" sinon.

Vous pouvez afficher la réponse dans n'importe quel cas (par exemple, les chaînes "yEs", "yes", "Yes" et "YES" seront reconnues comme une réponse positive).Exemple d'entrée 1 :
6

abc

acb

bac

bca

cab

cba

Exemple de sortie 1 :

YES
YES
YES
NO
NO
YES

Remarque

Dans le premier cas de test, nous n'avons pas besoin d'effectuer d'opérations, car la ligne est déjà $\texttt{abc}$.

Dans le deuxième cas de test, nous pouvons échanger $\texttt{c}$ et $\texttt{b}$ : $\texttt{acb} \to \texttt{abc}$.

Dans le troisième cas de test, nous pouvons échanger $\texttt{b}$ et $\texttt{a}$ : $\texttt{bac} \to \texttt{abc}$.

Dans le quatrième cas de test, il est impossible de créer $\texttt{abc}$ en utilisant au plus une opération.


Slavic prépare un cadeau pour l'anniversaire d'un ami. Il a un tableau $a$ de $n$ chiffres et le cadeau sera le produit de tous ces chiffres. Comme Slavic est un bon garçon qui veut faire le plus grand produit possible, il souhaite ajouter $1$ à exactement un de ses chiffres.

Quel est le produit maximal que Slavic peut obtenir ?

Entrée

La première ligne contient un entier unique $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier unique $n$ ($1 \leq n \leq 9$) — le nombre de chiffres.

La deuxième ligne de chaque cas de test contient $n$ entiers séparés par des espaces $a_i$ ($0 \leq a_i \leq 9$) — les chiffres dans le tableau.

Sortie

Pour chaque cas de test, affichez un entier unique — le produit maximal que Slavic peut obtenir, en ajoutant $1$ à exactement un de ses chiffres.Exemple d'entrée 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Exemple de sortie 1:

16
2
432
430467210

Slavic prépare un cadeau pour l'anniversaire d'un ami. Il a un tableau $a$ de $n$ chiffres et le cadeau sera le produit de tous ces chiffres. Comme Slavic est un bon garçon qui veut faire le plus grand produit possible, il souhaite ajouter $1$ à exactement un de ses chiffres.

Quel est le produit maximal que Slavic peut obtenir ?

Entrée

La première ligne contient un entier unique $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier unique $n$ ($1 \leq n \leq 9$) — le nombre de chiffres.

La deuxième ligne de chaque cas de test contient $n$ entiers séparés par des espaces $a_i$ ($0 \leq a_i \leq 9$) — les chiffres dans le tableau.

Sortie

Pour chaque cas de test, affichez un entier unique — le produit maximal que Slavic peut obtenir, en ajoutant $1$ à exactement un de ses chiffres.

Échantillon d'entrée 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Échantillon de sortie 1:

16
2
432
430467210

Slavic prépare un cadeau pour l'anniversaire d'un ami. Il a un tableau $a$ de $n$ chiffres et le cadeau sera le produit de tous ces chiffres. Comme Slavic est un bon garçon qui veut faire le plus grand produit possible, il veut ajouter $1$ à exactement un de ses chiffres.

Quel est le produit maximum que Slavic peut faire ?

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 10^4$) - le nombre de cas de test.

La première ligne de chaque cas de test contient un seul entier $n$ ($1 \leq n \leq 9$) - le nombre de chiffres.

La deuxième ligne de chaque cas de test contient $n$ entiers séparés par des espaces $a_i$ ($0 \leq a_i \leq 9$) - les chiffres du tableau.

Sortie

Pour chaque cas de test, la sortie est un seul entier - le produit maximum que Slavic peut faire, en ajoutant $1$ à exactement un de ses chiffres.Exemple d'entrée 1 :
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Exemple de sortie 1 :

16
2
432
430467210


Vous avez une bande de papier $s$ qui fait $n$ cellules de long. Chaque cellule est soit noire, soit blanche. Lors d'une opération, vous pouvez prendre n'importe quelles $k$ cellules consécutives et les rendre toutes blanches.

Trouvez le nombre minimum d'opérations nécessaires pour enlever toutes les cellules noires.

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 1000$) — le nombre de cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — la longueur du papier et l'entier utilisé dans l'opération.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$ composée de caractères $\texttt{B}$ (représentant une cellule noire) ou $\texttt{W}$ (représentant une cellule blanche).

La somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez un seul entier — le nombre minimum d'opérations nécessaires pour enlever toutes les cellules noires.Exemple d'entrée 1 :
8

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

Exemple de sortie 1 :

2
1
2
1
4
3
4
0

Remarque

Dans le premier cas de test, vous pouvez effectuer les opérations suivantes : $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

Dans le deuxième cas de test, vous pouvez effectuer les opérations suivantes : $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

Dans le troisième cas de test, vous pouvez effectuer les opérations suivantes : $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

Vous avez une bande de papier $s$ qui fait $n$ cellules de long. Chaque cellule est soit noire, soit blanche. Lors d'une opération, vous pouvez prendre n'importe quelles $k$ cellules consécutives et les rendre toutes blanches.

Trouvez le nombre minimum d'opérations nécessaires pour enlever toutes les cellules noires.

Entrée

La première ligne contient un seul entier $t$ ($1 \leq t \leq 1000$) — le nombre de cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — la longueur du papier et l'entier utilisé dans l'opération.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$ composée de caractères $\texttt{B}$ (représentant une cellule noire) ou $\texttt{W}$ (représentant une cellule blanche).

La somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez un seul entier — le nombre minimum d'opérations nécessaires pour enlever toutes les cellules noires.Exemple d'entrée 1:
8

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

Exemple de sortie 1 :

2
1
2
1
4
3
4
0

Remarque

Dans le premier cas de test, vous pouvez effectuer les opérations suivantes : $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

Dans le deuxième cas de test, vous pouvez effectuer les opérations suivantes : $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

Dans le troisième cas de test, vous pouvez effectuer les opérations suivantes : $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

On vous donne une bande de papier $s$ qui est des cellules $n$ long. Chaque cellule est noire ou blanche. Dans une opération, vous pouvez prendre toutes les cellules consécutives $k$ et les rendre tout blancs.

Trouvez le nombre minimum d'opérations nécessaires pour éliminer toutes les cellules noires.

Saisir

La première ligne contient un seul entier $t$ ($1 \leq t \leq 1000$) - le nombre de cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($1 \ leq k \ leq n \ leq 2 \ cdot 10 ^ 5$) - la longueur du papier et l'entier utilisé dans l'opération.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$ composée de caractères $\texttt{B}$ (représentant une cellule noire) ou $\texttt{W}$ (représentant une cellule blanche).

La somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortir

Pour chaque cas de test, sortez un seul entier - le nombre minimum d'opérations nécessaires pour éliminer toutes les cellules noires. Entrée d'échantillon 1:
8

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

Exemple de sortie 1:

2
1
2
1
4
3
4
0

Note

Dans le premier cas de test, vous pouvez effectuer les opérations suivantes: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

Dans le deuxième cas de test, vous pouvez effectuer les opérations suivantes: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

Dans le troisième cas de test, vous pouvez effectuer les opérations suivantes: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$


On vous donne une chaîne $s$ de longueur $n$, composée de lettres latines minuscules et d'un entier $k$.

Vous devez vérifier s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de manière à ce que les caractères restants puissent être réorganisés pour former un palindrome. Notez que vous pouvez réorganiser les caractères restants de n'importe quelle manière.

Un palindrome est une chaîne qui se lit de la même manière dans le bon sens. Par exemple, les chaînes "z", "aaa", "aba", "abccba" sont des palindromes, tandis que les chaînes "codeforces", "reality", "ab" ne le sont pas.

Entrée

Chaque test se compose de plusieurs cas de test. La première ligne contient un seul entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Ceci est suivi de leur description.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($0 \leq k < n \leq 10^5$) — la longueur de la chaîne $s$ et le nombre de caractères à supprimer.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$, composée de lettres latines minuscules.

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez « OUI » s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de telle manière que les caractères restants puissent être réorganisés pour former un palindrome, et « NON » dans le cas contraire.

Vous pouvez afficher la réponse dans n'importe quelle casse (majuscule ou minuscule). Par exemple, les chaînes "yEs", "yes", "Yes", and "YES" seront reconnues comme des réponses positives.Exemple d'entrée 1 :
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

Exemple de sortie 1 :

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Remarque

Dans le premier cas de test, rien ne peut être supprimé et la chaîne "a" est un palindrome.

Dans le deuxième cas de test, rien ne peut être supprimé, mais les chaînes "ab" et "ba" ne sont pas des palindromes.

Dans le troisième cas de test, n'importe quel caractère peut être supprimé et la chaîne résultante sera un palindrome.

Dans le quatrième cas de test, une occurrence du caractère "a" peut être supprimée, ce qui donne la chaîne "bb", qui est un palindrome.

Dans le sixième cas de test, une occurrence des caractères "b" et "d" peut être supprimée, ce qui donne la chaîne "acac", qui peut être réorganisée en chaîne "acca".

Dans le neuvième cas de test, une occurrence des caractères "t" et "k" peut être supprimée, ce qui donne la chaîne "aagaa", qui est un palindrome.

Vous avez une chaîne $s$ de longueur $n$, composée de lettres minuscules latines, et d'un entier $k$.

Vous devez vérifier s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de manière à ce que les caractères restants puissent être réarrangés pour former un palindrome. Notez que vous pouvez réarranger les caractères restants de n'importe quelle manière.

Un palindrome est une chaîne qui se lit de la même manière dans les deux sens. Par exemple, les chaînes "z", "aaa", "aba", "abccba" sont des palindromes, tandis que les chaînes "codeforces", "reality", "ab" ne le sont pas.

Entrée

Chaque test consiste en plusieurs cas de test. La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Ceci est suivi de leur description.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($0 \leq k < n \leq 10^5$) — la longueur de la chaîne $s$ et le nombre de caractères à supprimer.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$, composée de lettres minuscules latines.

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez "YES" s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de manière à ce que les caractères restants puissent être réarrangés pour former un palindrome, et "NO" sinon.

Vous pouvez donner la réponse dans n'importe quel cas (majuscule ou minuscule). Par exemple, les chaînes "yEs", "yes", "Yes" et "YES" seront reconnues comme des réponses positives.

Exemple d'entrée 1 :

14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

Exemple de sortie 1 :

Yes
NO
Yes
Yes
Yes
Yes
NO
NO
Yes
Yes
Yes
Yes
NO
Yes

Remarque

Dans le premier cas de test, rien ne peut être supprimé, et la chaîne "a" est un palindrome.

Dans le deuxième cas de test, rien ne peut être supprimé, mais les chaînes "ab" et "ba" ne sont pas des palindromes.

Dans le troisième cas de test, n'importe quel caractère peut être supprimé, et la chaîne résultante sera un palindrome.

Dans le quatrième cas de test, une occurrence du caractère "a" peut être retirée, ce qui donne la chaîne "bb", qui est un palindrome.

Dans le sixième cas de test, une occurrence des caractères "b" et "d" peut être retirée, ce qui donne la chaîne "acac", qui peut être réarrangée pour donner la chaîne "acca".

Dans le neuvième cas de test, une occurrence des caractères "t" et "k" peut être supprimée, ce qui donne la chaîne "aagaa", qui est un palindrome.

Vous avez une chaîne $s$ de longueur $n$, composée de lettres minuscules latines, et un entier $k$.

Vous devez vérifier s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de manière à ce que les caractères restants puissent être réarrangés pour former un palindrome. Notez que vous pouvez réarranger les caractères restants de n'importe quelle manière.

Un palindrome est une chaîne qui se lit de la même manière dans les deux sens. Par exemple, les chaînes "z", "aaa", "aba", "abccba" sont des palindromes, tandis que les chaînes "codeforces", "reality", "ab" ne le sont pas.

Entrée

Chaque test consiste en plusieurs cas de test. La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Leur description suit.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($0 \leq k < n \leq 10^5$) — la longueur de la chaîne $s$ et le nombre de caractères à supprimer.

La deuxième ligne de chaque cas de test contient une chaîne $s$ de longueur $n$, composée de lettres minuscules latines.

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez "YES" s'il est possible de supprimer exactement $k$ caractères de la chaîne $s$ de manière à ce que les caractères restants puissent être réarrangés pour former un palindrome, et "NO" sinon.

Vous pouvez donner la réponse avec n'importe quelle casse (majuscule ou minuscule). Par exemple, les chaînes "yEs", "yes", "Yes" et "YES" seront reconnues comme des réponses positives.Exemple d'entrée 1 :
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

Exemple de sortie 1 :

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Remarque

Dans le premier cas de test, rien ne peut être supprimé, et la chaîne "a" est un palindrome.

Dans le deuxième cas de test, rien ne peut être supprimé, mais les chaînes "ab" et "ba" ne sont pas des palindromes.

Dans le troisième cas de test, n'importe quel caractère peut être supprimé, et la chaîne résultante sera un palindrome.

Dans le quatrième cas de test, une occurrence du caractère "a" peut être retirée, ce qui donne la chaîne "bb", qui est un palindrome.

Dans le sixième cas de test, une occurrence des caractères "b" et "d" peut être retirée, ce qui donne la chaîne "acac", qui peut être réarrangée pour donner la chaîne "acca".

Dans le neuvième cas de test, une occurrence des caractères "t" et "k" peut être supprimée, ce qui donne la chaîne "aagaa", qui est un palindrome.


On vous donne un tableau d'entiers $a_1, a_2, \ldots, a_n$ et un nombre $k$ ($2 \leq k \leq 5$). Lors d'une opération, vous pouvez faire ce qui suit :

- Choisir un indice $1 \leq i \leq n$,
- Incrémenter $a_i = a_i + 1$.

Trouvez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres dans le tableau $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ divisible par $k$.

Entrée

Chaque test consiste en plusieurs cas de test. La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Suit la description des cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — la taille du tableau $a$ et le nombre $k$.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Il est garanti que la somme de $n$ sur tous les cas de test n'excède pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres dans le tableau divisible par $k$.

Exemple d'entrée 1 :

15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Exemple de sortie 1 :

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

Remarque

Dans le premier cas de test, nous devons choisir l'indice $i = 2$ deux fois. Après cela, le tableau sera $a = [7, 5]$. Le produit de tous les nombres dans le tableau est $35$.

Dans le quatrième cas de test, le produit des nombres dans le tableau est $120$, ce qui est déjà divisible par $5$, donc aucune opération n'est nécessaire.

Dans le huitième cas de test, nous pouvons effectuer deux opérations en choisissant $i = 2$ et $i = 3$ dans n'importe quel ordre. Après cela, le tableau sera $a = [1, 6, 10]$. Le produit des nombres dans le tableau est $60$.

Vous avez un tableau d'entiers $a_1, a_2, \ldots, a_n$ et un nombre $k$ ($2 \leq k \leq 5$). Lors d'une opération, vous pouvez faire ce qui suit :

- Choisir un indice $1 \leq i \leq n$,
- Définir $a_i = a_i + 1$.Trouvez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres dans le tableau $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ divisible par $k$.

Entrée

Chaque test consiste en plusieurs cas de test. La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Suit ensuite la description des cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — la taille du tableau $a$ et le nombre $k$.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Il est garanti que la somme de $n$ sur tous les cas de test n'excède pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres dans le tableau divisible par $k$.Exemple d'entrée 1 :
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Exemple de sortie 1 :

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

Note

Dans le premier cas de test, nous devons choisir l'indice $i = 2$ deux fois. Après cela, le tableau sera $a = [7, 5]$. Le produit de tous les nombres dans le tableau est $35$.

Dans le quatrième cas de test, le produit des nombres dans le tableau est $120$, ce qui est déjà divisible par $5$, donc aucune opération n'est nécessaire.

Dans le huitième cas de test, nous pouvons effectuer deux opérations en choisissant $i = 2$ et $i = 3$ dans n'importe quel ordre. Après cela, le tableau sera $a = [1, 6, 10]$. Le produit des nombres dans le tableau est $60$.

On vous donne un tableau d'entiers $a_1, a_2, \ldots, a_n$ et un nombre $k$ ($2 \leq k \leq 5$). En une seule opération, vous pouvez effectuer les opérations suivantes :

- Choisissez un indice $1 \leq i \leq n$,
- Définissez $a_i = a_i + 1$. Trouvez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres du tableau $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ divisible par $k$.

Entrée

Chaque test se compose de plusieurs cas de test. La première ligne contient un seul entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test. Vient ensuite la description des cas de test.

La première ligne de chaque cas de test contient deux entiers $n$ et $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — la taille du tableau $a$ et le nombre $k$.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre minimum d'opérations nécessaires pour rendre le produit de tous les nombres du tableau divisible par $k$.Exemple d'entrée 1 :
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Exemple de sortie 1 :

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

Note

Dans le premier cas de test, nous devons choisir l'indice $i = 2$ deux fois. Après cela, le tableau sera $a = [7, 5]$. Le produit de tous les nombres du tableau est $35$.

Dans le quatrième cas de test, le produit des nombres du tableau est $120$, ce qui est déjà divisible par $5$, donc aucune opération n'est nécessaire.

Dans le huitième cas de test, nous pouvons effectuer deux opérations en choisissant $i = 2$ et $i = 3$ dans n'importe quel ordre. Après cela, le tableau sera $a = [1, 6, 10]$. Le produit des nombres du tableau est $60$.


Vanya et Vova jouent à un jeu. Les joueurs reçoivent un entier $n$. À leur tour, le joueur peut ajouter $1$ à l'entier actuel ou soustraire $1$. Les joueurs jouent à tour de rôle ; Vanya commence. Si, après le coup de Vanya, l'entier est divisible par $3$, alors il gagne. Si $10$ coups ont passé et que Vanya n'a pas gagné, alors Vova gagne.

Écrivez un programme qui, en fonction de l'entier $n$, détermine qui va gagner si les deux joueurs jouent de manière optimale.

Entrée

La première ligne contient l'entier $t$ ($1 \leq t \leq 100$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient l'entier $n$ ($1 \leq n \leq 1000$).

Sortie

Pour chaque cas de test, affichez "First" sans guillemets si Vanya gagne, et "Second" sans guillemets si Vova gagne.Exemple d'entrée 1 :
6

1

3

5

100

999

1000

Exemple de sortie 1 :

First
Second
First
First
Second
First

Vanya et Vova jouent à un jeu. Les joueurs reçoivent un nombre entier $n$. Quand vient son leur tour, le joueur peut ajouter $1$ ou soustraire $1$ au nombre actuel. Les joueurs jouent à tour de rôle ; Vanya commence. Si, après le tour de Vanya, le nombre entier est divisible par $3$, alors il gagne. Après $10$ coups, si Vanya n'a pas gagné, alors Vova gagne.

Écrivez un programme qui, en fonction du nombre entier $n$, détermine qui va gagner si les deux joueurs jouent de manière optimale.

Entrée

La première ligne contient le nombre entier $t$ ($1 \leq t \leq 100$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient le nombre entier $n$ ($1 \leq n \leq 1000$).

Sortie

Pour chaque cas de test, imprimez « First » sans guillemets si Vanya gagne, et « Second » sans guillemets si Vova gagne.Exemple d'entrée 1 :
6

1

3

5

100

999

1000

Exemple de sortie 1 :

First
Second
First
First
Second
First

Vanya et Vova jouent à un jeu. Les joueurs reçoivent un entier $n$. À leur tour, le joueur peut ajouter $1$ à l'entier actuel ou soustraire $1$. Les joueurs jouent à tour de rôle ; Vanya commence. Si, après le coup de Vanya, l'entier est divisible par $3$, alors il gagne. Si $10$ coups ont passé et que Vanya n'a pas gagné, alors Vova gagne.

Écrivez un programme qui, en fonction de l'entier $n$, détermine qui va gagner si les deux joueurs jouent de manière optimale.

Entrée

La première ligne contient l'entier $t$ ($1 \leq t \leq 100$) — le nombre de cas de test.

La seule ligne de chaque cas de test contient l'entier $n$ ($1 \leq n \leq 1000$).

Sortie

Pour chaque cas de test, imprimez "First" sans guillemets si Vanya gagne, et "Second" sans guillemets si Vova gagne.Exemple d'entrée 1 :
6

1

3

5

100

999

1000

Exemple de sortie 1 :

First
Second
First
First
Second
First


Alex participe au tournage d'une autre vidéo de BrMeast, et BrMeast a demandé à Alex de préparer 250000 tonnes de TNT, mais Alex n'a pas bien entendu, alors il a préparé $n$ caisses et les a disposées en rang en attendant les camions. La $i$-ème caisse depuis la gauche pèse $a_i$ tonnes.

Tous les camions qu'Alex va utiliser contiennent le même nombre de caisses, noté $k$. Le chargement se passe comme suit:

- Les premières $k$ caisses vont dans le premier camion,
- Les deuxièmes $k$ caisses vont dans le deuxième camion,
- $\dotsb$
- Les dernières $k$ caisses vont dans le $\frac{n}{k}$-ième camion. Une fois le chargement terminé, chaque camion doit avoir exactement $k$ caisses. En d'autres termes, si à un moment donné il n'est pas possible de charger exactement $k$ caisses dans le camion, alors l'option de chargement avec ce $k$ n'est pas possible.

Alex déteste la justice, donc il veut que la différence absolue maximale entre les poids totaux de deux camions soit aussi grande que possible. S'il n'y a qu'un seul camion, cette valeur est $0$.

Alex a pas mal de contacts, donc pour chaque $1 \leq k \leq n$, il peut trouver une entreprise telle que chacun de ses camions puisse contenir exactement $k$ caisses. Affichez la différence absolue maximale entre les poids totaux de deux camions.

Entrée

La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 150\,000$) — le nombre de caisses.

La deuxième ligne contient $n$ entiers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — les poids des caisses.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $150\,000$.

Sortie

Pour chaque cas de test, affichez un seul entier — la réponse au problème.Échantillon d'entrée 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

Échantillon de sortie 1:

1
9
0
189114
112141

Note

Dans le premier cas, nous devons choisir deux camions, donc le premier n'aura que la première caisse, et le deuxième n'aura que la deuxième caisse.

Dans le deuxième cas, nous devons choisir six camions, donc le maximum sera $10$, le minimum sera $1$, et la réponse est $10 - 1 = 9$.

Dans le troisième cas, pour n'importe quel $k$ possible, les camions auront le même poids total de caisses, donc la réponse est $0$.

Alex participe au tournage d'une autre vidéo de BrMeast, et BrMeast a demandé à Alex de préparer 250 mille tonnes de TNT, mais Alex ne l'a pas bien entendu, alors il a préparé $n$ boîtes et les a disposées en rangée en attendant les camions. La $i$-ième boîte à partir de la gauche pèse $a_i$ tonnes.

Tous les camions qu'Alex va utiliser contiennent le même nombre de boîtes, noté $k$. Le chargement se déroule de la manière suivante :

- Les $k$ premières boîtes vont au premier camion,
- Les $k$ secondes boîtes vont au deuxième camion,
- $\dotsb$
- Les $k$ dernières boîtes vont au $\frac{n}{k}$-ième camion. Une fois le chargement terminé, chaque camion doit avoir exactement $k$ boîtes. En d'autres termes, si à un moment donné il n'est pas possible de charger exactement $k$ boîtes dans le camion, alors l'option de chargement avec ce $k$ n'est pas possible.

Alex déteste la justice, il veut donc que la différence absolue maximale entre les poids totaux de deux camions soit la plus grande possible. S'il n'y a qu'un seul camion, cette valeur est $0$.

Alex a beaucoup de relations, donc pour chaque $1 \leq k \leq n$, il peut trouver une entreprise telle que chacun de ses camions puisse contenir exactement $k$ boîtes. Affichez la différence absolue maximale entre les poids totaux de deux camions quelconques.

Entrée

La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 150\,000$) — le nombre de boîtes.

La deuxième ligne contient $n$ entiers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — les poids des boîtes.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $150\,000$.

Sortie

Pour chaque cas de test, imprimez un seul entier — la réponse au problème.Exemple d'entrée 1 :
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60 978 82 265 78 961 56 708 39 846 31 071 4 913 4 769 29 092 91 348 64 119 72 421 98 405 222 14 294

8

19 957 69 913 37 531 96 991 57 838 21 008 14 207 19198

Exemple de sortie 1 :

1
9
0
189114
112141

Note

Dans le premier cas, nous devons choisir deux camions, donc le premier n'aura que la première boîte et le deuxième n'aura que la deuxième boîte.

Dans le deuxième cas, nous devons choisir six camions, donc le maximum sera de 10 $, le minimum sera de 1 $ et la réponse sera 10 - 1 = 9 $.

Dans le troisième cas, pour tout $k$ possible, les camions auront le même poids total de boîtes, donc la réponse est 0 $.

Alex participe au tournage d'une autre vidéo de BrMeast, et BrMeast a demandé à Alex de préparer 250 mille tonnes de TNT, mais Alex ne l'a pas bien entendu, alors il a préparé $n$ caisses et les a disposées en rang en attendant les camions. La $i$-ème caisse depuis la gauche pèse $a_i$ tonnes.

Tous les camions qu'Alex va utiliser contiennent le même nombre de caisses, noté par $k$. Le chargement se passe comme suit :

- Les premières $k$ caisses vont dans le premier camion,
- Les deuxièmes $k$ caisses vont dans le deuxième camion,
- $\dotsb$
- Les dernières $k$ caisses vont dans le $\frac{n}{k}$-ième camion. Une fois le chargement terminé, chaque camion doit avoir exactement $k$ caisses. En d'autres termes, si à un moment donné il n'est pas possible de charger exactement $k$ caisses dans le camion, alors l'option de chargement avec ce $k$ n'est pas possible.

Alex déteste la justice, donc il veut que la différence absolue maximale entre les poids totaux de deux camions soit aussi grande que possible. S'il n'y a qu'un seul camion, cette valeur est $0$.

Alex a pas mal de contacts, donc pour chaque $1 \leq k \leq n$, il peut trouver une entreprise telle que chacun de ses camions puisse contenir exactement $k$ caisses. Imprimez la différence absolue maximale entre les poids totaux de deux camions.

Entrée

La première ligne contient un entier $t$ ($1 \leq t \leq 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 150\,000$) — le nombre de caisses.

La deuxième ligne contient $n$ entiers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — les poids des caisses.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $150\,000$.

Sortie

Pour chaque cas de test, imprimez un seul entier — la réponse au problème.Échantillon d'entrée 1 :
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

Échantillon de sortie 1 :

1
9
0
189114
112141

Note

Dans le premier cas, nous devons choisir deux camions, donc le premier n'aura que la première caisse, et le deuxième n'aura que la deuxième caisse.

Dans le deuxième cas, nous devons choisir six camions, donc le maximum sera $10$, le minimum sera $1$, et la réponse est $10 - 1 = 9$.

Dans le troisième cas, pour n'importe quel $k$ possible, les camions auront le même poids total de caisses, donc la réponse est $0$.


Un sous-tableau est une partie continue d'un tableau.

Yarik a récemment trouvé un tableau $a$ de $n$ éléments et s'est beaucoup intéressé à trouver la somme maximale d'un sous-tableau non vide. Cependant, Yarik n'aime pas les entiers consécutifs ayant la même parité, donc le sous-tableau qu'il choisit doit avoir des parités alternées pour les éléments adjacents.

Par exemple, $[1, 2, 3]$ est acceptable, mais $[1, 2, 4]$ ne l'est pas, car $2$ et $4$ sont tous deux pairs et adjacents.

Vous devez aider Yarik à trouver la somme maximale d'un tel sous-tableau.

Entrée

La première ligne contient un entier $t$ $(1 \le t \le 10^4)$ — le nombre de cas de test. Chaque cas de test est décrit comme suit.

La première ligne de chaque cas de test contient un entier $n$ $(1 \le n \le 2 \cdot 10^5)$ — la longueur du tableau.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — éléments du tableau.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez un seul entier — la réponse au problème.

Exemple d'entrée 1 :
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

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

Exemple de sortie 1 :

15
17
8
4
-1000
101
10

Un sous-tableau est une partie continue d'un tableau.

Yarik a récemment trouvé un tableau $a$ de $n$ éléments et s'est beaucoup intéressé à trouver la somme maximale d'un sous-tableau non vide. Cependant, Yarik n'aime pas les entiers consécutifs ayant la même parité, donc le sous-tableau qu'il choisit doit avoir des parités alternées pour les éléments adjacents.

Par exemple, $[1, 2, 3]$ est acceptable, mais $[1, 2, 4]$ ne l'est pas, car $2$ et $4$ sont tous deux pairs et adjacents.

Vous devez aider Yarik à trouver la somme maximale d'un tel sous-tableau.

Entrée

La première ligne contient un entier $t$ $(1 \le t \le 10^4)$ — le nombre de cas de test. Chaque cas de test est décrit comme suit.

La première ligne de chaque cas de test contient un entier $n$ $(1 \le n \le 2 \cdot 10^5)$ — la longueur du tableau.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — les éléments du tableau.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez un seul entier — la réponse au problème.Exemple d'entrée 1 :
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

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

Exemple de sortie 1 :

15
17
8
4
-1000
101
10

Un sous-tableau est une partie continue d'un tableau.

Yarik a récemment trouvé un tableau $a$ de $n$ éléments et s'est intéressé à la recherche de la somme maximale d'un sous-tableau non vide. Cependant, Yarik n'aime pas les entiers consécutifs avec la même parité, donc le sous-tableau qu'il choisit doit avoir des parités alternées pour les éléments adjacents.

Par exemple, $[1, 2, 3]$ est acceptable, mais $[1, 2, 4]$ ne l'est pas, car $2$ et $4$ sont tous deux pairs et adjacents.

Vous devez aider Yarik en trouvant la somme maximale d'un tel sous-tableau.

Entrée

La première ligne contient un entier $t$ $(1 \le t \le 10^4)$ — nombre de cas de test. Chaque cas de test est décrit comme suit.

La première ligne de chaque cas de test contient un entier $n$ $(1 \le n \le 2 \cdot 10^5)$ — longueur du tableau.

La deuxième ligne de chaque cas de test contient $n$ entiers $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — éléments du tableau.

Il est garanti que la somme de $n$ pour tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, générez un seul entier — la réponse au problème.Exemple d'entrée 1 :
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

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

Exemple de sortie 1 :

15
17
8
4
-1000
101
10


Yarik est un grand fan de nombreux types de musique. Mais Yarik aime non seulement écouter de la musique, mais aussi l’écrire. Il aime par-dessus tout la musique électronique, c’est pourquoi il a créé son propre système de notes de musique, qui, selon lui, est le meilleur pour lui.

Comme Yarik aime aussi l’informatique, dans son système, les notes sont désignées par des entiers de $2^k$, où $k \ge 1$ — un entier positif. Mais, comme vous le savez, vous ne pouvez pas utiliser uniquement des notes pour écrire de la musique, donc Yarik utilise des combinaisons de deux notes. La combinaison de deux notes $(a, b)$, où $a = 2^k$ et $b = 2^l$, il la désigne par l’entier $a^b$.

Par exemple, si $a = 8 = 2^3$, $b = 4 = 2^2$, alors la combinaison $(a, b)$ est notée par l’entier $a^b = 8^4 = 4096$. Notez que différentes combinaisons peuvent avoir la même notation, par exemple, la combinaison $(64, 2)$ est également désignée par l’entier $4096 = 64^2$.

Yarik a déjà choisi des notes de $n$ qu’il veut utiliser dans sa nouvelle mélodie. Cependant, comme leurs entiers peuvent être très grands, il les a notés sous la forme d’un tableau $a$ de longueur $n$, alors la note $i$ est $b_i = 2^{a_i}$. Les entiers du tableau $a$ peuvent être répétés.

La mélodie sera composée de plusieurs combinaisons de deux notes. Yarik se demandait combien de paires de billets $b_i, b_j$ $(i < j)$ existent de telle sorte que la combinaison $(b_i, b_j)$ soit égale à la combinaison $(b_j, b_i)$. En d’autres termes, il veut compter le nombre de paires $(i, j)$ $(i < j)$ tel que $b_i^{b_j} = b_j^{b_i}$. Aidez-le à trouver le nombre de ces paires.

Entrée

La première ligne de l’entrée contient un entier $t$ ($1 \le t \le 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 2 \cdot 10^5$) — la longueur des tableaux.

La ligne suivante contient les entiers $n$ $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — tableau $a$.

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre de paires qui satisfont à la condition donnée. Exemple d’entrée 1 :
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

Exemple de sortie 1 :

0
2
1
3
19

Yarik est un grand amateur de plusieurs genres de musique. Mais Yarik aime non seulement écouter de la musique, mais aussi en écrire. Il préfère la musique électronique par-dessus tout, il a donc créé son propre système de notes de musique, qui, selon lui, est le meilleur pour cela.

Étant donné que Yarik aime également l'informatique, dans son système, les notes sont désignées par des entiers de $2^k$, où $k \ge 1$ — un entier positif. Mais, comme vous le savez, vous ne pouvez pas utiliser uniquement des notes pour écrire de la musique, donc Yarik utilise des combinaisons de deux notes. La combinaison de deux notes $(a, b)$, où $a = 2^k$ et $b = 2^l$, il note cela par l'entier $a^b$.

Par exemple, si $a = 8 = 2^3$, $b = 4 = 2^2$, alors la combinaison $(a, b)$ est notée par l'entier $a^b = 8^4 = 4096$. Notez que différentes combinaisons peuvent avoir la même notation, par exemple, la combinaison $(64, 2)$ est également notée par l'entier $4096 = 64^2$.

Yarik a déjà choisi $n$ notes qu'il veut utiliser dans sa nouvelle mélodie. Cependant, comme leurs entiers peuvent être très grands, il les a écrits dans un tableau $a$ de longueur $n$, alors la note $i$ est $b_i = 2^{a_i}$. Les entiers dans le tableau $a$ peuvent être répétés.

La mélodie consistera en plusieurs combinaisons de deux notes. Yarik se demande combien de paires de notes $b_i, b_j$ $(i < j)$ existent telles que la combinaison $(b_i, b_j)$ soit égale à la combinaison $(b_j, b_i)$. En d'autres termes, il veut compter le nombre de paires $(i, j)$ $(i < j)$ telles que $b_i^{b_j} = b_j^{b_i}$. Aidez-le à trouver le nombre de telles paires.

Entrée

La première ligne de l'entrée contient un entier $t$ ($1 \le t \le 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 2 \cdot 10^5$) — la longueur des tableaux.

La ligne suivante contient $n$ entiers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — le tableau $a$.

Il est garanti que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre de paires qui satisfont la condition donnée.Exemple d'entrée 1 :
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

Exemple de sortie 1 :

0
2
1
3
19

Yarik est un grand amateur de nombreux genres de musique. Mais Yarik aime non seulement écouter de la musique, mais aussi en écrire. La musique électronique est ce qu'il préfère par-dessus tout, il a donc créé son propre système de notes de musique, qui, selon lui, est le meilleur pour cela.

Étant donné que Yarik aime également l'informatique, dans son système, les notes sont représentées par des entiers de $2^k$, avec $k \ge 1$ — un entier positif. Mais, comme vous le savez, on ne peut pas utiliser uniquement des notes pour écrire de la musique, donc Yarik utilise des combinaisons de deux notes. La combinaison de deux notes $(a, b)$, où $a = 2^k$ et $b = 2^l$, est représentée par l'entier $a^b$.

Par exemple, si $a = 8 = 2^3$, $b = 4 = 2^2$, alors la combinaison $(a, b)$ est notée par l'entier $a^b = 8^4 = 4096$. Notez que différentes combinaisons peuvent avoir la même notation, par exemple, la combinaison $(64, 2)$ est également représentée par l'entier $4096 = 64^2$.

Yarik a déjà choisi $n$ notes qu'il veut utiliser dans sa nouvelle mélodie. Cependant, comme leurs entiers peuvent être très grands, il a écrits ceux-ci dans un tableau $a$ de longueur $n$, où la note $i$ est $b_i = 2^{a_i}$. Les entiers dans le tableau $a$ peuvent être répétés.

La mélodie consistera en plusieurs combinaisons de deux notes. Yarik se demande combien de paires de notes $b_i, b_j$ $(i < j)$ existent telles que la combinaison $(b_i, b_j)$ soit égale à la combinaison $(b_j, b_i)$. En d'autres termes, il veut compter le nombre de paires $(i, j)$ $(i < j)$ telles que $b_i^{b_j} = b_j^{b_i}$. Aidez-le à trouver le nombre de telles paires.

Entrée

La première ligne de l'entrée contient un entier $t$ ($1 \le t \le 10^4$) — le nombre de cas de test.

La première ligne de chaque cas de test contient un entier $n$ ($1 \leq n \leq 2 \cdot 10^5$) — la longueur des tableaux.

La ligne suivante contient $n$ entiers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — le tableau $a$.

On garantit que la somme de $n$ sur tous les cas de test ne dépasse pas $2 \cdot 10^5$.

Sortie

Pour chaque cas de test, affichez le nombre de paires qui satisfont la condition donnée.Exemple d'entrée 1 :
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

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

Exemple de sortie 1 :

0
2
1
3
19


Vous avez un tableau details indexé à 0 de chaînes de caractères. Chaque élément de details fournit des informations sur un passager donné compressées en une chaîne de longueur 15. Le système est tel que :

Les dix premiers caractères consistent en le numéro de téléphone des passagers.
Le caractère suivant indique le genre de la personne.
Les deux caractères suivants sont utilisés pour indiquer l'âge de la personne.
Les deux derniers caractères déterminent le siège attribué à cette personne.

Retournez le nombre de passagers qui ont strictement plus de 60 ans.

Example 1 :

Entrée : details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Sortie : 2
Explication: Les passagers aux indices 0, 1 et 2 ont des âges de 75, 92 et 40. Ainsi, il y a 2 personnes qui ont plus de 60 ans.

Example 2 :

Entrée : details = ["1313579440F2036","2921522980M5644"]
Sortie : 0
Explication: Aucun des passagers n'a plus de 60 ans.

Contraintes :

1 <= details.length <= 100
details[i].length == 15
details[i] consiste en des chiffres de '0' à '9'.
details[i][10] est soit 'M', 'F' ou 'O'.
Les numéros de téléphone et les numéros de siège des passagers sont distincts.

Vous avez un tableau à indices 0 de chaînes de caractères details. Chaque élément de details fournit des informations sur un passager donné compressées en une chaîne de longueur 15. Le système est tel que :

Les dix premiers caractères consistent en le numéro de téléphone des passagers.
Le caractère suivant indique le genre de la personne.
Les deux caractères suivants sont utilisés pour indiquer l'âge de la personne.
Les deux derniers caractères déterminent le siège attribué à cette personne.

Retournez le nombre de passagers qui ont strictement plus de 60 ans.

Example 1 :

Input: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Output: 2
Explication: Les passagers aux indices 0, 1 et 2 ont des âges de 75, 92 et 40. Ainsi, il y a 2 personnes qui ont plus de 60 ans.

Example 2 :

Input: details = ["1313579440F2036","2921522980M5644"]
Output: 0
Explication: Aucun des passagers n'a plus de 60 ans.

Contraintes :

1 <= details.length <= 100
details[i].length == 15
details[i] consiste en des chiffres de '0' à '9'.
details[i][10] est soit 'M', 'F' ou 'O'.
Les numéros de téléphone et les numéros de siège des passagers sont distincts.

On vous donne un tableau 0-indexé de détails de chaînes. Chaque élément de détails fournit des informations sur un passager donné comprimé dans une chaîne de longueur 15. Le système est tel que:

Les dix premiers caractères sont composés du numéro de téléphone des passagers.
Le personnage suivant désigne le sexe de la personne.
Les deux caractères suivants sont utilisés pour indiquer l'âge de la personne.
Les deux derniers personnages déterminent le siège attribué à cette personne.

Renvoyez le nombre de passagers qui ont strictement plus de 60 ans.

Exemple 1:

Entrée: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Sortie: 2
Explication: Les passagers des indices 0, 1 et 2 ont 75, 92 et 40 ans. Ainsi, il y a 2 personnes qui ont plus de 60 ans.

Exemple 2:

Entrée: details = ["1313579440F2036","2921522980M5644"]
Sortie: 0
Explication: Aucun des passagers n'a plus de 60 ans.

Contraintes:

1 <= details.length <= 100
details[i].length == 15
Les détails [i] se compose de chiffres de '0' à '9'.
Les détails [i] [10] sont 'M', 'F' ou 'O'.
Les numéros de téléphone et les numéros de siège des passagers sont distincts.


Vous disposez d'un tableau 2D d’entiers indexé à partir de 0, nums. Initialement, votre score est de 0. Effectuez les opérations suivantes jusqu’à ce que la matrice soit vide :

Dans chaque ligne de la matrice, sélectionnez le plus grand nombre et supprimez-le. Dans le cas d’une égalité, le numéro choisi n’a pas d’importance.
Identifiez le plus grand nombre parmi tous ceux supprimés à l'étape 1. Ajoutez ce nombre à votre score.

Retournez le score final.

Exemple 1 :

Entrée : nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Sortie : 15
Explication : Dans la première opération, nous enlevons 7, 6, 6 et 3, puis nous ajoutons 7 à notre score. Ensuite, nous enlevons 2, 4, 5 et 2. Nous ajoutons 5 à notre score. Enfin, nous supprimons 1, 2, 3 et 1. Nous ajoutons 3 à notre score. Ainsi, notre score final est de 7 + 5 + 3 = 15.

Exemple 2 :

Entrée : nums = [[1]]
Sortie : 1
Explication : Nous supprimons 1 et l’ajoutons à la réponse. Nous retournons 1.

Contraintes:

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3

Vous disposez d'un tableau 2D d'entiers indexé à partir de 0, nums. Initialement, votre score est de 0. Effectuez les opérations suivantes jusqu'à ce que la matrice devienne vide :

Dans chaque ligne de la matrice, sélectionnez le plus grand nombre et supprimez-le. En cas d'égalité, n'importe quel nombre peut être choisi.
Identifiez le plus grand nombre parmi tous ceux supprimés à l'étape 1. Ajoutez ce nombre à votre score.

Retournez le score final.

Exemple 1 :

Entrée : nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Sortie : 15
Explication : Lors de la première opération, nous supprimons 7, 6, 6, et 3. Nous ajoutons ensuite 7 à notre score. Ensuite, nous supprimons 2, 4, 5, et 2. Nous ajoutons 5 à notre score. Enfin, nous supprimons 1, 2, 3, et 1. Nous ajoutons 3 à notre score. Ainsi, notre score final est 7 + 5 + 3 = 15.

Exemple 2 :

Entrée : nums = [[1]]
Sortie : 1
Explication : Nous supprimons 1 et l'ajoutons au score. Nous retournons 1.

Contraintes :

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3

Vous disposez d'un tableau 2D d'entiers indexé à partir de 0, nommé nums. Initialement, votre score est de 0. Effectuez les opérations suivantes jusqu'à ce que la matrice devienne vide :

Dans chaque ligne de la matrice, sélectionnez le plus grand nombre et supprimez-le. En cas d'égalité, n'importe quel nombre peut être choisi.
Identifiez le plus grand nombre parmi tous ceux supprimés à l'étape 1. Ajoutez ce nombre à votre score.

Renvoyez le score final.

Exemple 1 :

Entrée : nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Sortie : 15
Explication : Lors de la première opération, nous supprimons 7, 6, 6, et 3. Nous ajoutons ensuite 7 à notre score. Ensuite, nous supprimons 2, 4, 5, et 2. Nous ajoutons 5 à notre score. Enfin, nous supprimons 1, 2, 3, et 1. Nous ajoutons 3 à notre score. Ainsi, notre score final est 7 + 5 + 3 = 15.

Exemple 2 :

Entrée : nums = [[1]]
Sortie : 1
Explication : Nous supprimons 1 et l'ajoutons au score. Nous renvoyons 1.

Contraintes :

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3


On vous donne un tableau d'entiers nums indexé à partir de 0 de longueur n et un entier k. Lors d'une opération, vous pouvez choisir un élément et le multiplier par 2.
Retournez la valeur maximale possible de nums[0] | nums[1] | ... | nums[n - 1] pouvant être obtenue après avoir appliqué l'opération sur nums au maximum k fois.
Notez que a | b désigne l'opérateur ou binaire entre deux entiers a et b.

Exemple 1 :

Entrée : nums = [12,9], k = 1
Sortie : 30
Explication : Si nous appliquons l'opération à l'indice 1, notre nouveau tableau nums sera égal à [12,18]. Ainsi, nous retournons l'opération ou binaire entre 12 et 18, qui donne 30.

Exemple 2 :

Entrée : nums = [8,1,2], k = 2
Sortie : 35
Explication : Si nous appliquons l'opération deux fois sur l'indice 0, nous obtenons un nouveau tableau de [32,1,2]. Ainsi, nous retournons 32|1|2 = 35.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à 0 de longueur n et un entier k. Lors d'une opération, vous pouvez choisir un élément et le multiplier par 2.
Retournez la valeur maximale possible de nums[0] | nums[1] | ... | nums[n - 1] qui peut être obtenue après avoir appliqué l'opération sur nums au plus k fois.
Notez que a | b désigne l'opérateur ou binaire entre deux entiers a et b.

Exemple 1 :

Entrée : nums = [12,9], k = 1
Sortie : 30
Explication : Si nous appliquons l'opération à l'index 1, notre nouveau tableau nums sera égal à [12,18]. Ainsi, nous renvoyons l'opérateur ou binaire de 12 et 18, qui est 30.

Exemple 2 :

Entrée : nums = [8,1,2], k = 2
Sortie : 35
Explication : Si nous appliquons l'opération deux fois sur l'index 0, nous obtenons un nouveau tableau de [32,1,2]. Ainsi, nous renvoyons 32|1|2 = 35.

Contraintes :

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

On vous donne un tableau d'entiers indexés 0 nums de longueur n et un entier k. Dans une opération, vous pouvez choisir un élément et le multiplier par 2.
Retournez la valeur maximale possible de nums[0] | nums[1] | ... | nums[n - 1] qui peut être obtenue après avoir appliqué l'opération sur nums au plus k fois.
Notez que a | b dénote le bitwise or entre deux entiers a et b.

Exemple 1 :

Entrée : nums = [12,9], k = 1
Sortie : 30
Explication : Si nous appliquons l'opération à l'index 1, notre nouveau tableau nums sera égal à [12,18]. Ainsi, nous retournons le bitwise or de 12 et 18, qui est 30.

Exemple 2 :

Entrée : nums = [8,1,2], k = 2
Sortie : 35
Explication : Si nous appliquons l'opération deux fois sur l'index 0, nous obtenons un nouveau tableau de [32,1,2]. Nous obtenons donc 32|1|2 = 35.

Contraintes :

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


On vous donne un tableau d'entiers nums indexé à partir de 0 représentant le score des étudiants à un examen. Le professeur souhaite former un groupe non vide d'étudiants avec une force maximale, où la force d'un groupe d'étudiants d'indices i_0, i_1, i_2, ..., i_k est définie comme nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Renvoyez la force maximale d'un groupe que le professeur peut créer.

Exemple 1 :

Entrée : nums = [3,-1,-5,2,5,-9]
Sortie : 1350
Explication : Une façon de former un groupe de force maximale est de regrouper les étudiants aux indices [0,2,3,4,5]. Leur force est 3 * (-5) * 2 * 5 * (-9) = 1350, ce qui est optimal.

Exemple 2 :

Entrée : nums = [-4,-5,-4]
Sortie : 20
Explication : Grouper les étudiants aux indices [0, 1]. On obtient alors une force de 20. On ne peut pas atteindre une force plus grande.

Contraintes :

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Vous disposez d'un tableau d'entiers nums indexé à partir de 0 représentant le score des étudiants à un examen. Le professeur souhaite former un groupe non vide d'étudiants avec une force maximale, où la force d'un groupe d'étudiants d'indices i_0, i_1, i_2, ..., i_k est définie comme nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Retournez la force maximale d'un groupe que le professeur peut créer.

Exemple 1 :

Entrée : nums = [3,-1,-5,2,5,-9]
Sortie : 1350
Explication : Une façon de former un groupe de force maximale est de regrouper les étudiants aux indices [0,2,3,4,5]. Leur force est 3 * (-5) * 2 * 5 * (-9) = 1350, ce qui est optimal.

Exemple 2 :

Entrée : nums = [-4,-5,-4]
Sortie : 20
Explication : Grouper les étudiants aux indices [0, 1]. On obtient alors une force de 20. On ne peut pas atteindre une force plus grande.

Contraintes :

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Vous recevez un tableau d’entiers indexé 0 : nums, représentant le score des étudiants à un examen. L’enseignant aimerait former un groupe non vide d’élèves avec une force maximale, où la force d’un groupe d’élèves d’indices i_0, i_1, i_2, ... , i_k est définie comme nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Retournez la force maximale d’un groupe que l’enseignant peut créer.

Exemple 1 :

Entrée : nums = [3,-1,-5,2,5,-9]
Sortie : 1350
Explication : Une façon de former un groupe de force maximale est de regrouper les élèves aux indices [0,2,3,4,5]. Leur force est de 3 * (-5) * 2 * 5 * (-9) = 1350, ce que nous pouvons montrer comme optimal.

Exemple 2 :

Entrée : nums = [-4,-5,-4]
Sortie : 20
Explication : Regroupez les élèves aux indices [0, 1] . Ensuite, nous aurons une force résultante de 20. Nous ne pouvons pas obtenir une plus grande force.

Contraintes:

1 <= nums.length <= 13
-9 <= nums[i] <= 9


On vous donne une chaîne de caractères s indexée à partir de 0 et un dictionnaire de mots dictionary. Vous devez découper s en une ou plusieurs sous-chaînes non chevauchantes de sorte que chaque sous-chaîne soit présente dans le dictionnaire. Il se peut qu'il y ait des caractères supplémentaires dans s qui ne sont présents dans aucune des sous-chaînes.
Retournez le nombre minimum de caractères supplémentaires restants si vous découpez s de manière optimale.

Exemple 1 :

Entrée: s = "leetscode", dictionary = ["leet","code","leetcode"]
Sortie: 1
Explication : Nous pouvons découper s en deux sous-chaînes : "leet" de l'index 0 à 3 et "code" de l'index 5 à 8. Il n'y a qu'un seul caractère inutilisé (à l'index 4), donc nous retournons 1.

Exemple 2 :

Input: s = "sayhelloworld", dictionary = ["hello","world"]
Output: 3
Explication : Nous pouvons découper s en deux sous-chaînes : "hello" de l'index 3 à 7 et "world" de l'index 8 à 12. Les caractères aux indices 0, 1, 2 ne sont utilisés dans aucune sous-chaîne et sont donc considérés comme des caractères supplémentaires. Par conséquent, nous retournons 3.

Contraintes :

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
`dictionary[i]` et `s` sont composés uniquement de lettres minuscules anglaises
`dictionary` contient des mots distincts

Il vous est donné une chaîne de caractères s indexée à partir de 0 et un dictionnaire de mots dictionary. Vous devez découper s en une ou plusieurs sous-chaînes non chevauchantes de sorte que chaque sous-chaîne soit présente dans le dictionnaire. Il se peut qu'il y ait des caractères supplémentaires dans s qui ne sont présents dans aucune des sous-chaînes. Retournez le nombre minimum de caractères supplémentaires restants si vous découpez s de manière optimale.

Exemple 1 :

Input : s = "leetscode", dictionary = ["leet","code","leetcode"]
Output : 1
Explication : nous pouvons découper s en deux sous-chaînes : "leet" de l'index 0 à 3 et "code" de l'index 5 à 8. Il n'y a qu'un seul caractère inutilisé (à l'index 4), donc nous retournons 1.

Exemple 2 :

Input : s = "sayhelloworld", dictionary = ["hello","world"]
Output : 3
Explication : nous pouvons découper s en deux sous-chaînes : "hello" de l'index 3 à 7 et "world" de l'index 8 à 12. Les caractères aux indices 0, 1, 2 ne sont utilisés dans aucune sous-chaîne et sont donc considérés comme des caractères supplémentaires. Par conséquent, nous retournons 3.

Contraintes :

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] et s sont composés uniquement de lettres minuscules anglaises
dictionary contient des mots distincts

On vous donne une chaîne indexée 0 et un dictionnaire dictionnaire of Words. Vous devez diviser s en une ou plusieurs sous-chaînes non chevauchantes de sorte que chaque sous-chaîne est présente dans le dictionnaire. Il peut y avoir des caractères supplémentaires en s qui ne sont présents dans aucune sous-chaîne.
Renvoyez le nombre minimum de caractères supplémentaires restants si vous cassez s de manière optimale.

Exemple 1:

Entrée: s = "leetscode", dictionary = ["leet", "code", "leetcode"]
Sortie: 1
Explication: Nous pouvons casser s en deux sous-chaînes: "Leet" de l'index 0 à 3 et "code" de l'index 5 à 8. Il n'y a qu'un seul caractère inutilisé (à l'index 4), nous retournons donc 1.

Exemple 2:

Entrée: s = "sayhelloworld", dictionary = ["hello","world"]
Sortie: 3
Explication: Nous pouvons briser s en deux sous-chaînes: "hello" de l'index 3 à 7 et "Monde" de l'index 8 à 12. Les caractères des indices 0, 1, 2 ne sont utilisés dans aucune sous-chaîne et sont donc considérés comme des caractères supplémentaires . Par conséquent, nous retournons 3.

Contraintes:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
Le dictionary[i] et s se compose uniquement de lettres d'anglais minuscules
Le dictionnaire contient des mots distincts


Vous avez un tableau d'entiers `prices` représentant les prix de divers chocolats dans un magasin. Vous disposez aussi d'un entier `money`, qui représente votre montant initial d'argent.
Vous devez acheter exactement deux chocolats de telle manière qu'il vous reste encore de l'argent non négatif. Vous souhaitez minimiser la somme des prix des deux chocolats que vous achetez.
Retournez le montant d'argent qu'il vous restera après avoir acheté les deux chocolats. S'il n'y a aucun moyen pour vous d'acheter deux chocolats sans finir endetté, retournez `money`. Notez que le reste doit être non négatif.

Exemple 1 :

Input: prices = [1,2,2], money = 3
Output: 0
Explication: Achetez les chocolats aux prix de 1 et 2 unités respectivement. Il vous restera 3 - 3 = 0 unités d'argent par la suite. Ainsi, nous retournons 0.

Exemple 2 :

Input: prices = [3,2,3], money = 3
Output: 3
Explication: Vous ne pouvez pas acheter 2 chocolats sans vous endetter, donc nous retournons 3.

Contraintes :

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100

Vous avez un tableau d'entiers `prices` représentant les prix de divers chocolats dans un magasin. Vous disposez aussi d'un entier `money`, qui représente votre montant initial d'argent.
Vous devez acheter exactement deux chocolats de telle manière qu'il vous reste encore de l'argent non négatif. Vous souhaitez minimiser la somme des prix des deux chocolats que vous achetez.
Retournez le montant d'argent qu'il vous restera après avoir acheté les deux chocolats. S'il n'y a aucun moyen pour vous d'acheter deux chocolats sans finir endetté, retournez money. Notez que le reste doit être non négatif.

Exemple 1 :

Input: prices = [1,2,2], money = 3
Output: 0
Explication: Achetez les chocolats aux prix de 1 et 2 unités respectivement. Il vous restera 3 - 3 = 0 unités d'argent par la suite. Ainsi, nous retournons 0.

Exemple 2 :

Input: prices = [3,2,3], money = 3
Output: 3
Explication: Vous ne pouvez pas acheter 2 chocolats sans vous endetter, donc nous retournons 3.

Contraintes :

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100

On vous donne un tableau entier de prix représentant les prix des différents chocolats dans un magasin. Vous recevez également une seule somme d’argent entière, qui représente votre somme d’argent initiale.
Vous devez acheter exactement deux chocolats de manière à ce qu’il vous reste encore de l’argent non négatif. Vous souhaitez minimiser la somme des prix des deux chocolats que vous achetez.
Retournez le montant d’argent qu’il vous restera après avoir acheté les deux chocolats. S’il n’y a aucun moyen pour vous d’acheter deux chocolats sans vous endetter, rendez-vous de l’argent. Notez que le reste doit être non négatif.

Exemple 1 :

Intrants : prices = [1,2,2], money = 3
Sortie : 0
Explication : Achetez les chocolats au prix de 1 et 2 unités respectivement. Vous aurez 3 - 3 = 0 unités d’argent par la suite. Ainsi, nous retournons 0.

Exemple 2 :

Intrants : prices = [3,2,3], money = 3
Sortie : 3
Explication : Vous ne pouvez pas acheter 2 chocolats sans vous endetter, nous en rendons donc 3.

Contraintes:

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100


On vous donne deux chaînes numériques num1 et num2 et deux entiers max_sum et min_sum. Nous définissons un entier x comme bon si :

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Renvoyez le nombre d'entiers bons. Comme la réponse peut être grande, renvoyez-la modulo 10^9 + 7.
Notez que digit_sum(x) désigne la somme des chiffres de x.

Exemple 1 :

Entrée : num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Sortie : 11
Explication : Il y a 11 entiers dont la somme des chiffres est comprise entre 1 et 8, à savoir 1,2,3,4,5,6,7,8,10,11, et 12. Ainsi, nous renvoyons 11.

Exemple 2 :

Entrée : num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Sortie : 5
Explication : Les 5 entiers dont la somme des chiffres est comprise entre 1 et 5 sont 1,2,3,4, et 5. Ainsi, nous renvoyons 5.

Contraintes :

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

On vous donne deux chaînes numériques num1 et num2 et deux entiers max_sum et min_sum. On désigne un entier x comme étant bon si :

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Renvoie le nombre d'entiers bons. Étant donné que la réponse peut être grande, renvoyez-la modulo 10^9 + 7.
Notez que digit_sum(x) désigne la somme des chiffres de x.

Exemple 1 :

Entrée : num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Sortie : 11
Explication : Il y a 11 entiers dont la somme des chiffres se situe entre 1 et 8 : 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 et 12. Ainsi, nous renvoyons 11.

Exemple 2 :

Entrée : num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Sortie : 5
Explication : Les 5 entiers dont la somme des chiffres se situe entre 1 et 5 sont 1, 2, 3, 4 et 5. Ainsi, nous renvoyons 5.

Contraintes :

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

On donne deux chaînes numériques num1 et num2 et deux entiers max_sum et min_sum. Nous définissons un entier x comme bon si :

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Retournez le nombre d'entiers bons. Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.
Notez que digit_sum(x) désigne la somme des chiffres de x.

Exemple 1 :

Entrée : num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Sortie : 11
Explication : Il y a 11 entiers dont la somme des chiffres est comprise entre 1 et 8, à savoir 1,2,3,4,5,6,7,8,10,11, et 12. Ainsi, nous retournons 11.

Exemple 2 :

Entrée : num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Sortie : 5
Explication : Les 5 entiers dont la somme des chiffres est comprise entre 1 et 5 sont 1,2,3,4, et 5. Ainsi, nous retournons 5.

Contraintes :

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400


On considère un tableau indexé à partir de 0, nums, de longueur n.
Le tableau de différences distinctes de nums est un tableau diff de longueur n tel que diff[i] est égal au nombre d'éléments distincts dans le suffixe nums[i + 1, ..., n - 1] soustrait du nombre d'éléments distincts dans le préfixe nums[0, ..., i].
Retournez le tableau de différences distinctes de nums.
Notez que nums[i, ..., j] désigne le sous-tableau de nums commençant à l'indice i et se terminant à l'indice j inclus. En particulier, si i > j, alors nums[i, ..., j] désigne un sous-tableau vide.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : [-3,-1,1,3,5]
Explication : Pour l'indice i = 0, il y a 1 élément dans le préfixe et 4 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 4 = -3.
Pour l'indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l'indice i = 2, il y a 3 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 3 - 2 = 1.
Pour l'indice i = 3, il y a 4 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 4 - 1 = 3.
Pour l'indice i = 4, il y a 5 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 5 - 0 = 5.

Exemple 2 :

Entrée : nums = [3,2,3,4,2]
Sortie : [-2,-1,0,2,3]
Explication : Pour l'indice i = 0, il y a 1 élément dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 3 = -2.
Pour l'indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l'indice i = 2, il y a 2 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 2 - 2 = 0.
Pour l'indice i = 3, il y a 3 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 3 - 1 = 2.
Pour l'indice i = 4, il y a 3 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 3 - 0 = 3.

Contraintes :

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

On vous donne un tableau indexé 0 nombres de longueur n.
Le tableau de différences distinctes de nums est un tableau diff de longueur n tel que diff[i] est égal au nombre d’éléments distincts dans le suffixe nums[i + 1, ..., n - 1] soustrait du nombre d’éléments distincts dans le préfixe nums[0, ..., i].
Renvoie le tableau de différences distinctes de nums.
Notez que nums[i, ..., j] désigne le sous-tableau des nums commençant à l’index i et se terminant à l’index j inclus. En particulier, si i > j alors nums[i, ..., j] désigne un sous-tableau vide.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : [-3,-1,1,3,5]
Explication : Pour l’indice i = 0, il y a 1 élément dans le préfixe et 4 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 4 = -3.
Pour l’indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l’indice i = 2, il y a 3 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 3 - 2 = 1.
Pour l’indice i = 3, il y a 4 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 4 - 1 = 3.
Pour l’indice i = 4, il y a 5 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 5 - 0 = 5.

Exemple 2 :

Entrée : nums = [3,2,3,4,2]
Sortie : [-2,-1,0,2,3]
Explication : Pour l’indice i = 0, il y a 1 élément dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 3 = -2.
Pour l’indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l’indice i = 2, il y a 2 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 2 - 2 = 0.
Pour l’indice i = 3, il y a 3 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 3 - 1 = 2.
Pour l’indice i = 4, il y a 3 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 3 - 0 = 3.

Contraintes:

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

On vous donne un tableau indexé à partir de 0, nums, de longueur n.
Le tableau de différence distincte de nums est un tableau diff de longueur n tel que diff[i] est égal au nombre d'éléments distincts dans le suffixe nums[i + 1, ..., n - 1] soustrait du nombre d'éléments distincts dans le préfixe nums[0, ..., i].
Retournez le tableau de différence distincte de nums.
Notez que nums[i, ..., j] désigne le sous-tableau de nums commençant à l'indice i et se terminant à l'indice j inclus. En particulier, si i > j, alors nums[i, ..., j] désigne un sous-tableau vide.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : [-3,-1,1,3,5]
Explication : Pour l'indice i = 0, il y a 1 élément dans le préfixe et 4 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 4 = -3.
Pour l'indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l'indice i = 2, il y a 3 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 3 - 2 = 1.
Pour l'indice i = 3, il y a 4 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 4 - 1 = 3.
Pour l'indice i = 4, il y a 5 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 5 - 0 = 5.

Exemple 2 :

Entrée : nums = [3,2,3,4,2]
Sortie : [-2,-1,0,2,3]
Explication : Pour l'indice i = 0, il y a 1 élément dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[0] = 1 - 3 = -2.
Pour l'indice i = 1, il y a 2 éléments distincts dans le préfixe et 3 éléments distincts dans le suffixe. Ainsi, diff[1] = 2 - 3 = -1.
Pour l'indice i = 2, il y a 2 éléments distincts dans le préfixe et 2 éléments distincts dans le suffixe. Ainsi, diff[2] = 2 - 2 = 0.
Pour l'indice i = 3, il y a 3 éléments distincts dans le préfixe et 1 élément distinct dans le suffixe. Ainsi, diff[3] = 3 - 1 = 2.
Pour l'indice i = 4, il y a 3 éléments distincts dans le préfixe et aucun élément dans le suffixe. Ainsi, diff[4] = 3 - 0 = 3.

Contraintes :

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


Il y a un tableau indexé à 0, nums, de longueur n. Initialement, tous les éléments sont non colorés (ont une valeur de 0).
On vous donne un tableau d'entiers 2D queries où queries[i] = [index_i, color_i].
Pour chaque requête, vous colorez l'indice index_i avec la couleur color_i dans le tableau nums.
Renvoyez un tableau answer de la même longueur que queries où answer[i] est le nombre d'éléments adjacents avec la même couleur après la i^ème requête.
Plus formellement, answer[i] est le nombre d'indices j, tels que 0 <= j < n - 1 et nums[j] == nums[j + 1] et nums[j] != 0 après la i^ème requête.

Exemple 1 :

Entrée : n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Sortie : [0,1,1,0,2]
Explication : Initialement, tableau nums = [0,0,0,0], où 0 désigne les éléments non colorés du tableau.
- Après la 1^ère requête nums = [2,0,0,0]. Le nombre d'éléments adjacents avec la même couleur est 0.
- Après la 2^ème requête nums = [2,2,0,0]. Le nombre d'éléments adjacents avec la même couleur est 1.
- Après la 3^ème requête nums = [2,2,0,1]. Le nombre d'éléments adjacents avec la même couleur est 1.
- Après la 4^ème requête nums = [2,1,0,1]. Le nombre d'éléments adjacents avec la même couleur est 0.
- Après la 5^ème requête nums = [2,1,1,1]. Le nombre d'éléments adjacents avec la même couleur est 2.

Exemple 2 :

Entrée : n = 1, queries = [[0,100000]]
Sortie : [0]
Explication : Initialement, tableau nums = [0], où 0 désigne les éléments non colorés du tableau.
- Après la 1^ère requête nums = [100000]. Le nombre d'éléments adjacents avec la même couleur est 0.

Contraintes :

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5

On a un tableau nums indexé à partir de 0 de longueur n. Initialement, tous les éléments sont non colorés (ont une valeur de 0).
On vous donne un tableau d'entiers 2D queries où queries[i] = [index_i, color_i].
Pour chaque requête, vous colorez l'indice index_i avec la couleur color_i dans le tableau nums.
Retournez un tableau answer de la même longueur que queries où answer[i] est le nombre d'éléments adjacents avec la même couleur après la i^ème requête.
Plus formellement, answer[i] est le nombre d'indices j, tels que 0 <= j < n - 1 et nums[j] == nums[j + 1] et nums[j] != 0 après la i^ème requête.

Exemple 1 :

Entrée : n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Sortie : [0,1,1,0,2]
Explication : Initialement, tableau nums = [0,0,0,0], où 0 désigne les éléments non colorés du tableau.
- Après la 1^ère requête nums = [2,0,0,0]. Le nombre d'éléments adjacents avec la même couleur est 0.
- Après la 2^ème requête nums = [2,2,0,0]. Le nombre d'éléments adjacents avec la même couleur est 1.
- Après la 3^ème requête nums = [2,2,0,1]. Le nombre d'éléments adjacents avec la même couleur est 1.
- Après la 4^ème requête nums = [2,1,0,1]. Le nombre d'éléments adjacents avec la même couleur est 0.
- Après la 5^ème requête nums = [2,1,1,1]. Le nombre d'éléments adjacents avec la même couleur est 2.

Exemple 2 :

Entrée : n = 1, queries = [[0,100000]]
Sortie : [0]
Explication : Initialement, tableau nums = [0], où 0 désigne les éléments non colorés du tableau.
- Après la 1^ère requête nums = [100000]. Le nombre d'éléments adjacents avec la même couleur est 0.

Contraintes :

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5

Il existe un tableau indexé 0 nums de longueur n. Au départ, tous les éléments ne sont pas colorés (ont une valeur de 0).
On vous donne un tableau d'entiers 2D queries où queries[i] = [index_i, color_i].
Pour chaque requête, vous colorez l'index index_i avec la couleur color_i dans le tableau nums.
Renvoie un tableau answer de la même longueur que queries où answer[i] est le nombre d'éléments adjacents de la même couleur après la i^ème requête.
Plus formellement, answer[i] est le nombre d'indices j, tels que 0 <= j < n - 1 et nums[j] == nums[j + 1] et nums[j] != 0 après la i^ème requête.

Exemple 1 :

Entrée : n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Sortie : [0,1,1,0,2]
Explication : Initialement, le tableau nums = [0,0,0,0], où 0 désigne les éléments non colorés du tableau.
- Après la 1re requête nums = [2,0,0,0]. Le nombre d'éléments adjacents de la même couleur est de 0.
- Après la 2e requête nums = [2,2,0,0]. Le nombre d'éléments adjacents de la même couleur est de 1.
- Après la 3e requête nums = [2,2,0,1]. Le nombre d'éléments adjacents de la même couleur est de 1.
- Après la 4e requête nums = [2,1,0,1]. Le nombre d'éléments adjacents de la même couleur est de 0.
- Après la 5e requête nums = [2,1,1,1]. Le nombre d'éléments adjacents de la même couleur est de 2.

Exemple 2 :

Entrée : n = 1, queries = [[0,100000]]
Sortie : [0]
Explication : Initialement, le tableau nums = [0], où 0 désigne les éléments non colorés du tableau.
- Après la 1re requête nums = [100000]. Le nombre d'éléments adjacents de la même couleur est de 0.

Contraintes :

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <= color_i <= 10^5


Vous avez un tableau d'entiers nums indexé à partir 0, représentant la force de certains héros. La puissance d'un groupe de héros est définie comme suit :

Soient i_0, i_1, ... ,i_k les indices des héros dans un groupe. Alors, la puissance de ce groupe est max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Retournez la somme de la puissance de tous les groupes non vides de héros possibles. Étant donné que la somme peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,1,4]
Sortie : 141
Explication :
1^er groupe : [2] a une puissance = 2^2 * 2 = 8.
2^ème groupe : [1] a une puissance = 1^2 * 1 = 1.
3^ème groupe : [4] a une puissance = 4^2 * 4 = 64.
4^ème groupe : [2,1] a une puissance = 2^2 * 1 = 4.
5^ème groupe : [2,4] a une puissance = 4^2 * 2 = 32.
6^ème groupe : [1,4] a une puissance = 4^2 * 1 = 16.
7^ème groupe : [2,1,4] a une puissance = 4^2 * 1 = 16.
La somme des puissances de tous les groupes est 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Exemple 2 :

Entrée : nums = [1,1,1]
Sortie : 7
Explication : Un total de 7 groupes est possible, et la puissance de chaque groupe sera de 1. Par conséquent, la somme des puissances de tous les groupes est 7.

Contraintes :

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

On vous donne un tableau d'entiers indexés à 0 nums représentant la force de certains héros. La puissance d'un groupe de héros est définie comme suit :

Soit i_0, i_1, ... ,i_k les indices des héros d'un groupe. La puissance de ce groupe est alors max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Renvoie la somme de la puissance de tous les groupes de héros non vides possibles. Étant donné que la somme peut être très importante, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,1,4]
Sortie : 141
Explication :
1er groupe : [2] a une puissance = 2^2 * 2 = 8.
2e groupe : [1] a une puissance = 1^2 * 1 = 1.
3e groupe : [4] a une puissance = 4^2 * 4 = 64.
4e groupe : [2,1] a une puissance = 2^2 * 1 = 4.
5e groupe : [2,4] a une puissance = 4^2 * 2 = 32.
6e groupe : [1,4] a une puissance = 4^2 * 1 = 16.
7e groupe : [2,1,4] a une puissance = 4^2 * 1 = 16.
La somme des puissances de tous les groupes est 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Exemple 2 :

Entrée : nums = [1,1,1]
Sortie : 7
Explication : Un total de 7 groupes sont possibles, et la puissance de chaque groupe sera de 1. Par conséquent, la somme des puissances de tous les groupes est de 7.

Contraintes :

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

Vous avez un tableau d'entiers indexé à 0, `nums`, représentant la force de certains héros. La puissance d'un groupe de héros est définie comme suit :

Soient i_0, i_1, ... ,i_k les indices des héros dans un groupe. Alors, la puissance de ce groupe est max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Retournez la somme de la puissance de tous les groupes non vides de héros possibles. Étant donné que la somme peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,1,4]
Sortie : 141
Explication :
1^er groupe : [2] a une puissance = 2^2 * 2 = 8.
2^ème groupe : [1] a une puissance = 1^2 * 1 = 1.
3^ème groupe : [4] a une puissance = 4^2 * 4 = 64.
4^ème groupe : [2,1] a une puissance = 2^2 * 1 = 4.
5^ème groupe : [2,4] a une puissance = 4^2 * 2 = 32.
6^ème groupe : [1,4] a une puissance = 4^2 * 1 = 16.
7^ème groupe : [2,1,4] a une puissance = 4^2 * 1 = 16.
La somme des puissances de tous les groupes est 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Exemple 2 :

Entrée : nums = [1,1,1]
Sortie : 7
Explication : un total de 7 groupes est possible, et la puissance de chaque groupe sera 1. Par conséquent, la somme des puissances de tous les groupes est 7.

Contraintes :

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


Vous avez une permutation nums de n entiers indexée à partir de 0.
Une permutation est dite semi-ordonnée si le premier nombre est égal à 1 et le dernier nombre est égal à n. Vous pouvez effectuer l'opération ci-dessous autant de fois que vous le souhaitez jusqu'à ce que nums devienne une permutation semi-ordonnée :

Choisissez deux éléments adjacents dans nums, puis échangez-les.

Retournez le nombre minimum d'opérations pour que nums devienne une permutation semi-ordonnée.
Une permutation est une séquence d'entiers de 1 à n de longueur n contenant chaque nombre exactement une fois.

Exemple 1 :

Input: nums = [2,1,4,3]
Output: 2
Explication: Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :
1 - échange i = 0 et j = 1. La permutation devient [1,2,4,3].
2 - échange i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe pas de séquence de moins de deux opérations qui fasse de nums une permutation semi-ordonnée.

Exemple 2 :

Input: nums = [2,4,1,3]
Output: 3
Explication: Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :
1 - échange i = 1 et j = 2. La permutation devient [2,1,4,3].
2 - échange i = 0 et j = 1. La permutation devient [1,2,4,3].
3 - échange i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe pas de séquence de moins de trois opérations qui fasse de nums une permutation semi-ordonnée.

Exemple 3 :

Input: nums = [1,3,4,2,5]
Output: 0
Explication: La permutation est déjà une permutation semi-ordonnée.

Contraintes :

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums est une permutation.

On vous donne une permutation indexée à 0 de n entiers nums.
Une permutation est dite semi-ordonnée si le premier nombre est égal à 1 et le dernier nombre à n. Vous pouvez effectuer l'opération ci-dessous autant de fois que vous le souhaitez jusqu'à ce que vous fassiez de nums une permutation semi-ordonnée :

Choisissez deux éléments adjacents dans nums, puis échangez-les.

Renvoie le nombre minimum d'opérations pour faire de nums une permutation semi-ordonnée.
Une permutation est une séquence d'entiers de 1 à n de longueur n contenant chaque nombre exactement une fois.

Exemple 1 :

Entrée : nums = [2,1,4,3]
Sortie : 2
Explication : Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :

1 - échangez i = 0 et j = 1. La permutation devient [1,2,4,3].
2 - échanger i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe aucune séquence de moins de deux opérations qui fasse de nums une permutation semi-ordonnée.

Exemple 2 :

Entrée : nums = [2,4,1,3]
Sortie : 3
Explication : Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :
1 - échanger i = 1 et j = 2. La permutation devient [2,1,4,3].
2 - échanger i = 0 et j = 1. La permutation devient [1,2,4,3].
3 - échanger i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe aucune séquence de moins de trois opérations qui fasse de nums une permutation semi-ordonnée.

Exemple 3 :

Entrée : nums = [1,3,4,2,5]
Sortie : 0
Explication : La permutation est déjà une permutation semi-ordonnée.

Contraintes :

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums est une permutation.

Vous avez une permutation de n entiers nums indexée à partir de 0.
Une permutation est dite semi-ordonnée si le premier nombre est égal à 1 et le dernier nombre est égal à n. Vous pouvez effectuer l'opération ci-dessous autant de fois que vous le souhaitez jusqu'à ce que nums devienne une permutation semi-ordonnée :

Choisissez deux éléments adjacents dans nums, puis échangez-les.

Retournez le nombre minimum d'opérations pour rendre nums une permutation semi-ordonnée.
Une permutation est une séquence d'entiers de 1 à n de longueur n contenant chaque nombre exactement une fois.

Exemple 1 :

Input: nums = [2,1,4,3]
Output: 2
Explication: Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :
1 - échange i = 0 et j = 1. La permutation devient [1,2,4,3].
2 - échange i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe pas de séquence de moins de deux opérations qui rende nums une permutation semi-ordonnée.

Exemple 2 :

Input: nums = [2,4,1,3]
Output: 3
Explication: Nous pouvons rendre la permutation semi-ordonnée en utilisant cette séquence d'opérations :
1 - échange i = 1 et j = 2. La permutation devient [2,1,4,3].
2 - échange i = 0 et j = 1. La permutation devient [1,2,4,3].
3 - échange i = 2 et j = 3. La permutation devient [1,2,3,4].
Il peut être prouvé qu'il n'existe pas de séquence de moins de trois opérations qui rende nums une permutation semi-ordonnée.

Exemple 3 :

Input: nums = [1,3,4,2,5]
Output: 0
Explication: La permutation est déjà une permutation semi-ordonnée.

Contraintes :

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums est une permutation.


On vous donne une chaîne de caractères s indexée à partir de 0, qui se compose de chiffres de 0 à 9.
Une chaîne t est appelée semi-répétitive s'il y a au plus une paire consécutive des mêmes chiffres à l'intérieur de t. Par exemple, 0010, 002020, 0123, 2002, et 54944 sont semi-répétitives tandis que 00101022 et 1101234883 ne le sont pas.
Retournez la longueur de la plus longue sous-chaîne semi-répétitive à l'intérieur de s.
Une sous-chaîne est une séquence contiguë non vide de caractères à l'intérieur d'une chaîne.

Exemple 1 :

Input: s = "52233"
Output: 4
Explication : La plus longue sous-chaîne semi-répétitive est "5223", qui commence à i = 0 et se termine à j = 3.

Exemple 2 :

Input: s = "5494"
Output: 4
Explication : s est une chaîne semi-répétitive, donc la réponse est 4.

Exemple 3 :

Input: s = "1111111"
Output: 2
Explication : La plus longue sous-chaîne semi-répétitive est "11", qui commence à i = 0 et se termine à j = 1.

Contraintes :

1 <= s.length <= 50
'0' <= s[i] <= '9'

On vous donne une chaîne indexée 0 qui se compose de chiffres de 0 à 9.
Une chaîne t est appelée semi-répétitive s'il y a au plus une paire consécutive des mêmes chiffres à l'intérieur t. Par exemple, 0010, 002020, 0123, 2002 et 54944 sont semi-répétitifs tandis que 00101022 et 1101234883 ne le sont pas.
Retournez la longueur de la sous-chaîne semi-répétitive la plus longue à l'intérieur de s.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1:

Entrée: s = "52233"
Sortie: 4
Explication: La sous-chaîne semi-répétitive la plus longue est "5223", qui commence à i = 0 et se termine à j = 3.

Exemple 2:

Entrée: s = "5494"
Sortie: 4
Explication: S est une chaîne semi-représentative, donc la réponse est 4.

Exemple 3:

Entrée: s = "1111111"
Sortie: 2
Explication: La sous-chaîne semi-répétitive la plus longue est "11", qui commence à i = 0 et se termine à j = 1.

Contraintes:

1 <= s.Length <= 50
'0' <= s [i] <= '9'


Il y a n amis qui jouent à un jeu. Les amis sont assis en cercle et numérotés de 1 à n dans le sens des aiguilles d'une montre. Plus formellement, se déplacer dans le sens des aiguilles d'une montre depuis le i^ème ami vous amène à l'(i+1)^ème ami pour 1 <= i < n, et se déplacer dans le sens des aiguilles d'une montre depuis le n^ème ami vous amène au 1^er ami.
Les règles du jeu sont les suivantes :
Le 1^er ami reçoit la balle.

Après cela, le 1^er ami la passe à l'ami qui est à k pas d'eux dans le sens des aiguilles d'une montre.
Ensuite, l'ami qui reçoit la balle doit la passer à l'ami qui est à 2 * k pas d'eux dans le sens des aiguilles d'une montre.
Après cela, l'ami qui reçoit la balle doit la passer à l'ami qui est à 3 * k pas d'eux dans le sens des aiguilles d'une montre, et ainsi de suite.

En d'autres termes, au i^ème tour, l'ami qui tient la balle doit la passer à l'ami qui est à i * k pas d'eux dans le sens des aiguilles d'une montre.
Le jeu se termine lorsqu'un ami reçoit la balle pour la seconde fois.
Les perdants du jeu sont les amis qui n'ont pas reçu la balle durant toute la partie.
Étant donné le nombre d'amis, n, et un entier k, renvoyez le tableau réponse, qui contient les perdants du jeu dans l'ordre croissant.

Exemple 1 :

Entrée : n = 5, k = 2
Sortie : [4,5]
Explication : Le jeu se déroule comme suit :
1) Commencez chez le 1^er ami et passez la balle à l'ami qui est à 2 pas d'eux - 3^ème ami.
2) Le 3^ème ami passe la balle à l'ami qui est à 4 pas d'eux - 2^ème ami.
3) Le 2^ème ami passe la balle à l'ami qui est à 6 pas d'eux - 3^ème ami.
4) Le jeu se termine lorsque le 3^ème ami reçoit la balle pour la seconde fois.

Exemple 2 :

Entrée : n = 4, k = 4
Sortie : [2,3,4]
Explication : Le jeu se déroule comme suit :
1) Commencez chez le 1^er ami et passez la balle à l'ami qui est à 4 pas d'eux - 1^er ami.
2) Le jeu se termine lorsque le 1^er ami reçoit la balle pour la seconde fois.

Contraintes :

1 <= k <= n <= 50

Il y a n amis qui jouent à un jeu. Les amis sont assis en cercle et numérotés de 1 à n dans le sens des aiguilles d'une montre. Plus précisément, se déplacer dans le sens des aiguilles d'une montre depuis le i^ème ami vous amène à l'(i+1)^ème ami pour 1 <= i < n, et se déplacer dans le sens des aiguilles d'une montre depuis le n^ème ami vous amène au 1^er ami.
Les règles du jeu sont les suivantes :
Le 1^er ami reçoit la balle.

Après cela, le 1^er ami la passe à l'ami qui est à k pas de lui dans le sens des aiguilles d'une montre.
Ensuite, l'ami qui reçoit la balle doit la passer à l'ami qui est à 2 * k pas de lui dans le sens des aiguilles d'une montre.
Après cela, l'ami qui reçoit la balle doit la passer à l'ami qui est à 3 * k pas de lui dans le sens des aiguilles d'une montre, et ainsi de suite.

En d'autres termes, au i^ème tour, l'ami qui tient la balle doit la passer à l'ami qui est à i * k pas de lui dans le sens des aiguilles d'une montre.
Le jeu se termine lorsqu'un ami reçoit la balle pour la seconde fois.
Les perdants du jeu sont les amis qui n'ont pas reçu la balle pendant toute la durée du jeu.
Étant donné le nombre d'amis, n, et un entier k, retournez le tableau réponse, qui contient les perdants du jeu dans l'ordre croissant.

Exemple 1 :

Entrée : n = 5, k = 2
Sortie : [4,5]
Explication : Le jeu se déroule comme suit :
1) On commence  parle 1^er ami qui passe la balle à l'ami qui est à 2 pas de lui - le 3^ème ami.
2) Le 3^ème ami passe la balle à l'ami qui est à 4 pas de lui - le 2^ème ami.
3) Le 2^ème ami passe la balle à l'ami qui est à 6 pas de lui - le 3^ème ami.
4) Le jeu se termine lorsque le 3^ème ami reçoit la balle pour la seconde fois.

Exemple 2 :

Entrée : n = 4, k = 4
Sortie : [2,3,4]
Explication : Le jeu se déroule comme suit :
1) On commence par le 1^er ami qui passe la balle à l'ami qui est à 4 pas de lui - le 1^er ami.
2) Le jeu se termine lorsque le 1^er ami reçoit la balle pour la seconde fois.

Contraintes :

1 <= k <= n <= 50


Un tableau dérivé indexé à 0 de longueur n est dérivé en calculant le XOR (⊕) des valeurs adjacentes dans un tableau binaire original de longueur n.
Plus précisément, pour chaque indice i dans la plage [0, n - 1] :

Si i = n - 1, alors derived[i] = original[i] ⊕ original[0].
Sinon, derived[i] = original[i] ⊕ original[i + 1].

Étant donné un tableau derived, votre tâche est de déterminer s'il existe un tableau binaire original valide qui pourrait avoir formé derived.
Retournez true si un tel tableau existe ou false sinon.

Un tableau binaire est un tableau contenant uniquement des 0 et des 1

Exemple 1 :

Entrée : derived = [1,1,0]
Sortie : true
Explication : Un tableau original valide qui donne derived est [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Exemple 2 :

Entrée : derived = [1,1]
Sortie : true
Explication : Un tableau original valide qui donne derived est [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Exemple 3 :

Entrée : derived = [1,0]
Sortie : false
Explication : Il n'existe pas de tableau original valide qui donne derived.

Contraintes :

n == derived.length
1 <= n <= 10^5
Les valeurs dans derived sont soit des 0, soit des 1

Un tableau dérivé indexé à 0 de longueur n est dérivé en calculant le OU exclusif (⊕) des valeurs adjacentes dans un tableau binaire original de longueur n. Plus précisément, pour chaque indice i dans la plage [0, n - 1] :

Si i = n - 1, alors derived[i] = original[i] ⊕ original[0].
Sinon, derived[i] = original[i] ⊕ original[i + 1].

Étant donné un tableau derived, votre tâche est de déterminer s'il existe un tableau binaire original valide qui pourrait avoir formé derived.
Retournez true si un tel tableau existe ou false sinon.

Un tableau binaire est un tableau contenant uniquement des 0 et des 1

Exemple 1 :

Entrée : derived = [1,1,0]
Sortie : true
Explication : Un tableau original valide qui donne derived est [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Exemple 2 :

Entrée : derived = [1,1]
Sortie : true
Explication : Un tableau original valide qui donne derived est [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Exemple 3 :

Entrée : derived = [1,0]
Sortie : false
Explication : Il n'existe pas de tableau original valide qui donne derived.

Contraintes :

n == derived.length
1 <= n <= 10^5
Les valeurs dans derived sont soit des 0, soit des 1

Un tableau indexé 0 dérivé de longueur n est dérivé en calculant le XOR au niveau du bit (⊕) des valeurs adjacentes dans un tableau binaire original de longueur n.
Plus précisément, pour chaque index i dans la plage [0, n - 1] :

Si i = n - 1, alors derived[i] = original[i] ⊕ original[0].
Sinon, derived[i] = original[i] ⊕ original[i + 1].

Étant donné un tableau derived, votre tâche consiste à déterminer s'il existe un tableau binaire original valide qui aurait pu former derived.
Renvoyer true si un tel tableau existe ou false sinon.

Un tableau binaire est un tableau contenant uniquement des 0 et des 1.

Exemple 1 :

Entrée : derived = [1,1,0]
Sortie : true
Explication : Un tableau original valide qui donne derived est [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Exemple 2 :

Entrée : derived = [1,1]
Sortie : true
Explication : un tableau d'origine valide qui donne derived est [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Exemple 3 :

Entrée : derived = [1,0]
Sortie : false
Explication : il n'existe aucun tableau d'origine valide qui donne derived.

Contraintes :

n == derived.length
1 <= n <= 10^5
Les valeurs dans derived sont soit des 0, soit des 1