Un magicien possède divers sorts.
On vous donne un tableau power, où chaque élément représente les dégâts d'un sort. Plusieurs sorts peuvent avoir la même valeur de dégâts.
Il est connu que si un magicien décide de lancer un sort avec un dégât de power[i], il ne peut lancer aucun sort avec des dégâts de power[i] - 2, power[i] - 1, power[i] + 1, ou power[i] + 2.
Chaque sort ne peut être lancé qu'une seule fois.
Retournez le total maximal possible de dégâts qu'un magicien peut infliger.

Exemple 1 :

Entrée : power = [1,1,3,4]
Sortie : 6
Explication :
Le dommage maximal possible de 6 est obtenu en lançant les sorts 0, 1, 3 avec des dégâts 1, 1, 4.

Exemple 2 :

Entrée : power = [7,1,6,6]
Sortie : 13
Explication :
Le dommage maximal possible de 13 est obtenu en lançant les sorts 1, 2, 3 avec des dégâts 1, 6, 6.

Contraintes :

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

Un magicien possède divers sorts.
On vous donne un tableau power, où chaque élément représente les dégâts d'un sort. Plusieurs sorts peuvent avoir la même valeur de dégâts.
Il est connu que si un magicien décide de lancer un sort avec un dégât de power[i], il ne peut lancer aucun sort avec des dégâts de power[i] - 2, power[i] - 1, power[i] + 1, ou power[i] + 2.
Chaque sort peut être lancé une seule fois.
Retournez le total maximal possible de dégâts qu'un magicien peut infliger.

Exemple 1 :

Entrée : power = [1,1,3,4]
Sortie : 6
Explication :
Le dommage maximal possible de 6 est obtenu en lançant les sorts 0, 1, 3 avec des dégâts 1, 1, 4.

Exemple 2 :

Entrée : power = [7,1,6,6]
Sortie : 13
Explication :
Le dommage maximal possible de 13 est obtenu en lançant les sorts 1, 2, 3 avec des dégâts 1, 6, 6.

Contraintes :

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

Un magicien dispose de plusieurs sorts.
Vous recevez un tableau de puissance, où chaque élément représente les dégâts d'un sort. Plusieurs sorts peuvent avoir la même valeur de dégâts.
Il est bien connu que si un magicien décide de lancer un sort avec des dégâts de puissance[i], il ne peut pas lancer de sort avec des dégâts de puissance[i] - 2, puissance[i] - 1, puissance[i] + 1, ou puissance[i] + 2.
Chaque sort ne peut être lancé qu'une seule fois.
Renvoie les dégâts totaux maximums qu'un magicien peut infliger.

Exemple 1 :

Entrée : puissance = [1,1,3,4]
Sortie : 6
Explication :
Le maximum de dégâts possible de 6 est obtenu en lançant les sorts 0, 1, 3 avec les dégâts 1, 1, 4.

Exemple 2 :

Entrée : puissance = [7,1,6,6]
Sortie : 13
Explication :
Le maximum de dégâts possible de 13 est obtenu en lançant les sorts 1, 2, 3 avec les dégâts 1, 6, 6.

Contraintes :

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


Un pic dans un tableau arr est un élément qui est supérieur à son élément précédent et à son élément suivant dans arr.
On vous donne un tableau d'entiers nums et un tableau d'entiers 2D queries.
Vous devez traiter des requêtes de deux types :

queries[i] = [1, l_i, r_i], déterminer le nombre d'éléments de pic dans le sous-tableau nums[l_i..r_i].
queries[i] = [2, index_i, val_i], remplacer nums[index_i] par val_i.

Renvoyer une réponse de tableau contenant les résultats des requêtes du premier type dans l'ordre.
Remarques :

Le premier et le dernier élément d'un tableau ou d'un sous-tableau ne peuvent pas être un pic.

Exemple 1 :

Entrée : nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Sortie : [0]
Explication :
Première requête : nous changeons nums[3] en 4 et nums devient [3,1,4,4,5].
Deuxième requête : Le nombre de pics dans [3,1,4,4,5] est 0.

Exemple 2 :

Entrée : nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Sortie : [0,1]
Explication :
Première requête : nums[2] devrait devenir 4, mais il est déjà défini sur 4.
Deuxième requête : Le nombre de pics dans [4,1,4] est 0.
Troisième requête : Le deuxième 4 est un pic dans [4,1,4,2,1].

Contraintes :

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 ou queries[i][0] == 2
Pour tout i qui :

queries[i][0] == 1 : 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2 : 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Un pic dans un tableau arr est un élément qui est supérieur à son élément précédent et suivant dans arr.
On vous donne un tableau d'entiers nums et un tableau d'entiers 2D queries.
Vous devez traiter des requêtes de deux types :

queries[i] = [1, l_i, r_i], déterminer le nombre d'éléments pic dans le sous-tableau nums[l_i..r_i].
queries[i] = [2, index_i, val_i], changer nums[index_i] en val_i.

Retournez un tableau answer contenant les résultats des requêtes du premier type dans l'ordre.
Remarques :

Le premier et le dernier élément d'un tableau ou d'un sous-tableau ne peuvent pas être un pic.

Exemple 1 :

Entrée : nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Sortie : [0]
Explication :
Première requête : Nous changeons nums[3] en 4 et nums devient [3,1,4,4,5].
Deuxième requête : Le nombre de pics dans le [3,1,4,4,5] est 0.

Exemple 2 :

Entrée : nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Sortie : [0,1]
Explication :
Première requête : nums[2] devrait devenir 4, mais il est déjà fixé à 4.
Deuxième requête : Le nombre de pics dans le [4,1,4] est 0.
Troisième requête : Le deuxième 4 est un pic dans le [4,1,4,2,1].

Contraintes :

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 ou queries[i][0] == 2
Pour tout i tel que :

queries[i][0] == 1 : 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2 : 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Un pic dans un tableau arr est un élément qui est supérieur à son élément précédent et suivant dans arr.
On vous donne un tableau d'entiers nums et un tableau d'entiers 2D queries.
Vous devez traiter des requêtes de deux types :

queries[i] = [1, l_i, r_i], déterminer le nombre d'éléments pic dans le sous-tableau nums[l_i..r_i].
queries[i] = [2, index_i, val_i], changer nums[index_i] en val_i.

Retournez un tableau answer contenant les résultats des requêtes du premier type dans l'ordre.
Remarques :

Le premier et le dernier élément d'un tableau ou d'un sous-tableau ne peuvent pas être un pic.

Exemple 1 :

Entrée : nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Sortie : [0]
Explication :
Première requête : Nous changeons nums[3] en 4 et nums devient [3,1,4,4,5].
Deuxième requête : Le nombre de pics dans le [3,1,4,4,5] est 0.

Exemple 2 :

Entrée : nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Sortie : [0,1]
Explication :
Première requête : nums[2] devrait devenir 4, mais il est déjà réglé à 4.
Deuxième requête : Le nombre de pics dans le [4,1,4] est 0.
Troisième requête : Le deuxième 4 est un pic dans le [4,1,4,2,1].

Contraintes :

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 ou queries[i][0] == 2
Pour tout i tel que :

queries[i][0] == 1 : 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2 : 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5


On vous donne un tableau de nombres flottants averages qui est initialement vide. On vous donne un tableau nums de n entiers où n est pair.
Vous répétez la procédure suivante n / 2 fois :

Retirer l'élément le plus petit, minElement, et l'élément le plus grand maxElement, de nums.
Ajouter (minElement + maxElement) / 2 à averages.

Retourner l'élément minimal dans averages.

Exemple 1 :

Input: nums = [7,8,3,4,15,13,4,1]
Output: 5.5
Explication :

| étape | nums          | averages |
|-------|---------------|----------|
| 0     | [7,8,3,4,15,13,4,1] | []       |
| 1     | [7,8,3,4,13,4]      | [8]      |
| 2     | [7,8,4,4]           | [8,8]    |
| 3     | [7,4]               | [8,8,6]  |
| 4     | []                  | [8,8,6,5.5]  |

L'élément le plus petit de averages, 5.5, est retourné.

Exemple 2 :

Input: nums = [1,9,8,3,10,5]
Output: 5.5
Explication :

| étape | nums          | averages |
|-------|---------------|----------|
| 0     | [1,9,8,3,10,5]  | []       |
| 1     | [9,8,3,5]      | [5.5]    |
| 2     | [8,5]          | [5.5,6]  |
| 3     | []             | [5.5,6,6.5]  |

Exemple 3 :

Input: nums = [1,2,3,7,8,9]
Output: 5.0
Explication :

| étape | nums          | averages |
|-------|---------------|----------|
| 0     | [1,2,3,7,8,9]   | []       |
| 1     | [2,3,7,8]      | [5]      |
| 2     | [3,7]          | [5,5]    |
| 3     | []             | [5,5,5]  |

Contraintes :

2 <= n == nums.length <= 50
n est pair.
1 <= nums[i] <= 50

Vous avez un tableau de nombres flottants averages qui est initialement vide. On vous donne un tableau nums de n entiers où n est pair.
Vous répétez la procédure suivante n / 2 fois :

Retirer l'élément le plus petit, minElement, et l'élément le plus grand maxElement, de nums.
Ajouter (minElement + maxElement) / 2 à averages.

Retourner l'élément minimal dans averages.

Exemple 1 :

Entrée : nums = [7,8,3,4,15,13,4,1]
Sortie : 5.5
Explication :

étape
nums
averages

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

L'élément le plus petit de averages, 5.5, est retourné.
Exemple 2 :

Entrée : nums = [1,9,8,3,10,5]
Sortie : 5.5
Explication :

étape
nums
averages

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Exemple 3 :

Entrée : nums = [1,2,3,7,8,9]
Sortie : 5.0
Explication :

étape
nums
averages

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Contraintes :

2 <= n == nums.length <= 50
n est pair.
1 <= nums[i] <= 50

Vous avez un tableau de moyennes de nombres à virgule flottante qui est initialement vide. On vous donne un tableau des nombres de n entiers où n est pair.
Vous répétez la procédure suivante n / 2 fois:

Retirez le plus petit élément, minElement, et le plus grand élément, maxElement, de nums.
Ajouter (minElement + maxElement) / 2 aux moyennes.

Renvoyez l'élément minimum des moyennes.

Exemple 1:

Entrée: nums = [7,8,3,4,15,13,4,1]
Sortie: 5.5
Explication:

step
nums
averages

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

Le plus petit élément des moyennes, 5.5, est retourné.
Exemple 2:

Entrée: nums = [1,9,8,3,10,5]
Sortie: 5.5
Explication:

step
nums
averages

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6.5]

Exemple 3:

Entrée: nums = [1,2,3,7,8,9]
Sortie: 5.0
Explication:

step
nums
averages

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Contraintes:

2 <= n == nums.length <= 50
n est pair.
1 <= nums[i] <= 50


On donne un tableau binaire 2D appelé grid. Trouvez un rectangle avec des côtés horizontaux et verticaux ayant la plus petite aire, de sorte que tous les 1 de grid soient à l'intérieur de ce rectangle.
Retournez l'aire minimale possible du rectangle.

Exemple 1 :

Entrée : grid = [[0,1,0],[1,0,1]]
Sortie : 6
Explication :

Le plus petit rectangle a une hauteur de 2 et une largeur de 3, donc il a une aire de 2 * 3 = 6.

Exemple 2 :

Entrée : grid = [[1,0],[0,0]]
Sortie : 1
Explication :

Le plus petit rectangle a à la fois une hauteur et une largeur de 1, donc son aire est 1 * 1 = 1.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 0 soit 1.
L'entrée est générée de sorte qu'il y ait au moins un 1 dans grid.

Vous disposez d'un tableau binaire 2D appelé grid. Trouvez un rectangle avec des côtés horizontaux et verticaux ayant la plus petite aire, de sorte que tous les 1 de grid se trouvent à l'intérieur de ce rectangle.
Retournez l'aire minimale possible du rectangle.

Exemple 1 :

Entrée : grid = [[0,1,0],[1,0,1]]
Sortie : 6
Explication :

Le plus petit rectangle a une hauteur de 2 et une largeur de 3, donc il a une aire de 2 * 3 = 6.

Exemple 2 :

Entrée : grid = [[1,0],[0,0]]
Sortie : 1
Explication :

Le plus petit rectangle a à la fois une hauteur et une largeur de 1, donc son aire est 1 * 1 = 1.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 0 soit 1.
L'entrée est générée de sorte qu'il y ait au moins un 1 dans grid.

