On vous donne une chaîne s à indice 0, une chaîne a, une chaîne b, et un entier k.
Un indice i est beau si :

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Il existe un indice j tel que :

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Renvoyez le tableau contenant les beaux indices triés par ordre croissant.

Exemple 1 :

Entrée : s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Sortie : [16,33]
Explication : Il y a 2 beaux indices: [16,33].
- L'indice 16 est beau car s[16..17] == "my" et il existe un indice 4 avec s[4..11] == "squirrel" et |16 - 4| <= 15.
- L'indice 33 est beau car s[33..34] == "my" et il existe un indice 18 avec s[18..25] == "squirrel" et |33 - 18| <= 15.
Ainsi, nous renvoyons [16,33] comme résultat.

Exemple 2 :

Entrée : s = "abcd", a = "a", b = "a", k = 4
Sortie : [0]
Explication : Il y a 1 indice beau : [0].
- L'indice 0 est beau car s[0..0] == "a" et il existe un indice 0 avec s[0..0] == "a" et |0 - 0| <= 4.
Ainsi, nous renvoyons [0] comme résultat.

Contraintes :

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, et b contiennent uniquement des lettres minuscules anglaises.

On vous donne une chaîne s indexée à partir de 0, une chaîne a, une chaîne b, et un entier k.
Un indice i est dit beau si :

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Il existe un indice j tel que :

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Retournez le tableau contenant les indices beaux triés dans l'ordre croissant.

Exemple 1 :

Entrée : s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Sortie : [16,33]
Explication : Il y a 2 indices beaux : [16,33].
- L'indice 16 est beau car s[16..17] == "my" et il existe un indice 4 avec s[4..11] == "squirrel" et |16 - 4| <= 15.
- L'indice 33 est beau car s[33..34] == "my" et il existe un indice 18 avec s[18..25] == "squirrel" et |33 - 18| <= 15.
Ainsi, nous retournons [16,33] comme résultat.

Exemple 2 :

Entrée : s = "abcd", a = "a", b = "a", k = 4
Sortie : [0]
Explication : Il y a 1 indice beau : [0].
- L'indice 0 est beau car s[0..0] == "a" et il existe un indice 0 avec s[0..0] == "a" et |0 - 0| <= 4.
Ainsi, nous retournons [0] comme résultat.

Contraintes :

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, et b contiennent uniquement des lettres minuscules anglaises.

On vous donne une chaîne s indexée à partir de 0, une chaîne a, une chaîne b, et un entier k.
Un indice i est beau si :

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Il existe un indice j tel que :

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Retournez le tableau contenant les indices beaux triés par ordre croissant.

Exemple 1 :

Entrée : s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Sortie : [16,33]
Explication : il y a 2 indices beaux : [16,33].
- L'indice 16 est beau car s[16..17] == "my" et il existe un indice 4 avec s[4..11] == "squirrel" et |16 - 4| <= 15.
- L'indice 33 est beau car s[33..34] == "my" et il existe un indice 18 avec s[18..25] == "squirrel" et |33 - 18| <= 15.
Ainsi, nous renvoyons [16,33] comme résultat.

Exemple 2 :

Entrée : s = "abcd", a = "a", b = "a", k = 4
Sortie : [0]
Explication : il y a 1 indice beau : [0].
- L'indice 0 est beau car s[0..0] == "a" et il existe un indice 0 avec s[0..0] == "a" et |0 - 0| <= 4.
Ainsi, nous renvoyons [0] comme résultat.

Contraintes :

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, et b contiennent uniquement des lettres minuscules anglaises.


Vous avez un tableau d'entiers positifs nums.
Vous devez vérifier s'il est possible de sélectionner deux éléments ou plus dans le tableau tels que l'opération OR bit à bit des éléments sélectionnés ait au moins un zéro de fin dans sa représentation binaire.
Par exemple, la représentation binaire de 5, qui est "101", n'a pas de zéros de fin, alors que la représentation binaire de 4, qui est "100", a deux zéros de fin.
Retournez true s'il est possible de sélectionner deux éléments ou plus dont l'opération OR bit à bit a des zéros de fin, sinon retournez false.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OR bit à bit est 6, qui a la représentation binaire "110" avec un zéro de fin.

Exemple 2 :

Entrée : nums = [2,4,8,16]
Sortie : true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OR bit à bit est 6, qui a la représentation binaire "110" avec un zéro de fin.
D'autres façons possibles de sélectionner des éléments pour avoir des zéros de fin dans la représentation binaire de leur OR bit à bit sont : (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), et (2, 4, 8, 16).

Exemple 3 :

Entrée : nums = [1,3,5,7,9]
Sortie : false
Explication : Il n'y a pas de moyen possible de sélectionner deux éléments ou plus pour avoir des zéros de fin dans la représentation binaire de leur OR bit à bit.

Contraintes :

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

On vous donne un tableau d'entiers positifs nums.
Vous devez vérifier s'il est possible de sélectionner deux éléments ou plus dans le tableau de telle sorte que le OU binaire des éléments sélectionnés ait au moins un zéro final dans sa représentation binaire.
Par exemple, la représentation binaire de 5, qui est "101", n'a aucun zéro final, alors que la représentation binaire de 4, qui est "100", a deux zéros finals.
Renvoie true s'il est possible de sélectionner deux éléments ou plus dont le OU binaire a des zéros finals, renvoie false sinon.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OU binaire est 6, qui a la représentation binaire "110" avec un zéro final.

Exemple 2 :

Entrée : nums = [2,4,8,16]
Sortie : true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OU binaire est 6, ce qui a pour représentation binaire "110" avec un zéro à la fin.
D'autres manières possibles de sélectionner des éléments pour avoir des zéros à la fin de la représentation binaire de leur OU binaire sont : (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) et (2, 4, 8, 16).

Exemple 3 :

Entrée : nums = [1,3,5,7,9]
Sortie : false
Explication : Il n'existe aucun moyen possible de sélectionner deux éléments ou plus pour avoir des zéros à la fin de la représentation binaire de leur OU binaire.

Contraintes :

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

Vous avez un tableau d'entiers positifs nums.
Vous devez vérifier s'il est possible de sélectionner deux éléments ou plus dans le tableau tels que l'opération OU bit à bit des éléments sélectionnés ait au moins un zéro de fin dans sa représentation binaire.
Par exemple, la représentation binaire de 5, qui est "101", n'a pas de zéros de fin, alors que la représentation binaire de 4, qui est "100", a deux zéros de fin.
Retournez true s'il est possible de sélectionner deux éléments ou plus dont l'opération OU bit à bit a des zéros de fin, sinon retournez false.

Exemple 1 :

Input: nums = [1,2,3,4,5]
Output: true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OU bit à bit est 6, qui a la représentation binaire "110" avec un zéro de fin.

Exemple 2 :

Input: nums = [2,4,8,16]
Output: true
Explication : Si nous sélectionnons les éléments 2 et 4, leur OU bit à bit est 6, qui a la représentation binaire "110" avec un zéro de fin.
D'autres façons possibles de sélectionner des éléments pour avoir des zéros de fin dans la représentation binaire de leur OU bit à bit sont : (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), et (2, 4, 8, 16).

Exemple 3 :

Input: nums = [1,3,5,7,9]
Output: false
Explication : Il n'y a pas de moyen possible de sélectionner deux éléments ou plus pour avoir des zéros de fin dans la représentation binaire de leur OU bit à bit.

Contraintes :

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


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

Choisissez n'importe quel élément du tableau et inversez un bit dans sa représentation binaire. Inverser un bit signifie changer un 0 en 1 ou vice versa.

Retournez le nombre minimum d'opérations nécessaires pour que le XOR bit à bit de tous les éléments du tableau final soit égal à k.
Notez que vous pouvez inverser les bits zéro de tête dans la représentation binaire des éléments. Par exemple, pour le nombre (101)_2, vous pouvez inverser le quatrième bit et obtenir (1101)_2.

Exemple 1 :

Entrée : nums = [2,1,3,4], k = 1
Sortie : 2
Explication : Nous pouvons faire les opérations suivantes :
- Choisissez l'élément 2 qui est 3 == (011)_2, nous inversons le premier bit et nous obtenons (010)_2 == 2. nums devient [2,1,2,4].
- Choisissez l'élément 0 qui est 2 == (010)_2, nous inversons le troisième bit et nous obtenons (110)_2 = 6. nums devient [6,1,2,4].
Le XOR des éléments du tableau final est (6 XOR 1 XOR 2 XOR 4) == 1 == k.
On peut montrer qu'on ne peut pas faire en sorte que le XOR soit égal à k en moins de 2 opérations.

Exemple 2 :

Entrée : nums = [2,0,2,0], k = 0
Sortie : 0
Explication : Le XOR des éléments du tableau est (2 XOR 0 XOR 2 XOR 0) == 0 == k. Aucune opération n'est donc nécessaire.

Contraintes :

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

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

Choisissez n'importe quel élément du tableau et retournez un bit dans sa représentation binaire. Faire un peu signifie changer un 0 à 1 ou vice versa.

Renvoie le nombre minimum d'opérations nécessaires pour rendre le XOR de tous les éléments du tableau final égal à k.
Notez que vous pouvez retourner les bits de tête zéro dans la représentation binaire des éléments. Par exemple, pour le nombre (101) _2, vous pouvez retourner le quatrième bit et obtenir (1101) _2.

Exemple 1:

Entrée: nums = [2,1,3,4], k = 1
Sortie: 2
Explication: Nous pouvons effectuer les opérations suivantes:
- Choisissez l'élément 2 qui est 3 == (011) _2, nous retournons le premier bit et nous obtenons (010) _2 == 2. Nums devient [2,1,2,4].
- Choisissez l'élément 0 qui est 2 == (010) _2, nous retournons le troisième bit et nous obtenons (110) _2 = 6. Nums devient [6,1,2,4].
Le xor des éléments du tableau final est (6 xor 1 xor 2 xor 4) == 1 == k.
Il peut être démontré que nous ne pouvons pas rendre le XOR égal à k en moins de 2 opérations.

Exemple 2:

Entrée: nums = [2,0,2,0], k = 0
Sortie: 0
Explication: Le xor des éléments du tableau est (2 xor 0 xor 2 xor 0) == 0 == k. Donc, aucune opération n'est nécessaire.

Contraintes:

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

On donne un tableau nums d'entiers 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 n'importe quel élément du tableau et inversez un bit dans sa représentation binaire. Inverser un bit signifie changer un 0 en 1 ou vice versa.

Retournez le nombre minimum d'opérations nécessaires pour que le XOR bit à bit de tous les éléments du tableau final soit égal à k.
Notez que vous pouvez inverser les bits zéro de tête dans la représentation binaire des éléments. Par exemple, pour le nombre (101)_2, vous pouvez inverser le quatrième bit et obtenir (1101)_2.

Exemple 1 :

Entrée : nums = [2,1,3,4], k = 1
Sortie : 2
Explication : Nous pouvons faire les opérations suivantes :
- Choisissez l'élément 2 qui est 3 == (011)_2, nous inversons le premier bit et nous obtenons (010)_2 == 2. nums devient [2,1,2,4].
- Choisissez l'élément 0 qui est 2 == (010)_2, nous inversons le troisième bit et nous obtenons (110)_2 = 6. nums devient [6,1,2,4].
Le XOR des éléments du tableau final est (6 XOR 1 XOR 2 XOR 4) == 1 == k.
On peut montrer qu'on ne peut pas faire en sorte que le XOR soit égal à k en moins de 2 opérations.

Exemple 2 :

Entrée : nums = [2,0,2,0], k = 0
Sortie : 0
Explication : Le XOR des éléments du tableau est (2 XOR 0 XOR 2 XOR 0) == 0 == k. Aucune opération n'est donc nécessaire.

Contraintes :

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


Vous disposez d'un tableau 2D d'entiers à indexation 0, dimensions.
Pour tous les indices i, 0 <= i < dimensions.length, dimensions[i][0] représente la longueur et dimensions[i][1] représente la largeur du rectangle i.
Retournez l'aire du rectangle ayant la plus longue diagonale. S'il y a plusieurs rectangles avec la plus longue diagonale, retournez l'aire du rectangle ayant la superficie maximale.

Exemple 1:

Entrée: dimensions = [[9,3],[8,6]]
Sortie: 48
Explication:
Pour l'indice = 0, longueur = 9 et largeur = 3. Longueur de la diagonale = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Pour l'indice = 1, longueur = 8 et largeur = 6. Longueur de la diagonale = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Ainsi, le rectangle à l'indice 1 a une plus grande longueur de diagonale donc nous retournons l'aire = 8 * 6 = 48.

Exemple 2:

Entrée: dimensions = [[3,4],[4,3]]
Sortie: 12
Explication: La longueur de la diagonale est la même pour les deux qui est 5, donc aire maximale = 12.

Contraintes:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

On vous donne un tableau 2D d'entiers indexés 0, dimensions.
Pour tous les indices i, 0 <= i < dimensions.length, dimensions[i][0] représente la longueur et dimensions[i][1] représente la largeur du rectangle i.
Retourne la surface du rectangle ayant la diagonale la plus longue. S'il y a plusieurs rectangles ayant la plus longue diagonale, le système renvoie l'aire du rectangle ayant l'aire la plus grande.

Exemple 1 :

Entrée : dimensions = [[9,3],[8,6]]
Sortie : 48
Explication :
Pour l'indice = 0, la longueur = 9 et la largeur = 3. Longueur de la diagonale = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Pour l'indice = 1, la longueur = 8 et la largeur = 6. Longueur de la diagonale = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Ainsi, le rectangle à l'indice 1 a une plus grande longueur diagonale et nous obtenons donc l'aire = 8 * 6 = 48.

Exemple 2 :

Entrée : dimensions = [[3,4],[4,3]]
Sortie : 12
Explication : La longueur de la diagonale est la même pour les deux, soit 5, donc la surface maximale= 12.

Contraintes :

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Vous disposez d'un tableau 2D d'entiers dimensions indexé à partir de 0.
Pour tous les indices i, 0 <= i < dimensions.length, dimensions[i][0] représente la longueur et dimensions[i][1] représente la largeur du rectangle i.
Retournez l'aire du rectangle ayant la plus longue diagonale. S'il y a plusieurs rectangles avec la plus longue diagonale, retournez l'aire du rectangle ayant la superficie maximale.

Exemple 1:

Entrée: dimensions = [[9,3],[8,6]]
Sortie: 48
Explication:
Pour l'indice = 0, longueur = 9 et largeur = 3. Longueur de la diagonale = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Pour l'indice = 1, longueur = 8 et largeur = 6. Longueur de la diagonale = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Ainsi, le rectangle à l'indice 1 a une plus grande longueur de diagonale donc nous retournons l'aire = 8 * 6 = 48.

Exemple 2:

Entrée: dimensions = [[3,4],[4,3]]
Sortie: 12
Explication: La longueur de la diagonale est la même pour les deux qui est 5, donc aire maximale = 12.

Contraintes:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100


On vous donne un tableau indexé à 0 d'entiers positifs nums.
Un sous-tableau de nums est appelé incremovable si nums devient strictement croissant en supprimant le sous-tableau. Par exemple, le sous-tableau [3, 4] est un sous-tableau incremovable de [5, 3, 4, 6, 7] car supprimer ce sous-tableau transforme le tableau [5, 3, 4, 6, 7] en [5, 6, 7] qui est strictement croissant.
Retournez le nombre total de sous-tableaux incremovables de nums.
Notez qu'un tableau vide est considéré comme strictement croissant.
Un sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 10
Explication : Les 10 sous-tableaux incremovables sont : [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], et [1,2,3,4], car en supprimant n’importe lequel de ces sous-tableaux, nums devient strictement croissant. Notez que vous ne pouvez pas sélectionner un sous-tableau vide.

Exemple 2 :

Entrée : nums = [6,5,7,8]
Sortie : 7
Explication : Les 7 sous-tableaux incremovables sont : [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] et [6,5,7,8]. Il peut être montré qu'il n'y a que 7 sous-tableaux incremovables dans nums.

Exemple 3 :

Entrée : nums = [8,7,6,6]
Sortie : 3
Explication : Les 3 sous-tableaux incremovables sont : [8,7,6], [7,6,6], et [8,7,6,6]. Notez que [8,7] n'est pas un sous-tableau incremovable car, après suppression de [8,7], nums devient [6,6], qui est trié dans l'ordre croissant mais pas strictement croissant.

Contraintes :

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

On vous donne un tableau indexé à 0 d'entiers positifs nums.
Un sous-tableau de nums est appelé incrémoval si nums devient strictement croissant en supprimant le sous-tableau. Par exemple, le sous-tableau [3, 4] est un sous-tableau incrémoval de [5, 3, 4, 6, 7] car supprimer ce sous-tableau transforme le tableau [5, 3, 4, 6, 7] en [5, 6, 7] qui est strictement croissant.
Retournez le nombre total de sous-tableaux incrémovals de nums.
Notez qu'un tableau vide est considéré comme strictement croissant.
Un sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1:

Entrée: nums = [1,2,3,4]
Sortie: 10
Explication: Les 10 sous-tableaux incrémovals sont: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], et [1,2,3,4], car en supprimant n’importe lequel de ces sous-tableaux, nums devient strictement croissant. Notez que vous ne pouvez pas sélectionner un sous-tableau vide.

Exemple 2:

Entrée: nums = [6,5,7,8]
Sortie: 7
Explication: Les 7 sous-tableaux incrémovals sont: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] et [6,5,7,8].
Il peut être montré qu'il n'y a que 7 sous-tableaux incrémovals dans nums.

Exemple 3:

Entrée: nums = [8,7,6,6]
Sortie: 3
Explication: Les 3 sous-tableaux incrémovals sont: [8,7,6], [7,6,6], et [8,7,6,6]. Notez que [8,7] n'est pas un sous-tableau incrémoval car après suppression de [8,7] nums devient [6,6], qui est trié dans l'ordre croissant mais pas strictement croissant.

Contraintes:

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

On vous donne un tableau indexé à 0 d'entiers positifs nums.
Un sous-tableau de nums est dit incréamovible si nums devient strictement croissant lors de la suppression du sous-tableau. Par exemple, le sous-tableau [3, 4] est un sous-tableau incréamovible de [5, 3, 4, 6, 7] car la suppression de ce sous-tableau change le tableau [5, 3, 4, 6, 7] en [5, 6, 7] qui est strictement croissant.
Renvoie le nombre total de sous-tableaux incréamovibles de nums.
Notez qu'un tableau vide est considéré comme strictement croissant.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 10
Explication : Les 10 sous-tableaux incréamovible sont : [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] et [1,2,3,4], car en supprimant l'un de ces sous-tableaux, nums devient strictement croissant. Notez que vous ne pouvez pas sélectionner un sous-tableau vide.

Exemple 2 :

Entrée : nums = [6,5,7,8]
Sortie : 7
Explication : Les 7 sous-tableaux incréamovible sont : [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] et [6,5,7,8].
Il peut être démontré qu'il n'y a que 7 sous-tableaux incréamovible dans nums.

Exemple 3 :

Entrée : nums = [8,7,6,6]
Sortie : 3
Explication : Les 3 sous-tableaux inamovibles sont : [8,7,6], [7,6,6] et [8,7,6,6]. Notez que [8,7] n'est pas un sous-tableau inamovible car après avoir supprimé [8,7] nums devient [6,6], qui est trié par ordre croissant mais pas strictement croissant.

Contraintes :

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


On vous donne un tableau d'entiers nums indexé à partir de 0 et un entier k.
Dans une opération, vous pouvez choisir n'importe quel indice i de nums tel que 0 <= i < nums.length - 1 et remplacer nums[i] et nums[i + 1] par une seule occurrence de nums[i] & nums[i + 1], où & représente l'opérateur AND bit-à-bit.
Retournez la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.

Exemple 1 :

Entrée : nums = [3,5,3,2,7], k = 2
Sortie : 3
Explication : Effectuons les opérations suivantes :
1. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [1,3,2,7].
2. Remplacez nums[2] et nums[3] par (nums[2] & nums[3]) pour que nums devienne égal à [1,3,2].
Le OR bit-à-bit du tableau final est 3.
On peut montrer que 3 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.
Exemple 2 :

Entrée : nums = [7,3,15,14,2,8], k = 4
Sortie : 2
Explication : Effectuons les opérations suivantes :
1. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [3,15,14,2,8].
2. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [3,14,2,8].
3. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [2,2,8].
4. Remplacez nums[1] et nums[2] par (nums[1] & nums[2]) pour que nums devienne égal à [2,0].
Le OR bit-à-bit du tableau final est 2.
On peut montrer que 2 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.

Exemple 3 :

Entrée : nums = [10,7,10,3,9,14,9,4], k = 1
Sortie : 15
Explication : Sans appliquer aucune opération, le OR bit-à-bit de nums est 15.
On peut montrer que 15 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.

Contraintes :

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

On vous donne un tableau de nombres entiers à indice 0 et un entier k.
Dans une opération, vous pouvez choisir n'importe quel indice i de nombres tel que 0 <= i < nums.length - 1 et remplacer nums[i] et nums[i + 1] par une seule occurrence de nums[i] & nums[i + 1], où & représente l'opérateur AND bit-à-bit.
Re,nvoyez la valeur minimale possible du OR bit-à-bit des éléments restants de nombres après avoir appliqué au plus k opérations.

Exemple 1 :

Entrée : nums = [3,5,3,2,7], k = 2
Sortie : 3
Explication : Effectuons les opérations suivantes :
1. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [1,3,2,7].
2. Remplacez nums[2] et nums[3] par (nums[2] & nums[3]) pour que nums devienne égal à [1,3,2].
Le OR bit-à-bit du tableau final est 3.
On peut montrer que 3 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.
Exemple 2 :

Entrée : nums = [7,3,15,14,2,8], k = 4
Sortie : 2
Explication : Effectuons les opérations suivantes :
1. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [3,15,14,2,8].
2. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [3,14,2,8].
3. Remplacez nums[0] et nums[1] par (nums[0] & nums[1]) pour que nums devienne égal à [2,2,8].
4. Remplacez nums[1] et nums[2] par (nums[1] & nums[2]) pour que nums devienne égal à [2,0].
Le OR bit-à-bit du tableau final est 2.
On peut montrer que 2 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.

Exemple 3 :

Entrée : nums = [10,7,10,3,9,14,9,4], k = 1
Sortie : 15
Explication : Sans appliquer aucune opération, le OR bit-à-bit de nums est 15.
On peut montrer que 15 est la valeur minimale possible du OR bit-à-bit des éléments restants de nums après avoir appliqué au plus k opérations.

Contraintes :

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

On vous donne un nombre de tableaux entiers indexé à 0 et un entier k.
Dans une opération, vous pouvez choisir n'importe quel index i de nums de telle sorte que 0 <= i <nums.length - 1 et remplacer nums[i] et nums[i + 1] par une seule occurrence de nums[i] & nums[i + 1], où et représente le opérateur AND bit à bit.
Renvoyez la valeur minimale possible du bit du bit ou des éléments restants de nums après avoir appliqué ans au plus k opérations.

Exemple 1:

Entrée: nums = [3,5,3,2,7], k = 2
Sortie: 3
Explication: faisons les opérations suivantes:
1. Remplacez les nums[0] et les nums[1] par (nums[0] & nums[1]) de sorte que nums devient égal à [1,3,2,7].
2. Remplacez les nums[2] et les nums[3] par (nums[2] & nums[3]) de sorte que nums devient égal à [1,3,2].
Le opérateur OR bit à bit du tableau final est de 3.
On peut montrer que 3 est la valeur minimale possible du résultat de l'opérateur OR bit à bit des éléments restants de nums après avoir appliqué dans le plus de k opérations.
Exemple 2:

Entrée: nums = [7,3,15,14,2,8], k = 4
Sortie: 2
Explication: faisons les opérations suivantes:
1. Remplacez les nums[0] et les nums[1] par (nums[0] & nums[1]) de sorte que nums devient égal à [3,15,14,2,8].
2. Remplacez les nums[0] et les nums[1] par (nums[0] & nums[1]) de sorte que nums devient égal à [3,14,2,8].
3. Remplacez les nums[0] et les nums[1] par (nums[0] & nums[1]) de sorte que nums devient égal à [2,2,8].
4. Remplacez les nums[1] et les nums[2] par (nums[1] & nums[2]) de sorte que nums devient égal à [2,0].
Le opérateur OR bit à bit du tableau final est de 2.
On peut montrer que 2 est la valeur minimale possible du bit du bit ou des éléments restants de nums après avoir appliqué dans le plus de k opérations.

Exemple 3:

Entrée: nums = [10,7,10,3,9,14,9,4], k = 1
Sortie: 15
Explication: Sans appliquer aucune opération, le bit ou du nombre est de 15.
On peut montrer que 15 est la valeur minimale possible du bit du bit ou des éléments restants de nums après avoir appliqué dans le plus de K opérations.

Contraintes:

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


