On vous donne un tableau de montagnes indexé à 0. Votre tâche consiste à trouver tous les sommets du tableau de montagnes.
Renvoyer un tableau composé d'indices de sommets dans le tableau donné dans n'importe quel ordre.
Remarques :

Un sommet est défini comme un élément strictement supérieur à ses éléments voisins.
Le premier et le dernier élément du tableau ne sont pas un sommet.

Exemple 1 :

Entrée : montagne = [2,4,4]
Sortie : []
Explication : montagne[0] et montagne[2] ne peuvent pas être un sommet car ils sont le premier et le dernier éléments du tableau.
montagne[1] ne peut pas non plus être un sommet car il n'est pas strictement supérieur à montagne[2].
La réponse est donc [].

Exemple 2 :

Entrée : mountain = [1,4,3,8,5]
Sortie : [1,3]
Explication : montagne[0] et montagne[4] ne peuvent pas être un sommet car ils sont le premier et le dernier éléments du tableau.
mountain[2] ne peut pas non plus être un sommet car il n'est pas strictement supérieur à mountain[3] et mountain[1].
Mais mountain[1] et mountain[3] sont strictement supérieurs à leurs éléments voisins.
La réponse est donc [1,3].

Contraintes :

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Vous avez un tableau moutain indexé à partir de 0. Votre tâche est de trouver tous les pics dans le tableau mountain.
Retournez un tableau qui contient les indices des pics dans le tableau donné dans n'importe quel ordre.
Remarques :

Un pic est défini comme un élément qui est strictement supérieur à ses éléments voisins.
Les premiers et derniers éléments du tableau ne sont pas un pic.

Exemple 1 :

Entrée : mountain = [2,4,4]
Sortie : []
Explication : mountain[0] et mountain[2] ne peuvent pas être un pic car ils sont les premiers et derniers éléments du tableau.
mountain[1] ne peut pas être un pic car il n'est pas strictement supérieur à mountain[2].
Donc la réponse est [].

Exemple 2 :

Entrée : mountain = [1,4,3,8,5]
Sortie : [1,3]
Explication : mountain[0] et mountain[4] ne peuvent pas être un pic car ils sont les premiers et derniers éléments du tableau.
mountain[2] ne peut pas non plus être un pic car il n'est pas strictement supérieur à mountain[3] et mountain[1].
Mais mountain[1] et mountain[3] sont strictement supérieurs à leurs éléments voisins.
Donc la réponse est [1,3].

Contraintes :

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Vous avez un tableau indexé à partir de 0 nommé mountain. Votre tâche est de trouver tous les pics dans le tableau mountain. Retournez un tableau qui contient les indices des pics dans le tableau donné dans n'importe quel ordre. Remarques :

Un pic est défini comme un élément qui est strictement supérieur à ses éléments voisins.
Les premiers et derniers éléments du tableau ne sont pas un pic.

Exemple 1 :

Input: mountain = [2,4,4]
Output: []
Explication : mountain[0] et mountain[2] ne peuvent pas être un pic car ils sont les premiers et derniers éléments du tableau.
mountain[1] ne peut pas être un pic car il n'est pas strictement supérieur à mountain[2].
Donc la réponse est [].

Exemple 2 :

Input: mountain = [1,4,3,8,5]
Output: [1,3]
Explication : mountain[0] et mountain[4] ne peuvent pas être un pic car ils sont les premiers et derniers éléments du tableau.
mountain[2] ne peut pas non plus être un pic car il n'est pas strictement supérieur à mountain[3] et mountain[1].
Mais mountain[1] et mountain[3] sont strictement supérieurs à leurs éléments voisins.
Donc la réponse est [1,3].

Contraintes :

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


Vous avez une chaîne de caractères word et un entier k.
Une sous-chaîne s de word est complète si :

Chaque caractère dans s apparaît exactement k fois.
La différence entre deux caractères adjacents est au plus 2. C'est-à-dire que, pour deux caractères adjacents c1 et c2 dans s, la différence absolue de leurs positions dans l'alphabet est au plus 2.

Retournez le nombre de sous-chaînes complètes de word.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : word = "igigee", k = 2
Sortie : 3
Explication : les sous-chaînes complètes où chaque caractère apparaît exactement deux fois et la différence entre les caractères adjacents est au plus 2 sont : igigee, igigee, igigee.

Exemple 2 :

Entrée : word = "aaabbbccc", k = 3
Sortie : 6
Explication : les sous-chaînes complètes où chaque caractère apparaît exactement trois fois et la différence entre les caractères adjacents est au plus 2 sont : aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Contraintes :

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

Vous avez un mot de chaîne et un entier k.
Une substrat de mot est complète si:

Chaque caractère dans s se produit exactement k fois.
La différence entre deux caractères adjacents est au plus 2. C'est-à-dire que pour deux caractères adjacents c1 et c2 en s, la différence absolue dans leurs positions dans l'alphabet est au plus 2.

Renvoie le nombre de sous-chaînes complètes de mot.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1:

Entrée: word = "igigee", k = 2
Sortie: 3
Explication: Les sous-chaînes complètes où chaque caractère apparaît exactement deux fois et la différence entre les caractères adjacentes est au plus 2 sont: igigee, igigee, igigee.

Exemple 2:

Entrée: word = "aaabbbccc", k = 3
Sortie: 6
Explication: Les sous-chaînes complètes où chaque caractère apparaît exactement trois fois et La différence entre les caractères adjacents est au plus 2 sont: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Contraintes:

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

Vous avez une chaîne de caractères word et un entier k.
Une sous-chaîne s de word est complète si :

Chaque caractère dans s apparaît exactement k fois.
La différence entre deux caractères adjacents est au plus 2. C'est-à-dire que, pour deux caractères adjacents c1 et c2 dans s, la différence absolue de leurs positions dans l'alphabet est au plus 2.

Retournez le nombre de sous-chaînes complètes de word.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : word = "igigee", k = 2
Sortie : 3
Explication : Les sous-chaînes complètes où chaque caractère apparaît exactement deux fois et la différence entre les caractères adjacents est au plus 2 sont : igigee, igigee, igigee.

Exemple 2 :

Entrée : word = "aaabbbccc", k = 3
Sortie : 6
Explication : Les sous-chaînes complètes où chaque caractère apparaît exactement trois fois et la différence entre les caractères adjacents est au plus 2 sont : aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Contraintes :

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


On considère un entier n et un tableau d'entiers sick indexé à partir de 0 qui est trié par ordre croissant.
Il y a n enfants debout dans une file avec des positions allant de 0 à n - 1 qui leur sont attribuées. Le tableau sick contient les positions des enfants qui sont infectés par une maladie infectieuse. Un enfant infecté à la position i peut transmettre la maladie à l'un de ses enfants voisins immédiats aux positions i - 1 et i + 1 s'ils existent et ne sont actuellement pas infectés. Au maximum un enfant qui n'était pas infecté auparavant peut être infecté par la maladie en une seconde.
On peut montrer qu'après un nombre fini de secondes, tous les enfants dans la file seront infectés par la maladie. Une séquence d'infection est l'ordre séquentiel des positions dans lesquelles tous les enfants non infectés sont infectés par la maladie. Retournez le nombre total de séquences d'infection possibles.
Étant donné que la réponse peut être grande, retournez-la modulo 10^9 + 7.
Notez qu'une séquence d'infection ne contient pas les positions des enfants qui étaient déjà infectés par la maladie au début.

Exemple 1 :

Entrée : n = 5, sick = [0,4]
Sortie : 4
Explication : Les enfants aux positions 1, 2 et 3 ne sont pas infectés au début. Il y a 4 séquences d'infection possibles :
- Les enfants aux positions 1 et 3 peuvent être infectés puisque leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant à la position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc n'importe lequel d'entre eux peut être infecté. L'enfant à la position 2 est infecté.
Enfin, l'enfant à la position 3 est infecté car il est adjacent aux enfants aux positions 2 et 4 qui sont infectés. La séquence d'infection est [1,2,3].
- Les enfants aux positions 1 et 3 peuvent être infectés car leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant à la position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc n'importe lequel d'entre eux peut être infecté. L'enfant à la position 3 est infecté.
Enfin, l'enfant à la position 2 est infecté car il est adjacent aux enfants aux positions 1 et 3 qui sont infectés. La séquence d'infection est [1,3,2].
- La séquence d'infection est [3,1,2]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- La séquence d'infection est [3,2,1]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Exemple 2 :

Entrée : n = 4, sick = [1]
Sortie : 3
Explication : Les enfants aux positions 0, 2 et 3 ne sont pas infectés au début. Il y a 3 séquences d'infection possibles :
- La séquence d'infection est [0,2,3]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La séquence d'infection est [2,0,3]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La séquence d'infection est [2,3,0]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Contraintes :

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick est trié par ordre croissant.

Étant donné un entier n et un tableau d'entiers à indice 0 sick qui est trié par ordre croissant.
Il y a n enfants debout dans une file avec des positions allant de 0 à n - 1 qui leur sont attribuées. Le tableau sick contient les positions des enfants qui sont infectés par une maladie infectieuse. Un enfant infecté à la position i peut transmettre la maladie à l'un de ses enfants voisins immédiats aux positions i - 1 et i + 1 s'ils existent et ne sont actuellement pas infectés. Au maximum un enfant qui n'était pas infecté auparavant peut être infecté par la maladie en une seconde.
On peut montrer qu'après un nombre fini de secondes, tous les enfants dans la file seront infectés par la maladie. Une séquence d'infection est l'ordre séquentiel des positions dans lesquelles tous les enfants non infectés sont infectés par la maladie. Retournez le nombre total de séquences d'infection possibles.
Étant donné que la réponse peut être grande, retournez-la modulo 10^9 + 7.
Notez qu'une séquence d'infection ne contient pas les positions des enfants qui étaient déjà infectés par la maladie au début.

Exemple 1 :

Entrée : n = 5, sick = [0,4]
Sortie : 4
Explication : Les enfants aux positions 1, 2 et 3 ne sont pas infectés au début. Il y a 4 séquences d'infection possibles :
- Les enfants aux positions 1 et 3 peuvent être infectés puisque leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant à la position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc n'importe lequel d'entre eux peut être infecté. L'enfant à la position 2 est infecté.
Enfin, l'enfant à la position 3 est infecté car il est adjacent aux enfants aux positions 2 et 4 qui sont infectés. La séquence d'infection est [1,2,3].
- Les enfants aux positions 1 et 3 peuvent être infectés car leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant à la position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc n'importe lequel d'entre eux peut être infecté. L'enfant à la position 3 est infecté.
Enfin, l'enfant à la position 2 est infecté car il est adjacent aux enfants aux positions 1 et 3 qui sont infectés. La séquence d'infection est [1,3,2].
- La séquence d'infection est [3,1,2]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- La séquence d'infection est [3,2,1]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Exemple 2 :

Entrée : n = 4, sick = [1]
Sortie : 3
Explication : Les enfants aux positions 0, 2 et 3 ne sont pas infectés au début. Il y a 3 séquences d'infection possibles :
- La séquence d'infection est [0,2,3]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La séquence d'infection est [2,0,3]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- La séquence d'infection est [2,3,0]. L'ordre d'infection de la maladie chez les enfants peut être vu comme : [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Contraintes :

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick est trié par ordre croissant.

On vous donne un entier N et un réseau entier indexé à 0 sick qui est trié par ordre croissant.
Il y a n enfants debout dans une file d'attente avec des positions 0 à n - 1 qui leur sont attribuées. La maladie sick contient les positions des enfants infectés par une maladie infectieuse. Un enfant infecté en position i peux répandre la maladie à l'un de ses enfants voisins immédiats aux positions i - 1 et i + 1 s'ils existent et ne sont actuellement pas infectés. Au plus, un enfant qui n'était pas infecté auparavant peut être infecté par la maladie en une seconde.
On peut montrer qu'après un nombre fini de secondes, tous les enfants de la file d'attente seront infectés par la maladie. Une séquence d'infection est l'ordre séquentiel des positions dans lesquelles tous les enfants non infectés sont infectés par la maladie. Renvoie le nombre total de séquences d'infection possibles.
Étant donné que la réponse peut être grande, retournez-le modulo 10^9 + 7.
Notez qu'une séquence d'infection ne contient pas de positions d'enfants déjà infectées par la maladie au début.

