On vous donne deux chaînes binaires `s1` et `s2` indexées à partir de 0, toutes deux de longueur `n`, et un entier positif `x`.
Vous pouvez effectuer l'une des opérations suivantes sur la chaîne `s1` un nombre quelconque de fois :

Choisir deux indices `i` et `j`, et inverser à la fois `s1[i]` et `s1[j]`. Le coût de cette opération est `x`.
Choisir un indice `i` tel que `i < n - 1` et inverser à la fois `s1[i]` et `s1[i + 1]`. Le coût de cette opération est 1.

Retournez le coût minimum nécessaire pour rendre les chaînes `s1` et `s2` égales, ou retournez -1 s'il est impossible de le faire.
Notez qu'inverser un caractère signifie le changer de 0 à 1 ou de 1 à 0.

Exemple 1 :

Entrée : s1 = "1100011000", s2 = "0101001010", x = 2
Sortie : 4
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisir `i = 3` et appliquer la seconde opération. La chaîne résultante est `s1 = "1101111000"`.
- Choisir `i = 4` et appliquer la seconde opération. La chaîne résultante est `s1 = "1101001000"`.
- Choisir `i = 0` et `j = 8` et appliquer la première opération. La chaîne résultante est `s1 = "0101001010" = s2`.
Le coût total est 1 + 1 + 2 = 4. Il peut être démontré que c'est le coût minimum possible.

Exemple 2 :

Entrée : s1 = "10110", s2 = "00011", x = 4
Sortie : -1
Explication : Il n'est pas possible de rendre les deux chaînes égales.

Contraintes :

n == s1.length == s2.length
1 <= n, x <= 500
s1 et s2 ne contiennent que les caractères '0' et '1'.

On vous donne deux chaînes binaires s1 et s2 indexées à partir de 0, toutes deux de longueur n, et un entier positif x.
Vous pouvez effectuer l'une des opérations suivantes sur la chaîne s1 un nombre quelconque de fois :

Choisissez deux indices i et j, et inversez à la fois s1[i] et s1[j]. Le coût de cette opération est x.
Choisissez un indice i tel que i < n - 1 et inversez à la fois s1[i] et s1[i + 1]. Le coût de cette opération est 1.

Retournez le coût minimum nécessaire pour rendre les chaînes s1 et s2 égales, ou retournez -1 s'il est impossible de le faire.
Notez qu'inverser un caractère signifie le changer de 0 à 1 ou inversement.

Exemple 1 :

Entrée : s1 = "1100011000", s2 = "0101001010", x = 2
Sortie : 4
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisir `i = 3` et appliquer la seconde opération. La chaîne résultante est `s1 = "1101111000"`.
- Choisir `i = 4` et appliquer la seconde opération. La chaîne résultante est `s1 = "1101001000"`.
- Choisir `i = 0` et `j = 8` et appliquer la première opération. La chaîne résultante est `s1 = "0101001010" = s2`.
Le coût total est 1 + 1 + 2 = 4. Il peut être démontré que c'est le coût minimum possible.

Exemple 2 :

Entrée : s1 = "10110", s2 = "00011", x = 4
Sortie : -1
Explication : Il n'est pas possible de rendre les deux chaînes égales.

Contraintes :

n == s1.length == s2.length
1 <= n, x <= 500
s1 et s2 ne contiennent que les caractères '0' et '1'.

On vous donne deux chaînes binaires indexées 0 s1 et s2, toutes deux de longueur n, et un entier positif x.
Vous pouvez effectuer l'une des opérations suivantes sur la chaîne s1 autant de fois que vous le souhaitez :

Choisissez deux indices i et j, et inversez à la fois s1[i] et s1[j]. Le coût de cette opération est x.
Choisissez un indice i tel que i < n - 1 et inversez à la fois s1[i] et s1[i + 1]. Le coût de cette opération est 1.

Renvoie le coût minimum nécessaire pour rendre les chaînes s1 et s2 égales, ou renvoie -1 si c'est impossible.
Notez que l'inversion d'un caractère signifie le faire passer de 0 à 1 ou vice-versa.

Exemple 1 :

Entrée : s1 = "1100011000", s2 = "0101001010", x = 2
Sortie : 4
Explication : Nous pouvons effectuer les opérations suivantes :
- Choisir i = 3 et appliquer la deuxième opération. La chaîne résultante est s1 = "1101111000".
- Choisir i = 4 et appliquer la deuxième opération. La chaîne résultante est s1 = "1101001000".
- Choisir i = 0 et j = 8 et appliquer la première opération. La chaîne résultante est s1 = "0101001010" = s2.
Le coût total est de 1 + 1 + 2 = 4. On peut montrer qu'il s'agit du coût minimum possible.

Exemple 2 :

Entrée : s1 = "10110", s2 = "00011", x = 4
Sortie : -1
Explication : Il n'est pas possible de rendre les deux chaînes égales.

Contraintes :

n == s1.length == s2.length
1 <= n, x <= 500
s1 et s2 ne sont constitués que des caractères '0' et '1'.


Vous disposez d'un tableau 2D d'entiers indexé à 0, nums, représentant les coordonnées des voitures garées sur une ligne numérique. Pour tout indice i, nums[i] = [start_i, end_i] où start_i est le point de départ de la i^ème voiture et end_i est le point de fin de la i^ème voiture.
Renvoyez le nombre de points entiers sur la ligne qui sont couverts par n'importe quelle partie d'une voiture.

Exemple 1 :

Entrée : nums = [[3,6],[1,5],[4,7]]
Sortie : 7
Explication : Tous les points de 1 à 7 intersectent au moins une voiture, donc la réponse est 7.

Exemple 2 :

Entrée : nums = [[1,3],[5,8]]
Sortie : 7
Explication : Les points intersectant au moins une voiture sont 1, 2, 3, 5, 6, 7, 8. Il y a un total de 7 points, donc la réponse est 7.

Contraintes :

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

On vous donne un tableau d'entiers 2D indexé 0, nums, représentant les coordonnées des voitures stationnant sur une ligne numérique. Pour tout indice i, nums[i] = [start_i, end_i] où start_i est le point de départ de la i^ème voiture et end_i est le point d'arrivée de la i^ème voiture.
Renvoie le nombre de points entiers de la ligne qui sont couverts par une partie quelconque d'une voiture.

Exemple 1 :

Entrée : nums = [[3,6],[1,5],[4,7]]
Sortie : 7
Explication : Tous les points de 1 à 7 croisent au moins une voiture, la réponse est donc 7.

Exemple 2 :

Entrée : nums = [[1,3],[5,8]]
Sortie : 7
Explication : Les points qui croisent au moins une voiture sont 1, 2, 3, 5, 6, 7, 8. Il y a un total de 7 points, donc la réponse est 7.

Contraintes :

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

Vous disposez d'un tableau 2D d'entiers indexé à partir de 0, nums, représentant les coordonnées des voitures garées sur une droite numérique. Pour tout indice i, nums[i] = [start_i, end_i] où start_i est le point de départ de la i^ème voiture et end_i est le point d'arrivée de la i^ème voiture.
Retournez le nombre de points entiers sur la droite qui sont couverts par n'importe quelle partie d'une voiture.

Exemple 1 :

Entrée : nums = [[3,6],[1,5],[4,7]]
Sortie : 7
Explication : Tous les points de 1 à 7 sont couverts par au moins une voiture, donc la réponse est 7.

Exemple 2 :

Entrée : nums = [[1,3],[5,8]]
Sortie : 7
Explication : Les points qui sont couverts par au moins une voiture sont 1, 2, 3, 5, 6, 7, 8. Il y a un total de 7 points, donc la réponse est 7.

Contraintes :

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100


Soit un tableau nums d'entiers positifs et un entier k.
Lors d'une opération, vous pouvez retirer le dernier élément du tableau et l'ajouter à votre collection.
Retournez le nombre minimum d'opérations nécessaires pour collecter les éléments 1, 2, ..., k.

Exemple 1 :

Entrée : nums = [3,1,5,4,2], k = 2
Sortie : 4
Explication : Après 4 opérations, nous collectons les éléments 2, 4, 5 et 1, dans cet ordre. Notre collection contient les éléments 1 et 2. Par conséquent, la réponse est 4.

Exemple 2 :

Entrée : nums = [3,1,5,4,2], k = 5
Sortie : 5
Explication : Après 5 opérations, nous collectons les éléments 2, 4, 5, 1 et 3, dans cet ordre. Notre collection contient les éléments de 1 à 5. Par conséquent, la réponse est 5.

Exemple 3 :

Entrée : nums = [3,2,5,3,1], k = 3
Sortie : 4
Explication : Après 4 opérations, nous collectons les éléments 1, 3, 5 et 2, dans cet ordre. Notre collection contient les éléments de 1 à 3. Par conséquent, la réponse est 4.

Contraintes :

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
L'entrée est générée de sorte que vous puissiez collecter les éléments 1, 2, ..., k.

Vous avez un tableau `nums` d'entiers positifs et un entier `k`.
Dans une opération, vous pouvez retirer le dernier élément du tableau et l'ajouter à votre collection.
Retournez le nombre minimum d'opérations nécessaires pour collecter les éléments 1, 2, ..., k.

Exemple 1 :

Entrée : nums = [3,1,5,4,2], k = 2
Sortie : 4
Explication : Après 4 opérations, nous collectons les éléments 2, 4, 5 et 1, dans cet ordre. Notre collection contient les éléments 1 et 2. Par conséquent, la réponse est 4.

Exemple 2 :

Entrée : nums = [3,1,5,4,2], k = 5
Sortie : 5
Explication : Après 5 opérations, nous collectons les éléments 2, 4, 5, 1 et 3, dans cet ordre. Notre collection contient les éléments de 1 à 5. Par conséquent, la réponse est 5.

Exemple 3 :

Entrée : nums = [3,2,5,3,1], k = 3
Sortie : 4
Explication : Après 4 opérations, nous collectons les éléments 1, 3, 5 et 2, dans cet ordre. Notre collection contient les éléments de 1 à 3. Par conséquent, la réponse est 4.

Contraintes :

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
L'entrée est générée de sorte que vous puissiez collecter les éléments 1, 2, ..., k.


On vous donne un tableau nums de longueur n, indexé 0, contenant des entiers positifs distincts. Retournez le nombre minimum de décalages vers la droite requis pour trier nums et -1 si ce n'est pas possible.
Un décalage vers la droite est défini comme le déplacement de l'élément à l'indice i à l'indice (i + 1) % n, pour tous les indices.

Exemple 1 :

Entrée : nums = [3,4,5,1,2]
Sortie : 2
Explication :
Après le premier décalage vers la droite, nums = [2,3,4,5,1].
Après le deuxième décalage vers la droite, nums = [1,2,3,4,5].
Maintenant, nums est trié ; la réponse est donc 2.

Exemple 2 :

Entrée : nums = [1,3,5]
Sortie : 0
Explication : nums est déjà trié, la réponse est donc 0.

Exemple 3 :

Entrée : nums = [2,1,4]
Sortie : -1
Explication : Il est impossible de trier le tableau en utilisant des décalages vers la droite.

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contient des entiers distincts.

Vous avez un tableau nums de longueur n, indexé à partir de 0, contenant des entiers positifs distincts. Retournez le nombre minimum de décalages vers la droite nécessaires pour trier nums et -1 si cela n'est pas possible.
Un décalage vers la droite est défini comme le déplacement de l'élément à l'indice i vers l'indice (i + 1) % n, pour tous les indices.

Exemple 1 :

Entrée : nums = [3,4,5,1,2]
Sortie : 2
Explication :
Après le premier décalage à droite, nums = [2,3,4,5,1].
Après le second décalage à droite, nums = [1,2,3,4,5].
Maintenant nums est trié ; par conséquent, la réponse est 2.

Exemple 2 :

Entrée : nums = [1,3,5]
Sortie : 0
Explication : nums est déjà trié, donc la réponse est 0.
Exemple 3 :

Entrée : nums = [2,1,4]
Sortie : -1
Explication : Il est impossible de trier le tableau en utilisant des décalages à droite.

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contient des entiers distincts.

Vous avez un tableau nums de longueur n, indexé à partir de 0, contenant des entiers positifs distincts. Renvoyez le nombre minimum de décalages vers la droite nécessaires pour trier nums et -1 si cela n'est pas possible. Un décalage vers la droite est défini comme le déplacement de l'élément à l'index i vers l'index (i + 1) % n, pour tous les indices.

Exemple 1 :

Entrée : nums = [3,4,5,1,2]
Sortie : 2
Explication :
Après le premier décalage à droite, nums = [2,3,4,5,1].
Après le second décalage à droite, nums = [1,2,3,4,5].
Maintenant nums est trié ; par conséquent, la réponse est 2.

Exemple 2 :

Entrée : nums = [1,3,5]
Sortie : 0
Explication : nums est déjà trié, donc la réponse est 0.

Exemple 3 :