On vous donne un tableau d'entiers positifs `nums` de longueur `n`.
Un polygone est une figure plane fermée qui possède au moins 3 côtés. Le côté le plus long d'un polygone est plus petit que la somme de ses autres côtés.
Inversement, si vous avez `k` (k >= 3) nombres réels positifs `a_1, a_2, a_3, ..., a_k` où `a_1 <= a_2 <= a_3 <= ... <= a_k` et `a_1 + a_2 + a_3 + ... + a_k-1 > a_k`, alors il existe toujours un polygone à `k` côtés dont les longueurs sont `a_1, a_2, a_3, ..., a_k`.
Le périmètre d'un polygone est la somme des longueurs de ses côtés.
Renvoyez le plus grand périmètre possible d'un polygone dont les côtés peuvent être formés à partir de `nums`, ou -1 s'il n'est pas possible de créer un polygone.

Exemple 1 :

Entrée : `nums = [5,5,5]`
Sortie : `15`
Explication : Le seul polygone possible qui peut être formé à partir de `nums` a 3 côtés : 5, 5, et 5. Le périmètre est `5 + 5 + 5 = 15`.

Exemple 2 :

Entrée : `nums = [1,12,1,2,5,50,3]`
Sortie : `12`
Explication : Le polygone avec le plus grand périmètre qui peut être formé à partir de `nums` a 5 côtés : 1, 1, 2, 3, et 5. Le périmètre est `1 + 1 + 2 + 3 + 5 = 12`.
On ne peut pas avoir un polygone avec soit 12 soit 50 comme côté le plus long car il n'est pas possible d'inclure 2 ou plusieurs côtés plus petits dont la somme soit plus grande que chacun d'eux.
On peut montrer que le plus grand périmètre possible est 12.

Exemple 3 :

Entrée : `nums = [5,5,50]`
Sortie : `-1`
Explication : Il n'y a aucun moyen possible de former un polygone à partir de `nums`, car un polygone a au moins 3 côtés et `50 > 5 + 5`.

Contraintes :

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

On vous donne un tableau d'entiers positifs nums de longueur n.
Un polygone est une figure plane fermée qui possède au moins 3 côtés. Le côté le plus long d'un polygone est plus petit que la somme de ses autres côtés.
Inversement, si vous avez k (k >= 3) nombres réels positifs a_1, a_2, a_3, ..., a_k où a_1 <= a_2 <= a_3 <= ... <= a_k et a_1 + a_2 + a_3 + ... + a_k-1 > a_k, alors il existe toujours un polygone à k côtés dont les longueurs sont a_1, a_2, a_3, ..., a_k.
Le périmètre d'un polygone est la somme des longueurs de ses côtés.
Retournez le plus grand périmètre possible d'un polygone dont les côtés peuvent être formés à partir de nums, ou -1 s'il n'est pas possible de créer un polygone.

Exemple 1 :

Entrée : nums = [5,5,5]
Sortie : 15
Explication : Le seul polygone possible qui peut être formé à partir de nums a 3 côtés : 5, 5, et 5. Le périmètre est 5 + 5 + 5 = 15.

Exemple 2 :

Entrée : nums = [1,12,1,2,5,50,3]
Sortie : 12
Explication : Le polygone avec le plus grand périmètre qui peut être formé à partir de nums a 5 côtés : 1, 1, 2, 3, et 5. Le périmètre est 1 + 1 + 2 + 3 + 5 = 12.
On ne peut pas avoir un polygone avec soit 12 soit 50 comme côté le plus long car il n'est pas possible d'inclure 2 ou plusieurs côtés plus petits dont la somme soit plus grande que chacun d'eux.
On peut montrer que le plus grand périmètre possible est 12.

Exemple 3 :

Entrée : nums = [5,5,50]
Sortie : -1
Explication : Il n'y a aucun moyen possible de former un polygone à partir de nums, car un polygone a au moins 3 côtés et 50 > 5 + 5.

Contraintes :

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

On vous donne un tableau d'entiers positifs `nums` de longueur `n`.
Un polygone est une figure plane fermée qui possède au moins 3 côtés. Le côté le plus long d'un polygone est plus petit que la somme de ses autres côtés.
Inversement, si vous avez `k` (k >= 3) nombres réels positifs `a_1, a_2, a_3, ..., a_k` où `a_1 <= a_2 <= a_3 <= ... <= a_k` et `a_1 + a_2 + a_3 + ... + a_k-1 > a_k`, alors il existe toujours un polygone à `k` côtés dont les longueurs sont `a_1, a_2, a_3, ..., a_k`.
Le périmètre d'un polygone est la somme des longueurs de ses côtés.
Retournez le plus grand périmètre possible d'un polygone dont les côtés peuvent être formés à partir de `nums`, ou -1 s'il n'est pas possible de créer un polygone.

Exemple 1 :

Entrée : `nums = [5,5,5]`
Sortie : `15`
Explication : Le seul polygone possible qui peut être formé à partir de `nums` a 3 côtés : 5, 5, et 5. Le périmètre est `5 + 5 + 5 = 15`.

Exemple 2 :

Entrée : `nums = [1,12,1,2,5,50,3]`
Sortie : `12`
Explication : Le polygone avec le plus grand périmètre qui peut être formé à partir de `nums` a 5 côtés : 1, 1, 2, 3, et 5. Le périmètre est `1 + 1 + 2 + 3 + 5 = 12`.
On ne peut pas avoir un polygone avec soit 12 soit 50 comme côté le plus long car il n'est pas possible d'inclure 2 ou plusieurs côtés plus petits dont la somme soit plus grande que chacun d'eux.
On peut montrer que le plus grand périmètre possible est 12.

Exemple 3 :

Entrée : `nums = [5,5,50]`
Sortie : `-1`
Explication : Il n'y a aucun moyen possible de former un polygone à partir de `nums`, car un polygone a au moins 3 côtés et `50 > 5 + 5`.

Contraintes :

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


Vous disposez d'un tableau d'entiers nums de longueur n.
Le coût d'un tableau est la valeur de son premier élément. Par exemple, le coût de [1,2,3] est 1 tandis que le coût de [3,4,1] est 3.
Vous devez diviser nums en 3 sous-tableaux contigus disjoints.
Retournez la somme minimale possible du coût de ces sous-tableaux.

Exemple 1 :

Entrée : nums = [1,2,3,12]
Sortie : 6
Explication : La meilleure façon de former 3 sous-tableaux est : [1], [2] et [3,12] avec un coût total de 1 + 2 + 3 = 6.
Les autres façons possibles de former 3 sous-tableaux sont :
- [1], [2,3], et [12] avec un coût total de 1 + 2 + 12 = 15.
- [1,2], [3], et [12] avec un coût total de 1 + 3 + 12 = 16.

Exemple 2 :

Entrée : nums = [5,4,3]
Sortie : 12
Explication : La meilleure façon de former 3 sous-tableaux est : [5], [4] et [3] avec un coût total de 5 + 4 + 3 = 12.
Il peut être démontré que 12 est le coût minimum réalisable.

Exemple 3 :

Entrée : nums = [10,3,1,1]
Sortie : 12
Explication : La meilleure façon de former 3 sous-tableaux est : [10,3], [1] et [1] avec un coût total de 10 + 1 + 1 = 12.
Il peut être démontré que 12 est le coût minimum réalisable.

Contraintes :

3 <= n <= 50
1 <= nums[i] <= 50

On vous donne un tableau d'entiers nums de longueur n.
Le coût d'un tableau est la valeur de son premier élément. Par exemple, le coût de [1,2,3] est de 1 tandis que le coût de [3,4,1] est de 3.
Vous devez diviser nums en 3 sous-ensembles contigus disjoints.
Retournez la somme minimale possible du coût de ces sous-ensembles.

Exemple 1 :

Entrée : nums = [1,2,3,12]
Sortie : 6
Explication : La meilleure façon de former 3 sous-ensembles est : [1], [2], et [3,12] pour un coût total de 1 + 2 + 3 = 6.
Les autres façons possibles de former 3 sous-ensembles sont :
- [1], [2,3] et [12] pour un coût total de 1 + 2 + 12 = 15.
- [1,2], [3] et [12] pour un coût total de 1 + 3 + 12 = 16.

Exemple 2 :

Entrée : nums = [5,4,3]
Sortie : 12
Explication : La meilleure façon de former 3 sous-ensembles est la suivante : [5], [4] et [3] pour un coût total de 5 + 4 + 3 = 12.
On peut démontrer que 12 est le coût minimum réalisable.

Exemple 3 :

Entrée : nums = [10,3,1,1]
Sortie : 12
Explication : La meilleure façon de former 3 sous-ensembles est la suivante : [10,3], [1] et [1] : [10,3], [1] et [1] pour un coût total de 10 + 1 + 1 = 12.
On peut démontrer que 12 est le coût minimum réalisable.

Contraintes :

3 <= n <= 50
1 <= nums[i] <= 50

Vous disposez d'un tableau d’entiers nombres nums de longueur n.
Le coût d’un tableau est la valeur de son premier élément. Par exemple, le coût de [1,2,3] est de 1 tandis que le coût de [3,4,1] est de 3.
Vous devez diviser les nums en 3 sous-tableaux contigus disjoints.
Retournez la somme minimale possible du coût de ces sous-tableaux.

Exemple 1 :

Entrée : nums = [1,2,3,12]
Sortie : 6
Explication : La meilleure façon possible de former 3 sous-tableaux est : [1], [2] et [3,12] à un coût total de 1 + 2 + 3 = 6.
Les autres façons possibles de former 3 sous-tableaux sont :
- [1], [2,3] et [12] pour un coût total de 1 + 2 + 12 = 15.
- [1,2], [3] et [12] pour un coût total de 1 + 3 + 12 = 16.

Exemple 2 :

Entrée : nums = [5,4,3]
Sortie : 12
Explication : La meilleure façon possible de former 3 sous-tableaux est : [5], [4] et [3] à un coût total de 5 + 4 + 3 = 12.
Il peut être démontré que 12 est le coût minimum réalisable.

Exemple 3 :

Entrée : nums = [10,3,1,1]
Sortie : 12
Explication : La meilleure façon possible de former 3 sous-tableaux est : [10,3], [1] et [1] à un coût total de 10 + 1 + 1 = 12.
Il peut être démontré que 12 est le coût minimum réalisable.

Contraintes:

3 <= n <= 50
1 <= nums[i] <= 50


Vous avez un tableau nums de longueur n et un entier positif k.
Un sous-tableau de nums est appelé bon si la différence absolue entre son premier et dernier élément est exactement k, en d'autres termes, le sous-tableau nums[i..j] est bon si |nums[i] - nums[j]| == k.
Retournez la somme maximale d'un bon sous-tableau de nums. S'il n'y a pas de bons sous-tableaux, retournez 0.

Exemple 1 :

Entrée : nums = [1,2,3,4,5,6], k = 1
Sortie : 11
Explication : La différence absolue entre le premier et le dernier élément doit être 1 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [1,2], [2,3], [3,4], [4,5], et [5,6]. La somme maximale des sous-tableaux est 11 pour le sous-tableau [5,6].

Exemple 2 :

Entrée : nums = [-1,3,2,4,5], k = 3
Sortie : 11
Explication : La différence absolue entre le premier et le dernier élément doit être 3 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [-1,3,2], et [2,4,5]. La somme maximale des sous-tableaux est 11 pour le sous-tableau [2,4,5].

Exemple 3 :

Entrée : nums = [-1,-2,-3,-4], k = 2
Sortie : -6
Explication : La différence absolue entre le premier et le dernier élément doit être 2 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [-1,-2,-3], et [-2,-3,-4]. La somme maximale des sous-tableaux est -6 pour le sous-tableau [-1,-2,-3].

Contraintes :

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

On vous donne un tableau nombres de longueur n et un entier positif k.
Un sous-tableau de nums est dit bon si la différence absolue entre son premier et son dernier élément est exactement k, c’est-à-dire le sous-tableau nums[i.. j] est bon si |nums[i] - nums[j]| == k.
Renvoie la somme maximale d’un bon sous-tableau de nums. S’il n’y a pas de bons sous-tableaux, renvoyez 0.

Exemple 1 :

Entrée : nums = [1,2,3,4,5,6], k = 1
Sortie : 11
Explication : La différence absolue entre le premier et le dernier élément doit être de 1 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [1,2], [2,3], [3,4], [4,5] et [5,6]. La somme maximale des sous-tableaux est de 11 pour le sous-tableau [5,6].

Exemple 2 :

Entrée : nums = [-1,3,2,4,5], k = 3
Sortie : 11
Explication : La différence absolue entre le premier et le dernier élément doit être de 3 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [-1,3,2] et [2,4,5]. La somme maximale des sous-tableaux est de 11 pour le sous-tableau [2,4,5].

Exemple 3 :