Exemple 1:

Entrée: n = 5, sick = [0,4]
Sortie: 4
Explication: Les enfants aux positions 1, 2 et 3 ne sont pas infectés au début. Il y a 4 séquences d'infection possibles:
- Les enfants aux positions 1 et 3 peuvent être infectés car leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant à la position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc l'un ou l'autre peut être infecté. L'enfant à la position 2 est infecté.
Enfin, l'enfant à la position 3 est infecté car il est adjacent aux enfants aux positions 2 et 4 qui sont infectés. La séquence d'infection est [1,2,3].
- Les enfants aux positions 1 et 3 peuvent être infectés parce que leurs positions sont adjacentes aux enfants infectés 0 et 4. L'enfant en position 1 est infecté en premier.
Maintenant, l'enfant à la position 2 est adjacent à l'enfant à la position 1 qui est infecté et l'enfant à la position 3 est adjacent à l'enfant à la position 4 qui est infecté, donc l'un ou l'autre peut être infecté. L'enfant à la position 3 est infecté.
Enfin, l'enfant à la position 2 est infecté car il est adjacent aux enfants aux positions 1 et 3 qui sont infectés. La séquence d'infection est [1,3,2].
- La séquence d'infection est [3,1,2]. L'ordre d'infection de la maladie chez les enfants peut être considéré comme: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].
- La séquence d'infection est [3,2,1]. L'ordre d'infection de la maladie chez les enfants peut être considéré comme: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].

Exemple 2:

Entrée: n = 4, sick = [1]
Sortie: 3
Explication: Les enfants aux positions 0, 2 et 3 ne sont pas infectés au début. Il y a 3 séquences d'infection possibles:
- La séquence d'infection est [0,2,3]. L'ordre d'infection de la maladie chez les enfants peut être considéré comme: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- La séquence d'infection est [2,0,3]. L'ordre d'infection de la maladie chez les enfants peut être considéré comme: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- La séquence d'infection est [2,3,0]. L'ordre d'infection de la maladie chez les enfants peut être considéré comme: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].

Contraintes:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick est classé par ordre croissant.


On vous donne un tableau d'entiers `nums` et un entier `k`.
La fréquence d'un élément `x` est le nombre de fois qu'il apparaît dans un tableau.
Un tableau est appelé "bon" si la fréquence de chaque élément dans ce tableau est inférieure ou égale à `k`.
Renvoyez la longueur du plus long sous-tableau bon de `nums`.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,2,3,1,2,3,1,2], k = 2
Sortie : 6
Explication : Le plus long sous-tableau bon possible est [1,2,3,1,2,3] car les valeurs 1, 2 et 3 apparaissent au maximum deux fois dans ce sous-tableau. Notez que les sous-tableaux [2,3,1,2,3,1] et [3,1,2,3,1,2] sont également bons.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 6.

Exemple 2 :

Entrée : nums = [1,2,1,2,1,2,1,2], k = 1
Sortie : 2
Explication : Le plus long sous-tableau bon possible est [1,2] car les valeurs 1 et 2 apparaissent au maximum une fois dans ce sous-tableau. Notez que le sous-tableau [2,1] est également bon.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 2.

Exemple 3 :

Entrée : nums = [5,5,5,5,5,5,5], k = 4
Sortie : 4
Explication : Le plus long sous-tableau bon possible est [5,5,5,5] car la valeur 5 apparaît 4 fois dans ce sous-tableau.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 4.

Contraintes :

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

On vous donne un tableau d'entiers nums et un entier k.
La fréquence d'un élément x est le nombre de fois qu'il apparaît dans un tableau.
Un tableau est dit bon si la fréquence de chaque élément de ce tableau est inférieure ou égale à k.
Renvoie la longueur du sous-tableau le plus long et bon de nums.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,2,3,1,2,3,1,2], k = 2
Sortie : 6
Explication : Le sous-tableau le plus long et bon possible est [1,2,3,1,2,3] puisque les valeurs 1, 2 et 3 apparaissent au plus deux fois dans ce sous-tableau. Notez que les sous-tableaux [2,3,1,2,3,1] et [3,1,2,3,1,2] sont également bons.
Il est possible de montrer qu'il n'existe aucun sous-tableau correct dont la longueur soit supérieure à 6.

Exemple 2 :

Entrée : nums = [1,2,1,2,1,2,1,2], k = 1
Sortie : 2
Explication : Le sous-tableau correct le plus long possible est [1,2] puisque les valeurs 1 et 2 apparaissent au plus une fois dans ce sous-tableau. Notez que le sous-tableau [2,1] est également correct.
Il est possible de montrer qu'il n'existe aucun sous-tableau correct dont la longueur soit supérieure à 2.

Exemple 3 :

Entrée : nums = [5,5,5,5,5,5,5], k = 4
Sortie : 4
Explication : Le sous-tableau correct le plus long possible est [5,5,5,5] puisque la valeur 5 apparaît 4 fois dans ce sous-tableau.
Il peut être démontré qu'il n'existe pas de bons sous-tableaux dont la longueur soit supérieure à 4.

Contraintes :

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

Vous avez un tableau d'entiers nums et un entier k.
La fréquence d'un élément x est le nombre de fois qu'il apparaît dans un tableau.
Un tableau est appelé bon si la fréquence de chaque élément dans ce tableau est inférieure ou égale à k.
Retournez la longueur du plus long sous-tableau bon de nums.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,2,3,1,2,3,1,2], k = 2
Sortie : 6
Explication : Le plus long sous-tableau bon possible est [1,2,3,1,2,3] car les valeurs 1, 2 et 3 apparaissent au maximum deux fois dans ce sous-tableau. Notez que les sous-tableaux [2,3,1,2,3,1] et [3,1,2,3,1,2] sont également bons.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 6.

Exemple 2 :

Entrée : nums = [1,2,1,2,1,2,1,2], k = 1
Sortie : 2
Explication : Le plus long sous-tableau bon possible est [1,2] car les valeurs 1 et 2 apparaissent au maximum une fois dans ce sous-tableau. Notez que le sous-tableau [2,1] est également bon.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 2.

Exemple 3 :

Entrée : nums = [5,5,5,5,5,5,5], k = 4
Sortie : 4
Explication : Le plus long sous-tableau bon possible est [5,5,5,5] car la valeur 5 apparaît 4 fois dans ce sous-tableau.
On peut montrer qu'il n'existe pas de sous-tableaux bons de longueur supérieure à 4.

Contraintes :

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


On vous donne un tableau d'entiers nums indexé à 0 de longueur paire et on a également un tableau vide arr. Alice et Bob ont décidé de jouer à un jeu où à chaque tour Alice et Bob effectuent un mouvement. Les règles du jeu sont les suivantes :

A chaque tour, Alice enlève d'abord l'élément minimum de nums, puis Bob fait de même.
Ensuite, Bob ajoute d'abord l'élément retiré dans le tableau arr, puis Alice fait de même.
Le jeu continue jusqu'à ce que nums soit vide.

Retournez le tableau arr résultant.

Exemple 1 :

Entrée : nums = [5,4,2,3]
Sortie : [3,2,5,4]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 3. Ensuite, dans arr, Bob ajoute d'abord 3, puis Alice ajoute 2. Donc arr = [3,2].
Au début du deuxième tour, nums = [5,4]. Maintenant, Alice enlève d'abord 4, puis Bob enlève 5. Ensuite, les deux ajoutent dans arr qui devient [3,2,5,4].

Exemple 2 :

Entrée : nums = [2,5]
Sortie : [5,2]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 5. Ensuite, dans arr, Bob ajoute d'abord puis Alice ajoute. Donc arr = [5,2].

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

On vous donne un tableau d'entiers nums à indexation 0 de longueur paire et il y a également un tableau vide arr. Alice et Bob ont décidé de jouer à un jeu où à chaque tour Alice et Bob effectuent un mouvement. Les règles du jeu sont les suivantes :

Chaque tour, Alice enlève d'abord l'élément minimum de nums, puis Bob fait de même.
Ensuite, Bob ajoute d'abord l'élément retiré dans le tableau arr, puis Alice fait de même.
Le jeu continue jusqu'à ce que nums soit vide.

Retournez le tableau arr résultant.

Exemple 1 :

Entrée : nums = [5,4,2,3]
Sortie : [3,2,5,4]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 3. Ensuite, dans arr, Bob ajoute d'abord 3, puis Alice ajoute 2. Donc arr = [3,2].
Au début du deuxième tour, nums = [5,4]. Maintenant, Alice enlève d'abord 4, puis Bob enlève 5. Ensuite, les deux ajoutent dans arr qui devient [3,2,5,4].

Exemple 2 :

Entrée : nums = [2,5]
Sortie : [5,2]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 5. Ensuite, dans arr, Bob ajoute d'abord puis Alice ajoute. Donc arr = [5,2].

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

On vous donne un tableau d'entiers nums à indexation 0 de longueur paire et il y a également un tableau vide arr. Alice et Bob ont décidé de jouer à un jeu où à chaque tour Alice et Bob effectuent un mouvement. Les règles du jeu sont les suivantes :

Chaque tour, Alice enlève d'abord l'élément minimum de nums, puis Bob fait de même.
Ensuite, Bob ajoute d'abord l'élément retiré dans le tableau arr, puis Alice fait de même.
Le jeu continue jusqu'à ce que nums soit vide.

Renvoyez le tableau arr résultant.

Exemple 1 :

Entrée : nums = [5,4,2,3]
Sortie : [3,2,5,4]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 3. Ensuite, dans arr, Bob ajoute d'abord 3, puis Alice ajoute 2. Donc arr = [3,2].
Au début du deuxième tour, nums = [5,4]. Maintenant, Alice enlève d'abord 4, puis Bob enlève 5. Ensuite, les deux ajoutent dans arr qui devient [3,2,5,4].

Exemple 2 :

Entrée : nums = [2,5]
Sortie : [5,2]
Explication : Au premier tour, Alice enlève d'abord 2, puis Bob enlève 5. Ensuite, dans arr, Bob ajoute d'abord puis Alice ajoute. Donc arr = [5,2].

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0


Vous avez une matrice à 2 dimensions d'entiers indexée à 0, grid, de taille n * n avec des valeurs dans la plage [1, n^2]. Chaque entier apparaît exactement une fois sauf a qui apparaît deux fois et b qui manque. La tâche est de trouver les nombres répétés et manquants a et b.
Retournez un tableau d'entiers indexé à 0, ans, de taille 2 où ans[0] est égal à a et ans[1] est égal à b.

Exemple 1 :

Entrée : grid = [[1,3],[2,2]]
Sortie : [2,4]
Explication : Le nombre 2 est répété et le nombre 4 est manquant donc la réponse est [2,4].

Exemple 2 :

Entrée : grid = [[9,1,7],[8,9,2],[3,4,6]]
Sortie : [9,5]
Explication : Le nombre 9 est répété et le nombre 5 est manquant donc la réponse est [9,5].

Contraintes :

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Pour tout x tel que 1 <= x <= n * n il y a exactement un x qui n'est égal à aucun des membres de grid.
Pour tout x tel que 1 <= x <= n * n il y a exactement un x qui est égal à exactement deux des membres de grid.
Pour tout x tel que 1 <= x <= n * n sauf deux d'entre eux il existe exactement une paire de i, j telle que 0 <= i, j <= n - 1 et grid[i][j] == x.