Entrée : nums = [2,1,4]
Sortie : -1
Explication : Il est impossible de trier le tableau en utilisant des décalages à droite.

Contraintes :

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums contient des entiers distincts.


On vous donne une chaîne de caractères indexée 0 num représentant un entier non négatif.
En une seule opération, vous pouvez sélectionner n’importe quel chiffre de num et le supprimer. Notez que si vous supprimez tous les chiffres de num, num devient 0.
Renvoie le nombre minimum d’opérations requis pour rendre num spécial.
Un entier x est considéré comme spécial s’il est divisible par 25.

Exemple 1 :

Entrée : num = "2245047"
Sortie : 2
Explication : Supprimez les chiffres num[5] et num[6]. Le nombre résultant est « 22450 », ce qui est spécial puisqu’il est divisible par 25.
On peut montrer que 2 est le nombre minimum d’opérations nécessaires pour obtenir un numéro spécial.
Exemple 2 :

Entrée : num = "2908305"
Sortie : 3
Explication : Supprimez les chiffres num[3], num[4] et num[6]. Le nombre résultant est "2900" qui est spécial puisqu’il est divisible par 25.
On peut montrer que 3 est le nombre minimum d’opérations nécessaires pour obtenir un numéro spécial.
Exemple 3 :

Entrée : num = "10"
Sortie : 1
Explication : Supprimez le chiffre num[0]. Le nombre résultant est « 0 », ce qui est spécial puisqu’il est divisible par 25.
On peut montrer que 1 est le nombre minimum d’opérations nécessaires pour obtenir un numéro spécial.

Contraintes:

1 <= num.length <= 100
num uniquement se compose des chiffres '0' à '9'.
num ne contient pas de zéros non significatifs.

On donne une chaîne de caractères à index 0 num représentant un entier non négatif.
Dans une opération, vous pouvez choisir n'importe quel chiffre de num et le supprimer. Notez que si vous supprimez tous les chiffres de num, num devient 0.
Retournez le nombre minimum d'opérations nécessaires pour rendre num spécial.
Un entier x est considéré comme spécial s'il est divisible par 25.

Exemple 1 :

Entrée : num = "2245047"
Sortie : 2
Explication : Supprimez les chiffres num[5] et num[6]. Le nombre résultant est "22450" qui est spécial car divisible par 25.
Il peut être démontré que 2 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.
Exemple 2 :

Entrée : num = "2908305"
Sortie : 3
Explication : Supprimez les chiffres num[3], num[4], et num[6]. Le nombre résultant est "2900" qui est spécial car divisible par 25.
Il peut être démontré que 3 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.
Exemple 3 :

Entrée : num = "10"
Sortie : 1
Explication : Supprimez le chiffre num[0]. Le nombre résultant est "0" qui est spécial car divisible par 25.
Il peut être démontré que 1 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.

Contraintes :

1 <= num.length <= 100
num consiste uniquement en chiffres de '0' à '9'.
num ne contient pas de zéros en tête.

On vous donne une chaîne de caractères à index 0 num représentant un entier non négatif.
Dans une opération, vous pouvez choisir n'importe quel chiffre de num et le supprimer. Notez que si vous supprimez tous les chiffres de num, num devient 0.
Retournez le nombre minimum d'opérations nécessaires pour rendre num spécial.
Un entier x est considéré comme spécial s'il est divisible par 25.

Exemple 1 :

Input: num = "2245047"
Output: 2
Explication : Supprimez les chiffres num[5] et num[6]. Le nombre résultant est "22450" qui est spécial car divisible par 25.
Il peut être démontré que 2 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.

Exemple 2 :

Input: num = "2908305"
Output: 3
Explication : Supprimez les chiffres num[3], num[4], et num[6]. Le nombre résultant est "2900" qui est spécial car divisible par 25.
Il peut être démontré que 3 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.

Exemple 3 :

Input: num = "10"
Output: 1
Explication : Supprimez le chiffre num[0]. Le nombre résultant est "0" qui est spécial car divisible par 25.
Il peut être démontré que 1 est le nombre minimum d'opérations nécessaires pour obtenir un nombre spécial.

Contraintes :

1 <= num.length <= 100
num consiste uniquement en chiffres de '0' à '9'.
num ne contient pas de zéros en tête.


On vous donne un tableau nums indexé à partir de 1, composé de n entiers.
Un ensemble de nombres est complet si le produit de chaque paire de ses éléments est un carré parfait.
Pour un sous-ensemble de l'ensemble des indices {1, 2, ..., n} représenté comme {i_1, i_2, ..., i_k}, nous définissons la somme de ses éléments comme : nums[i_1] + nums[i_2] + ... + nums[i_k].
Retournez la somme maximale des éléments d'un sous-ensemble complet de l'ensemble des indices {1, 2, ..., n}.
Un carré parfait est un nombre pouvant être exprimé comme le produit d'un entier par lui-même.

Exemple 1 :

Input: nums = [8,7,3,5,7,2,4,9]
Output: 16
Explication : En dehors des sous-ensembles constitués d'un seul indice, il y a deux autres sous-ensembles complets d'indices : {1,4} et {2,8}.
La somme des éléments correspondant aux indices 1 et 4 est égale à nums[1] + nums[4] = 8 + 5 = 13.
La somme des éléments correspondant aux indices 2 et 8 est égale à nums[2] + nums[8] = 7 + 9 = 16.
Ainsi, la somme maximale des éléments d'un sous-ensemble complet d'indices est 16.

Exemple 2 :

Input: nums = [5,10,3,10,1,13,7,9,4]
Output: 19
Explication : En dehors des sous-ensembles constitués d'un seul indice, il y a quatre autres sous-ensembles complets d'indices : {1,4}, {1,9}, {2,8}, {4,9}, et {1,4,9}.
La somme des éléments correspondant aux indices 1 et 4 est égale à nums[1] + nums[4] = 5 + 10 = 15.
La somme des éléments correspondant aux indices 1 et 9 est égale à nums[1] + nums[9] = 5 + 4 = 9.
La somme des éléments correspondant aux indices 2 et 8 est égale à nums[2] + nums[8] = 10 + 9 = 19.
La somme des éléments correspondant aux indices 4 et 9 est égale à nums[4] + nums[9] = 10 + 4 = 14.
La somme des éléments correspondant aux indices 1, 4 et 9 est égale à nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Ainsi, la somme maximale des éléments d'un sous-ensemble complet d'indices est 19.

Contraintes :

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

On vous donne un tableau nums de n nombres entiers, indexé par 1.
Un ensemble de nombres est complet si le produit de chaque paire de ses éléments est un carré parfait.
Pour un sous-ensemble de l'ensemble d'indices {1, 2, ..., n} représenté par {i_1, i_2, ..., i_k}, nous définissons sa somme d'éléments comme : nums[i_1] + nums[i_2] + ... + nums[i_k].
Renvoyer la somme maximale d'un sous-ensemble complet de l'ensemble d'indices {1, 2, ..., n}.
Un carré parfait est un nombre qui peut être exprimé comme le produit d'un entier par lui-même.

Exemple 1 :

Entrée : nums = [8,7,3,5,7,2,4,9]
Sortie : 16
Explication : Outre les sous-ensembles composés d'un seul indice, il existe deux autres sous-ensembles complets d'indices : {1,4} et {2,8}.
La somme des éléments correspondant aux indices 1 et 4 est égale à nums[1] + nums[4] = 8 + 5 = 13.
La somme des éléments correspondant aux indices 2 et 8 est égale à nums[2] + nums[8] = 7 + 9 = 16.
Par conséquent, la somme maximale des éléments d'un sous-ensemble complet d'indices est de 16.
Exemple 2 :

Entrée : nums = [5,10,3,10,1,13,7,9,4]
Sortie : 19
Explication : Outre les sous-ensembles composés d'un seul indice, il existe quatre autres sous-ensembles complets d'indices : {1,4}, {1,9}, {2,8}, {4,9} et {1,4,9}.
La somme des éléments correspondant aux indices 1 et 4 est égale à nums[1] + nums[4] = 5 + 10 = 15.
La somme des éléments correspondant aux indices 1 et 9 est égale à nums[1] + nums[9] = 5 + 4 = 9.
La somme des éléments correspondant aux indices 2 et 8 est égale à nums[2] + nums[8] = 10 + 9 = 19.
La somme des éléments correspondant aux indices 4 et 9 est égale à nums[4] + nums[9] = 10 + 4 = 14.
La somme des éléments correspondant aux indices 1, 4 et 9 est égale à nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Par conséquent, la somme maximale des éléments d'un sous-ensemble complet d'indices est de 19.

Contraintes :

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


On vous donne une chaîne binaire s qui contient au moins un '1'.
Vous devez réorganiser les bits de telle manière que le nombre binaire résultant soit le nombre binaire impair maximal qui peut être créé à partir de cette combinaison.
Renvoyer une chaîne représentant le nombre binaire impair maximal qui peut être créé à partir de la combinaison donnée.
Notez que la chaîne résultante peut avoir des zéros non significatifs.

Exemple 1 :

Entrée : s = "010"
Sortie : "001"
Explication : Comme il n'y a qu'un seul « 1 », il doit être en dernière position. La réponse est donc « 001 ».

Exemple 2 :

Entrée : s = "0101"
Sortie : "1001"
Explication : L'un des « 1 » doit être en dernière position. Le nombre maximal qui peut être créé avec les chiffres restants est « 100 ». La réponse est donc « 1001 ».

Contraintes :

1 <= s.length <= 100
s est uniquement composé de '0' et '1'.
s contient au moins un '1'.

Vous avez une chaîne binaire \( s \) qui contient au moins un '1'.
Vous devez réarranger les bits de manière à ce que le nombre binaire résultant soit le nombre binaire impair maximal pouvant être créé à partir de cette combinaison.
Retournez une chaîne représentant le nombre binaire impair maximal qui peut être créé à partir de la combinaison donnée.
Notez que la chaîne résultante peut avoir des zéros en tête.

Exemple 1 :

Input: s = "010"
Output: "001"
Explication: Comme il y a un seul '1', il doit être à la dernière position. Donc la réponse est "001".

Exemple 2 :

Input: s = "0101"
Output: "1001"
Explication: Un des '1' doit être à la dernière position. Le nombre maximal pouvant être fait avec les chiffres restants est "100". Donc la réponse est "1001".

Contraintes :

1 <= s.length <= 100
s se compose uniquement de '0' et '1'.
s contient au moins un '1'.

On donne une chaîne binaire \( s \) qui contient au moins un '1'.
Vous devez réarranger les bits de manière à ce que le nombre binaire résultant soit le plus grand nombre binaire impair pouvant être créé à partir de cette combinaison.
Retournez une chaîne représentant le plus grand nombre binaire impair qui peut être créé à partir de la combinaison donnée.
Notez que la chaîne résultante peut avoir des zéros en tête.

Exemple 1 :

Input: s = "010"
Output: "001"
Explication: Comme il y a un seul '1', il doit être à la dernière position. La réponse est donc "001".

Exemple 2 :

Input: s = "0101"
Output: "1001"
Explication: Un des '1' doit être à la dernière position. Le plus grand nombre pouvant être créé avec les chiffres restants est "100". La réponse est donc "1001".

Contraintes :

1 <= s.length <= 100
s se compose uniquement de '0' et '1'.
s contient au moins un '1'.


On vous donne un tableau `nums` composé d'entiers non négatifs.
Nous définissons le score du sous-tableau `nums[l..r]` tel que `l <= r` comme `nums[l] AND nums[l + 1] AND ... AND nums[r]` où `AND` est l'opération bit à bit AND.
Considérez la division du tableau en un ou plusieurs sous-tableaux de manière à ce que les conditions suivantes soient satisfaites :

Chaque élément du tableau appartient à exactement un sous-tableau.
La somme des scores des sous-tableaux est la plus faible possible.

Renvoyez le nombre maximum de sous-tableaux dans une division qui satisfait les conditions ci-dessus.
Un sous-tableau est une partie contiguë d'un tableau.

Exemple 1 :

Entrée : `nums = [1,0,2,0,1,2]`
Sortie : `3`
Explication : Nous pouvons diviser le tableau en les sous-tableaux suivants :
- `[1,0]`. Le score de ce sous-tableau est `1 AND 0 = 0`.
- `[2,0]`. Le score de ce sous-tableau est `2 AND 0 = 0`.
- `[1,2]`. Le score de ce sous-tableau est `1 AND 2 = 0`.
La somme des scores est `0 + 0 + 0 = 0`, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être montré que nous ne pouvons pas diviser le tableau en plus de 3 sous-tableaux avec un score total de 0. Donc, nous renvoyons 3.

Exemple 2 :

Entrée : `nums = [5,7,1,3]`
Sortie : `1`
Explication : Nous pouvons diviser le tableau en un sous-tableau : `[5,7,1,3]` avec un score de 1, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être montré que nous ne pouvons pas diviser le tableau en plus de 1 sous-tableau avec un score total de 1. Donc, nous retournons 1.

