Vous disposez de deux tableaux de chaînes de caractères wordsContainer et wordsQuery.
Pour chaque wordsQuery[i], vous devez trouver une chaîne dans wordsContainer qui possède le plus long suffixe commun avec wordsQuery[i]. S'il y a deux ou plusieurs chaînes dans wordsContainer partageant le plus long suffixe commun, trouvez la chaîne la plus courte en longueur. S'il y a deux ou plusieurs chaînes de même longueur, trouvez celle qui apparaît en premier dans wordsContainer.
Renvoyez un tableau d'entiers ans, où ans[i] est l'indice de la chaîne dans wordsContainer ayant le plus long suffixe commun avec wordsQuery[i].

Exemple 1 :

Entrée : wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Sortie : [1,1,1]
Explication :
Examinons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "cd", les chaînes de wordsContainer partageant le plus long suffixe commun "cd" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.
Pour wordsQuery[1] = "bcd", les chaînes de wordsContainer partageant le plus long suffixe commun "bcd" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.
Pour wordsQuery[2] = "xyz", il n'y a pas de chaîne de wordsContainer partageant un suffixe commun. Ainsi le plus long suffixe commun est "", partagé avec les chaînes aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.

Exemple 2 :

Entrée : wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Sortie : [2,0,2]
Explication :
Examinons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "gh", les chaînes de wordsContainer partageant le plus long suffixe commun "gh" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 2 car elle a la plus courte longueur de 6.
Pour wordsQuery[1] = "acbfgh", seule la chaîne à l'indice 0 partage le plus long suffixe commun "fgh". Ainsi, c’est la réponse, même si la chaîne à l'indice 2 est plus courte.
Pour wordsQuery[2] = "acbfegh", les chaînes de wordsContainer partageant le plus long suffixe commun "gh" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 2 car elle a la plus courte longueur de 6.

Contraintes :

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] se compose uniquement de lettres anglaises minuscules.
wordsQuery[i] se compose uniquement de lettres anglaises minuscules.
La somme des longueurs de wordsContainer[i] est au plus de 5 * 10^5.
La somme des longueurs de wordsQuery[i] est au plus de 5 * 10^5.

Vous disposez de deux tableaux de chaînes de caractères wordsContainer et wordsQuery.
Pour chaque wordsQuery[i], vous devez trouver une chaîne dans wordsContainer qui possède le plus long suffixe commun avec wordsQuery[i]. S'il y a deux ou plusieurs chaînes dans wordsContainer partageant le plus long suffixe commun, trouvez la chaîne la plus courte en longueur. S'il y a deux ou plusieurs chaînes de même longueur, trouvez celle qui apparaît en premier dans wordsContainer.
Retournez un tableau d'entiers ans, où ans[i] est l'indice de la chaîne dans wordsContainer ayant le plus long suffixe commun avec wordsQuery[i].

Exemple 1 :

Entrée : wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Sortie : [1,1,1]
Explication :
Examinons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "cd", les chaînes de wordsContainer partageant le plus long suffixe commun "cd" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.
Pour wordsQuery[1] = "bcd", les chaînes de wordsContainer partageant le plus long suffixe commun "bcd" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.
Pour wordsQuery[2] = "xyz", il n'y a pas de chaîne de wordsContainer partageant un suffixe commun. Ainsi le plus long suffixe commun est "", partagé avec les chaînes aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 1 car elle a la plus courte longueur de 3.

Exemple 2 :

Entrée : wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Sortie : [2,0,2]
Explication :
Examinons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "gh", les chaînes de wordsContainer partageant le plus long suffixe commun "gh" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 2 car elle a la plus courte longueur de 6.
Pour wordsQuery[1] = "acbfgh", seule la chaîne à l'indice 0 partage le plus long suffixe commun "fgh". Ainsi, c’est la réponse, même si la chaîne à l'indice 2 est plus courte.
Pour wordsQuery[2] = "acbfegh", les chaînes de wordsContainer partageant le plus long suffixe commun "gh" sont aux indices 0, 1, et 2. Parmi elles, la réponse est la chaîne à l'indice 2 car elle a la plus courte longueur de 6.

Contraintes :

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] se compose uniquement de lettres anglaises minuscules.
wordsQuery[i] se compose uniquement de lettres anglaises minuscules.
La somme des longueurs de wordsContainer[i] est au plus de 5 * 10^5.
La somme des longueurs de wordsQuery[i] est au plus de 5 * 10^5.

Vous disposez de deux tableaux de chaînes wordsContainer et wordsQuery.
Pour chaque wordsQuery[i], vous devez trouver une chaîne de wordsContainer qui a le plus long suffixe commun avec wordsQuery[i]. S'il y a deux ou plusieurs chaînes dans wordsContainer qui partagent le plus long suffixe commun, recherchez la chaîne qui est la plus petite en longueur. S'il y a deux ou plusieurs chaînes de ce type qui ont la même plus petite longueur, recherchez celle qui est apparue plus tôt dans wordsContainer.
Renvoie un tableau d'entiers ans, où ans[i] est l'index de la chaîne dans wordsContainer qui a le plus long suffixe commun avec wordsQuery[i].

Exemple 1 :

Entrée : wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Sortie : [1,1,1]
Explication :
Examinons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "cd", les chaînes de wordsContainer qui partagent le suffixe commun le plus long "cd" sont aux indices 0, 1 et 2. Parmi celles-ci, la réponse est la chaîne à l'indice 1 car elle a la longueur la plus courte de 3.
Pour wordsQuery[1] = "bcd", les chaînes de wordsContainer qui partagent le suffixe commun le plus long "bcd" sont aux indices 0, 1 et 2. Parmi celles-ci, la réponse est la chaîne à l'indice 1 car elle a la longueur la plus courte de 3.
Pour wordsQuery[2] = "xyz", il n'existe aucune chaîne de wordsContainer qui partage un suffixe commun. Par conséquent, le suffixe commun le plus long est "", qui est partagé avec les chaînes d'index 0, 1 et 2. Parmi celles-ci, la réponse est la chaîne d'index 1 car elle a la longueur la plus courte de 3.

Exemple 2 :

Entrée : wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Sortie : [2,0,2]
Explication :
Regardons chaque wordsQuery[i] séparément :

Pour wordsQuery[0] = "gh", les chaînes de wordsContainer qui partagent le suffixe commun le plus long "gh" sont aux indices 0, 1 et 2. Parmi celles-ci, la réponse est la chaîne d'index 2 car elle a la longueur la plus courte de 6.
Pour wordsQuery[1] = "acbfgh", seule la chaîne d'index 0 partage le suffixe commun le plus long "fgh". C'est donc la réponse, même si la chaîne à l'index 2 est plus courte.
Pour wordsQuery[2] = "acbfegh", les chaînes de wordsContainer qui partagent le suffixe commun le plus long "gh" sont aux indices 0, 1 et 2. Parmi celles-ci, la réponse est la chaîne à l'index 2 car elle a la longueur la plus courte de 6.

Contraintes :

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] se compose uniquement de lettres minuscules anglaises.
wordsQuery[i] se compose uniquement de lettres minuscules anglaises.
La somme de wordsContainer[i].length est au plus égale à 5 * 10^5.
La somme de wordsQuery[i].length est au plus égale à 5 * 10^5.


Un entier divisible par la somme de ses chiffres est dit être un nombre Harshad. On vous donne un entier x. Retournez la somme des chiffres de x si x est un nombre Harshad, sinon, retournez -1.

Exemple 1 :

Entrée : x = 18
Sortie : 9
Explication :
La somme des chiffres de x est 9. 18 est divisible par 9. Donc 18 est un nombre Harshad et la réponse est 9.

Exemple 2 :

Entrée : x = 23
Sortie : -1
Explication :
La somme des chiffres de x est 5. 23 n'est pas divisible par 5. Donc 23 n'est pas un nombre Harshad et la réponse est -1.

Contraintes :

1 <= x <= 100

Un entier divisible par la somme de ses chiffres est dit un nombre Harshad. On vous donne un entier x. Renvoie la somme des chiffres de x si x est un nombre Harshad, sinon, renvoie -1.

Exemple 1 :

Entrée : x = 18
Sortie : 9
Explication :
La somme des chiffres de x est 9. 18 est divisible par 9. Donc 18 est un nombre Harshad et la réponse est 9.

Exemple 2 :

Entrée : x = 23
Sortie : -1
Explication :
La somme des chiffres de x est 5. 23 n'est pas divisible par 5. Donc 23 n'est pas un nombre Harshad et la réponse est -1.

Contraintes :

1 <= x <= 100


On vous donne un tableau binaire nums.
Un sous-tableau est dit alternatif si aucun des deux éléments adjacents dans le sous-tableau n'a la même valeur.
Retournez le nombre de sous-tableaux alternatifs dans nums.

Exemple 1 :

Entrée : nums = [0,1,1,1]
Sortie : 5
Explication :
Les sous-tableaux suivants sont alternatifs : [0], [1], [1], [1], et [0,1].

Exemple 2 :

Entrée : nums = [1,0,1,0]
Sortie : 10
Explication :
Chaque sous-tableau du tableau est alternatif. Il y a 10 sous-tableaux possibles que nous pouvons choisir.

Contraintes :

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

On vous donne un tableau binaire nums.
Nous appelons un sous-tableau alternatif si aucun des deux éléments adjacents dans le sous-tableau n'a la même valeur.
Renvoyez le nombre de sous-tableaux alternatifs dans nums.

Exemple 1 :

Entrée : nums = [0,1,1,1]
Sortie : 5
Explication :
Les sous-tableaux suivants sont alternatifs : [0], [1], [1], [1], et [0,1].

Exemple 2 :

Entrée : nums = [1,0,1,0]
Sortie : 10
Explication :
Chaque sous-tableau du tableau est alternatif. Il y a 10 sous-tableaux possibles que nous pouvons choisir.

Contraintes :

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

On vous donne un tableau binaire nums.
Nous disons qu'un sous-tableau est alterné si aucun élément adjacent du sous-tableau n'a la même valeur.
Renvoie le nombre de sous-tableaux alternés dans nums.

Exemple 1 :

Entrée : nums = [0,1,1,1]
Sortie : 5
Explication :
Les sous-tableaux suivants sont alternés : [0], [1], [1], [1] et [0,1].

Exemple 2 :

Entrée : nums = [1,0,1,0]
Sortie : 10
Explication :
Chaque sous-tableau du tableau est alterné. Il y a 10 sous-tableaux possibles parmi lesquels nous pouvons choisir.

Contraintes :

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


On vous donne un tableau points représentant les coordonnées entières de certains points sur un plan 2D, où points[i] = [x_i, y_i].
La distance entre deux points est définie comme leur distance de Manhattan.
Retournez la valeur minimale possible pour la distance maximale entre deux points quelconques en supprimant exactement un point.

Exemple 1 :

Entrée : points = [[3,10],[5,15],[10,2],[4,4]]
Sortie : 12
Explication :
La distance maximale après avoir supprimé chaque point est la suivante :

Après avoir supprimé le 0^e point, la distance maximale est entre les points (5, 15) et (10, 2), ce qui donne |5 - 10| + |15 - 2| = 18.
Après avoir supprimé le 1^e point, la distance maximale est entre les points (3, 10) et (10, 2), ce qui donne |3 - 10| + |10 - 2| = 15.
Après avoir supprimé le 2^e point, la distance maximale est entre les points (5, 15) et (4, 4), ce qui donne |5 - 4| + |15 - 4| = 12.
Après avoir supprimé le 3^e point, la distance maximale est entre les points (5, 15) et (10, 2), ce qui donne |5 - 10| + |15 - 2| = 18.

12 est la distance maximale minimale possible entre deux points après avoir supprimé exactement un point.

Exemple 2 :

Entrée : points = [[1,1],[1,1],[1,1]]
Sortie : 0
Explication :
Supprimer n'importe lequel des points résulte en une distance maximale de 0 entre deux points quelconques.