Entrée : nums = [-1,-2,-3,-4], k = 2
Sortie : -6
Explication : La différence absolue entre le premier et le dernier élément doit être de 2 pour un bon sous-tableau. Tous les bons sous-tableaux sont : [-1,-2,-3] et [-2,-3,-4]. La somme maximale des sous-tableaux est de -6 pour le sous-tableau [-1,-2,-3].

Contraintes:

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


On vous donne une chaîne de caractères s constituée de lettres minuscules anglaises.
Une chaîne est appelée spéciale si elle est composée d'un seul caractère. Par exemple, la chaîne "abc" n'est pas spéciale, tandis que les chaînes "ddd", "zz" et "f" sont spéciales.
Retournez la longueur de la plus longue sous-chaîne spéciale de s qui apparaît au moins trois fois, ou -1 si aucune sous-chaîne spéciale n'apparaît au moins trois fois.
Une sous-chaîne est une séquence contiguë et non vide de caractères dans une chaîne.

Exemple 1 :

Input: s = "aaaa"
Output: 2
Explication : La plus longue sous-chaîne spéciale qui apparaît trois fois est "aa" : sous-chaînes "aaaa", "aaaa" et "aaaa".
Il peut être démontré que la longueur maximale atteignable est 2.

Exemple 2 :

Input: s = "abcdef"
Output: -1
Explication : Il n'existe aucune sous-chaîne spéciale qui apparaît au moins trois fois. On renvoie donc -1.

Exemple 3 :

Input: s = "abcaba"
Output: 1
Explication : La plus longue sous-chaîne spéciale qui apparaît trois fois est "a" : sous-chaînes "abcaba", "abcaba" et "abcaba".
Il peut être démontré que la longueur maximale atteignable est 1.

Contraintes :

3 <= s.length <= 50
s consiste uniquement en lettres minuscules anglaises.

On vous donne une chaîne de caractères s qui se compose de lettres minuscules anglaises.
Une chaîne est appelée spéciale si elle est composée d'un seul caractère. Par exemple, la chaîne "abc" n'est pas spéciale, tandis que les chaînes "ddd", "zz" et "f" sont spéciales.
Retournez la longueur de la plus longue sous-chaîne spéciale de s qui apparaît au moins trois fois, ou -1 si aucune sous-chaîne spéciale n'apparaît au moins trois fois.
Une sous-chaîne est une séquence contiguë et non vide de caractères dans une chaîne.

Exemple 1 :

Input: s = "aaaa"
Output: 2
Explication : La plus longue sous-chaîne spéciale qui apparaît trois fois est "aa" : sous-chaînes "aaaa", "aaaa" et "aaaa".
Il peut être démontré que la longueur maximale atteignable est 2.

Exemple 2 :

Input: s = "abcdef"
Output: -1
Explication : Il n'existe aucune sous-chaîne spéciale qui apparaît au moins trois fois. On renvoie donc -1.

Exemple 3 :

Input: s = "abcaba"
Output: 1
Explication : La plus longue sous-chaîne spéciale qui apparaît trois fois est "a" : sous-chaînes "abcaba", "abcaba" et "abcaba".
Il peut être démontré que la longueur maximale atteignable est 1.

Contraintes :

3 <= s.length <= 50
s consiste uniquement en lettres minuscules anglaises.

On vous donne une chaîne s composée de lettres minuscules anglaises.
Une chaîne est dite spéciale si elle est composée d'un seul caractère. Par exemple, la chaîne « abc » n'est pas spéciale, alors que les chaînes « ddd », « zz » et « f » sont spéciales.
Renvoie la longueur de la plus longue sous-chaîne spéciale de s qui apparaît au moins trois fois, ou -1 si aucune sous-chaîne spéciale n'apparaît au moins trois fois.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "aaaa"
Sortie : 2
Explication : La plus longue sous-chaîne spéciale qui apparaît trois fois est « aa » : sous-chaînes "aaaa", "aaaa" et "aaaa".
Il peut être démontré que la longueur maximale atteignable est de 2.

Exemple 2 :

Entrée : s = "abcdef"
Sortie : -1
Explication : Il n'existe aucune sous-chaîne spéciale qui apparaisse au moins trois fois. Par conséquent, renvoyez -1.

Exemple 3 :

Entrée : s = "abcaba"
Sortie : 1
Explication : La sous-chaîne spéciale la plus longue qui apparaisse trois fois est "a" : sous-chaînes "abcaba", "abcaba" et "abcaba".
Il peut être démontré que la longueur maximale atteignable est de 1.

Contraintes :

3 <= s.length <= 50
s est composé uniquement de lettres minuscules anglaises.


On vous donne un tableau d'entiers 0-indexé `nums` de taille `n`, et un tableau d'entiers 0-indexé `pattern` de taille `m` composé des entiers -1, 0 et 1.
Un sous-tableau `nums[i..j]` de taille `m + 1` est censé correspondre au motif si les conditions suivantes sont remplies pour chaque élément `pattern[k]` :

`nums[i + k + 1] > nums[i + k]` si `pattern[k] == 1`.
`nums[i + k + 1] == nums[i + k]` si `pattern[k] == 0`.
`nums[i + k + 1] < nums[i + k]` si `pattern[k] == -1`.

Renvoyez le nombre de sous-tableaux dans `nums` qui correspondent au motif.

Exemple 1 :

Entrée : `nums = [1,2,3,4,5,6]`, `pattern = [1,1]`
Sortie : 4
Explication : Le motif `[1,1]` indique que nous recherchons des sous-tableaux strictement croissants de taille 3. Dans le tableau `nums`, les sous-tableaux `[1,2,3]`, `[2,3,4]`, `[3,4,5]`, et `[4,5,6]` correspondent à ce motif.
Ainsi, il y a 4 sous-tableaux dans `nums` qui correspondent au motif.

Exemple 2 :

Entrée : `nums = [1,4,4,1,3,5,5,3]`, `pattern = [1,0,-1]`
Sortie : 2
Explication : Ici, le motif `[1,0,-1]` indique que nous recherchons une séquence où le premier nombre est plus petit que le deuxième, le deuxième est égal au troisième, et le troisième est supérieur au quatrième. Dans le tableau `nums`, les sous-tableaux `[1,4,4,1]`, et `[3,5,5,3]` correspondent à ce motif.
Ainsi, il y a 2 sous-tableaux dans `nums` qui correspondent au motif.

Contraintes :

2 <= n == `nums.length` <= 100
1 <= `nums[i]` <= 10^9
1 <= m == `pattern.length` < n
-1 <= `pattern[i]` <= 1

On vous donne un tableau d'entiers indexés 0 nums de taille n, et un tableau d'entiers indexés 0 pattern de taille m composé d'entiers -1, 0 et 1.
Un sous-réseau nums[i..j] de taille m + 1 est considéré comme correspondant au motif si les conditions suivantes sont remplies pour chaque élément motif[k] :

nums[i + k + 1] > nums[i + k] si motif[k] == 1.
nums[i + k + 1] == nums[i + k] si motif[k] == 0.
nums[i + k + 1] < nums[i + k] si motif[k] == -1.

Renvoie le nombre de sous-réseaux dans nums qui correspondent au motif.

Exemple 1 :

Entrée : nums = [1,2,3,4,5,6], motif = [1,1]
Sortie : 4
Explication : Le motif [1,1] indique que nous recherchons des sous-ensembles strictement croissants de taille 3. Dans le tableau nums, les sous-ensembles [1,2,3], [2,3,4], [3,4,5] et [4,5,6] correspondent à ce motif.
Il y a donc 4 sous-ensembles dans nums qui correspondent au motif.

Exemple 2 :

Entrée : nums = [1,4,4,1,3,5,5,3], motif = [1,0,-1]
Sortie : 2
Explication : Ici, le motif [1,0,-1] indique que nous recherchons une séquence dans laquelle le premier nombre est plus petit que le deuxième, le deuxième est égal au troisième et le troisième est plus grand que le quatrième. Dans le tableau nums, les sous-réseaux [1,4,4,1] et [3,5,5,3] correspondent à ce modèle.
Il y a donc 2 sous-ensembles dans nums qui correspondent à ce motif.

Contraintes :

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= motif[i] <= 1

On vous donne un tableau d'entiers 0-indexé nums de taille n, et un tableau d'entiers 0-indexé pattern de taille m composé des entiers -1, 0 et 1.
Un sous-tableau nums[i..j] de taille m + 1 est censé correspondre au motif si les conditions suivantes sont remplies pour chaque élément pattern[k] :

nums[i + k + 1] > nums[i + k] si pattern[k] == 1.
nums[i + k + 1] == nums[i + k] si pattern[k] == 0.
nums[i + k + 1] < nums[i + k] si pattern[k] == -1.

Retournez le nombre de sous-tableaux dans nums`qui correspondent au motif.

Exemple 1 :

Entrée : `ums = [1,2,3,4,5,6], pattern = [1,1]
Sortie : 4
Explication : Le motif [1,1] indique que nous recherchons des sous-tableaux strictement croissants de taille 3. Dans le tableau nums, les sous-tableaux [1,2,3], [2,3,4], [3,4,5], et [4,5,6] correspondent à ce motif.
Ainsi, il y a 4 sous-tableaux dans nums qui correspondent au motif.

Exemple 2 :

Entrée : nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Sortie : 2
Explication : Ici, le motif [1,0,-1] indique que nous recherchons une séquence où le premier nombre est plus petit que le deuxième, le deuxième est égal au troisième, et le troisième est supérieur au quatrième. Dans le tableau nums, les sous-tableaux [1,4,4,1], et [3,5,5,3] correspondent à ce motif.
Ainsi, il y a 2 sous-tableaux dans nums qui correspondent au motif.

Contraintes :

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1


Alice et Bob jouent à un jeu au tour par tour sur un champ circulaire entouré de fleurs. Le cercle représente le champ, et il y a x fleurs dans le sens horaire entre Alice et Bob, et y fleurs dans le sens anti-horaire entre eux.
Le jeu se déroule comme suit :

Alice prend le premier tour.
À chaque tour, un joueur doit choisir soit le sens horaire, soit le sens anti-horaire et cueillir une fleur de ce côté.
À la fin du tour, s'il n'y a plus de fleurs du tout, le joueur actuel capture son adversaire et gagne la partie.

Étant donné deux entiers, n et m, la tâche est de calculer le nombre de paires possibles (x, y) qui satisfont les conditions suivantes :

Alice doit gagner la partie selon les règles décrites.
Le nombre de fleurs x dans le sens horaire doit être dans l'intervalle [1,n].
Le nombre de fleurs y dans le sens anti-horaire doit être dans l'intervalle [1,m].

Renvoyez le nombre de paires possibles (x, y) qui satisfont les conditions mentionnées dans l'énoncé.

Exemple 1 :

Entrée : n = 3, m = 2
Sortie : 3
Explication : Les paires suivantes satisfont les conditions décrites dans l'énoncé : (1,2), (3,2), (2,1).

Exemple 2 :

Entrée : n = 1, m = 1
Sortie : 0
Explication : Aucune paire ne satisfait les conditions décrites dans l'énoncé.

Contraintes :

1 <= n, m <= 10^5

Alice et Bob jouent un jeu au tour par tour sur un champ circulaire entouré de fleurs. Le cercle représente le champ, et il y a x fleurs dans le sens des aiguilles d'une montre entre Alice et Bob, et y fleurs dans le sens anti-horaire entre eux.
Le jeu se déroule comme suit:

Alice prend le premier tour.
À chaque tour, un joueur doit choisir la direction dans le sens des aiguilles d'une montre ou dans le sens inverse des aiguilles d'une montre et choisir une fleur de ce côté.
À la fin du tour, s'il ne reste plus de fleurs, le joueur actuel capture son adversaire et remporte le jeu.

Compte tenu de deux entiers, N et M, la tâche consiste à calculer le nombre de paires possibles (x, y) qui remplissent les conditions:

Alice doit gagner le jeu selon les règles décrites.
Le nombre de fleurs x dans le sens des aiguilles d'une montre doit être dans la plage [1, n].
Le nombre de fleurs y dans le sens anti-horaire doit être dans la plage [1, m].

Renvoie le nombre de paires possibles (x, y) qui remplissent les conditions mentionnées dans l'énoncé.

Exemple 1:

Entrée: n = 3, m = 2
Sortie: 3
Explication: Les paires suivantes remplissent les conditions décrites dans l'énoncé: (1,2), (3,2), (2,1).

Exemple 2:

Entrée: n = 1, m = 1
Sortie: 0
Explication: Aucune paire ne remplit les conditions décrites dans la déclaration.

Contraintes:

1 <= n, m <= 10 ^ 5

Alice et Bob jouent à un jeu au tour par tour sur un champ circulaire entouré de fleurs. Le cercle représente le champ, et il y a x fleurs dans le sens horaire entre Alice et Bob, et y fleurs dans le sens anti-horaire entre eux.
Le jeu se déroule comme suit :