Vous disposez d'une grille matricielle 2D de taille n * n, indexée à 0, dont les valeurs sont comprises entre [1, n^2]. Chaque nombre entier apparaît exactement une fois, à l'exception de a qui apparaît deux fois et de b qui est manquant. La tâche consiste à trouver les nombres répétitifs et manquants a et b.
La méthode renvoie un tableau d'entiers indexés 0 ans de taille 2 où ans[0] est égal à a et ans[1] est égal à b.

Exemple 1 :

Entrée : grid = [[1,3],[2,2]]
Sortie : [2,4]
Explication : Le numéro 2 est répété et le numéro 4 est manquant, la réponse est donc [2,4].

Exemple 2 :

Entrée : grid = [[9,1,7],[8,9,2],[3,4,6]]
Sortie : [9,5]
Explication : Le numéro 9 est répété et le numéro 5 est manquant, la réponse est donc [9,5].

Contraintes :

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Pour tous les x qui 1 <= x <= n * n, il y a exactement un x qui n'est égal à aucun des membres de la grille.
Pour tous les x qui 1 <= x <= n * n il y a exactement un x qui est égal à exactement deux des membres de la grille.
Pour tous les x qui 1 <= x <= n * n sauf deux d'entre eux, il y a exactement une paire de i, j qui 0 <= i, j <= n - 1 et grid[i][j] == x.

Vous avez une matrice entière à 2 dimensions indexée à 0, grid, de taille n * n avec des valeurs dans la plage [1, n^2]. Chaque entier apparaît exactement une fois sauf a qui apparaît deux fois et b qui manque. La tâche est de trouver les nombres répétés et manquants a et b.
Retournez un tableau d'entiers indexé à 0, ans, de taille 2 où ans[0] est égal à a et ans[1] est égal à b.

Exemple 1 :

Entrée : grid = [[1,3],[2,2]]
Sortie : [2,4]
Explication : Le nombre 2 est répété et le nombre 4 est manquant donc la réponse est [2,4].

Exemple 2 :

Entrée : grid = [[9,1,7],[8,9,2],[3,4,6]]
Sortie : [9,5]
Explication : Le nombre 9 est répété et le nombre 5 est manquant donc la réponse est [9,5].

Contraintes :

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Pour tout x tel que 1 <= x <= n * n il y a exactement un x qui n'est égal à aucun des membres de grid.
Pour tout x tel que 1 <= x <= n * n il y a exactement un x qui est égal à exactement deux des membres de grid.
Pour tout x tel que 1 <= x <= n * n sauf deux d'entre eux il existe exactement une paire de i, j telle que 0 <= i, j <= n - 1 et grid[i][j] == x.


On vous donne deux tableaux d'entiers 0-indexés nums1 et nums2 de longueur paire n.
Vous devez retirer n / 2 éléments de nums1 et n / 2 éléments de nums2. Après ces suppressions, vous insérez les éléments restants de nums1 et nums2 dans un ensemble s.
Renvoyez la taille maximale possible de l'ensemble s.

Exemple 1 :

Entrée : nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Sortie : 2
Explication : Nous retirons deux occurrences de 1 de nums1 et nums2. Après les suppressions, les tableaux deviennent nums1 = [2,2] et nums2 = [1,1]. Par conséquent, s = {1,2}.
Il peut être montré que 2 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 2 :

Entrée : nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Sortie : 5
Explication : Nous retirons 2, 3 et 6 de nums1, ainsi que 2 et deux occurrences de 3 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,4,5] et nums2 = [2,3,2]. Par conséquent, s = {1,2,3,4,5}.
Il peut être montré que 5 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 3 :

Entrée : nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Sortie : 6
Explication : Nous retirons 1, 2 et 3 de nums1, ainsi que 4, 5 et 6 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,2,3] et nums2 = [4,5,6]. Par conséquent, s = {1,2,3,4,5,6}.
Il peut être montré que 6 est la taille maximale possible de l'ensemble s après les suppressions.

Contraintes :

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n est pair.
1 <= nums1[i], nums2[i] <= 10^9

Vous disposez de deux tableaux d'entiers 0-indexés nums1 et nums2 de longueur paire n.
Vous devez retirer n / 2 éléments de nums1 et n / 2 éléments de nums2. Après ces suppressions, vous insérez les éléments restants de nums1 et nums2 dans un ensemble s.
Retournez la taille maximale possible de l'ensemble s.

Exemple 1:

Entrée: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Sortie: 2
Explication: Nous retirons deux occurrences de 1 de nums1 et nums2. Après les suppressions, les tableaux deviennent nums1 = [2,2] et nums2 = [1,1]. Par conséquent, s = {1,2}.
Il peut être montré que 2 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 2:

Entrée: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Sortie: 5
Explication: Nous retirons 2, 3 et 6 de nums1, ainsi que 2 et deux occurrences de 3 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,4,5] et nums2 = [2,3,2]. Par conséquent, s = {1,2,3,4,5}.
Il peut être montré que 5 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 3:

Entrée: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Sortie: 6
Explanation: Nous retirons 1, 2 et 3 de nums1, ainsi que 4, 5 et 6 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,2,3] et nums2 = [4,5,6]. Par conséquent, s = {1,2,3,4,5,6}.
Il peut être montré que 6 est la taille maximale possible de l'ensemble s après les suppressions.

Contraintes:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n est pair.
1 <= nums1[i], nums2[i] <= 10^9

Vous disposez de deux tableaux d'entiers indexés à partir de 0 nums1 et nums2 de longueur paire n.
Vous devez retirer n / 2 éléments de nums1 et n / 2 éléments de nums2. Après ces suppressions, vous insérez les éléments restants de nums1 et nums2 dans un ensemble s.
Retournez la taille maximale possible de l'ensemble s.

Exemple 1 :

Entrée : nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Sortie : 2
Explication : Nous retirons deux occurrences de 1 de nums1 et nums2. Après les suppressions, les tableaux deviennent nums1 = [2,2] et nums2 = [1,1]. Par conséquent, s = {1,2}.
Il peut être montré que 2 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 2 :

Entrée : nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Sortie : 5
Explication : Nous retirons 2, 3 et 6 de nums1, ainsi que 2 et deux occurrences de 3 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,4,5] et nums2 = [2,3,2]. Par conséquent, s = {1,2,3,4,5}.
Il peut être montré que 5 est la taille maximale possible de l'ensemble s après les suppressions.

Exemple 3 :

Entrée : nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Sortie : 6
Explication : Nous retirons 1, 2 et 3 de nums1, ainsi que 4, 5 et 6 de nums2. Après les suppressions, les tableaux deviennent nums1 = [1,2,3] et nums2 = [4,5,6]. Par conséquent, s = {1,2,3,4,5,6}.
Il peut être montré que 6 est la taille maximale possible de l'ensemble s après les suppressions.

Contraintes :

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n est pair.
1 <= nums1[i], nums2[i] <= 10^9


On vous donne un tableau d'entiers nums indexé à 0 de longueur n.
Vous êtes autorisé à effectuer un mouvement spécial un nombre quelconque de fois (y compris zéro) sur nums. Lors d'un mouvement spécial, vous effectuez les étapes suivantes dans l'ordre :

Choisissez un indice i dans l'intervalle [0, n - 1], et un entier positif x.
Ajoutez |nums[i] - x| au coût total.
Changez la valeur de nums[i] en x.

Un nombre palindromique est un entier positif qui reste identique lorsque ses chiffres sont inversés. Par exemple, 121, 2552 et 65756 sont des nombres palindromiques tandis que 24, 46, 235 ne le sont pas.
Un tableau est considéré comme palindromique égal si tous les éléments du tableau sont égaux à un entier y, où y est un nombre palindromique inférieur à 10^9.
Retournez un entier représentant le coût total minimum possible pour rendre nums palindromique égal en effectuant un nombre quelconque de mouvements spéciaux.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 6
Explication : Nous pouvons rendre le tableau palindromique égal en changeant tous les éléments en 3, qui est un nombre palindromique. Le coût pour changer le tableau en [3,3,3,3,3] en utilisant 4 mouvements spéciaux est donné par |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
On peut montrer que changer tous les éléments en n'importe quel autre nombre palindromique que 3 ne peut pas être réalisé à un coût inférieur.

Exemple 2 :

Entrée : nums = [10,12,13,14,15]
Sortie : 11
Explication : Nous pouvons rendre le tableau palindromique égal en changeant tous les éléments en 11, qui est un nombre palindromique. Le coût pour changer le tableau en [11,11,11,11,11] en utilisant 5 mouvements spéciaux est donné par |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
On peut montrer que changer tous les éléments en n'importe quel autre nombre palindromique que 11 ne peut pas être réalisé à un coût inférieur.

Exemple 3 :

Entrée : nums = [22,33,22,33,22]
Sortie : 22
Explication : Nous pouvons rendre le tableau palindromique égal en changeant tous les éléments en 22, qui est un nombre palindromique. Le coût pour changer le tableau en [22,22,22,22,22] en utilisant 2 mouvements spéciaux est donné par |33 - 22| + |33 - 22| = 22.
On peut montrer que changer tous les éléments en n'importe quel autre nombre palindromique que 22 ne peut pas être réalisé à un coût inférieur.

Contraintes :

1 <= n <= 10^5
1 <= nums[i] <= 10^9

On vous donne un tableau d'entiers nums à indice 0 de longueur n.
Vous êtes autorisé à effectuer un mouvement spécial un nombre quelconque de fois (y compris zéro) sur nums. Lors d'un mouvement spécial, vous effectuez les étapes suivantes dans l'ordre :

Choisissez un indice i dans l'intervalle [0, n - 1], et un entier positif x.
Ajoutez |nums[i] - x| au coût total.
Changez la valeur de nums[i] en x.

Un nombre palindromique est un entier positif qui reste identique lorsque ses chiffres sont inversés. Par exemple, 121, 2552 et 65756 sont des nombres palindromiques tandis que 24, 46, 235 ne le sont pas.
Un tableau est considéré comme égalindromique si tous les éléments du tableau sont égaux à un entier y, où y est un nombre palindromique inférieur à 10^9.
Retournez un entier représentant le coût total minimum possible pour rendre nums égalindromique en effectuant un nombre quelconque de mouvements spéciaux.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 6
Explication : Nous pouvons rendre le tableau égalindromique en changeant tous les éléments en 3, qui est un nombre palindromique. Le coût pour changer le tableau en [3,3,3,3,3] en utilisant 4 mouvements spéciaux est donné par |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Il peut être démontré que changer tous les éléments en n'importe quel autre nombre palindromique que 3 ne peut pas être réalisé à un coût inférieur.

Exemple 2 :

Entrée : nums = [10,12,13,14,15]
Sortie : 11
Explication : Nous pouvons rendre le tableau égalindromique en changeant tous les éléments en 11, qui est un nombre palindromique. Le coût pour changer le tableau en [11,11,11,11,11] en utilisant 5 mouvements spéciaux est donné par |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Il peut être démontré que changer tous les éléments en n'importe quel autre nombre palindromique que 11 ne peut pas être réalisé à un coût inférieur.

Exemple 3 :

Entrée : nums = [22,33,22,33,22]
Sortie : 22
Explication : Nous pouvons rendre le tableau égalindromique en changeant tous les éléments en 22, qui est un nombre palindromique. Le coût pour changer le tableau en [22,22,22,22,22] en utilisant 2 mouvements spéciaux est donné par |33 - 22| + |33 - 22| = 22.
Il peut être démontré que changer tous les éléments en n'importe quel autre nombre palindromique que 22 ne peut pas être réalisé à un coût inférieur.

Contraintes :

1 <= n <= 10^5
1 <= nums[i] <= 10^9

