On vous donne une chaîne de caractères s composée uniquement de lettres majuscules anglaises.
Vous pouvez effectuer des opérations sur cette chaîne où, lors d'une opération, vous pouvez supprimer toute occurrence de l'une des sous-chaînes "AB" ou "CD" de s.
Retournez la longueur minimale possible de la chaîne résultante que vous pouvez obtenir.
Notez que la chaîne se concatène après la suppression de la sous-chaîne et pourrait produire de nouvelles sous-chaînes "AB" ou "CD".

Exemple 1 :

Entrée : s = "ABFCACDB"
Sortie : 2
Explication : Nous pouvons effectuer les opérations suivantes :
- Supprimer la sous-chaîne "ABFCACDB", donc s = "FCACDB".
- Supprimer la sous-chaîne "FCACDB", donc s = "FCAB".
- Supprimer la sous-chaîne "FCAB", donc s = "FC".
Donc la longueur résultante de la chaîne est de 2.
Il peut être démontré que c'est la longueur minimale que nous pouvons obtenir.
Exemple 2 :

Entrée : s = "ACBBD"
Sortie : 5
Explication : Nous ne pouvons effectuer aucune opération sur la chaîne donc la longueur reste la même.

Contraintes :

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

On vous donne une chaîne s composée uniquement de lettres majuscules anglaises.
Vous pouvez appliquer certaines opérations à cette chaîne où, en une seule opération, vous pouvez supprimer toute occurrence de l'une des sous-chaînes « AB » ou « CD » de s.
Renvoie la longueur minimale possible de la chaîne résultante que vous pouvez obtenir.
Notez que la chaîne se concatène après la suppression de la sous-chaîne et pourrait produire de nouvelles sous-chaînes « AB » ou « CD ».

Exemple 1 :

Entrée : s = "ABFCACDB"
Sortie : 2
Explication : Nous pouvons effectuer les opérations suivantes :
- Supprimer la sous-chaîne « ABFCACDB », donc s = "FCACDB".
- Supprimer la sous-chaîne « FCACDB », donc s = "FCAB".
- Supprimer la sous-chaîne « FCAB », donc s = "FC".
La longueur résultante de la chaîne est donc de 2.
On peut montrer qu'il s'agit de la longueur minimale que nous pouvons obtenir.
Exemple 2 :

Entrée : s = "ACBBD"
Sortie : 5
Explication : Nous ne pouvons effectuer aucune opération sur la chaîne, la longueur reste donc la même.

Contraintes :

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

On vous donne une chaîne de caractères s composée uniquement de lettres majuscules anglaises.
Vous pouvez appliquer des opérations à cette chaîne où, dans une opération, vous pouvez supprimer toute occurrence de l'une des sous-chaînes "AB" ou "CD" de s.
Retournez la longueur minimale possible de la chaîne résultante que vous pouvez obtenir.
Notez que la chaîne se concatène après la suppression de la sous-chaîne et pourrait produire de nouvelles sous-chaînes "AB" ou "CD".

Exemple 1 :

Entrée : s = "ABFCACDB"
Sortie : 2
Explication : Nous pouvons effectuer les opérations suivantes :
- Supprimer la sous-chaîne "ABFCACDB", donc s = "FCACDB".
- Supprimer la sous-chaîne "FCACDB", donc s = "FCAB".
- Supprimer la sous-chaîne "FCAB", donc s = "FC".
Donc la longueur résultante de la chaîne est de 2.
Il peut être démontré que c'est la longueur minimale que nous pouvons obtenir.
Exemple 2 :

Entrée : s = "ACBBD"
Sortie : 5
Explication : Nous ne pouvons effectuer aucune opération sur la chaîne donc la longueur reste la même.

Contraintes :

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


Étant donné un entier positif n, retournez le nombre de punition de n.
Le nombre de punition de n est défini comme la somme des carrés de tous les entiers i tels que :

1 <= i <= n
La représentation décimale de i * i peut être partitionnée en sous-chaînes contiguës de sorte que la somme des valeurs entières de ces sous-chaînes soit égale à i.

Exemple 1 :

Entrée : n = 10
Sortie : 182
Explication : Il y a exactement 3 entiers i qui satisfont les conditions dans l'énoncé :
- 1 car 1 * 1 = 1
- 9 car 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 car 10 * 10 = 100 et 100 peut être partitionné en 10 + 0.
Par conséquent, le nombre de punition de 10 est 1 + 81 + 100 = 182

Exemple 2 :

Entrée : n = 37
Sortie : 1478
Explication : il y a exactement 4 entiers i qui satisfont les conditions dans l'énoncé :
- 1 car 1 * 1 = 1.
- 9 car 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 car 10 * 10 = 100 et 100 peut être partitionné en 10 + 0.
- 36 car 36 * 36 = 1296 et 1296 peut être partitionné en 1 + 29 + 6.
Par conséquent, le nombre de punition de 37 est 1 + 81 + 100 + 1296 = 1478

Contraintes :

1 <= n <= 1000

Étant donné un entier positif n, retournez le nombre de punition de n.
Le nombre de punition de n est défini comme la somme des carrés de tous les entiers i tels que :

1 <= i <= n
La représentation décimale de i * i peut être partitionnée en sous-chaînes contiguës de sorte que la somme des valeurs entières de ces sous-chaînes soit égale à i.

Exemple 1 :

Entrée : n = 10
Sortie : 182
Explication : Il y a exactement 3 entiers i qui satisfont les conditions dans l'énoncé :
- 1 car 1 * 1 = 1
- 9 car 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 car 10 * 10 = 100 et 100 peut être partitionné en 10 + 0.
Par conséquent, le nombre de punition de 10 est 1 + 81 + 100 = 182

Exemple 2 :

Entrée : n = 37
Sortie : 1478
Explication : Il y a exactement 4 entiers i qui satisfont les conditions dans l'énoncé :
- 1 car 1 * 1 = 1.
- 9 car 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 car 10 * 10 = 100 et 100 peut être partitionné en 10 + 0.
- 36 car 36 * 36 = 1296 et 1296 peut être partitionné en 1 + 29 + 6.
Par conséquent, le nombre de punition de 37 est 1 + 81 + 100 + 1296 = 1478

Contraintes :

1 <= n <= 1000

Étant donné un entier positif n, retournez le nombre de punition de n.
Le nombre de punition de n est défini comme la somme des carrés de tous les entiers i tel que:

1 <= i <= n
La représentation décimale de i * i peux être partitionnée en sous-chaînes contiguës de telle sorte que la somme des valeurs entières de ces sous-chaînes égales i.

Exemple 1:

Entrée: n = 10
Sortie: 182
Explication: Il y a exactement 3 entiers i qui remplissent les conditions de la déclaration:
- 1 depuis 1 * 1 = 1
- 9 Depuis 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 Depuis 10 * 10 = 100 et 100 peut être partitionné en 10 + 0.
Par conséquent, le nombre de punition de 10 est de 1 + 81 + 100 = 182

Exemple 2:

Entrée: n = 37
Sortie: 1478
Explication: Il y a exactement 4 entiers i qui remplissent les conditions de la déclaration:
- 1 depuis 1 * 1 = 1.
- 9 depuis 9 * 9 = 81 et 81 peut être partitionné en 8 + 1.
- 10 depuis 10 * 10 = 100 et 100 peuvent être partitionnés en 10 + 0.
- 36 depuis 36 * 36 = 1296 et 1296 peuvent être partitionnés en 1 + 29 + 6.
Par conséquent, le nombre de punition de 37 est 1 + 81 + 100 + 1296 = 1478

Contraintes:

1 <= n <= 1000


Vous avez deux tableaux d'entiers indexés à partir de 0, cost et time, de taille n représentant respectivement les coûts et le temps nécessaire pour peindre n murs différents. Il y a deux peintres disponibles :

Un peintre payé qui peint le i^ème mur en time[i] unités de temps et prend cost[i] unités d'argent.
Un peintre gratuit qui peint n'importe quel mur en 1 unité de temps à un coût de 0. Mais le peintre gratuit ne peut être utilisé que si le peintre payé est déjà occupé.

Retournez le montant minimum d'argent nécessaire pour peindre les n murs.

Exemple 1:

Input: cost = [1,2,3,2], time = [1,2,3,2]
Output: 3
Explication : Les murs aux indices 0 et 1 seront peints par le peintre payé, et cela prendra 3 unités de temps ; pendant ce temps, le peintre gratuit peindra les murs aux indices 2 et 3, sans coût en 2 unités de temps. Ainsi, le coût total est 1 + 2 = 3.

Exemple 2:

Input: cost = [2,3,4,2], time = [1,1,1,1]
Output: 4
Explication : Les murs aux indices 0 et 3 seront peints par le peintre payé, et cela prendra 2 unités de temps ; pendant ce temps, le peintre gratuit peindra les murs aux indices 1 et 2, sans coût en 2 unités de temps. Ainsi, le coût total est 2 + 2 = 4.

Contraintes :

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

Vous avez deux tableaux d'entiers indexés à partir de 0, cost et time, de taille n représentant les coûts et le temps nécessaire pour peindre n murs différents respectivement. Il y a deux peintres disponibles :

Un peintre payé qui peint le i^ème mur en time[i] unités de temps et prend cost[i] unités d'argent.
Un peintre gratuit qui peint n'importe quel mur en 1 unité de temps à un coût de 0. Mais le peintre gratuit ne peut être utilisé que si le peintre payé est déjà occupé.

Retournez le montant minimum d'argent nécessaire pour peindre les n murs.

Exemple 1:

Input: cost = [1,2,3,2], time = [1,2,3,2]
Output: 3
Explication : les murs aux indices 0 et 1 seront peints par le peintre payé, et cela prendra 3 unités de temps ; pendant ce temps, le peintre gratuit peindra les murs aux indices 2 et 3, sans coût en 2 unités de temps. Ainsi, le coût total est 1 + 2 = 3.

Exemple 2:

Input: cost = [2,3,4,2], time = [1,1,1,1]
Output: 4
Explication : les murs aux indices 0 et 3 seront peints par le peintre payé, et cela prendra 2 unités de temps ; pendant ce temps, le peintre gratuit peindra les murs aux indices 1 et 2, sans coût en 2 unités de temps. Ainsi, le coût total est 2 + 2 = 4.

Contraintes :

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

On vous donne deux tableaux d’entiers indexés 0, coût et temps, de taille n, représentant respectivement les coûts et le temps nécessaires pour peindre n murs différents. Il y a deux peintres disponibles :

Un peintre rémunéré qui peint le i^ème mur en unités de temps[i] unités de temps et prend des unités de coût[i] d’argent.
Un peintre gratuit qui peint n’importe quel mur en 1 unité de temps pour un coût de 0. Mais le peintre gratuit ne peut être utilisé que si le peintre rémunéré est déjà occupé.

Retournez le montant minimum d’argent requis pour peindre les n murs.

Exemple 1 :

Entrée : coût = [1,2,3,2], temps = [1,2,3,2]
Sortie : 3
Explication : Les murs à l’indice 0 et 1 seront peints par le peintre rémunéré, et cela prendra 3 unités de temps ; Pendant ce temps, le peintre libre peindra les murs aux indices 2 et 3, gratuitement en 2 unités de temps. Ainsi, le coût total est de 1 + 2 = 3.

Exemple 2 :

Entrée : coût = [2,3,4,2], temps = [1,1,1,1]
Sortie : 4
Explication : Les murs à l’indice 0 et 3 seront peints par le peintre rémunéré, et cela prendra 2 unités de temps ; Pendant ce temps, le peintre libre peindra les murs aux indices 1 et 2, gratuitement en 2 unités de temps. Ainsi, le coût total est de 2 + 2 = 4.

Contraintes:

1 <= coût.longueur <= 500
cost.length == temps.length
1 <= coût[i] <= 10^6
1 <= temps[i] <= 500


On vous donne un tableau d'entiers `nums` de taille `n` représentant le coût de collecte de différents chocolats. Le coût de collecte du chocolat à l'index `i` est `nums[i]`. Chaque chocolat est d'un type différent et, initialement, le chocolat à l'index `i` est du `i^ème` type.
Dans une opération, vous pouvez effectuer l'action suivante avec un coût supporté de `x` :

Changer simultanément le chocolat du `i^ème` type en `((i + 1) mod n)^ème` type pour tous les chocolats.

Renvoyez le coût minimum pour collecter les chocolats de tous les types, étant donné que vous pouvez effectuer autant d'opérations que vous le souhaitez.

Exemple 1 :