On vous donne une grille binaire 2D. Trouvez un rectangle avec des côtés horizontaux et verticaux ayant la plus petite surface, de telle sorte que tous les 1 de la grille se trouvent à l'intérieur de ce rectangle.
Renvoie la surface minimale possible du rectangle.

Exemple 1 :

Entrée : grille = [[0,1,0],[1,0,1]]
Sortie : 6
Explication :

Le plus petit rectangle a une hauteur de 2 et une largeur de 3, donc sa surface est de 2 * 3 = 6.

Exemple 2 :

Entrée : grid = [[1,0],[0,0]]
Sortie : 1
Explication :

Le plus petit rectangle a une hauteur et une largeur de 1, donc sa surface est de 1 * 1 = 1.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 0 soit 1.
L'entrée est générée de sorte qu'il y ait au moins un 1 dans grid.


On vous donne un tableau d'entiers nums de longueur n.
Le coût d’un sous-tableau nums[l..r], où 0 <= l <= r < n, est défini comme :
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Votre tâche consiste à diviser nums en sous-tableaux de sorte que le coût total des sous-tableaux soit maximisé, en veillant à ce que chaque élément appartienne exactement à un sous-tableau.
Formellement, si nums est divisé en k sous-tableaux, où k > 1, aux indices i_1, i_2, ..., i_k − 1, où 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, alors le coût total sera :
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Retournez un entier représentant le coût total maximal des sous-tableaux après avoir divisé le tableau de manière optimale.
Remarque : Si nums n’est pas divisé en sous-tableaux, c'est-à-dire k = 1, le coût total est simplement cost(0, n - 1).

Exemple 1 :

Input: nums = [1,-2,3,4]
Output: 10
Explication :
Une façon de maximiser le coût total est de diviser [1, -2, 3, 4] en sous-tableaux [1, -2, 3] et [4]. Le coût total sera (1 + 2 + 3) + 4 = 10.

Exemple 2 :

Input: nums = [1,-1,1,-1]
Output: 4
Explication :
Une façon de maximiser le coût total est de diviser [1, -1, 1, -1] en sous-tableaux [1, -1] et [1, -1]. Le coût total sera (1 + 1) + (1 + 1) = 4.

Exemple 3 :

Input: nums = [0]
Output: 0
Explication :
Nous ne pouvons pas diviser davantage le tableau, donc la réponse est 0.

Exemple 4 :

Input: nums = [1,-1]
Output: 2
Explication :
Sélectionner le tableau entier donne un coût total de 1 + 1 = 2, ce qui est le maximum.

Contraintes :

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

On vous donne un tableau d’entiers nums de longueur n.
Le coût d’un sous-tableau nums[l.. r], où 0 <= l <= r < n, est défini comme suit :
coût(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Votre tâche consiste à diviser les nums en sous-tableaux de sorte que le coût total des sous-tableaux soit maximisé, en veillant à ce que chaque élément appartienne exactement à un sous-tableau.
Formellement, si nums est divisé en k sous-tableaux, où k > 1, aux indices i_1, i_2, ..., i_k − 1, où 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, alors le coût total sera :
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Renvoie un entier indiquant le coût total maximal des sous-tableaux après avoir divisé le tableau de manière optimale.
Remarque : Si nums n’est pas divisé en sous-tableaux, c’est-à-dire k = 1, le coût total est simplement cost(0, n - 1).

Exemple 1 :

Entrée : nums = [1,-2,3,4]
Sortie : 10
Explication:
Une façon de maximiser le coût total est de diviser [1, -2, 3, 4] en sous-tableaux [1, -2, 3] et [4]. Le coût total sera de (1 + 2 + 3) + 4 = 10.

Exemple 2 :

Entrée : nums = [1,-1,1,-1]
Sortie : 4
Explication:
Une façon de maximiser le coût total est de diviser [1, -1, 1, -1] en sous-tableaux [1, -1] et [1, -1]. Le coût total sera de (1 + 1) + (1 + 1) = 4.

Exemple 3 :

Entrée : nums = [0]
Sortie : 0
Explication:
Nous ne pouvons pas diviser davantage le tableau, la réponse est donc 0.

Exemple 4 :

Entrée : nums = [1,-1]
Sortie : 2
Explication:
La sélection de l’ensemble du tableau donne un coût total de 1 + 1 = 2, ce qui est le maximum.

Contraintes:

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

On vous donne un tableau d’entiers nums de longueur n.
Le coût d’un sous-tableau nums[l.. r], où 0 <= l <= r < n, est défini comme suit :
coût(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Votre tâche consiste à diviser les nums en sous-tableaux de sorte que le coût total des sous-tableaux soit maximisé, en veillant à ce que chaque élément appartienne exactement à un sous-tableau.
Formellement, si nums est divisé en k sous-tableaux, où k > 1, aux indices i_1, i_2, ..., i_k − 1, où 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, alors le coût total sera :
coût(0, i_1) + coût(i_1 + 1, i_2) + ... + coût(i_k − 1 + 1, n − 1)
Retournez un entier indiquant le coût total maximal des sous-tableaux après avoir divisé le tableau de manière optimale.
Remarque : Si nums n’est pas divisé en sous-tableaux, c’est-à-dire k = 1, le coût total est simplement cost(0, n - 1).

Exemple 1 :

Entrée : nums = [1,-2,3,4]
Sortie : 10
Explication:
Une façon de maximiser le coût total est de diviser [1, -2, 3, 4] en sous-tableaux [1, -2, 3] et [4]. Le coût total sera de (1 + 2 + 3) + 4 = 10.

Exemple 2 :

Entrée : nums = [1,-1,1,-1]
Sortie : 4
Explication:
Une façon de maximiser le coût total est de diviser [1, -1, 1, -1] en sous-tableaux [1, -1] et [1, -1]. Le coût total sera de (1 + 1) + (1 + 1) = 4.

Exemple 3 :

Entrée : nums = [0]
Sortie : 0
Explication:
Nous ne pouvons pas diviser davantage le tableau, la réponse est donc 0.

Exemple 4 :

Entrée : nums = [1,-1]
Sortie : 2
Explication:
La sélection de l’ensemble du tableau donne un coût total de 1 + 1 = 2, ce qui est le maximum.

Contraintes:

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


On vous donne deux nombres entiers rouge et bleu représentant le nombre de boules colorées rouge et bleu. Vous devez disposer ces boules de manière à former un triangle de telle sorte que la première rangée contienne une boule, la deuxième rangée deux boules, la troisième rangée trois boules, et ainsi de suite.
Toutes les boules d'une rangée donnée doivent être de la même couleur, et les rangées adjacentes doivent être de couleurs différentes.
Retournez la hauteur maximale du triangle qui peut être obtenue.

Exemple 1 :

Entrée : rouge = 2, bleu = 4
Sortie : 3
Explication :

Le seul arrangement possible est illustré ci-dessus.

Exemple 2 :

Entrée : rouge = 2, bleu = 1
Sortie : 2
Explication :

Le seul arrangement possible est illustré ci-dessus.

Exemple 3 :

Entrée : rouge = 1, bleu = 1
Sortie : 1

Exemple 4 :

Entrée : rouge = 10, bleu = 1
Sortie : 2
Explication :

Le seul arrangement possible est illustré ci-dessus.

Contraintes :

1 <= rouge, bleu <= 100

Vous disposez de deux entiers rouge et bleu représentant le nombre de balles colorées en rouge et bleu. Vous devez arranger ces balles pour former un triangle de sorte que la 1ère rangée ait 1 balle, la 2ème rangée ait 2 balles, la 3ème rangée ait 3 balles, et ainsi de suite.
Toutes les balles d'une rangée particulière doivent être de la même couleur, et les rangées adjacentes doivent avoir des couleurs différentes.
Retournez la hauteur maximale du triangle qui peut être formé.

Exemple 1 :

Entrée : rouge = 2, bleu = 4
Sortie : 3
Explication :

La seule disposition possible est montrée ci-dessus.

Exemple 2 :

Entrée : rouge = 2, bleu = 1
Sortie : 2
Explication :

La seule disposition possible est montrée ci-dessus.

Exemple 3 :

Entrée : rouge = 1, bleu = 1
Sortie : 1

Exemple 4 :

Entrée : rouge = 10, bleu = 1
Sortie : 2
Explication :

La seule disposition possible est montrée ci-dessus.

Contraintes :

1 <= rouge, bleu <= 100

Vous disposez de deux entiers rouge et bleu représentant le nombre de balles colorées en rouge et bleu. Vous devez arranger ces balles pour former un triangle de sorte que la 1^re rangée ait 1 balle, la 2^e rangée ait 2 balles, la 3^e rangée ait 3 balles, et ainsi de suite. Toutes les balles d'une rangée particulière doivent être de la même couleur, et les rangées adjacentes doivent avoir des couleurs différentes. Retournez la hauteur maximale du triangle qui peut être atteinte.

Exemple 1 :

Entrée : rouge = 2, bleu = 4
Sortie : 3
Explication :

La seule disposition possible est montrée ci-dessus.

Exemple 2 :

Entrée : rouge = 2, bleu = 1
Sortie : 2
Explication :

La seule disposition possible est montrée ci-dessus.

Exemple 3 :

Entrée : rouge = 1, bleu = 1
Sortie : 1

Exemple 4 :

Entrée : rouge = 10, bleu = 1
Sortie : 2
Explication :

La seule disposition possible est montrée ci-dessus.

Contraintes :

1 <= rouge, bleu <= 100


On vous donne un tableau d'entiers nums.
Une sous-séquence sub de nums de longueur x est appelée valide si elle satisfait :

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Retournez la longueur de la plus longue sous-séquence valide de nums.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains éléments, ou aucun, sans changer l'ordre des éléments restants.

Exemple 1 :

Input: nums = [1,2,3,4]
Output: 4
Explication :
La plus longue sous-séquence valide est [1, 2, 3, 4].

Exemple 2 :

Input: nums = [1,2,1,1,2,1,2]
Output: 6
Explication :
La plus longue sous-séquence valide est [1, 2, 1, 2, 1, 2].

Exemple 3 :

Input: nums = [1,3]
Output: 2
Explication :
La plus longue sous-séquence valide est [1, 3].

Contraintes :

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

Vous avez un tableau d'entiers.
Une sous-séquence de nums avec la longueur x est appelé valide s'il satisfait:

(sub [0] + sub [1])% 2 == (sub [1] + sub [2])% 2 == ... == (sub [x - 2] + sub [x - 1]) % 2.

Retournez la longueur de la sous-séquence la plus longue valide de nums.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains éléments ou pas sans modifier l'ordre des éléments restants.

Exemple 1:

Entrée: nums = [1,2,3,4]
Sortie: 4
Explication:
La subséquence la plus longue valide est [1, 2, 3, 4].

Exemple 2:

Entrée: nums = [1,2,1,1,2,1,2]
Sortie: 6
Explication:
La subséquence la plus longue valide est [1, 2, 1, 2, 1, 2].

Exemple 3:

Entrée: nums = [1,3]
Sortie: 2
Explication:
La subséquence la plus longue valide est [1, 3].

Contraintes:

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

On vous donne un tableau d'entiers nums.
Une sous-séquence sub de nums de longueur x est appelée valide si elle satisfait :

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Renvoyez la longueur de la plus longue sous-séquence valide de nums.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains éléments, ou aucun, sans changer l'ordre des éléments restants.

Exemple 1 :

Input: nums = [1,2,3,4]
Output: 4
Explication :
La plus longue sous-séquence valide est [1, 2, 3, 4].

Exemple 2 :

Input: nums = [1,2,1,1,2,1,2]
Output: 6
Explication :
La plus longue sous-séquence valide est [1, 2, 1, 2, 1, 2].

Exemple 3 :

Input: nums = [1,3]
Output: 2
Explication :
La plus longue sous-séquence valide est [1, 3].

Contraintes :

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


On considère deux arbres non orientés avec n et m nœuds, numérotés respectivement de 0 à n - 1 et de 0 à m - 1. On vous donne deux tableaux 2D d'entiers edges1 et edges2 de longueurs respectives n - 1 et m - 1, où edges1[i] = [a_i, b_i] indique qu'il y a une arête entre les nœuds a_i et b_i dans le premier arbre et edges2[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans le deuxième arbre.
Vous devez connecter un nœud du premier arbre avec un autre nœud du deuxième arbre avec une arête.
Retournez le diamètre minimal possible de l'arbre résultant.
Le diamètre d'un arbre est la longueur du chemin le plus long entre deux nœuds quelconques dans l'arbre.

Exemple 1 :

Entrée : edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Sortie : 3
Explication :
On peut obtenir un arbre de diamètre 3 en connectant le nœud 0 du premier arbre avec n'importe quel nœud du deuxième arbre.

Exemple 2 :

Entrée : edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Sortie : 5
Explication :
On peut obtenir un arbre de diamètre 5 en connectant le nœud 0 du premier arbre avec le nœud 0 du deuxième arbre.

Contraintes :

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
L'entrée est générée de sorte que edges1 et edges2 représentent des arbres valides.

Il existe deux arbres non orientés avec n et m nœuds, numérotés de 0 à n - 1 et de 0 à m - 1, respectivement. On vous donne deux tableaux d'entiers 2D, edge1 et edge2, de longueurs n - 1 et m - 1, respectivement, où edges1[i] = [a_i, b_i] indique qu'il y a une arête entre les nœuds a_i et b_i dans le premier arbre et edges2[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans le deuxième arbre.
Vous devez connecter un nœud du premier arbre à un autre nœud du deuxième arbre avec une arête.
Renvoyer le diamètre minimal possible de l'arbre résultant.
Le diamètre d'un arbre est la longueur du chemin le plus long entre deux nœuds de l'arbre.

Exemple 1 :

Entrée : edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Sortie : 3
Explication :
Nous pouvons obtenir un arbre de diamètre 3 en connectant le nœud 0 du premier arbre à n'importe quel nœud du deuxième arbre.

Exemple 2 :

Entrée : edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Sortie : 5
Explication :
Nous pouvons obtenir un arbre de diamètre 5 en connectant le nœud 0 du premier arbre au nœud 0 du deuxième arbre.

Contraintes :

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edge2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
L'entrée est générée de telle sorte que edge1 et edge2 représentent des arbres valides.

Il existe deux arbres non orientés avec n et m nœuds, numérotés de 0 à n - 1 et de 0 à m - 1, respectivement. On vous donne deux tableaux 2D d'entiers edges1 et edges2 de longueurs n - 1 et m - 1, respectivement, où edges1[i] = [a_i, b_i] indique qu'il y a une arête entre les nœuds a_i et b_i dans le premier arbre et edges2[i] = [u_i, v_i] indique qu'il y a une arête entre les nœuds u_i et v_i dans le deuxième arbre. Vous devez connecter un nœud du premier arbre avec un autre nœud du deuxième arbre avec une arête. Retournez le diamètre minimal possible de l'arbre résultant. Le diamètre d'un arbre est la longueur du chemin le plus long entre deux nœuds quelconques dans l'arbre.

Exemple 1 :

Entrée : edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]] Sortie : 3 Explication : On peut obtenir un arbre de diamètre 3 en connectant le nœud 0 du premier arbre avec n'importe quel nœud du deuxième arbre.

Exemple 2 :

Entrée : edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]] Sortie : 5 Explication : On peut obtenir un arbre de diamètre 5 en connectant le nœud 0 du premier arbre avec le nœud 0 du deuxième arbre.

