Vous disposez d'un tableau d'entiers nums et de deux entiers cost1 et cost2. Vous êtes autorisé à effectuer l'une des opérations suivantes un nombre quelconque de fois :

Choisissez un indice i de nums et augmentez nums[i] de 1 pour un coût de cost1.
Choisissez deux indices différents i, j de nums et augmentez nums[i] et nums[j] de 1 pour un coût de cost2.

Retournez le coût minimum nécessaire pour rendre tous les éléments du tableau égaux.
Puisque la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [4,1], cost1 = 5, cost2 = 2
Sortie : 15
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter nums[1] de 1 pour un coût de 5. nums devient [4,2].
Augmenter nums[1] de 1 pour un coût de 5. nums devient [4,3].
Augmenter nums[1] de 1 pour un coût de 5. nums devient [4,4].

Le coût total est de 15.

Exemple 2 :

Entrée : nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Sortie : 6
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter nums[0] et nums[1] de 1 pour un coût de 1. nums devient [3,4,3,3,5].
Augmenter nums[0] et nums[2] de 1 pour un coût de 1. nums devient [4,4,4,3,5].
Augmenter nums[0] et nums[3] de 1 pour un coût de 1. nums devient [5,4,4,4,5].
Augmenter nums[1] et nums[2] de 1 pour un coût de 1. nums devient [5,5,5,4,5].
Augmenter nums[3] de 1 pour un coût de 2. nums devient [5,5,5,5,5].

Le coût total est de 6.

Exemple 3 :

Entrée : nums = [3,5,3], cost1 = 1, cost2 = 3
Sortie : 4
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter nums[0] de 1 pour un coût de 1. nums devient [4,5,3].
Augmenter nums[0] de 1 pour un coût de 1. nums devient [5,5,3].
Augmenter nums[2] de 1 pour un coût de 1. nums devient [5,5,4].
Augmenter nums[2] de 1 pour un coût de 1. nums devient [5,5,5].

Le coût total est de 4.

Contraintes :

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

Vous disposez d'un tableau d'entiers `nums` et de deux entiers `cost1` et `cost2`. Vous êtes autorisé à effectuer l'une des opérations suivantes un nombre quelconque de fois :

Choisissez un indice `i` de `nums` et augmentez `nums[i]` de 1 pour un coût de `cost1`.
Choisissez deux indices différents `i`, `j` de `nums` et augmentez `nums[i]` et `nums[j]` de 1 pour un coût de `cost2`.

Retournez le coût minimum nécessaire pour rendre tous les éléments du tableau égaux.
Puisque la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [4,1], cost1 = 5, cost2 = 2
Sortie : 15
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter `nums[1]` de 1 pour un coût de 5. `nums` devient [4,2].
Augmenter `nums[1]` de 1 pour un coût de 5. `nums` devient [4,3].
Augmenter `nums[1]` de 1 pour un coût de 5. `nums` devient [4,4].

Le coût total est de 15.

Exemple 2 :

Entrée : nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Sortie : 6
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter `nums[0]` et `nums[1]` de 1 pour un coût de 1. `nums` devient [3,4,3,3,5].
Augmenter `nums[0]` et `nums[2]` de 1 pour un coût de 1. `nums` devient [4,4,4,3,5].
Augmenter `nums[0]` et `nums[3]` de 1 pour un coût de 1. `nums` devient [5,4,4,4,5].
Augmenter `nums[1]` et `nums[2]` de 1 pour un coût de 1. `nums` devient [5,5,5,4,5].
Augmenter `nums[3]` de 1 pour un coût de 2. `nums` devient [5,5,5,5,5].

Le coût total est de 6.

Exemple 3 :

Entrée : nums = [3,5,3], cost1 = 1, cost2 = 3
Sortie : 4
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmenter `nums[0]` de 1 pour un coût de 1. `nums` devient [4,5,3].
Augmenter `nums[0]` de 1 pour un coût de 1. `nums` devient [5,5,3].
Augmenter `nums[2]` de 1 pour un coût de 1. `nums` devient [5,5,4].
Augmenter `nums[2]` de 1 pour un coût de 1. `nums` devient [5,5,5].

Le coût total est de 4.

Contraintes :

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

On vous donne un tableau d'entiers nums et deux entiers cost1 et cost2. Vous êtes autorisé à effectuer l'une des opérations suivantes autant de fois que vous le souhaitez :

Choisissez un index i dans nums et augmentez nums[i] de 1 pour un coût de cost1.
Choisissez deux index différents i, j, dans nums et augmentez nums[i] et nums[j] de 1 pour un coût de cost2.

Renvoie le coût minimum requis pour rendre tous les éléments du tableau égaux.

La réponse pouvant être très grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [4,1], cost1 = 5, cost2 = 2
Sortie : 15
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmentez nums[1] de 1 pour un coût de 5. nums devient [4,2].
Augmentez nums[1] de 1 pour un coût de 5. nums devient [4,3].
Augmentez nums[1] de 1 pour un coût de 5. nums devient [4,4].

Le coût total est de 15.

Exemple 2 :

Entrée : nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Sortie : 6
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmentez nums[0] et nums[1] de 1 pour un coût de 1. nums devient [3,4,3,3,5].
Augmentez nums[0] et nums[2] de 1 pour un coût de 1. nums devient [4,4,4,3,5].
Augmentez nums[0] et nums[3] de 1 pour un coût de 1. nums devient [5,4,4,4,5].
Augmentez nums[1] et nums[2] de 1 pour un coût de 1. nums devient [5,5,5,4,5].
Augmentez nums[3] de 1 pour un coût de 2. nums devient [5,5,5,5,5].

Le coût total est de 6.

Exemple 3 :

Entrée : nums = [3,5,3], cost1 = 1, cost2 = 3
Sortie : 4
Explication :
Les opérations suivantes peuvent être effectuées pour rendre les valeurs égales :

Augmentez nums[0] de 1 pour un coût de 1. nums devient [4,5,3].
Augmentez nums[0] de 1 pour un coût de 1. nums devient [5,5,3].
Augmentez nums[2] de 1 pour un coût de 1. nums devient [5,5,4].
Augmentez nums[2] de 1 pour un coût de 1. nums devient [5,5,5].

Le coût total est de 4.

Contraintes :

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


Vous avez une matrice 2D, grid, de taille 3 x 3 composée uniquement des caractères 'B' et 'W'. Le caractère 'W' représente la couleur blanche, et le caractère 'B' représente la couleur noire.
Votre tâche est de changer la couleur d'au plus une cellule afin que la matrice ait un carré de 2 x 2 où toutes les cellules sont de la même couleur.
Retournez true s'il est possible de créer un carré de 2 x 2 de la même couleur, sinon, retournez false.

Exemple 1:

Entrée: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Sortie: true
Explication:
Cela peut être fait en changeant la couleur de grid[0][2].

Exemple 2:

Entrée: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Sortie: false
Explication:
Cela ne peut pas être fait en changeant au plus une cellule.

Exemple 3:

Entrée: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Sortie: true
Explication:
La matrice contient déjà un carré de 2 x 2 de la même couleur.

Contraintes:

grid.length == 3
grid[i].length == 3
grid[i][j] est soit 'W' soit 'B'.

Vous avez une matrice 2D, grid, de taille 3 x 3 constituée uniquement des caractères 'B' et 'W'. Le caractère 'W' représente la couleur blanche, et le caractère 'B' représente la couleur noire.
Votre tâche consiste à modifier la couleur d'au plus une cellule afin que la matrice contienne un carré de 2 x 2 où toutes les cellules sont de la même couleur.
Retournez true s'il est possible de créer un carré de 2 x 2 de la même couleur, sinon, retournez false.

Exemple 1:

Entrée: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Sortie: true
Explication:
Cela peut être fait en modifiant la couleur de grid[0][2].

Exemple 2:

Entrée: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Sortie: false
Explication:
Cela ne peut pas être fait en modifiant au plus une cellule.

Exemple 3:

Entrée: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Sortie: true
Explication:
La matrice contient déjà un carré de 2 x 2 de la même couleur.

Contraintes:

grid.length == 3
grid[i].length == 3
grid[i][j] est soit 'W' soit 'B'.

Vous disposez d'une grille matricielle 2D de taille 3 x 3 composée uniquement des caractères « B » et « W ». Le caractère « W » représente la couleur blanche et le caractère « B » représente la couleur noire.
Votre tâche consiste à changer la couleur d'au plus une cellule afin que la matrice ait un carré 2 x 2 où toutes les cellules sont de la même couleur.
Retournez true s'il est possible de créer un carré 2 x 2 de la même couleur, sinon, retournez false.

Exemple 1 :

Entrée : grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Sortie : true
Explication :
Il suffit de changer la couleur de la grille [0][2].

Exemple 2 :

Entrée : grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Sortie : false
Explication :
Il n'est pas possible de modifier une seule cellule.

Exemple 3 :

Entrée : grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Sortie : true
Explication :
La grille contient déjà un carré 2 x 2 de la même couleur.

Contraintes :

grid.length == 3
grid[i].length == 3
grid[i][j] est soit 'W' soit 'B'.


Vous avez une matrice booléenne 2D appelée `grid`.
Renvoyez un entier qui est le nombre de triangles rectangles pouvant être formés avec les 3 éléments de `grid` de sorte que chacun ait une valeur de 1.
Remarque :

Une collection de 3 éléments de `grid` est un triangle rectangle si l'un de ses éléments est dans la même ligne qu'un autre élément et dans la même colonne que le troisième élément. Les 3 éléments ne doivent pas nécessairement être adjacents.

Exemple 1 :

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrée : `grid = [[0,1,0],[0,1,1],[0,1,0]]`
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Exemple 2 :

1
0
0
0

0
1
0
1

1
0
0
0

Entrée : `grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]`
Sortie : 0
Explication :
Il n'y a pas de triangles rectangles.

Exemple 3 :

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrée : `grid = [[1,0,1],[1,0,0],[1,0,0]]`
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Contraintes :

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

Vous avez une matrice booléenne 2D appelée `grid`.
Retournez un entier qui est le nombre de triangles rectangles pouvant être formés avec les 3 éléments de `grid` de sorte que chacun ait une valeur de 1.
Remarque :

Une collection de 3 éléments de `grid` est un triangle rectangle si l'un de ses éléments est dans la même ligne qu'un autre élément et dans la même colonne que le troisième élément. Les 3 éléments ne doivent pas nécessairement être adjacents.

Exemple 1 :

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrée : `grid = [[0,1,0],[0,1,1],[0,1,0]]`
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Exemple 2 :

1
0
0
0

0
1
0
1

1
0
0
0

Entrée : `grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]`
Sortie : 0
Explication :
Il n'y a pas de triangles rectangles.

Exemple 3 :

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrée : `grid = [[1,0,1],[1,0,0],[1,0,0]]`
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Contraintes :

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

On vous donne une matrice booléenne 2D appelée grid.
Retournez un entier qui est le nombre de triangles rectangles pouvant être formés avec les 3 éléments de grid de sorte que chacun ait une valeur de 1.
Remarque :

Une collection de 3 éléments de grid est un triangle rectangle si l'un de ses éléments est sur la même ligne qu'un autre élément et dans la même colonne que le troisième élément. Les 3 éléments ne doivent pas nécessairement être adjacents.

Exemple 1 :

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Entrée : grid = [[0,1,0],[0,1,1],[0,1,0]]
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Exemple 2 :

1
0
0
0

0
1
0
1

1
0
0
0

Entrée : grid = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Sortie : 0
Explication :
Il n'y a pas de triangles rectangles.

Exemple 3 :

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Entrée : grid = [[1,0,1],[1,0,0],[1,0,0]]
Sortie : 2
Explication :
Il y a deux triangles rectangles.

Contraintes :

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1


Vous avez 3 entiers positifs zero, one et limit.
Un tableau binaire arr est dit stable si :

Le nombre d'occurrences de 0 dans arr est exactement zero.
Le nombre d'occurrences de 1 dans arr est exactement one.
Chaque sous-tableau de arr d'une taille supérieure à limit doit contenir à la fois 0 et 1.

Retournez le nombre total de tableaux binaires stables.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : zero = 1, one = 1, limit = 2
Sortie : 2
Explication :
Les deux tableaux binaires stables possibles sont [1,0] et [0,1], car les deux tableaux ont un unique 0 et un unique 1, et aucun sous-tableau n'a une longueur supérieure à 2.

Exemple 2 :