Alice joue la première.
À chaque tour, un joueur doit choisir soit le sens horaire, soit le sens anti-horaire et cueillir une fleur de ce côté.
À la fin du tour, s'il n'y a plus de fleurs du tout, le joueur actuel capture son adversaire et gagne la partie.

Étant donné deux entiers, n et m, la tâche est de calculer le nombre de paires possibles (x, y) qui satisfont les conditions suivantes :

Alice doit gagner la partie selon les règles décrites.
Le nombre de fleurs x dans le sens horaire doit être dans l'intervalle [1,n].
Le nombre de fleurs y dans le sens anti-horaire doit être dans l'intervalle [1,m].

Retournez le nombre de paires possibles (x, y) qui satisfont les conditions mentionnées dans l'énoncé.

Exemple 1 :

Entrée : n = 3, m = 2
Sortie : 3
Explication : Les paires suivantes satisfont les conditions décrites dans l'énoncé : (1,2), (3,2), (2,1).

Exemple 2 :

Entrée : n = 1, m = 1
Sortie : 0
Explication : Aucune paire ne satisfait les conditions décrites dans l'énoncé.

Contraintes :

1 <= n, m <= 10^5


On vous donne un tableau indexé à 0 d'entiers positifs nums.
En une seule opération, vous pouvez échanger deux éléments adjacents s'ils ont le même nombre de bits définis. Vous êtes autorisé à effectuer cette opération autant de fois que vous le souhaitez (y compris zéro).
Renvoyez true si vous pouvez trier le tableau, sinon renvoyez false.

Exemple 1 :

Entrée : nums = [8,4,2,30,15]
Sortie : true
Explication : Regardons la représentation binaire de chaque élément. Les nombres 2, 4 et 8 ont chacun un bit défini avec une représentation binaire "10", "100", et "1000" respectivement. Les nombres 15 et 30 ont chacun quatre bits définis avec une représentation binaire "1111" et "11110".
Nous pouvons trier le tableau à l'aide de 4 opérations :
- Échangez nums[0] avec nums[1]. Cette opération est valide car 8 et 4 ont chacun un bit défini. Le tableau devient [4,8,2,30,15].
- Échangez nums[1] avec nums[2]. Cette opération est valide car 8 et 2 ont chacun un bit défini. Le tableau devient [4,2,8,30,15].
- Échangez nums[0] avec nums[1]. Cette opération est valide car 4 et 2 ont chacun un bit défini. Le tableau devient [2,4,8,30,15].
- Échangez nums[3] avec nums[4]. Cette opération est valide car 30 et 15 ont chacun quatre bits définis. Le tableau devient [2,4,8,15,30].
Le tableau est devenu trié, donc nous retournons true.
Notez qu'il peut y avoir d'autres séquences d'opérations qui trient également le tableau.

Exemple 2 :

Entrée : nums = [1,2,3,4,5]
Sortie : true
Explication : Le tableau est déjà trié, donc nous retournons true.

Exemple 3 :

Entrée : nums = [3,16,8,4,2]
Sortie : false
Explication : Il peut être démontré qu'il n'est pas possible de trier le tableau d'entrée à l'aide d'un nombre quelconque d'opérations.

Contraintes :

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

On vous donne un tableau nums indexé à partir de zéro d'entiers positifs.
Dans une opération, vous pouvez échanger deux éléments adjacents s'ils ont le même nombre de bits à un dans leur représentation binaire. Vous pouvez effectuer cette opération un nombre quelconque de fois (y compris zéro).
Retournez true si vous pouvez trier le tableau, false sinon.

Exemple 1 :

Entrée : nums = [8,4,2,30,15]
Sortie : true
Explication : Regardons la représentation binaire de chaque élément. Les nombres 2, 4, et 8 ont chacun un bit à un avec la représentation binaire "10", "100", et "1000" respectivement. Les nombres 15 et 30 ont chacun quatre bits à un avec la représentation binaire "1111" et "11110".
Nous pouvons trier le tableau en 4 opérations :
- Échanger nums[0] avec nums[1]. Cette opération est valide car 8 et 4 ont un bit à un chacun. Le tableau devient [4,8,2,30,15].
- Échangez nums[1] avec nums[2]. Cette opération est valide car 8 et 2 ont un bit à un chacun. Le tableau devient [4,2,8,30,15].
- Échanger nums[0] avec nums[1]. Cette opération est valide car 4 et 2 ont un bit à un chacun. Le tableau devient [2,4,8,30,15].
- Échanger nums[3] avec nums[4]. Cette opération est valide car 30 et 15 ont quatre bits à un chacun. Le tableau devient [2,4,8,15,30].
Le tableau est devenu trié, donc nous retournons true.
Notez qu'il peut y avoir d'autres séquences d'opérations qui trient également le tableau.

Exemple 2 :

Entrée : nums = [1,2,3,4,5]
Sortie : true
Explication : Le tableau est déjà trié, donc nous retournons true.

Exemple 3 :

Entrée : nums = [3,16,8,4,2]
Sortie : false
Explication : Il peut être démontré qu'il n'est pas possible de trier le tableau en entrée en utilisant un nombre quelconque d'opérations.

Contraintes :

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

On vous donne un tableau indexé sur zéro de nombres entiers positifs.
Dans une opération, vous pouvez échanger deux éléments adjacents s'ils ont le même nombre de bits définis. Vous pouvez effectuer cette opération autant de fois que vous le souhaitez (y compris zéro).
Répondez vrai si vous pouvez trier le tableau, et dans le cas contraire, faux.

Exemple 1 :

Entrée : nombres = [8,4,2,30,15]
Sortie : vrai
Explication : Regardons la représentation binaire de chaque élément. Les nombres 2, 4, et 8 ont chacun un bit défini avec la représentation binaire respective suivante : « 10 », « 100 », et « 1000 ». Les nombres 15 et 30 ont chacun quatre bits définis avec la représentation binaire suivante : « 1111 » et « 11110 ».
Nous pouvons trier le tableau à l'aide de 4 opérations :
- Échanger les nombres[0] avec les nombres[1]. Cette opération est valide car 8 et 4 ont un bit défini chacun. Le tableau devient [4,8,2,30,15].
- Échanger les nombres[1] avec les nombres[2]. Cette opération est valide car 8 et 2 ont un bit défini chacun. Le tableau devient [4,2,8,30,15].
- Échanger les nombres[0] avec les nombres[1]. Cette opération est valide car 4 et 2 ont un bit défini chacun. Le tableau devient [2,4,8,30,15].
- Échanger les nombres[3] avec les nombres[4]. Cette opération est valide car 30 et 15 ont quatre bits définis chacun. Le tableau devient [2,4,8,15,30].
Le tableau est devenu trié, donc nous répondons vrai.
Notez qu'il peut y avoir d'autres séquences d'opérations qui trient également le tableau.

Exemple 2 :

Entrée : nombres = [1,2,3,4,5]
Sortie : vrai
Explication : Le tableau est déjà trié, donc nous répondons vrai.

Exemple 3 :

Entrée : nombres = [3,16,8,4,2]
Sortie : faux
Explication : Il peut être démontré qu'il n'est pas possible de trier le tableau d'entrée en utilisant n'importe quel nombre d'opérations.

Contraintes :

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


Vous avez deux tableaux entiers indexés à partir de 1, nums et changeIndices, respectivement de longueurs n et m.
Initialement, tous les indices dans nums sont non marqués. Votre tâche est de marquer tous les indices dans nums.
À chaque seconde, s, de 1 à m (inclus), vous pouvez effectuer l'une des opérations suivantes :

Choisir un indice i dans l'intervalle [1, n] et décrémenter nums[i] de 1.
Si nums[changeIndices[s]] est égal à 0, marquer l'indice changeIndices[s].
Ne rien faire.

Retournez un entier indiquant la première seconde dans l'intervalle [1, m] lorsque tous les indices dans nums peuvent être marqués en choisissant les opérations de manière optimale, ou -1 si c'est impossible.

Exemple 1 :

Entrée : nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Sortie : 8
Explication : Dans cet exemple, nous avons 8 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [1,2,0].
Seconde 2 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [0,2,0].
Seconde 3 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [0,1,0].
Seconde 4 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [0,0,0].
Seconde 5 : Marquer l'indice changeIndices[5], ce qui marque l'indice 3, car nums[3] est égal à 0.
Seconde 6 : Marquer l'indice changeIndices[6], ce qui marque l'indice 2, car nums[2] est égal à 0.
Seconde 7 : Ne rien faire.
Seconde 8 : Marquer l'indice changeIndices[8], ce qui marque l'indice 1, car nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
Il peut être démontré qu'il n'est pas possible de marquer tous les indices avant la 8ème seconde.
Ainsi, la réponse est 8.

Exemple 2 :

Entrée : nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Sortie : 6
Explication : Dans cet exemple, nous avons 7 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,2].
Seconde 2 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,1].
Seconde 3 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,0].
Seconde 4 : Marquer l'indice changeIndices[4], ce qui marque l'indice 2, car nums[2] est égal à 0.
Seconde 5 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [0,0].
Seconde 6 : Marquer l'indice changeIndices[6], ce qui marque l'indice 1, car nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
Il peut être démontré qu'il n'est pas possible de marquer tous les indices avant la 6ème seconde.
Ainsi, la réponse est 6.

Exemple 3 :

Entrée : nums = [0,1], changeIndices = [2,2,2]
Sortie : -1
Explication : Dans cet exemple, il est impossible de marquer tous les indices car l'indice 1 n'est pas dans changeIndices.
Ainsi, la réponse est -1.

Contraintes :

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

On vous donne deux tableaux d’entiers indexés à 1, nums et changeIndices, ayant respectivement les longueurs n et m.
Initialement, tous les indices dans nums ne sont pas marqués. Votre tâche consiste à marquer tous les index en nums.
À chaque seconde, s, dans l’ordre de 1 à m (inclus), vous pouvez effectuer l’une des opérations suivantes :

Choisissez un indice i dans la plage [1, n] et décrémentez nums[i] de 1.
Si nums[changeIndices[s]] est égal à 0, marquez l’index changeIndices[s].
Ne rien faire.

Renvoie un entier indiquant la seconde la plus ancienne de la plage [1, m] lorsque tous les indices dans nums peuvent être marqués en choisissant les opérations de manière optimale, ou -1 si c’est impossible.

Exemple 1 :

Entrée : nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2]
Sortie : 8
Explication : Dans cet exemple, nous avons 8 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisissez l’indice 1 et décrémentez les nums[1] d’un. nums devient [1,2,0].
Seconde 2 : Choisissez l’indice 1 et décrémentez les nums[1] d’une unité. nums devient [0,2,0].
Seconde 3 : Choisissez l’indice 2 et décrémentez les nums[2] d’un. nums devient [0,1,0].
Seconde 4 : Choisissez l’indice 2 et décrémentez les nums[2] d’une unité. nums devient [0,0,0].
Seconde 5 : Marquez l’indice changeIndices[5], qui marque l’indice 3, puisque nums[3] est égal à 0.
Seconde 6 : Marquez l’index changeIndices[6], qui marque l’index 2, puisque nums[2] est égal à 0.
Seconde 7 : Ne rien faire.
Seconde 8 : Marquez l’index changeIndices[8], qui marque l’index 1, puisque nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
On peut montrer qu’il n’est pas possible de marquer tous les indices avant la 8e seconde.
Par conséquent, la réponse est 8.

Exemple 2 :

Entrée : nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Sortie : 6
Explication : Dans cet exemple, nous avons 7 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisissez l’indice 2 et décrémentez les nums[2] d’une unité. nums devient [1,2].
Seconde 2 : Choisissez l’indice 2 et décrémentez les nums[2] d’un. nums devient [1,1].
Seconde 3 : Choisissez l’indice 2 et décrémentez les nums[2] d’un. nums devient [1,0].
Seconde 4 : Marquez l’index changeIndices[4], qui marque l’index 2, puisque nums[2] est égal à 0.
Seconde 5 : Choisissez l’indice 1 et décrémentez les nums[1] d’un. nums devient [0,0].
Seconde 6 : Marquez l’index changeIndices[6], qui marque l’index 1, puisque nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
On peut montrer qu’il n’est pas possible de marquer tous les indices avant la 6ème seconde.
Par conséquent, la réponse est 6.

Exemple 3 :

Entrée : nums = [0,1], changeIndices = [2,2,2]
Sortie : -1
Explication : Dans cet exemple, il est impossible de marquer tous les indices, car l’index 1 n’est pas dans changeIndices.
Par conséquent, la réponse est -1.

Contraintes:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