Input: nums = [20,1,15], x = 5
Output: 13
Explication : Initialement, les types de chocolats sont [0,1,2]. Nous achèterons le 1^er type de chocolat à un coût de 1.
Maintenant, nous effectuerons l'opération à un coût de 5, et les types de chocolats deviendront [1,2,0]. Nous achèterons le 2^ème type de chocolat à un coût de 1.
Maintenant, nous allons de nouveau effectuer l'opération à un coût de 5, et les types de chocolats deviendront [2,0,1]. Nous achèterons le 0^ème type de chocolat à un coût de 1.
Ainsi, le coût total sera (1 + 5 + 1 + 5 + 1) = 13. Nous pouvons prouver que c'est optimal.

Exemple 2 :

Input: nums = [1,2,3], x = 4
Output: 6
Explication : Nous collecterons les trois types de chocolats à leur propre prix sans effectuer d'opérations. Par conséquent, le coût total est 1 + 2 + 3 = 6.

Contraintes :

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

On vous donne un tableau d'entiers nums de taille n représentant le coût de collecte de différents chocolats. Le coût de collecte du chocolat à l'index i est nums[i]. Chaque chocolat est d'un type différent et, initialement, le chocolat à l'index i est du i^ème type.
Dans une opération, vous pouvez effectuer l'action suivante avec un coût supporté de x :

Changer simultanément le chocolat du i^ème type en ((i + 1) mod n)^ème type pour tous les chocolats.

Retournez le coût minimum pour collecter les chocolats de tous les types, étant donné que vous pouvez effectuer autant d'opérations que vous le souhaitez.

Exemple 1 :

Entrée : nums = [20,1,15], x = 5
Sortie : 13
Explication : Initialement, les types de chocolats sont [0,1,2]. Nous achèterons le 1^er type de chocolat à un coût de 1.
Maintenant, nous effectuerons l'opération à un coût de 5, et les types de chocolats deviendront [1,2,0]. Nous achèterons le 2^ème type de chocolat à un coût de 1.
Maintenant, nous allons de nouveau effectuer l'opération à un coût de 5, et les types de chocolats deviendront [2,0,1]. Nous achèterons le 0^ème type de chocolat à un coût de 1.
Ainsi, le coût total sera (1 + 5 + 1 + 5 + 1) = 13. Nous pouvons prouver que c'est optimal.

Exemple 2 :

Entrée : nums = [1,2,3], x = 4
Sortie : 6
Explication : Nous collecterons les trois types de chocolats à leur propre prix sans effectuer d'opérations. Par conséquent, le coût total est 1 + 2 + 3 = 6.

Contraintes :

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

On vous donne un tableau d'entiers `nums` de taille `n` représentant le coût de collecte de différents chocolats. Le coût de collecte du chocolat à l'index `i` est `nums[i]`. Chaque chocolat est d'un type différent et, initialement, le chocolat à l'index `i` est du `i^ème` type.
Dans une opération, vous pouvez effectuer l'action suivante avec un coût supporté de `x` :

Changer simultanément le chocolat du `i^ème` type en `((i + 1) mod n)^ème` type pour tous les chocolats.

Retournez le coût minimum pour collecter les chocolats de tous les types, étant donné que vous pouvez effectuer autant d'opérations que vous le souhaitez.

Exemple 1 :

Input: nums = [20,1,15], x = 5
Output: 13
Explication : Initialement, les types de chocolats sont [0,1,2]. Nous achèterons le 1^er type de chocolat à un coût de 1.
Maintenant, nous effectuerons l'opération à un coût de 5, et les types de chocolats deviendront [1,2,0]. Nous achèterons le 2^ème type de chocolat à un coût de 1.
Maintenant, nous allons de nouveau effectuer l'opération à un coût de 5, et les types de chocolats deviendront [2,0,1]. Nous achèterons le 0^ème type de chocolat à un coût de 1.
Ainsi, le coût total sera (1 + 5 + 1 + 5 + 1) = 13. Nous pouvons prouver que c'est optimal.

Exemple 2 :

Input: nums = [1,2,3], x = 4
Output: 6
Explication : Nous collecterons les trois types de chocolats à leur propre prix sans effectuer d'opérations. Par conséquent, le coût total est 1 + 2 + 3 = 6.

Contraintes :

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


On vous donne deux entiers, n et k.
Un tableau d'entiers positifs distincts est appelé un tableau évitant k s'il n'existe pas de paire d'éléments distincts qui somme à k.
Retournez la somme minimale possible d'un tableau évitant k de longueur n.

Exemple 1 :

Entrée : n = 5, k = 4
Sortie : 18
Explication : Considérons le tableau évitant k [1,2,4,5,6], qui a une somme de 18. Il peut être prouvé qu'il n'existe pas de tableau évitant k avec une somme inférieure à 18.

Exemple 2 :

Entrée : n = 2, k = 6
Sortie : 3
Explication : Nous pouvons construire le tableau [1,2], qui a une somme de 3. Il peut être prouvé qu'il n'existe pas de tableau évitant k avec une somme inférieure à 3.

Contraintes :

1 <= n, k <= 50

On vous donne deux entiers, n et k.
Un tableau d'entiers positifs distincts est appelé tableau évitant k s'il n'existe aucune paire d'éléments distincts dont la somme est k.
Renvoie la somme minimale possible d'un tableau évitant k de longueur n.

Exemple 1 :

Entrée : n = 5, k = 4
Sortie : 18
Explication : Considérons le tableau k-avoiding [1,2,4,5,6], qui a une somme de 18.
Il peut être prouvé qu'il n'existe aucun tableau k-avoiding dont la somme est inférieure à 18.

Exemple 2 :

Entrée : n = 2, k = 6
Sortie : 3
Explication : Nous pouvons construire le tableau [1,2], qui a une somme de 3.
Il peut être prouvé qu'il n'existe aucun tableau k-avoiding dont la somme est inférieure à 3.

Contraintes :

1 <= n, k <= 50

Vous avez deux entiers, n et k.
Un tableau d'entiers positifs distincts est appelé un tableau évitant k s'il n'existe pas de paire d'éléments distincts dont la  somme est égale à k.
Retournez la somme minimale possible d'un tableau évitant k de longueur n.

Exemple 1 :

Entrée : n = 5, k = 4
Sortie : 18
Explication : Considérons le tableau évitant k [1,2,4,5,6], qui a une somme de 18.
Il peut être prouvé qu'il n'existe pas de tableau évitant k avec une somme inférieure à 18.

Exemple 2 :

Entrée : n = 2, k = 6
Sortie : 3
Explication : Nous pouvons construire le tableau [1,2], qui a une somme de 3.
Il peut être prouvé qu'il n'existe pas de tableau évitant k avec une somme inférieure à 3.

Contraintes :

1 <= n, k <= 50


On vous donne deux entiers, num et t.
Un entier x est dit atteignable s'il peut devenir égal à num après avoir appliqué l'opération suivante au maximum t fois :

Augmenter ou diminuer x de 1, et simultanément augmenter ou diminuer num de 1.

Retournez le plus grand nombre atteignable possible. Il peut être prouvé qu'il existe au moins un nombre atteignable.

Exemple 1 :

Entrée : num = 4, t = 1
Sortie : 6
Explication : Le plus grand nombre atteignable est x = 6 ; il peut devenir égal à num après avoir effectué cette opération :
1- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe pas de nombre atteignable plus grand que 6.

Exemple 2 :

Entrée : num = 3, t = 2
Sortie : 7
Explication : Le nombre atteignable maximum est x = 7 ; après avoir effectué ces opérations, x sera égal à num :
1- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 6 et num = 4.
2- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe pas de nombre atteignable plus grand que 7.

Contraintes :

1 <= num, t <= 50

Vous êtes donné deux entiers, num et t.
Un entier x est dit atteignable s'il peut devenir égal à num après avoir appliqué l'opération suivante au plus t fois :

Augmenter ou diminuer x de 1, et simultanément augmenter ou diminuer num de 1.

Retournez le nombre atteignable maximum possible. Il peut être prouvé qu'il existe au moins un nombre atteignable.

Exemple 1 :

Entrée : num = 4, t = 1
Sortie : 6
Explication : Le nombre atteignable maximum est x = 6 ; il peut devenir égal à num après avoir effectué cette opération :
1- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe pas de nombre atteignable plus grand que 6.

Exemple 2 :

Entrée : num = 3, t = 2
Sortie : 7
Explication : Le nombre atteignable maximum est x = 7 ; après avoir effectué ces opérations, x sera égal à num :
1- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 6 et num = 4.
2- Diminuer x de 1, et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe pas de nombre atteignable plus grand que 7.

Contraintes :

1 <= num, t <= 50

On vous donne deux entiers, num et t.
Un entier x est dit atteignable s'il peut devenir égal à num après avoir appliqué l'opération suivante au plus t fois :

Augmenter ou diminuer x de 1, et augmenter ou diminuer simultanément num de 1.

Renvoyer le nombre maximal atteignable possible. On peut prouver qu'il existe au moins un nombre atteignable.

Exemple 1 :

Entrée : num = 4, t = 1
Sortie : 6
Explication : Le nombre maximal atteignable est x = 6 ; il peut devenir égal à num après avoir effectué cette opération :
1- Diminuer x de 1 et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe aucun nombre atteignable supérieur à 6.

Exemple 2 :

Entrée : num = 3, t = 2
Sortie : 7
Explication : Le nombre maximum atteignable est x = 7 ; après avoir effectué ces opérations, x sera égal à num :
1- Diminuer x de 1 et augmenter num de 1. Maintenant, x = 6 et num = 4.
2- Diminuer x de 1 et augmenter num de 1. Maintenant, x = 5 et num = 5.
Il peut être prouvé qu'il n'existe aucun nombre atteignable supérieur à 7.

Contraintes :

1 <= num, t <= 50


On vous donne une chaîne de caractères s composée de lettres minuscules anglaises et vous êtes autorisé à effectuer des opérations dessus. Lors d'une opération, vous pouvez remplacer un caractère de s par une autre lettre minuscule anglaise.
Votre tâche est de transformer s en palindrome avec le minimum d'opérations possible. S'il existe plusieurs palindromes pouvant être créés en utilisant le nombre minimum d'opérations, réalisez celui qui est le plus petit lexicographiquement.
Une chaîne a est lexicographiquement plus petite qu'une chaîne b (de même longueur) si à la première position où a et b diffèrent, la chaîne a a une lettre qui apparaît plus tôt dans l'alphabet que la lettre correspondante dans b.
Retournez la chaîne palindrome résultante.

Exemple 1 :

Entrée : s = "egcfe"
Sortie : "efcfe"
Explication : Le nombre minimum d'opérations pour transformer "egcfe" en palindrome est de 1, et la plus petite chaîne palindrome que l'on peut obtenir en modifiant un caractère est "efcfe", en changeant 'g'.

Exemple 2 :

Entrée : s = "abcd"
Sortie : "abba"
Explication : Le nombre minimum d'opérations pour transformer "abcd" en palindrome est de 2, et la plus petite chaîne palindrome que l'on peut obtenir en modifiant deux caractères est "abba".

Exemple 3 :

Entrée : s = "seven"
Sortie : "neven"
Explication : Le nombre minimum d'opérations pour transformer "seven" en palindrome est de 1, et la plus petite chaîne palindrome que l'on peut obtenir en modifiant un caractère est "neven".

Contraintes :

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

On vous donne une chaîne de caractères s composée de lettres minuscules anglaises et vous êtes autorisé à effectuer des opérations dessus. Lors d'une opération, vous pouvez remplacer un caractère de s par une autre lettre minuscule anglaise.
Votre tâche est de transformer s en palindrome avec le minimum d'opérations possible. S'il existe plusieurs palindromes pouvant être créés en utilisant le nombre minimum d'opérations, réalisez celui qui est le plus petit lexicographiquement.
Une chaîne a est lexicographiquement plus petite qu'une chaîne b (de même longueur) si à la première position où a et b diffèrent, la chaîne a a une lettre qui apparaît plus tôt dans l'alphabet que la lettre correspondante dans b.
Retournez la chaîne palindrome résultante.

Exemple 1 :

Entrée : s = "egcfe"
Sortie : "efcfe"
Explication : Le nombre minimum d'opérations pour transformer "egcfe" en palindrome est de 1, et le palindrome lexicographiquement le plus petit que l'on puisse obtenir en modifiant un caractère est "efcfe", en changeant 'g'.

Exemple 2 :

Entrée : s = "abcd"
Sortie : "abba"
Explication : Le nombre minimum d'opérations pour transformer "abcd" en palindrome est de 2, et le palindrome  lexicographiquement le plus petit que l'on puisse obtenir en modifiant deux caractères est "abba".