Contraintes :

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

On vous donne un tableau de points représentant les coordonnées entières de certains points sur un plan 2D, où points[i] = [x_i, y_i].
La distance entre deux points est définie comme leur distance de Manhattan.
Renvoie la valeur minimale possible pour la distance maximale entre deux points quelconques en supprimant exactement un point.

Exemple 1 :

Entrée : points = [[3,10],[5,15],[10,2],[4,4]]
Sortie : 12
Explication :
La distance maximale après la suppression de chaque point est la suivante :

Après avoir supprimé le 0^e point, la distance maximale est entre les points (5, 15) et (10, 2), qui est |5 - 10| + |15 - 2| = 18.
Après avoir supprimé le 1^er point, la distance maximale est entre les points (3, 10) et (10, 2), qui est |3 - 10| + |10 - 2| = 15.
Après avoir supprimé le 2e point, la distance maximale entre les points (5, 15) et (4, 4) est de |5 - 4| + |15 - 4| = 12.
Après avoir supprimé le 3e point, la distance maximale entre les points (5, 15) et (10, 2) est de |5 - 10| + |15 - 2| = 18.

12 est la distance maximale minimale possible entre deux points après avoir supprimé exactement un point.

Exemple 2 :

Entrée : points = [[1,1],[1,1],[1,1]]
Sortie : 0
Explication :
La suppression de l'un des points entraîne une distance maximale de 0 entre deux points.

Contraintes :

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8


Vous avez un tableau d'entiers nums. Retournez la longueur du plus long sous-tableau de nums qui est soit strictement croissant, soit strictement décroissant.

Exemple 1 :

Input: nums = [1,4,3,3,2]
Output: 2
Explication :
Les sous-tableaux strictement croissants de nums sont [1], [2], [3], [3], [4], et [1,4].
Les sous-tableaux strictement décroissants de nums sont [1], [2], [3], [3], [4], [3,2], et [4,3].
Par conséquent, nous retournons 2.

Exemple 2 :

Input: nums = [3,3,3,3]
Output: 1
Explication :
Les sous-tableaux strictement croissants de nums sont [3], [3], [3], et [3].
Les sous-tableaux strictement décroissants de nums sont [3], [3], [3], et [3].
Par conséquent, nous retournons 1.

Exemple 3 :

Input: nums = [3,2,1]
Output: 3
Explication :
Les sous-tableaux strictement croissants de nums sont [3], [2], et [1].
Les sous-tableaux strictement décroissants de nums sont [3], [2], [1], [3,2], [2,1], et [3,2,1].
Par conséquent, nous retournons 3.

Contraintes :

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

On vous donne un tableau d'entiers nums. Renvoie la longueur du plus long sous-tableau de nums qui est soit strictement croissant, soit strictement décroissant.

Exemple 1 :

Entrée : nums = [1,4,3,3,2]
Sortie : 2
Explication :
Les sous-tableaux strictement croissants de nums sont [1], [2], [3], [3], [4] et [1,4].
Les sous-tableaux strictement décroissants de nums sont [1], [2], [3], [3], [4], [3,2] et [4,3].
Nous renvoyons donc 2.

Exemple 2 :

Entrée : nums = [3,3,3,3]
Sortie : 1
Explication :
Les sous-tableaux strictement croissants de nums sont [3], [3], [3] et [3].
Les sous-tableaux strictement décroissants de nums sont [3], [3], [3] et [3].
Nous renvoyons donc 1.

Exemple 3 :

Entrée : nums = [3,2,1]
Sortie : 3
Explication :
Les sous-tableaux strictement croissants de nums sont [3], [2] et [1].
Les sous-tableaux strictement décroissants de nums sont [3], [2], [1], [3,2], [2,1] et [3,2,1].
Nous renvoyons donc 3.

Contraintes :

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

Vous avez un tableau d'entiers `nums`. Retournez la longueur du sous-tableau le plus long de `nums` qui est soit strictement croissant, soit strictement décroissant.

Exemple 1 :

Input: nums = [1,4,3,3,2]
Output: 2
Explication :
Les sous-tableaux strictement croissants de `nums` sont [1], [2], [3], [3], [4], et [1,4].
Les sous-tableaux strictement décroissants de `nums` sont [1], [2], [3], [3], [4], [3,2], et [4,3].
Par conséquent, nous retournons 2.

Exemple 2 :

Input: nums = [3,3,3,3]
Output: 1
Explication :
Les sous-tableaux strictement croissants de `nums` sont [3], [3], [3], et [3].
Les sous-tableaux strictement décroissants de `nums` sont [3], [3], [3], et [3].
Par conséquent, nous retournons 1.

Exemple 3 :

Input: nums = [3,2,1]
Output: 3
Explication :
Les sous-tableaux strictement croissants de `nums` sont [3], [2], et [1].
Les sous-tableaux strictement décroissants de `nums` sont [3], [2], [1], [3,2], [2,1], et [3,2,1].
Par conséquent, nous retournons 3.

Contraintes :

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


On vous donne une chaîne de caractères s et un entier k.
Définissez une fonction distance(s_1, s_2) entre deux chaînes s_1 et s_2 de même longueur n comme :

La somme de la distance minimale entre s_1[i] et s_2[i] lorsque les caractères de 'a' à 'z' sont arrangés de manière cyclique, pour tout i dans la plage [0, n - 1].

Par exemple, distance("ab", "cd") == 4, et distance("a", "z") == 1.
Vous pouvez changer n'importe quelle lettre de s en n'importe quelle autre lettre minuscule anglaise, autant de fois que vous le souhaitez.
Retournez une chaîne décrivant la chaîne t lexicographiquement la plus petite que vous pouvez obtenir après quelques changements, telle que distance(s, t) <= k.

Exemple 1 :

Entrée : s = "zbbz", k = 3
Sortie : "aaaz"
Explication :
Changez s en "aaaz". La distance entre "zbbz" et "aaaz" est égale à k = 3.

Exemple 2 :

Entrée : s = "xaxcd", k = 4
Sortie : "aawcd"
Explication :
La distance entre "xaxcd" et "aawcd" est égale à k = 4.

Exemple 3 :

Entrée : s = "lol", k = 0
Sortie : "lol"
Explication :
Il est impossible de changer un caractère car k = 0.

Contraintes :

1 <= s.length <= 100
0 <= k <= 2000
s est constitué uniquement de lettres minuscules anglaises.

On vous donne une chaîne s et un entier k.
Définissez une fonction distance(s_1, s_2) entre deux chaînes s_1 et s_2 de même longueur n comme :

La somme de la distance minimale entre s_1[i] et s_2[i] lorsque les caractères de 'a' à 'z' sont placés dans un ordre cyclique, pour tous les i dans la plage [0, n - 1].

Par exemple, distance("ab", "cd") == 4, et distance("a", "z") == 1.
Vous pouvez remplacer n'importe quelle lettre de s par n'importe quelle autre lettre minuscule anglaise, autant de fois que vous le souhaitez.
Renvoie une chaîne indiquant la chaîne lexicographiquement la plus petite t que vous puissiez obtenir après quelques modifications, de telle sorte que distance(s, t) <= k.

Exemple 1 :

Entrée : s = "zbbz", k = 3
Sortie : "aaaz"
Explication :
Remplacez s par "aaaz". La distance entre "zbbz" et "aaaz" est égale à k = 3.

Exemple 2 :

Entrée : s = "xaxcd", k = 4
Sortie : "aawcd"
Explication :
La distance entre "xaxcd" et "aawcd" est égale à k = 4.

Exemple 3 :

Entrée : s = "lol", k = 0
Sortie : "lol"
Explication :
Il est impossible de modifier un caractère car k = 0.

Contraintes :

1 <= s.length <= 100
0 <= k <= 2000
s est uniquement composé de lettres minuscules anglaises.

Vous avez une chaîne de caractères s et un entier k.
Définissez une fonction distance(s_1, s_2) entre deux chaînes s_1 et s_2 de même longueur n comme :

La somme de la distance minimale entre s_1[i] et s_2[i] lorsque les caractères de 'a' à 'z' sont disposés de manière cyclique, pour tout i dans la plage [0, n - 1].

Par exemple, distance("ab", "cd") == 4, et distance("a", "z") == 1.
Vous pouvez changer n'importe quelle lettre de s en n'importe quelle autre lettre minuscule anglaise, autant de fois que vous le souhaitez.
Retournez une chaîne décrivant la plus petite chaîne lexicographiquement t que vous pouvez obtenir après quelques changements, telle que distance(s, t) <= k.

Exemple 1 :

Entrée : s = "zbbz", k = 3
Sortie : "aaaz"
Explication :
Changez s en "aaaz". La distance entre "zbbz" et "aaaz" est égale à k = 3.

Exemple 2 :

Entrée : s = "xaxcd", k = 4
Sortie : "aawcd"
Explication :
La distance entre "xaxcd" et "aawcd" est égale à k = 4.

Exemple 3 :

Entrée : s = "lol", k = 0
Sortie : "lol"
Explication :
Il est impossible de changer un caractère car k = 0.

Contraintes :

1 <= s.length <= 100
0 <= k <= 2000
s est constitué uniquement de lettres minuscules anglaises.


On vous donne un tableau d'entiers nums et un entier non négatif k. En une opération, vous pouvez augmenter ou diminuer n'importe quel élément de 1.
Retournez le nombre minimum d'opérations nécessaires pour que la médiane de nums soit égale à k.
La médiane d'un tableau est définie comme l'élément central du tableau lorsqu'il est trié par ordre non décroissant. S'il y a deux choix pour la médiane, la plus grande des deux valeurs est retenue.

Exemple 1 :

Entrée : nums = [2,5,6,8,5], k = 4
Sortie : 2
Explication :
Nous pouvons soustraire un à nums[1] et nums[4] pour obtenir [2, 4, 6, 8, 4]. La médiane du tableau résultant est égale à k.

Exemple 2 :

Entrée : nums = [2,5,6,8,5], k = 7
Sortie : 3
Explication :
Nous pouvons ajouter un à nums[1] deux fois et ajouter un à nums[2] une fois pour obtenir [2, 7, 7, 8, 5].

Exemple 3 :

Entrée : nums = [1,2,3,4,5,6], k = 4
Sortie : 0
Explication :
La médiane du tableau est déjà égale à k.

Contraintes :

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

Vous disposez d'un tableau d'entiers `nums` et d'un entier `k` non négatif. Dans une opération, vous pouvez augmenter ou diminuer n'importe quel élément de 1.
Retournez le nombre minimum d'opérations nécessaires pour faire en sorte que la médiane de `nums` soit égale à `k`.
La médiane d'un tableau est définie comme l'élément central du tableau lorsqu'il est trié dans l'ordre croissant. S'il y a deux choix pour une médiane, la plus grande des deux valeurs est prise.

Exemple 1 :

Entrée : nums = [2,5,6,8,5], k = 4
Sortie : 2
Explication :
Nous pouvons soustraire un de `nums[1]` et `nums[4]` pour obtenir [2, 4, 6, 8, 4]. La médiane du tableau résultant est égale à `k`.

Exemple 2 :

Entrée : nums = [2,5,6,8,5], k = 7
Sortie : 3
Explication :
Nous pouvons ajouter un à `nums[1]` deux fois et ajouter un à `nums[2]` une fois pour obtenir [2, 7, 7, 8, 5].

Exemple 3 :

Entrée : nums = [1,2,3,4,5,6], k = 4
Sortie : 0
Explication :
La médiane du tableau est déjà égale à `k`.

Contraintes :

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

On vous donne un tableau d'entiers nums et un entier k non négatif. Dans une opération, vous pouvez augmenter ou diminuer n'importe quel élément de 1.
Retournez le nombre minimum d'opérations nécessaires pour faire en sorte que la médiane de nums soit égale à k.
La médiane d'un tableau est définie comme l'élément du milieu du tableau lorsqu'il est trié dans l'ordre non décroissant. S'il y a deux choix pour une médiane, la plus grande des deux valeurs est prise.