Entrée : zero = 1, one = 2, limit = 1
Sortie : 1
Explication :
Le seul tableau binaire stable possible est [1,0,1].
Notez que les tableaux binaires [1,1,0] et [0,1,1] ont des sous-tableaux de longueur 2 avec des éléments identiques, donc ils ne sont pas stables.

Exemple 3 :

Entrée : zero = 3, one = 3, limit = 2
Sortie : 14
Explication :
Tous les tableaux binaires stables possibles sont [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] et [1,1,0,1,0,0].

Contraintes :

1 <= zero, one, limit <= 200

On vous donne 3 entiers positifs zéro, un et limite.
Un tableau binaire arr est dit stable si :

Le nombre d'occurrences de 0 dans arr est exactement zéro.
Le nombre d'occurrences de 1 dans arr est exactement un.
Chaque sous-tableau de arr dont la taille est supérieure à limit doit contenir à la fois 0 et 1.

Retournez le nombre total de tableaux binaires stables.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : zero = 1, one = 1, limit = 2
Sortie : 2
Explication :
Les deux tableaux binaires stables possibles sont [1,0] et [0,1], car les deux tableaux ont un seul 0 et un seul 1, et aucun sous-tableau n'a une longueur supérieure à 2.

Exemple 2 :

Entrée :  zero = 1, one = 2, limit = 1
Sortie : 1
Explication :
Le seul tableau binaire stable possible est [1,0,1].
Notez que les tableaux binaires [1,1,0] et [0,1,1] ont des sous-réseaux de longueur 2 avec des éléments identiques, ils ne sont donc pas stables.

Exemple 3 :

Entrée : zero = 3, one = 3, limit = 2
Sortie : 14
Explication :
Tous les tableaux binaires stables possibles sont [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0, 0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0], et [1,1,0,1,0,0,0].

Contraintes :

1 <= zero, one, limit <= 200

Vous avez 3 entiers positifs zero, one et limit.
Un tableau binaire arr est réputé stable si :

Le nombre d'occurrences de 0 dans arr est exactement zero.
Le nombre d'occurrences de 1 dans arr est exactement one.
Chaque sous-tableau de arr d'une taille supérieure à limit doit contenir à la fois 0 et 1.

Renvoyez le nombre total de tableaux binaires stables.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Input: zero = 1, one = 1, limit = 2
Output: 2
Explication :
Les deux tableaux binaires stables possibles sont [1,0] et [0,1], car les deux tableaux ont un unique 0 et un unique 1, et aucun sous-tableau n'a une longueur supérieure à 2.

Exemple 2 :

Input: zero = 1, one = 2, limit = 1
Output: 1
Explication :
Le seul tableau binaire stable possible est [1,0,1].
Notez que les tableaux binaires [1,1,0] et [0,1,1] ont des sous-tableaux de longueur 2 avec des éléments identiques, donc ils ne sont pas stables.

Exemple 3 :

Input: zero = 3, one = 3, limit = 2
Output: 14
Explication :
Tous les tableaux binaires stables possibles sont [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] et [1,1,0,1,0,0].

Contraintes :

1 <= zero, one, limit <= 200


On vous donne deux chaînes de caractères s et t telles que chaque caractère apparaît au plus une fois dans s et t est une permutation de s.
La différence de permutation entre s et t est définie comme la somme des différences absolues entre l'indice de l'occurrence de chaque caractère dans s et l'indice de l'occurrence du même caractère dans t.
Renvoyez la différence de permutation entre s et t.

Exemple 1 :

Entrée : s = "abc", t = "bac"
Sortie : 2
Explication :
Pour s = "abc" et t = "bac", la différence de permutation de s et t est égale à la somme de :

La différence absolue entre l'indice de l'occurrence de "a" dans s et l'indice de l'occurrence de "a" dans t.
La différence absolue entre l'indice de l'occurrence de "b" dans s et l'indice de l'occurrence de "b" dans t.
La différence absolue entre l'indice de l'occurrence de "c" dans s et l'indice de l'occurrence de "c" dans t.

C'est-à-dire, la différence de permutation entre s et t est égale à |0 - 1| + |2 - 2| + |1 - 0| = 2.

Exemple 2 :

Entrée : s = "abcde", t = "edbac"
Sortie : 12
Explication : La différence de permutation entre s et t est égale à |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Contraintes :

1 <= s.length <= 26
Chaque caractère apparaît au plus une fois dans s.
t est une permutation de s.
s se compose uniquement de lettres minuscules anglaises.

On vous donne deux chaînes s et t telles que chaque caractère apparaît au plus une fois dans s et t est une permutation de s.
La différence de permutation entre s et t est définie comme la somme de la différence absolue entre l'indice d'occurrence de chaque caractère dans s et l'indice d'occurrence du même caractère dans t.
Renvoie la différence de permutation entre s et t.

Exemple 1 :

Entrée : s = "abc", t = "bac"
Sortie : 2
Explication :
Pour s = "abc" et t = "bac", la différence de permutation de s et t est égale à la somme de :

La différence absolue entre l'indice d'occurrence de "a" dans s et l'indice d'occurrence de "a" dans t.
La différence absolue entre l'indice d'occurrence de "b" dans s et l'indice d'occurrence de "b" dans t.
Différence absolue entre l'indice d'occurrence de "c" dans s et l'indice d'occurrence de "c" dans t.

C'est-à-dire que la différence de permutation entre s et t est égale à |0 - 1| + |2 - 2| + |1 - 0| = 2.

Exemple 2 :

Entrée : s = "abcde", t = "edbac"
Sortie : 12
Explication : La différence de permutation entre s et t est égale à |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Contraintes :

1 <= s.length <= 26
Chaque caractère apparaît au plus une fois dans s.
t est une permutation de s.
s est composé uniquement de lettres minuscules anglaises.

On vous donne deux chaînes de caractères s et t telles que chaque caractère apparaît au plus une fois dans s et t est une permutation de s.
La différence de permutation entre s et t est définie comme la somme des différences absolues entre l'indice de l'occurrence de chaque caractère dans s et l'indice de l'occurrence du même caractère dans t.
Retournez la différence de permutation entre s et t.

Exemple 1 :

Entrée : s = "abc", t = "bac"
Sortie : 2
Explication :
Pour s = "abc" et t = "bac", la différence de permutation de s et t est égale à la somme de :

La différence absolue entre l'indice de l'occurrence de "a" dans s et l'indice de l'occurrence de "a" dans t.
La différence absolue entre l'indice de l'occurrence de "b" dans s et l'indice de l'occurrence de "b" dans t.
La différence absolue entre l'indice de l'occurrence de "c" dans s et l'indice de l'occurrence de "c" dans t.

Ainsi, la différence de permutation entre s et t est égale à |0 - 1| + |2 - 2| + |1 - 0| = 2.

Exemple 2 :

Entrée : s = "abcde", t = "edbac"
Sortie : 12
Explication : La différence de permutation entre s et t est égale à |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Contraintes :

1 <= s.length <= 26
Chaque caractère apparaît au plus une fois dans s.
t est une permutation de s.
s se compose uniquement de lettres minuscules anglaises.


Dans un donjon mystique, n magiciens sont alignés. Chaque magicien possède un attribut qui vous donne de l'énergie. Certains magiciens peuvent vous donner de l'énergie négative, ce qui signifie qu'ils vous en prennent.
Vous avez été maudit de telle sorte qu'après avoir absorbé l'énergie du magicien i, vous serez instantanément téléporté au magicien (i + k). Ce processus sera répété jusqu'à ce que vous atteigniez le magicien où (i + k) n'existe pas.
En d'autres termes, vous choisirez un point de départ puis vous vous téléporterez avec des sauts de k jusqu'à atteindre la fin de la séquence des magiciens, absorbant toute l'énergie pendant le voyage.
On vous donne un tableau energy et un entier k. Renvoyez l'énergie maximale possible que vous pouvez gagner.

Exemple 1 :

Input:  energy = [5,2,-10,-5,1], k = 3
Output: 3
Explication : Nous pouvons gagner une énergie totale de 3 en commençant par le magicien 1 absorbant 2 + 1 = 3.

Exemple 2 :

Input: energy = [-2,-3,-1], k = 2
Output: -1
Explication : Nous pouvons gagner une énergie totale de -1 en commençant par le magicien 2.

Contraintes :

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

Dans un donjon mystique, n magiciens sont alignés. Chaque magicien possède un attribut qui vous donne de l'énergie. Certains magiciens peuvent vous donner de l'énergie négative, ce qui signifie qu'ils vous en prennent.
Vous avez été maudit de telle sorte qu'après avoir absorbé l'énergie du magicien i, vous serez instantanément téléporté au magicien (i + k). Ce processus sera répété jusqu'à ce que vous atteigniez le magicien où (i + k) n'existe pas.
En d'autres termes, vous choisirez un point de départ puis vous vous téléporterez par sauts de valeur k jusqu'à atteindre la fin de la séquence des magiciens, absorbant toute l'énergie pendant le voyage.
On vous donne un tableau energy et un entier k. Retournez l'énergie maximale possible que vous pouvez gagner.

Exemple 1 :

Input:  energy = [5,2,-10,-5,1], k = 3
Output: 3
Explication : Nous pouvons gagner une énergie totale de 3 en commençant par le magicien 1 absorbant 2 + 1 = 3.

Exemple 2 :

Input: energy = [-2,-3,-1], k = 2
Output: -1
Explication : Nous pouvons gagner une énergie totale de -1 en commençant par le magicien 2.

Contraintes :

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1

Dans un donjon mystique, n magiciens sont en ligne. Chaque magicien a un attribut qui vous donne de l’énergie. Certains magiciens peuvent vous donner de l’énergie négative, ce qui signifie vous prendre de l’énergie.
Vous avez été maudit de telle sorte qu’après avoir absorbé l’énergie du magicien i, vous serez instantanément transporté vers le magicien (i + k). Ce processus sera répété jusqu’à ce que vous atteigniez le magicien où (i + k) n’existe pas.
En d’autres termes, vous choisirez un point de départ, puis vous vous téléporterez avec k sauts jusqu’à ce que vous atteigniez la fin de la séquence des magiciens, absorbant toute l’énergie pendant le voyage.
On vous donne une énergie de tableau et un entier k. Retournez le maximum d’énergie possible que vous pouvez gagner.

Exemple 1 :

Entrée : énergie = [5,2,-10,-5,1], k = 3
Sortie : 3
Explication : Nous pouvons gagner une énergie totale de 3 en partant du magicien 1 absorbant 2 + 1 = 3.

Exemple 2 :

Entrée : énergie = [-2,-3,-1], k = 2
Sortie : -1
Explication : On peut gagner une énergie totale de -1 en partant du magicien 2.

Contraintes:

1 <= energy.length <= 10^5
-1000 <= energy[i] <= 1000
1 <= k <= energy.length - 1


Un tableau est considéré comme spécial si chaque paire de ses éléments adjacents contient deux nombres de parité différente.
On vous donne un tableau d'entiers nums. Retournez true si nums est un tableau spécial, sinon, retournez false.

Exemple 1 :

Entrée : nums = [1]
Sortie : true
Explication :
Il n'y a qu'un seul élément. Donc la réponse est true.

Exemple 2 :

Entrée : nums = [2,1,4]
Sortie : true
Explication :
Il n'y a que deux paires : (2,1) et (1,4), et chacune d'elles contient des nombres de parité différente. Donc la réponse est true.

Exemple 3 :

Entrée : nums = [4,3,1,6]
Sortie : false
Explication :
nums[1] et nums[2] sont tous deux impairs. Donc la réponse est false.

Contraintes :

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

Un tableau est considéré comme spécial si chaque paire de ses éléments adjacents contient deux nombres avec une parité différente.
On vous donne un tableau d'entiers nums. Renvoie true si nums est un tableau spécial, sinon, renvoie false.

Exemple 1 :

Entrée : nums = [1]
Sortie : true
Explication :
Il n'y a qu'un seul élément. Donc la réponse est true.

Exemple 2 :

Entrée : nums = [2,1,4]
Sortie : true
Explication :
Il n'y a que deux paires : (2,1) et (1,4), et toutes deux contiennent des nombres avec une parité différente. Donc la réponse est true.

Exemple 3 :

Entrée : nums = [4,3,1,6]
Sortie : false
Explication :
nums[1] et nums[2] sont tous deux impairs. Donc la réponse est false.

Contraintes :

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

Un tableau est considéré comme spécial si chaque paire de ses éléments adjacents contient deux nombres de parité différente.
On vous donne un tableau d'entiers nums. Retournez true si nums est un tableau spécial, sinon, retournez false.