On vous donne un tableau d'entiers indexés 0 nums de longueur n.
Vous êtes autorisé à effectuer un déplacement spécial sur nums autant de fois que vous le souhaitez (y compris zéro). Dans un déplacement spécial, vous effectuez les étapes suivantes dans l'ordre :

Choisissez un index i dans la plage [0, n - 1] et un entier positif x.
Ajoutez |nums[i] - x| au coût total.
Remplacez la valeur de nums[i] par x.

Un nombre palindromique est un entier positif qui reste le même lorsque ses chiffres sont inversés. Par exemple, 121, 2552 et 65756 sont des nombres palindromiques tandis que 24, 46, 235 ne sont pas des nombres palindromiques.
Un tableau est considéré comme égalindromique si tous les éléments du tableau sont égaux à un entier y, où y est un nombre palindromique inférieur à 10^9.
Renvoie un entier indiquant le coût total minimum possible pour rendre nums égalindromique en effectuant un nombre quelconque de déplacements spéciaux.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 6
Explication : Nous pouvons rendre le tableau égalindromique en remplaçant tous les éléments par 3, qui est un nombre palindromique. Le coût de remplacement du tableau par [3,3,3,3,3] en utilisant 4 déplacements spéciaux est donné par |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Il peut être démontré que le remplacement de tous les éléments par un nombre palindromique autre que 3 ne peut pas être réalisé à un coût inférieur.

Exemple 2 :

Entrée : nums = [10,12,13,14,15]
Sortie : 11
Explication : Nous pouvons rendre le tableau égalindromique en remplaçant tous les éléments par 11, qui est un nombre palindromique. Le coût de la modification du tableau en [11,11,11,11,11] en 5 coups spéciaux est donné par |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Il peut être démontré que la modification de tous les éléments en un nombre palindromique autre que 11 ne peut pas être réalisée à un coût inférieur.

Exemple 3 :

Entrée : nums = [22,33,22,33,22]
Sortie : 22
Explication : Nous pouvons rendre le tableau équiindromique en modifiant tous les éléments en 22, qui est un nombre palindromique. Le coût de la modification du tableau en [22,22,22,22,22] en 2 coups spéciaux est donné par |33 - 22| + |33 - 22| = 22.
Il peut être démontré que la transformation de tous les éléments en un nombre palindromique autre que 22 ne peut pas être réalisée à moindre coût.

Contraintes :

1 <= n <= 10^5
1 <= nums[i] <= 10^9


On vous donne une chaîne `word` indexée à partir de 0.

Dans une opération, vous pouvez choisir n'importe quel index `i` de `word` et changer `word[i]` pour n'importe quelle lettre anglaise minuscule.

Renvoyez le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de `word`.

Deux caractères `a` et `b` sont presque égaux si `a == b` ou si `a` et `b` sont adjacents dans l'alphabet.

Exemple 1 :

Entrée : word = "aaaaa"
Sortie : 2
Explication : Nous pouvons changer `word` en "acaca" qui n'a pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de `word` est 2.

Exemple 2 :

Entrée : word = "abddez"
Sortie : 2
Explication : Nous pouvons changer `word` en "ybdoez" qui n'a pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de `word` est 2.

Exemple 3 :

Entrée : word = "zyxyxyz"
Sortie : 3
Explication : Nous pouvons changer `word` en "zaxaxaz" qui n'a pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de `word` est 3.

Contraintes :

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

On donne une chaîne word indexée à partir de 0.
Dans une opération, vous pouvez choisir n'importe quel indice i de word et changer word[i] en n'importe quelle lettre anglaise minuscule.
Retournez le nombre minimum d'opérations nécessaires pour supprimer tous les caractères adjacents presque égaux de word.
Deux caractères a et b sont presque égaux si a == b ou si a et b sont adjacents dans l'alphabet.

Exemple 1 :

Entrée : word = "aaaaa"
Sortie : 2
Explication : Nous pouvons changer word en "acaca" qui ne comporte pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de word est 2.

Exemple 2 :

Entrée : word = "abddez"
Sortie : 2
Explication : Nous pouvons changer word en "ybdoez" qui ne comporte pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de word est 2.
Exemple 3 :

Entrée : word = "zyxyxyz"
Sortie : 3
Explication : Nous pouvons changer word en "zaxaxaz" qui ne comporte pas de caractères presque égaux adjacents.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères presque égaux adjacents de word est 3.

Contraintes :

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

On vous donne une chaîne de caractères indexée 0, le mot.
En une opération, vous pouvez choisir n'importe quel indice i de word et remplacer word[i] par n'importe quelle lettre minuscule anglaise.
Retournez le nombre minimum d'opérations nécessaires pour supprimer tous les caractères adjacents presque égaux de word.
Deux caractères a et b sont presque égaux si a == b ou si a et b sont adjacents dans l'alphabet.

Exemple 1 :

Entrée : word = "aaaaa"
Sortie : 2
Explication : Nous pouvons transformer word en « acaca » qui n'a pas de caractères adjacents presque égaux.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères adjacents presque égaux de word est de 2.

Exemple 2 :

Entrée : word = "abddez"
Sortie : 2
Explication : Nous pouvons transformer word en « ybdoez » qui n'a pas de caractères adjacents presque égaux.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères adjacents presque égaux de word est de 2.
Exemple 3 :

Entrée : word = "zyxyxyz"
Sortie : 3
Explication : Nous pouvons transformer word en « zaxaxaz » qui n'a pas de caractères adjacents presque égaux.
On peut montrer que le nombre minimum d'opérations nécessaires pour supprimer tous les caractères adjacents presque égaux de word est de 3.

Contraintes :

1 <= word.length <= 100
word n'est constitué que de lettres minuscules anglaises.


On vous donne un tableau d'entiers indexés à 0, coins, représentant les valeurs des pièces disponibles, et un entier target.
Un entier x est atteignable s'il existe une sous-séquence de coins qui somme à x.
Renvoyez le nombre minimum de pièces de n'importe quelle valeur qu'il faut ajouter au tableau pour que chaque entier de l'intervalle [1, target] soit atteignable.
Une sous-séquence d'un tableau est un nouveau tableau non vide qui est formé à partir du tableau original en supprimant certains éléments (éventuellement aucun) sans perturber les positions relatives des éléments restants.

Exemple 1 :

Entrée : coins = [1,4,10], target = 19
Sortie : 2
Explication : Nous devons ajouter les pièces 2 et 8. Le tableau résultant sera [1,2,4,8,10].
On peut montrer que tous les entiers de 1 à 19 sont atteignables à partir du tableau résultant, et que 2 est le nombre minimum de pièces à ajouter au tableau.

Exemple 2 :

Entrée : coins = [1,4,10,5,7,19], target = 19
Sortie : 1
Explication : Nous devons seulement ajouter la pièce 2. Le tableau résultant sera [1,2,4,5,7,10,19].
On peut montrer que tous les entiers de 1 à 19 sont atteignables à partir du tableau résultant, et que 1 est le nombre minimum de pièces à ajouter au tableau.

Exemple 3 :

Entrée : coins = [1,1,1], target = 20
Sortie : 3
Explication : Nous devons ajouter les pièces 4, 8, et 16. Le tableau résultant sera [1,1,1,4,8,16].
On peut montrer que tous les entiers de 1 à 20 sont atteignables à partir du tableau résultant, et que 3 est le nombre minimum de pièces à ajouter au tableau.

Contraintes :

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

On vous donne des pièces de monnaie entier indexées à 0, représentant les valeurs des pièces disponibles et une objectif entière.
Un entier X est disponible s'il existe une sous-séquence de pièces qui somme à x.
Renvoie le nombre minimum de pièces de toute valeur qui doivent être ajoutées au tableau afin que chaque entier de la plage [1, objectif] soit disponible.
Une sous-séquence d'un tableau est un nouveau tableau non vide qui est formé à partir du tableau d'origine en supprimant certains (peut-être aucun) des éléments sans perturber les positions relatives des éléments restants.

Exemple 1:

Entrée: coins = [1,4,10], target = 19
Sortie: 2
Explication: Nous devons ajouter des pièces 2 et 8. Le tableau résultant sera [1,2,4,8,10].
On peut montrer que tous les entiers de 1 à 19 peuvent être obtenus à partir du tableau résultant, et que 2 est le nombre minimum de pièces qui doivent être ajoutées au tableau.

Exemple 2:

Entrée: coins = [1,4,10,5,7,19], target = 19
Sortie: 1
Explication: Nous devons seulement ajouter la pièce 2. Le tableau résultant sera [1,2,4,5,7,10,19].
On peut montrer que tous les entiers de 1 à 19 peuvent être obtenus à partir du tableau résultant, et que 1 est le nombre minimum de pièces qui doivent être ajoutées au tableau.

Exemple 3:

Entrée: coins = [1,1,1], target = 20
Sortie: 3
Explication: Nous devons ajouter des pièces 4, 8 et 16. Le tableau résultant sera [1,1,1,4,8,16].
Il peut être montré que tous les entiers de 1 à 20 peuvent être obtenus à partir du tableau résultant, et que 3 est le nombre minimum de pièces qui doivent être ajoutées au tableau.

Contraintes:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

On donne un tableau d'entiers coins indexé à partir de 0 représentant les valeurs des pièces disponibles, et un entier target.
On peut obtenir un entier x s'il existe une sous-séquence de coins dont la somme est égale à x.
Retournez le nombre minimum de pièces de n'importe quelle valeur qu'il faut ajouter au tableau pour que chaque entier de l'intervalle [1, target] soit atteignable.
Une sous-séquence d'un tableau est un nouveau tableau non vide qui est formé à partir du tableau original en supprimant certains éléments (éventuellement aucun) sans perturber les positions relatives des éléments restants.

Exemple 1 :

Entrée : coins = [1,4,10], target = 19
Sortie : 2
Explication : Nous devons ajouter les pièces 2 et 8. Le tableau résultant sera [1,2,4,8,10].
On peut montrer que tous les entiers de 1 à 19 sont atteignables à partir du tableau résultant, et que 2 est le nombre minimum de pièces à ajouter au tableau.

Exemple 2 :

Entrée : coins = [1,4,10,5,7,19], target = 19
Sortie : 1
Explication : Nous devons seulement ajouter la pièce 2. Le tableau résultant sera [1,2,4,5,7,10,19].
On peut montrer que tous les entiers de 1 à 19 sont atteignables à partir du tableau résultant, et que 1 est le nombre minimum de pièces à ajouter au tableau.

Exemple 3 :

Entrée : coins = [1,1,1], target = 20
Sortie : 3
Explication : Nous devons ajouter les pièces 4, 8, et 16. Le tableau résultant sera [1,1,1,4,8,16].
On peut montrer que tous les entiers de 1 à 20 sont atteignables à partir du tableau résultant, et que 3 est le nombre minimum de pièces à ajouter au tableau.

Contraintes :

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target


On vous donne une chaîne indexée à 0 s et un entier k.
Vous devez effectuer les opérations de partitionnement suivantes jusqu'à ce que s soit vide :

Choisissez le préfixe le plus long de s contenant au plus k caractères distincts.
Supprimez le préfixe de s et augmentez le nombre de partitions d'une unité. Les caractères restants (le cas échéant) dans s conservent leur ordre initial.

Avant les opérations, vous êtes autorisé à modifier au plus un index de s par une autre lettre anglaise minuscule.
Renvoyer un entier indiquant le nombre maximal de partitions résultantes après les opérations en choisissant de manière optimale au plus un index à changer.

Exemple 1 :

Entrée : s = "accca", k = 2
Sortie : 3
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[2] peut être modifié en 'b'.
s devient "acbca".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le préfixe le plus long contenant au plus 2 caractères distincts, "acbca".
- Supprimez le préfixe, et s devient "bca". Le nombre de partitions est maintenant de 1.
- Choisissez le préfixe le plus long contenant au plus 2 caractères distincts, "bca".
- Supprimez le préfixe, et s devient "a". Le nombre de partitions est maintenant de 2.
- Choisissez le préfixe le plus long contenant au plus 2 caractères distincts, "a".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant de 3.
La réponse est donc 3.
On peut montrer qu'il n'est pas possible d'obtenir plus de 3 partitions.
Exemple 2 :