Exemple 1 :

Entrée : nums = [2,5,6,8,5], k = 4
Sortie : 2
Explication :
Nous pouvons soustraire 1 de nums[1] et nums[4] pour obtenir [2, 4, 6, 8, 4]. La médiane du tableau résultant est égale à k.

Exemple 2 :

Entrée : nums = [2,5,6,8,5], k = 7
Sortie : 3
Explication :
Nous pouvons ajouter 1 à nums[1] deux fois et ajouter 1 à nums[2] une fois pour obtenir [2, 7, 7, 8, 5].

Exemple 3 :

Entrée : nums = [1,2,3,4,5,6], k = 4
Sortie : 0
Explication :
La médiane du tableau est déjà égale à k.

Contraintes :

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


Vous avez une chaîne de caractères s représentant une heure au format 12 heures où certains des chiffres (possiblement aucun) sont remplacés par un "?".
Les heures au format 12 heures sont formatées comme "HH:MM", où HH est compris entre 00 et 11, et MM est compris entre 00 et 59. L'heure la plus tôt au format 12 heures est 00:00, et la plus tard est 11:59.
Vous devez remplacer tous les caractères "?" dans s par des chiffres de manière à obtenir une heure valide au format 12 heures qui soit la plus tardive possible.
Retournez la chaîne résultante.

Exemple 1 :

Entrée : s = "1?:?4"
Sortie : "11:54"
Explication : L'heure la plus tardive au format 12 heures que nous pouvons obtenir en remplaçant les caractères "?" est "11:54".

Exemple 2 :

Entrée : s = "0?:5?"
Sortie : "09:59"
Explication : L'heure la plus tardive au format 12 heures que nous pouvons obtenir en remplaçant les caractères "?" est "09:59".

Contraintes :

s.length == 5
s[2] est égal au caractère ":".
Tous les caractères sauf s[2] sont des chiffres ou des caractères "?".
L'entrée est générée de manière à ce qu'il y ait au moins une heure entre "00:00" et "11:59" que vous pouvez obtenir après avoir remplacé les caractères "?".

Vous avez une chaîne de caractères s représentant une heure au format 12 heures où certains des chiffres (éventuellement aucun) sont remplacés par un "?".
Les heures au format 12 heures sont formatées comme "HH:MM", où HH est compris entre 00 et 11, et MM est compris entre 00 et 59. L'heure la plus tôt au format 12 heures est 00:00, et la plus tard est 11:59.
Vous devez remplacer tous les caractères "?" dans s par des chiffres de manière à obtenir une heure valide au format 12 heures qui soit la plus tardive possible.
Retournez la chaîne résultante.

Exemple 1 :

Entrée : s = "1?:?4"
Sortie : "11:54"
Explication : L'heure la plus tardive au format 12 heures que nous pouvons obtenir en remplaçant les caractères "?" est "11:54".

Exemple 2 :

Entrée : s = "0?:5?"
Sortie : "09:59"
Explication : L'heure la plus tardive au format 12 heures que nous pouvons obtenir en remplaçant les caractères "?" est "09:59".

Contraintes :

s.length == 5
s[2] est égal au caractère ":".
Tous les caractères sauf s[2] sont des chiffres ou des caractères "?".
L'entrée est générée de manière à ce qu'il y ait au moins une heure entre "00:00" et "11:59" que vous pouvez obtenir après avoir remplacé les caractères "?".

On vous donne une chaîne s représentant une heure au format 12 heures où certains chiffres (éventuellement aucun) sont remplacés par un « ? ».
Les heures au format 12 heures sont au format « HH:MM », où HH est compris entre 00 et 11 et MM entre 00 et 59. L'heure au format 12 heures la plus ancienne est 00:00 et la plus récente est 11:59.
Vous devez remplacer tous les caractères « ?» dans s par des chiffres de telle sorte que l'heure obtenue par la chaîne résultante soit une heure au format 12 heures valide et la plus récente possible.
Renvoyer la chaîne résultante.

Exemple 1 :

Entrée : s = "1?:?4"
Sortie : "11:54"
Explication : L'heure au format 12 heures la plus récente que nous pouvons obtenir en remplaçant les caractères "?" est "11:54".
Exemple 2 :

Entrée : s = "0?:5?"
Sortie : "09:59"
Explication : L'heure au format 12 heures la plus récente que nous pouvons obtenir en remplaçant les caractères "?" est "09:59".

Contraintes :

s.length == 5
s[2] est égal au caractère ":".
Tous les caractères, à l'exception de s[2], sont des chiffres ou des caractères "?".
L'entrée est générée de telle sorte qu'il existe au moins une heure entre "00:00" et "11:59" que vous pouvez obtenir après avoir remplacé les caractères "?".


Vous avez un tableau d'entiers `nums`.
Retournez un entier qui est la distance maximale entre les indices de deux nombres premiers (pas nécessairement différents) dans `nums`.

Exemple 1 :

Entrée : nums = [4,2,9,5,3]
Sortie : 3
Explication : nums[1], nums[3], et nums[4] sont premiers. Donc la réponse est |4 - 1| = 3.

Exemple 2 :

Entrée : nums = [4,8,2,8]
Sortie : 0
Explication : nums[2] est premier. Parce qu'il y a un seul nombre premier, la réponse est |2 - 2| = 0.

Contraintes :

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
L'entrée est générée de sorte que le nombre de nombres premiers dans `nums` soit au moins un.

On vous donne un tableau d'entiers `nums`.
Retournez un entier qui est la distance maximale entre les indices de deux nombres premiers (pas nécessairement différents) dans `nums`.

Exemple 1 :

Entrée : nums = [4,2,9,5,3]
Sortie : 3
Explication : nums[1], nums[3], et nums[4] sont premiers. Donc la réponse est |4 - 1| = 3.

Exemple 2 :

Entrée : nums = [4,8,2,8]
Sortie : 0
Explication : nums[2] est premier. Parce qu'il y a un seul nombre premier, la réponse est |2 - 2| = 0.

Contraintes :

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
L'entrée est générée de sorte que le nombre de nombres premiers dans `nums` soit au moins un.


On vous donne un tableau d'entiers coins représentant des pièces de différentes dénominations et un entier k. Vous avez un nombre infini de pièces de chaque dénomination. Cependant, vous n'êtes pas autorisé à combiner des pièces de différentes dénominations. Retournez le k^ème plus petit montant qui peut être obtenu en utilisant ces pièces.

Exemple 1 :

Entrée : coins = [3,6,9], k = 3
Sortie : 9
Explication : Les pièces données peuvent produire les montants suivants :
La pièce 3 produit des multiples de 3 : 3, 6, 9, 12, 15, etc.
La pièce 6 produit des multiples de 6 : 6, 12, 18, 24, etc.
La pièce 9 produit des multiples de 9 : 9, 18, 27, 36, etc.
Toutes les pièces combinées produisent : 3, 6, 9, 12, 15, etc.

Exemple 2 :

Entrée : coins = [5,2], k = 7
Sortie : 12
Explication : Les pièces données peuvent produire les montants suivants :
La pièce 5 produit des multiples de 5 : 5, 10, 15, 20, etc.
La pièce 2 produit des multiples de 2 : 2, 4, 6, 8, 10, 12, etc.
Toutes les pièces combinées produisent : 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Contraintes :

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contient des entiers distincts entre eux.

On vous donne un tableau d'entiers coins représentant des pièces de différentes valeurs et un entier k.
Vous disposez d'un nombre infini de pièces de chaque valeur. Cependant, vous n'êtes pas autorisé à combiner des pièces de différentes valeurs.
Renvoie le k^ième plus petit montant qui peut être obtenu à l'aide de ces pièces.

Exemple 1 :

Entrée : coins = [3,6,9], k = 3
Sortie : 9
Explication : les pièces données peuvent produire les montants suivants :
La pièce 3 produit des multiples de 3 : 3, 6, 9, 12, 15, etc.
La pièce 6 produit des multiples de 6 : 6, 12, 18, 24, etc.
La pièce 9 produit des multiples de 9 : 9, 18, 27, 36, etc.
L'ensemble des pièces produit : 3, 6, 9, 12, 15, etc.

Exemple 2 :

Entrée : coins = [5,2], k = 7
Sortie : 12
Explication : les pièces données peuvent produire les montants suivants :
La pièce 5 produit des multiples de 5 : 5, 10, 15, 20, etc.
La pièce 2 produit des multiples de 2 : 2, 4, 6, 8, 10, 12, etc.
Toutes les pièces combinées produisent : 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Contraintes :

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contient des entiers distincts par paires.

On a un tableau d'entiers coins représentant des pièces de différentes dénominations et un entier k.
Vous avez un nombre infini de pièces de chaque dénomination. Cependant, vous n'êtes pas autorisé à combiner des pièces de différentes dénominations.
Retournez le k^ème plus petit montant qui peut être obtenu en utilisant ces pièces.

Exemple 1 :

Entrée : coins = [3,6,9], k = 3
Sortie : 9
Explication : Les pièces données peuvent produire les montants suivants :
La pièce 3 produit des multiples de 3 : 3, 6, 9, 12, 15, etc.
La pièce 6 produit des multiples de 6 : 6, 12, 18, 24, etc.
La pièce 9 produit des multiples de 9 : 9, 18, 27, 36, etc.
Toutes les pièces combinées produisent : 3, 6, 9, 12, 15, etc.

Exemple 2 :

Entrée : coins = [5,2], k = 7
Sortie : 12
Explication : Les pièces données peuvent produire les montants suivants :
La pièce 5 produit des multiples de 5 : 5, 10, 15, 20, etc.
La pièce 2 produit des multiples de 2 : 2, 4, 6, 8, 10, 12, etc.
Toutes les pièces combinées produisent : 2, 4, 5, 6, 8, 10, 12, 14, 15, etc.

Contraintes :

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins contient des entiers distincts entre eux.


Vous disposez de deux tableaux nums et andValues respectivement de longueur n et m.
La valeur d'un tableau est égale au dernier élément de ce tableau.
Vous devez diviser nums en m sous-tableaux contigus disjoints de telle sorte que pour le i^ème sous-tableau [l_i, r_i], le AND bit à bit des éléments du sous-tableau soit égal à andValues[i], en d'autres termes, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] pour tout 1 <= i <= m, où & représente l'opérateur AND bit à bit.
Retournez la somme minimale possible des valeurs des m sous-tableaux dans lesquels nums est divisé. S'il n'est pas possible de diviser nums en m sous-tableaux satisfaisant ces conditions, retournez -1.

Exemple 1 :

Entrée : nums = [1,4,3,3,2], andValues = [0,3,3,2]
Sortie : 12
Explication :
La seule manière possible de diviser nums est :

[1,4] car 1 & 4 == 0.
[3] car le AND bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.
[3] car le AND bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.
[2] car le AND bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.

La somme des valeurs pour ces sous-tableaux est 4 + 3 + 3 + 2 = 12.

Exemple 2 :

Entrée : nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Sortie : 17
Explication :
Il existe trois façons de diviser nums :

[[2,3,5],[7,7,7],[5]] avec la somme des valeurs 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.

La somme minimale possible des valeurs est 17.

Exemple 3 :

Entrée : nums = [1,2,3,4], andValues = [2]
Sortie : -1
Explication :
Le AND bit à bit de l'ensemble du tableau nums est 0. Comme il n'y a pas de moyen possible de diviser nums en un seul sous-tableau pour obtenir le AND bit à bit des éléments égal à 2, retournez -1.

Contraintes :

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Vous disposez de deux tableaux nums et andValues de longueur n et m respectivement.
La valeur d'un tableau est égale au dernier élément de ce tableau.
Vous devez diviser nums en m sous-tableaux contigus disjoints de telle sorte que pour le i^ème sous-tableau [l_i, r_i], le ET bit à bit des éléments du sous-tableau soit égal à andValues[i], en d'autres termes, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] pour tout 1 <= i <= m, où & représente l'opérateur ET bit à bit.
Retournez la somme minimale possible des valeurs des m sous-tableaux dans lesquels nums est divisé. S'il n'est pas possible de diviser nums en m sous-tableaux satisfaisant ces conditions, retournez -1.