Exemple 1 :

Input: nums = [1]
Output: true
Explication :
Il n'y a qu'un seul élément. Donc la réponse est true.

Exemple 2 :

Input: nums = [2,1,4]
Output: true
Explication :
Il n'y a que deux paires : (2,1) et (1,4), et chacune d'elles contient des nombres de parité différente. Donc la réponse est true.

Exemple 3 :

Input: nums = [4,3,1,6]
Output: false
Explication :
nums[1] et nums[2] sont tous deux impairs. Donc la réponse est false.

Contraintes :

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


On vous donne un tableau nums composé d'entiers positifs où tous les entiers ont le même nombre de chiffres.
La différence de chiffres entre deux entiers est le nombre de chiffres différents qui sont à la même position dans les deux entiers.
Renvoie la somme des différences de chiffres entre toutes les paires d'entiers dans nums.

Exemple 1 :

Entrée : nums = [13,23,12]
Sortie : 4
Explication :
Nous avons ce qui suit :
- La différence de chiffres entre 13 et 23 est de 1.
- La différence de chiffres entre 13 et 12 est de 1.
- La différence de chiffres entre 23 et 12 est de 2.
Ainsi, la somme totale des différences de chiffres entre toutes les paires d'entiers est de 1 + 1 + 2 = 4.

Exemple 2 :

Entrée : nums = [10,10,10,10]
Sortie : 0
Explication :
Tous les entiers du tableau sont identiques. Ainsi, la somme totale des différences de chiffres entre toutes les paires d'entiers sera de 0.

Contraintes :

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Tous les entiers dans nums ont le même nombre de chiffres.

Vous avez un tableau nums composé d'entiers positifs où tous les entiers ont le même nombre de chiffres.
La différence de chiffres entre deux entiers est le nombre de chiffres différents qui sont à la même position dans les deux entiers.
Retournez la somme des différences de chiffres entre toutes les paires d'entiers dans nums.

Exemple 1 :

Entrée : nums = [13,23,12]
Sortie : 4
Explication :
Nous avons les éléments suivants :
- La différence de chiffres entre 13 et 23 est 1.
- La différence de chiffres entre 13 et 12 est 1.
- La différence de chiffres entre 23 et 12 est 2.
Donc, la somme totale des différences de chiffres entre toutes les paires d'entiers est 1 + 1 + 2 = 4.

Exemple 2 :

Entrée : nums = [10,10,10,10]
Sortie : 0
Explication :
Tous les entiers du tableau sont identiques. Donc, la somme totale des différences de chiffres entre toutes les paires d'entiers sera 0.

Contraintes :

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Tous les entiers dans nums ont le même nombre de chiffres.

Vous avez un tableau nums composé d'entiers positifs où tous les entiers ont le même nombre de chiffres.
La différence de chiffres entre deux entiers est le nombre de chiffres différents qui sont à la même position dans les deux entiers.
Renvoyez la somme des différences de chiffres entre toutes les paires d'entiers dans nums.

Exemple 1 :

Entrée : nums = [13,23,12]
Sortie : 4
Explication :
Nous avons les éléments suivants :
- La différence de chiffres entre 13 et 23 est 1.
- La différence de chiffres entre 13 et 12 est 1.
- La différence de chiffres entre 23 et 12 est 2.
Donc, la somme totale des différences de chiffres entre toutes les paires d'entiers est 1 + 1 + 2 = 4.

Exemple 2 :

Entrée : nums = [10,10,10,10]
Sortie : 0
Explication :
Tous les entiers du tableau sont identiques. Donc, la somme totale des différences de chiffres entre toutes les paires d'entiers sera 0.

Contraintes :

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Tous les entiers dans nums ont le même nombre de chiffres.


On vous donne un entier non négatif k. Il existe un escalier avec un nombre infini de marches, la marche la plus basse portant le numéro 0.
Alice a un saut entier, avec une valeur initiale de 0. Elle commence par l'escalier 1 et veut atteindre l'escalier k en utilisant un nombre quelconque d'opérations. Si elle est sur l'escalier i, en une seule opération elle peut :

Descendre jusqu'à l'escalier i - 1. Cette opération ne peut pas être utilisée consécutivement ou sur l'escalier 0.
Monter jusqu'à l'escalier i + 2^saut. Et alors, saut devient saut + 1.

Renvoie le nombre total de façons dont Alice peut atteindre l'escalier k.
Notez qu'il est possible qu'Alice atteigne l'escalier k et effectue certaines opérations pour atteindre à nouveau l'escalier k.

Exemple 1 :

Entrée : k = 0
Sortie : 2
Explication :
Les 2 manières possibles d'atteindre l'escalier 0 sont :

Alice commence à l'escalier 1.

En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.

Alice commence à l'escalier 1.

En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.
En utilisant une opération du deuxième type, elle monte 2^0 marches pour atteindre l'escalier 1.
En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.

Example 2:

Entrée : k = 1
Sortie : 4
Explication :
Les 4 manières possibles d'atteindre l'escalier 1 sont :

Alice commence à l'escalier 1. Alice est à l'escalier 1.
Alice commence à l'escalier 1.

En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.
En utilisant une opération du deuxième type, elle monte 2^0 marches pour atteindre l'escalier 1.

Alice commence à l'escalier 1.

En utilisant une opération du deuxième type, elle monte 2^0 marches pour atteindre l'escalier 2.
En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 1.

Alice commence à l'escalier 1.

En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.
En utilisant une opération du deuxième type, elle monte 2^0 marches pour atteindre l'escalier 1.
En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 0.
En utilisant une opération du deuxième type, elle monte 2^1 marches pour atteindre l'escalier 2.
En utilisant une opération du premier type, elle descend 1 marche pour atteindre l'escalier 1.

Constraints:

0 <= k <= 10^9

On vous donne un entier non négatif k. Il existe un escalier avec un nombre infini de marches, la marche la plus basse étant numérotée 0.
Alice a un saut d'entier, avec une valeur initiale de 0. Elle commence sur la marche 1 et veut atteindre la marche k en utilisant n'importe quel nombre d'opérations. Si elle est sur la marche i, en une opération, elle peut :

Descendre à la marche i - 1. Cette opération ne peut pas être utilisée consécutivement ou sur la marche 0.
Monter à la marche i + 2^jump. Ensuite, jump devient jump + 1.

Retourner le nombre total de façons dont Alice peut atteindre la marche k.
Notez qu'il est possible qu'Alice atteigne la marche k et effectue certaines opérations pour atteindre à nouveau la marche k.

Exemple 1 :

Entrée : k = 0
Sortie : 2
Explication :
Les 2 façons possibles d'atteindre la marche 0 sont :

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.

Exemple 2 :

Entrée : k = 1
Sortie : 4
Explication :
Les 4 façons possibles d'atteindre la marche 1 sont :

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.

Alice commence à la marche 1.

En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 2.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 1.

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^1 marches pour atteindre la marche 2.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 1.

Contraintes :

0 <= k <= 10^9

On donne un entier non négatif k. Il existe un escalier avec un nombre infini de marches, la marche la plus basse étant numérotée 0.
Alice a un saut sous forme d'entier jump, avec une valeur initiale de 0. Elle commence sur la marche 1 et veut atteindre la marche k en utilisant n'importe quel nombre d'opérations. Si elle est sur la marche i, en une opération, elle peut :

Descendre à la marche i - 1. Cette opération ne peut pas être utilisée consécutivement ou sur la marche 0.
Monter à la marche i + 2^jump. Ensuite, jump devient jump + 1.

Retourner le nombre total de façons dont Alice peut atteindre la marche k.
Notez qu'il est possible qu'Alice atteigne la marche k et effectue certaines opérations pour atteindre à nouveau la marche k.

Exemple 1 :

Entrée : k = 0
Sortie : 2
Explication :
Les 2 façons possibles d'atteindre la marche 0 sont :

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.

Exemple 2 :

Entrée : k = 1
Sortie : 4
Explication :
Les 4 façons possibles d'atteindre la marche 1 sont :

Alice commence à la marche 1. Alice se trouve à la marche 1.
Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.

Alice commence à la marche 1.

En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 2.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 1.

Alice commence à la marche 1.

En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^0 marches pour atteindre la marche 1.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 0.
En utilisant une opération du second type, elle monte de 2^1 marches pour atteindre la marche 2.
En utilisant une opération du premier type, elle descend de 1 marche pour atteindre la marche 1.

Contraintes :

0 <= k <= 10^9


On vous donne 2 tableaux d'entiers nums1 et nums2 de longueurs n et m respectivement. On vous donne également un entier positif k.
Une paire (i, j) est dite bonne si nums1[i] est divisible par nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Renvoie le nombre total de paires bonnes.

Exemple 1 :

Entrée : nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Sortie : 5
Explication :
Les 5 paires bonnes sont (0, 0), (1, 0), (1, 1), (2, 0) et (2, 2).
Exemple 2 :

Entrée : nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Sortie : 2
Explication :
Les 2 bonnes paires sont (3, 0) et (3, 1).

Contraintes :

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50

On vous donne 2 tableaux entiers nums1 et nums2 de longueurs n et m respectivement. On vous donne également un entier positif k.
Une paire (i, j) est appelée bonne si nums1[i] est divisible par nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Retournez le nombre total de bonnes paires.

Exemple 1 :

Entrée : nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Sortie : 5
Explication :
Les 5 bonnes paires sont (0, 0), (1, 0), (1, 1), (2, 0), et (2, 2).
Exemple 2 :

Entrée : nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Sortie : 2
Explication :
Les 2 bonnes paires sont (3, 0) et (3, 1).

Contraintes :

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50


Étant donné une chaîne de caractères word, compressez-la en utilisant l'algorithme suivant :

Commencez avec une chaîne vide comp. Tant que word n'est pas vide, utilisez l'opération suivante :

Retirez un préfixe de longueur maximale de word composé d'un seul caractère c se répétant au plus 9 fois.
Ajoutez la longueur du préfixe suivie de c à comp.

Retournez la chaîne comp.

Exemple 1 :

Entrée : word = "abcde"
Sortie : "1a1b1c1d1e"
Explication :
Initialement, comp = "". Appliquez l'opération 5 fois, en choisissant "a", "b", "c", "d", et "e" comme préfixe à chaque opération.
Pour chaque préfixe, ajoutez "1" suivi du caractère à comp.

Exemple 2 :

Entrée : word = "aaaaaaaaaaaaaabb"
Sortie : "9a5a2b"
Explication :
Initialement, comp = "". Appliquez l'opération 3 fois, en choisissant "aaaaaaaaa", "aaaaa", et "bb" comme préfixe à chaque opération.

Pour le préfixe "aaaaaaaaa", ajoutez "9" suivi de "a" à comp.
Pour le préfixe "aaaaa", ajoutez "5" suivi de "a" à comp.
Pour le préfixe "bb", ajoutez "2" suivi de "b" à comp.

Contraintes :

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

Étant donné une chaîne de caractères word, compressez-la en utilisant l'algorithme suivant :

Commencez avec une chaîne vide comp. Tant que word n'est pas vide, utilisez l'opération suivante :

Retirez un préfixe de longueur maximale de word composé d'un seul caractère c se répétant au plus 9 fois.
Ajoutez la longueur du préfixe suivie de c à comp.

Renvoyez la chaîne comp.

Exemple 1 :

Input: word = "abcde"
Output: "1a1b1c1d1e"
Explication :
Initialement, comp = "". Appliquez l'opération 5 fois, en choisissant "a", "b", "c", "d", et "e" comme préfixe à chaque opération.
Pour chaque préfixe, ajoutez "1" suivi du caractère à comp.

Exemple 2 :

Input: word = "aaaaaaaaaaaaaabb"
Output: "9a5a2b"
Explication :
Initialement, comp = "". Appliquez l'opération 3 fois, en choisissant "aaaaaaaaa", "aaaaa", et "bb" comme préfixe à chaque opération.

Pour le préfixe "aaaaaaaaa", ajoutez "9" suivi de "a" à comp.
Pour le préfixe "aaaaa", ajoutez "5" suivi de "a" à comp.
Pour le préfixe "bb", ajoutez "2" suivi de "b" à comp.

Contraintes :

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

Étant donné une chaîne de caractères word, compressez-la en utilisant l'algorithme suivant :

Commencez avec une chaîne vide comp. Tant que word n'est pas vide, utilisez l'opération suivante :