Entrée : s = "aabaab", k = 3
Sortie : 1
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, nous pouvons laisser s tel quel.
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le préfixe le plus long contenant au plus 3 caractères distincts, « aabaab ».
- Supprimez le préfixe, et s devient vide. Le nombre de partitions devient 1.
Par conséquent, la réponse est 1.
On peut montrer qu'il n'est pas possible d'obtenir plus d'une partition.

Exemple 3 :

Entrée : s = "xxyz", k = 1
Sortie : 4
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[1] peut être changé en 'a'.
s devient "xayz".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le préfixe le plus long contenant au plus 1 caractère distinct, "xayz".
- Supprimez le préfixe, et s devient « ayz ». Le nombre de partitions est maintenant 1.
- Choisissez le préfixe le plus long contenant au plus 1 caractère distinct, "ayz".
- Supprimez le préfixe, et s devient "yz". Le nombre de partitions est maintenant de 2.
- Choisissez le préfixe le plus long contenant au plus 1 caractère distinct, "yz".
- Supprimez le préfixe, et s devient "z". Le nombre de partitions est maintenant de 3.
- Choisissez le préfixe le plus long contenant au plus 1 caractère distinct, "z".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant de 4.
La réponse est donc 4.
On peut montrer qu'il n'est pas possible d'obtenir plus de 4 partitions.

Contraintes :

1 <= s.length <= 10^4
s est uniquement composé de lettres minuscules anglaises.
1 <= k <= 26

Vous avez une chaîne s indexée à 0 et un entier k.
Vous devez effectuer les opérations de partitionnement suivantes jusqu'à ce que s soit vide :

Choisissez le plus long préfixe de s contenant au plus k caractères distincts.
Supprimez le préfixe de s et augmentez le nombre de partitions de un. Les caractères restants (le cas échéant) dans s conservent leur ordre initial.

Avant les opérations, vous pouvez modifier au plus un indice dans s pour une autre lettre minuscule anglaise.
Retournez un entier indiquant le nombre maximum de partitions résultantes après les opérations en choisissant de manière optimale au plus un indice à changer.

Exemple 1 :

Entrée : s = "accca", k = 2
Sortie : 3
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[2] peut être changé en 'b'.
s devient "acbca".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "acbca".
- Supprimez le préfixe, et s devient "bca". Le nombre de partitions est maintenant 1.
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "bca".
- Supprimez le préfixe, et s devient "a". Le nombre de partitions est maintenant 2.
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "a".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant 3.
Ainsi, la réponse est 3.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 3 partitions.

Exemple 2 :

Entrée : s = "aabaab", k = 3
Sortie : 1
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, nous pouvons laisser s tel quel.
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 3 caractères distincts, "aabaab".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions devient 1.
Ainsi, la réponse est 1.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 1 partition.

Exemple 3 :

Entrée : s = "xxyz", k = 1
Sortie : 4
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[1] peut être changé en 'a'.
s devient "xayz".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "xayz".
- Supprimez le préfixe, et s devient "ayz". Le nombre de partitions est maintenant 1.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "ayz".
- Supprimez le préfixe, et s devient "yz". Le nombre de partitions est maintenant 2.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "yz".
- Supprimez le préfixe, et s devient "z". Le nombre de partitions est maintenant 3.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "z".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant 4.
Ainsi, la réponse est 4.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 4 partitions.

Contraintes :

1 <= s.length <= 10^4
s est composé uniquement de lettres minuscules anglaises.
1 <= k <= 26

Vous avez une chaîne s indexée à partir de 0 et un entier k.
Vous devez effectuer les opérations de partitionnement suivantes jusqu'à ce que s soit vide :

Choisissez le plus long préfixe de s contenant au plus k caractères distincts.
Supprimez le préfixe de s et augmentez le nombre de partitions de un. Les caractères restants (le cas échéant) dans s conservent leur ordre initial.

Avant les opérations, vous pouvez modifier au plus un indice dans s pour une autre lettre minuscule anglaise.
Retournez un entier indiquant le nombre maximum de partitions résultantes après les opérations en choisissant de manière optimale au plus un indice à changer.

Exemple 1 :

Entrée : s = "accca", k = 2
Sortie : 3
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[2] peut être changé en 'b'.
s devient "acbca".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "acbca".
- Supprimez le préfixe, et s devient "bca". Le nombre de partitions est maintenant 1.
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "bca".
- Supprimez le préfixe, et s devient "a". Le nombre de partitions est maintenant 2.
- Choisissez le plus long préfixe contenant au plus 2 caractères distincts, "a".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant 3.
Ainsi, la réponse est 3.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 3 partitions.
Exemple 2 :

Entrée : s = "aabaab", k = 3
Sortie : 1
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, nous pouvons laisser s tel quel.
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 3 caractères distincts, "aabaab".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions devient 1.
Ainsi, la réponse est 1.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 1 partition.

Exemple 3 :

Entrée : s = "xxyz", k = 1
Sortie : 4
Explication : Dans cet exemple, pour maximiser le nombre de partitions résultantes, s[1] peut être changé en 'a'.
s devient "xayz".
Les opérations peuvent maintenant être effectuées comme suit jusqu'à ce que s devienne vide :
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "xayz".
- Supprimez le préfixe, et s devient "ayz". Le nombre de partitions est maintenant 1.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "ayz".
- Supprimez le préfixe, et s devient "yz". Le nombre de partitions est maintenant 2.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "yz".
- Supprimez le préfixe, et s devient "z". Le nombre de partitions est maintenant 3.
- Choisissez le plus long préfixe contenant au plus 1 caractère distinct, "z".
- Supprimez le préfixe, et s devient vide. Le nombre de partitions est maintenant 4.
Ainsi, la réponse est 4.
Il peut être démontré qu'il n'est pas possible d'obtenir plus de 4 partitions.

Contraintes :

1 <= s.length <= 10^4
s est composé uniquement de lettres minuscules anglaises.
1 <= k <= 26


Vous avez un tableau 2D indexé à partir de 0 nommé variables où variables[i] = [a_i, b_i, c_i, m_i], ainsi qu'un entier target.
Un indice i est dit bon si la formule suivante est vérifiée :

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Retournez un tableau composé des indices bons dans n'importe quel ordre.

Exemple 1 :

Entrée : variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Sortie : [0,2]
Explication : Pour chaque indice i dans le tableau variables :
1) Pour l'indice 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Pour l'indice 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Pour l'indice 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Par conséquent, nous retournons [0,2] comme réponse.

Exemple 2 :

Entrée : variables = [[39,3,1000,1000]], target = 17
Sortie : []
Explication : Pour chaque indice i dans le tableau variables :
1) Pour l'indice 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Par conséquent, nous retournons [] comme réponse.

Contraintes :

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

On vous donne un tableau 2D indexé à 0 de variables où variables[i] = [a_i, b_i, c_i, m_i] et un entier target.
Un index i est bon si la formule suivante est vraie :

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Renvoie un tableau composé de bons indices dans n'importe quel ordre.

Exemple 1 :

Entrée : variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Sortie : [0,2]
Explication : Pour chaque index i dans le tableau de variables :
1) Pour l'index 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Pour l'index 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Pour l'index 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Nous renvoyons donc [0,2] comme réponse.

Exemple 2 :

Entrée : variables = [[39,3,1000,1000]], target = 17
Sortie : []
Explication : Pour chaque index i dans le tableau de variables :
1) Pour l'index 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Nous renvoyons donc [] comme réponse.

Contraintes :

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Vous avez un tableau 2D à indices 0 nommé variables où variables[i] = [a_i, b_i, c_i, m_i], et un entier target.
Un indice i est bon si la formule suivante est vérifiée :

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Retournez un tableau composé des indices bons dans n'importe quel ordre.

Exemple 1 :

Entrée : variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Sortie : [0,2]
Explication : Pour chaque indice i dans le tableau variables :
1) Pour l'indice 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Pour l'indice 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Pour l'indice 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Par conséquent, nous retournons [0,2] comme réponse.

Exemple 2 :

Entrée : variables = [[39,3,1000,1000]], target = 17
Sortie : []
Explication : Pour chaque indice i dans le tableau variables :
1) Pour l'indice 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Par conséquent, nous retournons [] comme réponse.

Contraintes :

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


On vous donne deux chaînes de caractères indexées à partir de 0, `source` et `target`, toutes deux de longueur n et composées de lettres minuscules anglaises. Vous disposez également de deux tableaux de caractères indexés à partir de 0, `original` et `changed`, ainsi que d'un tableau d'entiers `cost`, où `cost[i]` représente le coût pour changer le caractère `original[i]` en le caractère `changed[i]`.
Vous commencez avec la chaîne `source`. En une seule opération, vous pouvez choisir un caractère x de la chaîne et le changer en le caractère y à un coût z s'il existe un indice j tel que `cost[j] == z`, `original[j] == x` et `changed[j] == y`.
Retournez le coût minimum pour convertir la chaîne `source` en la chaîne `target` en utilisant un nombre quelconque d'opérations. S'il est impossible de convertir `source` en `target`, retournez -1.
Notez qu'il peut exister des indices i, j tels que `original[j] == original[i]` et `changed[j] == changed[i]`.

Exemple 1 :

Entrée : source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Sortie : 28
Explication : Pour convertir la chaîne "abcd" en la chaîne "acbe" :
- Changez la valeur à l'indice 1 de 'b' en 'c' à un coût de 5.
- Changez la valeur à l'indice 2 de 'c' en 'e' à un coût de 1.
- Changez la valeur à l'indice 2 de 'e' en 'b' à un coût de 2.
- Changez la valeur à l'indice 3 de 'd' en 'e' à un coût de 20.
Le coût total encouru est 5 + 1 + 2 + 20 = 28.
Il est montré que c'est le coût minimum possible.

Exemple 2 :

Entrée : source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Sortie : 12
Explication : Pour changer le caractère 'a' en 'b', changez le caractère 'a' en 'c' à un coût de 1, suivi du changement du caractère 'c' en 'b' à un coût de 2, pour un coût total de 1 + 2 = 3. Pour changer toutes les occurrences de 'a' en 'b', un coût total de 3 * 4 = 12 est encouru.

Exemple 3 :

Entrée : source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Sortie : -1
Explication : Il est impossible de convertir `source` en `target` car la valeur à l'indice 3 ne peut pas être changée de 'd' en 'e'.

Contraintes :

1 <= source.length == target.length <= 10^5
source, target consistent en lettres minuscules anglaises.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] sont des lettres minuscules anglaises.
1 <= cost[i] <= 10^6
original[i] != changed[i]

On vous donne deux chaînes indexées 0 source et target, toutes deux de longueur n et composées de lettres minuscules anglaises. On vous donne également deux tableaux de caractères indexés 0 original et modified, ainsi qu'un tableau d'entiers cost, où cost[i] représente le coût de la modification du caractère original[i] en caractère modified[i].
Vous commencez avec la chaîne source. En une seule opération, vous pouvez choisir un caractère x dans la chaîne et le changer en caractère y pour un coût de z s'il existe un index j tel que cost[j] == z, original[j] == x et modified[j] == y.
Renvoie le coût minimum pour convertir la chaîne source en chaîne target en utilisant un nombre quelconque d'opérations. S'il est impossible de convertir la source en target, renvoie -1.
Notez qu'il peut exister des index i, j tels que original[j] == original[i] and changed[j] == changed[i].

Exemple 1 :