Vous avez deux tableaux entiers indexés à partir de 1, nums et changeIndices, de longueurs n et m, respectivement.
Initialement, tous les indices dans nums sont non marqués. Votre tâche est de marquer tous les indices dans nums.
À chaque seconde, s, de 1 à m (inclus), vous pouvez effectuer l'une des opérations suivantes :

Choisir un indice i dans l'intervalle [1, n] et décrémenter nums[i] de 1.
Si nums[changeIndices[s]] est égal à 0, marquer l'indice changeIndices[s].
Ne rien faire.

Renvoie un entier indiquant la première seconde dans l'intervalle [1, m] lorsque tous les indices dans nums peuvent être marqués en choisissant les opérations de manière optimale, ou -1 si c'est impossible.

Exemple 1 :

Entrée : nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Sortie : 8
Explication : Dans cet exemple, nous avons 8 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [1,2,0].
Seconde 2 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [0,2,0].
Seconde 3 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [0,1,0].
Seconde 4 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [0,0,0].
Seconde 5 : Marquer l'indice changeIndices[5], ce qui marque l'indice 3, car nums[3] est égal à 0.
Seconde 6 : Marquer l'indice changeIndices[6], ce qui marque l'indice 2, car nums[2] est égal à 0.
Seconde 7 : Ne rien faire.
Seconde 8 : Marquer l'indice changeIndices[8], ce qui marque l'indice 1, car nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
Il peut être démontré qu'il n'est pas possible de marquer tous les indices avant la 8ème seconde.
Ainsi, la réponse est 8.

Exemple 2 :

Entrée : nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Sortie : 6
Explication : Dans cet exemple, nous avons 7 secondes. Les opérations suivantes peuvent être effectuées pour marquer tous les indices :
Seconde 1 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,2].
Seconde 2 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,1].
Seconde 3 : Choisir l'indice 2 et décrémenter nums[2] d'un. nums devient [1,0].
Seconde 4 : Marquer l'indice changeIndices[4], ce qui marque l'indice 2, car nums[2] est égal à 0.
Seconde 5 : Choisir l'indice 1 et décrémenter nums[1] d'un. nums devient [0,0].
Seconde 6 : Marquer l'indice changeIndices[6], ce qui marque l'indice 1, car nums[1] est égal à 0.
Maintenant, tous les indices ont été marqués.
Il peut être démontré qu'il n'est pas possible de marquer tous les indices avant la 6ème seconde.
Ainsi, la réponse est 6.

Exemple 3 :

Entrée : nums = [0,1], changeIndices = [2,2,2]
Sortie : -1
Explication : Dans cet exemple, il est impossible de marquer tous les indices car l'indice 1 n'est pas dans changeIndices.
Ainsi, la réponse est -1.

Contraintes :

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n


On vous donne une chaîne de caractères word indexée à partir de 0 et un entier k.
À chaque seconde, vous devez effectuer les opérations suivantes :

Supprimez les k premiers caractères de word.
Ajoutez n’importe quels k caractères à la fin de word.

Notez que vous n'avez pas nécessairement besoin d'ajouter les mêmes caractères que vous avez supprimés. Cependant, vous devez effectuer ces deux opérations à chaque seconde.
Retournez le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 1 :

Entrée : word = "abacaba", k = 3
Sortie : 2
Explication : À la 1ère seconde, nous supprimons les caractères "aba" du préfixe de word, et ajoutons les caractères "bac" à la fin de word. Ainsi, word devient égal à "cababac".
À la 2ème seconde, nous supprimons les caractères "cab" du préfixe de word, et ajoutons "aba" à la fin de word. Ainsi, word devient égal à "abacaba" et revient à son état initial.
Il peut être démontré que 2 secondes est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 2 :

Entrée : word = "abacaba", k = 4
Sortie : 1
Explication : À la 1ère seconde, nous supprimons les caractères "abac" du préfixe de word, et ajoutons les caractères "caba" à la fin de word. Ainsi, word devient égal à "abacaba" et revient à son état initial.
Il peut être démontré qu'une seconde est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 3 :

Entrée : word = "abcbabcd", k = 2
Sortie : 4
Explication : À chaque seconde, nous supprimerons les 2 premiers caractères de word, et ajouterons les mêmes caractères à la fin de word.
Après 4 secondes, word devient égal à "abcbabcd" et revient à son état initial.
Il peut être démontré que 4 secondes est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Contraintes :

1 <= word.length <= 50
1 <= k <= word.length
word se compose uniquement de lettres minuscules anglaises.

On vous donne une chaîne de caractères word indexée à partir de 0 et un entier k.
À chaque seconde, vous devez effectuer les opérations suivantes :

Supprimez les k premiers caractères de word.
Ajoutez n’importe quels k caractères à la fin de word.

Notez que vous n'avez pas nécessairement besoin d'ajouter les mêmes caractères que vous avez supprimés. Cependant, vous devez effectuer ces deux opérations à chaque seconde.
Retournez le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 1 :

Entrée : word = "abacaba", k = 3
Sortie : 2
Explication : À la 1ère seconde, nous supprimons les caractères "aba" du préfixe de word, et ajoutons les caractères "bac" à la fin de word. Ainsi, word devient égal à "cababac".
À la 2ème seconde, nous supprimons les caractères "cab" du préfixe de word, et ajoutons "aba" à la fin de word. Ainsi, word devient égal à "abacaba" et revient à son état initial.
Il peut être démontré que 2 secondes est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 2 :

Entrée : word = "abacaba", k = 4
Sortie : 1
Explication : À la 1ère seconde, nous supprimons les caractères "abac" du préfixe de word, et ajoutons les caractères "caba" à la fin de word. Ainsi, word devient égal à "abacaba" et revient à son état initial.
Il peut être démontré qu'une seconde est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 3 :

Entrée : word = "abcbabcd", k = 2
Sortie : 4
Explication : À chaque seconde, nous supprimerons les 2 premiers caractères de word, et ajouterons les mêmes caractères à la fin de word.
Après 4 secondes, word devient égal à "abcbabcd" et revient à son état initial.
Il peut être démontré que 4 secondes est le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Contraintes :

1 <= word.length <= 50
1 <= k <= word.length
word se compose uniquement de lettres anglaises minuscules .

On vous donne une chaîne indexée 0, word, et un entier k.
À chaque seconde, vous devez effectuer les opérations suivantes :

Supprimez les k premiers caractères de word.
Ajoutez les k caractères à la fin de word.

Notez que vous n'avez pas nécessairement besoin d'ajouter les mêmes caractères que ceux que vous avez supprimés. Cependant, vous devez effectuer les deux opérations à chaque seconde.
Renvoie le temps minimum supérieur à zéro requis pour que word revienne à son état initial.

Exemple 1 :

Entrée : word = "abacaba", k = 3
Sortie : 2
Explication : À la 1ère seconde, nous supprimons les caractères "aba" du préfixe de word, et ajoutons les caractères "bac" à la fin de word. Ainsi, word devient égal à "cababac".
À la 2ème seconde, nous supprimons les caractères "cab" du préfixe de word, et ajoutons "aba" à la fin de word. Ainsi, word devient égal à "abacaba" et revient à son état initial.
Il peut être démontré que 2 secondes est le temps minimum supérieur à zéro requis pour que le word revienne à son état initial.

Exemple 2 :

Entrée : word = "abacaba", k = 4
Sortie : 1
Explication : À la 1ère seconde, nous supprimons les caractères « abac » du préfixe du word et ajoutons les caractères « caba » à la fin du word. Ainsi, le word devient égal à « abacaba » et revient à son état initial.
Il peut être démontré que 1 seconde est le temps minimum supérieur à zéro requis pour que le word revienne à son état initial.

Exemple 3 :

Entrée : word = "abcbabcd", k = 2
Sortie : 4
Explication : À chaque seconde, nous supprimons les 2 premiers caractères du word et ajoutons les mêmes caractères à la fin du word.
Après 4 secondes, le word devient égal à « abacaba » et revient à son état initial.
Il peut être démontré que 4 secondes est le temps minimum supérieur à zéro requis pour que le word revienne à son état initial.

Contraintes :

1 <= word.length <= 50
1 <= k <= word.length
word se compose uniquement de lettres minuscules anglaises.


On vous donne un tableau nums indexé à partir de 0 constitué d'entiers positifs.
Initialement, vous pouvez augmenter la valeur de n'importe quel élément du tableau d'au plus 1.
Ensuite, vous devez sélectionner un ou plusieurs éléments du tableau final de sorte que ces éléments soient consécutifs une fois triés dans l'ordre croissant. Par exemple, les éléments [3, 4, 5] sont consécutifs tandis que [3, 4, 6] et [1, 1, 2, 3] ne le sont pas.
Retournez le nombre maximum d'éléments que vous pouvez sélectionner.

Exemple 1 :

Entrée : nums = [2,1,5,1,1]
Sortie : 3
Explication : Nous pouvons augmenter les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,1,5,2,1].
Nous sélectionnons les éléments [3,1,5,2,1] et nous les trions pour obtenir [1,2,3], qui sont consécutifs.
Il peut être démontré que nous ne pouvons pas sélectionner plus de 3 éléments consécutifs.
Exemple 2 :

Entrée : nums = [1,4,7,10]
Sortie : 1
Explication : Le nombre maximum d'éléments consécutifs que nous pouvons sélectionner est 1.

Contraintes :

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

On vous donne un tableau nums indexé à 0 composé d'entiers positifs.
Au départ, vous pouvez augmenter la valeur de n'importe quel élément du tableau d'au plus 1.
Après cela, vous devez sélectionner un ou plusieurs éléments du tableau final de telle sorte que ces éléments soient consécutifs lorsqu'ils sont triés par ordre croissant. Par exemple, les éléments [3, 4, 5] sont consécutifs tandis que [3, 4, 6] et [1, 1, 2, 3] ne le sont pas.
Renvoie le nombre maximal d'éléments que vous pouvez sélectionner.

Exemple 1 :

Entrée : nums = [2,1,5,1,1]
Sortie : 3
Explication : Nous pouvons augmenter les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,1,5,2,1].
Nous sélectionnons les éléments [3,1,5,2,1] et nous les trions pour obtenir [1,2,3], qui sont consécutifs.
Il peut être démontré que nous ne pouvons pas sélectionner plus de 3 éléments consécutifs.
Exemple 2 :

Entrée : nums = [1,4,7,10]
Sortie : 1
Explication : Le nombre maximal d'éléments consécutifs que nous pouvons sélectionner est de 1.

Contraintes :

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

On vous donne un tableau indexé à partir de 0 `nums` composé d'entiers positifs.
Initialement, vous pouvez augmenter la valeur de n'importe quel élément du tableau d'au plus 1.
Ensuite, vous devez sélectionner un ou plusieurs éléments du tableau final de sorte que ces éléments soient consécutifs une fois triés par ordre croissant. Par exemple, les éléments [3, 4, 5] sont consécutifs tandis que [3, 4, 6] et [1, 1, 2, 3] ne le sont pas.
Retournez le nombre maximum d'éléments que vous pouvez sélectionner.

Exemple 1 :

Entrée : nums = [2,1,5,1,1]
Sortie : 3
Explication : Nous pouvons augmenter les éléments aux indices 0 et 3. Le tableau résultant est nums = [3,1,5,2,1].
Nous sélectionnons les éléments [3,1,5,2,1] et nous les trions pour obtenir [1,2,3], qui sont consécutifs.
Il peut être démontré que nous ne pouvons pas sélectionner plus de 3 éléments consécutifs.
Exemple 2 :

Entrée : nums = [1,4,7,10]
Sortie : 1
Explication : Le nombre maximum d'éléments consécutifs que nous pouvons sélectionner est 1.

Contraintes :

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


Un tableau d'entiers positifs nums vous est donné.
Vous devez sélectionner un sous-ensemble de nums qui satisfait la condition suivante :

Vous pouvez placer les éléments sélectionnés dans un tableau indexé à partir de 0 de manière à suivre le motif : [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Notez que k peut être une puissance de 2 non-négative). Par exemple, [2, 4, 16, 4, 2] et [3, 9, 3] suivent le motif alors que [2, 4, 8, 4, 2] ne le suit pas.

Retournez le nombre maximum d'éléments dans un sous-ensemble qui satisfait ces conditions.

Exemple 1 :

Entrée : nums = [5,4,1,2,2]
Sortie : 3
Explication : Nous pouvons sélectionner le sous-ensemble {4,2,2}, qui peut être placé dans le tableau comme [2,4,2] qui suit le motif et 2^2 == 4. Donc la réponse est 3.

Exemple 2 :