Contraintes :

1 <= n, m <= 10^5 edges1.length == n - 1 edges2.length == m - 1 edges1[i].length == edges2[i].length == 2 edges1[i] = [a_i, b_i] 0 <= a_i, b_i < n edges2[i] = [u_i, v_i] 0 <= u_i, v_i < m L'entrée est générée de sorte que edges1 et edges2 représentent des arbres valides.


On vous donne une chaîne de caractères s et un entier k. Chiffrez la chaîne en utilisant l'algorithme suivant :

Pour chaque caractère c dans s, remplacez c par le k^ème caractère après c dans la chaîne (de manière cyclique).

Renvoyez la chaîne chiffrée.

Exemple 1 :

Entrée : s = "dart", k = 3
Sortie : "tdar"
Explication :

Pour i = 0, le 3^ème caractère après 'd' est 't'.
Pour i = 1, le 3^ème caractère après 'a' est 'd'.
Pour i = 2, le 3^ème caractère après 'r' est 'a'.
Pour i = 3, le 3^ème caractère après 't' est 'r'.

Exemple 2 :

Entrée : s = "aaa", k = 1
Sortie : "aaa"
Explication :
Comme tous les caractères sont identiques, la chaîne chiffrée sera également identique.

Contraintes:

1 <= s.length <= 100
1 <= k <= 10^4
s se compose uniquement de lettres minuscules anglaises.

On vous donne une chaîne de caractères s et un entier k. Chiffrez la chaîne en utilisant l'algorithme suivant :

Pour chaque caractère c dans s, remplacez c par le k^ème caractère après c dans la chaîne (de manière cyclique).

Retournez la chaîne chiffrée.

Exemple 1 :

Entrée : s = "dart", k = 3
Sortie : "tdar"
Explication :

Pour i = 0, le 3^ème caractère après 'd' est 't'.
Pour i = 1, le 3^ème caractère après 'a' est 'd'.
Pour i = 2, le 3^ème caractère après 'r' est 'a'.
Pour i = 3, le 3^ème caractère après 't' est 'r'.

Exemple 2 :

Entrée : s = "aaa", k = 1
Sortie : "aaa"
Explication :
Comme tous les caractères sont identiques, la chaîne chiffrée sera également identique.

Contraintes :

1 <= s.length <= 100
1 <= k <= 10^4
s se compose uniquement de lettres minuscules anglaises.


On vous donne un entier positif n.
Une chaîne binaire x est valide si toutes les sous-chaînes de x de longueur 2 contiennent au moins un "1".
Renvoyez toutes les chaînes valides de longueur n, dans n'importe quel ordre.

Exemple 1 :

Entrée : n = 3
Sortie : ["010","011","101","110","111"]
Explication :
Les chaînes valides de longueur 3 sont : "010", "011", "101", "110" et "111".

Exemple 2 :

Entrée : n = 1
Sortie : ["0","1"]
Explication :
Les chaînes valides de longueur 1 sont : "0" et "1".

Contraintes :

1 <= n <= 18

On vous donne un entier positif n.
Une chaîne binaire x est valide si toutes les sous-chaînes de x de longueur 2 contiennent au moins un "1".
Retournez toutes les chaînes valides de longueur n, dans n'importe quel ordre.

Exemple 1 :

Entrée : n = 3
Sortie : ["010","011","101","110","111"]
Explication :
Les chaînes valides de longueur 3 sont : "010", "011", "101", "110" et "111".

Exemple 2 :

Entrée : n = 1
Sortie : ["0","1"]
Explication :
Les chaînes valides de longueur 1 sont : "0" et "1".

Contraintes :

1 <= n <= 18

On vous donne un entier positif n.
Une chaîne binaire x est valide si toutes les sous-chaînes de x de longueur 2 contiennent au moins un « 1 ».
Renvoie toutes les chaînes valides de longueur n, dans n'importe quel ordre.

Exemple 1 :

Entrée : n = 3
Sortie : ["010","011","101","110","111"]
Explication :
Les chaînes valides de longueur 3 sont : "010", "011", "101", "110" et "111".

Exemple 2 :

Entrée : n = 1
Sortie : ["0","1"]
Explication :
Les chaînes valides de longueur 1 sont : "0" et "1".

Contraintes :

1 <= n <= 18


Étant donné une matrice de caractères 2D grid, où grid[i][j] est soit 'X', 'Y', ou '.', retournez le nombre de sous-matrices qui contiennent :

grid[0][0]
une fréquence égale de 'X' et 'Y'.
au moins un 'X'.

Exemple 1 :

Entrée : grid = [["X","Y","."],["Y",".","."]]
Sortie : 3
Explication :

Exemple 2 :

Entrée : grid = [["X","X"],["X","Y"]]
Sortie : 0
Explication :
Aucune sous-matrice n'a une fréquence égale de 'X' et 'Y'.

Exemple 3 :

Entrée : grid = [[".","."],[".","."]]
Sortie : 0
Explication :
Aucune sous-matrice n'a au moins un 'X'.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 'X', 'Y', ou '.'.

Étant donné une matrice de caractères 2D, où grid[i][j] est soit 'X', soit 'Y', soit '.', renvoie le nombre de sous-matrices qu'elle contient :

grid[0][0]
une fréquence égale de 'X' et de 'Y'.
au moins un 'X'.

Exemple 1 :

Entrée : grid = [["X","Y","."],["Y",".","."]]
Sortie : 3
Explication :

Exemple 2 :

Entrée : grid = [["X","X"],["X","Y"]]
Sortie : 0
Explication :
Aucune sous-matrice n'a une fréquence égale de 'X' et de 'Y'.

Exemple 3 :

Entrée : grid = [[".","."],[".","."]]
Sortie : 0
Explication :
Aucune sous-matrice n'a au moins un 'X'.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 'X', 'Y', soit '.'.

Donné une matrice de caractères 2D grid, où grid[i][j] est soit 'X', 'Y', ou '.', retournez le nombre de sous-matrices qui contiennent :

grid[0][0]
une fréquence égale de 'X' et 'Y'.
au moins un 'X'.

Exemple 1 :

Entrée : grid = [["X","Y","."],["Y",".","."]]
Sortie : 3
Explication :

Exemple 2 :

Entrée : grid = [["X","X"],["X","Y"]]
Sortie : 0
Explication :
Aucune sous-matrice n'a une fréquence égale de 'X' et 'Y'.

Exemple 3 :

Entrée : grid = [[".","."],[".","."]]
Sortie : 0
Explication :
Aucune sous-matrice n'a au moins un 'X'.

Contraintes :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] est soit 'X', 'Y', ou '.'.


On vous donne une chaîne `target`, un tableau de chaînes `words`, et un tableau d'entiers `costs`, les deux tableaux ayant la même longueur.
Imaginez une chaîne vide `s`.
Vous pouvez effectuer l'opération suivante un nombre quelconque de fois (y compris zéro) :

Choisir un index `i` dans la plage [0, words.length - 1].
Ajouter `words[i]` à `s`.
Le coût de l'opération est `costs[i]`.

Renvoyez le coût minimal pour que `s` soit égal à `target`. Si ce n'est pas possible, renvoyez -1.

Exemple 1 :

Entrée : `target = "abcdef"`, `words = ["abdef","abc","d","def","ef"]`, `costs = [100,1,1,10,5]`
Sortie : 7
Explication :
Le coût minimal peut être atteint en effectuant les opérations suivantes :

Sélectionnez l'index 1 et ajoutez "abc" à `s` pour un coût de 1, ce qui donne `s = "abc"`.
Sélectionnez l'index 2 et ajoutez "d" à `s` pour un coût de 1, ce qui donne `s = "abcd"`.
Sélectionnez l'index 4 et ajoutez "ef" à `s` pour un coût de 5, ce qui donne `s = "abcdef"`.

Exemple 2 :

Entrée : `target = "aaaa"`, `words = ["z","zz","zzz"]`, `costs = [1,10,100]`
Sortie : -1
Explication :
Il est impossible de faire en sorte que `s` soit égal à `target`, donc nous renvoyons -1.

Contraintes :

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La somme totale de `words[i].length` est inférieure ou égale à 5 * 10^4.
`target` et `words[i]` sont composés uniquement de lettres minuscules anglaises.
1 <= costs[i] <= 10^4

On vous donne une chaîne cible, un tableau de chaînes de caractères words, et un tableau d'entiers costs, tous deux de même longueur.
Imaginez une chaîne vide s.
Vous pouvez effectuer l'opération suivante autant de fois que vous le souhaitez (y compris zéro) :

Choisissez un indice i dans l'intervalle [0, words.length - 1].
Ajoutez words[i] à s.
Le coût de l'opération est costs[i].

Retourner le coût minimum pour que s soit égal à la cible. Si ce n'est pas possible, renvoyer -1.

Exemple 1 :

Entrée : target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Résultat : 7
Explication :
Le coût minimum peut être atteint en effectuant les opérations suivantes :

Sélectionnez l'index 1 et ajoutez "abc" à s pour un coût de 1, ce qui donne s = "abc".
Sélectionnez l'index 2 et ajoutez "d" à s pour un coût de 1, ce qui donne s = "abcd".
Sélectionnez l'index 4 et ajoutez "ef" à s pour un coût de 5, ce qui donne s = "abcdef".

Exemple 2 :

Entrée : target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Sortie : -1
Explication :
Il est impossible de rendre s égal à cible, donc nous retournons -1.