Contraintes :

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

On vous donne un tableau `nums` composé d'entiers non négatifs.
Nous définissons le score du sous-tableau `nums[l..r]` tel que `l <= r` comme `nums[l] AND nums[l + 1] AND ... AND nums[r]` où `AND` est l'opération AND bit à bit.
Considérez la division du tableau en un ou plusieurs sous-tableaux de manière à ce que les conditions suivantes soient satisfaites :

Chaque élément du tableau appartient à exactement un sous-tableau.
La somme des scores des sous-tableaux est la plus faible possible.

Retournez le nombre maximum de sous-tableaux dans une division qui satisfait les conditions ci-dessus.
Un sous-tableau est une partie contiguë d'un tableau.

Exemple 1 :

Entrée : `nums = [1,0,2,0,1,2]`
Sortie : `3`
Explication : Nous pouvons diviser le tableau en sous-tableaux suivants :
- `[1,0]`. Le score de ce sous-tableau est `1 AND 0 = 0`.
- `[2,0]`. Le score de ce sous-tableau est `2 AND 0 = 0`.
- `[1,2]`. Le score de ce sous-tableau est `1 AND 2 = 0`.
La somme des scores est `0 + 0 + 0 = 0`, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être démontré que nous ne pouvons pas diviser le tableau en plus de 3 sous-tableaux avec un score total de 0. Donc, nous retournons 3.

Exemple 2 :

Entrée : `nums = [5,7,1,3]`
Sortie : `1`
Explication : Nous pouvons diviser le tableau en un sous-tableau : `[5,7,1,3]` avec un score de 1, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être démontré que nous ne pouvons pas diviser le tableau en plus de 1 sous-tableau avec un score total de 1. Donc, nous retournons 1.

Contraintes :

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

On a un tableau nums composé d'entiers non négatifs.
On définit le score du sous-tableau nums[l..r] tel que l <= r tel que nums[l] AND nums[l + 1] AND ... AND nums[r] où AND est l'opération bit à bit AND.
Considérez la possibilité de diviser le tableau en un ou plusieurs sous-tableaux de manière à ce que les conditions suivantes soient satisfaites :

Chaque élément du tableau appartient à exactement un sous-tableau.
La somme des scores des sous-tableaux est la plus petite possible.

Retournez le nombre maximum de sous-tableaux dans une division qui satisfait les conditions ci-dessus.
Un sous-tableau est une partie contiguë d'un tableau.

Exemple 1 :

Entrée : nums = [1,0,2,0,1,2]
Sortie : 3
Explication : Nous pouvons diviser le tableau en les sous-tableaux suivants :
- [1,0]. Le score de ce sous-tableau est 1 AND 0 = 0.
- [2,0]. Le score de ce sous-tableau est 2 AND 0 = 0.
- [1,2]. Le score de ce sous-tableau est 1 AND 2 = 0.
La somme des scores est `0 + 0 + 0 = 0`, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être montré que nous ne pouvons pas diviser le tableau en plus de 3 sous-tableaux avec un score total de 0. Donc, nous retournons 3.

Exemple 2 :

Entrée : nums = [5,7,1,3]
Sortie : 1
Explication : Nous pouvons diviser le tableau en un sous-tableau : [5,7,1,3] avec un score de 1, ce qui est le score minimum possible que nous pouvons obtenir.
Il peut être montré que nous ne pouvons pas diviser le tableau en plus de 1 sous-tableau avec un score total de 1. Donc, nous retournons 1.

Contraintes :

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


Vous disposez d'un tableau d'entiers trié et indexé à partir de 0, nommé nums.
Vous pouvez effectuer l'opération suivante un nombre quelconque de fois :

Choisissez deux indices, i et j, où i < j, tels que nums[i] < nums[j].
Ensuite, supprimez les éléments aux indices i et j de nums. Les éléments restants conservent leur ordre d'origine et le tableau est réindexé.

Retournez un entier qui indique la longueur minimale de nums après avoir effectué l'opération un nombre quelconque de fois (y compris zéro).
Notez que nums est trié dans l'ordre non décroissant.

Exemple 1 :

Entrée : nums = [1,3,4,9]
Sortie : 0
Explication : Initialement, nums = [1, 3, 4, 9].
Lors de la première opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 1 < 3.
Supprimez les indices 0 et 1, et nums devient [4, 9].
Pour la prochaine opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 4 < 9.
Supprimez les indices 0 et 1, et nums devient un tableau vide [].
Ainsi, la longueur minimale réalisable est de 0.

Exemple 2 :

Entrée : nums = [2,3,6,9]
Sortie : 0
Explication : Initialement, nums = [2, 3, 6, 9].
Lors de la première opération, nous pouvons choisir l'indice 0 et 2 car nums[0] < nums[2] <=> 2 < 6.
Supprimez les indices 0 et 2, et nums devient [3, 9].
Pour la prochaine opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 3 < 9.
Supprimez les indices 0 et 1, et nums devient un tableau vide [].
Ainsi, la longueur minimale réalisable est de 0.

Exemple 3 :

Entrée : nums = [1,1,2]
Sortie : 1
Explication : Initialement, nums = [1, 1, 2].
Lors d'une opération, nous pouvons choisir l'indice 0 et 2 car nums[0] < nums[2] <=> 1 < 2.
Supprimez les indices 0 et 2, et nums devient [1].
Il n'est plus possible d'effectuer une opération sur le tableau.
Ainsi, la longueur minimale réalisable est de 1.

Contraintes :

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums est trié dans l'ordre non décroissant.

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

Choisissez deux indices, i et j, où i < j, tels que nums[i] < nums[j].
Ensuite, supprimez les éléments aux indices i et j de nums. Les éléments restants conservent leur ordre d'origine et le tableau est réindexé.

Retournez un entier qui indique la longueur minimale de nums après avoir effectué l'opération un nombre quelconque de fois (y compris zéro).
Notez que nums est trié dans l'ordre non décroissant.

Exemple 1 :

Entrée : nums = [1,3,4,9]
Sortie : 0
Explication : Initialement, nums = [1, 3, 4, 9].
Lors de la première opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 1 < 3.
Supprimez les indices 0 et 1, et nums devient [4, 9].
Pour la prochaine opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 4 < 9.
Supprimez les indices 0 et 1, et nums devient un tableau vide [].
Ainsi, la longueur minimale réalisable est de 0.
Exemple 2 :

Entrée : nums = [2,3,6,9]
Sortie : 0
Explication : Initialement, nums = [2, 3, 6, 9].
Lors de la première opération, nous pouvons choisir l'indice 0 et 2 car nums[0] < nums[2] <=> 2 < 6.
Supprimez les indices 0 et 2, et nums devient [3, 9].
Pour la prochaine opération, nous pouvons choisir l'indice 0 et 1 car nums[0] < nums[1] <=> 3 < 9.
Supprimez les indices 0 et 1, et nums devient un tableau vide [].
Ainsi, la longueur minimale réalisable est de 0.

Exemple 3 :

Entrée : nums = [1,1,2]
Sortie : 1
Explication : Initialement, nums = [1, 1, 2].
Lors d'une opération, nous pouvons choisir l'indice 0 et 2 car nums[0] < nums[2] <=> 1 < 2.
Supprimez les indices 0 et 2, et nums devient [1].
Il n'est plus possible d'effectuer d'opération sur le tableau.
Ainsi, la longueur minimale réalisable est de 1.

Contraintes :

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums est trié dans l'ordre non décroissant.

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

Choisissez deux indices, i et j, où i < j, tels que nums[i] < nums[j].
Ensuite, supprimez les éléments aux indices i et j de nums. Les éléments restants conservent leur ordre d'origine et le tableau est réindexé.

Renvoie un entier qui indique la longueur minimale de nums après avoir effectué l'opération un nombre quelconque de fois (y compris zéro).
Notez que nums est trié dans l'ordre non décroissant.

Exemple 1 :

Entrée : nums = [1,3,4,9]
Sortie : 0
Explication : Initialement, nums = [1, 3, 4, 9].
Dans la première opération, nous pouvons choisir les index 0 et 1 car nums[0] < nums[1] <=> 1 < 3.
Supprimez les index 0 et 1, et nums devient [4, 9].
Pour l'opération suivante, nous pouvons choisir les index 0 et 1 car nums[0] < nums[1] <=> 4 < 9.
Supprimez les index 0 et 1, et nums devient un tableau vide [].
Par conséquent, la longueur minimale atteignable est 0.
Exemple 2 :

Entrée : nums = [2,3,6,9]
Sortie : 0
Explication : Initialement, nums = [2, 3, 6, 9].
Dans la première opération, nous pouvons choisir les index 0 et 2 car nums[0] < nums[2] <=> 2 < 6.
Supprimez les index 0 et 2, et nums devient [3, 9].
Pour l'opération suivante, nous pouvons choisir les index 0 et 1 car nums[0] < nums[1] <=> 3 < 9.
Supprimez les index 0 et 1, et nums devient un tableau vide [].
Par conséquent, la longueur minimale atteignable est 0.

Exemple 3 :

Entrée : nums = [1,1,2]
Sortie : 1
Explication : Initialement, nums = [1, 1, 2].
Dans une opération, nous pouvons choisir les index 0 et 2 car nums[0] < nums[2] <=> 1 < 2.
Supprimez les index 0 et 2, et nums devient [1].
Il n'est plus possible d'effectuer une opération sur le tableau.
Par conséquent, la longueur minimale atteignable est de 1.

Contraintes :

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums est trié par ordre non décroissant.


Vous disposez d'un tableau nums indexé à partir de 0, composé d'entiers non négatifs, ainsi que de deux entiers l et r.
Retournez le compte des sous-multiensembles dans nums où la somme des éléments dans chaque sous-ensemble se situe dans l'intervalle inclusif de [l, r].
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.
Un sous-multiensemble est une collection non ordonnée d'éléments du tableau dans laquelle une valeur donnée x peut apparaître 0, 1, ..., occ[x] fois, où occ[x] est le nombre d'occurrences de x dans le tableau.
Notez que :

Deux sous-multiensembles sont identiques si le tri des deux sous-multiensembles aboutit à des multiensembles identiques.
La somme d'un multiensemble vide est 0.

Exemple 1 :

Entrée : nums = [1,2,2,3], l = 6, r = 6
Sortie : 1
Explication : Le seul sous-ensemble de nums qui a une somme de 6 est {1, 2, 3}.

Exemple 2 :

Entrée : nums = [2,1,4,2,7], l = 1, r = 5
Sortie : 7
Explication : Les sous-ensembles de nums qui ont une somme dans l'intervalle [1, 5] sont {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} et {1, 2, 2}.

Exemple 3 :

Entrée : nums = [1,2,1,3,5,2], l = 3, r = 5
Sortie : 9
Explication : Les sous-ensembles de nums qui ont une somme dans l'intervalle [3, 5] sont {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} et {1, 2, 2}.

Contraintes :

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
La somme de nums ne dépasse pas 2 * 10^4.
0 <= l <= r <= 2 * 10^4

On vous donne un  tableau indexé à partir de 0, nommé nums, composé d'entiers non négatifs, ainsi que de deux entiers l et r.
Retournez le compte des sous-multiensembles dans nums où la somme des éléments dans chaque sous-ensemble se situe dans l'intervalle inclusif de [l, r].
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.
Un sous-multiensemble est une collection non ordonnée d'éléments du tableau dans laquelle une valeur donnée x peut apparaître 0, 1, ..., occ[x] fois, où occ[x] est le nombre d'occurrences de x dans le tableau.
Notez que :

Deux sous-multiensembles sont identiques si le tri des deux sous-multiensembles aboutit à des multiensembles identiques.
La somme d'un multiensemble vide est 0.

Exemple 1 :

Input: nums = [1,2,2,3], l = 6, r = 6
Output: 1
Explication : Le seul sous-ensemble de nums qui a une somme de 6 est {1, 2, 3}.

Exemple 2 :

Input: nums = [2,1,4,2,7], l = 1, r = 5
Output: 7
Explication : Les sous-ensembles de nums qui ont une somme dans l'intervalle [1, 5] sont {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} et {1, 2, 2}.

Exemple 3 :

Input: nums = [1,2,1,3,5,2], l = 3, r = 5
Output: 9
Explication : Les sous-ensembles de nums qui ont une somme dans l'intervalle [3, 5] sont {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} et {1, 2, 2}.

Contraintes :

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
La somme de nums ne dépasse pas 2 * 10^4.
0 <= l <= r <= 2 * 10^4

On vous donne un tableau indexé à 0 nums d'entiers non négatifs et deux entiers l et r.
Renvoie le nombre de sous-multi-ensembles dans nums où la somme des éléments de chaque sous-ensemble se situe dans la plage inclusive de [l, r].
Étant donné que la réponse peut être grande, renvoyez-la modulo 10^9 + 7.
Un sous-multi-ensemble est une collection non ordonnée d'éléments du tableau dans laquelle une valeur donnée x peut apparaître 0, 1, ..., occ[x] fois, où occ[x] est le nombre d'occurrences de x dans le tableau.
Notez que :