Retirez un préfixe de longueur maximale de word composé d'un seul caractère c se répétant au plus 9 fois.
Ajoutez la longueur du préfixe suivie de c à comp.

Retournez la chaîne comp.

Exemple 1 :

Input: word = "abcde"
Output: "1a1b1c1d1e"
Explication :
Initialement, comp = "". Appliquez l'opération 5 fois, en choisissant "a", "b", "c", "d", et "e" comme préfixe à chaque opération.
Pour chaque préfixe, ajoutez "1" suivi du caractère à comp.

Exemple 2 :

Input: word = "aaaaaaaaaaaaaabb"
Output: "9a5a2b"
Explication :
Initialement, comp = "". Appliquez l'opération 3 fois, en choisissant "aaaaaaaaa", "aaaaa", et "bb" comme préfixe à chaque opération.

Pour le préfixe "aaaaaaaaa", ajoutez "9" suivi de "a" à comp.
Pour le préfixe "aaaaa", ajoutez "5" suivi de "a" à comp.
Pour le préfixe "bb", ajoutez "2" suivi de "b" à comp.

Contraintes :

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


On vous donne un tableau nums composé d'entiers. On vous donne également un tableau 2D de requêtes, où requêtes[i] = [pos_i, x_i].
Pour la requête i, nous mettons d'abord nums[pos_i] égal à x_i, puis nous calculons la réponse à la requête i qui est la somme maximale d'une sous-séquence de nums où aucun des deux éléments adjacents n'est sélectionné.
Retourner la somme des réponses à toutes les requêtes.
Comme la réponse finale peut être très grande, nous la retournons modulo 10^9 + 7.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains éléments ou aucun élément sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [3,5,9], queries = [[1,-2],[0,-3]]
Sortie : 21
Explication :
Après la 1^ère requête, nums = [3,-2,9] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 3 + 9 = 12.
Après la 2^e requête, nums = [-3,-2,9] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 9.

Exemple 2 :

Entrée : nums = [0,-1], queries = [[0,-5]]
Sortie : 0
Explication :
Après la 1^e requête, nums = [-5,-1] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 0 (choix d'une sous-séquence vide).

Contraintes :

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

On vous donne un tableau nums composé d'entiers. On vous donne également un tableau 2D queries, où queries[i] = [pos_i, x_i].
Pour la requête i, nous devons d'abord définir nums[pos_i] égal à x_i, puis calculer la réponse à la requête i qui est la somme maximale d'une sous-séquence de nums où aucun deux éléments adjacents ne sont sélectionnés.
Retournez la somme des réponses à toutes les requêtes.
Comme la réponse finale peut être très grande, retournez-la modulo 10^9 + 7.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains éléments ou aucun sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [3,5,9], queries = [[1,-2],[0,-3]]
Sortie : 21
Explication :
Après la 1ère requête, nums = [3,-2,9] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 3 + 9 = 12.
Après la 2ème requête, nums = [-3,-2,9] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 9.

Exemple 2 :

Entrée : nums = [0,-1], queries = [[0,-5]]
Sortie : 0
Explication :
Après la 1ère requête, nums = [-5,-1] et la somme maximale d'une sous-séquence avec des éléments non adjacents est 0 (en choisissant une sous-séquence vide).

Contraintes :

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5


Étant donné une chaîne de caractères \( s \), vous devez la partitionner en une ou plusieurs sous-chaînes équilibrées. Par exemple, si \( s == "ababcc" \) alors ("abab", "c", "c"), ("ab", "abc", "c") et ("ababcc") sont toutes des partitions valides, mais ("a", "bab", "cc"), ("aba", "bc", "c") et ("ab", "abcc") ne le sont pas. Les sous-chaînes déséquilibrées sont en gras.
Retournez le nombre minimum de sous-chaînes dans lesquelles vous pouvez partitionner \( s \).
Remarque : Une chaîne équilibrée est une chaîne dans laquelle chaque caractère apparaît le même nombre de fois.

Exemple 1 :

Input: s = "fabccddg"
Output: 3
Explication :
Nous pouvons partitionner la chaîne \( s \) en 3 sous-chaînes de l'une des manières suivantes : ("fab", "ccdd", "g"), ou ("fabc", "cd", "dg").

Exemple 2 :

Input: s = "abababaccddb"
Output: 2
Explication :
Nous pouvons partitionner la chaîne \( s \) en 2 sous-chaînes comme suit : ("abab", "abaccddb").

Contraintes :

1 <= s.length <= 1000
\( s \) est composé uniquement de lettres minuscules de l'alphabet anglais.

Étant donné une chaîne de caractères \( s \), vous devez la partitionner en une ou plusieurs sous-chaînes équilibrées. Par exemple, si \( s == "ababcc" \) alors ("abab", "c", "c"), ("ab", "abc", "c") et ("ababcc") sont toutes des partitions valides, mais ("a", "bab", "cc"), ("aba", "bc", "c") et ("ab", "abcc") ne le sont pas. Les sous-chaînes déséquilibrées sont mises en gras.
Retournez le nombre minimum de sous-chaînes dans lesquelles vous pouvez partitionner \( s \).
Remarque : Une chaîne équilibrée est une chaîne dans laquelle chaque caractère apparaît le même nombre de fois.

Exemple 1 :

Entrée : s = "fabccddg"
Sortie : 3
Explication :
Nous pouvons diviser la chaîne \( s \) en 3 sous-chaînes de l'une des manières suivantes : ("fab", "ccdd", "g"), ou ("fabc", "cd", "dg").

Exemple 2 :

Entrée : s = "abababaccddb"
Sortie : 2
Explication :
Nous pouvons diviser la chaîne \( s \) en 2 sous-chaînes comme suit : ("abab", "abaccddb").

Contraintes :

1 <= s.length <= 1000
\( s \) est composé uniquement de lettres minuscules anglaises.

Étant donné une chaîne s, vous devez la partitionner en une ou plusieurs sous-chaînes équilibrées. Par exemple, si s == "ababcc" alors ("abab", "c", "c"), ("ab", "abc", "c") et ("ababcc") sont toutes des partitions valides, mais ("a", "bab", "cc"), ("aba", "bc", "c") et ("ab", "abcc") ne le sont pas. Les sous-chaînes non équilibrées sont en gras.
Renvoie le nombre minimum de sous-chaînes dans lesquelles vous pouvez partitionner s.
Remarque : une chaîne équilibrée est une chaîne dans laquelle chaque caractère de la chaîne apparaît le même nombre de fois.

Exemple 1 :

Entrée : s = "fabccddg"
Sortie : 3
Explication :
Nous pouvons partitionner la chaîne s en 3 sous-chaînes de l'une des manières suivantes : ("fab", "ccdd", "g"), ou ("fabc", "cd", "dg").

Exemple 2 :

Entrée : s = "abababaccddb"
Sortie : 2
Explication :
Nous pouvons partitionner la chaîne s en 2 sous-chaînes comme suit : ("abab", "abaccddb").

Contraintes :

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


Un tableau puissant pour un entier x est le tableau trié le plus court de puissances de deux dont la somme est égale à x. Par exemple, le tableau puissant pour 11 est [1, 2, 8].
Le tableau big_nums est créé en concaténant les tableaux puissants pour chaque entier positif i dans l'ordre croissant : 1, 2, 3, etc. Ainsi, big_nums commence par [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
On vous donne une matrice d'entiers 2D queries, où pour queries[i] = [from_i, to_i, mod_i] vous devez calculer (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Renvoie un tableau d'entiers answer tel que answer[i] soit la réponse à la i^ème requête.

Exemple 1 :

Entrée : queries = [[1,3,7]]
Sortie : [4]
Explication :
Il y a une requête.
big_nums[1..3] = [2,1,2]. Le produit des deux est 4. Le reste de 4 sous 7 est 4.

Exemple 2 :

Entrée : queries = [[2,5,3],[7,7,4]]
Sortie : [2,2]
Explication :
Il y a deux requêtes.
Première requête : big_nums[2..5] = [1,2,4,1]. Le produit de ces deux nombres est 8. Le reste de 8 sous 3 est 2.
Deuxième requête : big_nums[7] = 2. Le reste de 2 sous 4 est 2.

Contraintes :

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5

Un tableau puissant pour un entier x est le plus court tableau trié de puissances de deux qui somme à x. Par exemple, le tableau puissant pour 11 est [1, 2, 8].
Le tableau big_nums est créé en concaténant les tableaux puissants pour chaque entier positif i dans l'ordre croissant : 1, 2, 3, et ainsi de suite. Ainsi, big_nums commence par [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
On vous donne des requêtes de matrice entière en 2D, où pour queries[i] = [from_i, to_i, mod_i] vous devez calculer (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Rentrons une réponse de tableau d'entiers tel que answer[i] soit la réponse à la i^ème requête.

Exemple 1 :

Entrée: requêtes = [[1,3,7]]
Sortie: [4]
Explication :
Il y a une requête.
big_nums[1..3] = [2,1,2]. Leur produit est 4. Le reste de 4 sous 7 est 4.

Exemple 2 :

Entrée: requêtes = [[2,5,3],[7,7,4]]
Sortie: [2,2]
Explication :
Il y a deux requêtes.
Première requête : big_nums[2..5] = [1,2,4,1]. Leur produit est 8. Le reste de 8 sous 3 est 2.
Deuxième requête : big_nums[7] = 2. Le reste de 2 sous 4 est 2.

Contraintes :

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5

Un tableau puissant pour un entier x est le plus court tableau trié de puissances de deux dont la somme est égale à x. Par exemple, le tableau puissant pour 11 est [1, 2, 8].
Le tableau big_nums est créé en concaténant les tableaux puissants pour chaque entier positif i dans l'ordre croissant : 1, 2, 3, et ainsi de suite. Ainsi, big_nums commence par [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
On vous donne une matrice entière queries en 2D, où pour queries[i] = [from_i, to_i, mod_i] vous devez calculer (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Retournez un tableau d'entiers answer tel que answer[i] soit la réponse à la i^ème requête.

Exemple 1 :

Input: queries = [[1,3,7]]
Output: [4]
Explication :
Il y a une requête.
big_nums[1..3] = [2,1,2]. Le produit est 4. Le reste de 4 modulo 7 est 4.

Exemple 2 :

Input: queries = [[2,5,3],[7,7,4]]
Output: [2,2]
Explication :
Il y a deux requêtes.
Première requête : big_nums[2..5] = [1,2,4,1]. Le produit est 8. Le reste de 8 modulo 3 est 2.
Deuxième requête : big_nums[7] = 2. Le reste de 2 modulo 4 est 2.

Contraintes :

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5


On vous donne un tableau nums, où chaque nombre dans le tableau apparaît soit une fois, soit deux fois.
Retournez le résultat du XOR bit à bit de tous les nombres qui apparaissent deux fois dans le tableau, ou 0 si aucun nombre n'apparaît deux fois.

Exemple 1 :

Entrée : nums = [1,2,1,3]
Sortie : 1
Explication :
Le seul nombre qui apparaît deux fois dans nums est 1.

Exemple 2 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication :
Aucun nombre n'apparaît deux fois dans nums.

Exemple 3 :

Entrée : nums = [1,2,2,1]
Sortie : 3
Explication :
Les nombres 1 et 2 apparaissent deux fois. 1 XOR 2 == 3.

Contraintes :

1 <= nums.length <= 50
1 <= nums[i] <= 50
Chaque nombre dans nums apparaît soit une fois, soit deux fois.

On vous donne un tableau nums, où chaque nombre dans le tableau apparaît soit une fois, soit deux fois. Renvoyez le résultat du XOR bit à bit de tous les nombres qui apparaissent deux fois dans le tableau, ou 0 si aucun nombre n'apparaît deux fois.

Exemple 1 :

Entrée : nums = [1,2,1,3]
Sortie : 1
Explication :
Le seul nombre qui apparaît deux fois dans nums est 1.

Exemple 2 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication :
Aucun nombre n'apparaît deux fois dans nums.

Exemple 3 :

Entrée : nums = [1,2,2,1]
Sortie : 3
Explication :
Les nombres 1 et 2 apparaissent deux fois. 1 XOR 2 == 3.

Contraintes :

1 <= nums.length <= 50
1 <= nums[i] <= 50
Chaque nombre dans nums apparaît soit une fois, soit deux fois.

On vous donne un tableau nums, où chaque nombre du tableau apparaît une ou deux fois.
Renvoie le XOR au niveau du bit de tous les nombres qui apparaissent deux fois dans le tableau, ou 0 si aucun nombre n'apparaît deux fois.

Exemple 1 :

Entrée : nums = [1,2,1,3]
Sortie : 1
Explication :
Le seul nombre qui apparaît deux fois dans nums est 1.

Exemple 2 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication :
Aucun nombre n'apparaît deux fois dans nums.

Exemple 3 :

Entrée : nums = [1,2,2,1]
Sortie : 3
Explication :
Les nombres 1 et 2 sont apparus deux fois. 1 XOR 2 == 3.

Contraintes :

1 <= nums.length <= 50
1 <= nums[i] <= 50
Chaque nombre dans nums apparaît une ou deux fois.


On vous donne un  tableau d'entiers nums, d'un tableau d'entiers queries, et d'un entier x.
Pour chaque queries[i], vous devez trouver l'indice de la queries[i]^ème occurrence de x dans le tableau nums. S'il y a moins de queries[i] occurrences de x, la réponse doit être -1 pour cette requête.
Retournez un tableau d'entiers contenant les réponses à toutes les requêtes.

Exemple 1 :

Entrée : nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Sortie : [0,-1,2,-1]
Explication :

Pour la 1^ère requête, la première occurrence de 1 est à l'indice 0.
Pour la 2^ème requête, il n'y a que deux occurrences de 1 dans nums, la réponse est donc -1.
Pour la 3^ème requête, la deuxième occurrence de 1 est à l'indice 2.
Pour la 4^ème requête, il n'y a que deux occurrences de 1 dans nums, la réponse est donc -1.

Exemple 2 :

Entrée : nums = [1,2,3], queries = [10], x = 5
Sortie : [-1]
Explication :

Pour la 1^ère requête, 5 n'existe pas dans nums, donc la réponse est -1.

Contraintes :

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4

Vous disposez d'un tableau d'entiers nums, d'un tableau d'entiers queries, et d'un entier x.
Pour chaque queries[i], vous devez trouver l'indice de la queries[i]^ème occurrence de x dans le tableau nums. S'il y a moins de queries[i] occurrences de x, la réponse doit être -1 pour cette requête.
Retournez un tableau d'entiers contenant les réponses à toutes les requêtes.

Exemple 1 :

Entrée : nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Sortie : [0,-1,2,-1]
Explication :

Pour la 1^ère requête, la première occurrence de 1 est à l'indice 0.
Pour la 2^ème requête, il n'y a que deux occurrences de 1 dans nums, la réponse est donc -1.
Pour la 3^ème requête, la deuxième occurrence de 1 est à l'indice 2.
Pour la 4^ème requête, il n'y a que deux occurrences de 1 dans nums, la réponse est donc -1.

Exemple 2 :

Entrée : nums = [1,2,3], queries = [10], x = 5
Sortie : [-1]
Explication :

Pour la 1^ère requête, 5 n'existe pas dans nums, donc la réponse est -1.

Contraintes :

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4


Vous recevez des entiers positifs N, L et R.
Pour une séquence A = (1, 2, \dots, N) de longueur N, une opération de renversement des éléments de L à R a été effectuée une fois.
Imprimez la séquence après cette opération.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N L R

Sortie

Soit A' = (A'_1, A'_2, \dots, A'_N) la séquence après l'opération. Affichez-la dans le format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \leq L \leq R \leq N \leq 100

Exemple d'entrée 1

5 2 3

Exemple de sortie 1

1 3 2 4 5

Initialement, A = (1, 2, 3, 4, 5).
Après avoir inversé les deuxièmes à troisièmes éléments, la séquence devient (1, 3, 2, 4, 5), qui doit être affichée.

Exemple d'entrée 2

7 1 1

Exemple de sortie 2

1 2 3 4 5 6 7

Il est possible que L = R.

Exemple d'entrée 3

10 1 10

Exemple de sortie 3

10 9 8 7 6 5 4 3 2 1

Il est possible que L = 1 ou R = N.

Vous recevez des entiers positifs N, L et R.
Pour une séquence A = (1, 2, \dots, N) de longueur N, une opération de renversement des éléments de L à R a été effectuée une fois.
Affichez la séquence après cette opération.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N L R

Sortie

Soit A' = (A'_1, A'_2, \dots, A'_N) la séquence après l'opération. Affichez-la dans le format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \leq L \leq R \leq N \leq 100

Exemple d'entrée 1

5 2 3

Exemple de sortie 1

1 3 2 4 5

Initialement, A = (1, 2, 3, 4, 5).
Après avoir inversé les deuxièmes à troisièmes éléments, la séquence devient (1, 3, 2, 4, 5), qui doit être affichée.

Exemple d'entrée 2

7 1 1

Exemple de sortie 2

1 2 3 4 5 6 7

Il est possible que L = R.

Exemple d'entrée 3

10 1 10

Exemple de sortie 3

10 9 8 7 6 5 4 3 2 1

Il est possible que L = 1 ou R = N.

On donne des entiers positifs N, L et R.
Pour une séquence A = (1, 2, \dots, N) de longueur N, une opération d'inversion des éléments de L à R a été effectuée une fois.
Imprimez la séquence après cette opération.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N L R

Sortie

Soit A' = (A'_1, A'_2, \dots, A'_N) la séquence après l'opération. Affichez-la dans le format suivant :
A'_1 A'_2 \dots A'_N