Entrée : source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Sortie : 28
Explication : Pour convertir la chaîne "abcd" en la chaîne "acbe" :
- Changez la valeur de l'index 1 de « b » à « c » pour un coût de 5.
- Changez la valeur de l'index 2 de « c » à « e » pour un coût de 1.
- Changez la valeur de l'index 2 de « e » à « b » pour un coût de 2.
- Changez la valeur de l'index 3 de « d » à « e » pour un coût de 20.
Le coût total engagé est de 5 + 1 + 2 + 20 = 28.
On peut montrer qu'il s'agit du coût minimum possible.

Exemple 2 :

Entrée : source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Sortie : 12
Explication : Pour changer le caractère 'a' en 'b', changez le caractère 'a' en 'c' à un coût de 1, suivi du changement du caractère 'c' en 'b' à un coût de 2, pour un coût total de 1 + 2 = 3. Pour changer toutes les occurrences de 'a' en 'b', un coût total de 3 * 4 = 12 est encouru.

Exemple 3 :

Entrée : source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Sortie : -1
Explication : Il est impossible de convertir source en target car la valeur à l'indice 3 ne peut pas être changée de 'd' en 'e'.
Contraintes :

1 <= source.length == target.length <= 10^5
source, target consistent en lettres minuscules anglaises.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] sont des lettres minuscules anglaises.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Vous avez deux chaînes de caractères source et target indexées à partir de 0, toutes deux de longueur n et composées de lettres minuscules anglaises. Vous disposez également de deux tableaux de caractères original et changed indexés à partir de 0, ainsi que d'un tableau d'entiers cost, où cost[i] représente le coût pour changer le caractère original[i] en le caractère changed[i].
Vous commencez avec la chaîne source. En une opération, vous pouvez choisir un caractère x de la chaîne et le changer en le caractère y à un coût z s'il existe un indice j tel que cost[j] == z, original[j] == x et changed[j] == y.
Retournez le coût minimum pour convertir la chaîne source en la chaîne target en utilisant un nombre quelconque d'opérations. S'il est impossible de convertir source en target, retournez -1.
Notez qu'il peut exister des indices i, j tels que original[j] == original[i] et changed[j] == changed[i].

Exemple 1 :

Entrée : source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Sortie : 28
Explication : Pour convertir la chaîne "abcd" en la chaîne "acbe" :
- Changez la valeur à l'indice 1 de 'b' en 'c' à un coût de 5.
- Changez la valeur à l'indice 2 de 'c' en 'e' à un coût de 1.
- Changez la valeur à l'indice 2 de 'e' en 'b' à un coût de 2.
- Changez la valeur à l'indice 3 de 'd' en 'e' à un coût de 20.
Le coût total induit est 5 + 1 + 2 + 20 = 28.
On peut montrer que c'est le coût minimum possible.

Exemple 2 :

Entrée : source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Sortie : 12
Explication : Pour changer le caractère 'a' en 'b', changez le caractère 'a' en 'c' à un coût de 1, suivi du changement du caractère 'c' en 'b' à un coût de 2, pour un coût total de 1 + 2 = 3. Pour changer toutes les occurrences de 'a' en 'b', un coût total de 3 * 4 = 12 est induit.

Exemple 3 :

Entrée : source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Sortie : -1
Explication : Il est impossible de convertir source en target car la valeur à l'indice 3 ne peut pas être changée de 'd' en 'e'.

Contraintes :

1 <= source.length == target.length <= 10^5
source, target consistent en lettres minuscules anglaises.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] sont des lettres minuscules anglaises.
1 <= cost[i] <= 10^6
original[i] != changed[i]


On vous donne un tableau d'entiers indexé à partir de 0, nums.
Un préfixe nums[0..i] est séquentiel si, pour tout 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particulier, le préfixe constitué uniquement de nums[0] est séquentiel.
Retournez le plus petit entier x manquant de nums tel que x soit supérieur ou égal à la somme du plus long préfixe séquentiel.

Exemple 1 :

Entrée : nums = [1,2,3,2,5]
Sortie : 6
Explication : Le plus long préfixe séquentiel de nums est [1,2,3] avec une somme de 6. 6 n'est pas dans le tableau, donc 6 est le plus petit entier manquant supérieur ou égal à la somme du plus long préfixe séquentiel.

Exemple 2 :

Entrée : nums = [3,4,5,1,12,14,13]
Sortie : 15
Explication : Le plus long préfixe séquentiel de nums est [3,4,5] avec une somme de 12. 12, 13 et 14 appartiennent au tableau tandis que 15 n'y est pas. Donc 15 est le plus petit entier manquant supérieur ou égal à la somme du plus long préfixe séquentiel.

Contraintes :

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

On vous donne un tableau nums d'entiers indexé à partir de 0.
Un préfixe nums[0..i] est séquentiel si, pour tout 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particulier, le préfixe constitué uniquement de nums[0] est séquentiel.
Retournez le plus petit entier x manquant de nums tel que x soit supérieur ou égal à la somme du plus long préfixe séquentiel.

Exemple 1 :

Entrée : nums = [1,2,3,2,5]
Sortie : 6
Explication : Le plus long préfixe séquentiel de nums est [1,2,3] avec une somme de 6. 6 n'est pas dans le tableau, donc 6 est le plus petit entier manquant supérieur ou égal à la somme du plus long préfixe séquentiel.

Exemple 2 :

Entrée : nums = [3,4,5,1,12,14,13]
Sortie : 15
Explication : Le plus long préfixe séquentiel de nums est [3,4,5] avec une somme de 12. 12, 13 et 14 appartiennent au tableau tandis que 15 n'y est pas. Donc 15 est le plus petit entier manquant supérieur ou égal à la somme du plus long préfixe séquentiel.

Contraintes :

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

Vous recevez un tableau indexé 0 d’entiers nums.
Un préfixe nums[0..i] est séquentiel si, pour tout 1 <= j <= i, nums[j] = nums[j - 1] + 1. En particulier, le préfixe composé uniquement de nums[0] est séquentiel.
Renvoie le plus petit entier x manquant dans les nombres tels que x soit supérieur ou égal à la somme du préfixe séquentiel le plus long.

Exemple 1 :

Entrée : nums = [1,2,3,2,5]
Sortie : 6
Explication : Le préfixe séquentiel le plus long de nums est [1,2,3] avec une somme de 6. 6 n’est pas dans le tableau, donc 6 est le plus petit entier manquant supérieur ou égal à la somme du préfixe séquentiel le plus long.

Exemple 2 :

Entrée : nums = [3,4,5,1,12,14,13]
Sortie : 15
Explication : Le préfixe séquentiel le plus long de nums est [3,4,5] avec une somme de 12. 12, 13 et 14 appartiennent au tableau, contrairement à 15. Par conséquent, 15 est le plus petit entier manquant supérieur ou égal à la somme du préfixe séquentiel le plus long.

Contraintes:

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


On vous donne deux entiers positifs x et y.
Lors d'une opération, vous pouvez effectuer l'une des quatre opérations suivantes :

Diviser x par 11 si x est un multiple de 11.
Diviser x par 5 si x est un multiple de 5.
Décrémenter x de 1.
Incrémenter x de 1.

Retournez le nombre minimum d'opérations nécessaires pour rendre x et y égaux.

Exemple 1 :

Entrée : x = 26, y = 1
Sortie : 3
Explication : Nous pouvons faire en sorte que 26 soit égal à 1 en appliquant les opérations suivantes :
1. Décrémenter x de 1
2. Diviser x par 5
3. Diviser x par 5
Il peut être montré que 3 est le nombre minimum d'opérations nécessaires pour rendre 26 égal à 1.

Exemple 2 :

Entrée : x = 54, y = 2
Sortie : 4
Explication : Nous pouvons faire en sorte que 54 soit égal à 2 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Diviser x par 11
3. Diviser x par 5
4. Incrémenter x de 1
Il peut être montré que 4 est le nombre minimum d'opérations nécessaires pour rendre 54 égal à 2.

Exemple 3 :

Entrée : x = 25, y = 30
Sortie : 5
Explication : Nous pouvons faire en sorte que 25 soit égal à 30 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Incrémenter x de 1
3. Incrémenter x de 1
4. Incrémenter x de 1
5. Incrémenter x de 1
Il peut être montré que 5 est le nombre minimum d'opérations nécessaires pour rendre 25 égal à 30.

Contraintes :

1 <= x, y <= 10^4

Vous avez deux entiers positifs x et y.
Lors d'une opération, vous pouvez effectuer l'une des quatre opérations suivantes :

Diviser x par 11 si x est un multiple de 11.
Diviser x par 5 si x est un multiple de 5.
Décrémenter x de 1.
Incrémenter x de 1.

Retournez le nombre minimum d'opérations nécessaires pour rendre x et y égaux.

Exemple 1 :

Entrée : x = 26, y = 1
Sortie : 3
Explication : Nous pouvons faire en sorte que 26 soit égal à 1 en appliquant les opérations suivantes :
1. Décrémenter x de 1
2. Diviser x par 5
3. Diviser x par 5
Il peut être montré que 3 est le nombre minimum d'opérations nécessaires pour faire 26 égal à 1.

Exemple 2 :

Entrée : x = 54, y = 2
Sortie : 4
Explication : Nous pouvons faire en sorte que 54 soit égal à 2 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Diviser x par 11
3. Diviser x par 5
4. Incrémenter x de 1
Il peut être montré que 4 est le nombre minimum d'opérations nécessaires pour faire 54 égal à 2.

Exemple 3 :

Entrée : x = 25, y = 30
Sortie : 5
Explication : Nous pouvons faire en sorte que 25 soit égal à 30 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Incrémenter x de 1
3. Incrémenter x de 1
4. Incrémenter x de 1
5. Incrémenter x de 1
Il peut être montré que 5 est le nombre minimum d'opérations nécessaires pour faire 25 égal à 30.

Contraintes :

1 <= x, y <= 10^4

On vous donne deux entiers positifs x et y.
En une seule opération, vous pouvez effectuer l'une des quatre opérations suivantes :

Diviser x par 11 si x est un multiple de 11.
Diviser x par 5 si x est un multiple de 5.
Diminuer x de 1.
Incrémenter x de 1.

Renvoyer le nombre minimum d'opérations requises pour rendre x et y égaux.

Exemple 1 :

Entrée : x = 26, y = 1
Sortie : 3
Explication : Nous pouvons rendre 26 égal à 1 en appliquant les opérations suivantes :
1. Diminuer x de 1
2. Diviser x par 5
3. Diviser x par 5
Il peut être démontré que 3 est le nombre minimum d'opérations nécessaires pour rendre 26 égal à 1.

Exemple 2 :

Entrée : x = 54, y = 2
Sortie : 4
Explication : Nous pouvons rendre 54 égal à 2 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Diviser x par 11
3. Diviser x par 5
4. Incrémenter x de 1
Il peut être démontré que 4 est le nombre minimum d'opérations nécessaires pour rendre 54 égal à 2.

Exemple 3 :

Entrée : x = 25, y = 30
Sortie : 5
Explication : Nous pouvons rendre 25 égal à 30 en appliquant les opérations suivantes :
1. Incrémenter x de 1
2. Incrémenter x de 1
3. Incrémenter x de 1
4. Incrémenter x de 1
5. Incrémenter x de 1
On peut montrer que 5 est le nombre minimum d'opérations nécessaires pour rendre 25 égal à 30.

Contraintes :

1 <= x, y <= 10^4


On vous donne un entier k et un entier x.
Considérons que s est la représentation binaire à base 1 d'un entier num. Le prix d'un nombre num est le nombre de i tels que i % x == 0 et s[i] est un bit défini.
Retournez le plus grand entier num tel que la somme des prix de tous les nombres de 1 à num soit inférieure ou égale à k.
Remarques :

Dans la représentation binaire d'un nombre, un bit défini est un bit de valeur 1.
La représentation binaire d'un nombre sera indexée de droite à gauche. Par exemple, si s == 11100, s[4] == 1 et s[2] == 0.

