On vous donne trois entiers x, y et z.
Vous avez x chaînes égales à "AA", y chaînes égales à "BB", et z chaînes égales à "AB". Vous voulez choisir certaines (possiblement toutes ou aucune) de ces chaînes et les concaténer dans un certain ordre pour former une nouvelle chaîne. Cette nouvelle chaîne ne doit pas contenir "AAA" ou "BBB" comme sous-chaîne.
Retournez la longueur maximale possible de la nouvelle chaîne.
Une sous-chaîne est une séquence contiguë et non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : x = 2, y = 5, z = 1
Sortie : 12
Explication : Nous pouvons concaténer les chaînes "BB", "AA", "BB", "AA", "BB", et "AB" dans cet ordre. Alors, notre nouvelle chaîne est "BBAABBAABBAB".
Cette chaîne a une longueur de 12, et nous pouvons démontrer qu'il est impossible de construire une chaîne de longueur supérieure.

Exemple 2 :

Entrée : x = 3, y = 2, z = 2
Sortie : 14
Explication : Nous pouvons concaténer les chaînes "AB", "AB", "AA", "BB", "AA", "BB", et "AA" dans cet ordre. Alors, notre nouvelle chaîne est "ABABAABBAABBAA".
Cette chaîne a une longueur de 14, et nous pouvons démontrer qu'il est impossible de construire une chaîne de longueur supérieure.

Contraintes :

1 <= x, y, z <= 50

On vous donne trois nombres entiers x, y et z.
Vous avez x chaînes égales à "AA", y chaînes égales à "BB", et z chaînes égales à "AB". Vous voulez choisir certaines (possiblement toutes ou aucune) de ces chaînes et les concaténer dans un certain ordre pour former une nouvelle chaîne. Cette nouvelle chaîne ne doit pas contenir "AAA" ou "BBB" comme sous-chaîne.
La longueur maximale possible de la nouvelle chaîne est renvoyée.
Une sous-chaîne est une séquence contiguë et non vide de caractères à l'intérieur d'une chaîne.

Exemple 1 :

Entrée : x = 2, y = 5, z = 1
Sortie : 12
Explication : Nous pouvons concaténer les chaînes "BB", "AA", "BB", "AA", "BB", et "AB" dans cet ordre. Alors, notre nouvelle chaîne est "BBAABBAABBAB".
Cette chaîne a une longueur de 12, et nous pouvons montrer qu'il est impossible de construire une chaîne plus longue.

Exemple 2 :

Entrée : x = 3, y = 2, z = 2
Sortie : 14
Explication : Nous pouvons concaténer les chaînes "AB", "AB", "AA", "BB", "AA", "BB", et "AA" dans cet ordre. Alors, notre nouvelle chaîne est "ABABAABBAABBAA".
Cette chaîne a une longueur de 14, et nous pouvons montrer qu'il est impossible de construire une chaîne plus longue.

Contraintes :

1 <= x, y, z <= 50

On vous donne trois entiers x, y et z.
Vous avez x chaînes égales à "AA", y chaînes égales à "BB", et z chaînes égales à "AB". Vous voulez choisir certaines (possiblement toutes ou aucune) de ces chaînes et les concaténer dans un certain ordre pour former une nouvelle chaîne. Cette nouvelle chaîne ne doit pas contenir "AAA" ou "BBB" comme sous-chaîne.
Retournez la longueur maximale possible de la nouvelle chaîne.
Une sous-chaîne est une séquence contiguë et non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : x = 2, y = 5, z = 1
Sortie : 12
Explication : Nous pouvons concaténer les chaînes "BB", "AA", "BB", "AA", "BB", et "AB" dans cet ordre. Alors, notre nouvelle chaîne est "BBAABBAABBAB".
Cette chaîne a une longueur de 12, et nous pouvons montrer qu'il est impossible de construire une chaîne de plus grande longueur.

Exemple 2 :

Entrée : x = 3, y = 2, z = 2
Sortie : 14
Explication : Nous pouvons concaténer les chaînes "AB", "AB", "AA", "BB", "AA", "BB", et "AA" dans cet ordre. Alors, notre nouvelle chaîne est "ABABAABBAABBAA".
Cette chaîne a une longueur de 14, et nous pouvons montrer qu'il est impossible de construire une chaîne de plus grande longueur.

Contraintes :

1 <= x, y, z <= 50


On vous donne un tableau `words` indexé à partir de 0 contenant n chaînes de caractères.

Définissons une opération de fusion `join(x, y)` entre deux chaînes x et y comme leur concaténation en xy. Cependant, si le dernier caractère de x est égal au premier caractère de y, l'un d'eux est supprimé.

Par exemple, `join("ab", "ba") = "aba"` et `join("ab", "cde") = "abcde"`.

Vous devez effectuer n - 1 opérations de fusion. Soit `str_0 = words[0]`. À partir de i = 1 jusqu'à i = n - 1, pour la i^ème opération, vous pouvez faire l'une des choses suivantes :

Faire `str_i = join(str_i - 1, words[i])`
Faire `str_i = join(words[i], str_i - 1)`

Votre tâche est de minimiser la longueur de `str_n - 1`.

Retournez un entier représentant la longueur minimale possible de `str_n - 1`.

Exemple 1 :

Entrée : `words = ["aa", "ab", "bc"]`
Sortie : 4
Explication : Dans cet exemple, nous pouvons effectuer des opérations de fusion dans l'ordre suivant pour minimiser la longueur de `str_2` :
`str_0 = "aa"`
`str_1 = join(str_0, "ab") = "aab"`
`str_2 = join(str_1, "bc") = "aabc"`
Il peut être démontré que la longueur minimale possible de `str_2` est 4.

Exemple 2 :

Entrée : `words = ["ab", "b"]`
Sortie : 2
Explication : Dans cet exemple, `str_0 = "ab"`, il y a deux façons d'obtenir `str_1` :
`join(str_0, "b") = "ab"` ou `join("b", str_0) = "bab"`.
La première chaîne, "ab", a la longueur minimale. Par conséquent, la réponse est 2.

Exemple 3 :

Entrée : `words = ["aaa", "c", "aba"]`
Sortie : 6
Explication : Dans cet exemple, nous pouvons effectuer des opérations de fusion dans l'ordre suivant pour minimiser la longueur de `str_2` :
`str_0 = "aaa"`
`str_1 = join(str_0, "c") = "aaac"`
`str_2 = join("aba", str_1) = "abaaac"`
Il peut être démontré que la longueur minimale possible de `str_2` est 6.

Contraintes :

1 <= words.length <= 1000
1 <= words[i].length <= 50
Chaque caractère dans `words[i]` est une lettre minuscule anglaise.

On vous donne un tableau indexé à 0 contenant n chaînes contenant n chaînes.
Définissons une opération de jointure join(x, y) entre deux chaînes x et y comme les concaténant dans xy. Cependant, si le dernier caractère de x est égal au premier caractère de y, l'un d'eux est supprimé.
Par exemple, join ("ab", "ba") = "aba" et join ("ab", "cde") = "abcde".
Vous devez effectuer n - 1 opérations. Soit str_0 = mots [0]. À partir de i = 1 jusqu'à i = n - 1, pour l'opération i ^ th, vous pouvez faire l'un des éléments suivants:

Faire str_i = join(str_i-1, words[i])
Faire str_i = join(words[i], str_i - 1)

Votre tâche consiste à minimiser la longueur de str_n - 1.
Renvoie un entier indiquant la longueur minimale possible de str_n - 1.

Exemple 1:

Entrée: words = ["aa","ab","bc"]
Sortie: 4
Explication: Dans cet exemple, nous pouvons effectuer des opérations de jointure dans l'ordre suivant pour minimiser la longueur de str_2:
str_0 = "aa"
str_1 = join (str_0, "ab") = "aab"
str_2 = join (str_1, "bc") = "aabc"
On peut montrer que la longueur minimale possible de str_2 est 4.
Exemple 2:

Entrée: words = ["ab","b"]
Sortie: 2
Explication: Dans cet exemple, str_0 = "ab", il existe deux façons d'obtenir str_1:
join (str_0, "b") = "ab" ou join ("b", str_0) = "bab".
La première chaîne, "AB", a la longueur minimale. Par conséquent, la réponse est 2.

Exemple 3:

Entrée:  words = ["aaa","c","aba"]
Sortie: 6
Explication: Dans cet exemple, nous pouvons effectuer des opérations de jointure dans l'ordre suivant pour minimiser la longueur de str_2:
str_0 = "aaa"
str_1 = join (str_0, "c") = "aaac"
str_2 = join ("aba", str_1) = "abaaac"
On peut montrer que la longueur minimale possible de str_2 est de 6.

Contraintes:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Chaque caractère dans words[i] est une lettre minuscule anglaise

Vous avez un tableau words indexé à partir de 0 contenant n chaînes de caractères.
Définissons une opération de fusion join(x, y) entre deux chaînes x et y comme leur concaténation en xy. Cependant, si le dernier caractère de x est égal au premier caractère de y, l'un d'eux est supprimé.
Par exemple, join("ab", "ba") = "aba" et join("ab", "cde") = "abcde".
Vous devez effectuer n - 1 opérations de fusion. Soit `str_0 = words[0]`. À partir de i = 1 jusqu'à i = n - 1, pour la i^ème opération, vous pouvez faire l'une des choses suivantes :

Effectuer str_i = join(str_i - 1, words[i])
Effectuer str_i = join(words[i], str_i - 1)

Votre tâche est de minimiser la longueur de str_n - 1.
Retournez un entier représentant la longueur minimale possible de str_n - 1.

Exemple 1 :

Entrée : words = ["aa", "ab", "bc"]
Sortie : 4
Explication : Dans cet exemple, nous pouvons effectuer des opérations de fusion dans l'ordre suivant pour minimiser la longueur de str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
On peut montrer que la longueur minimale possible de str_2 est 4.
Exemple 2 :

Entrée : words = ["ab", "b"]
Sortie : 2
Explication : Dans cet exemple, str_0 = "ab", il y a deux façons d'obtenir str_1 :
join(str_0, "b") = "ab" ou join("b", str_0) = "bab".
La première chaîne, "ab", a la longueur minimale. Par conséquent, la réponse est 2.

Exemple 3 :

Entrée : words = ["aaa", "c", "aba"]
Sortie : 6
Explication : Dans cet exemple, nous pouvons effectuer des opérations de fusion dans l'ordre suivant pour minimiser la longueur de str_2 :
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
On peut montrer que la longueur minimale possible de str_2 est 6.

Contraintes :

1 <= words.length <= 1000
1 <= words[i].length <= 50
Chaque caractère dans `words[i]` est une lettre minuscule anglaise.


On vous donne un tableau 0-indexé `nums` de n entiers et un entier `target`.
Vous êtes initialement positionné à l'index 0. En un seul pas, vous pouvez sauter de l'index i à n'importe quel index j tel que :

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Renvoyez le nombre maximum de sauts que vous pouvez effectuer pour atteindre l'index n - 1.
S'il n'y a aucun moyen d'atteindre l'index n - 1, retournez -1.

Exemple 1 :

Entrée : nums = [1,3,6,4,1,2], target = 2
Sortie : 3
Explication : Pour aller de l'index 0 à l'index n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'index 0 à l'index 1.
- Sautez de l'index 1 à l'index 3.
- Sautez de l'index 3 à l'index 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 3 sauts. Par conséquent, la réponse est 3.

Exemple 2 :

Entrée : nums = [1,3,6,4,1,2], target = 3
Sortie : 5
Explication : Pour aller de l'index 0 à l'index n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'index 0 à l'index 1.
- Sautez de l'index 1 à l'index 2.
- Sautez de l'index 2 à l'index 3.
- Sautez de l'index 3 à l'index 4.
- Sautez de l'index 4 à l'index 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 5 sauts. Par conséquent, la réponse est 5.

Exemple 3 :

Entrée : nums = [1,3,6,4,1,2], target = 0
Sortie : -1
Explication : On peut prouver qu'il n'existe pas de séquence de sauts qui va de 0 à n - 1. Par conséquent, la réponse est -1.

Contraintes :

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

On vous donne un tableau 0-indexé `nums` de n entiers et un entier `target`.
Vous êtes initialement positionné à l'index 0. En un seul pas, vous pouvez sauter de l'index i à n'importe quel index j tel que :

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Retournez le nombre maximum de sauts que vous pouvez effectuer pour atteindre l'index n - 1.
S'il n'y a aucun moyen d'atteindre l'index n - 1, retournez -1.

Exemple 1 :