Contraintes

- Toutes les valeurs d'entrée sont des entiers.
- 1 \leq L \leq R \leq N \leq 100

Exemple d'entrée 1

5 2 3

Exemple de sortie 1

1 3 2 4 5

Initialement, A = (1, 2, 3, 4, 5).
Après avoir inversé les deuxièmes à troisièmes éléments, la séquence devient (1, 3, 2, 4, 5), qui doit être affichée.

Exemple d'entrée 2

7 1 1

Exemple de sortie 2

1 2 3 4 5 6 7

Il est possible que L = R.

Exemple d'entrée 3

10 1 10

Exemple de sortie 3

10 9 8 7 6 5 4 3 2 1

Il est possible que L = 1 ou R = N.


Étant donné des entiers N et M, calculer la somme \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M), modulo 998244353.
Ici, \mathbin{\&} représente l'opération bit à bit \rm{AND}.
Qu'est-ce que l'opération bit à bit \rm{AND} ?
Le résultat x = a \mathbin{\&} b de l'opération bit à bit \rm{AND} entre des entiers non négatifs a et b est défini comme suit :

- x est l'unique entier non négatif qui satisfait aux conditions suivantes pour tous les entiers non négatifs k :

- Si la 2^k place dans la représentation binaire de a et la 2^k place dans la représentation binaire de b sont toutes deux 1, alors la 2^k place dans la représentation binaire de x est 1.
- Sinon, la 2^k place dans la représentation binaire de x est 0.

Par exemple, 3=11_{(2)} et 5=101_{(2)}, donc 3 \mathbin{\&} 5 = 1.

Qu'est-ce que \rm{popcount} ?
\rm{popcount}(x) représente le nombre de 1 dans la représentation binaire de x.
Par exemple, 13=1101_{(2)}, donc \rm{popcount}(13) = 3.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N M

Sortie

Affiche la réponse sous la forme d'un nombre entier.

Contraintes

- N est un entier compris entre 0 et 2^{60} - 1, inclus.
- M est un nombre entier compris entre 0 et 2^{60} - 1, inclus.

Exemple d'entrée 1

4 3

Exemple de sortie 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

La somme de ces valeurs est de 4.
Exemple d'entrée 2

0 0

Échantillon de sortie 2

0

Il est possible que N = 0 ou M = 0.

Exemple d'entrée 3

1152921504606846975 1152921504606846975

Exemple de sortie 3

499791890

N'oubliez pas de calculer le résultat modulo 998244353.

Étant donné des entiers N et M, calculez la somme \displaystyle \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M), modulo 998244353.
Ici, \mathbin{\&} représente l'opération \rm{AND} binaire.
Qu'est-ce que l'opération \rm{AND} binaire ?
Le résultat x = a \mathbin{\&} b de l'opération \rm{AND} binaire entre les entiers non négatifs a et b est défini comme suit :

- x est l'unique entier non négatif qui satisfait les conditions suivantes pour tous les entiers non négatifs k :

- Si le chiffre 2^k dans la représentation binaire de a et le chiffre 2^k dans la représentation binaire de b sont tous deux 1, alors le chiffre 2^k dans la représentation binaire de x est 1.
- Sinon, le chiffre 2^k dans la représentation binaire de x est 0.

Par exemple, 3=11_{(2)} et 5=101_{(2)}, donc 3 \mathbin{\&} 5 = 1.

Qu'est-ce que \rm{popcount} ?
\rm{popcount}(x) représente le nombre de 1 dans la représentation binaire de x.
Par exemple, 13=1101_{(2)}, donc \rm{popcount}(13) = 3.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant :
N M

Sortie

Affichez la réponse en tant qu'entier.

Contraintes

- N est un entier compris entre 0 et 2^{60} - 1, inclus.
- M est un entier compris entre 0 et 2^{60} - 1, inclus.

Exemple d'entrée 1

4 3

Exemple de sortie 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

La somme de ces valeurs est 4.

Exemple d'entrée 2

0 0

Exemple de sortie 2

0

Il est possible que N = 0 ou M = 0.

Exemple d'entrée 3

1152921504606846975 1152921504606846975

Exemple de sortie 3

499791890

N'oubliez pas de calculer le résultat modulo 998244353.

Étant donné des entiers N et M, calculez la somme \displaystyle \sum_{k=0}^{N} \rm{popcount}(k \mathbin{\&} M), modulo 998244353.
Ici, \mathbin{\&} représente l'opération \rm{ET} binaire.
Qu'est-ce que l'opération \rm{ET} binaire ?
Le résultat x = a \mathbin{\&} b de l'opération \rm{ET} binaire entre les entiers non négatifs a et b est défini comme suit :

- x est l'unique entier non négatif qui satisfait les conditions suivantes pour tous les entiers non négatifs k :

- Si le chiffre 2^k dans la représentation binaire de a et le chiffre 2^k dans la représentation binaire de b sont tous deux 1, alors le chiffre 2^k dans la représentation binaire de x est 1.
- Sinon, le chiffre 2^k dans la représentation binaire de x est 0.

Par exemple, 3=11_{(2)} et 5=101_{(2)}, donc 3 \mathbin{\&} 5 = 1.

Qu'est-ce que \rm{popcount} ?
\rm{popcount}(x) représente le nombre de 1 dans la représentation binaire de x.
Par exemple, 13=1101_{(2)}, donc \rm{popcount}(13) = 3.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant :
N M

Sortie

Affichez la réponse en tant qu'entier.

Contraintes

- N est un entier compris entre 0 et 2^{60} - 1, inclus.
- M est un entier compris entre 0 et 2^{60} - 1, inclus.

Exemple d'entrée 1

4 3

Exemple de sortie 1

4

- \rm{popcount}(0\mathbin{\&}3) = 0
- \rm{popcount}(1\mathbin{\&}3) = 1
- \rm{popcount}(2\mathbin{\&}3) = 1
- \rm{popcount}(3\mathbin{\&}3) = 2
- \rm{popcount}(4\mathbin{\&}3) = 0

La somme de ces valeurs est 4.

Exemple d'entrée 2

0 0

Exemple de sortie 2

0

Il est possible que N = 0 ou M = 0.

Exemple d'entrée 3

1152921504606846975 1152921504606846975

Exemple de sortie 3

499791890

N'oubliez pas de calculer le résultat modulo 998244353.


On vous donne une séquence A=(A_1,\ldots,A_N) de longueur N.
Trouvez \displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^{N}\left\lfloor\frac{\max(A_i,A_j)}{\min(A_i,A_j)}\right\rfloor.
Ici, \lfloor x \rfloor représente le plus grand entier inférieur ou égal à x. Par exemple, \lfloor 3.14 \rfloor=3 et \lfloor 2 \rfloor=2.

Entrée

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

Sortie

Imprimez la réponse.

Contraintes

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

3
3 1 4

Exemple de sortie 1

8

La valeur recherchée est
\left\lfloor\frac{\max(3,1)}{\min(3,1)}\right\rfloor + \left\lfloor\frac{\max(3,4)}{\min(3,4)}\right\rfloor + \left\lfloor\frac{\max(1,4)}{\min(1,4)}\right\rfloor\ =\left\lfloor\frac{3}{1}\right\rfloor + \left\lfloor\frac{4}{3}\right\rfloor + \left\lfloor\frac{4}{1}\right\rfloor\ =3+1+4\ =8.