Exemple 1 :

Entrée : nums = [1,4,3,3,2], andValues = [0,3,3,2]
Sortie : 12
Explication :
La seule manière possible de diviser nums est :

[1,4] car 1 & 4 == 0.
[3] car le ET bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.
[3] car le ET bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.
[2] car le ET bit à bit d'un sous-tableau à un seul élément est cet élément lui-même.

La somme des valeurs pour ces sous-tableaux est 4 + 3 + 3 + 2 = 12.

Exemple 2 :

Entrée : nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Sortie : 17
Explication :
Il existe trois façons de diviser nums :

[[2,3,5],[7,7,7],[5]] avec la somme des valeurs 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.

La somme minimale possible des valeurs est 17.

Exemple 3 :

Entrée : nums = [1,2,3,4], andValues = [2]
Sortie : -1
Explication :
Le ET bit à bit de l'ensemble du tableau nums est 0. Comme il n'y a pas de moyen possible de diviser nums en un seul sous-tableau pour obtenir le ET bit à bit des éléments égal à 2, retournez -1.

Contraintes :

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

On vous donne deux tableaux nums et andValues de longueur n et m respectivement.
La valeur d'un tableau est égale au dernier élément de ce tableau.
Vous devez diviser nums en m sous-tableaux contigus disjoints tels que pour le i^ème sous-tableau [l_i, r_i], l'opérateur AND au niveau du bit des éléments du sous-tableau soit égal à andValues[i], en d'autres termes, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] pour tout 1 <= i <= m, où & représente l'opérateur AND au niveau du bit.
Renvoie la somme minimale possible des valeurs des m sous-tableaux dans lesquels nums est divisé. S'il n'est pas possible de diviser nums en m sous-tableaux satisfaisant ces conditions, renvoie -1.

Exemple 1 :

Entrée : nums = [1,4,3,3,2], etValues = [0,3,3,2]
Sortie : 12
Explication :
La seule façon possible de diviser nums est :

[1,4] comme 1 et 4 == 0.
[3] comme le ET au niveau du bit d'un sous-tableau à un seul élément est cet élément lui-même.
[3] comme le ET au niveau du bit d'un sous-tableau à un seul élément est cet élément lui-même.
[2] comme le ET au niveau du bit d'un sous-tableau à un seul élément est cet élément lui-même.

La somme des valeurs de ces sous-tableaux est 4 + 3 + 3 + 2 = 12.

Exemple 2 :

Entrée : nums = [2,3,5,7,7,7,5] etValues = [0,7,5]
Sortie : 17
Explication :
Il existe trois façons de diviser nums :

[[2,3,5],[7,7,7],[5]] avec la somme des valeurs 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] avec la somme des valeurs 7 + 7 + 5 == 19.

La somme minimale possible des valeurs est 17.

Exemple 3 :

Entrée : nums = [1,2,3,4], andValues = [2]
Sortie : -1
Explication :
Le AND au niveau du bit de l'ensemble du tableau nums est 0. Comme il n'existe aucun moyen de diviser nums en un seul sous-tableau pour obtenir le AND au niveau du bit des éléments 2, renvoyez -1.

Contraintes :

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Vous avez un tableau d'entiers nums contenant des entiers positifs. Nous définissons une fonction encrypt telle que encrypt(x) remplace chaque chiffre de x par le plus grand chiffre de x. Par exemple, encrypt(523) = 555 et encrypt(213) = 333.
Retournez la somme des éléments cryptés.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 6
Explication : Les éléments cryptés sont [1,2,3]. La somme des éléments cryptés est 1 + 2 + 3 == 6.

Exemple 2 :

Entrée : nums = [10,21,31]
Sortie : 66
Explication : Les éléments cryptés sont [11,22,33]. La somme des éléments cryptés est 11 + 22 + 33 == 66.

Contraintes :

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

On vous donne un tableau d'entiers nums contenant des entiers positifs. Nous définissons une fonction encrypt telle que encrypt(x) remplace chaque chiffre de x par le plus grand chiffre de x. Par exemple, encrypt(523) = 555 et encrypt(213) = 333.
Renvoyer la somme des éléments chiffrés.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 6
Explication : Les éléments chiffrés sont [1,2,3]. La somme des éléments chiffrés est 1 + 2 + 3 == 6.

Exemple 2 :

Entrée : nums = [10,21,31]
Sortie : 66
Explication : Les éléments chiffrés sont [11,22,33]. La somme des éléments chiffrés est 11 + 22 + 33 == 66.

Contraintes :

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


On vous donne un tableau indexé à 0, `nums`, de taille `n` composé d'entiers positifs.
On vous donne également un tableau 2D `queries` de taille `m` où `queries[i] = [index_i, k_i]`.
Initialement, tous les éléments du tableau sont non marqués.
Vous devez appliquer `m` requêtes sur le tableau dans l'ordre, où pour la `i`-ème requête, vous faites ce qui suit :

Marquez l'élément à l'index `index_i` s'il n'est pas déjà marqué.
Ensuite, marquez `k_i` éléments non marqués dans le tableau avec les plus petites valeurs. Si plusieurs de ces éléments existent, marquez ceux avec les indices les plus petits. Et s'il existe moins de `k_i` éléments non marqués, marquez-les tous.

Retournez un tableau `answer` de taille `m` où `answer[i]` est la somme des éléments non marqués dans le tableau après la `i`-ème requête.

Exemple 1 :

Entrée : nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Sortie : [8,3,0]
Explication :
Nous effectuons les requêtes suivantes sur le tableau :

Marquez l'élément à l'index 1, et deux des plus petits éléments non marqués avec les indices les plus petits s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 2 + 2 + 3 + 1 = 8.
Marquez l'élément à l'index 3, puisqu'il est déjà marqué, nous le sautons. Ensuite, nous marquons 3 des plus petits éléments non marqués avec les indices les plus petits, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 3.
Marquez l'élément à l'index 4, puisqu'il est déjà marqué, nous le sautons. Ensuite, nous marquons 2 des plus petits éléments non marqués avec les indices les plus petits s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 0.

Exemple 2 :

Entrée : nums = [1,4,2,3], queries = [[0,1]]
Sortie : [7]
Explication : Nous faisons une requête qui consiste à marquer l'élément à l'index 0 et à marquer le plus petit élément parmi les éléments non marqués. Les éléments marqués seront nums = [1,4,2,3], et la somme des éléments non marqués est 4 + 3 = 7.

Contraintes :

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Vous avez un tableau nums indexé à partir de 0 de taille n constitué d'entiers positifs.
On vous donne également un tableau 2D queries de taille m où queries[i] = [index_i, k_i].
Initialement, tous les éléments du tableau sont non marqués.
Vous devez appliquer m requêtes sur le tableau dans l'ordre, où pour la i-ème requête, vous faites ce qui suit :

Marquez l'élément à l'indice index_i s'il n'est pas déjà marqué.
Ensuite, marquez k_i éléments non marqués dans le tableau avec les plus petites valeurs. Si plusieurs de ces éléments existent, marquez ceux avec les indices les plus petits. Et s'il existe moins de k_i éléments non marqués, marquez-les tous.

Retournez un tableau answer de taille m où answer[i] est la somme des éléments non marqués dans le tableau après la i-ème requête.

Exemple 1 :

Entrée : nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Sortie : [8,3,0]
Explication :
Nous effectuons les requêtes suivantes sur le tableau :

Marquez l'élément à l'indice 1, et deux des plus petits éléments non marqués avec les indices les plus petits s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 2 + 2 + 3 + 1 = 8.
Marquez l'élément à l'indice 3, puisqu'il est déjà marqué, nous le sautons. Ensuite, nous marquons 3 des plus petits éléments non marqués avec les indices les plus petits, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 3.
Marquez l'élément à l'indice 4, puisqu'il est déjà marqué, nous le sautons. Ensuite, nous marquons 2 des plus petits éléments non marqués avec les indices les plus petits s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 0.

Exemple 2 :

Entrée : nums = [1,4,2,3], queries = [[0,1]]
Sortie : [7]
Explication : Nous faisons une requête qui consiste à marquer l'élément à l'indice 0 et à marquer le plus petit élément parmi les éléments non marqués. Les éléments marqués seront nums = [1,4,2,3], et la somme des éléments non marqués est 4 + 3 = 7.

Contraintes :

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

On vous donne un tableau nums indexé à 0 de taille n composé d'entiers positifs.
On vous donne également un tableau 2D queries de taille m où queries[i] = [index_i, k_i].
Au départ, tous les éléments du tableau ne sont pas marqués.
Vous devez appliquer m requêtes sur le tableau dans l'ordre, où à la i^ème requête, vous effectuez les opérations suivantes :

Marquez l'élément à l'index index_i s'il n'est pas déjà marqué.
Marquez ensuite k_i éléments non marqués dans le tableau avec les plus petites valeurs. Si plusieurs de ces éléments existent, marquez ceux avec les plus petits indices. Et s'il existe moins de k_i éléments non marqués, marquez-les tous.

Renvoie un tableau answer de taille m où answer[i] est la somme des éléments non marqués dans le tableau après la i^ème requête.

Exemple 1 :

Entrée : nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Sortie : [8,3,0]
Explication :
Nous effectuons les requêtes suivantes sur le tableau :

Marquons l'élément à l'index 1, et 2 des plus petits éléments non marqués avec les plus petits indices s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est 2 + 2 + 3 + 1 = 8.
Marquons l'élément à l'index 3, puisqu'il est déjà marqué, nous l'ignorons. Ensuite, nous marquons 3 des plus petits éléments non marqués avec les plus petits indices, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est de 3.
Marquons l'élément à l'index 4, puisqu'il est déjà marqué, nous l'ignorons. Ensuite, nous marquons 2 des plus petits éléments non marqués avec les plus petits indices s'ils existent, les éléments marqués sont maintenant nums = [1,2,2,1,2,3,1]. La somme des éléments non marqués est de 0.

Exemple 2 :

Entrée : nums = [1,4,2,3], queries = [[0,1]]
Sortie : [7]
Explication : Nous effectuons une requête qui consiste à marquer l'élément à l'index 0 et à marquer le plus petit élément parmi les éléments non marqués. Les éléments marqués seront nums = [1,4,2,3], et la somme des éléments non marqués est 4 + 3 = 7.

Contraintes :

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1


Vous avez une chaîne de caractères s. s[i] est soit une lettre anglaise minuscule, soit un '?'.
Pour une chaîne de caractères t de longueur m contenant uniquement des lettres anglaises minuscules, nous définissons la fonction cost(i) pour un indice i comme le nombre de caractères égaux à t[i] qui sont apparus avant, c'est-à-dire dans la plage [0, i - 1].
La valeur de t est la somme de cost(i) pour tous les indices i.
Par exemple, pour la chaîne t = "aab" :

cost(0) = 0
cost(1) = 1
cost(2) = 0
Ainsi, la valeur de "aab" est 0 + 1 + 0 = 1.

Votre tâche est de remplacer toutes les occurrences de '?' dans s par n'importe quelle lettre anglaise minuscule afin que la valeur de s soit minimisée.
Retournez une chaîne de caractères indiquant la chaîne modifiée avec les occurrences de '?' remplacées. S'il existe plusieurs chaînes entraînant la valeur minimale, retournez celle qui est lexicographiquement la plus petite.

Exemple 1 :

Entrée :   s = "???"
Sortie :   "abc"
Explication :  Dans cet exemple, nous pouvons remplacer les occurrences de '?' pour que s soit égal à "abc".
Pour "abc", cost(0) = 0, cost(1) = 0, et cost(2) = 0.
La valeur de "abc" est 0.
D'autres modifications de s qui ont une valeur de 0 sont "cba", "abz", et "hey".
Parmi toutes celles-ci, nous choisissons la plus petite lexicographiquement.