Exemple 3 :

Entrée : s = "seven"
Sortie : "neven"
Explication : Le nombre minimum d'opérations pour transformer "seven" en palindrome est de 1, et le palindrome lexicographiquement le plus petit que l'on puisse obtenir en modifiant un caractère est "neven".

Contraintes :

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

On vous donne une chaîne composée de lettres anglaises minuscules, et vous êtes autorisé à effectuer des opérations dessus. Dans une opération, vous pouvez remplacer un caractère de S par une autre lettre d'anglais minuscule.
Votre tâche consiste à faire de S un palindrome avec le nombre minimum d'opérations possibles. S'il y a plusieurs palindromes qui peuvent être fabriqués en utilisant le nombre minimum d'opérations, faites le plus petit lexicographiquement.
Une chaîne A est lexiquement plus petite qu'une chaîne B (de la même longueur) si dans la première position où A et B diffèrent, la chaîne A a une lettre qui apparaît plus tôt dans l'alphabet que la lettre correspondante en b.
Renvoie la chaîne palindrome résultante.

Exemple 1:

Entrée: s = "egcfe"
Sortie: "efcfe"
Explication: Le nombre minimum d'opérations pour faire de "egcfe" un palindrome est 1, et la plus petite chaîne de palindrome lexicogrante que nous pouvons obtenir en modifiant un caractère est "efcfe", en changeant "g".

Exemple 2:

Entrée: s = "abcd"
Sortie: "abba"
Explication: Le nombre minimum d'opérations pour faire de "abcd" un palindrome est de 2, et la plus petite chaîne de palindrome lexicogrante que nous pouvons obtenir en modifiant deux caractères est "abba".

Exemple 3:

Entrée: s = "seven"
Sortie: "neven"
Explication: Le nombre minimum d'opérations pour faire des "sept" un palindrome est de 1, et la plus petite chaîne de palindrome lexicogrante que nous pouvons obtenir en modifiant un caractère est "neven".

Contraintes:

1 <= S.Length <= 1000
S ne contient que des lettres anglaises minuscules.


On vous donne une chaîne binaire indexée à partir de 0, \( s \), de longueur \( n \) sur laquelle vous pouvez appliquer deux types d'opérations :

Choisissez un index \( i \) et inversez tous les caractères de l'index 0 à l'index \( i \) (inclus), avec un coût de \( i + 1 \).
Choisissez un index \( i \) et inversez tous les caractères de l'index \( i \) à l'index \( n - 1 \) (inclus), avec un coût de \( n - i \).

Retournez le coût minimum pour rendre tous les caractères de la chaîne égaux.
Inverser un caractère signifie que si sa valeur est '0', elle devient '1' et vice-versa.

Exemple 1 :

Entrée : s = "0011"
Sortie : 2
Explication : Appliquer la deuxième opération avec \( i = 2 \) pour obtenir \( s = "0000" \) pour un coût de 2. On peut montrer que 2 est le coût minimum pour rendre tous les caractères égaux.

Exemple 2 :

Entrée : s = "010101"
Sortie : 9
Explication : Appliquer la première opération avec \( i = 2 \) pour obtenir \( s = "101101" \) pour un coût de 3.
Appliquer la première opération avec \( i = 1 \) pour obtenir \( s = "011101" \) pour un coût de 2.
Appliquer la première opération avec \( i = 0 \) pour obtenir \( s = "111101" \) pour un coût de 1.
Appliquer la deuxième opération avec \( i = 4 \) pour obtenir \( s = "111110" \) pour un coût de 2.
Appliquer la deuxième opération avec \( i = 5 \) pour obtenir \( s = "111111" \) pour un coût de 1.
Le coût total pour rendre tous les caractères égaux est 9. On peut montrer que 9 est le coût minimum pour rendre tous les caractères égaux.

Contraintes :

1 <= s.length == n <= 10^5
s[i] est soit '0' soit '1'

On vous donne une chaîne binaire indexée à partir de 0, \( s \), de longueur \( n \) sur laquelle vous pouvez appliquer deux types d'opérations :

Choisissez un index \( i \) et inversez tous les caractères de l'index 0 à l'index \( i \) (tous deux inclus), avec un coût de \( i + 1 \).
Choisissez un index \( i \) et inversez tous les caractères de l'index \( i \) à l'index \( n - 1 \) (tous deux inclus), avec un coût de \( n - i \).

Retournez le coût minimum pour rendre tous les caractères de la chaîne égaux.
Inverser un caractère signifie que si sa valeur est '0', elle devient '1' et vice-versa.

Exemple 1 :

Entrée : s = "0011"
Sortie : 2
Explication : Appliquer la deuxième opération avec \( i = 2 \) pour obtenir \( s = "0000" \) pour un coût de 2. On peut montrer que 2 est le coût minimum pour rendre tous les caractères égaux.

Exemple 2 :

Entrée : s = "010101"
Sortie : 9
Explication : Appliquer la première opération avec \( i = 2 \) pour obtenir \( s = "101101" \) pour un coût de 3.
Appliquer la première opération avec \( i = 1 \) pour obtenir \( s = "011101" \) pour un coût de 2.
Appliquer la première opération avec \( i = 0 \) pour obtenir \( s = "111101" \) pour un coût de 1.
Appliquer la deuxième opération avec \( i = 4 \) pour obtenir \( s = "111110" \) pour un coût de 2.
Appliquer la deuxième opération avec \( i = 5 \) pour obtenir \( s = "111111" \) pour un coût de 1.
Le coût total pour rendre tous les caractères égaux est 9. On peut montrer que 9 est le coût minimum pour rendre tous les caractères égaux.

Contraintes :

1 <= s.length == n <= 10^5
s[i] est soit '0' soit '1'

On vous donne une chaîne binaire s, indexée à partir de 0 et de longueur n, sur laquelle vous pouvez appliquer deux types d’opérations :

Choisissez un index \( i \) et inversez tous les caractères de l'index 0 à l'index \( i \) (inclus), avec un coût de \( i + 1 \).
Choisissez un index \( i \) et inversez tous les caractères de l'index \( i \) à l'index \( n - 1 \) (inclus), avec un coût de \( n - i \).

Retournez le coût minimum pour rendre tous les caractères de la chaîne égaux.
Inverser un caractère signifie que si sa valeur est '0', elle devient '1' et vice-versa.

Exemple 1 :

Entrée : s = "0011"
Sortie : 2
Explication : Appliquer la deuxième opération avec \( i = 2 \) pour obtenir \( s = "0000" \) pour un coût de 2. On peut démontrer que 2 est le coût minimum pour rendre tous les caractères égaux.

Exemple 2 :

Entrée : s = "010101"
Sortie : 9
Explication : Appliquer la première opération avec \( i = 2 \) pour obtenir \( s = "101101" \) pour un coût de 3.
Appliquer la première opération avec \( i = 1 \) pour obtenir \( s = "011101" \) pour un coût de 2.
Appliquer la première opération avec \( i = 0 \) pour obtenir \( s = "111101" \) pour un coût de 1.
Appliquer la deuxième opération avec \( i = 4 \) pour obtenir \( s = "111110" \) pour un coût de 2.
Appliquer la deuxième opération avec \( i = 5 \) pour obtenir \( s = "111111" \) pour un coût de 1.
Le coût total pour rendre tous les caractères égaux est 9. On peut démontrer que 9 est le coût minimum pour rendre tous les caractères égaux.

Contraintes :

1 <= s.length == n <= 10^5
s[i] est soit '0' soit '1'


Étant donné un entier positif num représenté sous forme de chaîne, renvoyez l'entier num sans les zéros finaux sous forme de chaîne.

Exemple 1 :

Entrée : num = "51230100"
Sortie : "512301"
Explication : L'entier "51230100" a 2 zéros finaux, nous les supprimons et retournons l'entier "512301".

Exemple 2 :

Entrée : num = "123"
Sortie : "123"
Explication : L'entier "123" n'a pas de zéros finaux, nous retournons l'entier "123".

Contraintes :

1 <= num.length <= 1000
num se compose uniquement de chiffres.
num n'a pas de zéros initiaux.

Étant donné un entier positif Num représenté en tant que chaîne, renvoyez le Num entier sans zéros de fin en tant que chaîne.

Exemple 1:

Entrée: num = "51230100"
Sortie: "512301"
Explication: L'entier "51230100" a 2 zéros de fin, nous les supprimons et retournons entier "512301".

Exemple 2:

Entrée: num = "123"
Sortie: "123"
Explication: L'entier "123" n'a pas de zéros de fin, nous retournons entier "123".

Contraintes:

1 <= num.length <= 1000
num se compose uniquement de chiffres.
num n'a pas de zéros de début.


On vous donne un entier n qui se compose exactement de 3 chiffres.
Nous appelons le nombre n fascinant si, après la modification suivante, le nombre résultant contient tous les chiffres de 1 à 9 exactement une fois et ne contient aucun 0 :

Concaténez n avec les nombres 2 * n et 3 * n.

Renvoyez vrai si n est fascinant, ou faux sinon.
Concaténer deux nombres signifie les joindre ensemble. Par exemple, la concaténation de 121 et 371 est 121371.

Exemple 1 :

Entrée : n = 192
Sortie : true
Explication : Nous concaténons les nombres n = 192 et 2 * n = 384 et 3 * n = 576. Le nombre résultant est 192384576. Ce nombre contient tous les chiffres de 1 à 9 exactement une fois.

Exemple 2 :

Entrée : n = 100
Sortie : false
Explication : Nous concaténons les nombres n = 100 et 2 * n = 200 et 3 * n = 300. Le nombre résultant est 100200300. Ce nombre ne satisfait aucune des conditions.

Contraintes :

100 <= n <= 999

On vous donne un entier n qui se compose exactement de 3 chiffres.
Nous appelons le nombre n fascinant si, après la modification suivante, le nombre résultant contient tous les chiffres de 1 à 9 exactement une fois et ne contient aucun 0 :

Concaténez n avec les nombres 2 * n et 3 * n.

Retournez true si n est fascinant, ou false sinon.
Concaténer deux nombres signifie les joindre ensemble. Par exemple, la concaténation de 121 et 371 est 121371.

Exemple 1 :

Entrée : n = 192
Sortie : true
Explication : Nous concaténons les nombres n = 192 et 2 * n = 384 et 3 * n = 576. Le nombre résultant est 192384576. Ce nombre contient tous les chiffres de 1 à 9 exactement une fois.

Exemple 2 :

Entrée : n = 100
Sortie : false
Explication : Nous concaténons les nombres n = 100 et 2 * n = 200 et 3 * n = 300. Le nombre résultant est 100200300. Ce nombre ne satisfait aucune des conditions.

Contraintes :

100 <= n <= 999

On vous donne un entier n qui se compose exactement de 3 chiffres.
Nous appelons le numéro N fascinant si, après la modification suivante, le numéro résultant contient tous les chiffres de 1 à 9 exactement une fois et ne contient aucun 0:

Concaténez n avec les nombres 2 * n et 3 * n.

Renvoie vrai si n est fascinant ou faux sinon.
Conaténuer deux nombres signifie les rejoindre. Par exemple, la concaténation de 121 et 371 est 121371.

Exemple 1:

Entrée: n = 192
Sortie: vrai
Explication : Nous concaténons les nombres n = 192 et 2 * n = 384 et 3 * n = 576. Le nombre résultant est 192384576. Ce nombre contient tous les chiffres de 1 à 9 exactement une fois.

Exemple 2:

Entrée: n = 100
Sortie: faux
Explication: Nous concatenons les nombres n = 100 et 2 * n = 200 et 3 * n = 300. Le nombre résultant est 100200300. Ce nombre ne satisfait aucune des conditions.

Contraintes:

100 <= n <= 999


Étant donné une chaîne s indexée à 0, effectuez l'opération suivante de manière répétée un nombre quelconque de fois :

Choisissez un index i dans la chaîne et laissez c être le caractère en position i. Supprimez l'occurrence la plus proche de c à gauche de i (le cas échéant) et l'occurrence la plus proche de c à droite de i (le cas échéant).

Votre tâche consiste à minimiser la longueur de s en effectuant l'opération ci-dessus un nombre quelconque de fois.
Renvoyer un entier indiquant la longueur de la chaîne minimisée.

Exemple 1 :