Deux sous-multi-ensembles sont identiques si le tri des deux sous-multi-ensembles donne des multi-ensembles identiques.
La somme d'un multiset vide est 0.

Exemple 1 :

Entrée : nums = [1,2,2,3], l = 6, r = 6
Sortie : 1
Explication : Le seul sous-ensemble de nums dont la somme est de 6 est {1, 2, 3}.

Exemple 2 :

Entrée : nums = [2,1,4,2,7], l = 1, r = 5
Sortie : 7
Explication : Les sous-ensembles de nums dont la somme est comprise dans la plage [1, 5] sont {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} et {1, 2, 2}.

Exemple 3 :

Entrée : nums = [1,2,1,3,5,2], l = 3, r = 5
Sortie : 9
Explication : Les sous-ensembles de nums dont la somme est comprise dans la plage [3, 5] sont {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} et {1, 2, 2}.

Contraintes :

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
La somme de nums ne dépasse pas 2 * 10^4.
0 <= l <= r <= 2 * 10^4


On vous donne un tableau d'entiers, nums, indexé à partir de 0, et un entier k. Retournez un entier qui représente la somme des éléments de nums dont les indices correspondants ont exactement k bits à 1 dans leur représentation binaire. Les bits à 1 dans un entier sont les 1 présents lorsqu'il est écrit en binaire.

Par exemple, la représentation binaire de 21 est 10101, qui a 3 bits à 1.

Exemple 1 :

Entrée : nums = [5,10,1,5,2], k = 1
Sortie : 13
Explication : La représentation binaire des indices est :
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Les indices 1, 2 et 4 ont k = 1 bits à 1 dans leur représentation binaire.
Ainsi, la réponse est nums[1] + nums[2] + nums[4] = 13.
Exemple 2 :

Entrée : nums = [4,3,2,1], k = 2
Sortie : 1
Explication : La représentation binaire des indices est :
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Seul l'indice 3 a k = 2 bits à 1 dans sa représentation binaire.
Ainsi, la réponse est nums[3] = 1.

Contraintes :

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

On a un tableau d'entiers nums indexé à partir de 0 et un entier k.
Retournez un entier qui représente la somme des éléments de nums dont les indices correspondants ont exactement k bits à 1 dans leur représentation binaire.
Les bits à 1 dans un entier sont les 1 présents lorsqu'il est écrit en binaire.

Par exemple, la représentation binaire de 21 est 10101, qui a 3 bits à 1.

Exemple 1 :

Entrée : nums = [5,10,1,5,2], k = 1
Sortie : 13
Explication : La représentation binaire des indices est :
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Les indices 1, 2 et 4 ont k = 1 bits à 1 dans leur représentation binaire.
Ainsi, la réponse est nums[1] + nums[2] + nums[4] = 13.
Exemple 2 :

Entrée : nums = [4,3,2,1], k = 2
Sortie : 1
Explication : La représentation binaire des indices est :
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Seul l'indice 3 a k = 2 bits à 1 dans sa représentation binaire.
Ainsi, la réponse est nums[3] = 1.

Contraintes :

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


Vous avez un tableau nums indexé à partir de 0 constitué d'entiers positifs.
Il y a deux types d'opérations que vous pouvez appliquer sur le tableau un nombre quelconque de fois :

Choisissez deux éléments ayant des valeurs égales et supprimez-les du tableau.
Choisissez trois éléments ayant des valeurs égales et supprimez-les du tableau.

Retournez le nombre minimum d'opérations nécessaires pour vider le tableau, ou -1 s'il n'est pas possible de le faire.

Exemple 1 :

Entrée : nums = [2,3,3,2,2,4,2,3,4]
Sortie : 4
Explication : Nous pouvons appliquer les opérations suivantes pour vider le tableau :
- Appliquez la première opération sur les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,3,2,4,2,3,4].
- Appliquez la première opération sur les éléments aux indices 2 et 4. Le tableau résultant est nums = [3,3,4,3,4].
- Appliquez la deuxième opération sur les éléments aux indices 0, 1 et 3. Le tableau résultant est nums = [4,4].
- Appliquez la première opération sur les éléments aux indices 0 et 1. Le tableau résultant est nums = [].
Il peut être démontré que nous ne pouvons pas vider le tableau en moins de 4 opérations.

Exemple 2 :

Entrée : nums = [2,1,2,2,3,3]
Sortie : -1
Explication : Il est impossible de vider le tableau.

Contraintes :

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

Vous avez un tableau numéroté à partir de 0, appelé `nums`, composé d'entiers positifs.
Il y a deux types d'opérations que vous pouvez appliquer sur le tableau autant de fois que nécessaire :

Choisissez deux éléments ayant des valeurs égales et supprimez-les du tableau.
Choisissez trois éléments ayant des valeurs égales et supprimez-les du tableau.

Renvoyez le nombre minimum d'opérations nécessaires pour vider le tableau, ou -1 s'il n'est pas possible de le faire.

Exemple 1 :

Entrée : nums = [2,3,3,2,2,4,2,3,4]
Sortie : 4
Explication : Nous pouvons appliquer les opérations suivantes pour vider le tableau :
- Appliquez la première opération sur les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,3,2,4,2,3,4].
- Appliquez la première opération sur les éléments aux indices 2 et 4. Le tableau résultant est nums = [3,3,4,3,4].
- Appliquez la deuxième opération sur les éléments aux indices 0, 1 et 3. Le tableau résultant est nums = [4,4].
- Appliquez la première opération sur les éléments aux indices 0 et 1. Le tableau résultant est nums = [].
Il peut être démontré que nous ne pouvons pas vider le tableau en moins de 4 opérations.

Exemple 2 :

Entrée : nums = [2,1,2,2,3,3]
Sortie : -1
Explication : Il est impossible de vider le tableau.

Contraintes :

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

On vous donne un nombre de numéros de tableau indexé à 0 composé d'entiers positifs.
Il existe deux types d'opérations que vous pouvez appliquer sur la tableau du nombre de fois:

Choisissez deux éléments avec des valeurs égales et supprimez-les du tableau.
Choisissez trois éléments avec des valeurs égales et supprimez-les du tableau.

Renvoie le nombre minimum d'opérations requis pour rendre le tableau vide, ou -1 si ce n'est pas possible.

Exemple 1:

Entrée: nums = [2,3,3,2,2,4,2,3,4]
Sortie: 4
Explication: Nous pouvons appliquer les opérations suivantes pour rendre le tableau vide:
- Appliquez la première opération sur les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,3,2,4,2,3,4].
- Appliquez la première opération sur les éléments aux indices 2 et 4. Le tableau résultant est nums = [3,3,4,3,4].
- Appliquez la deuxième opération sur les éléments aux indices 0, 1 et 3. Le tableau résultant est nums = [4,4].
- Appliquez la première opération sur les éléments aux indices 0 et 1. Le tableau résultant est num = [].
On peut montrer que nous ne pouvons pas rendre le tableau vide en moins de 4 opérations.

Exemple 2:

Entrée: nums = [2,1,2,2,3,3]
Sortie: -1
Explication: Il est impossible de vider le tableau.

Contraintes:

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


Vous avez un tableau d'entiers indexé à 0 `nums` de longueur `n` où `n` est le nombre total d'élèves dans la classe. Le professeur tente de sélectionner un groupe d'élèves afin que tous les élèves restent contents.
L'élève `i` sera content si l'une des deux conditions suivantes est remplie :

L'élève est sélectionné et le nombre total d'élèves sélectionnés est strictement supérieur à `nums[i]`.
L'élève n'est pas sélectionné et le nombre total d'élèves sélectionnés est strictement inférieur à `nums[i]`.

Retournez le nombre de façons de sélectionner un groupe d'élèves pour que tous restent contents.

Exemple 1 :

Entrée : `nums = [1,1]`
Sortie : `2`
Explication :
Les deux façons possibles sont :
Le professeur ne sélectionne aucun élève.
Le professeur sélectionne les deux élèves pour former le groupe.
Si le professeur sélectionne juste un élève pour former un groupe, alors les deux élèves ne seront pas contents. Par conséquent, il n'y a que deux façons possibles.

Exemple 2 :

Entrée : `nums = [6,0,3,3,6,7,2,7]`
Sortie : `3`
Explication :
Les trois façons possibles sont :
Le professeur sélectionne l'élève avec index = 1 pour former le groupe.
Le professeur sélectionne les élèves avec index = 1, 2, 3, 6 pour former le groupe.
Le professeur sélectionne tous les élèves pour former le groupe.

Contraintes :

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

Vous avez un tableau d'entiers nums indexé à partir de 0 de longueur n où n est le nombre total d'élèves dans la classe. Le professeur tente de sélectionner un groupe d'élèves afin que tous les élèves restent contents.
L'élève à l'indice i sera content si l'une des deux conditions suivantes est remplie :

L'élève est sélectionné et le nombre total d'élèves sélectionnés est strictement supérieur à nums[i].
L'élève n'est pas sélectionné et le nombre total d'élèves sélectionnés est strictement inférieur à nums[i].

Retournez le nombre de façons de sélectionner un groupe d'élèves pour que tous restent contents.

Exemple 1 :

Entrée : nums = [1,1]
Sortie : 2
Explication :
Les deux façons possibles sont :
Le professeur ne sélectionne aucun élève.
Le professeur sélectionne les deux élèves pour former le groupe.
Si le professeur sélectionne juste un élève pour former un groupe, les deux élèves ne seront pas contents. Par conséquent, il n'y a que deux façons possibles.

Exemple 2 :

Entrée : nums = [6,0,3,3,6,7,2,7]
Sortie : 3
Explication :
Les trois façons possibles sont :
Le professeur sélectionne l'élève avec index = 1 pour former le groupe.
Le professeur sélectionne les élèves avec index = 1, 2, 3, 6 pour former le groupe.
Le professeur sélectionne tous les élèves pour former le groupe.

Contraintes :

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

On vous donne un tableau d'entiers indexé à 0 nums de longueur n où n est le nombre total d'élèves de la classe. Le professeur principal essaie de sélectionner un groupe d'élèves de manière à ce que tous les élèves restent satisfaits.
Le i^ème élève sera satisfait si l'une de ces deux conditions est remplie :

L'élève est sélectionné et le nombre total d'élèves sélectionnés est strictement supérieur à nums[i].
L'élève n'est pas sélectionné et le nombre total d'élèves sélectionnés est strictement inférieur à nums[i].

Renvoie le nombre de façons de sélectionner un groupe d'élèves de manière à ce que tout le monde reste satisfait.

Exemple 1 :

Entrée : nums = [1,1]
Sortie : 2
Explication :
Les deux façons possibles sont :
Le professeur principal ne sélectionne aucun élève.
Le professeur principal sélectionne les deux élèves pour former le groupe.
Si le professeur principal sélectionne un seul élève pour former un groupe, les deux élèves ne seront pas satisfaits. Par conséquent, il n'y a que deux façons possibles.

Exemple 2 :

Entrée : nums = [6,0,3,3,6,7,2,7]
Sortie : 3
Explication :
Les trois manières possibles sont :
Le professeur de classe sélectionne l'élève avec l'index = 1 pour former le groupe.
Le professeur de classe sélectionne les élèves avec l'index = 1, 2, 3, 6 pour former le groupe.
Le professeur de classe sélectionne tous les élèves pour former le groupe.

Contraintes :

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


Vous avez un tableau d'entiers nums indexé à partir de 0, et un entier target.
Retournez la longueur de la plus longue sous-séquence de nums dont la somme est égale à target. Si une telle sous-séquence n'existe pas, retournez -1.
Une sous-séquence est un tableau pouvant être dérivé d'un autre tableau en supprimant certains éléments ou aucun élément sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,3,4,5], target = 9
Sortie : 3
Explication : Il y a 3 sous-séquences dont la somme est égale à 9 : [4,5], [1,3,5] et [2,3,4]. Les plus longues sous-séquences sont [1,3,5] et [2,3,4]. Donc, la réponse est 3.

Exemple 2 :

Entrée : nums = [4,1,3,2,1,5], target = 7
Sortie : 4
Explication : Il y a 5 sous-séquences dont la somme est égale à 7 : [4,3], [4,1,2], [4,2,1], [1,1,5] et [1,3,2,1]. La plus longue sous-séquence est [1,3,2,1]. Donc, la réponse est 4.

Exemple 3 :

Entrée : nums = [1,1,5,4,5], target = 3
Sortie : -1
Explication : Il peut être montré que nums n’a aucune sous-séquence dont la somme est égale à 3.

Contraintes :

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