Exemple d'entrée 2

6
2 7 1 8 2 8

Exemple de sortie 2

53

Exemple d'entrée 3

12
3 31 314 3141 31415 314159 2 27 271 2718 27182 271828

Exemple de sortie 3

592622

On vous donne une séquence A=(A_1,\ldots,A_N) de longueur N.
Trouvez \displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^{N}\left\lfloor\frac{\max(A_i,A_j)}{\min(A_i,A_j)}\right\rfloor.
Ici, \lfloor x \rfloor représente le plus grand entier inférieur ou égal à x. Par exemple, \lfloor 3.14 \rfloor=3 et \lfloor 2 \rfloor=2.

Entrée

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

Sortie

Affichez la réponse.

Contraintes

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

Exemple d'entrée 1

3
3 1 4

Exemple de sortie 1

8

La valeur recherchée est
\left\lfloor\frac{\max(3,1)}{\min(3,1)}\right\rfloor + \left\lfloor\frac{\max(3,4)}{\min(3,4)}\right\rfloor + \left\lfloor\frac{\max(1,4)}{\min(1,4)}\right\rfloor\\ =\left\lfloor\frac{3}{1}\right\rfloor + \left\lfloor\frac{4}{3}\right\rfloor + \left\lfloor\frac{4}{1}\right\rfloor\\ =3+1+4\\ =8.

Exemple d'entrée 2

6
2 7 1 8 2 8

Exemple de sortie 2

53

Exemple d'entrée 3

12
3 31 314 3141 31415 314159 2 27 271 2718 27182 271828

Exemple de sortie 3

592622

On vous donne une séquence A=(A_1,\ldots,A_N) de longueur N.
Trouvez \displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^{N}\left\lfloor\frac{\max(A_i,A_j)}{\min(A_i,A_j)}\right\rfloor.
Ici, \lfloor x \rfloor représente le plus grand entier inférieur ou égal à x. Par exemple, \lfloor 3.14 \rfloor=3 et \lfloor 2 \rfloor=2.

Entrée

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

Sortie

Affichez la réponse.

Contraintes

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

Exemple d'entrée 1

3
3 1 4

Exemple de sortie 1

8

La valeur recherchée est
\left\lfloor\frac{\max(3,1)}{\min(3,1)}\right\rfloor + \left\lfloor\frac{\max(3,4)}{\min(3,4)}\right\rfloor + \left\lfloor\frac{\max(1,4)}{\min(1,4)}\right\rfloor\\ =\left\lfloor\frac{3}{1}\right\rfloor + \left\lfloor\frac{4}{3}\right\rfloor + \left\lfloor\frac{4}{1}\right\rfloor\\ =3+1+4\\ =8.

Exemple d'entrée 2

6
2 7 1 8 2 8

Exemple de sortie 2

53

Exemple d'entrée 3

12
3 31 314 3141 31415 314159 2 27 271 2718 27182 271828

Exemple de sortie 3

592622


Vous avez N clés numérotées de 1 à N.
Certaines sont de vraies clés, tandis que les autres sont des fausses.
Il y a une porte, Porte X, dans laquelle vous pouvez insérer n'importe quel nombre de clés. La Porte X s'ouvrira si et seulement si au moins K vraies clés sont insérées.
Vous avez effectué M tests sur ces clés. Le i-ième test s'est déroulé comme suit :

- Vous avez inséré C_i clés A_{i,1}, A_{i,2}, \dots, A_{i,C_i} dans la Porte X.
- Le résultat du test est représenté par une seule lettre anglaise R_i.
- R_i = o signifie que la Porte X s'est ouverte lors du i-ième test.
- R_i = x signifie que la Porte X ne s'est pas ouverte lors du i-ième test.

Il y a 2^N combinaisons possibles qui indiquent quelles clés sont réelles et lesquelles sont fausses. Parmi celles-ci, trouvez le nombre de combinaisons qui ne contredisent aucun des résultats des tests.
Il est possible que les résultats des tests soient incorrects et qu'aucune combinaison ne satisfasse les conditions. Dans ce cas, indiquez 0.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
C_1 A_{1,1} A_{1,2} \dots A_{1,C_1} R_1
C_2 A_{2,1} A_{2,2} \dots A_{2,C_2} R_2
\vdots
C_M A_{M,1} A_{M,2} \dots A_{M,C_M} R_M

Sortie

Affichez la réponse sous forme d'entier.

Contraintes

- N, M, K, C_i, et A_{i,j} sont des entiers.
- 1 \le K \le N \le 15
- 1 \le M \le 100
- 1 \le C_i \le N
- 1 \le A_{i,j} \le N
- A_{i,j} \neq A_{i,k} si j \neq k.
- R_i est o ou x.

Exemple d'entrée 1

3 2 2
3 1 2 3 o
2 2 3 x

Exemple de sortie 1

2

Dans cet exemple, il y a trois clés et deux tests ont été effectués.
Deux clés correctes sont nécessaires pour ouvrir la Porte X.

- Lors du premier test, les clés 1, 2, 3 ont été utilisées et la Porte X s'est ouverte.
- Lors du second test, les clés 2 et 3 ont été utilisées et la Porte X ne s'est pas ouverte.

Il y a deux combinaisons de clés réelles et fausses qui ne contredisent aucun des résultats des tests :

- La clé 1 est réelle, la clé 2 est une fausse et la clé 3 est réelle.
- La clé 1 est réelle, la clé 2 est réelle et la clé 3 est une fausse.

Exemple d'entrée 2

4 5 3
3 1 2 3 o
3 2 3 4 o
3 3 4 1 o
3 4 1 2 o
4 1 2 3 4 x

Exemple de sortie 2

0

Comme mentionné dans l'énoncé du problème, la réponse peut être 0.

Exemple d'entrée 3

11 4 9
10 1 2 3 4 5 6 7 8 9 10 o
11 1 2 3 4 5 6 7 8 9 10 11 o
10 11 10 9 8 7 6 5 4 3 2 x
10 11 9 1 4 3 7 5 6 2 10 x

Exemple de sortie 3

8

Vous disposez de N clés numérotées 1, 2, points, N.
Certaines d'entre elles sont de vraies clés, tandis que les autres sont des leurres.
Il existe une porte, la porte X, dans laquelle vous pouvez insérer un nombre quelconque de clés. La porte X s'ouvrira si et seulement si au moins K clés réelles sont insérées.
Vous avez effectué M tests sur ces clés. Le i-ième test s'est déroulé comme suit :

- Vous avez inséré les clés C_i A_{i,1}, A_{i,2}, \dots, A_{i,C_i} dans la porte X.
- Le résultat du test est représenté par une seule lettre anglaise, R_i.
- R_i = o signifie que la porte X s'est ouverte lors du i-ème test.
- R_i = x signifie que la porte X ne s'est pas ouverte lors du i-ème test.

Il existe 2^N combinaisons possibles de clés réelles et de clés factices. Parmi celles-ci, trouvez le nombre de combinaisons qui ne contredisent aucun des résultats du test.
Il est possible que les résultats des tests donnés soient incorrects et qu'aucune combinaison ne satisfasse aux conditions. Dans ce cas, indiquez 0.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
C_1 A_{1,1} A_{1,2} \dots A_{1,C_1} R_1
C_2 A_{2,1} A_{2,2} \dots A_{2,C_2} R_2
\vdots
C_M A_{M,1} A_{M,2} \dots A_{M,C_M} R_M

Sortie

Affiche la réponse sous la forme d'un nombre entier.

Contraintes

- N, M, K, C_i, and A_{i,j} are integers.
- 1 \le K \le N \le 15
- 1 \le M \le 100
- 1 \le C_i \le N
- 1 \le A_{i,j} \le N
- A_{i,j} \neq A_{i,k} if j \neq k.
- R_i is o or x.

Exemple d'entrée 1

3 2 2
3 1 2 3 o
2 2 3 x

Exemple de sortie 1

2

Dans cet exemple, il y a trois clés et deux tests ont été effectués. Deux clés correctes sont nécessaires pour ouvrir la Porte X.

- Lors du premier essai, les clés 1, 2 et 3 ont été utilisées et la porte X s'est ouverte.
- Lors du deuxième essai, les clés 2, 3 ont été utilisées et la porte X ne s'est pas ouverte.

Il y a deux combinaisons de clés réelles et fausses qui ne contredisent aucun des résultats des tests :

- La clé 1 est réelle, la clé 2 est factice et la clé 3 est réelle.
- La clé 1 est réelle, la clé 2 est réelle et la clé 3 est factice.

Exemple d'entrée 2

4 5 3
3 1 2 3 o
3 2 3 4 o
3 3 4 1 o
3 4 1 2 o
4 1 2 3 4 x

Exemple de sortie 2

0

Comme mentionné dans l'énoncé du problème, la réponse peut être 0.

Exemple d'entrée 3

11 4 9
10 1 2 3 4 5 6 7 8 9 10 o
11 1 2 3 4 5 6 7 8 9 10 11 o
10 11 10 9 8 7 6 5 4 3 2 x
10 11 9 1 4 3 7 5 6 2 10 x

Exemple de sortie 3

8

Vous avez N clés numérotées de 1 à N.
Certaines sont de vraies clés, tandis que les autres sont des fausses.
Il y a une porte, Porte X, dans laquelle vous pouvez insérer n'importe quel nombre de clés. La Porte X s'ouvrira si et seulement si au moins K vraies clés sont insérées.
Vous avez effectué M tests sur ces clés. Le i-ième test s'est déroulé comme suit :

- Vous avez inséré C_i clés A_{i,1}, A_{i,2}, \dots, A_{i,C_i} dans la Porte X.
- Le résultat du test est représenté par une seule lettre anglaise R_i.
- R_i = o signifie que la Porte X s'est ouverte lors du i-ième test.
- R_i = x signifie que la Porte X ne s'est pas ouverte lors du i-ième test.

Il y a 2^N combinaisons possibles qui indiquent quelles clés sont réelles et quelles sont des fausses. Parmi celles-ci, trouvez le nombre de combinaisons qui ne contredisent aucun des résultats des tests.
Il est possible que les résultats des tests soient incorrects et qu'aucune combinaison ne satisfasse les conditions. Dans ce cas, indiquez 0.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
C_1 A_{1,1} A_{1,2} \dots A_{1,C_1} R_1
C_2 A_{2,1} A_{2,2} \dots A_{2,C_2} R_2
\vdots
C_M A_{M,1} A_{M,2} \dots A_{M,C_M} R_M

Sortie

Affichez la réponse sous forme d'entier.

Contraintes

- N, M, K, C_i, et A_{i,j} sont des entiers.
- 1 \le K \le N \le 15
- 1 \le M \le 100
- 1 \le C_i \le N
- 1 \le A_{i,j} \le N
- A_{i,j} \neq A_{i,k} si j \neq k.
- R_i est o ou x.

Exemple d'entrée 1

3 2 2
3 1 2 3 o
2 2 3 x

Exemple de sortie 1

2

Dans cet exemple, il y a trois clés et deux tests ont été effectués.
Deux clés correctes sont nécessaires pour ouvrir la Porte X.

- Lors du premier test, les clés 1, 2, 3 ont été utilisées et la Porte X s'est ouverte.
- Lors du second test, les clés 2 et 3 ont été utilisées et la Porte X ne s'est pas ouverte.

Il y a deux combinaisons de clés réelles et fausses qui ne contredisent aucun des résultats des tests :

- La clé 1 est réelle, la clé 2 est une fausse et la clé 3 est réelle.
- La clé 1 est réelle, la clé 2 est réelle et la clé 3 est une fausse.

Exemple d'entrée 2

4 5 3
3 1 2 3 o
3 2 3 4 o
3 3 4 1 o
3 4 1 2 o
4 1 2 3 4 x

Exemple de sortie 2

0

Comme mentionné dans l'énoncé du problème, la réponse peut être 0.

Exemple d'entrée 3

11 4 9
10 1 2 3 4 5 6 7 8 9 10 o
11 1 2 3 4 5 6 7 8 9 10 11 o
10 11 10 9 8 7 6 5 4 3 2 x
10 11 9 1 4 3 7 5 6 2 10 x

Exemple de sortie 3

8


Takahashi est soucieux de sa santé et se demande s'il consomme suffisamment de M types de nutriments dans son alimentation.
Pour le i-ème nutriment, son objectif est de consommer au moins A_i unités par jour.
Aujourd'hui, il a mangé N aliments, et pour le i-ème aliment, il a consommé X_{i,j} unités de nutriment j.
Déterminez s'il a atteint l'objectif pour les M types de nutriments.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
A_1 \ldots A_M
X_{1,1} \ldots X_{1,M}
\vdots
X_{N,1} \ldots X_{N,M}