Exemple 1 :

Entrée : k = 9, x = 1
Sortie : 6
Explication : Les nombres 1, 2, 3, 4, 5 et 6 peuvent être respectivement écrits en représentation binaire sous forme de "1", "10", "11", "100", "101" et "110".
Puisque x est égal à 1, le prix de chaque nombre est le nombre de ses bits définis.
Le nombre de bits définis dans ces nombres est 9. Donc, la somme des prix des 6 premiers nombres est 9.
Ainsi, la réponse est 6.
Exemple 2 :

Entrée : k = 7, x = 2
Sortie : 9
Explication : Puisque x est égal à 2, nous devrions simplement vérifier les bits de numéro pair.
Le deuxième bit de la représentation binaire des nombres 2 et 3 est un bit défini. Donc, la somme de leurs prix est 2.
Le deuxième bit de la représentation binaire des nombres 6 et 7 est un bit défini. Donc, la somme de leurs prix est 2.
Le quatrième bit de la représentation binaire des nombres 8 et 9 est un bit défini mais leur deuxième bit ne l'est pas. Donc, la somme de leurs prix est 2.
Les nombres 1, 4 et 5 n'ont pas de bits définis dans leurs bits de numéro pair dans leur représentation binaire. Donc, la somme de leurs prix est 0.
Le deuxième et le quatrième bit de la représentation binaire du nombre 10 sont des bits définis. Donc, son prix est 2.
La somme des prix des 9 premiers nombres est 6.
Comme la somme des prix des 10 premiers nombres est 8, la réponse est 9.

Contraintes :

1 <= k <= 10^15
1 <= x <= 8

On vous donne un entier k et un entier x.
Considérons que s est la représentation binaire à base 1 d'un entier num. Le prix d'un chiffre num est le chiffre de i tels que i % x == 0 et s[i] est un bit défini.
Retournez le plus grand entier num tel que la somme des prix de tous les chiffres de 1 à num soit inférieure ou égale à k.
Remarques :

Dans la représentation binaire d'un chiffre, un bit défini est un bit de valeur 1.
La représentation binaire d'un nombre sera indexée de droite à gauche. Par exemple, si s == 11100, s[4] == 1 et s[2] == 0.

Exemple 1 :

Entrée : k = 9, x = 1
Sortie : 6
Explication : Les nombres 1, 2, 3, 4, 5 et 6 peuvent être écrits en représentation binaire sous forme de "1", "10", "11", "100", "101" et "110" respectivement.
Puisque x est égal à 1, le prix de chaque nombre est le nombre de ses bits définis.
Le nombre de bits définis dans ces nombres est 9. Donc, la somme des prix des 6 premiers nombres est 9.
Ainsi, la réponse est 6.
Exemple 2 :

Entrée : k = 7, x = 2
Sortie : 9
Explication : Puisque x est égal à 2, nous devrions simplement vérifier les bits de numéro pair.
Le deuxième bit de la représentation binaire des nombres 2 et 3 est un bit défini. Donc, la somme de leurs prix est 2.
Le deuxième bit de la représentation binaire des nombres 6 et 7 est un bit défini. Donc, la somme de leurs prix est 2.
Le quatrième bit de la représentation binaire des nombres 8 et 9 est un bit défini mais leur deuxième bit ne l'est pas. Donc, la somme de leurs prix est 2.
Les nombres 1, 4 et 5 n'ont pas de bits définis dans leurs bits de numéro pair dans leur représentation binaire. Donc, la somme de leurs prix est 0.
Le deuxième et le quatrième bit de la représentation binaire du nombre 10 sont des bits définis. Donc, son prix est 2.
La somme des prix des 9 premiers nombres est 6.
Comme la somme des prix des 10 premiers nombres est 8, la réponse est 9.

Contraintes :

1 <= k <= 10^15
1 <= x <= 8

On vous donne un entier k et un entier x.
Considérons que s est la représentation binaire à base 1 d'un entier num. Le prix d'un nombre num est le nombre de i tels que i % x == 0 et s[i] est un bit défini.
Retournez le plus grand entier num tel que la somme des prix de tous les nombres de 1 à num soit inférieure ou égale à k.
Remarques :

Dans la représentation binaire d'un nombre, un bit défini est un bit de valeur 1.
La représentation binaire d'un nombre sera indexée de droite à gauche. Par exemple, si s == 11100, s[4] == 1 et s[2] == 0.

Exemple 1 :

Entrée : k = 9, x = 1
Sortie : 6
Explication : Les nombres 1, 2, 3, 4, 5 et 6 peuvent être écrits en représentation binaire sous forme de "1", "10", "11", "100", "101" et "110" respectivement.
Puisque x est égal à 1, le prix de chaque nombre est le nombre de ses bits définis.
Le nombre de bits définis dans ces nombres est 9. Donc, la somme des prix des 6 premiers nombres est 9.
Ainsi, la réponse est 6.
Exemple 2 :

Entrée : k = 7, x = 2
Sortie : 9
Explication : Puisque x est égal à 2, nous devrions simplement vérifier les bits de numéro pair.
Le deuxième bit de la représentation binaire des nombres 2 et 3 est un bit défini. Donc, la somme de leurs prix est 2.
Le deuxième bit de la représentation binaire des nombres 6 et 7 est un bit défini. Donc, la somme de leurs prix est 2.
Le quatrième bit de la représentation binaire des nombres 8 et 9 est un bit défini mais leur deuxième bit ne l'est pas. Donc, la somme de leurs prix est 2.
Les nombres 1, 4 et 5 n'ont pas de bits définis dans leurs bits de numéro pair dans leur représentation binaire. Donc, la somme de leurs prix est 0.
Le deuxième et le quatrième bit de la représentation binaire du nombre 10 sont des bits définis. Donc, son prix est 2.
La somme des prix des 9 premiers nombres est 6.
Comme la somme des prix des 10 premiers nombres est 8, la réponse est 9.

Contraintes :

1 <= k <= 10^15
1 <= x <= 8


On vous donne un tableau nums constitué d'entiers positifs.
Retournez la somme des fréquences des éléments dans nums tels que ces éléments ont tous la fréquence maximale.
La fréquence d'un élément est le nombre d'occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,2,3,1,4]
Sortie : 4
Explication : Les éléments 1 et 2 ont une fréquence de 2, ce qui correspond à la fréquence maximale dans le tableau.
Ainsi, le nombre d'éléments dans le tableau avec la fréquence maximale est 4.

Exemple 2 :

Entrée : nums = [1,2,3,4,5]
Sortie : 5
Explication : Tous les éléments du tableau ont une fréquence de 1, ce qui correspond à la fréquence maximale.
Ainsi, le nombre d'éléments dans le tableau avec la fréquence maximale est 5.

Contraintes :

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

Vous avez un tableau nums composé d'entiers positifs.
Retournez la somme des fréquences des éléments dans nums tels que ces éléments ont tous la fréquence maximale.
La fréquence d’un élément est le nombre d’occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,2,3,1,4]
Sortie : 4
Explication : Les éléments 1 et 2 ont une fréquence de 2 qui est la fréquence maximale dans le tableau.
Ainsi, le nombre d’éléments dans le tableau avec une fréquence maximale est de 4.

Exemple 2 :

Entrée : nums = [1,2,3,4,5]
Sortie : 5
Explication : Tous les éléments du réseau ont une fréquence de 1, ce qui est le maximum.
Ainsi, le nombre d’éléments dans le réseau avec une fréquence maximale est de 5.

Contraintes:

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

On vous donne un tableau nums composé d'entiers positifs.
Renvoie les fréquences totales des éléments dans nums tels que ces éléments aient tous la fréquence maximale.
La fréquence d'un élément est le nombre d'occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,2,3,1,4]
Sortie : 4
Explication : Les éléments 1 et 2 ont une fréquence de 2, qui est la fréquence maximale dans le tableau.
Le nombre d'éléments dans le tableau ayant une fréquence maximale est donc de 4.

Exemple 2 :

Entrée : nums = [1,2,3,4,5]
Sortie : 5
Explication : Tous les éléments du tableau ont une fréquence de 1, qui est la fréquence maximale.
Ainsi, le nombre d'éléments dans le tableau avec une fréquence maximale est de 5.

Contraintes :

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


Vous avez trois entiers start, finish et limit. On vous donne également une chaîne s indexée à 0 représentant un entier positif.
Un entier positif x est dit puissant s'il se termine par s (en d'autres termes, s est un suffixe de x) et chaque chiffre de x est au plus limit.
Retournez le nombre total d'entiers puissants dans l'intervalle [start..finish].
Une chaîne x est un suffixe d'une chaîne y si et seulement si x est une sous-chaîne de y qui commence à partir d'un certain indice (y compris 0) dans y et s'étend jusqu'à l'index y.length - 1. Par exemple, 25 est un suffixe de 5125 alors que 512 ne l'est pas.

Exemple 1 :

Entrée : start = 1, finish = 6000, limit = 4, s = "124"
Sortie : 5
Explication : Les entiers puissants dans l'intervalle [1..6000] sont 124, 1124, 2124, 3124, et 4124. Tous ces entiers ont chaque chiffre <= 4, et "124" comme suffixe. Notez que 5124 n'est pas un entier puissant car le premier chiffre est 5 qui est supérieur à 4. On peut montrer qu'il n'y a que 5 entiers puissants dans cet intervalle.

Exemple 2 :

Entrée : start = 15, finish = 215, limit = 6, s = "10"
Sortie : 2
Explication : Les entiers puissants dans l'intervalle [15..215] sont 110 et 210. Tous ces entiers ont chaque chiffre <= 6, et "10" comme suffixe.
On peut montrer qu'il n'y a que 2 entiers puissants dans cet intervalle.

Exemple 3 :

Entrée : start = 1000, finish = 2000, limit = 4, s = "3000"
Sortie : 0
Explication : Tous les entiers dans l'intervalle [1000..2000] sont plus petits que 3000, donc "3000" ne peut pas être un suffixe d'un entier dans cet intervalle.

Contraintes :

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s ne contient que des chiffres numériques qui sont au plus limit.
s n'a pas de zéros en tête.

On vous donne trois entiers début, fin et limite. On vous donne également une chaîne indexée 0 représentant un entier positif.
Un entier positif X est appelé puissant s'il se termine par S (en d'autres termes, S est un suffixe de x) et chaque chiffre en x est au plus limite.
Renvoie le nombre total d'entiers puissants dans la gamme [start..finish].
Une chaîne x est un suffixe d'une chaîne y si x est une sous-chaîne de y commençant à un index (y compris 0) et s'étendant jusqu'à l'index y.length - 1. Par exemple, 25 est un suffixe de 5125 alors que 512 ne l'est pas.

Exemple 1:

Entrée: start = 1, finish = 6000, limit = 4, s = "124"
Sortie: 5
Explication: Les entiers puissants de la gamme [1..6000] sont 124, 1124, 2124, 3124 et, 4124. Tous ces entiers ont chaque chiffre <= 4 et "124" comme suffixe. Notez que 5124 n'est pas un entier puissant car le premier chiffre est 5, ce qui est supérieur à 4.
On peut montrer qu'il n'y a que 5 entiers puissants dans cette gamme.

Exemple 2:

Entrée: start = 15, finish = 215, limit = 6, s = "10"
Sortie: 2
Explication: Les entiers puissants de la gamme [15..215] sont 110 et 210. Tous ces entiers ont chaque chiffre <= 6 et "10" comme suffixe.
On peut montrer qu'il n'y a que 2 entiers puissants dans cette gamme.

Exemple 3:

Entrée: start = 1000, finish = 2000, limit = 4, s = "3000"
Sortie: 0
Explication: Tous les entiers de la gamme [1000..2000] sont inférieurs à 3000, par conséquent "3000" ne peuvent pas être un suffixe d'aucun entier dans cette gamme.