Vous avez un tableau d'entiers numéroté à partir de 0, appelé nums, et un entier target.
Retournez la longueur de la plus longue sous-séquence de nums dont la somme est égale à target. Si une telle sous-séquence n'existe pas, retournez -1.
Une sous-séquence est un tableau pouvant être dérivé d'un autre tableau en supprimant certains éléments ou aucun élément sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,3,4,5], target = 9
Sortie : 3
Explication : Il y a 3 sous-séquences dont la somme est égale à 9 : [4,5], [1,3,5] et [2,3,4]. Les plus longues sous-séquences sont [1,3,5] et [2,3,4]. Donc, la réponse est 3.

Exemple 2 :

Entrée : nums = [4,1,3,2,1,5], target = 7
Sortie : 4
Explication : Il y a 5 sous-séquences dont la somme est égale à 7 : [4,3], [4,1,2], [4,2,1], [1,1,5] et [1,3,2,1]. La plus longue sous-séquence est [1,3,2,1]. Donc, la réponse est 4.

Exemple 3 :

Entrée : nums = [1,1,5,4,5], target = 3
Sortie : -1
Explication : Il peut être montré que nums n’a aucune sous-séquence dont la somme est égale à 3.

Contraintes :

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

Vous recevez un tableau indexé 0 d’entiers, nums et une cible entière.
Renvoie la longueur de la plus longue sous-séquence de nums dont la somme correspond à la cible. S’il n’existe pas de sous-séquence de ce type, retournez -1.
Une sous-séquence est un tableau qui peut être dérivé d’un autre tableau en supprimant certains éléments ou aucun élément sans changer l’ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,3,4,5], target = 9
Sortie : 3
Explication : Il y a 3 sous-suites dont la somme est égale à 9 : [4,5], [1,3,5] et [2,3,4]. Les sous-séquences les plus longues sont [1,3,5] et [2,3,4]. Par conséquent, la réponse est 3.

Exemple 2 :

Entrée : nums = [4,1,3,2,1,5], target = 7
Sortie : 4
Explication : Il y a 5 sous-suites dont la somme est égale à 7 : [4,3], [4,1,2], [4,2,1], [1,1,5] et [1,3,2,1]. La sous-séquence la plus longue est [1,3,2,1]. Par conséquent, la réponse est 4.

Exemple 3 :

Entrée : nums = [1,1,5,4,5], target = 3
Sortie : -1
Explication : On peut montrer que nums n’a pas de sous-séquence dont la somme est égale à 3.

Contraintes:

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


Vous avez un tableau maxHeights de n entiers indexé à partir de 0.
Vous devez construire n tours sur la ligne de coordonnées. La i^ème tour est construite à la coordonnée i et a une hauteur de heights[i].
Une configuration de tours est belle si les conditions suivantes sont remplies :

1 <= heights[i] <= maxHeights[i]
heights est un tableau montagne.

Le tableau heights est une montagne s'il existe un indice i tel que :

Pour tout 0 < j <= i, heights[j - 1] <= heights[j]
Pour tout i <= k < n - 1, heights[k + 1] <= heights[k]

Retournez la somme maximale possible des hauteurs d'une configuration belle de tours.

Exemple 1 :

Entrée : maxHeights = [5,3,4,1,1]
Sortie : 13
Explication : Une configuration belle avec une somme maximale est heights = [5,3,3,1,1]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 0.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 13.

Exemple 2 :