Entrée : s = "aaabc"
Sortie : 3
Explication : Dans cet exemple, s est "aaabc". Nous pouvons commencer par sélectionner le caractère 'a' à l'index 1. Nous supprimons ensuite le 'a' le plus proche à gauche de l'index 1, qui est à l'index 0, et le 'a' le plus proche à droite de l'index 1, qui est à l'index 2. Après cette opération, la chaîne devient "abc". Toute autre opération que nous effectuons sur la chaîne la laissera inchangée. Par conséquent, la longueur de la chaîne minimisée est de 3.
Exemple 2 :

Entrée : s = "cbbd"
Sortie : 3
Explication : Pour cela, nous pouvons commencer avec le caractère « b » à l'index 1. Il n'y a aucune occurrence de « b » à gauche de l'index 1, mais il y en a une à droite à l'index 2, nous supprimons donc le 'b' à l'index 2. La chaîne devient "cbd" et les opérations ultérieures la laisseront inchangée. Par conséquent, la longueur minimisée est de 3.

Exemple 3 :

Entrée : s = "dddaaa"
Sortie : 2
Explication : Pour cela, nous pouvons commencer avec le caractère 'd' à l'index 1. L'occurrence la plus proche d'un 'd' à sa gauche est à l'index 0, et l'occurrence la plus proche d'un 'd' à sa droite est à l'index 2. Nous supprimons les index 0 et 2, donc la chaîne devient "daaa". Dans la nouvelle chaîne, nous pouvons sélectionner le caractère 'a' à l'index 2. L'occurrence la plus proche d'un 'a' à sa gauche est à l'index 1, et l'occurrence la plus proche d'un 'a' à sa droite est à l'index 3. Nous supprimons les deux, et la chaîne devient "da". Nous ne pouvons pas minimiser davantage cela, donc la longueur minimisée est de 2.

Contraintes :

1 <= s.length <= 100
s ne contient que des lettres minuscules anglaises

Étant donné une chaîne de caractères s indexée à partir de 0, effectuez à plusieurs reprises un nombre quelconque de fois l'opération suivante :

Choisissez un indice i dans la chaîne, et soit c le caractère à la position i. Supprimez l'occurrence la plus proche de c à gauche de i (si elle existe) et l'occurrence la plus proche de c à droite de i (si elle existe).

Votre tâche est de minimiser la longueur de s en effectuant l'opération ci-dessus un nombre quelconque de fois.
Retournez un entier représentant la longueur de la chaîne minimisée.

Exemple 1 :

Entrée : s = "aaabc"
Sortie : 3
Explication : Dans cet exemple, s est "aaabc". Nous pouvons commencer par sélectionner le caractère 'a' à l'indice 1. Nous supprimons ensuite le 'a' le plus proche à gauche de l'indice 1, qui est à l'indice 0, et le 'a' le plus proche à droite de l'indice 1, qui est à l'indice 2. Après cette opération, la chaîne devient "abc". Toute opération supplémentaire que nous effectuons sur la chaîne la laissera inchangée. Par conséquent, la longueur de la chaîne minimisée est de 3.
Exemple 2 :

Entrée : s = "cbbd"
Sortie : 3
Explication : Pour ce cas, nous pouvons commencer avec le caractère 'b' à l'indice 1. Il n'y a pas d'occurrence de 'b' à gauche de l'indice 1, mais il y en a une à droite à l'indice 2, nous supprimons donc le 'b' à l'indice 2. La chaîne devient "cbd" et les opérations supplémentaires la laisseront inchangée. Ainsi, la longueur minimisée est de 3.

Exemple 3 :

Entrée : s = "dddaaa"
Sortie : 2
Explication : Pour ce cas, nous pouvons commencer avec le caractère 'd' à l'indice 1. L'occurrence la plus proche de 'd' à sa gauche est à l'indice 0, et l'occurrence la plus proche de 'd' à sa droite est à l'indice 2. Nous supprimons les indices 0 et 2, donc la chaîne devient "daaa". Dans la nouvelle chaîne, nous pouvons sélectionner le caractère 'a' à l'indice 2. L'occurrence la plus proche de 'a' à sa gauche est à l'indice 1, et l'occurrence la plus proche de 'a' à sa droite est à l'indice 3. Nous les supprimons tous les deux, et la chaîne devient "da". Nous ne pouvons pas la réduire davantage, donc la longueur minimisée est de 2.

Contraintes :

1 <= s.length <= 100
s contient uniquement des lettres minuscules anglaises

Étant donné une chaîne de caractères s indexée à partir de 0, effectuez à plusieurs reprises l'opération suivante un nombre quelconque de fois :

Choisissez un indice i dans la chaîne, et laissez c être le caractère à la position i. Supprimez l'occurrence la plus proche de c à gauche de i (si elle existe) et l'occurrence la plus proche de c à droite de i (si elle existe).

Votre tâche est de minimiser la longueur de s en effectuant l'opération ci-dessus un nombre quelconque de fois.
Retournez un entier représentant la longueur de la chaîne minimisée.

Exemple 1 :

Entrée : s = "aaabc"
Sortie : 3
Explication : Dans cet exemple, s est "aaabc". Nous pouvons commencer par sélectionner le caractère 'a' à l'indice 1. Nous supprimons ensuite le 'a' le plus proche à gauche de l'indice 1, qui est à l'indice 0, et le 'a' le plus proche à droite de l'indice 1, qui est à l'indice 2. Après cette opération, la chaîne devient "abc". Toute opération supplémentaire que nous effectuons sur la chaîne la laissera inchangée. Par conséquent, la longueur de la chaîne minimisée est de 3.
Exemple 2 :

Entrée : s = "cbbd"
Sortie : 3
Explication : Pour cela, nous pouvons commencer avec le caractère 'b' à l'indice 1. Il n'y a pas d'occurrence de 'b' à gauche de l'indice 1, mais il y en a une à droite à l'indice 2, nous supprimons donc le 'b' à l'indice 2. La chaîne devient "cbd" et les opérations supplémentaires la laisseront inchangée. Ainsi, la longueur minimisée est de 3.

Exemple 3 :

Entrée : s = "dddaaa"
Sortie : 2
Explication : Pour cela, nous pouvons commencer avec le caractère 'd' à l'indice 1. L'occurrence la plus proche de 'd' à sa gauche est à l'indice 0, et l'occurrence la plus proche de 'd' à sa droite est à l'indice 2. Nous supprimons les indices 0 et 2, donc la chaîne devient "daaa". Dans la nouvelle chaîne, nous pouvons sélectionner le caractère 'a' à l'indice 2. L'occurrence la plus proche de 'a' à sa gauche est à l'indice 1, et l'occurrence la plus proche de 'a' à sa droite est à l'indice 3. Nous les supprimons, et la chaîne devient "da". Nous ne pouvons pas la minimiser davantage, donc la longueur minimisée est de 2.

Contraintes :

1 <= s.length <= 100
s contient uniquement des lettres minuscules anglaises


On vous donne un tableau d'entiers numéroté à partir de zéro, `nums`, et vous êtes autorisé à traverser entre ses indices. Vous pouvez traverser entre les indices `i` et `j`, `i != j`, si et seulement si `gcd(nums[i], nums[j]) > 1`, où `gcd` est le plus grand diviseur commun.
Votre tâche est de déterminer si, pour chaque paire d'indices `i` et `j` dans `nums`, où `i < j`, il existe une séquence de traversées qui nous permet de passer de `i` à `j`.
Affichez `true` s'il est possible de traverser entre toutes ces paires d'indices, ou `false` sinon.

Exemple 1 :

Entrée : nums = [2,3,6]
Sortie : true
Explication : Dans cet exemple, il y a 3 paires possibles d'indices : (0, 1), (0, 2) et (1, 2).
Pour aller de l'indice 0 à l'indice 1, nous pouvons utiliser la séquence de traversées 0 -> 2 -> 1, où nous passons de l'indice 0 à l'indice 2 parce que `gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1`, et ensuite passer de l'indice 2 à l'indice 1 parce que `gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1`.
Pour aller de l'indice 0 à l'indice 2, nous pouvons simplement y aller directement parce que `gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1`. De même, pour aller de l'indice 1 à l'indice 2, nous pouvons simplement y aller directement parce que `gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1`.

Exemple 2 :

Entrée : nums = [3,9,5]
Sortie : false
Explication : Aucune séquence de traversées ne peut nous amener de l'indice 0 à l'indice 2 dans cet exemple. Donc, on affiche `false`.

Exemple 3 :

Entrée : nums = [4,3,12,8]
Sortie : true
Explication : Il y a 6 paires possibles d'indices pour traverser entre : (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), et (2, 3). Une séquence de traversées valide existe pour chaque paire, donc on affiche `true`.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de zéro, et vous êtes autorisé à traverser entre ses indices. Vous pouvez traverser entre les indices i et j, i != j, si et seulement si gcd(nums[i], nums[j]) > 1, où gcd est le plus grand diviseur commun.
Votre tâche est de déterminer si, pour chaque paire d'indices i et j dans nums, où i < j, il existe une séquence de traversées qui nous permet de passer de i à j.
Retournez true s'il est possible de traverser entre toutes ces paires d'indices, ou false sinon.

Exemple 1 :

Entrée : nums = [2,3,6]
Sortie : true
Explication : Dans cet exemple, il y a 3 paires possibles d'indices : (0, 1), (0, 2) et (1, 2).
Pour aller de l'indice 0 à l'indice 1, nous pouvons utiliser la séquence de traversées 0 -> 2 -> 1, où nous passons de l'indice 0 à l'indice 2 parce que gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, et ensuite passer de l'indice 2 à l'indice 1 parce que gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Pour aller de l'indice 0 à l'indice 2, nous pouvons simplement y aller directement parce que gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. De même, pour aller de l'indice 1 à l'indice 2, nous pouvons simplement y aller directement parce que gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Exemple 2 :

Entrée : nums = [3,9,5]
Sortie : false
Explication : Aucune séquence de traversées ne peut nous amener de l'indice 0 à l'indice 2 dans cet exemple. Donc, nous retournons false.

Exemple 3 :

Entrée : nums = [4,3,12,8]
Sortie : true
Explication : Il y a 6 paires possibles d'indices pour traverser entre : (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), et (2, 3). Une séquence de traversées valide existe pour chaque paire, donc nous retournons true.

Contraintes :

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

On vous donne un tableau d'entiers indexé 0, nums, et vous êtes autorisé à passer d'un indice à l'autre. Vous pouvez passer de l'indice i à l'indice j, i != j, si et seulement si pgcd(nums[i], nums[j]) > 1, où pgcd est le plus grand diviseur commun.
Votre tâche est de déterminer si pour chaque paire d'indices i et j dans nums, où i < j, il existe une séquence de traversées qui peut nous amener de i à j.
Retournez true s'il est possible de parcourir toutes ces paires d'indices, ou false dans le cas contraire.

Exemple 1 :

Entrée : nums = [2,3,6]
Sortie : true
Explication : Dans cet exemple, il existe trois paires d'indices possibles : (0, 1), (0, 2) et (1, 2).
Pour aller de l'indice 0 à l'indice 1, nous pouvons utiliser la séquence de traversées 0 -> 2 -> 1, où nous passons de l'indice 0 à l'indice 2 parce que pgcd(nums[0], nums[2]) = pgcd(2, 6) = 2 > 1, puis nous passons de l'indice 2 à l'indice 1 parce que pgcd(nums[2], nums[1]) = pgcd(6, 3) = 3 > 1.
Pour passer de l'indice 0 à l'indice 2, il suffit d'aller directement car pgcd(nums[0], nums[2]) = pgcd(2, 6) = 2 > 1. De même, pour passer de l'indice 1 à l'indice 2, il suffit d'y aller directement car pgcd(nums[1], nums[2]) = pgcd(3, 6) = 3 > 1.

Exemple 2 :

Entrée : nums = [3,9,5]
Sortie : false
Explication : Aucune séquence de parcours ne peut nous amener de l'index 0 à l'index 2 dans cet exemple. Nous renvoyons donc false.

Exemple 3 :

Entrée : nums = [4,3,12,8]
Sortie : true
Explication : Il y a 6 paires d'indices possibles à parcourir : (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), et (2, 3). Une séquence valide de parcours existe pour chaque paire, nous retournons donc true.

Contraintes :

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


Vous avez une chaîne de caractères s composée uniquement de lettres minuscules anglaises. Lors d'une opération, vous pouvez faire ce qui suit :

Sélectionnez une sous-chaîne non vide de s, éventuellement la chaîne entière, puis remplacez chacun de ses caractères par le caractère précédent de l'alphabet anglais. Par exemple, 'b' est converti en 'a', et 'a' est converti en 'z'.