Exemple 2 :

Entrée :  s = "a?a?"
Sortie :  "abac"
Explication :  Dans cet exemple, les occurrences de '?' peuvent être remplacées pour que s soit égal à "abac".
Pour "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1, et cost(3) = 0.
La valeur de "abac" est 1.

Contraintes :

1 <= s.length <= 10^5
s[i] est soit une lettre anglaise minuscule, soit '?'.

On vous donne une chaîne s. s[i] est soit une lettre anglaise minuscule, soit ' ?'.
Pour une chaîne t de longueur m ne contenant que des lettres minuscules anglaises, on définit la fonction cost(i) pour un indice i comme le nombre de caractères égal à t[i] qui apparaissaient avant elle, c’est-à-dire dans l’intervalle [0, i - 1].
La valeur de t est la somme de cost(i) pour tous les indices i.
Par exemple, pour la chaîne t = "aab" :

coût(0) = 0
coût(1) = 1
coût(2) = 0
Par conséquent, la valeur de « aab » est 0 + 1 + 0 = 1.

Votre tâche consiste à remplacer toutes les occurrences de ' ?' dans s par n’importe quelle lettre anglaise minuscule afin que la valeur de s soit minimisée.
Renvoie une chaîne indiquant la chaîne modifiée avec les occurrences remplacées de ' ?'. S’il y a plusieurs chaînes de caractères donnant la valeur minimale, renvoyez la plus petite lexicographiquement.

Exemple 1 :

Entrée : s = "???"
Sortie : "abc"
Explication : Dans cet exemple, nous pouvons remplacer les occurrences de '?' pour que s soit égal à "abc".
Pour "abc", cost(0) = 0, cost(1) = 0, et cost(2) = 0.
La valeur de "abc" est 0.
D'autres modifications de s qui ont une valeur de 0 sont "cba", "abz", et "hey".
Parmi tous, nous choisissons le plus petit lexicographiquement.

Exemple 2 :

Entrée : s = "a?a?"
Sortie : "abac"
Explication : Dans cet exemple, les occurrences de '?' peuvent être remplacées pour que s soit égal à "abac".
Pour "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1, et cost(3) = 0.
La valeur de "abac" est 1.

Contraintes:

1 <= s.length <= 10^5
s[i] est soit une lettre anglaise minuscule, soit ' ?'.

On vous donne une chaîne de caractères s. s[i] est soit une lettre anglaise minuscule, soit un '?'.

Pour une chaîne de caractères t de longueur m contenant uniquement des lettres anglaises minuscules, nous définissons la fonction cost(i) pour un indice i comme le nombre de caractères égaux à t[i] qui sont apparus avant, c'est-à-dire dans la plage [0, i - 1].

La valeur de t est la somme de cost(i) pour tous les indices i.

Par exemple, pour la chaîne t = "aab" :

cost(0) = 0
cost(1) = 1
cost(2) = 0
Ainsi, la valeur de "aab" est 0 + 1 + 0 = 1.

Votre tâche est de remplacer toutes les occurrences de '?' dans s par n'importe quelle lettre anglaise minuscule afin que la valeur de s soit minimisée.

Renvoyez une chaîne de caractères indiquant la chaîne modifiée avec les occurrences de '?' remplacées. S'il existe plusieurs chaînes entraînant la valeur minimale, renvoyez celle qui est lexicographiquement la plus petite.

Exemple 1 :

Entrée :   s = "???"
Sortie :   "abc"
Explication : Dans cet exemple, nous pouvons remplacer les occurrences de '?' pour que s soit égal à "abc".
Pour "abc", cost(0) = 0, cost(1) = 0, et cost(2) = 0.
La valeur de "abc" est 0.
D'autres modifications de s qui ont une valeur de 0 sont "cba", "abz", et "hey".
Parmi toutes celles-ci, nous choisissons la plus petite lexicographiquement.

Exemple 2 :

Entrée :  s = "a?a?"
Sortie :  "abac"
Explication : Dans cet exemple, les occurrences de '?' peuvent être remplacées pour que s soit égal à "abac".
Pour "abac", cost(0) = 0, cost(1) = 0, cost(2) = 1, et cost(3) = 0.
La valeur de "abac" est 1.

Contraintes :

1 <= s.length <= 10^5
s[i] est soit une lettre anglaise minuscule, soit '?'.