Contraintes :

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La somme totale de words[i].length est inférieure ou égale à 5 * 10^4.
target et words[i] ne sont constitués que de lettres minuscules anglaises.
1 <= costs[i] <= 10^4

Vous avez une chaîne target, un tableau de chaînes words, et un tableau d'entiers costs, les deux tableaux ayant la même longueur.
Imaginez une chaîne vide s.
Vous pouvez effectuer l'opération suivante un nombre quelconque de fois (y compris zéro) :

Choisir un indice i dans la plage [0, words.length - 1].
Ajouter words[i] à s.
Le coût de l'opération est costs[i].

Retournez le coût minimal pour que s soit égal à target. Si ce n'est pas possible, retournez -1.

Exemple 1 :

Entrée : target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Sortie : 7
Explication :
Le coût minimal peut être atteint en effectuant les opérations suivantes :

Sélectionnez l'indice 1 et ajoutez "abc" à s pour un coût de 1, ce qui donne s = "abc".
Sélectionnez l'indice 2 et ajoutez "d" à s pour un coût de 1, ce qui donne s = "abcd".
Sélectionnez l'indice 4 et ajoutez "ef" à ` pour un coût de 5, ce qui donne s = "abcdef".

Exemple 2 :

Entrée : target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Sortie : -1
Explication :
Il est impossible de faire en sorte que s soit égal à target, donc nous retournons -1.

Contraintes :

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
La somme totale de words[i].length est inférieure ou égale à 5 * 10^4.
target et words[i] sont composés uniquement de lettres minuscules anglaises.
1 <= costs[i] <= 10^4


Étant donné une chaîne s contenant uniquement des chiffres, renvoyez la chaîne lexicographiquement la plus petite qui peut être obtenue après avoir échangé des chiffres adjacents dans s avec la même parité au plus une fois.
Les chiffres ont la même parité si les deux sont impairs ou pairs. Par exemple, 5 et 9, ainsi que 2 et 4, ont la même parité, tandis que 6 et 9 ne l'ont pas.

Exemple 1 :

Entrée : s = "45320"
Sortie : "43520"
Explication :
s[1] == '5' et s[2] == '3' ont tous deux la même parité, et leur échange donne la chaîne lexicographiquement la plus petite.

Exemple 2 :

Entrée : s = "001"
Sortie : "001"
Explication :
Il n'est pas nécessaire d'effectuer un échange car s est déjà la plus petite chaîne lexicographique.

Contraintes :

2 <= s.length <= 100
s est composé uniquement de chiffres.

Étant donné une chaîne s contenant uniquement des chiffres, retournez la chaîne lexicographiquement la plus petite pouvant être obtenue après avoir échangé au plus une fois des chiffres adjacents dans s ayant la même parité.
Les chiffres ont la même parité si les deux sont impairs ou les deux sont pairs. Par exemple, 5 et 9, ainsi que 2 et 4, ont la même parité, alors que 6 et 9 n'ont pas la même parité.

Exemple 1 :

Entrée : s = "45320"
Sortie : "43520"
Explication :
s[1] == '5' et s[2] == '3' ont tous deux la même parité, et en les échangeant, on obtient la chaîne lexicographiquement la plus petite.

Exemple 2 :

Entrée : s = "001"
Sortie : "001"
Explication :
Il n'est pas nécessaire d'effectuer un échange car s est déjà lexicographiquement la plus petite.

Contraintes :

2 <= s.length <= 100
s est composé uniquement de chiffres.

Étant donné une chaîne s contenant uniquement des chiffres, retournez la chaîne lexicographiquement la plus petite qui peut être obtenue après avoir échangé des chiffres adjacents dans s ayant la même parité au plus une fois. Les chiffres ont la même parité si les deux sont impairs ou les deux sont pairs. Par exemple, 5 et 9, ainsi que 2 et 4, ont la même parité, alors que 6 et 9 n'ont pas la même parité.

Exemple 1 :

Entrée : s = "45320"
Sortie : "43520"
Explication :
s[1] == '5' et s[2] == '3' ont tous deux la même parité, et les échanger résulte en la chaîne lexicographiquement la plus petite.

Exemple 2 :

Entrée : s = "001"
Sortie : "001"
Explication :
Il n'est pas nécessaire d'effectuer un échange car s est déjà la plus petite lexicographiquement.

Contraintes :

2 <= s.length <= 100
s est composé uniquement de chiffres.


Il y a un gâteau de m x n qu'il faut couper en morceaux de 1 x 1.
On vous donne les entiers m, n, et deux tableaux :

horizontalCut de taille m - 1, où horizontalCut[i] représente le coût de coupe le long de la ligne horizontale i.
verticalCut de taille n - 1, où verticalCut[j] représente le coût de coupe le long de la ligne verticale j.

Lors d'une opération, vous pouvez choisir un morceau de gâteau qui n'est pas encore un carré de 1 x 1 et effectuer l'une des coupes suivantes :

Couper le long d'une ligne horizontale i à un coût de horizontalCut[i].
Couper le long d'une ligne verticale j à un coût de verticalCut[j].

Après la coupe, le morceau de gâteau est divisé en deux morceaux distincts.
Le coût d'une coupe dépend uniquement du coût initial de la ligne et ne change pas.
Retournez le coût total minimum pour couper tout le gâteau en morceaux de 1 x 1.

Exemple 1 :

Entrée : m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Sortie : 13
Explication :

Effectuez une coupe sur la ligne verticale 0 avec un coût de 5, le coût total actuel est de 5.
Effectuez une coupe sur la ligne horizontale 0 sur la sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 0 sur la sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 1 sur la sous-grille 2 x 1 avec un coût de 3.
Effectuez une coupe sur la ligne horizontale 1 sur la sous-grille 2 x 1 avec un coût de 3.

Le coût total est 5 + 1 + 1 + 3 + 3 = 13.

Exemple 2 :

Entrée : m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Sortie : 15
Explication :

Effectuez une coupe sur la ligne horizontale 0 avec un coût de 7.
Effectuez une coupe sur la ligne verticale 0 sur la sous-grille 1 x 2 avec un coût de 4.
Effectuez une coupe sur la ligne verticale 0 sur la sous-grille 1 x 2 avec un coût de 4.

Le coût total est 7 + 4 + 4 = 15.

Contraintes :

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

On considère un gâteau de m x n qu'il faut couper en parts de 1 x 1.
On vous donne les entiers m, n, et deux tableaux :

horizontalCut de taille m - 1, où horizontalCut[i] représente le coût de coupe le long de la ligne horizontale i.
verticalCut de taille n - 1, où verticalCut[j] représente le coût de coupe le long de la ligne verticale j.

Lors d'une opération, vous pouvez choisir un morceau de gâteau qui n'est pas encore un carré de 1 x 1 et effectuer l'une des coupes suivantes :

Couper le long d'une ligne horizontale i à un coût de horizontalCut[i].
Couper le long d'une ligne verticale j à un coût de verticalCut[j].

Après la coupe, le morceau de gâteau est divisé en deux morceaux distincts.
Le coût d'une coupe dépend uniquement du coût initial de la ligne et ne change pas.
Retournez le coût total minimum pour couper tout le gâteau en morceaux de 1 x 1.

Exemple 1 :

Entrée : m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Sortie : 13
Explication :

Effectuez une coupe sur la ligne verticale 0 avec un coût de 5, le coût total actuel est de 5.
Effectuez une coupe sur la ligne horizontale 0 sur la sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 0 sur la sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 1 sur la sous-grille 2 x 1 avec un coût de 3.
Effectuez une coupe sur la ligne horizontale 1 sur la sous-grille 2 x 1 avec un coût de 3.

Le coût total est 5 + 1 + 1 + 3 + 3 = 13.

Exemple 2 :

Entrée : m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Sortie : 15
Explication :

Effectuez une coupe sur la ligne horizontale 0 avec un coût de 7.
Effectuez une coupe sur la ligne verticale 0 sur la sous-grille 1 x 2 avec un coût de 4.
Effectuez une coupe sur la ligne verticale 0 sur la sous-grille 1 x 2 avec un coût de 4.

Le coût total est 7 + 4 + 4 = 15.

Contraintes :

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

Il y a un gâteau m x n qui doit être coupé en morceaux de 1 x 1.
On vous donne des entiers m, n et deux tableaux :

horizontalCut de taille m - 1, où horizontalCut[i] représente le coût de coupe le long de la ligne horizontale i.
verticalCut de taille n - 1, où verticalCut[j] représente le coût de coupe le long de la ligne verticale j.

En une seule opération, vous pouvez choisir n’importe quel morceau de gâteau qui n’est pas encore un carré 1 x 1 et effectuer l’une des coupes suivantes :

Coupez le long d’une ligne horizontale i au coût de horizontalCut[i].
Coupez le long d’une ligne verticale j au coût de verticalCut[j].

Après la coupe, le morceau de gâteau est divisé en deux morceaux distincts.
Le coût d’une coupe dépend uniquement du coût initial de la ligne et ne change pas.
Retournez le coût total minimum pour couper le gâteau entier en 1 x 1 morceaux.

Exemple 1 :

Entrée : m = 3, n = 2, horizontale = [1,3], verticale = [5]
Sortie : 13
Explication:

Effectuez une coupe sur la ligne verticale 0 avec un coût de 5, le coût total actuel est de 5.
Effectuez une coupe sur la ligne horizontale 0 sur une sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 0 sur une sous-grille 3 x 1 avec un coût de 1.
Effectuez une coupe sur la ligne horizontale 1 sur une sous-grille 2 x 1 avec un coût de 3.
Effectuez une coupe sur la ligne horizontale 1 sur une sous-grille 2 x 1 avec un coût de 3.

Le coût total est de 5 + 1 + 1 + 3 + 3 = 13.

Exemple 2 :

Entrée : m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Sortie : 15
Explication:

Effectuez une coupe sur la ligne horizontale 0 avec un coût de 7.
Effectuez une coupe sur la ligne verticale 0 sur une sous-grille 1 x 2 avec un coût de 4.
Effectuez une coupe sur la ligne verticale 0 sur une sous-grille 1 x 2 avec un coût de 4.

Le coût total est de 7 + 4 + 4 = 15.

Contraintes:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3


Vous avez deux entiers positifs n et k.
Vous pouvez choisir n'importe quel bit égal à 1 dans la représentation binaire de n et le changer en 0.
Retournez le nombre de changements nécessaires pour que n soit égal à k. Si c'est impossible, retournez -1.

Exemple 1 :

Entrée : n = 13, k = 4
Sortie : 2
Explication :
Initialement, les représentations binaires de n et k sont n = (1101)_2 et k = (0100)_2.
Nous pouvons changer le premier et le quatrième bit de n. L'entier résultant est n = (0100)_2 = k.

Exemple 2 :

Entrée : n = 21, k = 21
Sortie : 0
Explication :
n et k sont déjà égaux, donc aucun changement n'est nécessaire.

Exemple 3 :

Entrée : n = 14, k = 13
Sortie : -1
Explication :
Il n'est pas possible de faire en sorte que n soit égal à k.

Contraintes :

1 <= n, k <= 10^6

Vous avez deux entiers positifs n et k.
Vous pouvez choisir n'importe quel bit égal à 1 dans la représentation binaire de n et le changer en 0.
Retournez le nombre de changements nécessaires pour que n soit égal à k. Si c'est impossible, retournez -1.

Exemple 1:

Entrée: n = 13, k = 4
Sortie: 2
Explication:
Initialement, les représentations binaires de n et k sont n = (1101)_2 et k = (0100)_2.
Nous pouvons changer le premier et le quatrième bit de n. L'entier résultant est n = (0100)_2 = k.

Exemple 2:

Entrée: n = 21, k = 21
Sortie: 0
Explication:
n et k sont déjà égaux, donc aucun changement n'est nécessaire.

Exemple 3:

Entrée: n = 14, k = 13
Sortie: -1
Explication:
Il n'est pas possible de faire en sorte que n soit égal à k.

Contraintes:

1 <= n, k <= 10^6


Alice et Bob jouent à un jeu sur une chaîne de caractères.
On donne une chaîne s, Alice et Bob jouent tour à tour au jeu selon les règles suivantes, Alice commence en premier :

Au tour d'Alice, elle doit retirer toute sous-chaîne non vide de s qui contient un nombre impair de voyelles.
Au tour de Bob, il doit retirer toute sous-chaîne non vide de s qui contient un nombre pair de voyelles.