Retournez la chaîne lexicographiquement la plus petite que vous pouvez obtenir après avoir effectué l'opération ci-dessus exactement une fois.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Une chaîne x est lexicographiquement plus petite qu'une chaîne y de même longueur si x[i] précède y[i] dans l'ordre alphabétique pour la première position i telle que x[i] != y[i].

Exemple 1 :

Entrée : s = "cbabc"
Sortie : "baabc"
Explication : Nous appliquons l'opération sur la sous-chaîne commençant à l'index 0 et se terminant à l'index 1 inclus.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Exemple 2 :

Entrée : s = "acbbc"
Sortie : "abaab"
Explication : Nous appliquons l'opération sur la sous-chaîne commençant à l'index 1 et se terminant à l'index 4 inclus.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Exemple 3 :

Entrée : s = "leetcode"
Sortie : "kddsbncd"
Explication : Nous appliquons l'opération sur la chaîne entière.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Contraintes :

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

Vous avez une chaîne de caractères s composée uniquement de lettres minuscules anglaises. Lors d'une opération, vous pouvez faire ce qui suit :

Sélectionnez une sous-chaîne non vide de s, éventuellement la chaîne entière, puis remplacez chacun de ses caractères par le caractère précédent de l'alphabet anglais. Par exemple, 'b' est converti en 'a', et 'a' est converti en 'z'.

Retournez la chaîne lexicographiquement la plus petite que vous pouvez obtenir après avoir effectué l'opération ci-dessus exactement une fois.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Une chaîne x est lexicographiquement plus petite qu'une chaîne y de même longueur si x[i] précède y[i] dans l'ordre alphabétique pour la première position i telle que x[i] != y[i].

Exemple 1 :

Entrée : s = "cbabc"
Sortie : "baabc"
Explication : nous appliquons l'opération sur la sous-chaîne commençant à l'index 0 et se terminant à l'index 1 inclus.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Exemple 2 :

Entrée : s = "acbbc"
Sortie : "abaab"
Explication : nous appliquons l'opération sur la sous-chaîne commençant à l'index 1 et se terminant à l'index 4 inclus.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Exemple 3 :

Entrée : s = "leetcode"
Sortie : "kddsbncd"
Explication : nous appliquons l'opération sur la chaîne entière.
Il peut être prouvé que la chaîne résultante est la plus petite possible lexicographiquement.

Contraintes :

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

Vous avez une chaîne de caractères s composée uniquement de lettres minuscules anglaises. Lors d'une opération, vous pouvez faire ce qui suit :

Sélectionnez une sous-chaîne non vide de s, éventuellement la chaîne entière, puis remplacez chacun de ses caractères par le caractère précédent de l'alphabet anglais. Par exemple, 'b' est converti en 'a', et 'a' est converti en 'z'.

Retournez la chaîne lexicographiquement la plus petite que vous pouvez obtenir après avoir effectué l'opération ci-dessus exactement une fois.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Une chaîne x est lexicographiquement plus petite qu'une chaîne y de même longueur si x[i] précède y[i] dans l'ordre alphabétique pour la première position i telle que x[i] != y[i].

Exemple 1 :

Entrée : s = "cbabc"
Sortie : "baabc"
Explication : Nous appliquons l'opération sur la sous-chaîne commençant à l'indice 0, et se terminant à l'indice 1 inclus.
Il peut être prouvé que la chaîne résultante est lexicographiquement la plus petite possible.

Exemple 2 :

Entrée : s = "acbbc"
Sortie : "abaab"
Explication : Nous appliquons l'opération sur la sous-chaîne commençant à l'indice 1 et se terminant à l'indice 4 inclus.
Il peut être prouvé que la chaîne résultante est lexicographiquement la plus petite possible.

Exemple 3 :

Entrée : s = "leetcode"
Sortie : "kddsbncd"
Explication : Nous appliquons l'opération sur la chaîne entière.
Il peut être prouvé que la chaîne résultante est lexicographiquement la plus petite possible.

Contraintes :

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


Vous disposez d'un tableau d'entiers nums indexé à partir de 0. Une paire d'indices i, j où 0 <= i < j < nums.length est appelée belle si le premier chiffre de nums[i] et le dernier chiffre de nums[j] sont premiers entre eux.
Retournez le nombre total de paires belles dans nums.
Deux entiers x et y sont premiers entre eux s'il n'existe pas d'entier supérieur à 1 qui divise à la fois x et y. En d'autres termes, x et y sont premiers entre eux si gcd(x, y) == 1, où gcd(x, y) est le plus grand commun diviseur de x et y.

Exemple 1 :

Entrée : nums = [2,5,1,4]
Sortie : 5
Explication : Il y a 5 paires belles dans nums :
Lorsque i = 0 et j = 1 : le premier chiffre de nums[0] est 2, et le dernier chiffre de nums[1] est 5. Nous pouvons confirmer que 2 et 5 sont premiers entre eux, puisque gcd(2,5) == 1.
Lorsque i = 0 et j = 2 : le premier chiffre de nums[0] est 2, et le dernier chiffre de nums[2] est 1. En effet, gcd(2,1) == 1.
Lorsque i = 1 et j = 2 : le premier chiffre de nums[1] est 5, et le dernier chiffre de nums[2] est 1. En effet, gcd(5,1) == 1.
Lorsque i = 1 et j = 3 : le premier chiffre de nums[1] est 5, et le dernier chiffre de nums[3] est 4. En effet, gcd(5,4) == 1.
Lorsque i = 2 et j = 3 : le premier chiffre de nums[2] est 1, et le dernier chiffre de nums[3] est 4. En effet, gcd(1,4) == 1.
Ainsi, nous retournons 5.

Exemple 2 :

Entrée : nums = [11,21,12]
Sortie : 2
Explication : Il y a 2 paires belles :
Lorsque i = 0 et j = 1 : le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[1] est 1. En effet, gcd(1,1) == 1.
Lorsque i = 0 et j = 2 : le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[2] est 2. En effet, gcd(1,2) == 1.
Ainsi, nous retournons 2.

Contraintes :

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

Vous disposez d'un tableau de nombres entiers à indice 0. Une paire d'indices i, j où 0 <= i < j < nums.length est appelée belle si le premier chiffre de nums[i] et le dernier chiffre de nums[j] sont premiers entre eux.
Retournez le nombre total de belles paires dans nombres.
Deux entiers x et y sont premiers entre eux s'il n'existe pas d'entier supérieur à 1 qui divise à la fois x et y. En d'autres termes, x et y sont premiers entre eux si gcd(x, y) == 1, où gcd(x, y) est le plus grand commun diviseur de x et y.

Exemple 1 :

Entrée : nums = [2,5,1,4]
Sortie : 5
Explication : Il y a 5 belles paires dans nombres :
Lorsque i = 0 et j = 1 : le premier chiffre de nums[0] est 2, et le dernier chiffre de nums[1] est 5. Nous pouvons confirmer que 2 et 5 sont premiers entre eux, puisque gcd(2,5) == 1.
Lorsque i = 0 et j = 2 : le premier chiffre de nums[0] est 2, et le dernier chiffre de nums[2] est 1. En effet, gcd(2,1) == 1.
Lorsque i = 1 et j = 2 : le premier chiffre de nums[1] est 5, et le dernier chiffre de nums[2] est 1. En effet, gcd(5,1) == 1.
Lorsque i = 1 et j = 3 : le premier chiffre de nums[1] est 5, et le dernier chiffre de nums[3] est 4. En effet, gcd(5,4) == 1.
Lorsque i = 2 et j = 3 : le premier chiffre de nums[2] est 1, et le dernier chiffre de nums[3] est 4. En effet, gcd(1,4) == 1.
Ainsi, nous renvoyons 5.

Exemple 2 :

Entrée : nums = [11,21,12]
Sortie : 2
Explication : Il y a 2 belles paires :
Lorsque i = 0 et j = 1 : le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[1] est 1. En effet, gcd(1,1) == 1.
Lorsque i = 0 et j = 2 : le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[2] est 2. En effet, gcd(1,2) == 1.
Donc, nous renvoyons 2.

Contraintes :

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

Vous recevez un un tableau d'entiers indexé à 0. Une paire d'indices i, j où 0 <= i <j <nums.length est appelée belle si le premier chiffre de nums[i] et le dernier chiffre de nums[j] sont coprime.
Renvoyez le nombre total de belles paires en nums.
Deux entiers x et y sont coprime s'il n'y a pas d'entier supérieur à 1 qui les divise tous les deux. En d'autres termes, x et y sont coprime si gcd(x, y) == 1, où gcd(x, y) est le plus grand diviseur commun de x et y.

Exemple 1:

Entrée: nums = [2,5,1,4]
Sortie: 5
Explication: Il y a 5 belles paires dans nums:
Lorsque i = 0 et j = 1: Le premier chiffre de nums[0] est 2, et le dernier chiffre de nums [1] est 5. Nous pouvons confirmer que 2 et 5 sont premiers entre eux, puisque gcd(2,5) = = 1.
Lorsque I = 0 et J = 2: Le premier chiffre de nums[0] est 2, et le dernier chiffre de nums [2] est 1. En effet, gcd(2,1) == 1.
Lorsque I = 1 et J = 2: Le premier chiffre de nums[1] est 5, et le dernier chiffre de nums [2] est 1. En effet, gcd(5,1) == 1.
Lorsque I = 1 et J = 3: Le premier chiffre de nums[1] est 5, et le dernier chiffre de nums [3] est 4. En effet, gcd(5,4) == 1.
Lorsque I = 2 et J = 3: Le premier chiffre de nums[2] est 1, et le dernier chiffre de nums [3] est 4. En effet, gcd(1,4) == 1.
Ainsi, nous retournons 5.

Exemple 2:

Entrée: nums = [11,21,12]
Sortie: 2
Explication: Il y a 2 belles paires:
Lorsque i = 0 et j = 1: Le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[1] est 1. En effet, gcd(1,1) == 1.
Lorsque I = 0 et J = 2: Le premier chiffre de nums[0] est 1, et le dernier chiffre de nums[2] est 2. En effet, gcd(1,2) == 1.
Ainsi, nous retournons 2.

Constraints:

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


On donne un tableau d'entiers nums indexé à partir de 0 et un entier k.
Un sous-tableau est appelé égal si tous ses éléments sont égaux. Notez que le sous-tableau vide est un sous-tableau égal.
Retournez la longueur du plus long sous-tableau égal possible après avoir supprimé au plus k éléments de nums.
Un sous-tableau est une séquence contiguë, éventuellement vide, d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,3,2,3,1,3], k = 3
Sortie : 3
Explication : Il est optimal de supprimer les éléments aux indices 2 et 4.
Après les avoir supprimés, nums devient [1, 3, 3, 3].
Le plus long sous-tableau égal commence à i = 1 et se termine à j = 3 avec une longueur égale à 3.
Il peut être prouvé qu'aucun sous-tableau égal plus long ne peut être créé.

Exemple 2 :

Entrée : nums = [1,1,2,2,1,1], k = 2
Sortie : 4
Explication : Il est optimal de supprimer les éléments aux indices 2 et 3.
Après les avoir supprimés, nums devient [1, 1, 1, 1].
Le tableau lui-même est un sous-tableau égal, donc la réponse est 4.
Il peut être prouvé qu'aucun sous-tableau égal plus long ne peut être créé.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0 et un entier k.
Un sous-tableau est appelé égal si tous ses éléments sont égaux. Notez que le sous-tableau vide est un sous-tableau égal.
Retournez la longueur du plus long sous-tableau égal possible après avoir supprimé au plus k éléments de nums.
Un sous-tableau est une séquence contiguë, éventuellement vide, d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,3,2,3,1,3], k = 3
Sortie : 3
Explication : Il est optimal de supprimer les éléments aux indices 2 et 4.
Après les avoir supprimés, nums devient [1, 3, 3, 3].
Le plus long sous-tableau égal commence à i = 1 et se termine à j = 3 avec une longueur égale à 3.
Il peut être prouvé qu'aucun sous-tableau égal plus long ne peut être créé.

Exemple 2 :

Entrée : nums = [1,1,2,2,1,1], k = 2
Sortie : 4
Explication : Il est optimal de supprimer les éléments aux indices 2 et 3.
Après les avoir supprimés, nums devient [1, 1, 1, 1].
Le tableau lui-même est un sous-tableau égal, donc la réponse est 4.
Il peut être prouvé qu'aucun sous-tableau égal plus long ne peut être créé.

Contraintes :

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