Entrée : nums = [1,3,6,4,1,2], target = 2
Sortie : 3
Explication : Pour aller de l'index 0 à l'index n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'index 0 à l'index 1.
- Sautez de l'index 1 à l'index 3.
- Sautez de l'index 3 à l'index 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 3 sauts. Par conséquent, la réponse est 3.
Exemple 2 :

Entrée : nums = [1,3,6,4,1,2], target = 3
Sortie : 5
Explication : Pour aller de l'index 0 à l'index n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'index 0 à l'index 1.
- Sautez de l'index 1 à l'index 2.
- Sautez de l'index 2 à l'index 3.
- Sautez de l'index 3 à l'index 4.
- Sautez de l'index 4 à l'index 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 5 sauts. Par conséquent, la réponse est 5.
Exemple 3 :

Entrée : nums = [1,3,6,4,1,2], target = 0
Sortie : -1
Explication : On peut prouver qu'il n'existe pas de séquence de sauts qui va de 0 à n - 1. Par conséquent, la réponse est -1.

Contraintes :

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

On vous donne un tableau nums indexé à partir de 0 de n entiers et un entier target.
Vous êtes initialement positionné à l'indice 0. En un seul pas, vous pouvez sauter de l'indice i à n'importe quel indice j tel que :

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Retournez le nombre maximum de sauts que vous pouvez effectuer pour atteindre l'indice n - 1.
S'il n'y a aucun moyen d'atteindre l'indice n - 1, retournez -1.

Exemple 1 :

Entrée : nums = [1,3,6,4,1,2], target = 2
Sortie : 3
Explication : Pour aller de l'indice 0 à l'indice n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'indice 0 à l'indice 1.
- Sautez de l'indice 1 à l'indice 3.
- Sautez de l'indice 3 à l'indice 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 3 sauts. Par conséquent, la réponse est 3.
Exemple 2 :

Entrée : nums = [1,3,6,4,1,2], target = 3
Sortie : 5
Explication : Pour aller de l'indice 0 à l'iindice n - 1 avec le nombre maximum de sauts, vous pouvez effectuer la séquence de sauts suivante :
- Sautez de l'indice 0 à l'indice 1.
- Sautez de l'indice 1 à l'indice 2.
- Sautez de l'indice 2 à l'indice 3.
- Sautez de l'indice 3 à l'indice 4.
- Sautez de l'indice 4 à l'indice 5.
On peut prouver qu'il n'existe pas d'autre séquence de sauts qui va de 0 à n - 1 avec plus de 5 sauts. Par conséquent, la réponse est 5.
Exemple 3 :

Entrée : nums = [1,3,6,4,1,2], target = 0
Sortie : -1
Explication : On peut prouver qu'il n'existe pas de séquence de sauts qui va de 0 à n - 1. Par conséquent, la réponse est -1.

Contraintes :

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9


Vous avez un tableau nums composé d'entiers positifs.
Nous appelons un sous-tableau d'un tableau complet si la condition suivante est satisfaite :

Le nombre d'éléments distincts dans le sous-tableau est égal au nombre d'éléments distincts dans l'ensemble du tableau.

Retournez le nombre de sous-tableaux complets.
Un sous-tableau est une partie contiguë non vide d'un tableau.

Exemple 1 :

Entrée : nums = [1,3,1,2,2]
Sortie : 4
Explication : Les sous-tableaux complets sont les suivants : [1,3,1,2], [1,3,1,2,2], [3,1,2] et [3,1,2,2].

Exemple 2 :

Entrée : nums = [5,5,5,5]
Sortie : 10
Explication : Le tableau est constitué uniquement de l'entier 5, donc tout sous-tableau est complet. Le nombre de sous-tableaux que nous pouvons choisir est 10.

Contraintes :

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

On vous donne un tableau nums composé d'entiers positifs.
Nous disons qu'un sous-tableau d'un tableau est complet si la condition suivante est satisfaite :

Le nombre d'éléments distincts dans le sous-tableau est égal au nombre d'éléments distincts dans l'ensemble du tableau.

Renvoie le nombre de sous-tableaux complets.
Un sous-tableau est une partie contiguë non vide d'un tableau.

Exemple 1 :

Entrée : nums = [1,3,1,2,2]
Sortie : 4
Explication : Les sous-tableaux complets sont les suivants : [1,3,1,2], [1,3,1,2,2], [3,1,2] et [3,1,2,2].

Exemple 2 :

Entrée : nums = [5,5,5,5]
Sortie : 10
Explication : Le tableau est composé uniquement de l'entier 5, donc tout sous-tableau est complet. Le nombre de sous-tableaux que nous pouvons choisir est de 10.

Contraintes :

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


Un camion a deux réservoirs de carburant. On vous donne deux entiers, mainTank représentant le carburant présent dans le réservoir principal en litres et additionalTank représentant le carburant présent dans le réservoir supplémentaire en litres.
Le camion a une consommation de 10 km par litre. Chaque fois que 5 litres de carburant sont utilisés dans le réservoir principal, si le réservoir supplémentaire a au moins 1 litre de carburant, 1 litre de carburant sera transféré du réservoir supplémentaire au réservoir principal.
Retournez la distance maximale qui peut être parcourue.
Remarque : L'injection du réservoir supplémentaire n'est pas continue. Elle se produit soudainement et immédiatement pour chaque 5 litres consommés.

Exemple 1 :

Entrée : mainTank = 5, additionalTank = 10
Sortie : 60
Explication :
Après avoir dépensé 5 litres de carburant, le carburant restant est (5 - 5 + 1) = 1 litre et la distance parcourue est de 50 km.
Après avoir dépensé un autre litre de carburant, aucun carburant n'est injecté dans le réservoir principal et le réservoir principal se vide.
La distance totale parcourue est de 60 km.

Exemple 2 :

Entrée : mainTank = 1, additionalTank = 2
Sortie : 10
Explication :
Après avoir dépensé 1 litre de carburant, le réservoir principal se vide.
La distance totale parcourue est de 10 km.

Contraintes :

1 <= mainTank, additionalTank <= 100

Un camion a deux réservoirs de carburant. On vous donne deux entiers, Maintank représentant le carburant présent dans le réservoir principal en litres et supplémentaires représentant le carburant présent dans le réservoir supplémentaire en litres.
Le camion a un kilométrage de 10 km par litre. Chaque fois que 5 litres de carburant sont utilisés dans le réservoir principal, si le réservoir supplémentaire a au moins 1 litre de carburant, 1 litre de carburant sera transféré du réservoir supplémentaire au réservoir principal.
Retournez la distance maximale qui peut être parcourue.
Remarque: l'injection du réservoir supplémentaire n'est pas continue. Cela arrive soudainement et immédiatement pour 5 litres consommés.

Exemple 1:

Entrée: mainTank = 5, additionalTank = 10
Sortie: 60
Explication:
Après avoir passé 5 litres de carburant, le carburant restant est (5 - 5 + 1) = 1 litre et la distance parcourue est de 50 km.
Après avoir passé un autre 1 litre de carburant, aucun carburant n'est injecté dans le réservoir principal et le réservoir principal devient vide.
La distance totale parcourue est de 60 km.

Exemple 2:

Entrée: mainTank = 1, additionalTank = 2
Sortie: 10
Explication:
Après avoir passé 1 litre de carburant, le réservoir principal devient vide.
La distance totale parcourue est de 10 km.

Contraintes:

1 <= mainTank, additionalTank <= 100


On donne un tableau d'entiers nums indexé à partir de 0 et un entier threshold.
Trouvez la longueur du plus long sous-tableau de nums commençant à l'indice l et se terminant à l'indice r (0 <= l <= r < nums.length) satisfaisant les conditions suivantes :