Entrée : maxHeights = [6,5,3,9,2,7]
Sortie : 22
Explication : Une configuration belle avec une somme maximale est heights = [3,3,3,9,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 3.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 22.

Exemple 3 :

Entrée : maxHeights = [3,2,5,5,2,3]
Sortie : 18
Explication : Une configuration belle avec une somme maximale est heights = [2,2,5,5,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 2.
Notez que, pour cette configuration, i = 3 peut également être considéré comme un sommet.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 18.

Contraintes :

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

On donne un tableau maxHeights de n entiers indexé à partir de 0.
Vous devez construire n tours sur la ligne de coordonnées. La i^ème tour est construite à la coordonnée i et a une hauteur de heights[i].
Une configuration de tours est dite belle si les conditions suivantes sont remplies :

1 <= heights[i] <= maxHeights[i]
heights est un tableau montagne.

Le tableau heights est une montagne s'il existe un indice i tel que :

Pour tout 0 < j <= i, heights[j - 1] <= heights[j]
Pour tout i <= k < n - 1, heights[k + 1] <= heights[k]

Retournez la somme maximale possible des hauteurs d'une configuration belle de tours.

Exemple 1 :

Entrée : maxHeights = [5,3,4,1,1]
Sortie : 13
Explication : Une configuration belle avec une somme maximale est heights = [5,3,3,1,1]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 0.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 13.
Exemple 2 :

Entrée : maxHeights = [6,5,3,9,2,7]
Sortie : 22
Explication : Une configuration belle avec une somme maximale est heights = [3,3,3,9,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 3.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 22.
Exemple 3 :

Entrée : maxHeights = [3,2,5,5,2,3]
Sortie : 18
Explication : Une configuration belle avec une somme maximale est heights = [2,2,5,5,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne avec un sommet i = 2.
Notez que, pour cette configuration, i = 3 peut également être considéré comme un sommet.
Il peut être démontré qu'il n'existe aucune autre configuration belle avec une somme de hauteurs supérieure à 18.

Contraintes :

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

On vous donne un tableau maxHeights indexé à 0 de n entiers.
Vous devez construire n tours dans la ligne de coordonnées. La i^ème tour est construite à la coordonnée i et a une hauteur de heights[i].
Une configuration de tours est belle si les conditions suivantes sont remplies :

1 <= heights[i] <= maxHeights[i]
heights est un tableau de montagnes.

Le tableau heights est une montagne s'il existe un index i tel que :

Pour tout 0 < j <= i, heights[j - 1] <= heights[j]
Pour tout i <= k < n - 1, heights[k + 1] <= heights[k]

Renvoie la somme maximale possible des hauteurs d'une belle configuration de tours.

Exemple 1 :

Entrée : maxHeights = [5,3,4,1,1]
Sortie : 13
Explication : Une belle configuration avec une somme maximale est heights = [5,3,3,1,1]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne de pic i = 0.
On peut montrer qu'il n'existe aucune autre belle configuration avec une somme de hauteurs supérieure à 13.
Exemple 2 :

Entrée : maxHeights = [6,5,3,9,2,7]
Sortie : 22
Explication : Une belle configuration avec une somme maximale est heights = [3,3,3,9,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne de pic i = 3.
On peut montrer qu'il n'existe aucune autre belle configuration avec une somme de hauteurs supérieure à 22.
Exemple 3 :

Entrée : maxHeights = [3,2,5,5,2,3]
Sortie : 18
Explication : Une belle configuration avec une somme maximale est heights = [2,2,5,5,2,2]. Cette configuration est belle car :
- 1 <= heights[i] <= maxHeights[i]
- heights est une montagne de pic i = 2.
Notez que, pour cette configuration, i = 3 peut également être considéré comme un pic.
On peut montrer qu'il n'existe aucune autre belle configuration avec une somme de hauteurs supérieure à 18.

Contraintes :

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9


On vous a donné un tableau indexé à partir de 0 `nums` et un entier `target`.
Un tableau indexé à partir de 0 `infinite_nums` est généré en ajoutant infiniment les éléments de `nums` à lui-même.
Retournez la longueur du sous-tableau la plus courte du tableau `infinite_nums` avec une somme égale à `target`. S'il n'y a pas un tel sous-tableau, retournez -1.

Exemple 1 :

Entrée : nums = [1,2,3], target = 5
Sortie : 2
Explication : Dans cet exemple `infinite_nums` = [1,2,3,1,2,3,1,2,...].
Le sous-tableau dans la plage [1,2] a la somme égale à `target` = 5 et une longueur = 2.
Il peut être prouvé que 2 est la plus courte longueur d'un sous-tableau avec somme égale à `target` = 5.

Exemple 2 :

Entrée : nums = [1,1,1,2,3], target = 4
Sortie : 2
Explication : Dans cet exemple `infinite_nums` = [1,1,1,2,3,1,1,1,2,3,1,1,...].
Le sous-tableau dans la plage [4,5] a la somme égale à `target` = 4 et une longueur = 2.
Il peut être prouvé que 2 est la plus courte longueur d'un sous-tableau avec somme égale à `target` = 4.

Exemple 3 :

Entrée : nums = [2,4,6,8], target = 3
Sortie : -1
Explication : Dans cet exemple `infinite_nums` = [2,4,6,8,2,4,6,8,...].
Il peut être prouvé qu'il n'y a pas de sous-tableau avec une somme égale à `target` = 3.

Contraintes :

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

On vous donne un tableau indexé à 0 nums et un entier target.
Un tableau indexé à 0 infinite_nums est généré en ajoutant à l'infini les éléments de nums à lui-même.
Renvoie la longueur du sous-tableau le plus court du tableau infinite_nums avec une somme égale à target. S'il n'y a pas de sous-tableau de ce type, renvoie -1.

Exemple 1 :

Entrée : nums = [1,2,3], target = 5
Sortie : 2
Explication : Dans cet exemple, infinite_nums = [1,2,3,1,2,3,1,2,...].
Le sous-tableau dans la plage [1,2] a la somme égale à target = 5 et length = 2.
Il peut être prouvé que 2 est la longueur la plus courte d'un sous-tableau avec une somme égale à target = 5.

Exemple 2 :

Entrée : nums = [1,1,1,2,3], target = 4
Sortie : 2
Explication : Dans cet exemple, infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...]. Le sous-tableau dans la plage [4,5] a la somme égale à target = 4 et length = 2.
Il peut être prouvé que 2 est la longueur la plus courte d'un sous-tableau avec une somme égale à target = 4.

Exemple 3 :

Entrée : nums = [2,4,6,8], target = 3
Sortie : -1
Explication : Dans cet exemple, infinite_nums = [2,4,6,8,2,4,6,8,...].
Il peut être prouvé qu'il n'existe aucun sous-tableau avec une somme égale à target = 3.

Contraintes :

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

Vous avez un tableau indexé à partir de 0 `nums` et un entier `target`.
Un tableau indexé à partir de 0 `infinite_nums` est généré en ajoutant indéfiniment les éléments de `nums` à lui-même.
Retournez la longueur de la sous-tableau la plus courte du tableau `infinite_nums` avec une somme égale à `target`. S'il n'y a pas de tel sous-tableau, retournez -1.

Exemple 1 :

Entrée : nums = [1,2,3], target = 5
Sortie : 2
Explication : Dans cet exemple `infinite_nums` = [1,2,3,1,2,3,1,2,...].
La sous-tableau dans la plage [1,2] a la somme égale à `target` = 5 et une longueur = 2.
Il peut être prouvé que 2 est la plus courte longueur d'une sous-tableau avec somme égale à `target` = 5.

Exemple 2 :

Entrée : nums = [1,1,1,2,3], target = 4
Sortie : 2
Explication : Dans cet exemple `infinite_nums` = [1,1,1,2,3,1,1,1,2,3,1,1,...].
La sous-tableau dans la plage [4,5] a la somme égale à `target` = 4 et une longueur = 2.
Il peut être prouvé que 2 est la plus courte longueur d'une sous-tableau avec somme égale à `target` = 4.

Exemple 3 :

Entrée : nums = [2,4,6,8], target = 3
Sortie : -1
Explication : Dans cet exemple `infinite_nums` = [2,4,6,8,2,4,6,8,...].
Il peut être prouvé qu'il n'y a pas de sous-tableau avec une somme égale à `target` = 3.

Contraintes :

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


On vous donne une chaîne binaire s et un entier positif k.
Une sous-chaîne de s est belle si le nombre de 1 qu'elle contient est exactement k.
Soit len la longueur de la plus courte sous-chaîne belle.
Retournez la plus petite sous-chaîne belle de s, de longueur égale à len, selon l'ordre lexicographique. Si s ne contient pas de sous-chaîne belle, retournez une chaîne vide.
Une chaîne a est lexicographiquement plus grande qu'une chaîne b (de même longueur) si à la première position où a et b diffèrent, a a un caractère strictement plus grand que le caractère correspondant de b.

Par exemple, "abcd" est lexicographiquement plus grand que "abcc" car la première position où elles diffèrent est le quatrième caractère, et d est plus grand que c.

Exemple 1 :

Entrée : s = "100011001", k = 3
Sortie : "11001"
Explication : Il y a 7 sous-chaînes belles dans cet exemple :
1. La sous-chaîne "100011001".
2. La sous-chaîne "100011001".
3. La sous-chaîne "100011001".
4. La sous-chaîne "100011001".
5. La sous-chaîne "100011001".
6. La sous-chaîne "100011001".
7. La sous-chaîne "100011001".
La longueur de la plus courte sous-chaîne belle est 5.
La plus petite sous-chaîne belle de longueur 5 selon l'ordre lexicographique est la sous-chaîne "11001".

Exemple 2 :

Entrée : s = "1011", k = 2
Sortie : "11"
Explication : Il y a 3 sous-chaînes belles dans cet exemple :
1. La sous-chaîne "1011".
2. La sous-chaîne "1011".
3. La sous-chaîne "1011".
La longueur de la plus courte sous-chaîne belle est 2.
La plus petite sous-chaîne belle de longueur 2 selon l'ordre lexicographique est la sous-chaîne "11".

Exemple 3 :

Entrée : s = "000", k = 1
Sortie : ""
Explication : il n'y a pas de sous-chaînes belles dans cet exemple.

Contraintes :

1 <= s.length <= 100
1 <= k <= s.length

On donne une chaîne binaire s et un entier positif k.
Une sous-chaîne de s est dite belle si le nombre de 1 qu'elle contient est exactement k.
Soit len la longueur la sous-chaîne belle la plus courte.
Retournez la sous-chaîne belle de s lexicographiquement la plus petite qui soit de longueur égale à len. Si s ne contient pas de sous-chaîne belle, retournez une chaîne vide.
Une chaîne a est lexicographiquement plus grande qu'une chaîne b (de même longueur) si à la première position où a et b diffèrent, a a un caractère strictement plus grand que le caractère correspondant de b.

Par exemple, "abcd" est lexicographiquement plus grand que "abcc" car la première position où elles diffèrent est le quatrième caractère, et d est plus grand que c.

Exemple 1 :

Entrée : s = "100011001", k = 3
Sortie : "11001"
Explication : Il y a 7 sous-chaînes belles dans cet exemple :
1. La sous-chaîne "100011001".
2. La sous-chaîne "100011001".
3. La sous-chaîne "100011001".
4. La sous-chaîne "100011001".
5. La sous-chaîne "100011001".
6. La sous-chaîne "100011001".
7. La sous-chaîne "100011001".
La longueur de la plus courte sous-chaîne belle est 5.
La sous-chaîne belle lexocographiquement la plus belle de longueur 5 est la sous-chaîne "11001".

Exemple 2 :

Entrée : s = "1011", k = 2
Sortie : "11"
Explication : Il y a 3 sous-chaînes belles dans cet exemple :
1. La sous-chaîne "1011".
2. La sous-chaîne "1011".
3. La sous-chaîne "1011".
La longueur de la plus courte sous-chaîne belle est 2.
La sous-chaîne belle lexicographiquement la plus petite de longueur 2 est la sous-chaîne "11".

Exemple 3 :

Entrée : s = "000", k = 1
Sortie : ""
Explication : Il n'y a pas de sous-chaînes belles dans cet exemple.

Contraintes :

1 <= s.length <= 100
1 <= k <= s.length

On vous donne une chaîne binaire s et un entier positif k.
Une sous-chaîne de s est belle si le nombre de 1 qu'elle contient est exactement k.
Soit len la longueur de la plus courte sous-chaîne belle.
Renvoie la plus petite sous-chaîne belle lexicographiquement de la chaîne s avec une longueur égale à len. Si s ne contient pas de sous-chaîne belle, renvoie une chaîne vide.
Une chaîne a est lexicographiquement plus grande qu'une chaîne b (de même longueur) si dans la première position où a et b diffèrent, a a un caractère strictement plus grand que le caractère correspondant dans b.

Par exemple, "abcd" est lexicographiquement plus grand que "abcc" car la première position où ils diffèrent est au quatrième caractère, et d est plus grand que c.

Exemple 1 :

Entrée : s = "100011001", k = 3
Sortie : "11001"
Explication : Il y a 7 belles sous-chaînes dans cet exemple :
1. La sous-chaîne "100011001".
2. La sous-chaîne "100011001".
3. La sous-chaîne "100011001".
4. La sous-chaîne "100011001".
5. La sous-chaîne "100011001".
6. La sous-chaîne "100011001".
7. La sous-chaîne "100011001".
La longueur de la plus courte belle sous-chaîne est de 5.
La plus petite belle sous-chaîne lexicographiquement de longueur 5 est la sous-chaîne "11001".

Exemple 2 :

Entrée : s = "1011", k = 2
Sortie : "11"
Explication : Il y a 3 belles sous-chaînes dans cet exemple :
1. La sous-chaîne "1011".
2. La sous-chaîne "1011".
3. La sous-chaîne "1011".
La longueur de la plus courte belle sous-chaîne est de 2.
La plus petite belle sous-chaîne lexicographiquement avec une longueur de 2 est la sous-chaîne "11".

Exemple 3 :

Entrée : s = "000", k = 1
Sortie : ""
Explication : Il n'y a pas de belles sous-chaînes dans cet exemple.

Contraintes :

1 <= s.length <= 100
1 <= k <= s.length


Vous avez n processeurs, chacun ayant 4 cœurs et n * 4 tâches à exécuter, de sorte que chaque cœur ne doit effectuer qu'une seule tâche.
Étant donné un tableau d'entiers indexé à 0, processorTime, représentant le moment où chaque processeur devient disponible pour la première fois, et un tableau d'entiers indexé à 0, tasks, représentant le temps nécessaire pour exécuter chaque tâche, retournez le temps minimum lorsque toutes les tâches ont été exécutées par les processeurs.
Remarque : Chaque cœur exécute la tâche indépendamment des autres.

Exemple 1 :

Entrée : processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Sortie : 16
Explication :
Il est optimal d'assigner les tâches aux indices 4, 5, 6, 7 au premier processeur qui devient disponible à temps = 8, et les tâches aux indices 0, 1, 2, 3 au deuxième processeur qui devient disponible à temps = 10.
Temps pris par le premier processeur pour finir l'exécution de toutes les tâches = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Temps pris par le deuxième processeur pour finir l'exécution de toutes les tâches = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Ainsi, il peut être montré que le temps minimum pris pour exécuter toutes les tâches est 16.
Exemple 2 :

Entrée : processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Sortie : 23
Explication :
Il est optimal d'assigner les tâches aux indices 1, 4, 5, 6 au premier processeur qui devient disponible à temps = 10, et les tâches aux indices 0, 2, 3, 7 au deuxième processeur qui devient disponible à temps = 20.
Temps pris par le premier processeur pour finir l'exécution de toutes les tâches = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Temps pris par le deuxième processeur pour finir l'exécution de toutes les tâches = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Ainsi, il peut être montré que le temps minimum pris pour exécuter toutes les tâches est 23.

Contraintes :

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

Vous avez n processeurs, chacun ayant 4 cœurs et n * 4 tâches à exécuter, de sorte que chaque cœur ne doit effectuer qu'une seule tâche.
Étant donné un tableau d'entiers indexé à 0, processorTime, représentant le moment où chaque processeur devient disponible pour la première fois, et un tableau d'entiers indexé à 0, tasks, représentant le temps nécessaire pour exécuter chaque tâche, renvoyez le temps minimum nécessaire à l'exécution de toutes les tâches par les processeurs.
Remarque : Chaque cœur exécute la tâche indépendamment des autres.

Exemple 1 :

Entrée : processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Sortie : 16
Explication :
Il est optimal d'assigner les tâches aux indices 4, 5, 6, 7 au premier processeur qui devient disponible à temps = 8, et les tâches aux indices 0, 1, 2, 3 au deuxième processeur qui devient disponible à temps = 10.
Temps pris par le premier processeur pour finir l'exécution de toutes les tâches = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Temps pris par le deuxième processeur pour finir l'exécution de toutes les tâches = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Ainsi, il peut être montré que le temps minimum pris pour exécuter toutes les tâches est 16.
Exemple 2 :

Entrée : processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Sortie : 23
Explication :
Il est optimal d'assigner les tâches aux indices 1, 4, 5, 6 au premier processeur qui devient disponible à temps = 10, et les tâches aux indices 0, 2, 3, 7 au deuxième processeur qui devient disponible à temps = 20.
Temps pris par le premier processeur pour finir l'exécution de toutes les tâches = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Temps pris par le deuxième processeur pour finir l'exécution de toutes les tâches = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Ainsi, il peut être montré que le temps minimum pris pour exécuter toutes les tâches est 23.

Contraintes :

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


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

Choisissez deux indices distincts i et j et mettez à jour simultanément les valeurs de nums[i] à (nums[i] ET nums[j]) et nums[j] à (nums[i] OU nums[j]). Ici, OU désigne l'opération OU binaire, et ET désigne l'opération ET binaire.

Vous devez choisir k éléments du tableau final et calculer la somme de leurs carrés.
Retournez la somme maximale des carrés que vous pouvez obtenir.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,6,5,8], k = 2
Sortie : 261
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0 et j = 3, puis changez nums[0] à (2 ET 8) = 0 et nums[3] à (2 OU 8) = 10. Le tableau résultant est nums = [0,6,5,10].
- Choisissez i = 2 et j = 3, puis changez nums[2] à (5 ET 10) = 0 et nums[3] à (5 OU 10) = 15. Le tableau résultant est nums = [0,6,0,15].
Nous pouvons choisir les éléments 15 et 6 du tableau final. La somme des carrés est 15^2 + 6^2 = 261.
Il peut être démontré que c'est la valeur maximale que nous pouvons obtenir.

Exemple 2 :

Entrée : nums = [4,5,4,7], k = 3
Sortie : 90
Explication : Nous n'avons pas besoin d'appliquer d'opérations.
Nous pouvons choisir les éléments 7, 5 et 4 avec une somme des carrés : 7^2 + 5^2 + 4^2 = 90.
Il peut être démontré que c'est la valeur maximale que nous pouvons obtenir.

Contraintes :

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

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

Choisissez deux indices distincts i et j et mettez simultanément à jour les valeurs de nums[i] en (nums[i] ET nums[j]) et nums[j] en (nums[i] OU nums[j]). Ici, OR désigne l’opération OU au niveau du bit, et AND désigne l’opération AND au niveau du bit.

Vous devez choisir k éléments dans le tableau final et calculer la somme de leurs carrés.
Renvoie la somme maximale de carrés que vous pouvez atteindre.
Comme la réponse peut être très grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,6,5,8], k = 2
Sortie : 261
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0 et j = 3, puis changez nums[0] en (2 ET 8) = 0 et nums[3] en (2 OU 8) = 10. Le tableau résultant est nums = [0,6,5,10].
- Choisissez i = 2 et j = 3, puis changez nums[2] en (5 ET 10) = 0 et nums[3] en (5 OU 10) = 15. Le tableau résultant est nums = [0,6,0,15].
Nous pouvons choisir les éléments 15 et 6 dans le tableau final. La somme des carrés est 15^2 + 6^2 = 261.
On peut montrer que c’est la valeur maximale que nous pouvons obtenir.

Exemple 2 :

Entrée : nums = [4,5,4,7], k = 3
Sortie : 90
Explication : Nous n’avons pas besoin d’appliquer d’opérations.
Nous pouvons choisir les éléments 7, 5 et 4 avec une somme de carrés : 7^2 + 5^2 + 4^2 = 90.
On peut montrer que c’est la valeur maximale que nous pouvons obtenir.

Contraintes:

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

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

Choisissez deux indices distincts i et j et mettez à jour simultanément les valeurs de nums[i] à (nums[i] ET nums[j]) et nums[j] à (nums[i] OU nums[j]). Ici, OR désigne l'opération OR binaire, et AND désigne l'opération AND binaire.

Vous devez choisir k éléments du tableau final et calculer la somme de leurs carrés.
Retournez la somme maximale des carrés que vous pouvez obtenir.
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,6,5,8], k = 2
Sortie : 261
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0 et j = 3, puis changez nums[0] à (2 AND 8) = 0 et nums[3] à (2 OR 8) = 10. Le tableau résultant est nums = [0,6,5,10].
- Choisissez i = 2 et j = 3, puis changez nums[2] à (5 AND 10) = 0 et nums[3] à (5 OR 10) = 15. Le tableau résultant est nums = [0,6,0,15].
Nous pouvons choisir les éléments 15 et 6 du tableau final. La somme des carrés est 15^2 + 6^2 = 261.
On peut montrer que c'est la valeur maximale que nous pouvons obtenir.

Exemple 2 :

Entrée : nums = [4,5,4,7], k = 3
Sortie : 90
Explication : Nous n'avons pas besoin d'appliquer d'opérations.
Nous pouvons choisir les éléments 7, 5 et 4 avec une somme des carrés : 7^2 + 5^2 + 4^2 = 90.
On peut montrer que c'est la valeur maximale que nous pouvons obtenir.

Contraintes :

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


On vous donne un tableau d'entiers nums indexé à partir de 0.
Retournez la valeur maximale pour tous les triplets d'indices (i, j, k) tels que i < j < k. Si tous ces triplets ont une valeur négative, retournez 0.
La valeur d'un triplet d'indices (i, j, k) est égale à (nums[i] - nums[j]) * nums[k].

Exemple 1 :

Entrée : nums = [12,6,1,2,7]
Sortie : 77
Explication : La valeur du triplet (0, 2, 4) est (nums[0] - nums[2]) * nums[4] = 77.
On peut montrer qu'il n'y a pas de triplets d'indices ordonnés avec une valeur supérieure à 77.

Exemple 2 :

Entrée : nums = [1,10,3,4,19]
Sortie : 133
Explication : La valeur du triplet (1, 2, 4) est (nums[1] - nums[2]) * nums[4] = 133.
On peut montrer qu'il n'y a pas de triplets d'indices ordonnés avec une valeur supérieure à 133.

Exemple 3 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication : Le seul triplet d'indices ordonné (0, 1, 2) a une valeur négative de (nums[0] - nums[1]) * nums[2] = -3. Par conséquent, la réponse serait 0.

Contraintes :

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

On vous donne un tableau d'entiers indexés à 0 nums.
Renvoie la valeur maximale sur tous les triplets d'indices (i, j, k) tels que i < j < k. Si tous ces triplets ont une valeur négative, renvoie 0.
La valeur d'un triplet d'indices (i, j, k) est égale à (nums[i] - nums[j]) * nums[k].

Exemple 1 :

Entrée : nums = [12,6,1,2,7]
Sortie : 77
Explication : La valeur du triplet (0, 2, 4) est (nums[0] - nums[2]) * nums[4] = 77.
Il peut être démontré qu'il n'existe aucun triplet ordonné d'indices dont la valeur est supérieure à 77.

Exemple 2 :

Entrée : nums = [1,10,3,4,19]
Sortie : 133
Explication : La valeur du triplet (1, 2, 4) est (nums[1] - nums[2]) * nums[4] = 133.
Il peut être démontré qu'il n'existe aucun triplet ordonné d'indices dont la valeur est supérieure à 133.

Exemple 3 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication : Le seul triplet ordonné d'indices (0, 1, 2) a une valeur négative de (nums[0] - nums[1]) * nums[2] = -3. Par conséquent, la réponse serait 0.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0.
Retournez la valeur maximale pour tous les triplets d'indices (i, j, k) tels que i < j < k. Si tous ces triplets ont une valeur négative, renvoyez 0.
La valeur d'un triplet d'indices (i, j, k) est égale à (nums[i] - nums[j]) * nums[k].

Exemple 1 :

Entrée : nums = [12,6,1,2,7]
Sortie : 77
Explication : La valeur du triplet (0, 2, 4) est (nums[0] - nums[2]) * nums[4] = 77.
Il peut être démontré qu'il n'y a pas de triplets d'indices ordonnés avec une valeur supérieure à 77.

Exemple 2 :

Entrée : nums = [1,10,3,4,19]
Sortie : 133
Explication : La valeur du triplet (1, 2, 4) est (nums[1] - nums[2]) * nums[4] = 133.
Il peut être démontré qu'il n'y a pas de triplets d'indices ordonnés avec une valeur supérieure à 133.

Exemple 3 :

Entrée : nums = [1,2,3]
Sortie : 0
Explication : Le seul triplet d'indices ordonné (0, 1, 2) a une valeur négative de (nums[0] - nums[1]) * nums[2] = -3. Par conséquent, la réponse serait 0.

Contraintes :

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


On vous donne un tableau d'entiers indexé à 0 appelé nums.
Le nombre distinct d'une sous-tableau de nums est défini comme :

Soit nums[i..j] une sous-tableau de nums composé de tous les indices de i à j tels que 0 <= i <= j < nums.length. Alors le nombre de valeurs distinctes dans nums[i..j] est appelé le nombre distinct de nums[i..j].

Renvoyez la somme des carrés des nombres distincts de toutes les sous-tableaux de nums.
Une sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [1,2,1]
Sortie : 15
Explication : Six sous-tableaux possibles sont :
[1] : 1 valeur distincte
[2] : 1 valeur distincte
[1] : 1 valeur distincte
[1,2] : 2 valeurs distinctes
[2,1] : 2 valeurs distinctes
[1,2,1] : 2 valeurs distinctes
La somme des carrés des nombres distincts dans tous les sous-tableaux est égale à 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Exemple 2 :

Entrée : nums = [1,1]
Sortie : 3
Explication : Trois sous-tableaux possibles sont :
[1] : 1 valeur distincte
[1] : 1 valeur distincte
[1,1] : 1 valeur distincte
La somme des carrés des nombres distincts dans tous les sous-tableaux est égale à 1^2 + 1^2 + 1^2 = 3.

Contraintes :

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

On vous donne un tableau d'entiers indexé à 0 nums.
Le nombre distinct d'un sous-tableau de nums est défini comme suit :

Soit nums[i..j] un sous-tableau de nums constitué de tous les indices de i à j tels que 0 <= i <= j < nums.length. Le nombre de valeurs distinctes dans nums[i..j] est alors appelé le nombre distinct de nums[i..j].

Renvoie la somme des carrés des nombres distincts de tous les sous-tableaux de nums.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,2,1]
Sortie : 15
Explication : Six sous-tableaux possibles :
[1] : 1 valeur distincte
[2] : 1 valeur distincte
[1] : 1 valeur distincte
[1,2] : 2 valeurs distinctes
[2,1] : 2 valeurs distinctes
[1,2,1] : 2 valeurs distinctes
La somme des carrés des nombres distincts dans tous les sous-tableaux est égale à 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Exemple 2 :