On vous donne un tableau d'entiers indexé 0 nums et un entier k.
Un sous-tableau est dit égal si tous ses éléments sont égaux. Notez que le sous-tableau vide est un sous-tableau égal.
Renvoie la longueur du sous-tableau égal le plus long possible après avoir supprimé au plus k éléments de nums.
Un sous-tableau est une séquence contiguë, éventuellement vide, d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,3,2,3,1,3], k = 3
Sortie : 3
Explication : Il est optimal de supprimer les éléments d'index 2 et d'index 4.
Après les avoir supprimés, nums devient égal à [1, 3, 3, 3].
Le sous-tableau égal le plus long commence à i = 1 et se termine à j = 3 avec une longueur égale à 3.
Il peut être prouvé qu'il n'est plus possible de créer de sous-tableaux égaux.

Exemple 2 :

Entrée : nums = [1,1,2,2,1,1], k = 2
Sortie : 4
Explication : Il est optimal de supprimer les éléments d'index 2 et 3.
Après les avoir supprimés, nums devient égal à [1, 1, 1, 1].
Le tableau lui-même est un sous-tableau égal, la réponse est donc 4.
Il peut être prouvé qu'il n'est plus possible de créer de sous-tableaux égaux.

Contraintes :

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


Vous disposez d'un entier n représentant le nombre total de serveurs et d'un tableau entier 2D indexé à 0, logs, où logs[i] = [server_id, time] indique que le serveur avec l'identifiant server_id a reçu une requête à l'heure time.
Vous disposez également d'un entier x et d'un tableau entier indexé à 0, queries.
Retournez un tableau entier indexé à 0 arr de longueur queries.length où arr[i] représente le nombre de serveurs qui n'ont reçu aucune requête pendant l'intervalle de temps [queries[i] - x, queries[i]].
Notez que les intervalles de temps sont inclusifs.

Exemple 1:

Entrée: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Sortie: [1,2]
Explication:
Pour queries[0]: Les serveurs avec les identifiants 1 et 2 reçoivent des requêtes pendant la période de [5, 10]. Ainsi, seul le serveur 3 ne reçoit aucune requête.
Pour queries[1]: Seul le serveur avec l'identifiant 2 reçoit une requête pendant la période de [6,11]. Ainsi, les serveurs avec les identifiants 1 et 3 sont les seuls serveurs qui ne reçoivent aucune requête pendant cette période.

Exemple 2:

Entrée: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Sortie: [0,1]
Explication:
Pour queries[0]: Tous les serveurs reçoivent au moins une requête pendant la période de [1, 3].
Pour queries[1]: Seul le serveur avec l'identifiant 3 ne reçoit aucune requête pendant la période [2,4].

Contraintes:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Vous disposez d'un entier n représentant le nombre total de serveurs et d'un tableau entier 2D indexé à 0, logs, où logs[i] = [server_id, time] indique que le serveur avec l'identifiant server_id a reçu une requête à l'heure time.
Vous disposez également d'un entier x et d'un tableau entier indexé à 0, queries.
Retournez un tableau entier indexé à 0 arr de longueur queries.length où arr[i] représente le nombre de serveurs qui n'ont reçu aucune requête pendant l'intervalle de temps [queries[i] - x, queries[i]].
Notez que les intervalles de temps sont inclusifs.

Exemple 1 :

Entrée : n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Sortie : [1,2]
Explication :
Pour queries[0] : Les serveurs avec les identifiants 1 et 2 reçoivent des requêtes pendant la période de [5, 10]. Ainsi, seul le serveur 3 ne reçoit aucune requête.
Pour queries[1] : Seul le serveur avec l'identifiant 2 reçoit une requête pendant la période de [6,11]. Ainsi, les serveurs avec les identifiants 1 et 3 sont les seuls serveurs qui ne reçoivent aucune requête pendant cette période.

Exemple 2 :

Entrée : n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Sortie : [0,1]
Explication :
Pour queries[0] : Tous les serveurs reçoivent au moins une requête pendant la période de [1, 3].
Pour queries[1] : Seul le serveur avec l'identifiant 3 ne reçoit aucune requête pendant la période [2,4].

Contraintes :

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

On vous donne un  entier n représentant le nombre total de serveurs et d'un tableau entier 2D indexé à 0, logs, où logs[i] = [server_id, time] indique que le serveur avec l'identifiant server_id a reçu une requête à l'heure time. Vous disposez également d'un entier x et d'un tableau entier indexé à 0, queries. Retournez un tableau entier indexé à 0 arr de longueur queries.length où arr[i] représente le nombre de serveurs qui n'ont reçu aucune requête pendant l'intervalle de temps [queries[i] - x, queries[i]]. Notez que les intervalles de temps sont inclusifs.

Exemple 1 :

Input: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11] Output: [1,2] Explication : Pour queries[0] : Les serveurs avec les identifiants 1 et 2 reçoivent des requêtes pendant la période de [5, 10]. Ainsi, seul le serveur 3 ne reçoit aucune requête. Pour queries[1] : Seul le serveur avec l'identifiant 2 reçoit une requête pendant la période de [6,11]. Ainsi, les serveurs avec les identifiants 1 et 3 sont les seuls serveurs qui ne reçoivent aucune requête pendant cette période.

Exemple 2 :

Input: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4] Output: [0,1] Explication : Pour queries[0] : Tous les serveurs reçoivent au moins une requête pendant la période de [1, 3]. Pour queries[1] : Seul le serveur avec l'identifiant 3 ne reçoit aucune requête pendant la période [2,4].

Contraintes :

1 <= n <= 10^5 1 <= logs.length <= 10^5 1 <= queries.length <= 10^5 logs[i].length == 2 1 <= logs[i][0] <= n 1 <= logs[i][1] <= 10^6 1 <= x <= 10^5 x < queries[i] <= 10^6


Vous avez un tableau d'entiers indexé à partir de 0, `nums`, représentant les positions initiales de certaines billes. On vous donne également deux tableaux d'entiers indexés à partir de 0, `moveFrom` et `moveTo`, de même longueur.

Au cours des étapes `moveFrom.length`, vous allez changer les positions des billes. À la i^ème étape, vous déplacerez toutes les billes à la position `moveFrom[i]` vers la position `moveTo[i]`.

Après avoir complété toutes les étapes, retournez la liste triée des positions occupées.
Notes :

Nous appelons une position occupée s'il y a au moins une bille dans cette position.
Il peut y avoir plusieurs billes dans une seule position.

Exemple 1 :

Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Output: [5,6,8,9]
Explication : Initialement, les billes sont aux positions 1,6,7,8.
À l'étape i = 0, nous déplaçons les billes de la position 1 vers la position 2. Ensuite, les positions 2,6,7,8 sont occupées.
À l'étape i = 1, nous déplaçons les billes de la position 7 vers la position 9. Ensuite, les positions 2,6,8,9 sont occupées.
À l'étape i = 2, nous déplaçons les billes de la position 2 vers la position 5. Ensuite, les positions 5,6,8,9 sont occupées.
À la fin, les positions finales contenant au moins une bille sont [5,6,8,9].

Exemple 2 :

Input: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Output: [2]
Explication : Initialement, les billes sont aux positions [1,1,3,3].
À l'étape i = 0, nous déplaçons toutes les billes de la position 1 vers la position 2. Ensuite, les billes sont aux positions [2,2,3,3].
À l'étape i = 1, nous déplaçons toutes les billes de la position 3 vers la position 2. Ensuite, les billes sont aux positions [2,2,2,2].
Puisque 2 est la seule position occupée, nous retournons [2].

Contraintes :

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Les cas de test sont générés de sorte qu'il y ait au moins une bille dans `moveFrom[i]` au moment où nous voulons appliquer le i^ème déplacement.

Vous avez un tableau nums d'entiers indexé à partir de 0, représentant les positions initiales de certaines billes. On vous donne également deux tableaux moveFrom et moveTo d'entiers indexés à partir de 0 de même longueur.
Au cours des étapes moveFrom.length, vous allez changer les positions des billes. À la i^ème étape, vous déplacerez toutes les billes à la position moveFrom[i] vers la position moveTo[i].
Après avoir complété toutes les étapes, retournez la liste triée des positions occupées.
Remarques :

Nous disons d'une position qu'elle est occupée s'il y a au moins une bille dans cette position.
Il peut y avoir plusieurs billes dans une seule position.

Exemple 1 :

Entrée : nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Sortie : [5,6,8,9]
Explication : Initialement, les billes sont aux positions 1,6,7,8.
À l'étape i = 0, nous déplaçons les billes à la position 1 vers la position 2. Ensuite, les positions 2,6,7,8 sont occupées.
À l'étape i = 1, nous déplaçons les billes à la position 7 vers la position 9. Ensuite, les positions 2,6,8,9 sont occupées.
À l'étape i = 2, nous déplaçons les billes à la position 2 vers la position 5. Ensuite, les positions 5,6,8,9 sont occupées.
À la fin, les positions finales contenant au moins une bille sont [5,6,8,9].
Exemple 2 :

Entrée : nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Sortie : [2]
Explication : Initialement, les billes sont aux positions [1,1,3,3].
À l'étape i = 0, nous déplaçons toutes les billes à la position 1 vers la position 2. Ensuite, les billes sont aux positions [2,2,3,3].
À l'étape i = 1, nous déplaçons toutes les billes à la position 3 vers la position 2. Ensuite, les billes sont aux positions [2,2,2,2].
Puisque 2 est la seule position occupée, nous retournons [2].

Contraintes :

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Les cas de test sont générés de sorte qu'il y ait au moins une bille dans moveFrom[i] au moment où nous voulons appliquer le i^ème déplacement.

Vous avez un tableau d'entiers indexé à partir de 0, `nums`, représentant les positions initiales de certaines billes. On vous donne également deux tableaux d'entiers indexés à partir de 0, `moveFrom` et `moveTo`, de même longueur.
Au cours des étapes `moveFrom.length`, vous allez changer les positions des billes. À la i^ème étape, vous déplacerez toutes les billes à la position `moveFrom[i]` vers la position `moveTo[i]`.
Après avoir complété toutes les étapes, retournez la liste triée des positions occupées.
Notes :

Nous appelons une position occupée s'il y a au moins une bille dans cette position.
Il peut y avoir plusieurs billes dans une seule position.

Exemple 1 :

Entrée : nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Sortie : [5,6,8,9]
Explication : Initialement, les billes sont aux positions 1,6,7,8.
À l'étape i = 0, nous déplaçons les billes à la position 1 vers la position 2. Ensuite, les positions 2,6,7,8 sont occupées.
À l'étape i = 1, nous déplaçons les billes à la position 7 vers la position 9. Ensuite, les positions 2,6,8,9 sont occupées.
À l'étape i = 2, nous déplaçons les billes à la position 2 vers la position 5. Ensuite, les positions 5,6,8,9 sont occupées.
À la fin, les positions finales contenant au moins une bille sont [5,6,8,9].
Exemple 2 :

Entrée : nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Sortie : [2]
Explication : Initialement, les billes sont aux positions [1,1,3,3].
À l'étape i = 0, nous déplaçons toutes les billes à la position 1 vers la position 2. Ensuite, les billes sont aux positions [2,2,3,3].
À l'étape i = 1, nous déplaçons toutes les billes à la position 3 vers la position 2. Ensuite, les billes sont aux positions [2,2,2,2].
Puisque 2 est la seule position occupée, nous retournons [2].

Contraintes :

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Les cas de test sont générés de sorte qu'il y ait au moins une bille dans `moveFrom[i]` au moment où nous voulons appliquer le i^ème déplacement.


On vous donne  deux entiers num1 et num2.
Dans une opération, vous pouvez choisir un entier i dans la plage [0, 60] et soustraire 2^i + num2 de num1.
Retournez l'entier indiquant le nombre minimum d'opérations nécessaires pour rendre num1 égal à 0.
S'il est impossible de rendre num1 égal à 0, retournez -1.

Exemple 1 :

Entrée : num1 = 3, num2 = -2
Sortie : 3
Explication : Nous pouvons rendre 3 égal à 0 avec les opérations suivantes :
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Nous choisissons i = 0 et soustrayons 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Il peut être prouvé que 3 est le nombre minimum d'opérations que nous devons effectuer.

Exemple 2 :

Entrée : num1 = 5, num2 = 7
Sortie : -1
Explication : Il peut être prouvé qu'il est impossible de rendre 5 égal à 0 avec l'opération donnée.

Contraintes :

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Vous avez deux entiers num1 et num2.
Dans une opération, vous pouvez choisir un entier i dans la plage [0, 60] et soustraire 2^i + num2 de num1.
Retournez l'entier indiquant le nombre minimum d'opérations nécessaires pour rendre num1 égal à 0.
S'il est impossible de rendre num1 égal à 0, retournez -1.