Le premier joueur qui ne peut pas faire de mouvement à son tour perd la partie. Nous supposons qu'Alice et Bob jouent de manière optimale.
Retournez true si Alice gagne la partie, et false sinon.
Les voyelles en anglais sont : a, e, i, o, et u.

Exemple 1 :

Entrée : s = "leetcoder"
Sortie : true
Explication :
Alice peut gagner la partie comme suit :

Alice joue en premier, elle peut supprimer la sous-chaîne soulignée dans s = "leetcoder" qui contient 3 voyelles. La chaîne résultante est s = "der".
Bob joue en deuxième, il peut supprimer la sous-chaîne soulignée dans s = "der" qui contient 0 voyelles. La chaîne résultante est s = "er".
Alice joue en troisième, elle peut supprimer toute la chaîne s = "er" qui contient 1 voyelle.
Bob joue en quatrième, puisque la chaîne est vide, il n'y a aucun jeu valide pour Bob. Donc Alice gagne la partie.

Exemple 2 :

Entrée : s = "bbcd"
Sortie : false
Explication :
Il n'y a aucun jeu valide pour Alice à son premier tour, donc Alice perd la partie.

Contraintes :

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

Alice et Bob jouent à un jeu sur une chaîne de caractères.
On vous donne une chaîne s, Alice et Bob jouent tour à tour au jeu suivant où Alice commence en premier :

Au tour d'Alice, elle doit retirer toute sous-chaîne non vide de s qui contient un nombre impair de voyelles.
Au tour de Bob, il doit retirer toute sous-chaîne non vide de s qui contient un nombre pair de voyelles.

Le premier joueur qui ne peut pas faire de mouvement à son tour perd la partie. Nous supposons qu'Alice et Bob jouent de manière optimale.
Retournez vrai si Alice gagne la partie, et faux sinon.
Les voyelles en anglais sont : a, e, i, o, et u.

Exemple 1 :

Entrée : s = "leetcoder"
Sortie : true
Explication :
Alice peut gagner la partie comme suit :

Alice joue en premier, elle peut supprimer la sous-chaîne soulignée dans s = "leetcoder" qui contient 3 voyelles. La chaîne résultante est s = "der".
Bob joue en second, il peut supprimer la sous-chaîne soulignée dans s = "der" qui contient 0 voyelle. La chaîne résultante est s = "er".
Alice joue en troisième, elle peut supprimer toute la chaîne s = "er" qui contient 1 voyelle.
Bob joue en quatrième, puisque la chaîne est vide, il n'y a aucun jeu valide pour Bob. Donc Alice gagne la partie.

Exemple 2 :

Entrée : s = "bbcd"
Sortie : false
Explication :
Il n'y a aucun jeu valide pour Alice à son premier tour, donc Alice perd la partie.

Contraintes :

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

Alice et Bob jouent à un jeu sur une ficelle.
On vous donne une chaîne de caractères s. Alice et Bob joueront à tour de rôle au jeu suivant, Alice commençant en premier :

Au tour d'Alice, elle doit retirer de s toute sous-chaîne non vide contenant un nombre impair de voyelles.
Au tour de Bob, il doit retirer de s toute sous-chaîne non vide contenant un nombre pair de voyelles.

Le premier joueur qui ne peut pas jouer à son tour perd la partie. Nous supposons qu'Alice et Bob jouent de manière optimale.
Retourne true si Alice gagne la partie, et false sinon.
Les voyelles anglaises sont : a, e, i, o et u.

Exemple 1 :

Entrée : s = "leetcoder"
Sortie : true
Explication :
Alice peut gagner le jeu comme suit :

Alice joue en premier, elle peut supprimer la sous-chaîne soulignée dans s = "leetcoder" qui contient 3 voyelles. La chaîne résultante est s = "der".
Bob joue en second, il peut supprimer la sous-chaîne soulignée dans s = "der" qui contient 0 voyelles. La chaîne résultante est s = "er".
Alice joue en troisième, elle peut supprimer toute la chaîne s = "er" qui contient 1 voyelle.
Bob joue en quatrième, puisque la chaîne est vide, il n'y a pas de jeu valide pour Bob. Alice gagne donc la partie.

Exemple 2 :

Entrée : s = "bbcd"
Sortie : false
Explication :
Il n'y a pas de jeu valide pour Alice lors de son premier tour, donc Alice perd la partie.

Contraintes :

1 <= s.length <= 10^5
s n'est constitué que de lettres minuscules anglaises.


On vous donne une chaîne binaire s.
Vous pouvez effectuer l'opération suivante sur la chaîne un nombre quelconque de fois :

Choisissez n'importe quel index i de la chaîne où i + 1 < s.length tel que s[i] == '1' et s[i + 1] == '0'.
Déplacez le caractère s[i] vers la droite jusqu'à ce qu'il atteigne la fin de la chaîne ou un autre '1'. Par exemple, pour s = "010010", si nous choisissons i = 1, la chaîne résultante sera s = "000110".

Retournez le nombre maximum d'opérations que vous pouvez effectuer.

Exemple 1 :

Entrée : s = "1001101"
Sortie : 4
Explication :
Nous pouvons effectuer les opérations suivantes :

Choisissez l'index i = 0. La chaîne résultante est s = "0011101".
Choisissez l'index i = 4. La chaîne résultante est s = "0011011".
Choisissez l'index i = 3. La chaîne résultante est s = "0010111".
Choisissez l'index i = 2. La chaîne résultante est s = "0001111".

Exemple 2 :

Entrée : s = "00111"
Sortie : 0

Contraintes :

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

On vous donne une chaîne binaire s.
Vous pouvez effectuer l'opération suivante sur la chaîne un nombre de fois illimité :

Choisissez n'importe quel index i de la chaîne où i + 1 < s.length tel que s[i] == '1' et s[i + 1] == '0'.
Déplacez le caractère s[i] vers la droite jusqu'à ce qu'il atteigne la fin de la chaîne ou un autre '1'. Par exemple, pour s = "010010", si nous choisissons i = 1, la chaîne résultante sera s = "000110".

Retournez le nombre maximum d'opérations que vous pouvez effectuer.

Exemple 1 :

Entrée : s = "1001101"
Sortie : 4
Explication :
Nous pouvons effectuer les opérations suivantes :

Choisissez l'index i = 0. La chaîne résultante est s = "0011101".
Choisissez l'index i = 4. La chaîne résultante est s = "0011011".
Choisissez l'index i = 3. La chaîne résultante est s = "0010111".
Choisissez l'index i = 2. La chaîne résultante est s = "0001111".

Exemple 2 :

Entrée : s = "00111"
Sortie : 0

Contraintes :

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

On vous donne une chaîne binaire s.
Vous pouvez effectuer l'opération suivante sur la chaîne autant de fois que vous le souhaitez :

Choisissez un index i dans la chaîne où i + 1 < s.length tel que s[i] == '1' et s[i + 1] == '0'.
Déplacez le caractère s[i] vers la droite jusqu'à ce qu'il atteigne la fin de la chaîne ou un autre « 1 ». Par exemple, pour s = "010010", si nous choisissons i = 1, la chaîne résultante sera s = "000110".

Renvoie le nombre maximal d'opérations que vous pouvez effectuer.

Exemple 1 :

Entrée : s = "1001101"
Sortie : 4
Explication :
Nous pouvons effectuer les opérations suivantes :

Choisissez l'index i = 0. La chaîne résultante est s = "0011101".
Choisissez l'index i = 4. La chaîne résultante est s = "0011011".
Choisissez l'index i = 3. La chaîne résultante est s = "0010111".
Choisissez l'index i = 2. La chaîne résultante est s = "0001111".

Exemple 2 :

Entrée : s = "00111"
Sortie : 0

Contraintes :

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


Vous avez deux tableaux d'entiers positifs nums et target, de même longueur.
Dans une seule opération, vous pouvez sélectionner n'importe quel sous-tableau de nums et incrémenter ou décrémenter chaque élément de ce sous-tableau de 1.
Retournez le nombre minimum d'opérations nécessaires pour rendre nums égal au tableau target.

Exemple 1 :

Entrée : nums = [3,5,1,2], target = [4,6,2,4]
Sortie : 2
Explication :
Nous effectuerons les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..3] de 1, nums = [4,6,2,3].
- Incrémenter nums[3..3] de 1, nums = [4,6,2,4].

Exemple 2 :

Entrée : nums = [1,3,2], target = [2,1,4]
Sortie : 5
Explication :
Nous effectuerons les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..0] de 1, nums = [2,3,2].
- Décrémenter nums[1..1] de 1, nums = [2,2,2].
- Décrémenter nums[1..1] de 1, nums = [2,1,2].
- Incrémenter nums[2..2] de 1, nums = [2,1,3].
- Incrémenter nums[2..2] de 1, nums = [2,1,4].

Contraintes :

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

On vous donne deux tableaux d'entiers positifs nums et target, de même longueur.
En une seule opération, vous pouvez sélectionner n'importe quel sous-tableau de nums et incrémenter ou décrémenter chaque élément de ce sous-tableau de 1.
Renvoie le nombre minimum d'opérations requises pour rendre nums égal au tableau target.

Exemple 1 :

Entrée : nums = [3,5,1,2], target = [4,6,2,4]
Sortie : 2
Explication :
Nous allons effectuer les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..3] de 1, nums = [4,6,2,3].
- Incrémenter nums[3..3] de 1, nums = [4,6,2,4].

Exemple 2 :

Entrée : nums = [1,3,2], target = [2,1,4]
Sortie : 5
Explication :
Nous allons effectuer les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..0] de 1, nums = [2,3,2].
- Décrémenter nums[1..1] de 1, nums = [2,2,2].
- Décrémenter nums[1..1] de 1, nums = [2,1,2].
- Incrémenter nums[2..2] de 1, nums = [2,1,3].
- Incrémenter nums[2..2] de 1, nums = [2,1,4].

Contraintes :

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

Vous avez deux tableaux d'entiers positifs nums et target, de même longueur.
Dans une seule opération, vous pouvez sélectionner n'importe quel sous-tableau de nums et augmenter ou diminuer chaque élément de ce sous-tableau de 1.
Renvoyez le nombre minimum d'opérations nécessaires pour rendre nums égal au tableau target.

Exemple 1 :

Entrée : nums = [3,5,1,2], target = [4,6,2,4]
Sortie : 2
Explication :
Nous effectuerons les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..3] de 1, nums = [4,6,2,3].
- Incrémenter nums[3..3] de 1, nums = [4,6,2,4].

Exemple 2 :

Entrée : nums = [1,3,2], target = [2,1,4]
Sortie : 5
Explication :
Nous effectuerons les opérations suivantes pour rendre nums égal à target :
- Incrémenter nums[0..0] de 1, nums = [2,3,2].
- Décrémenter nums[1..1] de 1, nums = [2,2,2].
- Décrémenter nums[1..1] de 1, nums = [2,1,2].
- Incrémenter nums[2..2] de 1, nums = [2,1,3].
- Incrémenter nums[2..2] de 1, nums = [2,1,4].

Contraintes :

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


On vous donne un tableau d'entiers positifs nums.
Alice et Bob jouent à un jeu. Dans ce jeu, Alice peut choisir soit tous les nombres à un chiffre, soit tous les nombres à deux chiffres de nums, et le reste des nombres est donné à Bob. Alice gagne si la somme de ses nombres est strictement supérieure à la somme des nombres de Bob.
Retournez true si Alice peut gagner ce jeu, sinon, retournez false.

Exemple 1 :

Entrée : nums = [1,2,3,4,10]
Sortie : false
Explication :
Alice ne peut pas gagner en choisissant des nombres à un chiffre ou à deux chiffres.

Exemple 2 :

Entrée : nums = [1,2,3,4,5,14]
Sortie : true
Explication :
Alice peut gagner en choisissant des nombres à un chiffre dont la somme est égale à 15.

Exemple 3 :

Entrée : nums = [5,5,5,25]
Sortie : true
Explication :
Alice peut gagner en choisissant des nombres à deux chiffres dont la somme est égale à 25.

Contraintes :

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

Vous avez un tableau d'entiers positifs nums.
Alice et Bob jouent à un jeu. Dans ce jeu, Alice peut choisir soit tous les nombres à un chiffre, soit tous les nombres à deux chiffres de nums, et le reste des nombres est donné à Bob. Alice gagne si la somme de ses nombres est strictement supérieure à la somme des nombres de Bob.
Renvoyez true si Alice peut gagner ce jeu, sinon, renvoyez false.