nums[l] % 2 == 0
Pour tous les indices i dans la plage [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Pour tous les indices i dans la plage [l, r], nums[i] <= threshold

Retournez un entier indiquant la longueur du plus long sous-tableau ainsi défini.
Remarque : Un sous-tableau est une séquence continue non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [3,2,5,4], threshold = 5
Sortie : 3
Explication : Dans cet exemple, nous pouvons sélectionner le sous-tableau qui commence à l = 1 et se termine à r = 3 => [2,5,4]. Ce sous-tableau satisfait les conditions.
Ainsi, la réponse est la longueur du sous-tableau, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.
Exemple 2 :

Entrée : nums = [1,2], threshold = 2
Sortie : 1
Explication : Dans cet exemple, nous pouvons sélectionner le sous-tableau qui commence à l = 1 et se termine à r = 1 => [2].
Il satisfait toutes les conditions et nous pouvons montrer que 1 est la longueur maximale possible réalisable.

Exemple 3 :

Entrée : nums = [2,3,4,5], threshold = 4
Sortie : 3
Explication : Dans cet exemple, nous pouvons sélectionner le sous-tableau qui commence à l = 0 et se termine à r = 2 => [2,3,4].
Il satisfait toutes les conditions.
Ainsi, la réponse est la longueur du sous-tableau, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0 et un entier threshold. Trouvez la longueur de la plus longue sous-suite de nums commençant à l'indice l et se terminant à l'indice r (0 <= l <= r < nums.length) qui satisfait les conditions suivantes :

nums[l] % 2 == 0
Pour tous les indices i dans la plage [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Pour tous les indices i dans la plage [l, r], nums[i] <= threshold

Renvoyez un entier indiquant la longueur de la plus longue sous-suite ainsi définie.
Remarque : Une sous-suite est une séquence continue non vide d'éléments dans un tableau.

Exemple 1 :

Input: nums = [3,2,5,4], threshold = 5
Output: 3
Explication : Dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 1 et se termine à r = 3 => [2,5,4]. Cette sous-suite satisfait les conditions.
Ainsi, la réponse est la longueur de la sous-suite, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.

Exemple 2 :

Input: nums = [1,2], threshold = 2
Output: 1
Explication : Dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 1 et se termine à r = 1 => [2].
Elle satisfait toutes les conditions et nous pouvons montrer que 1 est la longueur maximale possible réalisable.

Exemple 3 :

Input: nums = [2,3,4,5], threshold = 4
Output: 3
Explication : Dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 0 et se termine à r = 2 => [2,3,4].
Elle satisfait toutes les conditions.
Ainsi, la réponse est la longueur de la sous-suite, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0 et un entier threshold. Trouvez la longueur de la plus longue sous-suite de nums commençant à l'indice l et se terminant à l'indice r (0 <= l <= r < nums.length) qui satisfait les conditions suivantes :

nums[l] % 2 == 0
Pour tous les indices i dans la plage [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Pour tous les indices i dans la plage [l, r], nums[i] <= threshold

Retournez un entier indiquant la longueur de la plus longue sous-suite ainsi définie.
Remarque : une sous-suite est une séquence continue non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [3,2,5,4], threshold = 5
Sortie : 3
Explication : dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 1 et se termine à r = 3 => [2,5,4]. Cette sous-suite satisfait les conditions.
Ainsi, la réponse est la longueur de la sous-suite, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.

Exemple 2 :

Entrée : nums = [1,2], threshold = 2
Sortie : 1
Explication : dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 1 et se termine à r = 1 => [2].
Elle satisfait toutes les conditions et nous pouvons montrer que 1 est la longueur maximale possible réalisable.

Exemple 3 :

Entrée : nums = [2,3,4,5], threshold = 4
Sortie : 3
Explication : dans cet exemple, nous pouvons sélectionner la sous-suite qui commence à l = 0 et se termine à r = 2 => [2,3,4].
Elle satisfait toutes les conditions.
Ainsi, la réponse est la longueur de la sous-suite, 3. Nous pouvons montrer que 3 est la longueur maximale possible réalisable.

Contraintes :

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


On vous donne un tableau binaire nums.
Un sous-tableau est dit bon s'il contient exactement un élément de valeur 1.
Retournez un entier indiquant le nombre de façons de diviser le tableau nums en sous-tableaux bons. Comme le nombre peut être trop grand, retournez-le modulo 10^9 + 7.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [0,1,0,0,1]
Sortie : 3
Explication : Il y a 3 façons de diviser nums en sous-tableaux bons :
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Exemple 2 :

Entrée : nums = [0,1,0]
Sortie : 1
Explication : Il y a 1 façon de diviser nums en sous-tableaux bons :
- [0,1,0]

Contraintes :

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

On vous donne un tableau binaire nums.
Un sous-tableau est bon s'il contient exactement un élément de valeur 1.
Retournez un entier indiquant le nombre de façons de diviser le tableau nums en bons sous-tableaux. Comme le nombre peut être trop grand, retournez-le modulo 10^9 + 7.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [0,1,0,0,1]
Sortie : 3
Explication : Il y a 3 façons de diviser nums en bons sous-tableaux:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Exemple 2 :

Entrée : nums = [0,1,0]
Sortie : 1
Explication : Il y a 1 façon de diviser nums en bons sous-tableaux :
- [0,1,0]

Contraintes :

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

Vous avez un tableau de nombres binaires.
Un sous-tableau d'un tableau est bon s'il contient exactement un élément avec la valeur 1.
Renvoie un entier indiquant le nombre de façons de diviser le tableau en bons sous-tableaux. Comme le nombre peut être trop grand, retournez-le modulo 10^9 + 7.
Un sous-réseau est une séquence d'éléments contiguës non vides dans un tableau.

Exemple 1:

Entrée: nums = [0,1,0,0,1]
Sortie: 3
Explication: Il y a 3 façons de diviser les numéros en bons sous-réseaux:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Exemple 2:

Entrée: nums = [0,1,0]
Sortie: 1
Explication: Il y a une façon de diviser le tableau en bons sous-tableaux:
- [0,1,0]

Contraintes:

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


Vous avez un tableau d'entiers nums indexé à partir de 0. Un sous-tableau de nums est dit continu si :

Soient i, i + 1, ..., j_ les indices dans le sous-tableau. Alors, pour chaque paire d'indices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Retournez le nombre total de sous-tableaux continus.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [5,4,2,4]
Sortie : 8
Explication :
Sous-tableau continu de taille 1 : [5], [4], [2], [4].
Sous-tableau continu de taille 2 : [5,4], [4,2], [2,4].
Sous-tableau continu de taille 3 : [4,2,4].
Il n'y a pas de sous-tableaux de taille 4.
Total des sous-tableaux continus = 4 + 3 + 1 = 8.
On peut montrer qu'il n'y a pas d'autres sous-tableaux continus.

Exemple 2 :

Entrée : nums = [1,2,3]
Sortie : 6
Explication :
Sous-tableau continu de taille 1 : [1], [2], [3].
Sous-tableau continu de taille 2 : [1,2], [2,3].
Sous-tableau continu de taille 3 : [1,2,3].
Total des sous-tableaux continus = 3 + 2 + 1 = 6.

Contraintes :

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

Vous avez un tableau d'entiers nums indexé à partir de 0. Un sous-tableau de nums est appelé continu si :

Soient i, i + 1, ..., j_ les indices dans le sous-tableau. Alors, pour chaque paire d'indices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Renvoyez le nombre total de sous-tableaux continus.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [5,4,2,4]
Sortie : 8
Explication :
Sous-tableau continu de taille 1 : [5], [4], [2], [4].
Sous-tableau continu de taille 2 : [5,4], [4,2], [2,4].
Sous-tableau continu de taille 3 : [4,2,4].
Il n'y a pas de sous-tableaux de taille 4.
Total des sous-tableaux continus = 4 + 3 + 1 = 8.
On peut montrer qu'il n'y a pas d'autres sous-tableaux continus.

Exemple 2 :

Entrée : nums = [1,2,3]
Sortie : 6
Explication :
Sous-tableau continu de taille 1 : [1], [2], [3].
Sous-tableau continu de taille 2 : [1,2], [2,3].
Sous-tableau continu de taille 3 : [1,2,3].
Total des sous-tableaux continus = 3 + 2 + 1 = 6.

Contraintes :

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

On vous donne un tableau de nombres entiers à indice 0. Un sous-tableau de nombres est appelé continu si :

Soient i, i + 1, ..., j_ les indices dans le sous-tableau. Alors, pour chaque paire d'indices i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Renvoyez le nombre total de sous-tableaux continus.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nombres = [5,4,2,4]
Sortie : 8
Explication :
Sous-tableau continu de taille 1 : [5], [4], [2], [4].
Sous-tableau continu de taille 2 : [5,4], [4,2], [2,4].
Sous-tableau continu de taille 3 : [4,2,4].
Il n'y a pas de sous-tableaux de taille 4.
Total des sous-tableaux continus = 4 + 3 + 1 = 8.
On peut montrer qu'il n'y a pas d'autres sous-tableaux continus.

Exemple 2 :

Entrée : nombres = [1,2,3]
Sortie : 6
Explication :
Sous-tableau continu de taille 1 : [1], [2], [3].
Sous-tableau continu de taille 2 : [1,2], [2,3].
Sous-tableau continu de taille 3 : [1,2,3].
Total des sous-tableaux continus = 3 + 2 + 1 = 6.

Contraintes :

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


On vous donne deux tableaux d'entiers indexés à 0, nums1 et nums2 de longueur n.
Définissons un autre tableau d'entiers indexé à 0, nums3, de longueur n. Pour chaque indice i dans la plage [0, n - 1], vous pouvez assigner soit nums1[i], soit nums2[i] à nums3[i].
Votre tâche est de maximiser la longueur de la plus longue sous-séquence non décroissante dans nums3 en choisissant ses valeurs de manière optimale.
Retournez un entier représentant la longueur de la plus longue sous-séquence non décroissante dans nums3.
Remarque : une sous-séquence est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums1 = [2,3,1], nums2 = [1,2,1]
Sortie : 2
Explication : Une façon de construire nums3 est :
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
La sous-séquence commençant à l'indice 0 et se terminant à l'indice 1, [2,2], forme une sous-séquence non décroissante de longueur 2.
On peut montrer que 2 est la longueur maximale réalisable.
Exemple 2 :

Entrée : nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Sortie : 4
Explication : Une façon de construire nums3 est :
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Le tableau entier forme une sous-séquence non décroissante de longueur 4, ce qui en fait la longueur maximale réalisable.

Exemple 3 :

Entrée : nums1 = [1,1], nums2 = [2,2]
Sortie : 2
Explication : Une façon de construire nums3 est :
nums3 = [nums1[0], nums1[1]] => [1,1].
Le tableau entier forme une sous-séquence non décroissante de longueur 2, ce qui en fait la longueur maximale réalisable.

Contraintes :

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

On vous donne deux tableaux d'entiers indexés 0, nums1 et nums2, de longueur n.
Définissons un autre tableau d'entiers à indice 0, nums3, de longueur n. Pour chaque indice i dans l'intervalle [0, n - 1], vous pouvez affecter nums1[i] ou nums2[i] à nums3[i].
Votre tâche consiste à maximiser la longueur du plus long sous-réseau non décroissant de nums3 en choisissant ses valeurs de manière optimale.
Renvoyez un entier représentant la longueur du sous-réseau non décroissant le plus long de nums3.
Remarque : un sous-réseau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums1 = [2,3,1], nums2 = [1,2,1] Sortie : 2 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1]. La sous-séquence commençant à l'indice 0 et se terminant à l'indice 1, [2,2], forme une sous-séquence non décroissante de longueur 2. On peut montrer que 2 est la longueur maximale réalisable.

Exemple 2 :

Entrée : nums1 = [1,3,2,1], nums2 = [2,2,3,4] Sortie : 4 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4]. Le tableau entier forme une sous-séquence non décroissante de longueur 4, ce qui en fait la longueur maximale réalisable.

Exemple 3 :

Entrée : nums1 = [1,1], nums2 = [2,2] Sortie : 2 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums1[1]] => [1,1]. Le tableau entier forme une sous-séquence non décroissante de longueur 2, ce qui en fait la longueur maximale réalisable.

Contraintes :

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

On vous donne deux tableaux d'entiers indexés à 0, nums1 et nums2 de longueur n. Définissons un autre tableau d'entiers indexé à 0, nums3, de longueur n. Pour chaque indice i dans la plage [0, n - 1], vous pouvez attribuer soit nums1[i], soit nums2[i] à nums3[i]. Votre tâche est de maximiser la longueur de la plus longue sous-séquence non décroissante dans nums3 en choisissant ses valeurs de manière optimale. Retournez un entier représentant la longueur de la plus longue sous-séquence non décroissante dans nums3. Remarque : une sous-séquence est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums1 = [2,3,1], nums2 = [1,2,1] Sortie : 2 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1]. La sous-séquence commençant à l'indice 0 et se terminant à l'indice 1, [2,2], forme une sous-séquence non décroissante de longueur 2. On peut montrer que 2 est la longueur maximale réalisable.

Exemple 2 :

Entrée : nums1 = [1,3,2,1], nums2 = [2,2,3,4] Sortie : 4 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4]. Le tableau entier forme une sous-séquence non décroissante de longueur 4, ce qui en fait la longueur maximale réalisable.

Exemple 3 :

Entrée : nums1 = [1,1], nums2 = [2,2] Sortie : 2 Explication : Une façon de construire nums3 est : nums3 = [nums1[0], nums1[1]] => [1,1]. Le tableau entier forme une sous-séquence non décroissante de longueur 2, ce qui en fait la longueur maximale réalisable.

Contraintes :

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


Vous avez un tableau d'entiers nums indexé à partir de 0. Un sous-tableau s de longueur m est appelé alterné si :