Exemple 1 :

Entrée : num1 = 3, num2 = -2
Sortie : 3
Explication : Nous pouvons rendre 3 égal à 0 avec les opérations suivantes :
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Nous choisissons i = 0 et soustrayons 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Il peut être prouvé que 3 est le nombre minimum d'opérations que nous devons effectuer.

Exemple 2 :

Entrée : num1 = 5, num2 = 7
Sortie : -1
Explication : Il peut être prouvé qu'il est impossible de rendre 5 égal à 0 avec l'opération donnée.

Contraintes :

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

On vous donne deux entiers num1 et num2.
En une seule opération, vous pouvez choisir l'entier i dans la plage [0, 60] et soustraire 2^i + num2 de num1.
Renvoyer l'entier indiquant le nombre minimum d'opérations nécessaires pour rendre num1 égal à 0.
S'il est impossible de rendre num1 égal à 0, renvoyer -1.

Exemple 1 :

Entrée : num1 = 3, num2 = -2
Sortie : 3
Explication : Nous pouvons rendre 3 égal à 0 avec les opérations suivantes :
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 3, 3 - (4 + (-2)) = 1.
- Nous choisissons i = 2 et soustrayons 2^2 + (-2) de 1, 1 - (4 + (-2)) = -1.
- Nous choisissons i = 0 et soustrayons 2^0 + (-2) de -1, (-1) - (1 + (-2)) = 0.
Il peut être prouvé que 3 est le nombre minimum d'opérations que nous devons effectuer.

Exemple 2 :

Entrée : num1 = 5, num2 = 7
Sortie : -1
Explication : Il peut être prouvé qu'il est impossible de rendre 5 égal à 0 avec l'opération donnée.

Contraintes :

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


On vous donne deux tableaux d'entiers indexés à partir de 0, nums1 et nums2, chacun de longueur n, et un tableau 2D indexé à partir de 1 queries où queries[i] = [x_i, y_i].
Pour la i^ème requête, trouvez la valeur maximale de nums1[j] + nums2[j] parmi tous les indices j (0 <= j < n), où nums1[j] >= x_i et nums2[j] >= y_i, ou -1 s'il n'y a pas de j satisfaisant les contraintes.
Retournez un tableau answer où answer[i] est la réponse à la i^ème requête.

Exemple 1 :

Entrée : nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Sortie : [6,10,7]
Explication :
Pour la 1ère requête x_i = 4 et y_i = 1, nous pouvons sélectionner l'indice j = 0 puisque nums1[j] >= 4 et nums2[j] >= 1. La somme nums1[j] + nums2[j] est 6, et nous pouvons montrer que 6 est le maximum que nous pouvons obtenir.

Pour la 2ème requête x_i = 1 et y_i = 3, nous pouvons sélectionner l'indice j = 2 puisque nums1[j] >= 1 et nums2[j] >= 3. La somme nums1[j] + nums2[j] est 10, et nous pouvons montrer que 10 est le maximum que nous pouvons obtenir.

Pour la 3ème requête x_i = 2 et y_i = 5, nous pouvons sélectionner l'indice j = 3 puisque nums1[j] >= 2 et nums2[j] >= 5. La somme nums1[j] + nums2[j] est 7, et nous pouvons montrer que 7 est le maximum que nous pouvons obtenir.

Ainsi, nous retournons [6,10,7].

Exemple 2 :

Entrée : nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Sortie : [9,9,9]
Explication : Pour cet exemple, nous pouvons utiliser l'indice j = 2 pour toutes les requêtes car il satisfait les contraintes de chaque requête.

Exemple 3 :

Entrée : nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Sortie : [-1]
Explication : Il y a une requête dans cet exemple avec x_i = 3 et y_i = 3. Pour chaque indice, j, soit nums1[j] < x_i soit nums2[j] < y_i. Par conséquent, il n'y a pas de solution.

Contraintes :

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9

On vous donne deux tableaux d'entiers indexés à partir de 0, nums1 et nums2, chacun de longueur n, ainsi qu'un tableau 2D indexé à partir de 1, queries, où chaque élément queries[i] = [x_i, y_i].
Pour chaque requête i, trouvez la valeur maximale de nums1[j] + nums2[j] parmi tous les indices j (0 <= j < n), où nums1[j] >= x_i et nums2[j] >= y_i, ou -1 s'il n'y a aucun indice j satisfaisant ces contraintes.
Retournez un tableau de réponses, answer, où answer[i] est la réponse à la i^ème requête.

Exemple 1:

Entrée: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Sortie: [6,10,7]
Explication:
Pour la 1ère requête x_i = 4 et y_i = 1, nous pouvons sélectionner l'indice j = 0 puisque nums1[j] >= 4 et nums2[j] >= 1. La somme nums1[j] + nums2[j] est 6, et nous pouvons montrer que 6 est le maximum que nous pouvons obtenir.

Pour la 2ème requête x_i = 1 et y_i = 3, nous pouvons sélectionner l'indice j = 2 puisque nums1[j] >= 1 et nums2[j] >= 3. La somme nums1[j] + nums2[j] est 10, et nous pouvons montrer que 10 est le maximum que nous pouvons obtenir.

Pour la 3ème requête x_i = 2 et y_i = 5, nous pouvons sélectionner l'indice j = 3 puisque nums1[j] >= 2 et nums2[j] >= 5. La somme nums1[j] + nums2[j] est 7, et nous pouvons que 7 est le maximum que nous pouvons obtenir.

Ainsi, nous retournons [6,10,7].

Exemple 2:

Entrée: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Sortie: [9,9,9]
Explication: Pour cet exemple, nous pouvons utiliser l'indice j = 2 pour toutes les requêtes car il satisfait les contraintes de chaque requête.

Exemple 3:

Entrée: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Sortie: [-1]
Explication: Il y a une requête dans cet exemple avec x_i = 3 et y_i = 3. Pour chaque indice, j, soit nums1[j] < x_i soit nums2[j] < y_i. Par conséquent, il n'y a pas de solution.

Contraintes:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9

On vous donne deux tableaux d'entiers indexés 0 nums1 et nums2, chacun de longueur n, et un tableau 2D indexé 1 requêtes où requêtes[i] = [x_i, y_i].
Pour la i^e requête, trouver la valeur maximale de nums1[j] + nums2[j] parmi tous les indices j (0 <= j < n), où nums1[j] >= x_i et nums2[j] >= y_i, ou -1 s'il n'y a pas de j satisfaisant les contraintes.
Retourne un tableau answer où answer[i] est la réponse à la i^ème requête.

Exemple 1 :

Entrée : nums1 = [4,3,1,2], nums2 = [2,4,9,5], requêtes = [[4,1], [1,3], [2,5]]
Sortie : [6,10,7]
Explication :
Pour la première requête x_i = 4 et y_i = 1, nous pouvons sélectionner l'index j = 0 puisque nums1[j] >= 4 et nums2[j] >= 1. La somme nums1[j] + nums2[j] est de 6, et nous pouvons montrer que 6 est le maximum que nous pouvons obtenir.

Pour la 2ème requête x_i = 1 et y_i = 3, on peut sélectionner l'index j = 2 puisque nums1[j] >= 1 et nums2[j] >= 3. La somme nums1[j] + nums2[j] est égale à 10, et on peut montrer que 10 est le maximum que l'on peut obtenir.

Pour la 3ème requête x_i = 2 et y_i = 5, on peut sélectionner l'index j = 3 puisque nums1[j] >= 2 et nums2[j] >= 5. La somme nums1[j] + nums2[j] est égale à 7, et nous pouvons montrer que 7 est le maximum que nous pouvons obtenir.

Par conséquent, nous renvoyons [6,10,7].

Exemple 2 :

Entrée : nums1 = [3,2,5], nums2 = [2,3,4], requêtes = [[4,4], [3,2], [1,1]]
Sortie : [9,9,9]
Explication : Pour cet exemple, nous pouvons utiliser l'index j = 2 pour toutes les requêtes car il satisfait les contraintes pour chaque requête.

Exemple 3 :

Entrée : nums1 = [2,1], nums2 = [2,3], requêtes = [[3,3]]
Sortie : [-1]
Explication : Il y a une requête dans cet exemple avec x_i = 3 et y_i = 3. Pour chaque index j, soit nums1[j] < x_i, soit nums2[j] < y_i. Il n'y a donc pas de solution.

Contraintes :

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9


Vous avez un tableau d'entiers nums indexé à partir de 1 de longueur n.
Un élément nums[i] de nums est appelé spécial si i divise n, c'est-à-dire n % i == 0.
Renvoyez la somme des carrés de tous les éléments spéciaux de nums.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 21
Explication : Il y a exactement 3 éléments spéciaux dans nums : nums[1] puisque 1 divise 4, nums[2] puisque 2 divise 4, et nums[4] puisque 4 divise 4.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Exemple 2 :

Entrée : nums = [2,7,1,19,18,3]
Sortie : 63
Explication : Il y a exactement 4 éléments spéciaux dans nums : nums[1] puisque 1 divise 6, nums[2] puisque 2 divise 6, nums[3] puisque 3 divise 6, et nums[6] puisque 6 divise 6.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Contraintes :

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

Vous avez un tableau d'entiers nums indexé à partir de 1 de longueur n.
Un élément nums[i] de nums est appelé spécial si i divise n, c'est-à-dire n % i == 0.
Retournez la somme des carrés de tous les éléments spéciaux de nums.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 21
Explication : il y a exactement 3 éléments spéciaux dans nums : nums[1] puisque 1 divise 4, nums[2] puisque 2 divise 4, et nums[4] puisque 4 divise 4.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Exemple 2 :

Entrée : nums = [2,7,1,19,18,3]
Sortie : 63
Explication : il y a précisément 4 éléments spéciaux dans nums : nums[1] puisque 1 divise 6, nums[2] puisque 2 divise 6, nums[3] puisque 3 divise 6, et nums[6] puisque 6 divise 6.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Contraintes :

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

On vous donne un tableau d'entiers indexés à 1 nums de longueur n.
Un élément nums[i] de nums est dit spécial si i divise n, c'est-à-dire n % i == 0.
Renvoie la somme des carrés de tous les éléments spéciaux de nums.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 21
Explication : Il y a exactement 3 éléments spéciaux dans nums : nums[1] puisque 1 divise 4, nums[2] puisque 2 divise 4 et nums[4] puisque 4 divise 4.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Exemple 2 :

Entrée : nums = [2,7,1,19,18,3]
Sortie : 63
Explication : Il y a exactement 4 éléments spéciaux dans nums : nums[1] puisque 1 divise 6, nums[2] puisque 2 divise 6, nums[3] puisque 3 divise 6 et nums[6] puisque 6 divise 6.
Ainsi, la somme des carrés de tous les éléments spéciaux de nums est nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Contraintes :

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


Vous avez un tableau d'entiers positifs nums.
Divisez nums en deux tableaux, nums1 et nums2, de telle sorte que :

Chaque élément du tableau nums appartient soit au tableau nums1 soit au tableau nums2.
Les deux tableaux ne sont pas vides.
La valeur de la partition est minimisée.

La valeur de la partition est |max(nums1) - min(nums2)|.
Ici, max(nums1) désigne l'élément maximum du tableau nums1, et min(nums2) désigne l'élément minimum du tableau nums2. Retournez l'entier indiquant la valeur de cette partition.

Exemple 1 :

Entrée : nums = [1,3,2,4]
Sortie : 1
Explication : Nous pouvons diviser le tableau nums en nums1 = [1,2] et nums2 = [3,4].
- L'élément maximum du tableau nums1 est égal à 2.
- L'élément minimum du tableau nums2 est égal à 3.
La valeur de la partition est |2 - 3| = 1.
Il peut être prouvé que 1 est la valeur minimale de toutes les partitions.

Exemple 2 :

Entrée : nums = [100,1,10]
Sortie : 9
Explication : Nous pouvons diviser le tableau nums en nums1 = [10] et nums2 = [100,1].
- L'élément maximum du tableau nums1 est égal à 10.
- L'élément minimum du tableau nums2 est égal à 1.
La valeur de la partition est |10 - 1| = 9.
Il peut être prouvé que 9 est la valeur minimale de toutes les partitions.

Contraintes :

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

On vous donne un tableau d'entiers positifs nums.
Partitionnez nums en deux tableaux, nums1 et nums2, de telle sorte que :

Chaque élément du tableau nums appartient soit au tableau nums1, soit au tableau nums2.
Les deux tableaux ne sont pas vides.
La valeur de la partition est minimisée.