Exemple 1 :

Entrée : nums = [1,2,3,4,10]
Sortie : false
Explication :
Alice ne peut pas gagner en choisissant soit les nombres à un chiffre, soit les nombres à deux chiffres.

Exemple 2 :

Entrée : nums = [1,2,3,4,5,14]
Sortie : true
Explication :
Alice peut gagner en choisissant les nombres à un chiffre qui ont une somme égale à 15.

Exemple 3 :

Entrée : nums = [5,5,5,25]
Sortie : true
Explication :
Alice peut gagner en choisissant les nombres à deux chiffres qui ont une somme égale à 25.

Contraintes :

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

Vous avez un tableau d'entiers positifs nums.
Alice et Bob jouent à un jeu. Dans ce jeu, Alice peut choisir soit tous les nombres à un chiffre, soit tous les nombres à deux chiffres de nums, et le reste des nombres est donné à Bob. Alice gagne si la somme de ses nombres est strictement supérieure à la somme des nombres de Bob.
Retournez true si Alice peut gagner ce jeu, sinon, retournez false.

Exemple 1 :

Entrée : nums = [1,2,3,4,10]
Sortie : false
Explication :
Alice ne peut pas gagner en choisissant soit les nombres à un chiffre, soit les nombres à deux chiffres.

Exemple 2 :

Entrée : nums = [1,2,3,4,5,14]
Sortie : true
Explication :
Alice peut gagner en choisissant les nombres à un chiffre qui ont une somme égale à 15.

Exemple 3 :

Entrée : nums = [5,5,5,25]
Sortie : true
Explication :
Alice peut gagner en choisissant les nombres à deux chiffres qui ont une somme égale à 25.

Contraintes :

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


On vous donne 2 entiers positifs l et r. Pour n'importe quel nombre x, tous les diviseurs positifs de x sauf x sont appelés les diviseurs propres de x.
Un nombre est dit spécial s'il a exactement 2 diviseurs propres. Par exemple :

Le nombre 4 est spécial car il a pour diviseurs propres 1 et 2.
Le nombre 6 n'est pas spécial car il a pour diviseurs propres 1, 2 et 3.

Retournez le compte de nombres dans l'intervalle [l, r] qui ne sont pas spéciaux.

Exemple 1 :

Input: l = 5, r = 7
Output: 3
Explication :
Il n'y a pas de nombre spécial dans l'intervalle [5, 7].

Exemple 2 :

Input: l = 4, r = 16
Output: 11
Explication :
Les nombres spéciaux dans l'intervalle [4, 16] sont 4 et 9.

Contraintes :

1 <= l <= r <= 10^9

On vous donne 2 entiers positifs l et r. Pour tout nombre x, tous les diviseurs positifs de x, à l’exception de x, sont appelés les diviseurs propres de x.
Un nombre est dit spécial s’il a exactement 2 diviseurs propres. Par exemple:

Le nombre 4 est spécial parce qu’il a les diviseurs 1 et 2 propres.
Le nombre 6 n’est pas spécial car il a des diviseurs propres 1, 2 et 3.

Renvoie le nombre de nombres de l’intervalle [l, r] qui ne sont pas spéciaux.

Exemple 1 :

Entrée : l = 5, r = 7
Sortie : 3
Explication:
Il n’y a pas de numéros spéciaux dans la plage [5, 7].

Exemple 2 :

Entrée : l = 4, r = 16
Sortie : 11
Explication:
Les numéros spéciaux de la plage [4, 16] sont 4 et 9.

Contraintes:

1 <= l <= r <= 10^9


On vous donne une chaîne binaire s.
Renvoie le nombre de sous-chaînes avec des uns dominants.
Une chaîne a des uns dominants si le nombre de uns dans la chaîne est supérieur ou égal au carré du nombre de zéros dans la chaîne.

Exemple 1 :

Entrée : s = "00011"
Sortie : 5
Explication :
Les sous-chaînes avec des uns dominants sont présentées dans le tableau ci-dessous.

i
j
s[i..j]
Nombre de zéros
Nombre de uns

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Example 2:

Entrée : s = "101101"
Sortie : 16
Explication :
Les sous-chaînes contenant des uns non dominants sont présentées dans le tableau ci-dessous.
Puisqu'il y a 21 sous-chaînes au total et que 5 d'entre elles contiennent des uns non dominants, il s'ensuit qu'il y a 16 sous-chaînes contenant des uns dominants.

i
j
s[i..j]
Nombre de zéros
Nombre de uns

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Constraints:

1 <= s.length <= 4 * 10^4
s se compose uniquement des caractères '0' et '1'.

On vous donne une chaîne binaire s.
Retournez le nombre de sous-chaînes avec une dominante de uns.
Une chaîne a une dominante de uns si le nombre de uns dans la chaîne est supérieur ou égal au carré du nombre de zéros dans la chaîne.

Exemple 1 :

Entrée : s = "00011"
Sortie : 5
Explication :
Les sous-chaînes avec une dominante de uns sont montrées dans le tableau ci-dessous.

| i | j | s[i..j] | Nombre de Zéros | Nombre de Uns |
|---|---|---------|----------------|--------------|
| 3 | 3 | 1       | 0              | 1            |
| 4 | 4 | 1       | 0              | 1            |
| 2 | 3 | 01      | 1              | 1            |
| 3 | 4 | 11      | 0              | 2            |
| 2 | 4 | 011     | 1              | 2            |

Exemple 2 :

Entrée : s = "101101"
Sortie : 16
Explication :
Les sous-chaînes avec une non-dominante de uns sont montrées dans le tableau ci-dessous.
Puisqu'il y a 21 sous-chaînes au total et que 5 d'entre elles ont une non-dominante de uns, il en découle qu'il y a 16 sous-chaînes avec une dominante de uns.

| i | j | s[i..j] | Nombre de Zéros | Nombre de Uns |
|---|---|---------|----------------|--------------|
| 1 | 1 | 0       | 1              | 0            |
| 4 | 4 | 0       | 1              | 0            |
| 1 | 4 | 0110    | 2              | 2            |
| 0 | 4 | 10110   | 2              | 3            |
| 1 | 5 | 01101   | 2              | 3            |

Contraintes :

1 <= s.length <= 4 * 10^4
s consiste uniquement en caractères '0' et '1'.

On vous donne une chaîne binaire s.
Retournez le nombre de sous-chaînes ayant une dominante de uns.
Une chaîne a une dominante de uns si le nombre de uns dans la chaîne est supérieur ou égal au carré du nombre de zéros dans la chaîne.

Exemple 1 :

Entrée : s = "00011"
Sortie : 5
Explication :
Les sous-chaînes avec une dominante de uns sont montrées dans le tableau ci-dessous.

| i | j | s[i..j] | Nombre de Zéros | Nombre de Uns |
|---|---|---------|----------------|--------------|
| 3 | 3 | 1       | 0              | 1            |
| 4 | 4 | 1       | 0              | 1            |
| 2 | 3 | 01      | 1              | 1            |
| 3 | 4 | 11      | 0              | 2            |
| 2 | 4 | 011     | 1              | 2            |

Exemple 2 :

Entrée : s = "101101"
Sortie : 16
Explication :
Les sous-chaînes avec des uns non-dominants sont montrées dans le tableau ci-dessous.
Puisqu'il y a 21 sous-chaînes au total et que 5 d'entre elles ont des uns non-dominants, il en découle qu'il y a 16 sous-chaînes ayant une dominante de uns.

| i | j | s[i..j] | Nombre de Zéros | Nombre de Uns |
|---|---|---------|----------------|--------------|
| 1 | 1 | 0       | 1              | 0            |
| 4 | 4 | 0       | 1              | 0            |
| 1 | 4 | 0110    | 2              | 2            |
| 0 | 4 | 10110   | 2              | 3            |
| 1 | 5 | 01101   | 2              | 3            |

Contraintes :

1 <= s.length <= 4 * 10^4
s consiste uniquement en caractères '0' et '1'.


Vous avez deux entiers positifs xCorner et yCorner, et un tableau 2D circles, où circles[i] = [x_i, y_i, r_i] désigne un cercle avec centre en (x_i, y_i) et rayon r_i.
Il y a un rectangle dans le plan de coordonnées avec son coin inférieur gauche à l'origine et son coin supérieur droit aux coordonnées (xCorner, yCorner). Vous devez vérifier s'il existe un chemin du coin inférieur gauche au coin supérieur droit tel que l'intégralité du chemin se trouve à l'intérieur du rectangle, ne touche ni n'est à l'intérieur d'aucun cercle, et touche le rectangle uniquement aux deux coins.
Retournez true si un tel chemin existe, et false sinon.

Exemple 1 :

Entrée : xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Sortie : true
Explication :

La courbe noire montre un chemin possible entre (0, 0) et (3, 4).

Exemple 2 :

Entrée : xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Sortie : false
Explication :

Aucun chemin n'existe de (0, 0) à (3, 3).

Exemple 3 :

Entrée : xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Sortie : false
Explication :

Aucun chemin n'existe de (0, 0) à (3, 3).

Exemple 4 :

Entrée : xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Sortie : true
Explication :

Contraintes :

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

On vous donne deux entiers positifs xCorner et yCorner, et un tableau de cercles 2D, où circles[i] = [x_i, y_i, r_i] désigne un cercle de centre à (x_i, y_i) et de rayon r_i.
Il y a un rectangle dans le plan de coordonnées avec son coin inférieur gauche à l’origine et son coin supérieur droit à la coordonnée (xCorner, yCorner). Vous devez vérifier s’il existe un chemin entre le coin inférieur gauche et le coin supérieur droit, de sorte que le chemin entier se trouve à l’intérieur du rectangle, ne touche pas ou se trouve à l’intérieur d’un cercle et ne touche le rectangle qu’aux deux coins.
Renvoie true si un tel chemin existe, et false dans le cas contraire.

Exemple 1 :

Entrée : xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Sortie : true
Explication:

La courbe noire indique un chemin possible entre (0, 0) et (3, 4).

Exemple 2 :

Entrée : xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Sortie : false
Explication:

Il n’existe aucun chemin d’accès de (0, 0) à (3, 3).

Exemple 3 :

Entrée : xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Sortie : false
Explication:

Il n’existe aucun chemin d’accès de (0, 0) à (3, 3).

Exemple 4 :

Entrée : xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Sortie : true
Explication:

Contraintes:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].longueur == 3
1 <= x_i, y_i, r_i <= 10^9

Vous avez deux entiers positifs xCorner et yCorner, et un tableau 2D circles, où circles[i] = [x_i, y_i, r_i] désigne un cercle avec centre en (x_i, y_i) et rayon r_i.
On a un rectangle dans le plan de coordonnées dont le coin inférieur gauche se situe à l'origine et son coin supérieur droit aux coordonnées (xCorner, yCorner). Vous devez vérifier s'il existe un chemin du coin inférieur gauche au coin supérieur droit tel que l'intégralité du chemin se trouve à l'intérieur du rectangle, ne touche ni n'est à l'intérieur d'aucun cercle, et touche le rectangle uniquement aux deux coins.
Retournez true si un tel chemin existe, et false sinon.

Exemple 1 :

Entrée : xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Sortie : true
Explication :

La courbe noire montre un chemin possible entre (0, 0) et (3, 4).

Exemple 2 :

Entrée : xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Sortie : false
Explication :

Aucun chemin n'existe de (0, 0) à (3, 3).

Exemple 3 :

Entrée : xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Sortie : false
Explication :

Aucun chemin n'existe de (0, 0) à (3, 3).

Exemple 4 :

Entrée : xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Sortie : true
Explication :

Contraintes :

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9


On vous donne un entier n et un tableau 2D d'entiers queries.
Il y a n villes numérotées de 0 à n - 1. Initialement, il existe une route unidirectionnelle de la ville i à la ville i + 1 pour tous les 0 <= i < n - 1.
queries[i] = [u_i, v_i] représente l'ajout d'une nouvelle route unidirectionnelle de la ville u_i à la ville v_i. Après chaque requête, vous devez trouver la longueur du chemin le plus court de la ville 0 à la ville n - 1.
Retournez un tableau answer où, pour chaque i dans l'intervalle [0, queries.length - 1], answer[i] est la longueur du chemin le plus court de la ville 0 à la ville n - 1 après avoir traité les i + 1 premières requêtes.

Exemple 1:

Entrée: n = 5, queries = [[2,4],[0,2],[0,4]]
Sortie: [3,2,1]
Explication:

Après l'ajout de la route de 2 à 4, la longueur du chemin le plus court de 0 à 4 est 3.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court de 0 à 4 est 2.

Après l'ajout de la route de 0 à 4, la longueur du chemin le plus court de 0 à 4 est 1.

Exemple 2:

Entrée: n = 4, queries = [[0,3],[0,2]]
Sortie: [1,1]
Explication:

Après l'ajout de la route de 0 à 3, la longueur du chemin le plus court de 0 à 3 est 1.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court reste 1.

Contraintes:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Il n'y a pas de routes répétées parmi les requêtes.

On vous donne un entier n et un tableau d'entiers 2D querys.
Il y a n villes numérotées de 0 à n - 1. Au départ, il y a une route unidirectionnelle de la ville i à la ville i + 1 pour tout 0 <= i < n - 1.
queries[i] = [u_i, v_i] représente l'ajout d'une nouvelle route unidirectionnelle de la ville u_i à la ville v_i. Après chaque requête, vous devez trouver la longueur du chemin le plus court de la ville 0 à la ville n - 1.
Renvoyer un tableau de réponses où pour chaque i dans la plage [0, queries.length - 1], answer[i] est la longueur du chemin le plus court de la ville 0 à la ville n - 1 après le traitement des premières requêtes i + 1.

Exemple 1 :

Entrée : n = 5, queries = [[2,4],[0,2],[0,4]]
Sortie : [3,2,1]
Explication :

Après l'ajout de la route de 2 à 4, la longueur du chemin le plus court de 0 à 4 est de 3.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court de 0 à 4 est de 2.

Après l'ajout de la route de 0 à 4, la longueur du chemin le plus court de 0 à 4 est de 1.

Exemple 2 :

Entrée : n = 4, queries = [[0,3],[0,2]]
Sortie : [1,1]
Explication :

Après l'ajout de la route de 0 à 3, la longueur du chemin le plus court de 0 à 3 est de 1.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court reste 1.

Contraintes :

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Il n'y a pas de routes répétées parmi les requêtes.

On vous donne un entier n et un tableau d'entiers à deux dimensions queries.
Il y a n villes numérotées de 0 à n - 1. Initialement, il y a une route unidirectionnelle de la ville i à la ville i + 1 pour tout 0 <= i < n - 1.
queries[i] = [u_i, v_i] représente l'ajout d'une nouvelle route unidirectionnelle de la ville u_i à la ville v_i. Après chaque requête, vous devez trouver la longueur du chemin le plus court de la ville 0 à la ville n - 1.
Retournez un tableau answer où pour chaque i dans la plage [0, queries.length - 1], answer[i] est la longueur du chemin le plus court de la ville 0 à la ville n - 1 après avoir traité les i + 1 premières requêtes.

Exemple 1 :

Entrée : n = 5, queries = [[2,4],[0,2],[0,4]]
Sortie : [3,2,1]
Explication :

Après l'ajout de la route de 2 à 4, la longueur du chemin le plus court de 0 à 4 est 3.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court de 0 à 4 est 2.

Après l'ajout de la route de 0 à 4, la longueur du chemin le plus court de 0 à 4 est 1.

Exemple 2 :

Entrée : n = 4, queries = [[0,3],[0,2]]
Sortie : [1,1]
Explication :

Après l'ajout de la route de 0 à 3, la longueur du chemin le plus court de 0 à 3 est 1.

Après l'ajout de la route de 0 à 2, la longueur du chemin le plus court reste 1.

Contraintes :

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Il n'y a pas de routes répétées parmi les requêtes.


Il y a des tuiles rouges et bleues disposées en cercle. On vous donne un tableau d'entiers colors et un tableau d'entiers 2D queries.
La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Un groupe alterné est un sous-ensemble contigu de tuiles dans le cercle avec des couleurs alternées (chaque tuile dans le groupe, à l'exception de la première et de la dernière, a une couleur différente de ses tuiles adjacentes dans le groupe).
Vous devez traiter des requêtes de deux types :

queries[i] = [1, size_i], déterminer le nombre de groupes alternés de taille size_i.
queries[i] = [2, index_i, color_i], changer colors[index_i] en color_i.

Retournez un tableau answer contenant les résultats des requêtes du premier type dans l'ordre.
Notez que puisque colors représente un cercle, les première et dernière tuiles sont considérées comme étant adjacentes.

Exemple 1 :

Entrée : colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Sortie : [2]
Explication :

Première requête :
Changer colors[1] à 0.

Deuxième requête :
Nombre de groupes alternés de taille 4 :

Exemple 2 :

Entrée : colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Sortie : [2,0]
Explication :

Première requête :
Nombre de groupes alternés de taille 3 :

Deuxième requête : colors ne changera pas.
Troisième requête : Il n'y a pas de groupe alterné de taille 5.

Contraintes :

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 ou queries[i][0] == 2
Pour tous les i tels que :

queries[i][0] == 1 : queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2 : queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Il y a des tuiles rouges et bleues disposées en cercle. Vous recevez un tableau d'entiers colors et un tableau d'entiers 2D queries.
La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Un groupe alterné est un sous-ensemble contigu de tuiles dans le cercle avec des couleurs alternées (chaque tuile dans le groupe sauf la première et la dernière a une couleur différente de ses tuiles adjacentes dans le groupe).
Vous devez traiter des requêtes de deux types :

queries[i] = [1, size_i], déterminer le nombre de groupes alternés de taille size_i.
queries[i] = [2, index_i, color_i], changer colors[index_i] à color_i.

Renvoyez un tableau answer contenant les résultats des requêtes du premier type dans l'ordre.
Notez que puisque colors représente un cercle, les première et dernière tuiles sont considérées comme étant adjacentes.

Exemple 1 :

Entrée : colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Sortie : [2]
Explication :

Première requête :
Changer colors[1] à 0.

Deuxième requête :
Nombre de groupes alternés de taille 4 :

Exemple 2 :

Entrée : colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Sortie : [2,0]
Explication :

Première requête :
Nombre de groupes alternés de taille 3 :

Deuxième requête : colors ne changera pas.
Troisième requête : Il n'y a pas de groupe alterné de taille 5.

Contraintes :

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 ou queries[i][0] == 2
Pour tous les i tels que :

queries[i][0] == 1 : queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2 : queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Il y a des tuiles rouges et bleues disposées en cercle. On vous donne un tableau d'entiers colors et un tableau d'entiers 2D querys.
La couleur de la tuile i est représentée par colors[i] :

colors[i] == 0 signifie que la tuile i est rouge.
colors[i] == 1 signifie que la tuile i est bleue.

Un groupe alterné est un sous-ensemble contigu de tuiles dans le cercle avec des couleurs alternées (chaque tuile du groupe, à l'exception de la première et de la dernière, a une couleur différente de ses tuiles adjacentes dans le groupe).
Vous devez traiter des requêtes de deux types :

queries[i] = [1, size_i], déterminer le nombre de groupes alternés de taille size_i.
queries[i] = [2, index_i, color_i], changer colors[index_i] en color_i.

Renvoyer une réponse de tableau contenant les résultats des requêtes du premier type dans l'ordre.
Notez que comme les couleurs représentent un cercle, les première et dernière tuiles sont considérées comme étant côte à côte.

Exemple 1 :

Entrée : colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Sortie : [2]
Explication :

Première requête :
Changer colors[1] à 0.

Deuxième requête :
Nombre de groupes alternés de taille 4 :

Exemple 2 :

Entrée : colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Sortie : [2,0]
Explication :

Première requête :
Nombre de groupes alternés de taille 3 :

Deuxième requête : les couleurs ne changeront pas.
Troisième requête : il n'existe pas de groupe alterné de taille 5.

Contraintes :

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 ou queries[i][0] == 2
Pour tout i qui :

queries[i][0] == 1 : queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2 : queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1


Un serpent se trouve dans une grille matricielle de n x n et peut se déplacer dans quatre directions possibles. Chaque cellule de la grille est identifiée par sa position : grille[i][j] = (i * n) + j.
Le serpent commence à la cellule 0 et suit une séquence de commandes.
On vous donne un entier n représentant la taille de la grille et un tableau de chaînes de commandes où chaque commande[i] est soit "UP", "RIGHT", "DOWN", et "LEFT".  Il est garanti que le serpent restera à l'intérieur des limites de la grille tout au long de son mouvement.
Retourne la position de la cellule finale où le serpent se retrouve après avoir exécuté les commandes.

Exemple 1 :

Entrée : n = 2, commandes = ["RIGHT","DOWN"]
Sortie : 3
Explication :

0
1

2
3

0
1

2
3

0
1

2
3

Exemple 2 :

Entrée : n = 3, commandes = ["DOWN","RIGHT","UP"]
Sortie : 1
Explication :

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Contraintes :

2 <= n <= 10
1 <= commands.length <= 100
Les commandes consistent uniquement en"UP", "RIGHT", "DOWN", et "LEFT".
L'entrée est générée de manière à ce que le serpent ne se déplace pas en dehors des limites.

Il y a un serpent dans une grille matrice de n x n et peut se déplacer dans quatre directions possibles. Chaque cellule de la grille est identifiée par la position : grid[i][j] = (i * n) + j. Le serpent commence à la cellule 0 et suit une séquence de commandes. On vous donne un entier n représentant la taille de la grille et un tableau de chaînes de caractères commands où chaque command[i] est soit "UP", "RIGHT", "DOWN", soit "LEFT". Il est garanti que le serpent restera dans les limites de la grille tout au long de son mouvement. Retournez la position de la cellule finale où le serpent se termine après l'exécution des commandes.

Exemple 1 :

Entrée : n = 2, commands = ["RIGHT","DOWN"]
Sortie : 3
Explication :

0
1

2
3

0
1

2
3

0
1

2
3

Exemple 2 :

Entrée : n = 3, commands = ["DOWN","RIGHT","UP"]
Sortie : 1
Explication :

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Contraintes :

2 <= n <= 10
1 <= commands.length <= 100
commands consiste uniquement en "UP", "RIGHT", "DOWN", et "LEFT".
L'entrée est générée de sorte que le serpent ne sortira pas des limites.

Il y a un serpent dans une matrice de  taille n x n et il peut se déplacer dans quatre directions possibles. Chaque cellule de la grille est identifiée par la position : grid[i][j] = (i * n) + j.
Le serpent commence à la cellule 0 et suit une séquence de commandes.
On vous donne un entier n représentant la taille de la grille et un tableau de chaînes de caractères commands où chaque command[i] est soit "UP", "RIGHT", "DOWN", soit "LEFT". Il est garanti que le serpent restera dans les limites de la grille tout au long de son mouvement.
Retournez la position de la cellule finale où le serpent arrive après l'exécution des commandes.

Exemple 1 :

Entrée: n = 2, commands = ["RIGHT","DOWN"]
Sortie: 3
Explication :

0
1

2
3

0
1

2
3

0
1

2
3

Exemple 2 :

Entrée: n = 3, commands = ["DOWN","RIGHT","UP"]
Sortie: 1
Explication :

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Contraintes :

2 <= n <= 10
1 <= commands.length <= 100
commands consiste uniquement en "UP", "RIGHT", "DOWN", et "LEFT".
L'entrée est générée de sorte que le serpent ne sortira pas des limites.


On vous donne un tableau d'entiers positifs `nums` de longueur `n`.
Nous appelons une paire de tableaux d'entiers non-négatifs `(arr1, arr2)` monotone si :

Les longueurs des deux tableaux sont `n`.
`arr1` est monotone non-décroissant, en d'autres termes, `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`.
`arr2` est monotone non-croissant, en d'autres termes, `arr2[0] >= arr2[1] >= ... >= arr2[n - 1]`.
`arr1[i] + arr2[i] == nums[i]` pour tout `0 <= i <= n - 1`.

Renvoyez le nombre de paires monotones.
Puisque la réponse peut être très grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,3,2]
Sortie : 4
Explication :
Les bonnes paires sont :

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Exemple 2 :

Entrée : nums = [5,5,5,5]
Sortie : 126

Contraintes :

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

On vous donne un tableau d'entiers positifs nums de longueur n.
Nous appelons une paire de tableaux d'entiers non négatifs (arr1, arr2) monotone si :

Les longueurs des deux tableaux sont n.
arr1 est monotone et non décroissant, en d'autres termes, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 est monotone et non croissant, c'est-à-dire que arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] pour tout 0 <= i <= n - 1.