Entrée : nums = [1,3,2,4]
Sortie : 1
Explication : Nous pouvons sélectionner le sous-ensemble {1}, qui peut être placé dans le tableau comme [1] qui suit le motif. Donc la réponse est 1. Notez que nous aurions pu également sélectionner les sous-ensembles {2}, {4}, ou {3}, il peut y avoir plusieurs sous-ensembles qui fournissent la même réponse.

Contraintes :

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

On vous donne un tableau d'entiers positifs nums.
Vous devez sélectionner un sous-ensemble de nums qui satisfait la condition suivante :

Vous pouvez placer les éléments sélectionnés dans un tableau indexé à 0 de telle sorte qu'il suive le modèle : [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Notez que k peut être n'importe quelle puissance non négative de 2). Par exemple, [2, 4, 16, 4, 2] et [3, 9, 3] suivent le modèle tandis que [2, 4, 8, 4, 2] ne le fait pas.

Renvoie le nombre maximal d'éléments dans un sous-ensemble qui satisfait ces conditions.

Exemple 1 :

Entrée : nums = [5,4,1,2,2]
Sortie : 3
Explication : Nous pouvons sélectionner le sous-ensemble {4,2,2}, qui peut être placé dans le tableau comme [2,4,2] qui suit le modèle et 2^2 == 4. La réponse est donc 3.

Exemple 2 :

Entrée : nums = [1,3,2,4]
Sortie : 1
Explication : Nous pouvons sélectionner le sous-ensemble {1}, qui peut être placé dans le tableau comme [1] qui suit le modèle. La réponse est donc 1. Notez que nous aurions également pu sélectionner les sous-ensembles {2}, {4} ou {3}, il peut y avoir plusieurs sous-ensembles qui fournissent la même réponse.

Contraintes :

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


On vous donne une chaîne de caractères s.
Considérez effectuer l'opération suivante jusqu'à ce que s devienne vide :

Pour chaque caractère alphabétique de 'a' à 'z', supprimez la première occurrence de ce caractère dans s (s'il existe).

Par exemple, si initialement s = "aabcbbca". Nous effectuons les opérations suivantes :

Supprimez les caractères soulignés s = "aabcbbca". La chaîne résultante est s = "abbca".
Supprimez les caractères soulignés s = "abbca". La chaîne résultante est s = "ba".
Supprimez les caractères soulignés s = "ba". La chaîne résultante est s = "".

Retournez la valeur de la chaîne s juste avant d'appliquer la dernière opération. Dans l'exemple ci-dessus, la réponse est "ba".

Exemple 1 :

Entrée : s = "aabcbbca"
Sortie : "ba"
Explication : Expliqué dans l'énoncé.

Exemple 2 :

Entrée : s = "abcd"
Sortie : "abcd"
Explication : Nous effectuons l'opération suivante :
- Supprimez les caractères soulignés s = "abcd". La chaîne résultante est s = "".
La chaîne juste avant la dernière opération est "abcd".

Contraintes :

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

On vous donne une chaîne s.
Considérez l'opération suivante jusqu'à ce que s soit vide:

Pour chaque caractère alphabet de "a" à "z", supprimez la première occurrence de ce caractère en s (s'il existe).

Par exemple, Supposons initialement que s = "aabcbbca". Nous effectuons les opérations suivantes:

Supprimez les caractères soulignés s = "aabcbbca". La chaîne résultante est s = "abbca".
Supprimez les caractères soulignés s = "abbca". La chaîne résultante est s = "ba".
Supprimez les caractères soulignés s = "ba". La chaîne résultante est s = "".

Renvoie la valeur de la chaîne s juste avant d'appliquer la dernière opération. Dans l'exemple ci-dessus, la réponse est "ba".

Exemple 1:

Entrée: s = ""aabcbbca"
Sortie: "ba"
Explication: Expliquée dans la déclaration.

Exemple 2:

Entrée: s = "abcd"
Sortie: "abcd"
Explication: Nous effectuons l'opération suivante:
- Supprimez les caractères soulignés s = "abcd". La chaîne résultante est s = "".
La chaîne juste avant la dernière opération est "abcd".

Contraintes:

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

On donne une chaîne de caractères s.
Considérez effectuer l'opération suivante jusqu'à ce que s devienne vide :

Pour chaque caractère alphabétique de 'a' à 'z', supprimez la première occurrence de ce caractère dans s (s'il existe).

Par exemple, si initialement s = "aabcbbca". Nous effectuons les opérations suivantes :

Supprimez les caractères soulignés s = "aabcbbca". La chaîne résultante est s = "abbca".
Supprimez les caractères soulignés s = "abbca". La chaîne résultante est s = "ba".
Supprimez les caractères soulignés s = "ba". La chaîne résultante est s = "".

Retournez la valeur de la chaîne s juste avant d'appliquer la dernière opération. Dans l'exemple ci-dessus, la réponse est "ba".

Exemple 1 :

Entrée : s = "aabcbbca"
Sortie : "ba"
Explication : Expliqué dans l'énoncé.

Exemple 2 :

Entrée : s = "abcd"
Sortie : "abcd"
Explication : Nous effectuons l'opération suivante :
- Supprimez les caractères soulignés s = "abcd". La chaîne résultante est s = "".
La chaîne juste avant la dernière opération est "abcd".

Contraintes :

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


On vous donne un tableau de chaînes de caractères indexées à 0, words.
Définissons une fonction booléenne isPrefixAndSuffix qui prend deux chaînes, str1 et str2 :

isPrefixAndSuffix(str1, str2) renvoie true si str1 est à la fois un préfixe et un suffixe de str2, et false sinon.

Par exemple, isPrefixAndSuffix("aba", "ababa") est true car "aba" est un préfixe de "ababa" et également un suffixe, mais isPrefixAndSuffix("abc", "abcd") est false.
Renvoie un entier indiquant le nombre de paires d'index (i, j) telles que i < j, et isPrefixAndSuffix(words[i], words[j]) est true.

Exemple 1 :

Entrée : mots = ["a", "aba", "ababa", "aa"]
Sortie : 4
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 car isPrefixAndSuffix("a", "aba") est vrai.
i = 0 et j = 2 car isPrefixAndSuffix("a", "ababa") est vrai.
i = 0 et j = 3 car isPrefixAndSuffix("a", "aa") est vrai.
i = 1 et j = 2 car isPrefixAndSuffix("aba", "ababa") est vrai.
Par conséquent, la réponse est 4.
Exemple 2 :

Entrée : mots = ["pa","papa","ma","mama"]
Sortie : 2
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 car isPrefixAndSuffix("pa", "papa") est vrai.
i = 2 et j = 3 car isPrefixAndSuffix("ma", "mama") est vrai.
Par conséquent, la réponse est 2.
Exemple 3 :

Entrée : mots = ["abab","ab"]
Sortie : 0
Explication : Dans cet exemple, la seule paire d'index valide est i = 0 et j = 1, et isPrefixAndSuffix("abab", "ab") est faux.
Par conséquent, la réponse est 0.

Contraintes :

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] est composé uniquement de lettres minuscules anglaises.

Vous avez un tableau words de chaînes de caractères indexé à 0.
Définissons une fonction booléenne isPrefixAndSuffix qui prend deux chaînes, str1 et str2 :

isPrefixAndSuffix(str1, str2) retourne true si str1 est à la fois un préfixe et un suffixe de str2, et false sinon.

Par exemple, isPrefixAndSuffix("aba", "ababa") est vrai parce que "aba" est un préfixe de "ababa" et aussi un suffixe, mais isPrefixAndSuffix("abc", "abcd") est faux.
Retournez un entier représentant le nombre de paires d'index (i, j) telles que i < j, et isPrefixAndSuffix(words[i], words[j]) est vrai.

Exemple 1 :

Entrée : words = ["a","aba","ababa","aa"]
Sortie : 4
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 parce que isPrefixAndSuffix("a", "aba") est vrai.
i = 0 et j = 2 parce que isPrefixAndSuffix("a", "ababa") est vrai.
i = 0 et j = 3 parce que isPrefixAndSuffix("a", "aa") est vrai.
i = 1 et j = 2 parce que isPrefixAndSuffix("aba", "ababa") est vrai.
Par conséquent, la réponse est 4.
Exemple 2 :

Entrée : words = ["pa","papa","ma","mama"]
Sortie : 2
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 parce que isPrefixAndSuffix("pa", "papa") est vrai.
i = 2 et j = 3 parce que isPrefixAndSuffix("ma", "mama") est vrai.
Par conséquent, la réponse est 2.
Exemple 3 :

Entrée : words = ["abab","ab"]
Sortie : 0
Explication : Dans cet exemple, la seule paire d'index valide est i = 0 et j = 1, et isPrefixAndSuffix("abab", "ab") est faux.
Par conséquent, la réponse est 0.

Contraintes :

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] consiste uniquement en lettres minuscules anglaises.

Vous avez un tableau de chaînes de caractères indexé à 0, words.
Définissons une fonction booléenne isPrefixAndSuffix qui prend deux chaînes, str1 et str2 :

isPrefixAndSuffix(str1, str2) retourne vrai si str1 est à la fois un préfixe et un suffixe de str2, et faux sinon.

Par exemple, isPrefixAndSuffix("aba", "ababa") est vrai parce que "aba" est un préfixe de "ababa" et aussi un suffixe, mais isPrefixAndSuffix("abc", "abcd") est faux.
Retournez un entier représentant le nombre de paires d'index (i, j) telles que i < j, et isPrefixAndSuffix(words[i], words[j]) est vrai.

Exemple 1 :

Input: words = ["a","aba","ababa","aa"]
Output: 4
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 parce que isPrefixAndSuffix("a", "aba") est vrai.
i = 0 et j = 2 parce que isPrefixAndSuffix("a", "ababa") est vrai.
i = 0 et j = 3 parce que isPrefixAndSuffix("a", "aa") est vrai.
i = 1 et j = 2 parce que isPrefixAndSuffix("aba", "ababa") est vrai.
Par conséquent, la réponse est 4.
Exemple 2 :

Input: words = ["pa","papa","ma","mama"]
Output: 2
Explication : Dans cet exemple, les paires d'index comptées sont :
i = 0 et j = 1 parce que isPrefixAndSuffix("pa", "papa") est vrai.
i = 2 et j = 3 parce que isPrefixAndSuffix("ma", "mama") est vrai.
Par conséquent, la réponse est 2.
Exemple 3 :

Input: words = ["abab","ab"]
Output: 0
Explication : Dans cet exemple, la seule paire d'index valide est i = 0 et j = 1, et isPrefixAndSuffix("abab", "ab") est faux.
Par conséquent, la réponse est 0.

Contraintes :

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] consiste uniquement en lettres minuscules anglaises.


Une fourmi se trouve sur une frontière. Elle va parfois à gauche et parfois à droite.
On vous donne un tableau d'entiers non nuls nums. La fourmi commence à lire nums du premier élément de celui-ci jusqu'à sa fin. À chaque étape, elle se déplace en fonction de la valeur de l'élément courant :

Si nums[i] < 0, elle se déplace vers la gauche de -nums[i] unités.
Si nums[i] > 0, elle se déplace vers la droite de nums[i] unités.

Renvoie le nombre de fois que la fourmi revient à la frontière.
Remarques :

Il y a un espace infini des deux côtés de la frontière.
Nous vérifions si la fourmi est sur la frontière seulement après avoir bougé de |nums[i]| unités. En d'autres termes, si la fourmi traverse la frontière pendant son mouvement, elle ne compte pas.

Exemple 1 :

Entrée : nums = [2,3,-5]
Sortie : 1
Explication : Après la première étape, la fourmi se trouve à 2 pas à droite de la limite.
Après la deuxième étape, la fourmi se trouve à 5 pas à droite de la limite.
Après la troisième étape, la fourmi se trouve sur la limite.
La réponse est donc 1.

Exemple 2 :

Entrée : nums = [3,2,-3,-4]
Sortie : 0
Explication : Après la première étape, la fourmi se trouve à 3 pas à droite de la limite.
Après la deuxième étape, la fourmi se trouve à 5 pas à droite de la limite.
Après la troisième étape, la fourmi se trouve à 2 pas à droite de la limite.
Après la quatrième étape, la fourmi se trouve à 2 pas à gauche de la limite.
La fourmi n'est jamais revenue à la limite, donc la réponse est 0.

Contraintes :

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0

Une fourmi est sur une frontière. Parfois, elle va à gauche et parfois à droite.
On vous donne un tableau d'entiers non nuls nums. La fourmi commence à lire nums depuis le premier élément jusqu'à sa fin. À chaque étape, elle se déplace selon la valeur de l'élément courant :

Si nums[i] < 0, elle se déplace de -nums[i] unités vers la gauche.
Si nums[i] > 0, elle se déplace de nums[i] unités vers la droite.