On vous donne un tableau d'entiers nums de longueur n et un entier positif k.
La puissance d'un tableau d'entiers est définie comme le nombre de sous-séquences dont la somme est égale à k.
Renvoie la somme de la puissance de toutes les sous-séquences de nums.
Étant donné que la réponse peut être très grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3], k = 3
Sortie : 6
Explication :
Il existe 5 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [1,2,3] a 2 sous-séquences avec une somme == 3 : [1,2,3] et [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec une somme == 3 : [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3 : [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3 : [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3 : [1,2,3].

La réponse est donc 2 + 1 + 1 + 1 + 1 = 6.

Exemple 2 :

Entrée : nums = [2,3,3], k = 5
Sortie : 4

Explication :
Il y a 3 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [2,3,3] a 2 sous-séquence avec somme == 5 : [2,3,3] et [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5 : [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5 : [2,3,3].

La réponse est donc 2 + 1 + 1 = 4.

Exemple 3 :

Entrée : nums = [1,2,3], k = 7
Sortie : 0

Explication : Il n'existe aucune sous-séquence avec somme 7. Par conséquent, toutes les sous-séquences de nums ont une puissance = 0.

Contraintes :

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

Vous avez un tableau d'entiers `nums` de longueur `n` et un entier positif `k`.
La puissance d'un tableau d'entiers est définie comme le nombre de sous-séquences dont la somme est égale à `k`.
Renvoyez la somme des puissances de toutes les sous-séquences de `nums`.
Comme la réponse peut être très grande, renvoyez-la modulo `10^9 + 7`.

Exemple 1 :

Entrée : nums = [1,2,3], k = 3
Sortie : 6
Explication :
Il y a 5 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [1,2,3] a 2 sous-séquences avec somme == 3: [1,2,3] et [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].

D'où la réponse est 2 + 1 + 1 + 1 + 1 = 6.

Exemple 2 :

Entrée : nums = [2,3,3], k = 5
Sortie : 4
Explication :
Il y a 3 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [2,3,3] a 2 sous-séquences avec somme == 5: [2,3,3] et [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5: [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5: [2,3,3].

D'où la réponse est 2 + 1 + 1 = 4.

Exemple 3 :

Entrée : nums = [1,2,3], k = 7
Sortie : 0
Explication : Il n'existe aucune sous-séquence avec somme 7. Ainsi toutes les sous-séquences de nums ont une puissance = 0.

Contraintes :

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

On donne un tableau d'entiers nums de longueur n et un entier positif k.
La puissance d'un tableau d'entiers est définie comme le nombre de sous-séquences dont la somme est égale à k.
Retournez la somme des puissances de toutes les sous-séquences de nums.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée :   nums = [1,2,3], k = 3
Sortie :   6
Explication :
Il y a 5 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [1,2,3] a 2 sous-séquences avec somme == 3: [1,2,3] et [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].
La sous-séquence [1,2,3] a 1 sous-séquence avec somme == 3: [1,2,3].

D'où la réponse est 2 + 1 + 1 + 1 + 1 = 6.

Exemple 2 :

Entrée :   nums = [2,3,3], k = 5
Sortie :   4
Explication :
Il y a 3 sous-séquences de nums avec une puissance non nulle :

La sous-séquence [2,3,3] a 2 sous-séquences avec somme == 5: [2,3,3] et [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5: [2,3,3].
La sous-séquence [2,3,3] a 1 sous-séquence avec somme == 5: [2,3,3].

D'où la réponse est 2 + 1 + 1 = 4.

Exemple 3 :

Entrée :   nums = [1,2,3], k = 7
Sortie :   0
Explication : Il n'existe aucune sous-séquence avec somme 7. Ainsi toutes les sous-séquences de nums ont une puissance = 0.

Contraintes :

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100


On vous donne un tableau `nums` d'entiers non négatifs et un entier `k`.
Un tableau est appelé spécial si le OU bit-à-bit de tous ses éléments est au moins `k`.
Retournez la longueur du sous-tableau spécial non vide le plus court de `nums`, ou retournez -1 si aucun sous-tableau spécial n'existe.

Exemple 1 :

Entrée : nums = [1,2,3], k = 2
Sortie : 1
Explication :
Le sous-tableau [3] a une valeur de OU égale à 3. Ainsi, nous retournons 1.

Exemple 2 :

Entrée : nums = [2,1,8], k = 10
Sortie : 3
Explication :
Le sous-tableau [2,1,8] a une valeur de OU égale à 11. Ainsi, nous retournons 3.

Exemple 3 :

Entrée : nums = [1,2], k = 0
Sortie : 1
Explication :
Le sous-tableau [1] a une valeur de OU égale à 1. Ainsi, nous retournons 1.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

On vous donne un tableau nums d'entiers non négatifs et un entier k.
Un tableau est dit spécial si le OU binaire de tous ses éléments est au moins k.
Renvoie la longueur du sous-tableau spécial non vide le plus court de nums, ou renvoie -1 si aucun sous-tableau spécial n'existe.

Exemple 1 :

Entrée : nums = [1,2,3], k = 2
Sortie : 1
Explication :
Le sous-tableau [3] a une valeur de OU égale à 3. Ainsi, nous retournons 1.

Exemple 2 :

Entrée : nums = [2,1,8], k = 10
Sortie : 3
Explication :
Le sous-tableau [2,1,8] a une valeur de OU égale à 11. Ainsi, nous retournons 3.

Exemple 3 :

Entrée : nums = [1,2], k = 0
Sortie : 1
Explication :
Le sous-tableau [1] a une valeur de OU égale à 1. Ainsi, nous retournons 1.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Vous avez un tableau nums d'entiers non négatifs et un entier k.
Un tableau est appelé spécial si le OR bit-à-bit de tous ses éléments est au moins k.
Retournez la longueur du sous-tableau spécial non vide le plus court de nums, ou retournez -1 si aucun sous-tableau spécial n'existe.

Exemple 1 :

Entrée : nums = [1,2,3], k = 2
Sortie : 1
Explication :
Le sous-tableau [3] a une valeur de OR égale à 3. Ainsi, nous retournons 1.

Exemple 2 :

Entrée : nums = [2,1,8], k = 10
Sortie : 3
Explication :
Le sous-tableau [2,1,8] a une valeur de OR égale à 11. Ainsi, nous retournons 3.

Exemple 3 :

Entrée : nums = [1,2], k = 0
Sortie : 1
Explication :
Le sous-tableau [1] a une valeur de OR égale à 1. Ainsi, nous retournons 1.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64


On vous donne un tableau binaire possible de longueur n.
Alice et Bob jouent à un jeu qui consiste en n niveaux. Certains des niveaux du jeu sont impossibles à franchir tandis que d'autres peuvent toujours être franchis. En particulier, si possible[i] == 0, alors le i-ème niveau est impossible à franchir pour les deux joueurs. Un joueur gagne 1 point en franchissant un niveau et perd 1 point s'il échoue à le franchir.
Au début du jeu, Alice jouera certains niveaux dans l'ordre donné en commençant par le niveau 0, après quoi Bob jouera le reste des niveaux.
Alice veut savoir le nombre minimum de niveaux qu'elle doit jouer pour obtenir plus de points que Bob, si les deux joueurs jouent de manière optimale pour maximiser leurs points.
Renvoyez le nombre minimum de niveaux qu'Alice doit jouer pour obtenir plus de points. Si ce n'est pas possible, renvoyez -1.
Notez que chaque joueur doit jouer au moins 1 niveau.

Exemple 1 :

Entrée : possible = [1,0,1,0]
Sortie : 1
Explication :
Regardons tous les niveaux qu'Alice peut jouer jusqu'à :

Si Alice joue seulement le niveau 0 et Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a -1 + 1 - 1 = -1 point.
Si Alice joue jusqu'au niveau 1 et Bob joue le reste des niveaux, Alice a 1 - 1 = 0 points, tandis que Bob a 1 - 1 = 0 points.
Si Alice joue jusqu'au niveau 2 et Bob joue le reste des niveaux, Alice a 1 - 1 + 1 = 1 point, tandis que Bob a -1 point.

Alice doit jouer un minimum de 1 niveau pour obtenir plus de points.

Exemple 2 :

Entrée : possible = [1,1,1,1,1]
Sortie : 3
Explication :
Regardons tous les niveaux qu'Alice peut jouer jusqu'à :

Si Alice joue seulement le niveau 0 et Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a 4 points.
Si Alice joue jusqu'au niveau 1 et Bob joue le reste des niveaux, Alice a 2 points, tandis que Bob a 3 points.
Si Alice joue jusqu'au niveau 2 et Bob joue le reste des niveaux, Alice a 3 points, tandis que Bob a 2 points.
Si Alice joue jusqu'au niveau 3 et Bob joue le reste des niveaux, Alice a 4 points, tandis que Bob a 1 point.

Alice doit jouer un minimum de 3 niveaux pour obtenir plus de points.

Exemple 3 :

Entrée : possible = [0,0]
Sortie : -1
Explication :
La seule façon possible est que les deux joueurs jouent 1 niveau chacun. Alice joue le niveau 0 et perd 1 point. Bob joue le niveau 1 et perd 1 point. Comme les deux joueurs ont un score égal, Alice ne peut pas avoir plus de points que Bob.

Contraintes :

2 <= n == possible.length <= 10^5
possible[i] vaut soit 0 soit 1.

On vous donne un tableau binaire possible de longueur n.
Alice et Bob jouent à un jeu composé de n niveaux. Certains niveaux du jeu sont impossibles à franchir alors que d'autres peuvent toujours être franchis. En particulier, si possible[i] == 0, alors le i^e niveau est impossible à franchir pour les deux joueurs. Un joueur gagne 1 point en franchissant un niveau et perd 1 point s'il ne le franchit pas.
Au début du jeu, Alice jouera quelques niveaux dans l'ordre donné en commençant par le 0^ème niveau, après quoi Bob jouera le reste des niveaux.
Alice veut connaître le nombre minimum de niveaux qu'elle doit jouer pour gagner plus de points que Bob, si les deux joueurs jouent de façon optimale pour maximiser leurs points.
Retournez le nombre minimum de niveaux qu'Alice devrait jouer pour gagner plus de points. Si ce n'est pas possible, elle renvoie -1.
Notez que chaque joueur doit jouer au moins un niveau.

Exemple 1 :

Entrée : possible = [1,0,1,0]
Sortie : 1
Explication :
Examinons tous les niveaux qu'Alice peut jouer :

Si Alice ne joue que le niveau 0 et que Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a -1 + 1 - 1 = -1 point.
Si Alice joue jusqu'au niveau 1 et que Bob joue le reste des niveaux, Alice a 1 - 1 = 0 point, tandis que Bob a 1 - 1 = 0 point.
Si Alice joue jusqu'au niveau 2 et que Bob joue le reste des niveaux, Alice a 1 - 1 + 1 = 1 point, tandis que Bob a -1 point.

Alice doit jouer au moins un niveau pour gagner plus de points.

Exemple 2 :

Entrée : possible = [1,1,1,1,1]
Sortie : 3
Explication :
Examinons tous les niveaux qu'Alice peut jouer :

Si Alice ne joue que le niveau 0 et que Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a 4 points.
Si Alice joue jusqu'au niveau 1 et que Bob joue le reste des niveaux, Alice a 2 points, tandis que Bob a 3 points.
Si Alice joue jusqu'au niveau 2 et que Bob joue le reste des niveaux, Alice a 3 points, tandis que Bob a 2 points.
Si Alice joue jusqu'au niveau 3 et que Bob joue le reste des niveaux, Alice a 4 points, tandis que Bob a 1 point.

Alice doit jouer un minimum de 3 niveaux pour gagner plus de points.

Exemple 3 :

Entrée : possible = [0,0]
Sortie : -1
Explication :
La seule possibilité est que les deux joueurs jouent chacun un niveau. Alice joue le niveau 0 et perd 1 point. Bob joue le niveau 1 et perd 1 point. Comme les deux joueurs ont le même nombre de points, Alice ne peut pas gagner plus de points que Bob.

Contraintes :

2 <= n == possible.length <= 10^5
possible[i] vaut soit 0 soit 1.

On vous donne un tableau binaire possible de longueur n.
Alice et Bob jouent à un jeu qui consiste en n niveaux. Certains des niveaux du jeu sont impossibles à franchir tandis que d'autres peuvent toujours être franchis. En particulier, si possible[i] == 0, alors le i-ème niveau est impossible à franchir pour les deux joueurs. Un joueur gagne 1 point en franchissant un niveau et perd 1 point s'il échoue à le franchir.
Au début du jeu, Alice jouera certains niveaux dans l'ordre donné en commençant par le niveau 0, après quoi Bob jouera le reste des niveaux.
Alice veut savoir le nombre minimum de niveaux qu'elle doit jouer pour obtenir plus de points que Bob, si les deux joueurs jouent de manière optimale pour maximiser leurs points.
Retournez le nombre minimum de niveaux qu'Alice doit jouer pour obtenir plus de points. Si ce n'est pas possible, retournez -1.
Notez que chaque joueur doit jouer au moins 1 niveau.

Exemple 1 :

Entrée : possible = [1,0,1,0]
Sortie : 1
Explication :
Examinons tous les niveaux qu'Alice peut jouer jusqu'à :

Si Alice joue seulement le niveau 0 et Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a -1 + 1 - 1 = -1 point.
Si Alice joue jusqu'au niveau 1 et Bob joue le reste des niveaux, Alice a 1 - 1 = 0 points, tandis que Bob a 1 - 1 = 0 points.
Si Alice joue jusqu'au niveau 2 et Bob joue le reste des niveaux, Alice a 1 - 1 + 1 = 1 point, tandis que Bob a -1 point.

Alice doit jouer un minimum de 1 niveau pour obtenir plus de points.

Exemple 2 :

Entrée : possible = [1,1,1,1,1]
Sortie : 3
Explication :
Examinons tous les niveaux qu'Alice peut jouer jusqu'à :

Si Alice joue seulement le niveau 0 et Bob joue le reste des niveaux, Alice a 1 point, tandis que Bob a 4 points.
Si Alice joue jusqu'au niveau 1 et Bob joue le reste des niveaux, Alice a 2 points, tandis que Bob a 3 points.
Si Alice joue jusqu'au niveau 2 et Bob joue le reste des niveaux, Alice a 3 points, tandis que Bob a 2 points.
Si Alice joue jusqu'au niveau 3 et Bob joue le reste des niveaux, Alice a 4 points, tandis que Bob a 1 point.

Alice doit jouer un minimum de 3 niveaux pour obtenir plus de points.

Exemple 3 :

Entrée : possible = [0,0]
Sortie : -1
Explication :
La seule façon possible est que les deux joueurs jouent chacun 1 niveau. Alice joue le niveau 0 et perd 1 point. Bob joue le niveau 1 et perd 1 point. Comme les deux joueurs ont un score égal, Alice ne peut pas avoir plus de points que Bob.

Contraintes :

2 <= n == possible.length <= 10^5
possible[i] vaut soit 0 soit 1.


On vous donne un tableau d'entiers nums de longueur n, et un entier positif k.
La puissance d'une sous-séquence est définie comme la différence absolue minimale entre deux éléments quelconques de la sous-séquence.
Retournez la somme des puissances de toutes les sous-séquences de nums de longueur égale à k.
Puisque la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4], k = 3
Sortie : 4
Explication :
Il y a 4 sous-séquences dans nums de longueur 3 : [1,2,3], [1,3,4], [1,2,4], et [2,3,4]. La somme des puissances est |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Exemple 2 :

Entrée : nums = [2,2], k = 2
Sortie : 0
Explication :
La seule sous-séquence de nums de longueur 2 est [2,2]. La somme des puissances est |2 - 2| = 0.

Exemple 3 :

Entrée : nums = [4,3,-1], k = 2
Sortie : 10
Explication :
Il y a 3 sous-séquences dans nums de longueur 2 : [4,3], [4,-1], et [3,-1]. La somme des puissances est |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Contraintes :

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

On vous donne un tableau d'entiers `nums` de longueur `n`, et un entier positif `k`.
La puissance d'une sous-séquence est définie comme la différence absolue minimale entre deux éléments quelconques de la sous-séquence.
Retournez la somme des puissances de toutes les sous-séquences de `nums` qui ont une longueur égale à `k`.
Puisque la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4], k = 3
Sortie : 4
Explication :
Il y a 4 sous-séquences dans `nums` de longueur 3 : [1,2,3], [1,3,4], [1,2,4], et [2,3,4]. La somme des puissances est |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Exemple 2 :

Entrée : nums = [2,2], k = 2
Sortie : 0
Explication :
La seule sous-séquence de `nums` de longueur 2 est [2,2]. La somme des puissances est |2 - 2| = 0.

Exemple 3 :

Entrée : nums = [4,3,-1], k = 2
Sortie : 10
Explication :
Il y a 3 sous-séquences dans `nums` de longueur 2 : [4,3], [4,-1], et [3,-1]. La somme des puissances est |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Contraintes :

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

On vous donne un tableau d'entiers nums de longueur n et un entier positif k.
La puissance d'une sous-séquence est définie comme la différence absolue minimale entre deux éléments quelconques de la sous-séquence.
Renvoie la somme des puissances de toutes les sous-séquences de nums dont la longueur est égale à k.
Étant donné que la réponse peut être grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4], k = 3
Sortie : 4
Explication :
Il y a 4 sous-séquences dans nums dont la longueur est 3 : [1,2,3], [1,3,4], [1,2,4] et [2,3,4]. La somme des puissances est |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Exemple 2 :

Entrée : nums = [2,2], k = 2
Sortie : 0
Explication :
La seule sous-séquence dans nums qui a une longueur de 2 est [2,2]. La somme des puissances est |2 - 2| = 0.

Exemple 3 :

Entrée : nums = [4,3,-1], k = 2
Sortie : 10
Explication :
Il y a 3 sous-séquences dans nums qui ont une longueur de 2 : [4,3], [4,-1] et [3,-1]. La somme des puissances est |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Contraintes :

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n


On vous donne une chaîne de caractères s. Le score d'une chaîne est défini comme la somme des différences absolues entre les valeurs ASCII des caractères adjacents.
Retournez le score de s.

Exemple 1 :

Entrée : s = "hello"
Sortie : 13
Explication :
Les valeurs ASCII des caractères dans s sont : 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Donc, le score de s serait |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Exemple 2 :

Entrée : s = "zaz"
Sortie : 50
Explication :
Les valeurs ASCII des caractères dans s sont : 'z' = 122, 'a' = 97. Donc, le score de s serait |122 - 97| + |97 - 122| = 25 + 25 = 50.

Contraintes :

2 <= s.length <= 100
s consiste uniquement en lettres minuscules anglaises.

On vous donne une chaîne s. Le score d'une chaîne est défini comme la somme de la différence absolue entre les valeurs ASCII des caractères adjacents.
Retournez le score de l's.

Exemple 1:

Entrée: s = "hello"
Sortie: 13
Explication:
Les valeurs ASCII des caractères en s sont: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Ainsi, le score de S serait | 104 - 101 | + | 101 - 108 | + | 108 - 108 | + | 108 - 111 | = 3 + 7 + 0 + 3 = 13.

Exemple 2:

Entrée: s = "zaz"
Sortie: 50
Explication:
Les valeurs ASCII des caractères en s sont: 'z' = 122, 'a' = 97. Donc, le score de s serait | 122 - 97 | + | 97 - 122 | = 25 + 25 = 50.

Contraintes:

2 <= s.Length <= 100
s se compose uniquement de lettres anglaises minuscules.


On vous donne un tableau d'entiers positifs nums.
Renvoie le nombre de sous-tableaux de nums, où le premier et le dernier élément du sous-tableau sont égaux au plus grand élément du sous-tableau.

Exemple 1 :

Entrée : nums = [1,4,3,3,2]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [1,4,3,3,2], dont le plus grand élément est 1. Le premier élément est 1 et le dernier élément est également 1.
sous-tableau [1,4,3,3,2], dont le plus grand élément est 4. Le premier élément est 4 et le dernier élément est également 4.
sous-tableau [1,4,3,3,2], dont le plus grand élément est 3. Le premier élément est 3 et le dernier élément est également 3.
sous-tableau [1,4,3,3,2], dont le plus grand élément est 3. Le premier élément est 3 et le dernier élément est également 3.
sous-tableau [1,4,3,3,2], dont le plus grand élément est 2. Le premier élément est 2 et le dernier élément est aussi 2.
sous-tableau [1,4,3,3,2], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.

Nous renvoyons donc 6.

Exemple 2 :

Entrée : nums = [3,3,3]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier L'élément est 3 et le dernier élément est également 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est également 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est également 3.

Nous renvoyons donc 6.

Exemple 3 :

Entrée : nums = [1]
Sortie : 1
Explication :
Il existe un seul sous-tableau de nums qui est [1], avec son plus grand élément 1. Le premier élément est 1 et le dernier élément est également 1.
Nous renvoyons donc 1.

Contraintes :

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

Vous avez un tableau d'entiers positifs nums.
Retournez le nombre de sous-tableaux de nums, où le premier et le dernier élément du sous-tableau sont égaux au plus grand élément du sous-tableau.

Exemple 1 :

Entrée : nums = [1,4,3,3,2]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [1,4,3,3,2], avec son plus grand élément 1. Le premier élément est 1 et le dernier élément est aussi 1.
sous-tableau [1,4,3,3,2], avec son plus grand élément 4. Le premier élément est 4 et le dernier élément est aussi 4.
sous-tableau [1,4,3,3,2], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [1,4,3,3,2], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [1,4,3,3,2], avec son plus grand élément 2. Le premier élément est 2 et le dernier élément est aussi 2.
sous-tableau [1,4,3,3,2], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.

Ainsi, nous retournons 6.

Exemple 2 :

Entrée : nums = [3,3,3]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.

Ainsi, nous retournons 6.

Exemple 3 :

Entrée : nums = [1]
Sortie : 1
Explication :
Il y a un seul sous-tableau de nums qui est [1], avec son plus grand élément 1. Le premier élément est 1 et le dernier élément est aussi 1.
Ainsi, nous retournons 1.

Contraintes :

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

On vous donne un tableau d'entiers positifs nums.
Retournez le nombre de sous-tableaux de nums, où le premier et le dernier élément du sous-tableau sont égaux au plus grand élément du sous-tableau.

Exemple 1 :

Entrée : nums = [1,4,3,3,2]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 1. Le premier élément est 1 et le dernier élément est aussi 1.
sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 4. Le premier élément est 4 et le dernier élément est aussi 4.
sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 2. Le premier élément est 2 et le dernier élément est aussi 2.
sous-tableau [1,4,3,3,2], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.

Ainsi, nous retournons 6.

Exemple 2 :

Entrée : nums = [3,3,3]
Sortie : 6
Explication :
Il y a 6 sous-tableaux dont le premier et le dernier élément sont égaux au plus grand élément du sous-tableau :

sous-tableau [3,3,3], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément 3. Le premier élément est 3 et le dernier élément est aussi 3.
sous-tableau [3,3,3], avec son plus grand élément égal à 3. Le premier élément est 3 et le dernier élément est aussi 3.

Ainsi, nous retournons 6.

Exemple 3 :

Entrée : nums = [1]
Sortie : 1
Explication :
Il y a un seul sous-tableau de nums qui est [1], avec son plus grand élément égal à 1. Le premier élément est 1 et le dernier élément est aussi 1.
Ainsi, nous retournons 1.

Contraintes :

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


On vous donne une chaîne de caractères word. Une lettre est dite spéciale si elle apparaît à la fois en minuscule et en majuscule dans word.
Retournez le nombre de lettres spéciales dans word.

Exemple 1 :

Input: word = "aaAbcBC"
Output: 3
Explication :
Les caractères spéciaux dans word sont 'a', 'b' et 'c'.

Exemple 2 :

Input: word = "abc"
Output: 0
Explication :
Aucun caractère dans word n'apparaît en majuscule.

Exemple 3 :

Input: word = "abBCab"
Output: 1
Explication :
Le seul caractère spécial dans word est 'b'.

Contraintes :

1 <= word.length <= 50
word est constitué uniquement de lettres anglaises minuscules et majuscules.

Vous avez une chaîne de caractères. Une lettre est appelée spéciale si elle apparaît à la fois en minuscules et en majuscules dans le mot.
Renvoyez le nombre de lettres spéciales dans le mot.

Exemple 1:

Entrée: word = "aaAbcBC"
Sortie: 3
Explication:
Les caractères spéciaux dans le mot sont 'a', 'b' et 'c'.

Exemple 2:

Entrée: word = "abc"
Sortie: 0
Explication:
Aucun caractère du mot n'apparaît en majuscules.

Exemple 3:

Entrée: word = "abBCab"
Sortie: 1
Explication:
Le seul caractère spécial du mot est 'b'.

Contraintes:

1 <= word.length <= 50
Le mot se compose uniquement de lettres anglaises en minuscules et majuscules.

On vous donne une chaîne de caractères word. Une lettre est dite spéciale si elle apparaît à la fois en minuscule et en majuscule dans word.
Retournez le nombre de lettres spéciales dans word.

Exemple 1 :

Entrée: word = "aaAbcBC"
Sortie: 3
Explication :
Les caractères spéciaux dans word sont 'a', 'b' et 'c'.

Exemple 2 :

Entrée: word = "abc"
Sortie: 0
Explication :
Aucun caractère dans word n'apparaît en majuscule.

Exemple 3 :

Entrée: word = "abBCab"
Sortie: 1
Explication : Le seul caractère spécial dans word est 'b'.

Contraintes :

1 <= word.length <= 50
word est constitué uniquement de lettres anglaises minuscules et majuscules.


On considère deux tableaux de même longueur, nums1 et nums2.
Chaque élément dans nums1 a été augmenté (ou diminué dans le cas d'un nombre négatif) par un entier, représenté par la variable x.
En conséquence, nums1 devient égal à nums2. Deux tableaux sont considérés comme égaux lorsqu'ils contiennent les mêmes entiers avec les mêmes fréquences.
Retournez l'entier x.

Exemple 1 :

Entrée : nums1 = [2,6,4], nums2 = [9,7,5]
Sortie : 3
Explication :
L'entier ajouté à chaque élément de nums1 est 3.

Exemple 2 :

Entrée : nums1 = [10], nums2 = [5]
Sortie : -5
Explication :
L'entier ajouté à chaque élément de nums1 est -5.

Exemple 3 :

Entrée : nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Sortie : 0
Explication :
L'entier ajouté à chaque élément de nums1 est 0.

Contraintes :

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Les cas de test sont générés de manière à ce qu'il existe un entier x tel que nums1 puisse devenir égal à nums2 en ajoutant x à chaque élément de nums1.

On vous donne deux tableaux de longueur égale, nums1 et nums2.
Chaque élément de nums1 a été augmenté (ou diminué dans le cas d’un négatif) d’un entier, représenté par la variable x.
Par conséquent, nums1 devient égal à nums2. Deux tableaux sont considérés comme égaux lorsqu’ils contiennent les mêmes entiers avec les mêmes fréquences.
Renvoie l’entier x.

Exemple 1 :

Entrée : nums1 = [2,6,4], nums2 = [9,7,5]
Sortie : 3
Explication:
L’entier ajouté à chaque élément de nums1 est 3.

Exemple 2 :

Entrée : nums1 = [10], nums2 = [5]
Sortie : -5
Explication:
L’entier ajouté à chaque élément de nums1 est -5.

Exemple 3 :

Entrée : nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Sortie : 0
Explication:
L’entier ajouté à chaque élément de nums1 est 0.

Contraintes:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Les cas de test sont générés de telle sorte qu’il existe un entier x tel que nums1 puisse devenir égal à nums2 en ajoutant x à chaque élément de nums1.

Vous avez deux tableaux de même longueur, nums1 et nums2.
Chaque élément dans nums1 a été augmenté (ou diminué dans le cas de négatif) par un entier, représenté par la variable x.
En conséquence, nums1 devient égal à nums2. Deux tableaux sont considérés comme égaux lorsqu'ils contiennent les mêmes entiers avec les mêmes fréquences.
Retournez l'entier x.

Exemple 1 :

Entrée : nums1 = [2,6,4], nums2 = [9,7,5]
Sortie : 3
Explication :
L'entier ajouté à chaque élément de nums1 est 3.

Exemple 2 :

Entrée : nums1 = [10], nums2 = [5]
Sortie : -5
Explication :
L'entier ajouté à chaque élément de nums1 est -5.

Exemple 3 :

Entrée : nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Sortie : 0
Explication :
L'entier ajouté à chaque élément de nums1 est 0.

Contraintes :

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Les cas de test sont générés de manière à ce qu'il existe un entier x tel que nums1 puisse devenir égal à nums2 en ajoutant x à chaque élément de nums1.


On vous donne deux entiers n et x. Vous devez construire un tableau d'entiers positifs nums de taille n où pour chaque 0 <= i < n - 1, nums[i + 1] est supérieur à nums[i], et le résultat de l'opération AND bit à bit entre tous les éléments de nums est x.
Retournez la valeur minimale possible de nums[n - 1].

Exemple 1 :

Entrée : n = 3, x = 4
Sortie : 6
Explication :
nums peut être [4,5,6] et son dernier élément est 6.

Exemple 2 :

Entrée : n = 2, x = 7
Sortie : 15
Explication :
nums peut être [7,15] et son dernier élément est 15.

Contraintes :

1 <= n, x <= 10^8

On vous donne deux entiers n et x. Vous devez construire un tableau d’entiers positifs nombres de taille n où pour chaque 0 <= i < n - 1, nums[i + 1] est supérieur à nums[i], et le résultat de l’opération AND au niveau du bit entre tous les éléments de nums est x.
Renvoie la valeur minimale possible de nums[n - 1].

Exemple 1 :

Entrée : n = 3, x = 4
Sortie : 6
Explication:
nums peut être [4,5,6] et son dernier élément est 6.

Exemple 2 :

Entrée : n = 2, x = 7
Sortie : 15
Explication:
nums peut être [7,15] et son dernier élément est 15.

Contraintes:

1 <= n, x <= 10^8

Vous avez deux entiers n et x. Vous devez construire un tableau d'entiers positifs nums de taille n où pour chaque 0 <= i < n - 1, nums[i + 1] est supérieur à nums[i], et le résultat de l'opération AND bit à bit entre tous les éléments de nums est x.
Retournez la valeur minimale possible de nums[n - 1].

Exemple 1 :

Entrée : n = 3, x = 4
Sortie : 6
Explication :
nums peut être [4,5,6] et son dernier élément est 6.

Exemple 2 :

Entrée : n = 2, x = 7
Sortie : 15
Explication :
nums peut être [7,15] et son dernier élément est 15.

Contraintes :

1 <= n, x <= 10^8


On vous donne un tableau d'entiers nums. Le tableau d'unicité de nums est le tableau trié qui contient le nombre d’éléments distincts de tous les sous-tableaux de nums. En d'autres termes, c'est un tableau trié composé de distinct(nums[i..j]), pour tout 0 <= i <= j < nums.length.
Ici, distinct(nums[i..j]) désigne le nombre d'éléments distincts dans le sous-tableau qui commence à l'indice i et se termine à l'indice j.
Retournez la médiane du tableau d'unicité de nums.
Notez que la médiane d'un tableau est définie comme l'élément central du tableau lorsqu'il est trié par ordre non décroissant. S'il y a deux choix pour une médiane, on prend la plus petite des deux valeurs.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 1
Explication :
Le tableau d'unicité de nums est [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] qui est égal à [1, 1, 1, 2, 2, 3]. Le tableau d'unicité a une médiane de 1. Par conséquent, la réponse est 1.

Exemple 2 :

Entrée : nums = [3,4,3,4,5]
Sortie : 2
Explication :
Le tableau d'unicité de nums est [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Le tableau d'unicité a une médiane de 2. Par conséquent, la réponse est 2.

Exemple 3 :

Entrée : nums = [4,3,5,4]
Sortie : 2
Explication :
Le tableau d'unicité de nums est [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Le tableau d'unicité a une médiane de 2. Par conséquent, la réponse est 2.

Contraintes :

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

On vous donne un tableau d'entiers `nums`. Le tableau de singularité de `nums` est le tableau trié qui contient le nombre d’éléments distincts de tous les sous-tableaux de `nums`. En d'autres termes, c'est un tableau trié composé de `distinct(nums[i..j])`, pour tout `0 <= i <= j < nums.length`.
Ici, `distinct(nums[i..j])` désigne le nombre d'éléments distincts dans le sous-tableau qui commence à l'indice `i` et se termine à l'indice `j`.
Retournez la médiane du tableau de singularité de `nums`.
Notez que la médiane d'un tableau est définie comme l'élément central du tableau lorsqu'il est trié par ordre non décroissant. S'il y a deux choix pour une médiane, on prend la plus petite des deux valeurs.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 1
Explication :
Le tableau de singularité de `nums` est [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] qui est égal à [1, 1, 1, 2, 2, 3]. Le tableau de singularité a une médiane de 1. Par conséquent, la réponse est 1.

Exemple 2 :

Entrée : nums = [3,4,3,4,5]
Sortie : 2
Explication :
Le tableau de singularité de `nums` est [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Le tableau de singularité a une médiane de 2. Par conséquent, la réponse est 2.

Exemple 3 :

Entrée : nums = [4,3,5,4]
Sortie : 2
Explication :
Le tableau de singularité de `nums` est [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Le tableau de singularité a une médiane de 2. Par conséquent, la réponse est 2.

Contraintes :

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

Vous êtes donné un tableau d'entiers nums. Le tableau d'unicité de nums est le tableau trié qui contient le nombre d'éléments distincts de tous les sous-tableaux de nums. En d'autres termes, c'est un tableau trié composé de distinct (nums[i..j]), pour tous les 0 <= i <= j <nums.length.
Ici, distinct(nums[i..j]) désigne le nombre d'éléments distincts dans le sous-tableau qui commence à l'index i et se termine à l'index j.
Retournez la médiane du réseau d'unicité de nums.
Notez que la médiane d'un tableau est définie comme l'élément central du tableau lorsqu'il est trié par ordre non décroissant. S'il y a deux choix pour une médiane, le plus petit des deux valeurs est choisi.

Exemple 1:

Entrée: nums = [1,2,3]
Sortie: 1
Explication:
Le tableau d'unicité de nums est [distinct (nums[0..0]), distinct (nums[1..1]), distinct (nums[2..2]), distinct (nums[0..1]) , distinct (nums[1..2]), distinct (nums[0..2])] qui est égal à [1, 1, 1, 2, 2, 3]. Le tableau d'unicité a une médiane de 1. Par conséquent, la réponse est 1.

Exemple 2:

Entrée: nums = [3,4,3,4,5]
Sortie: 2
Explication:
Le réseau d'unicité de nums est [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Le réseau d'unicité a une médiane de 2. Par conséquent, la réponse est 2.

Exemple 3:

Entrée: nums = [4,3,5,4]
Sortie: 2
Explication:
Le réseau d'unicité de nums est [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Le réseau d'unicité a une médiane de 2. Par conséquent, la réponse est 2.

Contraintes:

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


Un mot est considéré comme valide si :

Il contient au moins 3 caractères.
Il ne contient que des chiffres (0 à 9) et des lettres anglaises (majuscules et minuscules).
Il comprend au moins une voyelle.
Il comprend au moins une consonne.

On vous donne une chaîne de caractères word.
Renvoie true si le mot est valide, sinon, renvoie false.
Remarques :

'a', 'e', 'i', 'o', 'u' et leurs majuscules sont des voyelles.
Une consonne est une lettre anglaise qui n'est pas une voyelle.

Exemple 1 :

Entrée : word = "234Adas"
Sortie : true
Explication :
Ce mot satisfait aux conditions.

Exemple 2 :

Entrée : word = "b3"
Sortie : false
Explication :
La longueur de ce mot est inférieure à 3 et ne contient pas de voyelle.

Exemple 3 :

Entrée : word = "a3$e"
Sortie : false
Explication :
Ce mot contient un caractère « $ » et n'a pas de consonne.

Contraintes :

1 <= word.length <= 20
Le mot est composé de lettres majuscules et minuscules anglaises, de chiffres, de '@', de '#' et de '$'.

Un mot est considéré comme valide si :

Il contient au minimum 3 caractères.
Il contient uniquement des chiffres (0-9) et des lettres anglaises (majuscules et minuscules).
Il inclut au moins une voyelle.
Il inclut au moins une consonne.

On vous donne une chaîne de caractères word.
Retournez true si word est valide, sinon, retournez false.
Remarques :

'a', 'e', 'i', 'o', 'u', et leurs majuscules sont des voyelles.
Une consonne est une lettre anglaise qui n'est pas une voyelle.

Exemple 1 :

Entrée : word = "234Adas"
Sortie : true
Explication :
Ce mot satisfait les conditions.

Exemple 2 :

Entrée : word = "b3"
Sortie : false
Explication :
La longueur de ce mot est inférieure à 3, et il n'a pas de voyelle.

Exemple 3 :

Entrée : word = "a3$e"
Sortie : false
Explication :
Ce mot contient un caractère '$' et n'a pas de consonne.

Contraintes :

1 <= word.length <= 20
word se compose de lettres anglaises majuscules et minuscules, de chiffres, de '@', '#', et '$'.


On vous donne une chaîne de caractères `word` de taille `n`, et un entier `k` tel que `k` divise `n`.
Dans une opération, vous pouvez choisir deux indices `i` et `j`, qui sont divisibles par `k`, puis remplacer la sous-chaîne de longueur `k` commençant à `i` par la sous-chaîne de longueur `k` commençant à `j`. C'est-à-dire, remplacer la sous-chaîne `word[i..i + k - 1]` par la sous-chaîne `word[j..j + k - 1]`.
Retournez le nombre minimum d'opérations nécessaires pour rendre `word` k-périodique.
On dit que `word` est k-périodique s'il existe une chaîne de caractères `s` de longueur `k` telle que `word` peut être obtenue en concaténant `s` un nombre arbitraire de fois. Par exemple, si `word == "ababab"`, alors `word` est 2-périodique pour `s = "ab"`.

Exemple 1 :

Entrée : `word = "leetcodeleet"`, `k = 4`
Sortie : 1
Explication :
On peut obtenir une chaîne 4-périodique en choisissant `i = 4` et `j = 0`. Après cette opération, `word` devient égale à "leetleetleet".

Exemple 2 :

Entrée : `word = "leetcoleet"`, `k = 2`
Sortie : 3
Explication :
On peut obtenir une chaîne 2-périodique en appliquant les opérations dans le tableau ci-dessous.

```
i   j   word

0   2   etetcoleet

4   0   etetetleet

6   0   etetetetet
```

Contraintes :

1 <= n == `word.length` <= 10^5
1 <= k <= `word.length`
k divise `word.length`.
`word` consiste uniquement en lettres minuscules anglaises.

Vous avez une chaîne de caractères word de taille n et un entier k tel que k divise n.
Dans une opération, vous pouvez choisir deux indices i et j, qui sont divisibles par k, puis remplacer la sous-chaîne de longueur k commençant à i par la sous-chaîne de longueur k commençant à j. C'est-à-dire, remplacer la sous-chaîne word[i..i + k - 1] par la sous-chaîne word[j..j + k - 1].
Retournez le nombre minimum d'opérations nécessaires pour rendre word k-périodique.
On dit que word est k-périodique s'il existe une chaîne de caractères s de longueur k telle que word peut être obtenue en concaténant s un nombre arbitraire de fois. Par exemple, si word == "ababab", alors word est 2-périodique pour s = "ab".

Exemple 1 :

Entrée : word = "leetcodeleet", k = 4
Sortie : 1
Explication :
On peut obtenir une chaîne 4-périodique en choisissant i = 4 et j = 0. Après cette opération, word devient égale à "leetleetleet".

Exemple 2 :

Entrée : word = "leetcoleet", k = 2
Sortie : 3
Explication :
On peut obtenir une chaîne 2-périodique en appliquant les opérations dans le tableau ci-dessous.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Contraintes :

1 <= n == word.length <= 10^5
1 <= k <= word.length
k divise word.length.
word consiste uniquement en lettres minuscules anglaises.

On vous donne une chaîne word de taille n et un entier k tel que k divise n.
En une seule opération, vous pouvez choisir deux indices i et j quelconques, divisibles par k, puis remplacer la sous-chaîne de longueur k commençant à i par la sous-chaîne de longueur k commençant à j. Autrement dit, remplacez la sous-chaîne word[i..i + k - 1] par la sous-chaîne word[j..j + k - 1].
Renvoie le nombre minimum d'opérations requises pour rendre word k-périodique.
Nous disons que word est k-périodique s'il existe une chaîne s de longueur k telle que word puisse être obtenue en concaténant s un nombre arbitraire de fois. Par exemple, si word == “ababab”, alors word est 2-périodique pour s = “ab”.

Exemple 1 :

Entrée : word = "leetcodeleet", k = 4
Sortie : 1
Explication :
Nous pouvons obtenir une chaîne à 4 périodes en choisissant i = 4 et j = 0. Après cette opération, word devient égal à "leetleetleet".

Exemple 2 :

Entrée : word = "leetcoleet", k = 2
Sortie : 3
Explication :
Nous pouvons obtenir une chaîne à 2 périodes en appliquant les opérations du tableau ci-dessous.

i
j
word

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Constraints:

1 <= n == word.length <= 10^5
1 <= k <= word.length
k divise word.length.
word se compose uniquement de lettres minuscules anglaises.


On vous donne une chaîne de caractères s, qui est connue pour être une concaténation d'anagrammes d'une certaine chaîne t. Retournez la longueur minimale possible de la chaîne t.
Un anagramme est formé en réarrangeant les lettres d'une chaîne. Par exemple, "aab", "aba" et "baa" sont des anagrammes de "aab".

Exemple 1 :

Entrée : s = "abba"
Sortie : 2
Explication :
Une chaîne t possible pourrait être "ba".

Exemple 2 :

Entrée : s = "cdef"
Sortie : 4
Explication :
Une chaîne t possible pourrait être "cdef", notez que t peut être égal à s.

Contraintes :

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

On vous donne une chaîne s, qui est connue pour être une concaténation d'anagrammes d'une chaîne t.
Renvoie la longueur minimale possible de la chaîne t.
Une anagramme est formée en réorganisant les lettres d'une chaîne. Par exemple, "aab", "aba" et "baa" sont des anagrammes de "aab".

Exemple 1 :

Entrée : s = "abba"
Sortie : 2
Explication :
Une chaîne t possible pourrait être "ba".

Exemple 2 :

Entrée : s = "cdef"
Sortie : 4
Explication :
Une chaîne t possible pourrait être "cdef", notez que t peut être égal à s.

Contraintes :

1 <= s.length <= 10^5
s se compose uniquement de lettres minuscules anglaises.