La valeur de la partition est |max(nums1) - min(nums2)|.
Ici, max(nums1) désigne l'élément maximal du tableau nums1, et min(nums2) désigne l'élément minimal du tableau nums2.
Renvoie l'entier indiquant la valeur de cette partition.

Exemple 1 :

Entrée : nums = [1,3,2,4]
Sortie : 1
Explication : Nous pouvons partitionner le tableau nums en nums1 = [1,2] et nums2 = [3,4].
- L'élément maximum du tableau nums1 est égal à 2.
- L'élément minimum du tableau nums2 est égal à 3.
La valeur de la partition est |2 - 3| = 1.
Il peut être prouvé que 1 est la valeur minimale de toutes les partitions.

Exemple 2 :

Entrée : nums = [100,1,10]
Sortie : 9
Explication : Nous pouvons partitionner le tableau nums en nums1 = [10] et nums2 = [100,1].
- L'élément maximum du tableau nums1 est égal à 10.
- L'élément minimum du tableau nums2 est égal à 1.
La valeur de la partition est |10 - 1| = 9.
Il peut être prouvé que 9 est la valeur minimale de toutes les partitions.

Contraintes :

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

Vous avez un tableau de nombres entiers positifs.
Partagez les nombres en deux tableaux, nums1 et nums2, de telle sorte que :

Chaque élément du tableau de nombres appartient soit au tableau nums1, soit au tableau nums2.
Les deux tableaux ne sont pas vides.
La valeur de la partition est minimisée.

La valeur de la partition est |max(nums1) - min(nums2)|.
Ici, max(nums1) désigne l'élément maximum du tableau nums1, et min(nums2) désigne l'élément minimum du tableau nums2.
Renvoyez l'entier indiquant la valeur de telle partition.

Exemple 1 :

Entrée: nombres = [1,3,2,4]
Sortie: 1
Explication : Nous pouvons partitionner le tableau nombres en nums1 = [1,2] et nums2 = [3,4].
- L'élément maximum du tableau nums1 est égal à 2.
- L'élément minimum du tableau nums2 est égal à 3.
La valeur de la partition est |2 - 3| = 1.
Il peut être prouvé que 1 est la valeur minimale de toutes les partitions.

Exemple 2 :

Entrée: nombres = [100,1,10]
Sortie: 9
Explication : Nous pouvons partitionner le tableau nums en nums1 = [10] et nums2 = [100,1].
- L'élément maximum du tableau nums1 est égal à 10.
- L'élément minimum du tableau nums2 est égal à 1.
La valeur de la partition est |10 - 1| = 9.
Il peut être prouvé que 9 est la valeur minimale de toutes les partitions.

Contraintes :

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


On vous donne un tableau indexé à 0 words constitué de chaînes de caractères distinctes.
La chaîne words[i] peut être associée à la chaîne words[j] si :

La chaîne words[i] est égale à la chaîne inversée de words[j].
0 <= i < j < words.length.

Renvoyez le nombre maximum de paires pouvant être formées à partir du tableau words.
Notez que chaque chaîne peut appartenir au plus à une paire.

Exemple 1 :

Entrée : words = ["cd","ac","dc","ca","zz"]
Sortie : 2
Explication : Dans cet exemple, nous pouvons former 2 paires de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 2^ème chaîne, car la chaîne inversée de word[0] est "dc" et est égale à words[2].
- Nous associons la 1^ère chaîne avec la 3^ème chaîne, car la chaîne inversée de word[1] est "ca" et est égale à words[3].
Il peut être prouvé que 2 est le nombre maximum de paires pouvant être formées.

Exemple 2 :

Entrée : words = ["ab","ba","cc"]
Sortie : 1
Explication : Dans cet exemple, nous pouvons former 1 paire de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 1^ère chaîne, car la chaîne inversée de words[1] est "ab" et est égale à words[0].
Il peut être prouvé que 1 est le nombre maximum de paires pouvant être formées.

Exemple 3 :

Entrée : words = ["aa","ab"]
Sortie : 0
Explication : Dans cet exemple, nous ne pouvons former aucune paire de chaînes.

Contraintes :

1 <= words.length <= 50
words[i].length == 2
words est constitué de chaînes distinctes.
words[i] contient uniquement des lettres minuscules anglaises.

On vous donne un tableau words indexé à partir 0 constitué de chaînes de caractères distinctes.
La chaîne words[i] peut être associée à la chaîne words[j] si :

La chaîne words[i] est égale à la chaîne inversée de words[j].
0 <= i < j < words.length.

Retournez le nombre maximum de paires pouvant être formées à partir du tableau words.
Notez que chaque chaîne peut appartenir au plus à une paire.

Exemple 1 :

Entrée : words = ["cd","ac","dc","ca","zz"]
Sortie : 2
Explication : Dans cet exemple, nous pouvons former 2 paires de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 2^ème chaîne, car la chaîne inversée de word[0] est "dc" et est égale à words[2].
- Nous associons la 1^ère chaîne avec la 3^ème chaîne, car la chaîne inversée de word[1] est "ca" et est égale à words[3].
Il peut être prouvé que 2 est le nombre maximum de paires pouvant être formées.
Exemple 2 :

Entrée : words = ["ab","ba","cc"]
Sortie : 1
Explication : Dans cet exemple, nous pouvons former 1 paire de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 1^ère chaîne, car la chaîne inversée de words[1] est "ab" et est égale à words[0].
Il peut être prouvé que 1 est le nombre maximum de paires pouvant être formées.

Exemple 3 :

Entrée : words = ["aa","ab"]
Sortie : 0
Explication : Dans cet exemple, nous ne pouvons former aucune paire de chaînes.

Contraintes :

1 <= words.length <= 50
words[i].length == 2
words est constitué de chaînes distinctes.
words[i] contient uniquement des lettres minuscules anglaises.

On vous donne un tableau indexé à 0 words constitué de chaînes de caractères distinctes.
La chaîne words[i] peut être associée à la chaîne words[j] si :

La chaîne words[i] est égale à la chaîne inversée de words[j].
0 <= i < j < words.length.

Retournez le nombre maximum de paires pouvant être formées à partir du tableau words.
Notez que chaque chaîne peut appartenir au plus à une paire.

Exemple 1 :

Entrée : words = ["cd","ac","dc","ca","zz"]
Sortie : 2
Explication : Dans cet exemple, nous pouvons former 2 paires de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 2^ème chaîne, car la chaîne inversée de word[0] est "dc" et est égale à words[2].
- Nous associons la 1^ère chaîne avec la 3^ème chaîne, car la chaîne inversée de word[1] est "ca" et est égale à words[3].
Il peut être prouvé que 2 est le nombre maximum de paires pouvant être formées.

Exemple 2 :

Entrée : words = ["ab","ba","cc"]
Sortie : 1
Explication : Dans cet exemple, nous pouvons former 1 paire de chaînes de la manière suivante :
- Nous associons la 0^ème chaîne avec la 1^ère chaîne, car la chaîne inversée de words[1] est "ab" et est égale à words[0].
Il peut être prouvé que 1 est le nombre maximum de paires pouvant être formées.

Exemple 3 :

Entrée : words = ["aa","ab"]
Sortie : 0
Explication : Dans cet exemple, nous ne pouvons former aucune paire de chaînes.

Contraintes :

1 <= words.length <= 50
words[i].length == 2
words est constitué de chaînes distinctes.
words[i] contient uniquement des lettres minuscules anglaises.


On donne un tableau d'entiers nums, indexé à partir de 0, contenant n entiers positifs distincts. Une permutation de nums est appelée spéciale si :

Pour tous les index 0 <= i < n - 1, soit nums[i] % nums[i+1] == 0, soit nums[i+1] % nums[i] == 0.

Retournez le nombre total de permutations spéciales. Comme la réponse pourrait être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,3,6]
Sortie : 2
Explication : [3,6,2] et [2,6,3] sont les deux permutations spéciales de nums.

Exemple 2 :

Entrée : nums = [1,4,3]
Sortie : 2
Explication : [3,1,4] et [4,1,3] sont les deux permutations spéciales de nums.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0, contenant n entiers positifs distincts. Une permutation de nums est appelée spéciale si:

Pour tous les index 0 <= i < n - 1, soit nums[i] % nums[i+1] == 0 ou nums[i+1] % nums[i] == 0.

Retournez le nombre total de permutations spéciales. Comme la réponse pourrait être grande, retournez-la modulo 10^9 + 7.

Exemple 1:

Entrée: nums = [2,3,6]

Sortie: 2

Explication: [3,6,2] et [2,6,3] sont les deux permutations spéciales de nums.

Exemple 2:

Entrée: nums = [1,4,3]

Sortie: 2

Explication: [3,1,4] et [4,1,3] sont les deux permutations spéciales de nums.

Contraintes:

2 <= nums.length <= 14

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

On vous donne un tableau d'entiers indexés 0 nums contenant n entiers positifs distincts. Une permutation de nums est dite spéciale si :

Pour tous les indices 0 <= i < n - 1, soit nums[i] % nums[i+1] == 0, soit nums[i+1] % nums[i] == 0.

Renvoyer le nombre total de permutations spéciales. Comme la réponse peut être importante, nous la renvoyons modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,3,6]
Sortie : 2
Explication : [3,6,2] et [2,6,3] sont les deux permutations spéciales de nums.

Exemple 2 :

Entrée : nums = [1,4,3]
Sortie : 2
Explication : [3,1,4] et [4,1,3] sont les deux permutations spéciales de nums.

Contraintes :

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


Le nombre de déséquilibre d'un tableau arr d'entiers indexé à partir de 0 de longueur n est défini comme le nombre d'indices dans sarr = sorted(arr) tels que :

0 <= i < n - 1, et
sarr[i+1] - sarr[i] > 1

Ici, sorted(arr) est la fonction qui renvoie la version triée de arr.
Étant donné un tableau d'entiers nums indexé à partir de 0, retournez la somme des nombres de déséquilibre de tous ses sous-tableaux.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2,3,1,4]
Sortie : 3
Explication : Il y a 3 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [3, 1] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 1, 4] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 4] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de nums est 3.

Exemple 2 :

Entrée : nums = [1,3,3,3,5]
Sortie : 8
Explication : Il y a 7 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [1, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3, 5] avec un nombre de déséquilibre de 2.
- Sous-tableau [3, 3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 5] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de nums est 8.

Contraintes :

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

Le nombre de déséquilibre d'un tableau d'entiers à index 0 `arr` de longueur n est défini comme le nombre d'indices dans `sarr = sorted(arr)` tels que :

0 <= i < n - 1, et
sarr[i+1] - sarr[i] > 1

Ici, `sorted(arr)` est la fonction qui renvoie la version triée de `arr`.
Étant donné un tableau d'entiers à index 0 `nums`, renvoyez la somme des nombres de déséquilibre de tous ses sous-tableaux.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2,3,1,4]
Sortie : 3
Explication : Il y a 3 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [3, 1] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 1, 4] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 4] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de `nums` est 3.

Exemple 2 :

Entrée : nums = [1,3,3,3,5]
Sortie : 8
Explication : Il y a 7 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [1, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3, 5] avec un nombre de déséquilibre de 2.
- Sous-tableau [3, 3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 5] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de `nums` est 8.

Contraintes :

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

Le nombre de déséquilibre d'un tableau d'entiers à index 0 `arr` de longueur n est défini comme le nombre d'indices dans `sarr = sorted(arr)` tels que :

0 <= i < n - 1, et
sarr[i+1] - sarr[i] > 1

Ici, `sorted(arr)` est la fonction qui renvoie la version triée de `arr`.
Étant donné un tableau d'entiers à index 0 `nums`, renvoyez la somme des nombres de déséquilibre de tous ses sous-tableaux.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2,3,1,4]
Sortie : 3
Explication : Il y a 3 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [3, 1] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 1, 4] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 4] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de `nums` est 3.

Exemple 2 :

Entrée : nums = [1,3,3,3,5]
Sortie : 8
Explication : il y a 7 sous-tableaux avec des nombres de déséquilibre non nuls :
- Sous-tableau [1, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3] avec un nombre de déséquilibre de 1.
- Sous-tableau [1, 3, 3, 3, 5] avec un nombre de déséquilibre de 2.
- Sous-tableau [3, 3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 3, 5] avec un nombre de déséquilibre de 1.
- Sous-tableau [3, 5] avec un nombre de déséquilibre de 1.
Le nombre de déséquilibre de tous les autres sous-tableaux est 0. Par conséquent, la somme des nombres de déséquilibre de tous les sous-tableaux de `nums` est 8.

Contraintes :

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