Contraintes:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
S ne contient que des chiffres numériques qui sont au plus limit.
S ne contient pas de zéros initiaux.

Vous avez trois entiers start, finish et limit. On vous donne également une chaîne s indexée à 0 représentant un entier positif. Un entier positif x est dit puissant s'il se termine par s (en d'autres termes, s est un suffixe de x) et chaque chiffre de x est au plus limit. Retournez le nombre total d'entiers puissants dans l'intervalle [start..finish]. Une chaîne x est un suffixe d'une chaîne y si et seulement si x est une sous-chaîne de y qui commence à partir d'un certain indice (y compris 0) dans y et s'étend jusqu'à l'index y.length - 1. Par exemple, 25 est un suffixe de 5125 alors que 512 ne l'est pas.

Exemple 1 :

Entrée : start = 1, finish = 6000, limit = 4, s = "124"
Sortie : 5
Explication : Les entiers puissants dans l'intervalle [1..6000] sont 124, 1124, 2124, 3124, et 4124. Tous ces entiers ont chaque chiffre <= 4, et "124" comme suffixe. Notez que 5124 n'est pas un entier puissant car le premier chiffre est 5 qui est supérieur à 4. On peut montrer qu'il n'y a que 5 entiers puissants dans cet intervalle.

Exemple 2 :

Entrée : start = 15, finish = 215, limit = 6, s = "10"
Sortie : 2
Explication : Les entiers puissants dans l'intervalle [15..215] sont 110 et 210. Tous ces entiers ont chaque chiffre <= 6, et "10" comme suffixe. On peut montrer qu'il n'y a que 2 entiers puissants dans cet intervalle.

Exemple 3 :

Entrée : start = 1000, finish = 2000, limit = 4, s = "3000"
Sortie : 0
Explication : Tous les entiers dans l'intervalle [1000..2000] sont plus petits que 3000, donc "3000" ne peut pas être un suffixe d'un entier dans cet intervalle.

Contraintes :

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s ne contient que des chiffres numériques qui sont au plus limit.
s n'a pas de zéros devant.


On vous donne un tableau d'entiers indexé à partir de zéro, nums, contenant des entiers positifs. Votre tâche est de minimiser la longueur de nums en effectuant les opérations suivantes un nombre quelconque de fois (y compris zéro) :

Sélectionnez deux indices distincts i et j de nums, tels que nums[i] > 0 et nums[j] > 0.
Insérez le résultat de nums[i] % nums[j] à la fin de nums.
Supprimez les éléments aux indices i et j de nums.

Retournez un entier indiquant la longueur minimale de nums après avoir effectué l'opération un nombre quelconque de fois.

Exemple 1 :

Entrée : nums = [1,4,3,1]
Sortie : 1
Explication : Une manière de minimiser la longueur du tableau est la suivante :
Opération 1 : Sélectionnez les indices 2 et 1, insérez nums[2] % nums[1] à la fin et il devient [1,4,3,1,3], puis supprimez les éléments aux indices 2 et 1.
nums devient [1,1,3].
Opération 2 : Sélectionnez les indices 1 et 2, insérez nums[1] % nums[2] à la fin et il devient [1,1,3,1], puis supprimez les éléments aux indices 1 et 2.
nums devient [1,1].
Opération 3 : Sélectionnez les indices 1 et 0, insérez nums[1] % nums[0] à la fin et il devient [1,1,0], puis supprimez les éléments aux indices 1 et 0.
nums devient [0].
La longueur de nums ne peut pas être réduite davantage. Par conséquent, la réponse est 1.
On peut montrer que 1 est la longueur minimale atteignable.
Exemple 2 :

Entrée : nums = [5,5,5,10,5]
Sortie : 2
Explication : Une manière de minimiser la longueur du tableau est la suivante :
Opération 1 : Sélectionnez les indices 0 et 3, insérez nums[0] % nums[3] à la fin et il devient [5,5,5,10,5,5], puis supprimez les éléments aux indices 0 et 3.
nums devient [5,5,5,5].
Opération 2 : Sélectionnez les indices 2 et 3, insérez nums[2] % nums[3] à la fin et il devient [5,5,5,5,0], puis supprimez les éléments aux indices 2 et 3.
nums devient [5,5,0].
Opération 3 : Sélectionnez les indices 0 et 1, insérez nums[0] % nums[1] à la fin et il devient [5,5,0,0], puis supprimez les éléments aux indices 0 et 1.
nums devient [0,0].
La longueur de nums ne peut pas être réduite davantage. Par conséquent, la réponse est 2.
On peut montrer que 2 est la longueur minimale atteignable.
Exemple 3 :

Entrée : nums = [2,3,4]
Sortie : 1
Explication : Une manière de minimiser la longueur du tableau est la suivante :
Opération 1 : Sélectionnez les indices 1 et 2, insérez nums[1] % nums[2] à la fin et il devient [2,3,4,3], puis supprimez les éléments aux indices 1 et 2.
nums devient [2,3].
Opération 2 : Sélectionnez les indices 1 et 0, insérez nums[1] % nums[0] à la fin et il devient [2,3,1], puis supprimez les éléments aux indices 1 et 0.
nums devient [1].
La longueur de nums ne peut pas être réduite davantage. Par conséquent, la réponse est 1.
On peut montrer que 1 est la longueur minimale atteignable.

Contraintes :

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

On vous donne un tableau d'entiers indexé à partir de zéro, `nums`, contenant des entiers positifs. Votre tâche est de minimiser la longueur de `nums` en effectuant les opérations suivantes un nombre quelconque de fois (y compris zéro) :

Sélectionnez deux indices distincts i et j de `nums`, tels que `nums[i] > 0` et `nums[j] > 0`. Insérez le résultat de `nums[i] % nums[j]` à la fin de `nums`. Supprimez les éléments aux indices i et j de `nums`.

Renvoyez un entier indiquant la longueur minimale de `nums` après avoir effectué l'opération un nombre quelconque de fois.

Exemple 1 :

Entrée : nums = [1,4,3,1] Sortie : 1 Explication : Une manière de minimiser la longueur du tableau est la suivante : Opération 1 : Sélectionnez les indices 2 et 1, insérez `nums[2] % nums[1]` à la fin et il devient [1,4,3,1,3], puis supprimez les éléments aux indices 2 et 1. `nums` devient [1,1,3]. Opération 2 : Sélectionnez les indices 1 et 2, insérez `nums[1] % nums[2]` à la fin et il devient [1,1,3,1], puis supprimez les éléments aux indices 1 et 2. `nums` devient [1,1]. Opération 3 : Sélectionnez les indices 1 et 0, insérez `nums[1] % nums[0]` à la fin et il devient [1,1,0], puis supprimez les éléments aux indices 1 et 0. `nums` devient [0]. La longueur de `nums` ne peut pas être réduite davantage. Par conséquent, la réponse est 1. On peut montrer que 1 est la longueur minimale atteignable.

Exemple 2 :

Entrée : nums = [5,5,5,10,5] Sortie : 2 Explication : Une manière de minimiser la longueur du tableau est la suivante : Opération 1 : Sélectionnez les indices 0 et 3, insérez `nums[0] % nums[3]` à la fin et il devient [5,5,5,10,5,5], puis supprimez les éléments aux indices 0 et 3. `nums` devient [5,5,5,5]. Opération 2 : Sélectionnez les indices 2 et 3, insérez `nums[2] % nums[3]` à la fin et il devient [5,5,5,5,0], puis supprimez les éléments aux indices 2 et 3. `nums` devient [5,5,0]. Opération 3 : Sélectionnez les indices 0 et 1, insérez `nums[0] % nums[1]` à la fin et il devient [5,5,0,0], puis supprimez les éléments aux indices 0 et 1. `nums` devient [0,0]. La longueur de `nums` ne peut pas être réduite davantage. Par conséquent, la réponse est 2. On peut montrer que 2 est la longueur minimale atteignable.

Exemple 3 :

Entrée : nums = [2,3,4] Sortie : 1 Explication : Une manière de minimiser la longueur du tableau est la suivante : Opération 1 : Sélectionnez les indices 1 et 2, insérez `nums[1] % nums[2]` à la fin et il devient [2,3,4,3], puis supprimez les éléments aux indices 1 et 2. `nums` devient [2,3]. Opération 2 : Sélectionnez les indices 1 et 0, insérez `nums[1] % nums[0]` à la fin et il devient [2,3,1], puis supprimez les éléments aux indices 1 et 0. `nums` devient [1]. La longueur de `nums` ne peut pas être réduite davantage. Par conséquent, la réponse est 1. On peut montrer que 1 est la longueur minimale atteignable.

Contraintes :

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

On vous donne un tableau entier indexé 0 contenant des entiers positifs.
Votre tâche consiste à minimiser la longueur de nums en effectuant les opérations suivantes à plusieurs reprises (y compris zéro):

Sélectionnez deux indices distincts i et j de nums, tels que nums[i]> 0 et nums[j]> 0.
Insérez le résultat de nums[i]% nums[j] à la fin des nombres.
Supprimez les éléments des indices i et j de nums.

Renvoie un entier indiquant la longueur minimale de nums après avoir effectué l'opération pour un certain nombre de fois.

Exemple 1:

Entrée: nums = [1,4,3,1]
Sortie: 1
Explication: Une façon de minimiser la longueur du tableau est la suivante:
Opération 1: Sélectionnez les indices 2 et 1, insérez nums[2] % nums[1] à la fin et cela devient [1,4,3,1,3], puis supprimez les éléments aux indices 2 et 1.
nums devient [1,1,3].
Opération 2: Sélectionnez les indices 1 et 2, insérez nums[1] % nums[2] à la fin, et il devient [1,1,3,1], puis supprimez les éléments aux indices 1 et 2.
nums devient [1,1].
Opération 3: Sélectionnez les indices 1 et 0, insérez nums[1] % nums[0] à la fin et cela devient [1,1,0], puis supprimez les éléments aux indices 1 et 0.
nums devient [0].
La longueur des num ne peut pas être réduite davantage. Par conséquent, la réponse est 1.
On peut montrer que 1 est la longueur minimale réalisable.
Exemple 2:

Entrée: nums = [5,5,5,10,5]
Sortie: 2
Explication: Une façon de minimiser la longueur du tableau est la suivante:
Opération 1 : Sélectionnez les indices 0 et 3, insérez nums[0] % nums[3] à la fin et cela devient [5,5,5,10,5,5], puis supprimez les éléments aux indices 0 et 3.
nums devient [5,5,5,5].
Opération 2 : Sélectionnez les indices 2 et 3, insérez nums[2] % nums[3] à la fin et cela devient [5,5,5,5,0], puis supprimez les éléments aux indices 2 et 3.
nums devient [5,5,0].
Opération 3 : Sélectionnez les indices 0 et 1, insérez nums[0] % nums[1] à la fin et cela devient [5,5,0,0], puis supprimez les éléments aux indices 0 et 1.
nums devient [0,0].
La longueur des num ne peut pas être réduite davantage. Par conséquent, la réponse est 2.
On peut montrer que 2 est la longueur minimale réalisable.
Exemple 3:

Entrée: nums = [2,3,4]
Sortie: 1
Explication: Une façon de minimiser la longueur du tableau est la suivante:
Opération 1 : Sélectionnez les indices 1 et 2, insérez nums[1] % nums[2] à la fin et cela devient [2,3,4,3], puis supprimez les éléments aux indices 1 et 2.
nums devient [2,3].
Opération 2 : Sélectionnez les indices 1 et 0, insérez nums[1] % nums[0] à la fin et cela devient [2,3,1], puis supprimez les éléments aux indices 1 et 0.
nums devient [1].
La longueur des num ne peut pas être réduite davantage. Par conséquent, la réponse est 1.
On peut montrer que 1 est la longueur minimale réalisable.

Contraintes:

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