Retournez le nombre de fois que la fourmi revient à la frontière.
Remarques :

Il y a un espace infini de chaque côté de la frontière.
Nous vérifions si la fourmi est sur la frontière seulement après qu'elle se soit déplacée de |nums[i]| unités. En d'autres termes, si la fourmi traverse la frontière pendant son mouvement, cela ne compte pas.

Exemple 1 :

Entrée : nums = [2,3,-5]
Sortie : 1
Explication : Après la première étape, la fourmi est à 2 pas à droite de la frontière.
Après la deuxième étape, la fourmi est à 5 pas à droite de la frontière.
Après la troisième étape, la fourmi est sur la frontière.
Donc la réponse est 1.

Exemple 2 :

Entrée : nums = [3,2,-3,-4]
Sortie : 0
Explication : Après la première étape, la fourmi est à 3 pas à droite de la frontière.
Après la deuxième étape, la fourmi est à 5 pas à droite de la frontière.
Après la troisième étape, la fourmi est à 2 pas à droite de la frontière.
Après la quatrième étape, la fourmi est à 2 pas à gauche de la frontière.
La fourmi n'est jamais revenue à la frontière, donc la réponse est 0.

Contraintes :

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0

Une fourmi est sur une frontière. Parfois, elle va à gauche et parfois à droite.
On vous donne un tableau d'entiers non nuls nums. La fourmi commence à lire nums depuis le premier élément jusqu'à sa fin. À chaque étape, elle se déplace selon la valeur de l'élément courant :

Si nums[i] < 0, elle se déplace de -nums[i] unités vers la gauche.
Si nums[i] > 0, elle se déplace de nums[i] unités vers la droite.

Retournez le nombre de fois que la fourmi revient à la frontière.
Remarques :

Il y a un espace infini de chaque côté de la frontière.
Nous vérifions si la fourmi est sur la frontière seulement après qu'elle s'est déplacée de |nums[i]| unités. En d'autres termes, si la fourmi traverse la frontière pendant son mouvement, cela ne compte pas.

Exemple 1 :

Entrée : nums = [2,3,-5]
Sortie : 1
Explication : Après la première étape, la fourmi est à 2 pas à droite de la frontière.
Après la deuxième étape, la fourmi est à 5 pas à droite de la frontière.
Après la troisième étape, la fourmi est sur la frontière.
Donc la réponse est 1.

Exemple 2 :

Entrée : nums = [3,2,-3,-4]
Sortie : 0
Explication : Après la première étape, la fourmi est à 3 pas à droite de la frontière.
Après la deuxième étape, la fourmi est à 5 pas à droite de la frontière.
Après la troisième étape, la fourmi est à 2 pas à droite de la frontière.
Après la quatrième étape, la fourmi est à 2 pas à gauche de la frontière.
La fourmi n'est jamais revenue à la frontière, donc la réponse est 0.

Contraintes :

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0


On vous donne une chaîne s à indice 0 saisie par un utilisateur. Changer de touche est défini comme utiliser une touche différente de la dernière utilisée. Par exemple, s = "ab" implique un changement de touche tandis que s = "bBBb" n'implique aucun changement.
Renvoyez le nombre de fois où l'utilisateur a dû changer de touche.
Remarque : Les modificateurs comme la touche majuscule ou le verrouillage des majuscules ne comptent pas pour un changement de touche. Si un utilisateur tape la lettre 'a' puis la lettre 'A', cela ne sera pas considéré comme un changement de touche.

Exemple 1 :

Entrée : s = "aAbBcC"
Sortie : 2
Explication :
De s[0] = 'a' à s[1] = 'A', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.
De s[1] = 'A' à s[2] = 'b', il y a un changement de touche.
De s[2] = 'b' à s[3] = 'B', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.
De s[3] = 'B' à s[4] = 'c', il y a un changement de touche.
De s[4] = 'c' à s[5] = 'C', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.

Exemple 2 :

Entrée : s = "AaAaAaaA"
Sortie : 0
Explication : Il n'y a pas de changement de touche puisque seules les lettres 'a' et 'A' sont appuyées, ce qui ne nécessite pas de changement de touche.

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres anglaises majuscules et minuscules.

On vous donne une chaîne indexée 0 s tapée par un utilisateur. Le changement de touche est défini comme l'utilisation d'une touche différente de la dernière touche utilisée. Par exemple, s = "ab" a un changement de touche tandis que s = "bBBb" n'en a pas.
Renvoie le nombre de fois que l'utilisateur a dû changer de touche.
Remarque : les modificateurs tels que Maj ou Verr Maj ne seront pas comptabilisés dans le changement de touche, c'est-à-dire que si un utilisateur a tapé la lettre « a » puis la lettre « A », cela ne sera pas considéré comme un changement de touche.

Exemple 1 :

Entrée : s = "aAbBcC"
Sortie : 2
Explication :
De s[0] = 'a' à s[1] = 'A', il n'y a pas de changement de touche car le verrouillage des majuscules ou la touche Maj ne sont pas comptabilisés.
De s[1] = 'A' à s[2] = 'b', il y a un changement de touche.
De s[2] = 'b' à s[3] = 'B', il n'y a pas de changement de touche car le verrouillage des majuscules ou la touche Maj ne sont pas comptés.
De s[3] = 'B' à s[4] = 'c', il y a un changement de touche.
De s[4] = 'c' à s[5] = 'C', il n'y a pas de changement de touche car le verrouillage des majuscules ou la touche Maj ne sont pas comptés.

Exemple 2 :

Entrée : s = "AaAaAaaA"
Sortie : 0
Explication : Il n'y a pas de changement de touche car seules les lettres « a » et « A » sont enfoncées, ce qui ne nécessite pas de changement de touche.

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres majuscules et minuscules anglaises.

On a une chaîne de caractères s indexée à partir de 0 saisie par un utilisateur. Changer de touche est défini comme utiliser une touche différente de la dernière utilisée. Par exemple, s = "ab" implique un changement de touche tandis que s = "bBBb" n'implique aucun changement.
Retournez le nombre de fois où l'utilisateur a dû changer de touche.
Remarque : Les modificateurs comme la touche majuscule ou le verrouillage des majuscules ne comptent pas comme changement de touche. Ainsi, si un utilisateur tape la lettre 'a' puis la lettre 'A', cela ne sera pas considéré comme un changement de touche.

Exemple 1 :

Entrée : s = "aAbBcC"
Sortie : 2
Explication :
De s[0] = 'a' à s[1] = 'A', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.
De s[1] = 'A' à s[2] = 'b', il y a un changement de touche.
De s[2] = 'b' à s[3] = 'B', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.
De s[3] = 'B' à s[4] = 'c', il y a un changement de touche.
De s[4] = 'c' à s[5] = 'C', il n'y a pas de changement de touche car la touche majuscule ou verrouillage des majuscules n'est pas comptée.

Exemple 2 :

Entrée : s = "AaAaAaaA"
Sortie : 0
Explication : Il n'y a pas de changement de touche puisque seules les lettres 'a' et 'A' sont pressées, ce qui ne nécessite pas de changement de touche.

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres anglaises majuscules et minuscules.


Vous avez un tableau de chaînes de caractères words indexé à 0 de longueur n, contenant des chaînes indexées à 0.
Vous êtes autorisé à effectuer l'opération suivante un nombre illimité de fois (y compris zéro) :

Choisissez les entiers i, j, x, et y tels que 0 <= i, j < n, 0 <= x < words[i].length, 0 <= y < words[j].length, et échangez les caractères words[i][x] et words[j][y].

Retournez un entier indiquant le nombre maximal de palindromes que words peut contenir, après avoir effectué certaines opérations.
Remarque : i et j peuvent être égaux lors d'une opération.

Exemple 1 :

Input: words = ["abbb","ba","aa"]
Output: 3
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 0, y = 0, donc nous échangeons words[0][0] et words[1][0]. words devient ["bbbb","aa","aa"].
Toutes les chaînes dans words sont maintenant des palindromes.
Ainsi, le nombre maximal de palindromes réalisable est 3.
Exemple 2 :

Input: words = ["abc","ab"]
Output: 2
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 1, y = 0, donc nous échangeons words[0][1] et words[1][0]. words devient ["aac","bb"].
Choisissez i = 0, j = 0, x = 1, y = 2, donc nous échangeons words[0][1] et words[0][2]. words devient ["aca","bb"].
Les deux chaînes sont maintenant des palindromes.
Ainsi, le nombre maximal de palindromes réalisable est 2.

Exemple 3 :

Input: words = ["cd","ef","a"]
Output: 1
Explication : Dans cet exemple, il n'est pas nécessaire d'effectuer une opération.
Il y a un palindrome dans words "a".
Il peut être démontré qu'il n'est pas possible d'obtenir plus d'un palindrome après un nombre quelconque d'opérations.
Ainsi, la réponse est 1.

Contraintes :

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] se compose uniquement de lettres minuscules anglaises.

Soit un tableau de chaînes de caractères words indexé à partir de 0, de longueur n, et contenant des chaînes indexées à 0.
Vous êtes autorisé à effectuer l'opération suivante un nombre quelconque de fois (y compris zéro) :

Choisissez les entiers i, j, x, et y tels que 0 <= i, j < n, 0 <= x < words[i].length, 0 <= y < words[j].length, et échangez les caractères words[i][x] et words[j][y].

Retournez un entier indiquant le nombre maximal de palindromes que words peut contenir, après avoir effectué certaines opérations.
Remarque : i et j peuvent être égaux lors d'une opération.

Exemple 1 :

Entrée: words = ["abbb","ba","aa"]
Sortie: 3
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 0, y = 0, donc nous échangeons words[0][0] et words[1][0]. words devient ["bbbb","aa","aa"].
Toutes les chaînes dans words sont maintenant des palindromes.
Ainsi, le nombre maximal de palindromes réalisable est 3.
Exemple 2 :

Entrée : words = ["abc","ab"]
Sortie : 2
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 1, y = 0, donc nous échangeons words[0][1] et words[1][0]. words devient ["aac","bb"].
Choisissez i = 0, j = 0, x = 1, y = 2, donc nous échangeons words[0][1] et words[0][2]. words devient ["aca","bb"].
Les deux chaînes sont maintenant des palindromes.
Ainsi, le nombre maximal de palindromes réalisable est 2.

Exemple 3 :

Entrée : words = ["cd","ef","a"]
Sortie : 1
Explication : Dans cet exemple, il n'est pas nécessaire d'effectuer une opération.
Il y a un palindrome dans words "a".
Il peut être démontré qu'il n'est pas possible d'obtenir plus d'un palindrome après un nombre quelconque d'opérations.
Ainsi, la réponse est 1.

Contraintes :

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] se compose uniquement de lettres minuscules anglaises.

On vous donne un tableau de chaînes indexées à 0, words, ayant une longueur n et contenant des chaînes indexées à 0.
Vous êtes autorisé à effectuer l'opération suivante autant de fois que vous le souhaitez (y compris zéro) :

Choisissez les entiers i, j, x et y tels que 0 <= i, j < n, 0 <= x < words[i].length, 0 <= y < words[j].length, et échangez les caractères words[i][x] et words[j][y].

Renvoyer un entier indiquant le nombre maximal de palindromes que words peut contenir, après avoir effectué certaines opérations.
Remarque : i et j peuvent être égaux pendant une opération.

Exemple 1 :

Entrée : words = ["abbb","ba","aa"]
Sortie : 3
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 0, y = 0, donc nous échangeons words[0][0] et words[1][0]. mots devient ["bbbb","aa","aa"].
Toutes les chaînes de mots sont maintenant des palindromes.
Par conséquent, le nombre maximal de palindromes atteignables est de 3.
Exemple 2 :

Entrée : mots = ["abc","ab"]
Sortie : 2
Explication : Dans cet exemple, une façon d'obtenir le nombre maximal de palindromes est :
Choisissez i = 0, j = 1, x = 1, y = 0, donc nous échangeons mots[0][1] et mots[1][0]. mots devient ["aac","bb"].
Choisissez i = 0, j = 0, x = 1, y = 2, donc nous échangeons mots[0][1] et mots[0][2]. mots devient ["aca","bb"].
Les deux chaînes sont maintenant des palindromes.
Par conséquent, le nombre maximal de palindromes réalisables est de 2.

Exemple 3 :

Entrée : words = ["cd","ef","a"]
Sortie : 1
Explication : Dans cet exemple, aucune opération n'est nécessaire.
Il existe un palindrome dans les mots « a ».
On peut montrer qu'il n'est pas possible d'obtenir plus d'un palindrome après un nombre quelconque d'opérations.
Par conséquent, la réponse est 1.

Contraintes :

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] se compose uniquement de lettres minuscules anglaises.