Sortie

Affichez Yes si l'objectif est atteint pour tous les M types de nutriments, et No sinon.

Contraintes

- 1 \leq N \leq 100
- 1 \leq M \leq 100
- 0 \leq A_i, X_{i,j} \leq 10^7
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 3
10 20 30
20 0 10
0 100 100

Exemple de sortie 1

Yes

Pour le nutriment 1, Takahashi a consommé 20 unités du 1er aliment et 0 unités du 2e aliment, totalisant 20 unités, atteignant ainsi l'objectif de consommer au moins 10 unités.
De même, il atteint l'objectif pour les nutriments 2 et 3.

Exemple d'entrée 2

2 4
10 20 30 40
20 0 10 30
0 100 100 0

Exemple de sortie 2

No

L'objectif n'est pas atteint pour le nutriment 4.

Takahashi est soucieux de sa santé et se demande s'il obtient suffisamment de M types de nutriments dans son alimentation.
Pour le i-ème nutriment, son objectif est de consommer au moins A_i unités par jour.
Aujourd'hui, il a mangé N aliments, et pour le i-ème aliment, il a consommé X_{i,j} unités de nutriment j.
Déterminez s'il a atteint l'objectif pour les M types de nutriments.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
A_1 \ldots A_M
X_{1,1} \ldots X_{1,M}
\vdots
X_{N,1} \ldots X_{N,M}

Sortie

Affichez Yes si l'objectif est atteint pour tous les M types de nutriments, et No sinon.

Contraintes

- 1 \leq N \leq 100
- 1 \leq M \leq 100
- 0 \leq A_i, X_{i,j} \leq 10^7
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 3
10 20 30
20 0 10
0 100 100

Exemple de sortie 1

Yes

Pour le nutriment 1, Takahashi a consommé 20 unités du 1er aliment et 0 unités du 2e aliment, totalisant 20 unités, atteignant ainsi l'objectif de consommer au moins 10 unités.
De même, il atteint l'objectif pour les nutriments 2 et 3.

Exemple d'entrée 2

2 4
10 20 30 40
20 0 10 30
0 100 100 0

Exemple de sortie 2

No

L'objectif n'est pas atteint pour le nutriment 4.

Takahashi est soucieux de sa santé et se demande s'il reçoit suffisamment de nutriments de type M dans son alimentation.
Pour le i-ème nutriment, son objectif est de prendre au moins A_i unités par jour.
Aujourd'hui, il a mangé N aliments et, pour le i-ème aliment, il a pris X_{i,j} unités du nutriment j.
Déterminez s'il a atteint l'objectif pour tous les types de nutriments M.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M
A_1 \ldots A_M
X_{1,1} \ldots X_{1,M}
\vdots
X_{N,1} \ldots X_{N,M}

Sortie

Imprimez Oui si l'objectif est atteint pour tous les types de nutriments M, et Non sinon.

Contraintes

- 1 \leq N \leq 100
- 1 \leq M \leq 100
- 0 \leq A_i, X_{i,j} \leq 10^7
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 3
10 20 30
20 0 10
0 100 100

Exemple de sortie 1

Yes

Pour le nutriment 1, Takahashi a pris 20 unités du 1er aliment et 0 unité du 2e aliment, soit un total de 20 unités, atteignant ainsi l'objectif de prendre au moins 10 unités.
De même, il atteint l'objectif pour les nutriments 2 et 3.

Exemple d'entrée 2

2 4
10 20 30 40
20 0 10 30
0 100 100 0

Exemple de sortie 2

No

L'objectif n'est pas atteint pour le nutriment 4.


Pour un entier non négatif K, nous définissons un tapis de niveau K comme suit :

- Un tapis de niveau 0 est une grille 1 \times 1 constituée d'une seule cellule noire.
- Pour K > 0, un tapis de niveau K est une grille 3^K \times 3^K. Lorsque cette grille est divisée en neuf blocs de 3^{K-1} \times 3^{K-1} :
  - Le bloc central est entièrement composé de cellules blanches.
  - Les huit autres blocs sont des tapis de niveau (K-1).

Vous recevez un entier non négatif N.
Affichez un tapis de niveau N selon le format spécifié.

Entrée

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

Sortie

Affichez 3^N lignes.
La i-ème ligne (1 \leq i \leq 3^N) doit contenir une chaîne S_i de longueur 3^N composée de . et #.
Le j-ème caractère de S_i (1 \leq j \leq 3^N) doit être # si la cellule située à la i-ème ligne depuis le haut et à la j-ème colonne depuis la gauche d'un tapis de niveau N est noire, et . si elle est blanche.

Contraintes

- 0 \leq N \leq 6
- N est un entier.

Exemple d'entrée 1

1

Exemple de sortie 1

###
#.#
###

Un tapis de niveau 1 est une grille 3 \times 3 comme suit :

Lorsqu'il est affiché selon le format spécifié, il ressemble à l'exemple de sortie.

Exemple d'entrée 2

2

Exemple de sortie 2

#########
#.##.##.#
#########
###...###
#.#...#.#
###...###
#########
#.##.##.#
#########

Un tapis de niveau 2 est une grille 9 \times 9.

Pour un entier non négatif K, nous définissons un tapis de niveau K comme suit :

- Un tapis de niveau 0 est une grille de 1 fois 1 composée d'une seule cellule noire.
- Pour K > 0, un tapis de niveau K est une grille 3^K fois 3^K. Lorsque cette grille est divisée en neuf blocs 3^{K-1} \ fois 3^{K-1} :
- Le bloc central est entièrement constitué de cellules blanches.
- Les huit autres blocs sont des tapis de niveau (K-1).

On vous donne un nombre entier non négatif N.
Imprime un tapis de niveau N selon le format spécifié.

Entrée

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

Sortie

Imprimer 3^N lignes.
La i-ième ligne (1 \leq i \leq 3^N) doit contenir une chaîne S_i de longueur 3^N composée de . et #.
Le jème caractère de S_i (1 \leq j \leq 3^N) doit être # si la cellule de la ième ligne en partant du haut et de la jème colonne en partant de la gauche d'un tapis de niveau N est noire, et . si elle est blanche.

Contraintes

- 0 \leq N \leq 6
- N est un nombre entier.

Exemple d'entrée 1

1

Exemple de sortie 1

###
#.#
###

Un tapis de niveau 1 est une grille de 3 \times 3 comme suit :

Lorsqu'il est édité selon le format spécifié, il ressemble à l'exemple d'édition.

Exemple d'entrée 2

2

Exemple de sortie 2

#########
#.##.##.#
#########
###...###
#.#...#.#
###...###
#########
#.##.##.#
#########

Un tapis de niveau 2 est une grille 9 \times 9.


Il y a une bouteille de désinfectant qui peut désinfecter exactement M mains.
N aliens viennent un par un pour désinfecter leurs mains.
Le i-ème alien (1 \leq i \leq N) a H_i mains et souhaite désinfecter toutes ses mains une fois.
Déterminez combien d'aliens peuvent désinfecter toutes leurs mains.
Ici, même s'il ne reste pas assez de désinfectant pour qu'un alien désinfecte toutes ses mains quand il commence, il utilisera le reste du désinfectant.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
H_1 H_2 \ldots H_N

Sortie

Affichez le nombre d'aliens qui peuvent désinfecter toutes leurs mains.

Contraintes

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5 10
2 3 2 5 3

Exemple de sortie 1

3

Les aliens désinfectent leurs mains selon les étapes suivantes :

- Le premier alien désinfecte ses deux mains. Le désinfectant restant peut désinfecter 10-2=8 mains.
- Le deuxième alien désinfecte ses trois mains. Le désinfectant restant peut désinfecter 8-3=5 mains.
- Le troisième alien désinfecte ses deux mains. Le désinfectant restant peut désinfecter 5-2=3 mains.
- Le quatrième alien a cinq mains, mais il ne reste assez de désinfectant que pour trois mains, donc il utilise le désinfectant sans désinfecter toutes ses mains.

Ainsi, les trois premiers aliens peuvent désinfecter toutes leurs mains, donc affichez 3.

Exemple d'entrée 2

5 10
2 3 2 3 5

Exemple de sortie 2

4

Exemple d'entrée 3

1 5
1

Exemple de sortie 3

1

Tous les aliens peuvent désinfecter leurs mains.

Il y a une bouteille de désinfectant qui peut désinfecter exactement M mains.
N aliens viennent un par un pour désinfecter leurs mains.
Le i-ème alien (1 \leq i \leq N) a H_i mains et souhaite désinfecter toutes ses mains une fois.
Déterminez combien d'aliens peuvent désinfecter toutes leurs mains.
Ici, même s'il ne reste pas assez de désinfectant pour qu'un alien désinfecte toutes ses mains quand il commence, il utilisera le reste du désinfectant.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
H_1 H_2 \ldots H_N

Sortie

Affichez le nombre d'aliens qui peuvent désinfecter toutes leurs mains.

Contraintes

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5 10
2 3 2 5 3

Exemple de sortie 1

3

Les aliens désinfectent leurs mains dans les étapes suivantes :

- Le premier alien désinfecte ses deux mains. Le désinfectant restant peut désinfecter 10-2=8 mains.
- Le deuxième alien désinfecte ses trois mains. Le désinfectant restant peut désinfecter 8-3=5 mains.
- Le troisième alien désinfecte ses deux mains. Le désinfectant restant peut désinfecter 5-2=3 mains.
- Le quatrième alien a cinq mains, mais il ne reste assez de désinfectant que pour trois mains, donc il utilise le désinfectant sans désinfecter toutes ses mains.

Ainsi, les trois premiers aliens peuvent désinfecter toutes leurs mains, donc affichez 3.

Exemple d'entrée 2

5 10
2 3 2 3 5

Exemple de sortie 2

4

Exemple d'entrée 3

1 5
1

Exemple de sortie 3

1

Tous les aliens peuvent désinfecter leurs mains.

Il y a une bouteille de désinfectant qui peut désinfecter exactement M mains.
N aliens viennent un par un pour se désinfecter les mains.
Le i-ème alien (1 \leq i \leq N) a H_i mains et veut désinfecter toutes ses mains une fois.
Déterminez combien d'aliens peuvent désinfecter toutes leurs mains.
Ici, même s'il ne reste pas assez de désinfectant pour qu'un alien puisse désinfecter toutes ses mains lorsqu'il commence, il utilisera le désinfectant restant.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M
H_1 H_2 \ldots H_N

Sortie

Afficher le nombre d'aliens qui peuvent désinfecter toutes leurs mains.

Contraintes

- 1 \leq N, M \leq 100
- 1 \leq H_i \leq 100
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

5 10
2 3 2 5 3

Exemple de sortie 1

3

Les extraterrestres se désinfectent les mains en procédant comme suit :

- Le premier extraterrestre désinfecte ses deux mains. Le désinfectant restant peut désinfecter 10-2=8 mains.
- Le deuxième extraterrestre désinfecte ses trois mains. Le désinfectant restant peut désinfecter 8-3=5 mains.
- Le troisième extraterrestre désinfecte ses deux mains. Le désinfectant restant peut désinfecter 5-2=3 mains.
- Le quatrième extraterrestre a cinq mains, mais il n'y a assez de désinfectant que pour trois mains, donc il utilise le désinfectant sans désinfecter toutes ses mains.

Ainsi, les trois premiers extraterrestres peuvent désinfecter toutes leurs mains, donc imprimez 3.

Exemple d'entrée 2

5 10
2 3 2 3 5

Exemple de sortie 2

4

Exemple d'entrée 3

1 5
1

Exemple de sortie 3

1

Tous les extraterrestres peuvent se désinfecter les mains.


Pour un entier positif N, soit V_N l'entier formé en concaténant N exactement N fois.
Plus précisément, considérez N comme une chaîne de caractères, concaténez N copies de celle-ci et traitez le résultat comme un entier pour obtenir V_N.
Par exemple, V_3=333 et V_{10}=10101010101010101010.
Trouvez le reste lorsque V_N est divisé par 998244353.

Entrée

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

Sortie

Affichez le reste lorsque V_N est divisé par 998244353.

Contraintes

- 1 \leq N \leq 10^{18}
- N est un entier.

Exemple d'entrée 1

5

Exemple de sortie 1