Entrée : nums = [1,1]
Sortie : 3
Explication : Trois sous-tableaux possibles :
[1] : 1 valeur distincte
[1] : 1 valeur distincte
[1,1] : 1 valeur distincte
La somme des carrés des nombres distincts dans tous les Les sous-tableaux sont égaux à 1^2 + 1^2 + 1^2 = 3.

Contraintes :

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

Vous avez un tableau nums d'entiers indexé à 0.
Le nombre distinct d'une sous-tableau de nums est défini comme :

Soit nums[i..j] une sous-tableau de nums composé de tous les indices de i à j tels que 0 <= i <= j < nums.length. Alors le nombre de valeurs distinctes dans nums[i..j] est appelé le nombre distinct de nums[i..j].

Retournez la somme des carrés des nombres distincts de toutes les sous-tableaux de nums.
Une sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [1,2,1]
Sortie : 15
Explication : Six sous-tableaux possibles sont :
[1] : 1 valeur distincte
[2] : 1 valeur distincte
[1] : 1 valeur distincte
[1,2] : 2 valeurs distinctes
[2,1] : 2 valeurs distinctes
[1,2,1] : 2 valeurs distinctes
La somme des carrés des nombres distincts dans tous les sous-tableaux est égale à 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Exemple 2 :

Entrée : nums = [1,1]
Sortie : 3
Explication : Trois sous-tableaux possibles sont :
[1] : 1 valeur distincte
[1] : 1 valeur distincte
[1,1] : 1 valeur distincte
La somme des carrés des nombres distincts dans tous les sous-tableaux est égale à 1^2 + 1^2 + 1^2 = 3.

Contraintes :

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


Étant donné un tableau 0-indexé de chaînes de caractères `words` où `words[i]` est soit un entier positif représenté en tant que chaîne, soit la chaîne "prev". Commencez à itérer depuis le début du tableau ; pour chaque chaîne "prev" vue dans `words`, trouvez le dernier entier visité défini comme suit :

Soit k le nombre de chaînes "prev" consécutives vues jusqu'ici (comprenant la chaîne actuelle). Soit `nums` le tableau 0-indexé des entiers vus jusqu'à présent et `nums_reverse` l'inverse de `nums`, alors l'entier à l'index (k - 1) de `nums_reverse` sera le dernier entier visité pour ce "prev". Si k est supérieur au nombre total d'entiers visités, alors le dernier entier visité sera -1.

Renvoyez un tableau d'entiers contenant les derniers entiers visités.

Exemple 1 :

Entrée : words = ["1","2","prev","prev","prev"]
Sortie : [2,1,-1]
Explication :
Pour "prev" à l'index = 2, le dernier entier visité sera 2 car ici le nombre de chaînes "prev" consécutives est 1, et dans le tableau `reverse_nums`, 2 sera le premier élément.
Pour "prev" à l'index = 3, le dernier entier visité sera 1 car il y a un total de deux chaînes "prev" consécutives y compris ce "prev" qui sont visitées, et 1 est le deuxième dernier entier visité.
Pour "prev" à l'index = 4, le dernier entier visité sera -1 car il y a un total de trois chaînes "prev" consécutives y compris ce "prev" qui sont visitées, mais le nombre total d'entiers visités est de deux.

Exemple 2 :

Entrée : words = ["1","prev","2","prev","prev"]
Sortie : [1,2,1]
Explication :
Pour "prev" à l'index = 1, le dernier entier visité sera 1.
Pour "prev" à l'index = 3, le dernier entier visité sera 2.
Pour "prev" à l'index = 4, le dernier entier visité sera 1 car il y a un total de deux chaînes "prev" consécutives y compris ce "prev" qui sont visitées, et 1 est le deuxième dernier entier visité.

Contraintes :

1 <= words.length <= 100
words[i] == "prev" ou 1 <= int(words[i]) <= 100

Étant donné un tableau indexé à partir de 0 de chaînes de caractères words où words[i] est soit un entier positif représenté en tant que chaîne, soit la chaîne "prev".
Commencez à itérer depuis le début du tableau ; pour chaque chaîne "prev" vue dans words, trouvez le dernier entier visité défini comme suit :

Soit k le nombre de chaînes "prev" consécutives vues jusqu'ici (comprenant la chaîne actuelle). Soit nums le tableau indexé à partir de 0 des entiers vus jusqu'à présent et nums_reverse l'inverse de nums, alors l'entier à l'index (k - 1) de nums_reverse sera le dernier entier visité pour ce "prev".
Si k est supérieur au nombre total d'entiers visités, alors le dernier entier visité sera -1.

Retournez un tableau d'entiers contenant les derniers entiers visités.

Exemple 1 :

Entrée : words = ["1","2","prev","prev","prev"]
Sortie : [2,1,-1]
Explication :
Pour "prev" à l'index = 2, le dernier entier visité sera 2 car ici le nombre de chaînes "prev" consécutives est 1, et dans le tableau reverse_nums, 2 sera le premier élément.
Pour "prev" à l'index = 3, le dernier entier visité sera 1 car il y a un total de deux chaînes "prev" consécutives y compris ce "prev" qui sont visitées, et 1 est le deuxième dernier entier visité.
Pour "prev" à l'index = 4, le dernier entier visité sera -1 car il y a un total de trois chaînes "prev" consécutives y compris ce "prev" qui sont visitées, mais le nombre total d'entiers visités est de deux.

Exemple 2 :

Entrée : words = ["1","prev","2","prev","prev"]
Sortie : [1,2,1]
Explication :
Pour "prev" à l'index = 1, le dernier entier visité sera 1.
Pour "prev" à l'index = 3, le dernier entier visité sera 2.
Pour "prev" à l'index = 4, le dernier entier visité sera 1 car il y a un total de deux chaînes "prev" consécutives y compris ce "prev" qui sont visitées, et 1 est le deuxième dernier entier visité.

Contraintes :

1 <= words.length <= 100
words[i] == "prev" ou 1 <= int(words[i]) <= 100

Etant donné un tableau de chaînes de caractères indexées 0, où words[i] est soit un entier positif représenté sous forme de chaîne de caractères, soit la chaîne "prev".
Commencez à itérer à partir du début du tableau ; pour chaque chaîne « prev » vue dans words, trouvez le dernier entier visité dans words qui est défini comme suit :

Soit k le nombre de chaînes « prev » consécutives vues jusqu'à présent (contenant la chaîne actuelle). Soit nums le tableau indexé 0 des entiers vus jusqu'à présent et nums_reverse l'inverse de nums, alors l'entier à (k - 1)^ème index de nums_reverse sera le dernier entier visité pour ce "prev".
Si k est supérieur au nombre total d'entiers visités, alors le dernier entier visité sera -1.

La fonction retourne un tableau d'entiers contenant les derniers entiers visités.Exemple 1:

Entrée : words = ["1","2","prev","prev","prev"]
Sortie : [2,1,-1]
Explication :
Pour "prev" à l'index = 2, le dernier entier visité sera 2 car ici le nombre de chaînes "prev" consécutives est 1, et dans le tableau reverse_nums, 2 sera le premier élément.
Pour "prev" à l'index = 3, le dernier entier visité sera 1 car il y a au total deux chaînes "prev" consécutives, y compris cette chaîne "prev", qui sont visitées, et 1 est l'avant-dernier entier visité.
Pour "prev" à l'index = 4, le dernier entier visité sera -1 car il y a un total de trois chaînes "prev" consécutives, y compris cette chaîne "prev", qui sont visitées, mais le nombre total d'entiers visités est de deux.
Exemple 2:

Entrée: words = ["1","prev","2","prev","prev"]
Sortie: [1,2,1]
Explication:
Pour "prev" à l'index = 1, le dernier entier visité sera 1.
Pour "prev" à Index = 3, le dernier entier visité sera 2.
Pour "prev" à Index = 4, le dernier entier visité sera 1, car il y a un total de deux chaînes ""prev" consécutives, y compris ce "prev" qui est visité, et 1 est le deuxième entier dernier visité.

Contraintes:

1 <= words.length <= 100
words[i] == "prev" ou 1 <= int(words[i]) <= 100


Vous avez un tableau d'entiers nums de longueur n indexé à partir de 0.
Nous voulons regrouper les indices afin que pour chaque indice i dans la plage [0, n - 1], celui-ci soit assigné à exactement un groupe.
Un regroupement est valide si les conditions suivantes sont remplies :

Pour chaque groupe g, tous les indices i assignés au groupe g ont la même valeur dans nums.
Pour deux groupes g_1 et g_2 quelconques, la différence entre le nombre d'indices assignés à g_1 et g_2 ne doit pas dépasser 1.

Retournez un entier représentant le nombre minimum de groupes nécessaires pour créer un regroupement valide.

Exemple 1 :

Entrée : nums = [3,2,3,2,3]
Sortie : 2
Explication : Une façon d'assigner les indices à 2 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0,2,4]
groupe 2 -> [1,3]
Tous les indices sont assignés à un groupe.
Dans le groupe 1, nums[0] == nums[2] == nums[4], donc tous les indices ont la même valeur.
Dans le groupe 2, nums[1] == nums[3], donc tous les indices ont la même valeur.
Le nombre d'indices assignés au groupe 1 est 3, et le nombre d'indices assignés au groupe 2 est 2.
Leur différence ne dépasse pas 1.
Il n'est pas possible d'utiliser moins de 2 groupes parce que, pour n'utiliser qu'un seul groupe, tous les indices assignés à ce groupe doivent avoir la même valeur.
Ainsi, la réponse est 2.
Exemple 2 :

Entrée : nums = [10,10,10,3,1,1]
Sortie : 4
Explication : Une façon d'assigner les indices à 4 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0]
groupe 2 -> [1,2]
groupe 3 -> [3]
groupe 4 -> [4,5]
L'assignation des groupes ci-dessus satisfait les deux conditions.
Il peut être démontré qu'il n'est pas possible de créer une assignation valide en utilisant moins de 4 groupes.
Ainsi, la réponse est 4.

Contraintes :

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

On vous donne un tableau d'entiers indexés à 0 nums de longueur n.
Nous voulons regrouper les indices de sorte que pour chaque indice i dans la plage [0, n - 1], il soit attribué exactement à un groupe.
Une affectation de groupe est valide si les conditions suivantes sont remplies :

Pour chaque groupe g, tous les indices i attribués au groupe g ont la même valeur dans nums.
Pour deux groupes quelconques g_1 et g_2, la différence entre le nombre d'indices attribués à g_1 et g_2 ne doit pas dépasser 1.

Renvoyer un entier indiquant le nombre minimum de groupes nécessaires pour créer une affectation de groupe valide.

Exemple 1 :

Entrée : nums = [3,2,3,2,3]
Sortie : 2
Explication : Une façon d'attribuer les indices à 2 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0,2,4]
groupe 2 -> [1,3]
Tous les indices sont attribués à un groupe.
Dans le groupe 1, nums[0] == nums[2] == nums[4], donc tous les indices ont la même valeur.
Dans le groupe 2, nums[1] == nums[3], donc tous les indices ont la même valeur.
Le nombre d'indices attribués au groupe 1 est de 3, et le nombre d'indices attribués au groupe 2 est de 2.
Leur différence ne dépasse pas 1.
Il n'est pas possible d'utiliser moins de 2 groupes car, pour n'utiliser qu'un seul groupe, tous les indices attribués à ce groupe doivent avoir la même valeur.
Par conséquent, la réponse est 2.
Exemple 2 :

Entrée : nums = [10,10,10,3,1,1]
Sortie : 4
Explication : Une façon d'attribuer les indices à 4 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0]
groupe 2 -> [1,2]
groupe 3 -> [3]
groupe 4 -> [4,5]
L'affectation de groupe ci-dessus satisfait les deux conditions.
Il peut être démontré qu'il n'est pas possible de créer une affectation valide en utilisant moins de 4 groupes.
Par conséquent, la réponse est 4.

Contraintes :

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

Vous avez un tableau d'entiers nums de longueur n indexé à partir de 0.
Nous voulons regrouper les indices afin que pour chaque indice i dans la plage [0, n - 1], il soit assigné à exactement un groupe.
Un regroupement est valide si les conditions suivantes sont remplies :

Pour chaque groupe g, tous les indices i assignés au groupe g ont la même valeur dans nums.
Pour deux groupes g_1 et g_2 quelconques, la différence entre le nombre d'indices assignés à g_1 et g_2 ne doit pas dépasser 1.

Retournez un entier représentant le nombre minimum de groupes nécessaires pour créer un regroupement valide.

Exemple 1 :

Entrée : nums = [3,2,3,2,3]
Sortie : 2
Explication : une façon d'assigner les indices à 2 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0,2,4]
groupe 2 -> [1,3]
Tous les indices sont assignés à un groupe.
Dans le groupe 1, nums[0] == nums[2] == nums[4], donc tous les indices ont la même valeur.
Dans le groupe 2, nums[1] == nums[3], donc tous les indices ont la même valeur.
Le nombre d'indices assignés au groupe 1 est 3, et le nombre d'indices assignés au groupe 2 est 2.
Leur différence ne dépasse pas 1.
Il n'est pas possible d'utiliser moins de 2 groupes parce que, pour n'utiliser qu'un seul groupe, tous les indices assignés à ce groupe doivent avoir la même valeur.
Ainsi, la réponse est 2.
Exemple 2 :

Entrée : nums = [10,10,10,3,1,1]
Sortie : 4
Explication : une façon d'assigner les indices à 4 groupes est la suivante, où les valeurs entre crochets sont des indices :
groupe 1 -> [0]
groupe 2 -> [1,2]
groupe 3 -> [3]
groupe 4 -> [4,5]
L'assignation des groupes ci-dessus satisfait les deux conditions.
Il peut être démontré qu'il n'est pas possible de créer une assignation valide en utilisant moins de 4 groupes.
Ainsi, la réponse est 4.

Contraintes :

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


Vous avez deux tableaux nums1 et nums2 composés d'entiers positifs.
Vous devez remplacer tous les 0 dans les deux tableaux par des entiers strictement positifs de sorte que la somme des éléments des deux tableaux devienne égale.
Retournez la somme égale minimale que vous pouvez obtenir, ou -1 si c'est impossible.

Exemple 1 :

Entrée : nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Sortie : 12
Explication : Nous pouvons remplacer les 0 de la manière suivante :
- Remplacer les deux 0 dans nums1 par les valeurs 2 et 4. Le tableau résultant est nums1 = [3,2,2,1,4].
- Remplacer le 0 dans nums2 par la valeur 1. Le tableau résultant est nums2 = [6,5,1].
Les deux tableaux ont une somme égale de 12. Il peut être démontré que c'est la somme minimale que nous pouvons obtenir.

Exemple 2 :

Entrée : nums1 = [2,0,2,0], nums2 = [1,4]
Sortie : -1
Explication: Il est impossible de rendre la somme des deux tableaux égale.

Contraintes :

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Vous avez deux tableaux nums1 et nums2 composés d'entiers positifs.
Vous devez remplacer tous les 0 dans les deux tableaux par des entiers strictement positifs de sorte que la somme des éléments des deux tableaux devienne égale.
Retournez la somme égale minimale que vous pouvez obtenir, ou -1 si c'est impossible.

Exemple 1 :

Entrée: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Sortie: 12
Explication: Nous pouvons remplacer les 0 de la manière suivante :
- Remplacez les deux 0 dans nums1 par les valeurs 2 et 4. Le tableau résultant est nums1 = [3,2,2,1,4].
- Remplacez le 0 dans nums2 par la valeur 1. Le tableau résultant est nums2 = [6,5,1].
Les deux tableaux ont une somme égale de 12. Il peut être démontré que c'est la somme minimale que nous pouvons obtenir.

Exemple 2 :

Entrée: nums1 = [2,0,2,0], nums2 = [1,4]
Sortie: -1
Explication: Il est impossible de rendre la somme des deux tableaux égale.

Contraintes :

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


On vous donne des entiers positifs n et m.
Définissez deux entiers, num1 et num2, comme suit :

num1 : La somme de tous les entiers dans la plage [1, n] qui ne sont pas divisibles par m.
num2 : La somme de tous les entiers dans la plage [1, n] qui sont divisibles par m.

Retournez l'entier num1 - num2.

Exemple 1 :

Entrée : n = 10, m = 3
Sortie : 19
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 10] qui ne sont pas divisibles par 3 sont [1,2,4,5,7,8,10], num1 est la somme de ces entiers = 37.
- Les entiers dans la plage [1, 10] qui sont divisibles par 3 sont [3,6,9], num2 est la somme de ces entiers = 18.
Nous retournons 37 - 18 = 19 comme réponse.

Exemple 2 :

Entrée : n = 5, m = 6
Sortie : 15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 6 sont [1,2,3,4,5], num1 est la somme de ces entiers = 15.
- Les entiers dans la plage [1, 5] qui sont divisibles par 6 sont [], num2 est la somme de ces entiers = 0.
Nous retournons 15 - 0 = 15 comme réponse.

Exemple 3 :

Entrée : n = 5, m = 1
Sortie : -15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 1 sont [], num1 est la somme de ces entiers = 0.
- Les entiers dans la plage [1, 5] qui sont divisibles par 1 sont [1,2,3,4,5], num2 est la somme de ces entiers = 15.
Nous retournons 0 - 15 = -15 comme réponse.

Contraintes :

1 <= n, m <= 1000

On vous donne des entiers positifs n et m.
Définissez deux entiers, num1 et num2, comme suit :

num1 : La somme de tous les entiers dans la plage [1, n] qui ne sont pas divisibles par m.
num2 : La somme de tous les entiers dans la plage [1, n] qui sont divisibles par m.

Renvoyez l'entier num1 - num2.

Exemple 1 :

Entrée : n = 10, m = 3
Sortie : 19
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 10] qui ne sont pas divisibles par 3 sont [1,2,4,5,7,8,10], num1 est la somme de ces entiers = 37.
- Les entiers dans la plage [1, 10] qui sont divisibles par 3 sont [3,6,9], num2 est la somme de ces entiers = 18.
Nous renvoyons 37 - 18 = 19 comme réponse.

Exemple 2 :

Entrée : n = 5, m = 6
Sortie : 15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 6 sont [1,2,3,4,5], num1 est la somme de ces entiers = 15.
- Les entiers dans la plage [1, 5] qui sont divisibles par 6 sont [], num2 est la somme de ces entiers = 0.
Nous renvoyons 15 - 0 = 15 comme réponse.

Exemple 3 :

Entrée : n = 5, m = 1
Sortie : -15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 1 sont [], num1 est la somme de ces entiers = 0.
- Les entiers dans la plage [1, 5] qui sont divisibles par 1 sont [1,2,3,4,5], num2 est la somme de ces entiers = 15.
Nous renvoyons 0 - 15 = -15 comme réponse.

Contraintes :

1 <= n, m <= 1000

On vous donne des entiers positifs n et m.
Définissez deux entiers, num1 et num2, comme suit :

num1 : la somme de tous les entiers de la plage [1, n] qui ne sont pas divisibles par m.
num2 : la somme de tous les entiers de la plage [1, n] qui sont divisibles par m.

Renvoie l'entier num1 - num2.

Exemple 1 :

Entrée : n = 10, m = 3
Sortie : 19
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 10] qui ne sont pas divisibles par 3 sont [1,2,4,5,7,8,10], num1 est la somme de ces entiers = 37.
- Les entiers dans la plage [1, 10] qui sont divisibles par 3 sont [3,6,9], num2 est la somme de ces entiers = 18.
Nous renvoyons 37 - 18 = 19 comme réponse.

Exemple 2 :

Entrée : n = 5, m = 6
Sortie : 15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 6 sont [1,2,3,4,5], num1 est la somme de ces entiers = 15.
- Les entiers dans la plage [1, 5] qui sont divisibles par 6 sont [], num2 est la somme de ces entiers = 0.
Nous renvoyons 15 - 0 = 15 comme réponse.

Exemple 3 :

Entrée : n = 5, m = 1
Sortie : -15
Explication : Dans l'exemple donné :
- Les entiers dans la plage [1, 5] qui ne sont pas divisibles par 1 sont [], num1 est la somme de ces entiers = 0.
- Les entiers dans la plage [1, 5] qui sont divisibles par 1 sont [1,2,3,4,5], num2 est la somme de ces entiers = 15.
Nous renvoyons 0 - 15 = -15 comme réponse.

Contraintes :

1 <= n, m <= 1000