m est supérieur à 1.
s_1 = s_0 + 1.
Le sous-tableau indexé à partir de 0 s ressemble à [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. En d'autres termes, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, et ainsi de suite jusqu'à s[m - 1] - s[m - 2] = (-1)^m.

Retournez la longueur maximale de tous les sous-tableaux alternés présents dans nums ou -1 si aucun sous-tableau de ce type n'existe.
Un sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [2,3,4,3,4]
Sortie : 4
Explication : Les sous-tableaux alternés sont [3,4], [3,4,3], et [3,4,3,4]. Le plus long de ceux-ci est [3,4,3,4], qui est de longueur 4.

Exemple 2 :

Entrée : nums = [4,5,6]
Sortie : 2
Explication : [4,5] et [5,6] sont les seuls deux sous-tableaux alternés. Ils sont tous deux de longueur 2.

Contraintes :

2 <= nums.length <= 100
1 <= nums[i] <= 10^4

Vous recevez un nombre de tableaux entiers indexé à 0. Un sous-tableau de longueur m est appelé en alternance si:

m est supérieur à 1.
s_1 = s_0 + 1.
Le sous-tableau 0-indexé ressemble à [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. En d'autres termes, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, et ainsi de suite jusqu'à s[m - 1] - s[m - 2] = (-1)^m.

Renvoyez la longueur maximale de tous les sous-réseaux alternés présents en nums ou -1 si aucune sous-tableau de ce type n'existe.
Un sous-tableau est une séquence d'éléments contiguës non vides dans un tableau.

Exemple 1:

Entrée: nums = [2,3,4,3,4]
Sortie: 4
Explication: Les sous-réseaux alternés sont [3,4], [3,4,3] et [3,4,3,4]. Le plus long d'entre eux est [3,4,3,4], qui est de longueur 4.

Exemple 2:

Entrée: nums = [4,5,6]
Sortie: 2
Explication: [4,5] et [5,6] sont les deux seules sous-réseaux alternés. Ils sont tous les deux de longueur 2.

Contraintes:

2 <= nums.length <= 100
1 <= nums[i] <= 10 ^ 4


Vous disposez d'un tableau nums indexé à partir de 0 constitué d'entiers positifs.
Vous pouvez effectuer l'opération suivante sur le tableau un nombre quelconque de fois :

Choisissez un entier i tel que 0 <= i < nums.length - 1 et nums[i] <= nums[i + 1]. Remplacez l'élément nums[i + 1] par nums[i] + nums[i + 1] et supprimez l'élément nums[i] du tableau.

Retournez la valeur du plus grand élément que vous pouvez obtenir dans le tableau final.

Exemple 1 :

Entrée : nums = [2,3,7,9,3]
Sortie : 21
Explication : Nous pouvons appliquer les opérations suivantes sur le tableau :
- Choisir i = 0. Le tableau résultant sera nums = [5,7,9,3].
- Choisir i = 1. Le tableau résultant sera nums = [5,16,3].
- Choisir i = 0. Le tableau résultant sera nums = [21,3].
Le plus grand élément dans le tableau final est 21. On peut montrer qu'il est impossible d'obtenir un élément plus grand.

Exemple 2 :

Entrée : nums = [5,3,3]
Sortie : 11
Explication : Nous pouvons faire les opérations suivantes sur le tableau :
- Choisir i = 1. Le tableau résultant sera nums = [5,6].
- Choisir i = 0. Le tableau résultant sera nums = [11].
Il n'y a qu'un seul élément dans le tableau final, qui est 11.

Contraintes :

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

On vous donne un tableau nums indexé à 0 composé d'entiers positifs.
Vous pouvez effectuer l'opération suivante sur le tableau autant de fois que vous le souhaitez :

Choisissez un entier i tel que 0 <= i < nums.length - 1 et nums[i] <= nums[i + 1]. Remplacez l'élément nums[i + 1] par nums[i] + nums[i + 1] et supprimez l'élément nums[i] du tableau.

Renvoie la valeur du plus grand élément que vous pouvez éventuellement obtenir dans le tableau final.

Exemple 1 :

Entrée : nums = [2,3,7,9,3]
Sortie : 21
Explication : Nous pouvons appliquer les opérations suivantes sur le tableau :
- Choisissez i = 0. Le tableau résultant sera nums = [5,7,9,3].
- Choisissez i = 1. Le tableau résultant sera nums = [5,16,3].
- Choisissez i = 0. Le tableau résultant sera nums = [21,3].
Le plus grand élément du tableau final est 21. On peut montrer que nous ne pouvons pas obtenir un élément plus grand.

Exemple 2 :

Entrée : nums = [5,3,3]
Sortie : 11
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 1. Le tableau résultant sera nums = [5,6].
- Choisissez i = 0. Le tableau résultant sera nums = [11].
Il n'y a qu'un seul élément dans le tableau final, qui est 11.

Contraintes :

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

Vous disposez d'un tableau à index 0 `nums` constitué d'entiers positifs.
Vous pouvez effectuer l'opération suivante sur le tableau un nombre quelconque de fois :

Choisissez un entier `i` tel que 0 <= i < nums.length - 1 et nums[i] <= nums[i + 1]. Remplacez l'élément nums[i + 1] par nums[i] + nums[i + 1] et supprimez l'élément nums[i] du tableau.

Retournez la valeur du plus grand élément que vous pouvez obtenir dans le tableau final.

Exemple 1 :

Entrée : nums = [2,3,7,9,3]
Sortie : 21
Explication : Nous pouvons appliquer les opérations suivantes sur le tableau :
- Choisir i = 0. Le tableau résultant sera nums = [5,7,9,3].
- Choisir i = 1. Le tableau résultant sera nums = [5,16,3].
- Choisir i = 0. Le tableau résultant sera nums = [21,3].
Le plus grand élément dans le tableau final est 21. On peut montrer qu'il est impossible d'obtenir un élément plus grand.

Exemple 2 :

Entrée : nums = [5,3,3]
Sortie : 11
Explication : Nous pouvons faire les opérations suivantes sur le tableau :
- Choisir i = 1. Le tableau résultant sera nums = [5,6].
- Choisir i = 0. Le tableau résultant sera nums = [11].
Il n'y a qu'un seul élément dans le tableau final, qui est 11.

Contraintes :

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


Vous avez un entier n. Disons que deux entiers x et y forment une paire de nombres premiers si :

1 <= x <= y <= n
x + y == n
x et y sont des nombres premiers

Retournez la liste 2D triée des paires de nombres premiers [x_i, y_i]. La liste doit être triée par ordre croissant de x_i. S'il n'y a pas du tout de paires de nombres premiers, retournez un tableau vide.
Remarque : Un nombre premier est un nombre naturel supérieur à 1 qui n'a que deux diviseurs, lui-même et 1.

Exemple 1 :

Entrée : n = 10
Sortie : [[3,7],[5,5]]
Explication : Dans cet exemple, il y a deux paires de nombres premiers qui satisfont les critères.
Ces paires sont [3,7] et [5,5], et nous les retournons dans l'ordre trié comme décrit dans l'énoncé du problème.

Exemple 2 :

Entrée : n = 2
Sortie : []
Explication : Nous pouvons montrer qu'il n'y a pas de paire de nombres premiers dont la somme est 2, donc nous retournons un tableau vide.

Contraintes :

1 <= n <= 10^6

On vous donne un entier n. On dit que deux entiers x et y forment une paire de nombres premiers si :

1 <= x <= y <= n
x + y == n
x et y sont des nombres premiers

Renvoie la liste triée en 2D de paires de nombres premiers [x_i, y_i]. La liste doit être triée par ordre croissant de x_i. S’il n’y a pas de paires de nombres premiers, renvoyez un tableau vide.
Remarque : Un nombre premier est un nombre naturel supérieur à 1 avec seulement deux facteurs, lui-même et 1.

Exemple 1 :

Entrée : n = 10
Sortie : [[3,7],[5,5]]
Explication : Dans cet exemple, il y a deux paires premières qui satisfont aux critères.
Ces paires sont [3,7] et [5,5], et nous les retournons dans l’ordre trié décrit dans l’énoncé du problème.

Exemple 2 :

Entrée : n = 2
Sortie : []
Explication : Nous pouvons montrer qu’il n’y a pas de paire de nombres premiers qui donne une somme de 2, nous retournons donc un tableau vide.

Contraintes:

1 <= n <= 10^6

Vous avez un entier n. Nous disons que deux entiers x et y forment une paire de nombres premiers si :

1 <= x <= y <= n
x + y == n
x et y sont des nombres premiers

Retournez la liste 2D triée des paires de nombres premiers [x_i, y_i]. La liste doit être triée par ordre croissant de x_i. S'il n'y a pas du tout de paires de nombres premiers, retournez un tableau vide.
Note : Un nombre premier est un nombre naturel supérieur à 1 avec seulement deux facteurs, lui-même et 1.

Exemple 1 :

Entrée : n = 10
Sortie : [[3,7],[5,5]]
Explication : Dans cet exemple, il y a deux paires de nombres premiers qui satisfont les critères.
Ces paires sont [3,7] et [5,5], et nous les retournons dans l'ordre trié comme décrit dans l'énoncé du problème.

Exemple 2 :

Entrée : n = 2
Sortie : []
Explication : Nous pouvons montrer qu'il n'y a pas de paire de nombres premiers dont la somme est 2, donc nous retournons un tableau vide.

Contraintes :

1 <= n <= 10^6


Il y a n employés dans une entreprise, numérotés de 0 à n - 1. Chaque employé i a travaillé pendant heures[i] heures dans l'entreprise. L'entreprise exige que chaque employé travaille pendant au moins target heures. On vous donne un tableau indexé à 0 d'entiers non négatifs heures de longueur n et un entier non négatif target. Renvoyez l'entier représentant le nombre d'employés qui ont travaillé au moins target heures.

Exemple 1 :

Entrée : hours = [0,1,2,3,4], target = 2
Sortie : 3
Explication : L'entreprise veut que chaque employé travaille au moins 2 heures.
- L'employé 0 a travaillé pendant 0 heures et n'a pas atteint l'objectif.
- L'employé 1 a travaillé pendant 1 heures et n'a pas atteint l'objectif.
- L'employé 2 a travaillé pendant 2 heures et a atteint l'objectif.
- L'employé 3 a travaillé pendant 3 heures et a atteint l'objectif.
- L'employé 4 a travaillé pendant 4 heures et a atteint l'objectif.
Il y a 3 employés qui ont atteint l'objectif.

Exemple 2 :

Entrée : hours = [5,1,4,2,2], target = 6
Sortie : 0
Explication : L'entreprise veut que chaque employé travaille au moins 6 heures.
Il y a 0 employé qui a atteint l'objectif.

Contraintes :

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Il y a n employés dans une entreprise, numérotés de 0 à n - 1. Chaque employé i a travaillé pendant heures[i] heures dans l'entreprise. L'entreprise exige que chaque employé travaille pendant au moins target heures. On vous donne un tableau indexé à 0 d'entiers non négatifs heures de longueur n et un entier non négatif target. Retourne l'entier représentant le nombre d'employés qui ont travaillé au moins target heures.

Exemple 1 :

Entrée : hours = [0,1,2,3,4], target = 2
Sortie : 3
Explication : L'entreprise veut que chaque employé travaille au moins 2 heures.
- L'employé 0 a travaillé pendant 0 heures et n'a pas atteint l'objectif.
- L'employé 1 a travaillé pendant 1 heures et n'a pas atteint l'objectif.
- L'employé 2 a travaillé pendant 2 heures et a atteint l'objectif.
- L'employé 3 a travaillé pendant 3 heures et a atteint l'objectif.
- L'employé 4 a travaillé pendant 4 heures et a atteint l'objectif.
Il y a 3 employés qui ont atteint l'objectif.

Exemple 2 :

Entrée : hours = [5,1,4,2,2], target = 6
Sortie : 0
Explication : L'entreprise veut que chaque employé travaille au moins 6 heures.
Il y a 0 employé qui a atteint l'objectif.

Contraintes :

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Il y a n employés dans une entreprise, numérotés de 0 à n - 1. Chaque employé i a travaillé pendant heures[i] heures dans l'entreprise.
L'entreprise exige que chaque employé travaille pendant au moins target heures.
On vous donne un tableau indexé à 0 d'entiers non négatifs heures de longueur n et un entier non négatif target.
Retournez l'entier représentant le nombre d'employés qui ont travaillé au moins target heures.

Exemple 1 :

Entrée : hours = [0,1,2,3,4], target = 2
Sortie : 3
Explication : L'entreprise veut que chaque employé travaille au moins 2 heures.
- L'employé 0 a travaillé pendant 0 heures et n'a pas atteint l'objectif.
- L'employé 1 a travaillé pendant 1 heures et n'a pas atteint l'objectif.
- L'employé 2 a travaillé pendant 2 heures et a atteint l'objectif.
- L'employé 3 a travaillé pendant 3 heures et a atteint l'objectif.
- L'employé 4 a travaillé pendant 4 heures et a atteint l'objectif.
Il y a 3 employés qui ont atteint l'objectif.

Exemple 2 :

Entrée : hours = [5,1,4,2,2], target = 6
Sortie : 0
Explication : L'entreprise veut que chaque employé travaille au moins 6 heures.
Il y a 0 employé qui a atteint l'objectif.

Contraintes :

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5


Étant donné trois chaînes a, b et c, votre tâche est de trouver une chaîne de longueur minimale et qui contient les trois chaînes comme sous-chaînes.
S'il existe plusieurs chaînes de ce type, retournez celle qui est lexicographiquement la plus petite.
Retournez une chaîne indiquant la réponse au problème.
Notes

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.
Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.

Exemple 1:

Entrée : a = "abc", b = "bca", c = "aaa"
Sortie : "aaabca"
Explication : Nous montrons que "aaabca" contient toutes les chaînes données : a = ans[2...4], b = ans[3..5], c = ans[0..2]. Il peut être montré que la longueur de la chaîne résultante serait au moins de 6 et que "aaabca" est la plus petite lexicographiquement.
Exemple 2:

Entrée : a = "ab", b = "ba", c = "aba"
Sortie : "aba"
Explication : Nous montrons que la chaîne "aba" contient toutes les chaînes données : a = ans[0..1], b = ans[1..2], c = ans[0..2]. Puisque la longueur de c est 3, la longueur de la chaîne résultante serait au moins de 3. Il peut être montré que "aba" est la plus petite lexicographiquement.

Contraintes :

1 <= a.length, b.length, c.length <= 100
a, b, c sont constitués uniquement de lettres minuscules anglaises.

Étant donné trois chaînes a, b et c, votre tâche est de trouver une chaîne de longueur minimale qui contient les trois chaînes comme sous-chaînes.
S'il existe plusieurs chaînes de ce type, retournez celle qui est lexicographiquement la plus petite.
Retournez une chaîne indiquant la réponse au problème.

Notes

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.
Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.

Exemple 1:

Entrée : a = "abc", b = "bca", c = "aaa"
Sortie : "aaabca"
Explication : Nous montrons que "aaabca" contient toutes les chaînes données : a = ans[2...4], b = ans[3..5], c = ans[0..2]. Il peut être montré que la longueur de la chaîne résultante serait au moins de 6 et que "aaabca" est la plus petite lexicographiquement.

Exemple 2:

Entrée : a = "ab", b = "ba", c = "aba"
Sortie : "aba"
Explication : Nous montrons que la chaîne "aba" contient toutes les chaînes données : a = ans[0..1], b = ans[1..2], c = ans[0..2]. Puisque la longueur de c est 3, la longueur de la chaîne résultante serait au moins de 3. Il peut être montré que "aba" est la plus petite lexicographiquement.

Contraintes :

1 <= a.length, b.length, c.length <= 100
a, b, c sont constitués uniquement de lettres minuscules anglaises.

Compte tenu de trois chaînes a, b et c, votre tâche est de trouver une chaîne qui a la longueur minimale et contient les trois chaînes sous forme de sous-chaînes.
S'il y a plusieurs telles chaînes, retournez la plus petite lexicographiquement.
Renvoie une chaîne indiquant la réponse au problème.
Notes

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.
Une sous-chaîne est une séquence contigu de caractères dans une chaîne.

Exemple 1:

Entrée: a = "abc", b = "bca", c = "aaa"
Sortie: "aaabca"
Explication: Nous montrons que  "aaabca" contient toutes les chaînes données: a = ans [2 ... 4], b = ans [3..5], C = ans [0..2]. On peut montrer que la longueur de la chaîne résultante serait au moins 6 et "aaabca"  est la plus petite lexicographique.
Exemple 2:

Entrée: a = "ab", b = "ba", c = "aba"
Sortie: "aba"
Explication: Nous montrons que la chaîne "aba" contient toutes les chaînes données: a = ans [0..1], b = ans [1..2], C = ans [0..2]. Étant donné que la longueur de C est de 3, la longueur de la chaîne résultante serait d'au moins 3. On peut montrer que "aba" est lexicographiquement.

Contraintes:

1 <= a.length, b.length, c.length <= 100
a, b, c se compose uniquement de lettres anglaises minuscules.


On vous donne un tableau d'entiers indexés 0 nums et un entier positif k.
Vous pouvez appliquer l'opération suivante sur le tableau autant de fois que vous le souhaitez :

Choisissez un sous-tableau de taille k dans le tableau et diminuez tous ses éléments de 1.

Renvoyez true si vous pouvez rendre tous les éléments du tableau égaux à 0, ou false dans le cas contraire.
Un sous-tableau est une partie contiguë non vide d'un tableau.

Exemple 1 :

Entrée : nums = [2,2,3,1,1,0], k = 3
Sortie : true
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisissez le sous-tableau [2,2,3]. Le tableau résultant sera nums = [1,1,2,1,1,0].
- Choisissez le sous-tableau [2,1,1]. Le tableau résultant sera nums = [1,1,1,0,0,0].
- Choisissez le sous-tableau [1,1,1]. Le tableau résultant sera nums = [0,0,0,0,0,0].

Exemple 2 :

Entrée : nums = [1,3,1,1], k = 2
Sortie : false
Explication : Il n'est pas possible de rendre tous les éléments du tableau égaux à 0.

Contraintes :

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

Vous disposez d'un tableau d'entiers nums indexé à partir de 0 et d'un entier positif k.
Vous pouvez effectuer l'opération suivante sur le tableau un nombre quelconque de fois :

Choisissez n'importe quelle sous-tableau de taille k du tableau et diminuez tous ses éléments de 1.

Retournez true si vous pouvez rendre tous les éléments du tableau égaux à 0, false sinon.
Une sous-tableau est une partie contiguë non vide d'un tableau.

Exemple 1 :

Entrée : nums = [2,2,3,1,1,0], k = 3
Sortie : true
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisissez la sous-tableau [2,2,3]. Le tableau résultant sera nums = [1,1,2,1,1,0].
- Choisissez la sous-tableau [2,1,1]. Le tableau résultant sera nums = [1,1,1,0,0,0].
- Choisissez la sous-tableau [1,1,1]. Le tableau résultant sera nums = [0,0,0,0,0,0].

Exemple 2 :

Entrée : nums = [1,3,1,1], k = 2
Sortie : false
Explication : Il n'est pas possible de rendre tous les éléments du tableau égaux à 0.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0 et d'un entier positif k.
Vous pouvez appliquer l'opération suivante sur le tableau un nombre quelconque de fois :

Choisissez n'importe quelle sous-tableau de taille k du tableau et diminuez tous ses éléments de 1.

Renvoyez true si vous pouvez rendre tous les éléments du tableau égaux à 0, ou false sinon.
Une sous-tableau est une partie contiguë non vide d'un tableau.

Exemple 1 :

Input: nums = [2,2,3,1,1,0], k = 3
Output: true
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisissez la sous-tableau [2,2,3]. Le tableau résultant sera nums = [1,1,2,1,1,0].
- Choisissez la sous-tableau [2,1,1]. Le tableau résultant sera nums = [1,1,1,0,0,0].
- Choisissez la sous-tableau [1,1,1]. Le tableau résultant sera nums = [0,0,0,0,0,0].

Exemple 2 :

Input: nums = [1,3,1,1], k = 2
Output: false
Explication : Il n'est pas possible de rendre tous les éléments du tableau égaux à 0.

Contraintes :

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


Étant donné une chaîne de caractères s et un entier k, divisez s en k sous-chaînes de manière à minimiser la somme des changements de lettres nécessaires pour que chaque sous-chaîne devienne un semi-palindrome.
Retournez un entier représentant le nombre minimum de changements de lettres requis.
Notes

Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.
Une chaîne de caractères de longueur len est considérée comme un semi-palindrome s'il existe un entier positif d tel que 1 <= d < len et len % d == 0, et si nous prenons les indices ayant le même modulo par d, ils forment un palindrome. Par exemple, "aa", "aba", "adbgad" et "abab" sont des semi-palindromes et "a", "ab" et "abca" ne le sont pas.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "abcac", k = 2
Sortie : 1
Explication : Nous pouvons diviser s en sous-chaînes "ab" et "cac". La chaîne "cac" est déjà un semi-palindrome. Si nous changeons "ab" en "aa", elle devient un semi-palindrome avec d = 1.
Il peut être démontré qu'il n'y a aucun moyen de diviser la chaîne "abcac" en deux sous-chaînes semi-palindromes. Par conséquent, la réponse serait au moins 1.
Exemple 2 :

Entrée : s = "abcdef", k = 2
Sortie : 2
Explication : Nous pouvons la diviser en sous-chaînes "abc" et "def". Chacune des sous-chaînes "abc" et "def" nécessite un changement pour devenir un semi-palindrome, donc nous avons besoin de 2 changements au total pour que toutes les sous-chaînes soient des semi-palindromes.
Il peut être démontré que nous ne pouvons pas diviser la chaîne donnée en deux sous-chaînes d'une manière qui nécessiterait moins de 2 changements.
Exemple 3 :

Entrée : s = "aabbaa", k = 3
Sortie : 0
Explication : Nous pouvons la diviser en sous-chaînes "aa", "bb" et "aa".
Les chaînes "aa" et "bb" sont déjà des semi-palindromes. Ainsi, la réponse est zéro.

Contraintes :

2 <= s.length <= 200
1 <= k <= s.length / 2
s se compose uniquement de lettres minuscules anglaises.

Étant donné une chaîne de caractères s et un entier k, divisez s en k sous-chaînes de manière à minimiser la somme des changements de lettres nécessaires pour transformer chaque sous-chaîne en un semi-palindrome.
Retournez un entier représentant le nombre minimum de changements de lettres requis.
Remarques

Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.
Une chaîne de caractères de longueur len est considérée comme un semi-palindrome s'il existe un entier positif d tel que 1 <= d < len et len % d == 0, et si nous prenons les indices ayant le même modulo par d, ils forment un palindrome. Par exemple, "aa", "aba", "adbgad" et "abab" sont des semi-palindromes et "a", "ab" et "abca" ne le sont pas.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "abcac", k = 2
Sortie : 1
Explication : Nous pouvons diviser s en sous-chaînes "ab" et "cac". La chaîne "cac" est déjà un semi-palindrome. Si nous changeons "ab" en "aa", elle devient un semi-palindrome avec d = 1.
Il peut être démontré qu'il n'y a aucun moyen de diviser la chaîne "abcac" en deux sous-chaînes semi-palindromes. Par conséquent, la réponse serait au moins 1.
Exemple 2 :

Entrée : s = "abcdef", k = 2
Sortie : 2
Explication : Nous pouvons la diviser en sous-chaînes "abc" et "def". Chacune des sous-chaînes "abc" et "def" nécessite un changement pour devenir un semi-palindrome, donc nous avons besoin de 2 changements au total pour que toutes les sous-chaînes soient des semi-palindromes.
Il peut être démontré que nous ne pouvons pas diviser la chaîne donnée en deux sous-chaînes d'une manière qui nécessiterait moins de 2 changements.
Exemple 3 :

Entrée : s = "aabbaa", k = 3
Sortie : 0
Explication : Nous pouvons la diviser en sous-chaînes "aa", "bb" et "aa".
Les chaînes "aa" et "bb" sont déjà des semi-palindromes. Ainsi, la réponse est zéro.

Contraintes :

2 <= s.length <= 200
1 <= k <= s.length / 2
s se compose uniquement de lettres minuscules anglaises.

Étant donné une chaîne de caractères s et un entier k, divisez s en k sous-chaînes de manière à minimiser la somme des changements de lettres nécessaires pour que chaque sous-chaîne devienne un semi-palindrome.
Renvoyez un entier représentant le nombre minimum de changements de lettres requis.
Remarques

Une chaîne de caractères est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.
Une chaîne de caractères de longueur len est considérée comme un semi-palindrome s'il existe un entier positif d tel que 1 <= d < len et len % d == 0, et si nous prenons les indices ayant le même modulo par d, ils forment un palindrome. Par exemple, "aa", "aba", "adbgad" et "abab" sont des semi-palindromes et "a", "ab" et "abca" ne le sont pas.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "abcac", k = 2
Sortie : 1
Explication : Nous pouvons diviser s en sous-chaînes "ab" et "cac". La chaîne "cac" est déjà un semi-palindrome. Si nous changeons "ab" en "aa", elle devient un semi-palindrome avec d = 1.
Il peut être démontré qu'il n'y a aucun moyen de diviser la chaîne "abcac" en deux sous-chaînes semi-palindromes. Par conséquent, la réponse serait au moins 1.
Exemple 2 :

Entrée : s = "abcdef", k = 2
Sortie : 2
Explication : Nous pouvons la diviser en sous-chaînes "abc" et "def". Chacune des sous-chaînes "abc" et "def" nécessite un changement pour devenir un semi-palindrome, donc nous avons besoin de 2 changements au total pour que toutes les sous-chaînes soient des semi-palindromes.
Il peut être démontré que nous ne pouvons pas diviser la chaîne donnée en deux sous-chaînes d'une manière qui nécessiterait moins de 2 changements.
Exemple 3 :

Entrée : s = "aabbaa", k = 3
Sortie : 0
Explication : Nous pouvons la diviser en sous-chaînes "aa", "bb" et "aa".
Les chaînes "aa" et "bb" sont déjà des semi-palindromes. Ainsi, la réponse est zéro.

Contraintes :

2 <= s.length <= 200
1 <= k <= s.length / 2
s se compose uniquement de lettres minuscules anglaises.


Étant donné un tableau de chaînes de caractères words et un caractère separator, divisez chaque chaîne de words par separator.
Retournez un tableau de chaînes contenant les nouvelles chaînes formées après les divisions, en excluant les chaînes vides.
Remarques

separator est utilisé pour déterminer où la division doit se produire, mais il n'est pas inclus dans les chaînes résultantes.
Une division peut donner lieu à plus de deux chaînes.
Les chaînes résultantes doivent conserver le même ordre qu'elles avaient initialement.

Exemple 1:

Entrée : words = ["one.two.three","four.five","six"], separator = "."
Sortie : ["one","two","three","four","five","six"]
Explication: Dans cet exemple, nous divisons comme suit:

"one.two.three" se divise en "one", "two", "three"
"four.five" se divise en "four", "five"
"six" se divise en "six"

Ainsi, le tableau résultant est ["one","two","three","four","five","six"].
Exemple 2:

Entrée : words = ["$easy$","$problem$"], separator = "$"
Sortie : ["easy","problem"]
Explication: Dans cet exemple, nous divisons comme suit:

"$easy$" se divise en "easy" (en excluant les chaînes vides)
"$problem$" se divise en "problem" (en excluant les chaînes vides)

Ainsi, le tableau résultant est ["easy","problem"].

Exemple 3:

Entrée : words = ["|||"], separator = "|"
Sortie : []
Explication: Dans cet exemple, la division de "|||" ne contiendra que des chaînes vides, donc nous renvoyons un tableau vide [].

Contraintes:

1 <= words.length <= 100
1 <= words[i].length <= 20
les caractères dans words[i] sont soit des lettres minuscules anglaises, soit des caractères de la chaîne ".,|$#@" (excluant les guillemets)
separator est un caractère de la chaîne ".,|$#@" (excluant les guillemets)

Étant donné un tableau de chaînes de mots et un séparateur de caractères, divisez chaque chaîne en mots par séparateur.
Renvoie un tableau de chaînes contenant les nouvelles chaînes formées après les divisions, à l'exclusion des chaînes vides.
Remarques

Le séparateur est utilisé pour déterminer où la division doit se produire, mais il n'est pas inclus dans les chaînes résultantes.
Une division peut donner lieu à plus de deux chaînes.
Les chaînes résultantes doivent conserver le même ordre que celui dans lequel elles ont été initialement données.

Exemple 1 :

Entrée : words = ["one.two.three","four.five","six"], separator = "."
Sortie : ["one","two","three","four","five","six"]
Explication : Dans cet exemple, nous divisons comme suit :

"one.two.three" se divise en "one", "two", "three"
"four.five" se divise en "four", "five"
"six" se divise en "six"

Le tableau résultant est donc ["one","two","three","four","five","six"].
Exemple 2 :

Entrée : mots = ["$easy$","$problem$"], séparateur = "$"
Sortie : ["easy","problem"]
Explication : Dans cet exemple, nous divisons comme suit :

"$easy$" se divise en "easy" (à l'exclusion des chaînes vides)
"$problem$" se divise en "problem" (à l'exclusion des chaînes vides)

Le tableau résultant est donc ["easy","problem"].

Exemple 3 :

Entrée : mots = ["|||"], séparateur = "|"
Sortie : []
Explication : Dans cet exemple, la division résultante de "|||" ne contiendra que des chaînes vides, nous renvoyons donc un tableau vide [].

Contraintes :

1 <= mots.longueur <= 100
1 <= mots[i].longueur <= 20
Les caractères de mots[i] sont soit des lettres minuscules anglaises, soit des caractères de la chaîne ".,|$#@" (à l'exclusion des guillemets)
Le séparateur est un caractère de la chaîne ".,|$#@" (à l'exclusion des guillemets)

Donné un tableau de chaînes de caractères words et un caractère separator, divisez chaque chaîne de words par separator.
Retournez un tableau de chaînes contenant les nouvelles chaînes formées après les divisions, en excluant les chaînes vides.
Remarques

separator est utilisé pour déterminer où la division doit se produire, mais il n'est pas inclus dans les chaînes résultantes.
Une division peut donner lieu à plus de deux chaînes.
Les chaînes résultantes doivent conserver le même ordre qu'elles avaient initialement.

Exemple 1:

Input: words = ["one.two.three","four.five","six"], separator = "."
Output: ["one","two","three","four","five","six"]
Explication: Dans cet exemple, nous divisons comme suit:

"one.two.three" se divise en "one", "two", "three"
"four.five" se divise en "four", "five"
"six" se divise en "six"

Ainsi, le tableau résultant est ["one","two","three","four","five","six"].
Exemple 2:

Input: words = ["$easy$","$problem$"], separator = "$"
Output: ["easy","problem"]
Explication: Dans cet exemple, nous divisons comme suit:

"$easy$" se divise en "easy" (en excluant les chaînes vides)
"$problem$" se divise en "problem" (en excluant les chaînes vides)

Ainsi, le tableau résultant est ["easy","problem"].

Exemple 3:

Input: words = ["|||"], separator = "|"
Output: []
Explication: Dans cet exemple, la division de "|||" ne contiendra que des chaînes vides, donc nous renvoyons un tableau vide [].

Contraintes:

1 <= words.length <= 100
1 <= words[i].length <= 20
les caractères dans words[i] sont soit des lettres minuscules anglaises, soit des caractères de la chaîne ".,|$#@" (excluant les guillemets)
separator est un caractère de la chaîne ".,|$#@" (excluant les guillemets)


Étant donné deux entiers positifs n et x.
Renvoie le nombre de façons dont n peut être exprimé comme la somme de la puissance x d'entiers positifs uniques, en d'autres termes, le nombre d'ensembles d'entiers uniques [n_1, n_2, ..., n_k] où n = n_1^x + n_2^x + ... + n_k^x.
Étant donné que le résultat peut être très grand, renvoie-le modulo 10^9 + 7.
Par exemple, si n = 160 et x = 3, une façon d'exprimer n est n = 2^3 + 3^3 + 5^3.

Exemple 1 :

Entrée : n = 10, x = 2
Sortie : 1
Explication : Nous pouvons exprimer n comme suit : n = 3^2 + 1^2 = 10.
Il peut être démontré que c'est la seule façon d'exprimer 10 comme la somme de la puissance 2 d'entiers uniques.

Exemple 2 :

Entrée : n = 4, x = 1
Sortie : 2
Explication : Nous pouvons exprimer n de la manière suivante :
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Contraintes :

1 <= n <= 300
1 <= x <= 5

Étant donnés deux entiers positifs n et x.
Retournez le nombre de façons dont n peut être exprimé comme la somme de la x^ième puissance d'entiers positifs uniques, en d'autres termes, le nombre d'ensembles d'entiers uniques [n_1, n_2, ..., n_k] où n = n_1^x + n_2^x + ... + n_k^x.
Étant donné que le résultat peut être très grand, retournez-le modulo 10^9 + 7.
Par exemple, si n = 160 et x = 3, une façon d'exprimer n est n = 2^3 + 3^3 + 5^3.

Exemple 1:

Entrée: n = 10, x = 2
Sortie: 1
Explication: Nous pouvons exprimer n comme suit : n = 3^2 + 1^2 = 10.
Il peut être montré que c'est la seule façon d'exprimer 10 comme somme de la 2^ième puissance d'entiers uniques.

Exemple 2:

Entrée: n = 4, x = 1
Sortie: 2
Explication: Nous pouvons exprimer n de la manière suivante :
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Contraintes:

1 <= n <= 300
1 <= x <= 5


Étant donnée une chaîne binaire s, partitionnez la chaîne en une ou plusieurs sous-chaînes de sorte que chaque sous-chaîne soit belle.
Une chaîne est belle si :

Elle ne contient pas de zéros en tête.
C'est la représentation binaire d'un nombre qui est une puissance de 5.

Retournez le nombre minimum de sous-chaînes dans une telle partition. S'il est impossible de partitionner la chaîne s en sous-chaînes belles, retournez -1.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "1011"
Sortie : 2
Explication : Nous pouvons partitionner la chaîne donnée en ["101", "1"].
- La chaîne "101" ne contient pas de zéros en tête et est la représentation binaire de l'entier 5^1 = 5.
- La chaîne "1" ne contient pas de zéros en tête et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 2 est le nombre minimum de sous-chaînes belles dans lesquelles s peut être partitionnée.

Exemple 2 :

Entrée : s = "111"
Sortie : 3
Explication : Nous pouvons partitionner la chaîne donnée en ["1", "1", "1"].
- La chaîne "1" ne contient pas de zéros en tête et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 3 est le nombre minimum de sous-chaînes belles dans lesquelles s peut être partitionnée.

Exemple 3 :

Entrée : s = "0"
Sortie : -1
Explication : Il n'est pas possible de partitionner la chaîne donnée en sous-chaînes belles.

Contraintes :

1 <= s.length <= 15
s[i] est soit '0' soit '1'.

Étant donné une chaîne binaire s, partitionnez la chaîne en une ou plusieurs sous-chaînes de telle sorte que chaque sous-chaîne soit belle.
Une chaîne est belle si :

Elle ne contient pas de zéros non significatifs.
C'est la représentation binaire d'un nombre qui est une puissance de 5.

Renvoie le nombre minimum de sous-chaînes dans cette partition. S'il est impossible de partitionner la chaîne s en sous-chaînes belles, renvoie -1.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "1011"
Sortie : 2
Explication : Nous pouvons partitionner la chaîne donnée en ["101", "1"].
- La chaîne "101" ne contient pas de zéros non significatifs et est la représentation binaire de l'entier 5^1 = 5.
- La chaîne "1" ne contient pas de zéros non significatifs et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 2 est le nombre minimum de belles sous-chaînes dans lesquelles s peut être partitionné.

Exemple 2 :

Entrée : s = "111"
Sortie : 3
Explication : Nous pouvons partitionner la chaîne donnée en ["1", "1", "1"].
- La chaîne "1" ne contient pas de zéros non significatifs et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 3 est le nombre minimum de belles sous-chaînes dans lesquelles s peut être partitionné.

Exemple 3 :

Entrée : s = "0"
Sortie : -1
Explication : Nous ne pouvons pas partitionner la chaîne donnée en belles sous-chaînes.

Contraintes :

1 <= s.length <= 15
s[i] est soit '0' soit '1'.

Étant donné une chaîne binaire s, partitionnez la chaîne en une ou plusieurs sous-chaînes de sorte que chaque sous-chaîne soit belle.
Une chaîne est belle si :

Elle ne contient pas de zéros initiaux.
C'est la représentation binaire d'un nombre qui est une puissance de 5.

Retournez le nombre minimum de sous-chaînes dans une telle partition. S'il est impossible de partitionner la chaîne s en sous-chaînes belles, retournez -1.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "1011"
Sortie : 2
Explication : nous pouvons partitionner la chaîne donnée en ["101", "1"].
- La chaîne "101" ne contient pas de zéros initiaux et est la représentation binaire de l'entier 5^1 = 5.
- La chaîne "1" ne contient pas de zéros initiaux et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 2 est le nombre minimum de sous-chaînes belles dans lesquelles s peut être partitionnée.

Exemple 2 :

Entrée : s = "111"
Sortie : 3
Explication : nous pouvons partitionner la chaîne donnée en ["1", "1", "1"].
- La chaîne "1" ne contient pas de zéros initiaux et est la représentation binaire de l'entier 5^0 = 1.
On peut montrer que 3 est le nombre minimum de sous-chaînes belles dans lesquelles s peut être partitionnée.

Exemple 3 :

Entrée : s = "0"
Sortie : -1
Explication : Il n'est pas possible de partitionner la chaîne donnée en sous-chaînes belles.

Contraintes :

1 <= s.length <= 15
s[i] est soit '0' soit '1'.


Vous avez une chaîne de caractères `word` et un tableau de chaînes `forbidden`.
Une chaîne est appelée valide si aucune de ses sous-chaînes n'est présente dans `forbidden`.
Retournez la longueur de la plus longue sous-chaîne valide de la chaîne `word`.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne, éventuellement vide.

Exemple 1 :

Entrée : word = "cbaaaabc", forbidden = ["aaa","cb"]
Sortie : 4
Explication : Il y a 11 sous-chaînes valides dans `word`: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" et "aabc". La longueur de la plus longue sous-chaîne valide est de 4.
On peut montrer que toutes les autres sous-chaînes contiennent soit "aaa" soit "cb" comme sous-chaîne.
Exemple 2 :

Entrée : word = "leetcode", forbidden = ["de","le","e"]
Sortie : 4
Explication : Il y a 11 sous-chaînes valides dans `word`: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" et "tcod". La longueur de la plus longue sous-chaîne valide est de 4.
On peut montrer que toutes les autres sous-chaînes contiennent soit "de", "le" ou "e" comme sous-chaîne.

Contraintes :

1 <= word.length <= 10^5
`word` consiste uniquement en des lettres minuscules anglaises.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
`forbidden[i]` consiste uniquement en des lettres minuscules anglaises.

On vous donne un mot à cordes et un tableau de chaînes interdites.
Une chaîne est appelée valide si aucune de ses sous-chaînes n'est présente dans forbidden.
Renvoyez la longueur de la sous-chaîne valide la plus longue du mot de chaîne.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne, peut-être vide.

Exemple 1:

Entrée: word = "cbaaaabc", forbidden = ["aaa", "cb"]
Sortie: 4
Explication:Il y a 11 sous-chaînes valides dans word : "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" et "aabc".
 La longueur de la plus longue sous-chaîne valide est de 4.
On peut montrer que toutes les autres sous-chaînes contiennent soit "aaa" ou "cb" en tant que sous-chaîne.
Exemple 2:

Entrée: word = "leetcode", forbidden = ["de","le","e"]
Sortie: 4
Explication: Il y a 11 sous-chaînes valides dans word:"l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", et "tcod".  La longueur de la sous-chaîne valide la plus longue est de 4.
On peut montrer que toutes les autres sous-chaînes contiennent "de", "le", or "e" en tant que sous-chaîne.

Contraintes:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] se compose uniquement de lettres anglaises minuscules.


Votre clavier d'ordinateur portable est défectueux, et chaque fois que vous tapez un caractère 'i', il inverse la chaîne que vous avez écrite. Taper d'autres caractères fonctionne comme prévu.
On vous donne une chaîne s indexée à 0, et vous tapez chaque caractère de s en utilisant votre clavier défectueux.
Retournez la chaîne finale qui sera présente sur l'écran de votre ordinateur portable.

Exemple 1 :

Entrée : s = "string"
Sortie : "rtsng"
Explication :
Après avoir tapé le premier caractère, le texte à l'écran est "s".
Après le deuxième caractère, le texte est "st".
Après le troisième caractère, le texte est "str".
Puisque le quatrième caractère est un 'i', le texte est inversé et devient "rts".
Après le cinquième caractère, le texte est "rtsn".
Après le sixième caractère, le texte est "rtsng".
Par conséquent, nous obtenons "rtsng".

Exemple 2 :

Entrée : s = "poiinter"
Sortie : "ponter"
Explication :
Après le premier caractère, le texte à l'écran est "p".
Après le deuxième caractère, le texte est "po".
Puisque le troisième caractère que vous tapez est un 'i', le texte est inversé et devient "op".
Puisque le quatrième caractère que vous tapez est un 'i', le texte est inversé et devient "po".
Après le cinquième caractère, le texte est "pon".
Après le sixième caractère, le texte est "pont".
Après le septième caractère, le texte est "ponte".
Après le huitième caractère, le texte est "ponter".
Par conséquent, nous obtenons "ponter".

Contraintes :

1 <= s.length <= 100
s se compose de lettres minuscules anglaises.
s[0] != 'i'

Votre clavier d'ordinateur portable est défectueux, et chaque fois que vous tapez un caractère 'i', il inverse la chaîne que vous avez écrite. Taper d'autres caractères fonctionne comme prévu.
On vous donne une chaîne s indexée à 0, et vous tapez chaque caractère de s en utilisant votre clavier défectueux.
Retournez la chaîne finale qui sera présente sur l'écran de votre ordinateur portable.

Exemple 1:

Entrée: s = "string"
Sortie: "rtsng"
Explication:
Après avoir tapé le premier caractère, le texte à l'écran est "s".
Après le deuxième caractère, le texte est "st".
Après le troisième caractère, le texte est "str".
Puisque le quatrième caractère est un 'i', le texte est inversé et devient "rts".
Après le cinquième caractère, le texte est "rtsn".
Après le sixième caractère, le texte est "rtsng".
Par conséquent, nous renvoyons "rtsng".

Exemple 2:

Entrée: s = "poiinter"
Sortie: "ponter"
Explication:
Après le premier caractère, le texte à l'écran est "p".
Après le deuxième caractère, le texte est "po".
Puisque le troisième caractère que vous tapez est un 'i', le texte est inversé et devient "op".
Puisque le quatrième caractère que vous tapez est un 'i', le texte est inversé et devient "po".
Après le cinquième caractère, le texte est "pon".
Après le sixième caractère, le texte est "pont".
Après le septième caractère, le texte est "ponte".
Après le huitième caractère, le texte est "ponter".
Par conséquent, nous renvoyons "ponter".

Contraintes:

1 <= s.length <= 100
s consiste en lettres minuscules anglaises.
s[0] != 'i'

Le clavier de votre ordinateur portable est défectueux et, chaque fois que vous tapez un caractère « i » dessus, il inverse la chaîne que vous avez écrite. La saisie d’autres caractères fonctionne comme prévu.
On vous donne une chaîne s indexée 0, et vous tapez chaque caractère de s à l’aide de votre clavier défectueux.
Retournez la dernière chaîne qui sera présente sur l’écran de votre ordinateur portable.

Exemple 1 :

Entrée : s = "string"
Sortie : "rtsng"
Explication :
Après avoir tapé le premier caractère, le texte à l'écran est "s".
Après le deuxième caractère, le texte est "st".
Après le troisième caractère, le texte est "str".
Puisque le quatrième caractère est un 'i', le texte est inversé et devient "rts".
Après le cinquième caractère, le texte est "rtsn".
Après le sixième caractère, le texte est "rtsng".
Par conséquent, nous renvoyons "rtsng".

Exemple 2 :

Entrée : s = "poiinter"
Sortie : "ponter"
Explication :
Après le premier caractère, le texte à l'écran est "p".
Après le deuxième caractère, le texte est "po".
Puisque le troisième caractère que vous tapez est un 'i', le texte est inversé et devient "op".
Puisque le quatrième caractère que vous tapez est un 'i', le texte est inversé et devient "po".
Après le cinquième caractère, le texte est "pon".
Après le sixième caractère, le texte est "pont".
Après le septième caractère, le texte est "ponte".
Après le huitième caractère, le texte est "ponter".
Par conséquent, nous renvoyons "ponter".

Contraintes:

1 <= s.length <= 100
s consiste en lettres minuscules anglaises.
s[0] != 'i'


Étant donné une chaîne de caractères s indexée par 0, permutez s pour obtenir une nouvelle chaîne de caractères t telle que :

Toutes les consonnes restent à leur place d'origine. Plus formellement, s'il existe un indice i avec 0 <= i < s.length tel que s[i] est une consonne, alors t[i] = s[i].
Les voyelles doivent être triées dans l'ordre non décroissant de leurs valeurs ASCII. Plus formellement, pour les paires d'indices i, j avec 0 <= i < j < s.length tels que s[i] et s[j] sont des voyelles, alors t[i] ne doit pas avoir une valeur ASCII plus élevée que t[j].

Renvoyez la chaîne de caractères résultante.
Les voyelles sont 'a', 'e', 'i', 'o' et 'u', et elles peuvent apparaître en minuscules ou en majuscules. Les consonnes comprennent toutes les lettres qui ne sont pas des voyelles.

Exemple 1 :

Entrée : s = "lEetcOde"
Sortie : "lEOtcede"
Explication : 'E', 'O' et 'e' sont les voyelles de s ; 'l', 't', 'c' et 'd' sont les consonnes. Les voyelles sont triées en fonction de leur valeur ASCII, et les consonnes restent à la même place.

Exemple 2 :

Entrée : s = "lYmpH"
Sortie : "lYmpH"
Explication : Il n'y a pas de voyelles dans s (tous les caractères de s sont des consonnes), donc nous retournons "lYmpH".

Contraintes :

1 <= s.length <= 10^5
s est composé uniquement de lettres de l'alphabet anglais en majuscules et en minuscules.

Étant donné une chaîne de caractères s indexée à partir de 0, permutez s pour obtenir une nouvelle chaîne t telle que :

Toutes les consonnes restent à leur place d'origine. Plus précisément, s'il existe un indice i avec 0 <= i < s.length telle que s[i] est une consonne, alors t[i] = s[i].
Les voyelles doivent être triées par ordre non décroissant de leurs valeurs ASCII. Plus précisément, pour des paires d'indices i, j avec 0 <= i < j < s.length telles que s[i] et s[j] sont des voyelles, alors t[i] ne doit pas avoir une valeur ASCII supérieure à t[j].

Retournez la chaîne résultante.
Les voyelles sont 'a', 'e', 'i', 'o' et 'u', et elles peuvent apparaître en minuscules ou majuscules. Les consonnes incluent toutes les lettres qui ne sont pas des voyelles.

Exemple 1 :

Input: s = "lEetcOde"
Output : "lEOtcede"
Explication : 'E', 'O' et 'e' sont les voyelles dans s ; 'l', 't', 'c' et 'd' sont toutes des consonnes. Les voyelles sont triées selon leurs valeurs ASCII, et les consonnes restent aux mêmes emplacements.

Exemple 2 :

Input : s = "lYmpH"
Output : "lYmpH"
Explication : Il n'y a pas de voyelles dans s (tous les caractères dans s sont des consonnes), donc nous retournons "lYmpH".

Contraintes :

1 <= s.length <= 10^5
s se compose uniquement de lettres de l'alphabet anglais en majuscules et minuscules.

Étant donné une chaîne de caractères s indexée à partir de 0, permutez s pour obtenir une nouvelle chaîne t telle que :

Toutes les consonnes restent à leur place d'origine. Plus précisément, s'il existe un indice i avec 0 <= i < s.length tel que s[i] est une consonne, alors t[i] = s[i].
Les voyelles doivent être triées par ordre non décroissant de leurs valeurs ASCII. Plus précisément, pour des paires d'indices i, j avec 0 <= i < j < s.length telles que s[i] et s[j] sont des voyelles, alors t[i] ne doit pas avoir une valeur ASCII supérieure à t[j].

Retournez la chaîne résultante.
Les voyelles sont 'a', 'e', 'i', 'o' et 'u', et elles peuvent apparaître en minuscules ou majuscules. Les consonnes incluent toutes les lettres qui ne sont pas des voyelles.

Exemple 1 :

Entrée : s = "lEetcOde"
Sortie : "lEOtcede"
Explication : 'E', 'O' et 'e' sont les voyelles dans `s` ; 'l', 't', 'c' et 'd' sont toutes des consonnes. Les voyelles sont triées selon leurs valeurs ASCII, et les consonnes restent aux mêmes emplacements.

Exemple 2 :

Entrée : s = "lYmpH"
Sortie : "lYmpH"
Explication : Il n'y a pas de voyelles dans s (tous les caractères dans s sont des consonnes), donc nous retournons "lYmpH".

Contraintes :

1 <= s.length <= 10^5
s se compose uniquement de lettres de l'alphabet anglais en majuscules et minuscules.


Un élément x d'un tableau d'entiers arr de longueur m est dominant si freq(x) * 2 > m, où freq(x) est le nombre d'occurrences de x dans arr. Notez que cette définition implique que arr ne peut avoir qu'un seul élément dominant.
On vous donne un tableau d'entiers nums indexé à 0 de longueur n avec un élément dominant.
Vous pouvez diviser nums à un index i en deux tableaux nums[0, ..., i] et nums[i + 1, ..., n - 1], mais la division n'est valide que si :

0 <= i < n - 1
nums[0, ..., i] et nums[i + 1, ..., n - 1] ont le même élément dominant.

Ici, nums[i, ..., j] désigne le sous-tableau de nums commençant à l'index i et se terminant à l'index j, les deux extrémités étant incluses. En particulier, si j < i alors nums[i, ..., j] désigne un sous-tableau vide.
Renvoie l'index minimum d'une division valide. Si aucune division valide n'existe, renvoie -1.

Exemple 1 :

Entrée : nums = [1,2,2,2]
Sortie : 2
Explication : Nous pouvons diviser le tableau à l'index 2 pour obtenir les tableaux [1,2,2] et [2].

Dans le tableau [1,2,2], l'élément 2 est dominant car il apparaît deux fois dans le tableau et 2 * 2 > 3.

Dans le tableau [2], l'élément 2 est dominant car il apparaît une fois dans le tableau et 1 * 2 > 1.
[1,2,2] et [2] ont tous deux le même élément dominant que nums, il s'agit donc d'une division valide.
Il peut être démontré que l'index 2 est l'index minimum d'une division valide.
Exemple 2 :

Entrée : nums = [2,1,3,1,1,1,7,1,2,1]
Sortie : 4
Explication : Nous pouvons diviser le tableau à l'index 4 pour obtenir les tableaux [2,1,3,1,1] et [1,7,1,2,1].
Dans le tableau [2,1,3,1,1], l'élément 1 est dominant car il apparaît trois fois dans le tableau et 3 * 2 > 5.
Dans le tableau [1,7,1,2,1], l'élément 1 est dominant car il apparaît trois fois dans le tableau et 3 * 2 > 5.
[2,1,3,1,1] et [1,7,1,2,1] ont tous deux le même élément dominant que nums, il s'agit donc d'une division valide.
Il peut être démontré que l'index 4 est l'index minimum d'une division valide.
Exemple 3 :

Entrée : nums = [3,3,3,3,7,2,2]
Sortie : -1
Explication : Il peut être démontré qu'il n'existe pas de division valide.

Contraintes :

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums a exactement un élément dominant.

Un élément x d'un tableau d'entiers arr de longueur m est dominant si freq(x) * 2 > m, où freq(x) est le nombre d'occurrences de x dans arr. Notez que cette définition implique que arr peut avoir au plus un élément dominant.
On vous donne un tableau d'entiers nums de longueur n indexé à partir de 0 avec un élément dominant.
Vous pouvez diviser nums à un indice i en deux tableaux nums[0, ..., i] et nums[i + 1, ..., n - 1], mais la division n'est valide que si :

0 <= i < n - 1
nums[0, ..., i], et nums[i + 1, ..., n - 1] ont le même élément dominant.

Ici, nums[i, ..., j] désigne la sous-séquence de nums commençant à l'indice i et se terminant à l'indice j, les deux bornes étant incluses. En particulier, si j < i alors nums[i, ..., j] désigne une sous-séquence vide.
Retournez l'indice minimum d'une division valide. Si aucune division valide n'existe, retournez -1.

Exemple 1 :

Entrée : nums = [1,2,2,2]
Sortie : 2
Explication : Nous pouvons diviser le tableau à l'indice 2 pour obtenir les tableaux [1,2,2] et [2].
Dans le tableau [1,2,2], l'élément 2 est dominant puisqu'il apparaît deux fois dans le tableau et 2 * 2 > 3.
Dans le tableau [2], l'élément 2 est dominant puisqu'il apparaît une fois dans le tableau et 1 * 2 > 1.
Les deux [1,2,2] et [2] ont le même élément dominant que nums, donc c'est une division valide.
Il peut être démontré que l'indice 2 est le minimum indice d'une division valide.
Exemple 2 :

Entrée : nums = [2,1,3,1,1,1,7,1,2,1]
Sortie : 4
Explication : Nous pouvons diviser le tableau à l'indice 4 pour obtenir les tableaux [2,1,3,1,1] et [1,7,1,2,1].
Dans le tableau [2,1,3,1,1], l'élément 1 est dominant puisqu'il apparaît trois fois dans le tableau et 3 * 2 > 5.
Dans le tableau [1,7,1,2,1], l'élément 1 est dominant puisqu'il apparaît trois fois dans le tableau et 3 * 2 > 5.
Les deux [2,1,3,1,1] et [1,7,1,2,1] ont le même élément dominant que nums, donc c'est une division valide.
Il peut être démontré que l'indice 4 est le minimum indice d'une division valide.
Exemple 3 :

Entrée : nums = [3,3,3,3,7,2,2]
Sortie : -1
Explication : Il peut être démontré qu'il n'y a pas de division valide.

Contraintes :

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums a exactement un élément dominant.


Vous disposez d'un tableau nums indexé à partir de 0 et d'un entier non négatif k.
Lors d'une opération, vous pouvez effectuer les actions suivantes :

Choisissez un indice i qui n'a pas été choisi auparavant dans la plage [0, nums.length - 1].
Remplacez nums[i] par n'importe quel entier de la plage [nums[i] - k, nums[i] + k].

La beauté du tableau est la longueur de la plus longue sous-séquence composée d'éléments égaux.
Retournez la beauté maximale possible du tableau nums après avoir appliqué l'opération un nombre quelconque de fois.
Notez que vous pouvez appliquer l'opération une seule fois à chaque indice.
Une sous-séquence d'un tableau est un nouveau tableau généré à partir du tableau original en supprimant certains éléments (éventuellement aucun) sans modifier l'ordre des éléments restants.

Exemple 1:

Entrée : nums = [4,6,1,2], k = 2
Sortie : 3
Explication : Dans cet exemple, nous appliquons les opérations suivantes :
- Choisir l'indice 1, le remplacer par 4 (de la plage [4,8]), nums = [4,4,1,2].
- Choisir l'indice 3, le remplacer par 4 (de la plage [0,4]), nums = [4,4,1,4].
Après les opérations appliquées, la beauté du tableau nums est 3 (sous-séquence composée des indices 0, 1 et 3).
Il peut être prouvé que 3 est la longueur maximale possible que nous pouvons atteindre.

Exemple 2:

Entrée : nums = [1,1,1,1], k = 10
Sortie : 4
Explication : Dans cet exemple, nous n'avons pas besoin d'effectuer d'opérations.
La beauté du tableau nums est 4 (tableau entier).

Contraintes :

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

On vous donne un tableau indexé 0 nums et un entier non négatif k.
En une seule opération, vous pouvez effectuer les opérations suivantes :

Choisissez un index i qui n'a pas été choisi auparavant dans la plage [0, nums.length - 1].
Remplacez nums[i] par n'importe quel entier de la plage [nums[i] - k, nums[i] + k].

La beauté du tableau est la longueur de la plus longue sous-séquence composée d'éléments égaux.
Renvoie la beauté maximale possible du tableau nums après avoir appliqué l'opération un nombre quelconque de fois.
Notez que vous ne pouvez appliquer l'opération à chaque index qu'une seule fois.
Une sous-séquence d'un tableau est un nouveau tableau généré à partir du tableau d'origine en supprimant certains éléments (éventuellement aucun) sans modifier l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [4,6,1,2], k = 2
Sortie : 3
Explication : Dans cet exemple, nous appliquons les opérations suivantes :
- Choisissez l'index 1, remplacez-le par 4 (de la plage [4,8]), nums = [4,4,1,2].
- Choisissez l'index 3, remplacez-le par 4 (de la plage [0,4]), nums = [4,4,1,4].
Après les opérations appliquées, la beauté du tableau nums est 3 (sous-séquence composée des indices 0, 1 et 3).
Il peut être prouvé que 3 est la longueur maximale possible que nous pouvons atteindre.

Exemple 2 :

Entrée : nums = [1,1,1,1], k = 10
Sortie : 4
Explication : Dans cet exemple, nous n'avons pas besoin d'appliquer d'opérations.
La beauté du tableau nums est 4 (tableau entier).

Contraintes :

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

Vous disposez d'un tableau indexé à partir de 0, nums, et d'un entier non négatif k.
Lors d'une opération, vous pouvez effectuer les actions suivantes :

Choisissez un indice i qui n'a pas été choisi auparavant dans la plage [0, nums.length - 1].
Remplacez nums[i] par n'importe quel entier de la plage [nums[i] - k, nums[i] + k].

La beauté du tableau est la longueur de la plus longue sous-séquence composée d'éléments égaux.
Retournez la beauté maximale possible du tableau nums après avoir appliqué l'opération un nombre quelconque de fois.
Notez que vous pouvez appliquer l'opération à chaque indice une seule fois.
Une sous-séquence d'un tableau est un nouveau tableau généré à partir du tableau original en supprimant certains éléments (éventuellement aucun) sans modifier l'ordre des éléments restants.

Exemple 1:

Entrée : nums = [4,6,1,2], k = 2
Sortie : 3
Explication : dans cet exemple, nous appliquons les opérations suivantes :
- Choisir l'indice 1, le remplacer par 4 (de la plage [4,8]), nums = [4,4,1,2].
- Choisir l'indice 3, le remplacer par 4 (de la plage [0,4]), nums = [4,4,1,4].
Après les opérations appliquées, la beauté du tableau nums est 3 (sous-séquence composée des indices 0, 1 et 3).
Il peut être prouvé que 3 est la longueur maximale possible que nous pouvons atteindre.

Exemple 2:

Entrée : nums = [1,1,1,1], k = 10
Sortie : 4
Explication : dans cet exemple, nous n'avons pas besoin d'appliquer d'opérations.
La beauté du tableau nums est 4 (tableau entier).

Contraintes :

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


Un tableau d'entiers `nums` vous est donné. Nous considérons qu'un tableau est bon s'il est une permutation d'un tableau `base[n]`.
`base[n] = [1, 2, ..., n - 1, n, n]` (en d'autres termes, c'est un tableau de longueur `n + 1` qui contient de 1 à `n - 1` exactement une fois, plus deux occurrences de `n`). Par exemple, `base[1] = [1, 1]` et `base[3] = [1, 2, 3, 3]`.
Renvoyez true si le tableau donné est bon, sinon retournez false.
Note : Une permutation d'entiers représente un arrangement de ces nombres.

Exemple 1 :

Input: nums = [2, 1, 3]
Output: false
Explication : Comme l'élément maximum du tableau est 3, le seul candidat `n` pour lequel ce tableau pourrait être une permutation de `base[n]` est `n = 3`. Cependant, `base[3]` a quatre éléments mais le tableau `nums` en a trois. Par conséquent, il ne peut pas être une permutation de `base[3] = [1, 2, 3, 3]`. Donc, la réponse est false.

Exemple 2 :

Input: nums = [1, 3, 3, 2]
Output: true
Explication : Comme l'élément maximum du tableau est 3, le seul candidat `n` pour lequel ce tableau pourrait être une permutation de `base[n]` est `n = 3`. On peut voir que `nums` est une permutation de `base[3] = [1, 2, 3, 3]` (en échangeant le deuxième et le quatrième éléments dans `nums`, on obtient `base[3]`). Par conséquent, la réponse est true.

Exemple 3 :

Input: nums = [1, 1]
Output: true
Explication : Comme l'élément maximum du tableau est 1, le seul candidat `n` pour lequel ce tableau pourrait être une permutation de `base[n]` est `n = 1`. On peut voir que `nums` est une permutation de `base[1] = [1, 1]`. Par conséquent, la réponse est true.

Exemple 4 :

Input: nums = [3, 4, 4, 1, 2, 1]
Output: false
Explication : Comme l'élément maximum du tableau est 4, le seul candidat `n` pour lequel ce tableau pourrait être une permutation de `base[n]` est `n = 4`. Cependant, `base[4]` a cinq éléments mais le tableau `nums` en a six. Par conséquent, il ne peut pas être une permutation de `base[4] = [1, 2, 3, 4, 4]`. Donc, la réponse est false.

Contraintes :

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

Vous avez un tableau d'entiers. Nous considérons un tableau bon s'il s'agit d'une permutation d'une base de tableau [n].
base [n] = [1, 2, ..., n - 1, n, n] (en d'autres termes, c'est un tableau de longueur n + 1 qui contient 1 à n - 1 exactement une fois, plus deux occurrences de n). Par exemple, la base [1] = [1, 1] et la base [3] = [1, 2, 3, 3].
Renvoyez vrai si le tableau donné est bon, sinon renvoyez false.
Remarque: Une permutation d'entiers représente un arrangement de ces nombres.

Exemple 1:

Entrée: nums = [2, 1, 3]
Sortie: false
Explication: Étant donné que l'élément maximum du tableau est 3, le seul candidat n pour lequel ce tableau pourrait être une permutation de base [n], est n = 3. Cependant, la base [3] a quatre éléments mais les numéros du tableau en ont trois. Par conséquent, il ne peut pas être une permutation de base [3] = [1, 2, 3, 3]. La réponse est donc fausse.

Exemple 2:

Entrée: nums = [1, 3, 3, 2]
Sortie: true
Explication: Étant donné que l'élément maximum du tableau est 3, le seul candidat n pour lequel ce tableau pourrait être une permutation de base [n], est n = 3. On peut voir que nums est une permutation de base [3] = [1, 2, 3, 3] (en échangeant les deuxième et quatrième éléments, nous obtenons base [3]). Par conséquent, la réponse est vraie.
Exemple 3:

Entrée: nums = [1, 1]
Sortie: true
Explication: Étant donné que l'élément maximum du tableau est 1, le seul candidat n pour lequel ce tableau pourrait être une permutation de base [n], est n = 1. On peut voir que Nums est une permutation de base [1] = [1, 1]. Par conséquent, la réponse est vraie.
Exemple 4:

Entrée: nums = [3, 4, 4, 1, 2, 1]
Sortie: false
Explication: Étant donné que l'élément maximum du tableau est de 4, le seul candidat n pour lequel ce tableau pourrait être une permutation de base [n], est n = 4. Cependant, la base [4] a cinq éléments mais les numéros du tableau en ont six. Par conséquent, il ne peut pas être une permutation de base [4] = [1, 2, 3, 4, 4]. La réponse est donc fausse.

Contraintes:

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

On donne un tableau d'entiers nums. Nous considérons qu'un tableau est bon s'il est une permutation d'un tableau base[n].
base[n] = [1, 2, ..., n - 1, n, n] (en d'autres termes, c'est un tableau de longueur n + 1 qui contient 1 à n - 1 exactement une fois, plus deux occurrences de n). Par exemple, base[1] = [1, 1] et base[3] = [1, 2, 3, 3].
Retournez true si le tableau donné est bon, sinon retournez false.
Note : Une permutation d'entiers représente un arrangement de ces nombres.

Exemple 1 :

Entrée : nums = [2, 1, 3]
Sortie : false
Explication : Comme l'élément maximum du tableau est 3, le seul candidat n pour lequel ce tableau pourrait être une permutation de base[n] est n = 3. Cependant, base[3] a quatre éléments mais le tableau nums en a trois. Par conséquent, il ne peut pas être une permutation de base[3] = [1, 2, 3, 3]. Donc, la réponse est false.

Exemple 2 :

Entrée : nums = [1, 3, 3, 2]
Sortie : true
Explication : Comme l'élément maximum du tableau est 3, le seul candidat n pour lequel ce tableau pourrait être une permutation de base[n] est n = 3. On peut voir que nums est une permutation de base[3] = [1, 2, 3, 3] (en échangeant le deuxième et le quatrième éléments dans nums, on obtient base[3]). Par conséquent, la réponse est true.
Exemple 3 :

Entrée : nums = [1, 1]
Sortie : true
Explication : Comme l'élément maximum du tableau est 1, le seul candidat n pour lequel ce tableau pourrait être une permutation de base[n] est n = 1. On peut voir que nums est une permutation de base[1] = [1, 1]. Par conséquent, la réponse est true.
Exemple 4 :

Entrée : nums = [3, 4, 4, 1, 2, 1]
Sortie : false
Explication : Comme l'élément maximum du tableau est 4, le seul candidat n pour lequel ce tableau pourrait être une permutation de base[n] est n = 4. Cependant, base[4] a cinq éléments et le tableau nums en a six. Par conséquent, il ne peut pas être une permutation de base[4] = [1, 2, 3, 4, 4]. Donc, la réponse est false.

Contraintes :

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