Retourne le nombre de paires monotones.
Comme la réponse peut être très grande, elle est retournée modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,3,2]
Sortie : 4
Explication :
Les bonnes paires sont :

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Exemple 2 :

Entrée : nums = [5,5,5,5]
Sortie : 126

Contraintes :

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

On donne un tableau d'entiers positifs nums de longueur n.
Une paire de tableaux d'entiers non-négatifs (arr1, arr2) est dite monotone si :

Les longueurs des deux tableaux sont égales à n.
arr1 est monotone non-décroissant, en d'autres termes, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 est monotone non-croissant, en d'autres termes, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] pour tout 0 <= i <= n - 1.

Retournez le nombre de paires monotones.
Puisque la réponse peut être très grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [2,3,2]
Sortie : 4
Explication :
Les bonnes paires sont :

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Exemple 2 :

Entrée : nums = [5,5,5,5]
Sortie : 126

Contraintes :

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


On vous donne une chaîne de caractères s.
Votre tâche consiste à supprimer tous les chiffres en effectuant cette opération de manière répétée :

Supprimez le premier chiffre et le caractère non numérique le plus proche à sa gauche.

Retournez la chaîne résultante après avoir supprimé tous les chiffres.

Exemple 1 :

Entrée : s = "abc"
Sortie : "abc"
Explication :
Il n'y a pas de chiffre dans la chaîne.

Exemple 2 :

Entrée : s = "cb34"
Sortie : ""
Explication :
Tout d'abord, nous appliquons l'opération sur s[2], et s devient "c4".
Ensuite, nous appliquons l'opération sur s[1], et s devient "".

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres minuscules anglaises et de chiffres.
L'entrée est générée de telle sorte qu'il est possible de supprimer tous les chiffres.

Vous avez une chaîne de caractères s.
Votre tâche est de retirer tous les chiffres en effectuant cette opération de manière répétée :

Supprimez le premier chiffre et le caractère non-chiffre le plus proche à sa gauche.

Retournez la chaîne résultante après avoir supprimé tous les chiffres.

Exemple 1 :

Entrée : s = "abc"
Sortie : "abc"
Explication :
Il n'y a aucun chiffre dans la chaîne.

Exemple 2 :

Entrée : s = "cb34"
Sortie : ""
Explication :
Tout d'abord, nous appliquons l'opération sur s[2], et s devient "c4".
Ensuite, nous appliquons l'opération sur s[1], et s devient "".

Contraintes :

1 <= s.length <= 100
s se compose uniquement de lettres minuscules anglaises et de chiffres.
L'entrée est générée de sorte qu'il est possible de supprimer tous les chiffres.


Une compétition se compose de n joueurs numérotés de 0 à n - 1.
On vous donne un tableau d'entiers skills de taille n et un entier positif k, où skills[i] est le niveau de compétence du joueur i. Tous les entiers de skills sont uniques.
Tous les joueurs se tiennent en file d'attente dans l'ordre du joueur 0 au joueur n - 1.
La compétition se déroule de la façon suivante :

Les deux premiers joueurs de la file jouent une partie, et le joueur avec le niveau de compétence le plus élevé gagne.
Après le jeu, le gagnant reste au début de la file, et le perdant va à la fin de celle-ci.

Le gagnant de la compétition est le premier joueur qui remporte k parties consécutives.
Retournez l'indice initial du joueur gagnant.

Exemple 1 :

Entrée : skills = [4,2,6,3,9], k = 2
Sortie : 2
Explication :
Initialement, la file des joueurs est [0,1,2,3,4]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent une partie, puisque la compétence du joueur 0 est plus élevée que celle du joueur 1, le joueur 0 gagne. La file résultante est [0,2,3,4,1].
Les joueurs 0 et 2 jouent une partie, puisque la compétence du joueur 2 est plus élevée que celle du joueur 0, le joueur 2 gagne. La file résultante est [2,3,4,1,0].
Les joueurs 2 et 3 jouent une partie, puisque la compétence du joueur 2 est plus élevée que celle du joueur 3, le joueur 2 gagne. La file résultante est [2,4,1,0,3].

Le joueur 2 a remporté k = 2 parties consécutives, donc le gagnant est le joueur 2.

Exemple 2 :

Entrée : skills = [2,5,4], k = 3
Sortie : 1
Explication :
Initialement, la file des joueurs est [0,1,2]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 0, le joueur 1 gagne. La file résultante est [1,2,0].
Les joueurs 1 et 2 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 2, le joueur 1 gagne. La file résultante est [1,0,2].
Les joueurs 1 et 0 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 0, le joueur 1 gagne. La file résultante est [1,2,0].

Le joueur 1 a remporté k = 3 parties consécutives, donc le gagnant est le joueur 1.

Contraintes :

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Tous les entiers de skills sont uniques.

Une compétition se compose de n joueurs numérotés de 0 à n - 1.
On vous donne un tableau d'entiers skills de taille n et un entier positif k, où skills[i] est le niveau de compétence du joueur i. Tous les entiers dans skills sont uniques.
Tous les joueurs sont placés dans une file d'attente dans l'ordre du joueur 0 au joueur n - 1.
Le processus de compétition est le suivant :

Les deux premiers joueurs de la file d'attente jouent une partie, et le joueur avec le niveau de compétence le plus élevé gagne.
Après la partie, le gagnant reste au début de la file d'attente, et le perdant va à la fin de celle-ci.

Le gagnant de la compétition est le premier joueur à gagner k parties d'affilée.
Renvoie l'index initial du joueur gagnant.

Exemple 1 :

Entrée : skills = [4,2,6,3,9], k = 2
Sortie : 2
Explication :
Au départ, la file d'attente des joueurs est [0,1,2,3,4]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent à une partie, puisque la compétence du joueur 0 est supérieure à celle du joueur 1, le joueur 0 gagne. La file d'attente résultante est [0,2,3,4,1].
Les joueurs 0 et 2 jouent à une partie, puisque la compétence du joueur 2 est supérieure à celle du joueur 0, le joueur 2 gagne. La file d'attente résultante est [2,3,4,1,0].
Les joueurs 2 et 3 jouent à une partie, puisque la compétence du joueur 2 est supérieure à celle du joueur 3, le joueur 2 gagne. La file d'attente résultante est [2,4,1,0,3].

Le joueur 2 a gagné k = 2 parties d'affilée, le gagnant est donc le joueur 2.

Exemple 2 :

Entrée : skills = [2,5,4], k = 3
Sortie : 1
Explication :
Au départ, la file d'attente des joueurs est [0,1,2]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent à une partie, puisque la compétence du joueur 1 est supérieure à celle du joueur 0, le joueur 1 gagne. La file d'attente résultante est [1,2,0].
Les joueurs 1 et 2 jouent à une partie, puisque la compétence du joueur 1 est supérieure à celle du joueur 2, le joueur 1 gagne. La file d'attente résultante est [1,0,2].
Les joueurs 1 et 0 jouent à une partie, puisque la compétence du joueur 1 est supérieure à celle du joueur 0, le joueur 1 gagne. La file d'attente résultante est [1,2,0].

Le joueur 1 a gagné k = 3 parties d'affilée, le gagnant est donc le joueur 1.

Contraintes :

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Tous les entiers dans skills sont uniques.

Une compétition se compose de n joueurs numérotés de 0 à n - 1. On vous donne un tableau d'entiers skills de taille n et un entier positif k, où skills[i] est le niveau de compétence du joueur i. Tous les entiers de skills sont uniques. Tous les joueurs se tiennent en file d'attente dans l'ordre du joueur 0 au joueur n - 1. Le processus de compétition est le suivant :

Les deux premiers joueurs de la file jouent une partie, et le joueur avec le niveau de compétence le plus élevé gagne. Après le jeu, le gagnant reste au début de la file, et le perdant va à la fin de celle-ci.

Le gagnant de la compétition est le premier joueur qui remporte k parties consécutives. Retournez l'indice initial du joueur gagnant.

Exemple 1 :

Entrée : skills = [4,2,6,3,9], k = 2
Sortie : 2
Explication :
Initialement, la file des joueurs est [0,1,2,3,4]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent une partie, puisque la compétence du joueur 0 est plus élevée que celle du joueur 1, le joueur 0 gagne. La file résultante est [0,2,3,4,1].
Les joueurs 0 et 2 jouent une partie, puisque la compétence du joueur 2 est plus élevée que celle du joueur 0, le joueur 2 gagne. La file résultante est [2,3,4,1,0].
Les joueurs 2 et 3 jouent une partie, puisque la compétence du joueur 2 est plus élevée que celle du joueur 3, le joueur 2 gagne. La file résultante est [2,4,1,0,3].

Le joueur 2 a remporté k = 2 parties consécutives, donc le gagnant est le joueur 2.

Exemple 2 :

Entrée : skills = [2,5,4], k = 3
Sortie : 1
Explication :
Initialement, la file des joueurs est [0,1,2]. Le processus suivant se produit :

Les joueurs 0 et 1 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 0, le joueur 1 gagne. La file résultante est [1,2,0].
Les joueurs 1 et 2 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 2, le joueur 1 gagne. La file résultante est [1,0,2].
Les joueurs 1 et 0 jouent une partie, puisque la compétence du joueur 1 est plus élevée que celle du joueur 0, le joueur 1 gagne. La file résultante est [1,2,0].

Le joueur 1 a remporté k = 3 parties consécutives, donc le gagnant est le joueur 1.

Contraintes :

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Tous les entiers de skills sont uniques.


On vous donne un tableau d'entiers nums et un entier non négatif k. Une séquence d'entiers seq est dite bonne s'il y a au plus k indices i dans la plage [0, seq.length - 2] tels que seq[i] != seq[i + 1].
Retournez la longueur maximale possible d'une bonne sous-séquence de nums.

Exemple 1 :

Entrée : nums = [1,2,1,1,3], k = 2
Sortie : 4
Explication :
La sous-séquence de longueur maximale est [1,2,1,1,3].

Exemple 2 :

Entrée : nums = [1,2,3,4,5,1], k = 0
Sortie : 2
Explication :
La sous-séquence de longueur maximale est [1,2,3,4,5,1].

Contraintes :

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

On vous donne un tableau d'entiers nums et un entier non négatif k. Une séquence de seq entiers est appelée bonne s'il y a au plus k indices i dans la plage [0, seq.length - 2] tel que seq [i]! = Seq [i + 1].
Renvoyez la longueur maximale possible d'une bonne sous-séquence de nums.

Exemple 1:

Entrée: nums = [1,2,1,1,3], k = 2
Sortie: 4
Explication:
La sous-séquence de longueur maximale est [1,2,1,1,3].

Exemple 2:

Entrée: nums = [1,2,3,4,5,1], k = 0
Sortie: 2
Explication:
La sous-séquence de longueur maximale est [1,2,3,4,5,1].

Contraintes:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


On vous donne un tableau d'entiers nums. En une seule opération, vous pouvez ajouter ou soustraire 1 à n'importe quel élément de nums.
Retournez le nombre minimum d'opérations pour rendre tous les éléments de nums divisibles par 3.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 3
Explication :
Tous les éléments du tableau peuvent être rendus divisibles par 3 à l'aide de 3 opérations :

Soustraire 1 de 1.
Ajouter 1 à 2.
Soustraire 1 à 4.

Exemple 2 :

Entrée : nums = [3,6,9]
Sortie : 0

Contraintes :

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

On vous donne un tableau d'entiers nums. En une opération, vous pouvez ajouter ou soustraire 1 à n'importe quel élément de nums.
Renvoyez le nombre minimal d'opérations pour rendre tous les éléments de nums divisibles par 3.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 3
Explication :
Tous les éléments du tableau peuvent être rendus divisibles par 3 en utilisant 3 opérations :

Soustraire 1 à 1.
Ajouter 1 à 2.
Soustraire 1 à 4.

Exemple 2 :

Entrée : nums = [3,6,9]
Sortie : 0

Contraintes :

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

On vous donne un tableau d'entiers nums. En une opération, vous pouvez ajouter ou soustraire 1 à n'importe quel élément de nums.
Retournez le nombre minimal d'opérations pour rendre tous les éléments de nums divisibles par 3.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 3
Explication :
Tous les éléments du tableau peuvent être rendus divisibles par 3 en utilisant 3 opérations :

Soustraire 1 à 1.
Ajouter 1 à 2.
Soustraire 1 à 4.

Exemple 2 :

Entrée : nums = [3,6,9]
Sortie : 0

Contraintes :

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