55555

Le reste lorsque V_5=55555 est divisé par 998244353 est 55555.

Exemple d'entrée 2

9

Exemple de sortie 2

1755646

Le reste lorsque V_9=999999999 est divisé par 998244353 est 1755646.

Exemple d'entrée 3

10000000000

Exemple de sortie 3

468086693

Notez que l'entrée peut ne pas tenir dans un type entier 32 bits.

Pour un entier positif N, soit V_N l'entier formé en concaténant N exactement N fois.
Plus précisément, considérez N comme une chaîne, concaténez-en N copies et traitez le résultat comme un entier pour obtenir V_N.
Par exemple, V_3=333 et V_{10}=10101010101010101010.
Trouver le reste lorsque V_N est divisé par 998244353.

Entrée

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

Sortie

Imprimer le reste lorsque V_N est divisé par 998244353.

Contraintes

- 1 \leq N \leq 10^{18}
- N est un entier.

Exemple d'entrée 1

5

Exemple de sortie 1

55555

Le reste lorsque V_5=55555 est divisé par 998244353 est 55555.

Exemple d'entrée 2

9

Exemple de sortie 2

1755646

Le reste lorsque V_9=999999999 est divisé par 998244353 est 1755646.

Exemple d'entrée 3

10000000000

Exemple de sortie 3

468086693

Notez que l'entrée peut ne pas correspondre à un type entier 32 bits.


Vous avez une chaîne S composée de lettres anglaises majuscules et minuscules. La longueur de S est impaire.
Si le nombre de lettres majuscules dans S est supérieur au nombre de lettres minuscules, convertissez toutes les lettres minuscules de S en majuscules.
Sinon, convertissez toutes les lettres majuscules de S en minuscules.

Entrée

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

Sortie

Affichez la chaîne S après avoir converti les lettres selon l'énoncé du problème.

Contraintes

- S est une chaîne composée de lettres anglaises majuscules et minuscules.
- La longueur de S est un nombre impair entre 1 et 99, inclus.

Exemple d'entrée 1

AtCoder

Exemple de sortie 1

atcoder

La chaîne AtCoder contient cinq lettres minuscules et deux lettres majuscules. Ainsi, convertissez toutes les lettres majuscules dans AtCoder en minuscules, ce qui donne atcoder.

Exemple d'entrée 2

SunTORY

Exemple de sortie 2

SUNTORY

La chaîne SunTORY contient deux lettres minuscules et cinq lettres majuscules. Ainsi, convertissez toutes les lettres minuscules dans SunTORY en majuscules, ce qui donne SUNTORY.

Exemple d'entrée 3

a

Exemple de sortie 3

a

On vous donne une chaîne S composée de lettres anglaises minuscules et majuscules. La longueur de S est impaire.
Si le nombre de lettres majuscules dans S est supérieur au nombre de lettres minuscules, convertissez toutes les lettres minuscules de S en majuscules.
Sinon, convertissez toutes les lettres majuscules de S en minuscules.

Entrée

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

Sortie

Imprimez la chaîne S après avoir converti les lettres conformément à l'énoncé du problème.

Contraintes

- S est une chaîne composée de lettres anglaises minuscules et majuscules.
- La longueur de S est un nombre impair compris entre 1 et 99, inclus.

Exemple d'entrée 1

AtCoder

Exemple de sortie 1

atcoder

La chaîne AtCoder contient cinq lettres minuscules et deux lettres majuscules. Ainsi, convertissez toutes les lettres majuscules de AtCoder en minuscules, ce qui donne atcoder.

Exemple d'entrée 2

SunTORY

Exemple de sortie 2

SUNTORY

La chaîne SunTORY contient deux lettres minuscules et cinq lettres majuscules. Ainsi, convertissez toutes les lettres minuscules de SunTORY en majuscules, ce qui donne SUNTORY.

Exemple d'entrée 3

a

Exemple de sortie 3

a


Il y a un graphe orienté avec N sommets numérotés de 1 à N et N arêtes.
Le degré de sortie de chaque sommet est 1, et l'arête depuis le sommet i pointe vers le sommet a_i.
Comptez le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u.
Ici, le sommet v est accessible depuis le sommet u s'il existe une séquence de sommets w_0, w_1, \dots, w_K de longueur K+1 qui satisfait les conditions suivantes. En particulier, si u = v, il est toujours accessible.

- w_0 = u.
- w_K = v.
- Pour tout 0 \leq i \lt K, il existe une arête du sommet w_i au sommet w_{i+1}.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N
a_1 a_2 \dots a_N

Sortie

Affichez le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u.

Contraintes

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

Exemple d'entrée 1

4
2 1 1 4

Exemple de sortie 1

8

Les sommets accessibles depuis le sommet 1 sont les sommets 1, 2.
Les sommets accessibles depuis le sommet 2 sont les sommets 1, 2.
Les sommets accessibles depuis le sommet 3 sont les sommets 1, 2, 3.
Le sommet accessible depuis le sommet 4 est le sommet 4.
Par conséquent, le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u est 8.
Notez que l'arête depuis le sommet 4 est une boucle, c'est-à-dire qu'elle pointe vers le sommet 4 lui-même.

Exemple d'entrée 2

5
2 4 3 1 2

Exemple de sortie 2

14

Exemple d'entrée 3

10
6 10 4 1 5 9 8 6 5 1

Exemple de sortie 3

41

Il existe un graphe orienté avec N sommets numérotés de 1 à N et N arêtes.
Le degré de sortie de chaque sommet est de 1, et l'arête du sommet i pointe vers le sommet a_i.
Comptez le nombre de paires de sommets (u, v) telles que le sommet v est accessible depuis le sommet u.
Le sommet v est accessible à partir du sommet u s'il existe une séquence de sommets w_0, w_1, \dots, w_K de longueur K+1 qui satisfait aux conditions suivantes. En particulier, si u = v, il est toujours atteignable.

- w_0 = u.
- w_K = v.
- Pour chaque 0 \leq i \lt K, il existe une arête entre le sommet w_i et le sommet w_{i+1}.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
a_1 a_2 \dots a_N

Sortie

Affiche le nombre de paires de sommets (u, v) telles que le sommet v est accessible depuis le sommet u.

Contraintes

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

Exemple d'entrée 1

4
2 1 1 4

Exemple de sortie 1

8

Les sommets accessibles à partir du sommet 1 sont les sommets 1, 2.
Les sommets accessibles à partir du sommet 2 sont les sommets 1, 2.
Les sommets accessibles à partir du sommet 3 sont les sommets 1, 2, 3.
Le sommet accessible à partir du sommet 4 est le sommet 4.
Par conséquent, le nombre de paires de sommets (u, v) telles que le sommet v est accessible depuis le sommet u est de 8.
Notez que l'arête du sommet 4 est une boucle automatique, c'est-à-dire qu'elle pointe vers le sommet 4 lui-même.

Exemple d'entrée 2

5
2 4 3 1 2

Exemple de sortie 2

14

Exemple d'entrée 3

10
6 10 4 1 5 9 8 6 5 1

Échantillon de sortie 3

41

On a un graphe orienté avec N sommets numérotés de 1 à N et N arêtes.
Le degré de sortie de chaque sommet est 1, et l'arête depuis le sommet i pointe vers le sommet a_i.
Comptez le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u.
Ici, le sommet v est accessible depuis le sommet u s'il existe une séquence de sommets w_0, w_1, \dots, w_K de longueur K+1 qui satisfait les conditions suivantes. En particulier, si u = v, il est toujours accessible.

- w_0 = u.
- w_K = v.
- Pour tout 0 \leq i \lt K, il existe une arête du sommet w_i au sommet w_{i+1}.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N
a_1 a_2 \dots a_N

Sortie

Affichez le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u.

Contraintes

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

Exemple d'entrée 1

4
2 1 1 4

Exemple de sortie 1

8

Les sommets accessibles depuis le sommet 1 sont les sommets 1, 2.
Les sommets accessibles depuis le sommet 2 sont les sommets 1, 2.
Les sommets accessibles depuis le sommet 3 sont les sommets 1, 2, 3.
Le sommet accessible depuis le sommet 4 est le sommet 4.
Par conséquent, le nombre de paires de sommets (u, v) telles que le sommet v soit accessible depuis le sommet u est 8.
Notez que l'arête depuis le sommet 4 est une boucle, c'est-à-dire qu'elle pointe vers le sommet 4 lui-même.

Exemple d'entrée 2

5
2 4 3 1 2

Exemple de sortie 2

14

Exemple d'entrée 3

10
6 10 4 1 5 9 8 6 5 1

Exemple de sortie 3

41


AtCoder Land vend des tuiles avec des lettres anglaises inscrites dessus. Takahashi envisage de créer une plaque nominative en disposant ces tuiles en ligne.

Trouver le nombre, modulo 998244353, de chaînes composées de lettres majuscules anglaises de longueur entre 1 et K, inclus, qui satisfont les conditions suivantes :

- Pour chaque entier i satisfaisant 1 \leq i \leq 26, il est vrai que :
- Soit a_i la i-ème lettre majuscule anglaise dans l'ordre lexicographique. Par exemple, a_1 = A, a_5 = E, a_{26} = Z.
- Le nombre d'occurrences de a_i dans la chaîne est compris entre 0 et C_i, inclus.

Entrée

L'entrée est donnée depuis Standard Input dans le format suivant :
K
C_1 C_2 \ldots C_{26}

Sortie

Affichez la réponse.

Contraintes

- 1 \leq K \leq 1000
- 0 \leq C_i \leq 1000
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2
2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Exemple de sortie 1

10

Les 10 chaînes qui satisfont les conditions sont A, B, C, AA, AB, AC, BA, BC, CA, CB.

Exemple d'entrée 2

358
1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Exemple de sortie 2

64

Exemple d'entrée 3

1000
1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000

Exemple de sortie 3

270274035

AtCoder Land vend des tuiles avec des lettres anglaises inscrites dessus. Takahashi envisage de créer une plaque nominative en disposant ces tuiles en ligne.

Trouver le nombre, modulo 998244353, de chaînes composées de lettres majuscules anglaises avec une longueur entre 1 et K, inclusivement, qui satisfont les conditions suivantes :

- Pour chaque entier i satisfaisant 1 \leq i \leq 26, il est vrai que :
- Soit a_i la i-ème lettre majuscule anglaise dans l'ordre lexicographique. Par exemple, a_1 = A, a_5 = E, a_{26} = Z.
- Le nombre d'occurrences de a_i dans la chaîne est compris entre 0 et C_i, inclusivement.

Entrée

L'entrée est donnée depuis Standard Input dans le format suivant :
K
C_1 C_2 \ldots C_{26}

Sortie

Affichez la réponse.

Contraintes

- 1 \leq K \leq 1000
- 0 \leq C_i \leq 1000
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2
2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Exemple de sortie 1

10

Les 10 chaînes qui satisfont les conditions sont A, B, C, AA, AB, AC, BA, BC, CA, CB.

Exemple d'entrée 2

358
1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Exemple de sortie 2

64

Exemple d'entrée 3

1000
1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000

Exemple de sortie 3

270274035

AtCoder Land vend des tuiles sur lesquelles sont inscrites des lettres anglaises. Takahashi envisage de fabriquer une plaque d'identification en alignant ces tuiles.

Trouver le nombre, modulo 998244353, de chaînes composées de lettres anglaises majuscules d'une longueur comprise entre 1 et K inclus, qui satisfont aux conditions suivantes :

- Pour tout entier i satisfaisant 1 \leq i \leq 26, ce qui suit est vrai :
- Soit a_i la i-ième lettre anglaise majuscule dans l'ordre lexicographique. Par exemple, a_1 = A, a_5 = E, a_{26} = Z.
- Le nombre d'occurrences de a_i dans la chaîne est compris entre 0 et C_i, inclus.

Saisir

L'entrée est donnée à partir de l'entrée standard dans le format suivant:
K
C_1 C_2 \ldots C_ {26}

Sortir

Imprimez la réponse.

Contraintes

- 1 \leq K \leq 1000
- 0 \leq C_i \leq 1000
- Toutes les valeurs d'entrée sont des entiers.

Échantillon d'entrée 1

2
2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Échantillon de sortie 1

10

Les 10 chaînes qui satisfont aux conditions sont A, B, C, AA, AB, AC, BA, BC, CA, CB.

Échantillon d'entrée 2

358
1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Échantillon de sortie 2

64

Exemple d'entrée 3

1000
1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000

Exemple de sortie 3

270274035