On vous donne une chaîne binaire s indexée à partir de 0 et ayant une longueur paire.
Une chaîne est dite belle s'il est possible de la partitionner en une ou plusieurs sous-chaînes telles que :

Chaque sous-chaîne a une longueur paire.
Chaque sous-chaîne contient uniquement des 1 ou uniquement des 0.

Vous pouvez changer n'importe quel caractère de s en 0 ou en 1.
Retournez le nombre minimum de changements nécessaires pour que la chaîne s devienne belle.

Exemple 1 :

Entrée : s = "1001"
Sortie : 2
Explication : Nous changeons s[1] en 1 et s[3] en 0 pour obtenir la chaîne "1100".
On peut voir que la chaîne "1100" est belle car nous pouvons la partitionner en "11|00".
Il peut être prouvé que 2 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 2 :

Entrée : s = "10"
Sortie : 1
Explication : Nous changeons s[1] en 1 pour obtenir la chaîne "11".
On peut voir que la chaîne "11" est belle car nous pouvons la partitionner en "11".
Il peut être prouvé que 1 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 3 :

Entrée : s = "0000"
Sortie : 0
Explication : Nous n'avons pas besoin de faire de changements car la chaîne "0000" est déjà belle.

Contraintes :

- 2 <= s.length <= 10^5
- s a une longueur paire.
- s[i] est soit '0' soit '1'.

On vous donne une chaîne binaire `s` indexée à partir de 0 et ayant une longueur paire.
Une chaîne est belle s'il est possible de la partitionner en une ou plusieurs sous-chaînes telles que :

- Chaque sous-chaîne a une longueur paire.
- Chaque sous-chaîne contient uniquement des 1 ou uniquement des 0.

Vous pouvez changer n'importe quel caractère de `s` en 0 ou en 1.
Renvoyez le nombre minimum de changements nécessaires pour rendre la chaîne `s` belle.

Exemple 1 :

Entrée : `s = "1001"`
Sortie : `2`
Explication : Nous changeons `s[1]` en 1 et `s[3]` en 0 pour obtenir la chaîne "1100".
Il peut être vu que la chaîne "1100" est belle car nous pouvons la partitionner en "11|00".
Il peut être prouvé que 2 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 2 :

Entrée : `s = "10"`
Sortie : `1`
Explication : Nous changeons `s[1]` en 1 pour obtenir la chaîne "11".
Il peut être vu que la chaîne "11" est belle car nous pouvons la partitionner en "11".
Il peut être prouvé que 1 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 3 :

Entrée : `s = "0000"`
Sortie : `0`
Explication : Nous n'avons pas besoin de faire de changements car la chaîne "0000" est déjà belle.

Contraintes :

- 2 <= s.length <= 10^5
- s a une longueur paire.
- s[i] est soit '0' soit '1'.

On vous donne une chaîne binaire `s` indexée à partir de 0 et ayant une longueur paire.
Une chaîne est belle s'il est possible de la partitionner en une ou plusieurs sous-chaînes telles que :

- Chaque sous-chaîne a une longueur paire.
- Chaque sous-chaîne contient uniquement des 1 ou uniquement des 0.

Vous pouvez changer n'importe quel caractère de `s` en 0 ou en 1.
Retournez le nombre minimum de changements nécessaires pour rendre la chaîne `s` belle.

Exemple 1 :

Entrée : `s = "1001"`
Sortie : `2`
Explication : Nous changeons `s[1]` en 1 et `s[3]` en 0 pour obtenir la chaîne "1100".
Il peut être vu que la chaîne "1100" est belle car nous pouvons la partitionner en "11|00".
Il peut être prouvé que 2 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 2 :

Entrée : `s = "10"`
Sortie : `1`
Explication : Nous changeons `s[1]` en 1 pour obtenir la chaîne "11".
Il peut être vu que la chaîne "11" est belle car nous pouvons la partitionner en "11".
Il peut être prouvé que 1 est le nombre minimal de changements nécessaires pour rendre la chaîne belle.

Exemple 3 :

Entrée : `s = "0000"`
Sortie : `0`
Explication : Nous n'avons pas besoin de faire de changements car la chaîne "0000" est déjà belle.

Contraintes :

- 2 <= s.length <= 10^5
- s a une longueur paire.
- s[i] est soit '0' soit '1'.


On vous donne un tableau d'entiers nums indexé à partir de 0.
Un triplet d'indices (i, j, k) est une montagne si :

i < j < k
nums[i] < nums[j] et nums[k] < nums[j]

Retournez la somme minimale possible d'un triplet montagne de nums. Si aucun triplet de ce type n'existe, retournez -1.

Exemple 1 :

Entrée : nums = [8,6,1,5,3]
Sortie : 9
Explication : Le triplet (2, 3, 4) est un triplet montagne de somme 9 puisque :
- 2 < 3 < 4
- nums[2] < nums[3] et nums[4] < nums[3]
Et la somme de ce triplet est nums[2] + nums[3] + nums[4] = 9. Il peut être démontré qu'il n'existe pas de triplets montagne avec une somme inférieure à 9.

Exemple 2 :

Entrée : nums = [5,4,8,7,10,2]
Sortie : 13
Explication : Le triplet (1, 3, 5) est un triplet montagne de somme 13 car:
- 1 < 3 < 5
- nums[1] < nums[3] et nums[5] < nums[3]
Et la somme de ce triplet est nums[1] + nums[3] + nums[5] = 13. Il peut être démontré qu'il n'existe pas de triplets montagne avec une somme inférieure à 13.

Exemple 3 :

Entrée : nums = [6,5,4,3,4,5]
Sortie : -1
Explication : Il peut être démontré qu'il n'existe pas de triplets montagne dans nums.

Contraintes :

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

On vous donne un tableau indexé 0 nums entiers.
Un triplet d’indices (i, j, k) est une montagne si :

i < j < k
nums[i] < nums[j] et nums[k] < nums[j]

Renvoie la somme minimale possible d’un triplet montagne de nums. Si aucun triplet de ce type n’existe, renvoyez -1.

Exemple 1 :

Entrée : nums = [8,6,1,5,3]
Sortie : 9
Explication : Le triplet (2, 3, 4) est un triplet montagne de somme 9 puisque :
- 2 < 3 < 4
- nums[2] < nums[3] et nums[4] < nums[3]
Et la somme de ce triplet est nums[2] + nums[3] + nums[4] = 9. On peut montrer qu’il n’y a pas de triplets de montagne dont la somme est inférieure à 9.

Exemple 2 :

Entrée : nums = [5,4,8,7,10,2]
Sortie : 13
Explication : Le triplet (1, 3, 5) est un triplet montagne de somme 13 puisque :
- 1 < 3 < 5
- nums[1] < nums[3] et nums[5] < nums[3]
Et la somme de ce triplet est nums[1] + nums[3] + nums[5] = 13. On peut montrer qu’il n’y a pas de triplets de montagne dont la somme est inférieure à 13.

Exemple 3 :

Entrée : nums = [6,5,4,3,4,5]
Sortie : -1
Explication : On peut montrer qu’il n’y a pas de triplets de montagne dans les nums.

Contraintes:

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

Vous avez un tableau d'entiers nums indexé à partir de 0.
Un triplet d'indices (i, j, k) est une montagne si :

i < j < k
nums[i] < nums[j] et nums[k] < nums[j]

Retournez la somme minimale possible d'un triplet montagne de nums. Si aucun triplet de ce type n'existe, retournez -1.

Exemple 1 :

Entrée : nums = [8,6,1,5,3]
Sortie : 9
Explication : Le triplet (2, 3, 4) est un triplet montagne de somme 9 puisque :
- 2 < 3 < 4
- nums[2] < nums[3] et nums[4] < nums[3]
Et la somme de ce triplet est nums[2] + nums[3] + nums[4] = 9. Il peut être démontré qu'il n'existe pas de triplets montagne avec une somme inférieure à 9.

Exemple 2 :

Entrée : nums = [5,4,8,7,10,2]
Sortie : 13
Explication : Le triplet (1, 3, 5) est un triplet montagne de somme 13 puisque :
- 1 < 3 < 5
- nums[1] < nums[3] et nums[5] < nums[3]
Et la somme de ce triplet est nums[1] + nums[3] + nums[5] = 13. Il peut être démontré qu'il n'existe pas de triplets montagne avec une somme inférieure à 13.

Exemple 3 :

Entrée : nums = [6,5,4,3,4,5]
Sortie : -1
Explication : Il peut être démontré qu'il n'existe pas de triplets montagne dans nums.

Contraintes :

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


Vous avez un tableau d'entiers nums indexé à partir de 0 et un entier k.
Le K-or de nums est un entier non négatif qui satisfait les conditions suivantes :

Le i^ème bit est activé dans le K-or si et seulement s'il y a au moins k éléments de nums dans lesquels le bit i est activé.

Retournez le K-or de nums.
Notez qu'un bit i est activé dans x si (2^i ET x) == 2^i, où AND est l'opérateur AND bit à bit.

Exemple 1 :

Entrée : nums = [7,12,9,8,9,15], k = 4
Sortie : 9
Explication : Le bit 0 est activé dans nums[0], nums[2], nums[4], et nums[5].
Le bit 1 est activé dans nums[0], et nums[5].
Le bit 2 est activé dans nums[0], nums[1], et nums[5].
Le bit 3 est activé dans nums[1], nums[2], nums[3], nums[4], et nums[5].
Seuls les bits 0 et 3 sont activés dans au moins k éléments du tableau, et les bits i >= 4 ne sont pas activés dans aucun des éléments du tableau. Par conséquent, la réponse est 2^0 + 2^3 = 9.

Exemple 2 :

Entrée : nums = [2,12,1,11,4,5], k = 6
Sortie : 0
Explication : Puisque k == 6 == nums.length, le 6-or du tableau est égal au AND bit à bit de tous ses éléments. Par conséquent, la réponse est 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Exemple 3 :

Entrée : nums = [10,8,5,9,11,6,8], k = 1
Sortie : 15
Explication : Puisque k == 1, le 1-or du tableau est égal au OR bit à bit de tous ses éléments. Par conséquent, la réponse est 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Vous avez un tableau de nombres entiers à indices 0 et un entier k.
Le K-or de nombres est un entier non négatif qui satisfait les conditions suivantes :

Le i^ème bit est activé dans le K-or si et seulement s'il y a au moins k éléments de nombres dans lesquels le bit i est activé.

Retournez le K-or de nombres.
Notez qu'un bit i est activé dans x si (2^i ET x) == 2^i, où ET est l'opérateur AND bit à bit.

Exemple 1 :

Entrée : nums = [7,12,9,8,9,15], k = 4
Sortie : 9
Explication : Le bit 0 est activé dans nums[0], nums[2], nums[4], et nums[5].
Le bit 1 est activé dans nums[0], et nums[5].
Le bit 2 est activé dans nums[0], nums[1], et nums[5].
Le bit 3 est activé dans nums[1], nums[2], nums[3], nums[4], et nums[5].
Seuls les bits 0 et 3 sont activés dans au moins k éléments du tableau, et les bits i >= 4 ne sont pas activés dans aucun des éléments du tableau. Par conséquent, la réponse est 2^0 + 2^3 = 9.

Exemple 2 :

Entrée : nums = [2,12,1,11,4,5], k = 6
Sortie : 0
Explication : Puisque k == 6 == nums.length, le 6-or du tableau est égal à l'AND bit à bit de tous ses éléments. Par conséquent, la réponse est 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Exemple 3 :

Entrée : nums = [10,8,5,9,11,6,8], k = 1
Sortie : 15
Explication : Puisque k == 1, le 1-or du tableau est égal à l'OR bit à bit de tous ses éléments. Par conséquent, la réponse est 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

On vous donne un tableau d'entiers indexés 0, nums, et un entier k.
Le K-or de nums est un entier non négatif qui satisfait à la condition suivante :

Le i^e bit est positionné dans le K-or si et seulement s'il y a au moins k éléments de nums dans lesquels le bit i est positionné.

Retourner le K-or de nums.
Notez qu'un bit i est positionné dans x si (2^i AND x) == 2^i, où AND est l'opérateur bitwise AND.

Exemple 1 :

Entrée : nums = [7,12,9,8,9,15], k = 4
Sortie : 9
Explication : Le bit 0 est défini sur nums[0], nums[2], nums[4] et nums[5].
Le bit 1 est positionné sur nums[0], et nums[5].
Le bit 2 est positionné sur nums[0], nums[1] et nums[5].
Le bit 3 est défini sur nums[1], nums[2], nums[3], nums[4] et nums[5].
Seuls les bits 0 et 3 sont définis dans au moins k éléments du tableau, et les bits i >= 4 ne sont définis dans aucun des éléments du tableau. La réponse est donc 2^0 + 2^3 = 9.

Exemple 2 :

Entrée : nums = [2,12,1,11,4,5], k = 6
Sortie : 0
Explication : Puisque k == 6 == nums.length, le 6-or du tableau est égal au bitwise AND de tous ses éléments. La réponse est donc 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Exemple 3 :

Entrée : nums = [10,8,5,9,11,6,8], k = 1
Sortie : 15
Explication : Puisque k == 1, le 1-or du tableau est égal au bitwise OR de tous ses éléments. La réponse est donc 10 OU 8 OU 5 OU 9 OU 11 OU 6 OU 8 = 15.

Contraintes :

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length


On vous donne un tableau d'entiers indexés à partir de zéro, nums.
Une sous-séquence de nums de longueur k et composée d'indices i_0 < i_1 < ... < i_k-1 est équilibrée si la condition suivante est vérifiée :

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pour chaque j dans la gamme [1, k - 1].

Une sous-séquence de nums de longueur 1 est considérée comme équilibrée.
Retournez un entier représentant la somme maximale possible des éléments dans une sous-séquence équilibrée de nums.
Une sous-séquence d'un tableau est un nouveau tableau non vide formé à partir du tableau original en supprimant certains (éventuellement aucun) des éléments sans perturber les positions relatives des éléments restants.

Exemple 1 :

Entrée : nums = [3,3,5,6]
Sortie : 14
Explication : dans cet exemple, la sous-séquence [3,5,6] composée des indices 0, 2 et 3 peut être sélectionnée.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Ainsi, c'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.
La sous-séquence composée des indices 1, 2 et 3 est également valide.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 14.
Exemple 2 :

Entrée : nums = [5,-1,-3,8]
Sortie : 13
Explication : dans cet exemple, la sous-séquence [5,8] composée des indices 0 et 3 peut être sélectionnée.
nums[3] - nums[0] >= 3 - 0.
Ainsi, c'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 13.

Exemple 3 :

Entrée : nums = [-2,-1]
Sortie : -1
Explication : dans cet exemple, la sous-séquence [-1] peut être sélectionnée.
C'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de zéro.
Une sous-séquence de nums de longueur k et composée d'indices i_0 < i_1 < ... < i_k-1 est équilibrée si la condition suivante est vérifiée :

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pour chaque j dans la gamme [1, k - 1].

Une sous-séquence de nums de longueur 1 est considérée comme équilibrée.
Retournez un entier représentant la somme maximale possible des éléments dans une sous-séquence équilibrée de nums.
Une sous-séquence d'un tableau est un nouveau tableau non vide formé à partir du tableau original en supprimant certains (éventuellement aucun) des éléments sans perturber les positions relatives des éléments restants.

Exemple 1 :

Entrée : nums = [3,3,5,6]
Sortie : 14
Explication : Dans cet exemple, la sous-séquence [3,5,6] composée des indices 0, 2 et 3 peut être sélectionnée.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Ainsi, c'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.
La sous-séquence composée des indices 1, 2 et 3 est également valide.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 14.
Exemple 2 :

Entrée : nums = [5,-1,-3,8]
Sortie : 13
Explication : Dans cet exemple, la sous-séquence [5,8] composée des indices 0 et 3 peut être sélectionnée.
nums[3] - nums[0] >= 3 - 0.
Ainsi, c'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 13.

Exemple 3 :

Entrée : nums = [-2,-1]
Sortie : -1
Explication : Dans cet exemple, la sous-séquence [-1] peut être sélectionnée.
C'est une sous-séquence équilibrée, et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.

Contraintes :

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

On vous donne un tableau d'entiers indexé 0 nums.
Une sous-séquence de nums de longueur k et composée d'indices i_0 < i_1 < ... < i_k-1 est équilibrée si les conditions suivantes sont remplies :

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pour chaque j dans la plage [1, k - 1].

Une sous-séquence de nums de longueur 1 est considérée comme équilibrée.
Renvoie un entier indiquant la somme maximale possible d'éléments dans une sous-séquence équilibrée de nums.
Une sous-séquence d'un tableau est un nouveau tableau non vide formé à partir du tableau d'origine en supprimant certains (éventuellement aucun) des éléments sans perturber les positions relatives des éléments restants.

Exemple 1 :

Entrée : nums = [3,3,5,6]
Sortie : 14
Explication : Dans cet exemple, la sous-séquence [3,5,6] composée des indices 0, 2 et 3 peut être sélectionnée.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Il s'agit donc d'une sous-séquence équilibrée et sa somme est le maximum parmi les sous-séquences équilibrées de nums.
La sous-séquence composée des indices 1, 2 et 3 est également valide.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 14.
Exemple 2 :

Entrée : nums = [5,-1,-3,8]
Sortie : 13
Explication : Dans cet exemple, la sous-séquence [5,8] composée des indices 0 et 3 peut être sélectionnée.
nums[3] - nums[0] >= 3 - 0.
Il s'agit donc d'une sous-séquence équilibrée et sa somme est la plus élevée parmi les sous-séquences équilibrées de nums.
Il peut être démontré qu'il n'est pas possible d'obtenir une sous-séquence équilibrée avec une somme supérieure à 13.

Exemple 3 :

Entrée : nums = [-2,-1]
Sortie : -1
Explication : Dans cet exemple, la sous-séquence [-1] peut être sélectionnée.
Il s'agit d'une sous-séquence équilibrée, et sa somme est le maximum parmi les sous-séquences équilibrées de nums.

Contraintes :

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


Il y a n équipes numérotées de 0 à n - 1 dans un tournoi.
Etant donné une matrice booléenne 2D indexée 0 de taille n * n. Pour tous les i, j que 0 <= i, j <= n - 1 et i != j, l'équipe i est plus forte que l'équipe j si grid[i][j] == 1, sinon, l'équipe j est plus forte que l'équipe i.
L'équipe a sera championne du tournoi si aucune équipe b n'est plus forte que l'équipe a.
Retourne l'équipe qui sera championne du tournoi.

Exemple 1 :

Entrée : grid = [[0,1],[0,0]]
Sortie : 0
Explication : Il y a deux équipes dans ce tournoi.
grid[0][1] == 1 signifie que l'équipe 0 est plus forte que l'équipe 1. L'équipe 0 sera donc championne.

Exemple 2 :

Entrée : grid = [[0,0,1],[1,0,1],[0,0,0]]
Sortie : 1
Explication : Il y a trois équipes dans ce tournoi.
grid[1][0] == 1 signifie que l'équipe 1 est plus forte que l'équipe 0.
grid[1][2] == 1 signifie que l'équipe 1 est plus forte que l'équipe 2.
L'équipe 1 sera donc championne.

Contraintes :

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] est soit 0, soit 1.
Pour tout i, grid[i][i] est 0.
Pour tout i, j que i != j, grid[i][j] != grid[j][i].
L'entrée est générée de telle sorte que si l'équipe a est plus forte que l'équipe b et que l'équipe b est plus forte que l'équipe c, alors l'équipe a est plus forte que l'équipe c.

Il y a n équipes numérotées de 0 à n - 1 dans un tournoi.
Étant donné une matrice booléenne 2D `grid` de taille n * n indexée à 0. Pour tous i, j où 0 <= i, j <= n - 1 et i != j, l'équipe i est plus forte que l'équipe j si `grid[i][j] == 1`, sinon, l'équipe j est plus forte que l'équipe i.
L'équipe a sera la championne du tournoi s'il n'existe aucune équipe b plus forte que l'équipe a.
Retourner l'équipe qui sera la championne du tournoi.

Exemple 1 :

Entrée : `grid = [[0,1],[0,0]]`
Sortie : 0
Explication : Il y a deux équipes dans ce tournoi.
`grid[0][1] == 1` signifie que l'équipe 0 est plus forte que l'équipe 1. Donc l'équipe 0 sera la championne.

Exemple 2 :

Entrée : `grid = [[0,0,1],[1,0,1],[0,0,0]]`
Sortie : 1
Explication : Il y a trois équipes dans ce tournoi.
`grid[1][0] == 1` signifie que l'équipe 1 est plus forte que l'équipe 0.
`grid[1][2] == 1` signifie que l'équipe 1 est plus forte que l'équipe 2.
Donc l'équipe 1 sera la championne.

Contraintes :

n == `grid.length`
n == `grid[i].length`
2 <= n <= 100
`grid[i][j]` est soit 0 soit 1.
Pour tout i `grid[i][i]` est 0.
Pour tous i, j où i != j, `grid[i][j] != grid[j][i]`.
L'entrée est générée de telle sorte que si l'équipe a est plus forte que l'équipe b et que l'équipe b est plus forte que l'équipe c, alors l'équipe a est plus forte que l'équipe c.

On a n équipes numérotées de 0 à n - 1 dans un tournoi.
Soit une matrice booléenne 2D grid de taille n * n indexée à 0. Pour tous i, j où 0 <= i, j <= n - 1 et i != j, l'équipe i est plus forte que l'équipe j si grid[i][j] == 1, sinon, l'équipe j est plus forte que l'équipe i.
L'équipe a sera la championne du tournoi s'il n'existe aucune équipe b plus forte que l'équipe a.
Retourner l'équipe qui sera la championne du tournoi.

Exemple 1 :

Entrée : grid = [[0,1],[0,0]]
Sortie : 0
Explication : Il y a deux équipes dans ce tournoi.
grid[0][1] == 1 signifie que l'équipe 0 est plus forte que l'équipe 1. Donc l'équipe 0 sera la championne.

Exemple 2 :

Entrée : grid = [[0,0,1],[1,0,1],[0,0,0]]
Sortie : 1
Explication : Il y a trois équipes dans ce tournoi.
grid[1][0] == 1 signifie que l'équipe 1 est plus forte que l'équipe 0.
grid[1][2] == 1 signifie que l'équipe 1 est plus forte que l'équipe 2.
Donc l'équipe 1 sera la championne.

Contraintes :

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] est soit 0 soit 1.
Pour tout i grid[i][i] est 0.
Pour tous i, j où i != j, grid[i][j] != grid[j][i].
L'entrée est générée de telle sorte que si l'équipe a est plus forte que l'équipe b et que l'équipe b est plus forte que l'équipe c, alors l'équipe a est plus forte que l'équipe c.


On vous donne deux tableaux d’entiers indexés 0, nums1 et nums2, tous deux de longueur n.
Vous êtes autorisé à effectuer une série d’opérations (éventuellement aucune).
Au cours d’une opération, vous sélectionnez un index i dans l’intervalle [0, n - 1] et permutez les valeurs de nums1[i] et nums2[i].
Votre tâche consiste à trouver le nombre minimum d’opérations requis pour satisfaire aux conditions suivantes :

nums1[n - 1] est égal à la valeur maximale parmi tous les éléments de nums1, c’est-à-dire nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] est égal à la valeur maximale parmi tous les éléments de nums2, c’est-à-dire nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Renvoie un entier indiquant le nombre minimum d’opérations nécessaires pour remplir les deux conditions, ou -1 s’il est impossible de satisfaire les deux conditions.

Exemple 1 :

Entrée : nums1 = [1,2,7], nums2 = [4,5,3]
Sortie : 1
Explication : Dans cet exemple, une opération peut être effectuée à l’aide de l’indice i = 2.
Lorsque nums1[2] et nums2[2] sont échangés, nums1 devient [1,2,3] et nums2 devient [4,5,7].
Les deux conditions sont maintenant remplies.
On peut montrer que le nombre minimum d’opérations à effectuer est de 1.
Donc, la réponse est 1.

Exemple 2 :

Entrée : nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Sortie : 2
Explication : Dans cet exemple, les opérations suivantes peuvent être effectuées :
Première opération à l’aide de l’indice i = 4.
Lorsque nums1[4] et nums2[4] sont échangés, nums1 devient [2,3,4,5,4] et nums2 devient [8,8,4,4,9].
Une autre opération utilisant l’indice i = 3.
Lorsque nums1[3] et nums2[3] sont échangés, nums1 devient [2,3,4,4,4], et nums2 devient [8,8,4,5,9].
Les deux conditions sont maintenant remplies.
On peut montrer que le nombre minimum d’opérations à effectuer est de 2.
Donc, la réponse est 2.

Exemple 3 :

Entrée : nums1 = [1,5,4], nums2 = [2,5,3]
Sortie : -1
Explication : Dans cet exemple, il n’est pas possible de satisfaire aux deux conditions.
Donc, la réponse est -1.

Contraintes:

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

On vous deux tableaux d'entiers indexés à partir de 0, nums1 et nums2, tous deux de longueur n.
Vous êtes autorisé à effectuer une série d'opérations (possiblement aucune).
Lors d'une opération, vous sélectionnez un indice i dans l'intervalle [0, n - 1] et échangez les valeurs de nums1[i] et nums2[i].
Votre tâche est de trouver le nombre minimum d'opérations nécessaires pour satisfaire les conditions suivantes :

nums1[n - 1] est égal à la valeur maximale parmi tous les éléments de nums1, c'est-à-dire, nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] est égal à la valeur maximale parmi tous les éléments de nums2, c'est-à-dire, nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Retournez un entier représentant le nombre minimum d'opérations nécessaires pour satisfaire les deux conditions, ou -1 s'il est impossible de satisfaire les deux conditions.

Exemple 1 :

Entrée : nums1 = [1,2,7], nums2 = [4,5,3]
Sortie : 1
Explication : Dans cet exemple, une opération peut être effectuée en utilisant l'indice i = 2.
Lorsque nums1[2] et nums2[2] sont échangés, nums1 devient [1,2,3] et nums2 devient [4,5,7].
Les deux conditions sont maintenant satisfaites.
On peut montrer que le nombre minimum d'opérations à effectuer est 1.
Donc, la réponse est 1.

Exemple 2 :

Entrée : nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Sortie : 2
Explication : Dans cet exemple, les opérations suivantes peuvent être effectuées :
Première opération en utilisant l'indice i = 4.
Lorsque nums1[4] et nums2[4] sont échangés, nums1 devient [2,3,4,5,4], et nums2 devient [8,8,4,4,9].
Une autre opération en utilisant l'indice i = 3.
Lorsque nums1[3] et nums2[3] sont échangés, nums1 devient [2,3,4,4,4], et nums2 devient [8,8,4,5,9].
Les deux conditions sont maintenant satisfaites.
On peut montrer que le nombre minimum d'opérations à effectuer est 2.
Donc, la réponse est 2.

Exemple 3 :

Entrée : nums1 = [1,5,4], nums2 = [2,5,3]
Sortie : -1
Explication : Dans cet exemple, il n'est pas possible de satisfaire les deux conditions.
Donc, la réponse est -1.

Contraintes :

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

Vous avez deux tableaux d'entiers de 0-indexés, nums1 et nums2, tous deux de longueur n.
Vous êtes autorisé à effectuer une série d'opérations (peut-être aucune).
Lors d'une opération, vous sélectionnez un indice i dans l'intervalle [0, n - 1] et échangez les valeurs de nums1[i] et nums2[i].
Votre tâche est de trouver le nombre minimum d'opérations nécessaires pour satisfaire les conditions suivantes :

nums1[n - 1] est égal à la valeur maximale parmi tous les éléments de nums1, c'est-à-dire, nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] est égal à la valeur maximale parmi tous les éléments de nums2, c'est-à-dire, nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Retournez un entier représentant le nombre minimum d'opérations nécessaires pour satisfaire les deux conditions, ou -1 s'il est impossible de satisfaire les deux conditions.

Exemple 1 :

Entrée : nums1 = [1,2,7], nums2 = [4,5,3]
Sortie : 1
Explication : Dans cet exemple, une opération peut être effectuée en utilisant l'indice i = 2.
Lorsque nums1[2] et nums2[2] sont échangés, nums1 devient [1,2,3] et nums2 devient [4,5,7].
Les deux conditions sont maintenant satisfaites.
On peut montrer que le nombre minimum d'opérations à effectuer est 1.
Donc, la réponse est 1.

Exemple 2 :

Entrée : nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Sortie : 2
Explication : Dans cet exemple, les opérations suivantes peuvent être effectuées :
Première opération en utilisant l'indice i = 4.
Lorsque nums1[4] et nums2[4] sont échangés, nums1 devient [2,3,4,5,4], et nums2 devient [8,8,4,4,9].
Une autre opération en utilisant l'indice i = 3.
Lorsque nums1[3] et nums2[3] sont échangés, nums1 devient [2,3,4,4,4], et nums2 devient [8,8,4,5,9].
Les deux conditions sont maintenant satisfaites.
On peut montrer que le nombre minimum d'opérations à effectuer est 2.
Donc, la réponse est 2.

Exemple 3 :

Entrée : nums1 = [1,5,4], nums2 = [2,5,3]
Sortie : -1
Explication : Dans cet exemple, il n'est pas possible de satisfaire les deux conditions.
Donc, la réponse est -1.

Contraintes :

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


Étant donné trois entiers a, b et n, retournez la valeur maximale de (a XOR x) * (b XOR x) où 0 <= x < 2^n.
Comme la réponse peut être trop grande, retournez-la modulo 10^9 + 7.
Notez que XOR est l'opération XOR au niveau des bits.

Exemple 1 :

Entrée : a = 12, b = 5, n = 4
Sortie : 98
Explication : Pour x = 2, (a XOR x) = 14 et (b XOR x) = 7. Donc, (a XOR x) * (b XOR x) = 98.
Il peut être prouvé que 98 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.

Exemple 2 :

Entrée : a = 6, b = 7, n = 5
Sortie : 930
Explication : Pour x = 25, (a XOR x) = 31 et (b XOR x) = 30. Donc, (a XOR x) * (b XOR x) = 930.
Il peut être prouvé que 930 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.
Exemple 3 :

Entrée : a = 1, b = 6, n = 3
Sortie : 12
Explication : Pour x = 5, (a XOR x) = 4 et (b XOR x) = 3. Donc, (a XOR x) * (b XOR x) = 12.
Il peut être prouvé que 12 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.

Contraintes :

0 <= a, b < 2^50
0 <= n <= 50

Étant donné trois entiers a, b et n, renvoyez la valeur maximale de (a XOR x) * (b XOR x) où 0 <= x < 2^n.
La réponse étant peut-être trop grande, renvoyez-la modulo 10^9 + 7.
Notez que XOR est l'opération XOR au niveau du bit.

Exemple 1 :

Entrée : a = 12, b = 5, n = 4
Sortie : 98
Explication : pour x = 2, (a XOR x) = 14 et (b XOR x) = 7. Par conséquent, (a XOR x) * (b XOR x) = 98.
On peut montrer que 98 est la valeur maximale de (a XOR x) * (b XOR x) pour tout 0 <= x < 2^n.

Exemple 2 :

Entrée : a = 6, b = 7, n = 5
Sortie : 930
Explication : pour x = 25, (a XOR x) = 31 et (b XOR x) = 30. Par conséquent, (a XOR x) * (b XOR x) = 930.
On peut montrer que 930 est la valeur maximale de (a XOR x) * (b XOR x) pour tout 0 <= x < 2^n.
Exemple 3 :

Entrée : a = 1, b = 6, n = 3
Sortie : 12
Explication : pour x = 5, (a XOR x) = 4 et (b XOR x) = 3. Par conséquent, (a XOR x) * (b XOR x) = 12.
On peut montrer que 12 est la valeur maximale de (a XOR x) * (b XOR x) pour tout 0 <= x < 2^n.

Contraintes :

0 <= a, b < 2^50
0 <= n <= 50

Étant donné trois entiers a, b et n, retournez la valeur maximale de (a XOR x) * (b XOR x) où 0 <= x < 2^n.
Comme la réponse peut être trop grande, retournez-la modulo 10^9 + 7.
Notez que XOR est l'opération XOR au niveau des bits.

Exemple 1 :

Entrée : a = 12, b = 5, n = 4
Sortie : 98
Explication : pour x = 2, (a XOR x) = 14 et (b XOR x) = 7. Donc, (a XOR x) * (b XOR x) = 98.
Il peut être prouvé que 98 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.

Exemple 2 :

Entrée : a = 6, b = 7, n = 5
Sortie : 930
Explication : pour x = 25, (a XOR x) = 31 et (b XOR x) = 30. Donc, (a XOR x) * (b XOR x) = 930.
Il peut être prouvé que 930 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.
Exemple 3 :

Entrée : a = 1, b = 6, n = 3
Sortie : 12
Explication : pour x = 5, (a XOR x) = 4 et (b XOR x) = 3. Donc, (a XOR x) * (b XOR x) = 12.
Il peut être prouvé que 12 est la valeur maximale de (a XOR x) * (b XOR x) pour tous 0 <= x < 2^n.

Contraintes :

0 <= a, b < 2^50
0 <= n <= 50


Vous avez un tableau d'entiers indexé à partir de 0 appelé `nums`. Une paire d'entiers x et y est appelée une paire forte si elle satisfait la condition :

|x - y| <= min(x, y)

Vous devez sélectionner deux entiers de `nums` de sorte qu'ils forment une paire forte et que leur XOR bit à bit soit le maximum parmi toutes les paires fortes du tableau.
Renvoyez la valeur maximale du XOR parmi toutes les paires fortes possibles dans le tableau `nums`.
Notez que vous pouvez choisir le même entier deux fois pour former une paire.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 7
Explanation: Il y a 11 paires fortes dans le tableau nums : (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) et (5, 5).
Le maximum possible de XOR parmi ces paires est 3 XOR 4 = 7.

Exemple 2 :

Entrée : nums = [10,100]
Sortie : 0
Explanation: Il y a 2 paires fortes dans le tableau nums : (10, 10) et (100, 100).
Le maximum possible de XOR parmi ces paires est 10 XOR 10 = 0 puisque la paire (100, 100) donne aussi 100 XOR 100 = 0.

Exemple 3 :

Entrée : nums = [5,6,25,30]
Sortie : 7
Explanation: Il y a 6 paires fortes dans le tableau nums : (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) et (30, 30).
Le maximum possible de XOR parmi ces paires est 25 XOR 30 = 7 puisque la seule autre valeur de XOR non nulle est 5 XOR 6 = 3.

Contraintes :

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

Vous avez un tableau nums d'entiers indexé à partir de 0. Une paire d'entiers x et y est appelée une paire forte si elle satisfait la condition :

|x - y| <= min(x, y)

Vous devez sélectionner deux entiers de nums de sorte qu'ils forment une paire forte et que leur XOR bit à bit soit le maximum parmi toutes les paires fortes du tableau.
Retournez la valeur maximale du XOR parmi toutes les paires fortes possibles dans le tableau nums.
Notez que vous pouvez choisir le même entier deux fois pour former une paire.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 7
Explanation: Il y a 11 paires fortes dans le tableau nums : (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) et (5, 5).
Le maximum possible de XOR parmi ces paires est 3 XOR 4 = 7.

Exemple 2 :

Entrée : nums = [10,100]
Sortie : 0
Explanation: Il y a 2 paires fortes dans le tableau nums : (10, 10) et (100, 100).
Le maximum possible de XOR parmi ces paires est 10 XOR 10 = 0 puisque la paire (100, 100) donne aussi 100 XOR 100 = 0.

Exemple 3 :

Entrée : nums = [5,6,25,30]
Sortie : 7
Explanation: Il y a 6 paires fortes dans le tableau nums : (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) et (30, 30).
Le maximum possible de XOR parmi ces paires est 25 XOR 30 = 7 puisque la seule autre valeur de XOR non nulle est 5 XOR 6 = 3.

Contraintes :

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

On vous donne un tableau d'entiers indexés 0 nums. Une paire d'entiers x et y est appelée une paire forte si elle satisfait la condition :

|x - y| <= min(x, y)

Vous devez sélectionner deux entiers de nums tels qu'ils forment une paire forte et que leur XOR au niveau du bit soit le maximum parmi toutes les paires fortes du tableau.
Renvoyer la valeur XOR maximale parmi toutes les paires fortes possibles dans le tableau nums.
Notez que vous pouvez choisir le même entier deux fois pour former une paire.

Exemple 1 :

Entrée : nums = [1,2,3,4,5]
Sortie : 7
Explication : Il y a 11 paires fortes dans le tableau nums : (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) et (5, 5).
Le XOR maximum possible à partir de ces paires est 3 XOR 4 = 7.

Exemple 2 :

Entrée : nums = [10,100]
Sortie : 0
Explication : Il y a 2 paires fortes dans le tableau nums : (10, 10) et (100, 100).
Le XOR maximum possible à partir de ces paires est 10 XOR 10 = 0 puisque la paire (100, 100) donne également 100 XOR 100 = 0.

Exemple 3 :

Entrée : nums = [5,6,25,30]
Sortie : 7
Explication : Il y a 6 paires fortes dans le tableau nums : (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) et (30, 30).
Le XOR maximum possible à partir de ces paires est 25 XOR 30 = 7 puisque la seule autre valeur XOR non nulle est 5 XOR 6 = 3.

Contraintes :

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


On vous donne un tableau indexé à partir de 0 de chaînes de caractères `words` et un caractère `x`.
Retournez un tableau d'indices représentant les mots qui contiennent le caractère `x`.
Notez que le tableau retourné peut être dans n'importe quel ordre.

Exemple 1 :

Entrée : mots = ["leet","code"], x = "e"
Sortie : [0,1]
Explication : "e" apparaît dans les deux mots : "leet" et "code". Ainsi, nous retournons les indices 0 et 1.

Exemple 2 :

Entrée : mots = ["abc","bcd","aaaa","cbc"], x = "a"
Sortie : [0,2]
Explication : "a" apparaît dans "abc" et "aaaa". Ainsi, nous retournons les indices 0 et 2.

Exemple 3 :

Entrée : mots = ["abc","bcd","aaaa","cbc"], x = "z"
Sortie : []
Explication : "z" n'apparaît dans aucun des mots. Ainsi, nous retournons un tableau vide.

Contraintes :

1 <= mots.length <= 50
1 <= mots[i].length <= 50
x est une lettre minuscule anglaise.
mots[i] est constitué uniquement de lettres minuscules anglaises.

On vous donne un tableau indexé à 0 de chaînes de mots et d'un caractère x.
Renvoie un tableau d'indices représentant les mots qui contiennent le caractère x.
Notez que le tableau renvoyé peut être dans n'importe quel ordre.

Exemple 1 :

Entrée : mots = ["leet","code"], x = "e"
Sortie : [0,1]
Explication : "e" apparaît dans les deux mots : "leet" et "code". Par conséquent, nous renvoyons les indices 0 et 1.

Exemple 2 :

Entrée : mots = ["abc","bcd","aaaa","cbc"], x = "a"
Sortie : [0,2]
Explication : "a" apparaît dans "abc" et "aaaa". Par conséquent, nous renvoyons les indices 0 et 2.

Exemple 3 :

Entrée : words = ["abc","bcd","aaaa","cbc"], x = "z"
Sortie : []
Explication : "z" n'apparaît dans aucun des mots. Par conséquent, nous renvoyons un tableau vide.

Contraintes :

1 <= words.length <= 50
1 <= words[i].length <= 50
x est une lettre anglaise minuscule.
words[i] se compose uniquement de lettres anglaises minuscules.

On vous donne un tableau indexé à partir de 0 de chaînes de caractères words et un caractère x.
Retournez un tableau d'indices représentant les mots qui contiennent le caractère x.
Notez que le tableau retourné peut être dans n'importe quel ordre.

Exemple 1 :

Entrée : words = ["leet","code"], x = "e"
Sortie : [0,1]
Explication : "e" apparaît dans les deux mots : "leet" et "code". Ainsi, nous retournons les indices 0 et 1.

Exemple 2 :

Entrée : words = ["abc","bcd","aaaa","cbc"], x = "a"
Sortie : [0,2]
Explication : "a" apparaît dans "abc" et "aaaa". Ainsi, nous retournons les indices 0 et 2.

Exemple 3 :

Entrée : words = ["abc","bcd","aaaa","cbc"], x = "z"
Sortie : []
Explication : "z" n'apparaît dans aucun des mots. Ainsi, nous retournons un tableau vide.

Contraintes :

1 <= words.length <= 50
1 <= words[i].length <= 50
x est une lettre minuscule anglaise.
words[i] est constitué uniquement de lettres minuscules anglaises.


Il y a n boules sur une table, chaque boule a une couleur noire ou blanche.
On vous donne une chaîne binaire indexée à 0 s de longueur n, où 1 et 0 représentent respectivement les boules noires et blanches.
À chaque étape, vous pouvez choisir deux boules adjacentes et les échanger.
Renvoyer le nombre minimum d'étapes pour regrouper toutes les boules noires à droite et toutes les boules blanches à gauche.

Exemple 1 :

Entrée : s = "101"
Sortie : 1
Explication : Nous pouvons regrouper toutes les boules noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "011".
Initialement, les 1 ne sont pas regroupés ensemble, ce qui nécessite au moins 1 étape pour les regrouper à droite.
Exemple 2 :

Entrée : s = "100"
Sortie : 2
Explication : Nous pouvons regrouper toutes les boules noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "010".
- Échanger s[1] et s[2], s = "001".
Il peut être prouvé que le nombre minimum d'étapes nécessaires est de 2.

Exemple 3 :

Entrée : s = "0111"
Sortie : 0
Explication : Toutes les boules noires sont déjà groupées à droite.

Contraintes :

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

On a n balles sur une table, chaque balle ayant une couleur noire ou blanche.
On donne une chaîne binaire s indexée à partir de 0 de longueur n, où 1 et 0 représentent respectivement des balles noires et blanches.
À chaque étape, vous pouvez choisir deux balles adjacentes et les échanger.
Retournez le nombre minimal d'étapes pour regrouper toutes les balles noires à droite et toutes les balles blanches à gauche.

Exemple 1:

Entrée: s = "101"
Sortie: 1
Explication: Nous pouvons regrouper toutes les balles noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "011".
Initialement, les 1 ne sont pas regroupés ensemble, nécessitant au moins 1 étape pour les regrouper à droite.
Exemple 2:

Entrée: s = "100"
Sortie: 2
Explication: Nous pouvons regrouper toutes les balles noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "010".
- Échanger s[1] et s[2], s = "001".
On peut prouver que le nombre minimum d'étapes nécessaires est 2.

Exemple 3:

Entrée: s = "0111"
Sortie: 0
Explication: Toutes les balles noires sont déjà regroupées à droite.

Contraintes:

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

Il y a n balles sur une table, chaque balle est de couleur noire ou blanche.
On vous donne une chaîne binaire indexée à partir de 0, s, de longueur n, où 1 et 0 représentent des balles noires et blanches, respectivement.
À chaque étape, vous pouvez choisir deux balles adjacentes et les échanger.
Renvoyez le nombre minimum d'étapes pour regrouper toutes les balles noires à droite et toutes les balles blanches à gauche.

Exemple 1 :

Entrée : s = "101"
Sortie : 1
Explication : Nous pouvons regrouper toutes les balles noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "011".
Initialement, les 1 ne sont pas regroupés ensemble, nécessitant au moins 1 étape pour les regrouper à droite.

Exemple 2 :

Entrée : s = "100"
Sortie : 2
Explication : Nous pouvons regrouper toutes les balles noires à droite de la manière suivante :
- Échanger s[0] et s[1], s = "010".
- Échanger s[1] et s[2], s = "001".
On peut prouver que le nombre minimum d'étapes nécessaires est 2.

Exemple 3 :

Entrée : s = "0111"
Sortie : 0
Explication : Toutes les balles noires sont déjà regroupées à droite.

Contraintes :

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


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

Choisissez n'importe quel indice i du tableau et augmentez ou diminuez nums[i] de 1.

Le score du tableau final est la fréquence de l'élément le plus fréquent dans le tableau.
Retournez le score maximum que vous pouvez atteindre.
La fréquence d'un élément est le nombre d'occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,6,4], k = 3
Sortie : 3
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0, et augmentez la valeur de nums[0] de 1. Le tableau résultant est [2,2,6,4].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,3].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,2].
L'élément 2 est le plus fréquent dans le tableau final donc notre score est 3.
On peut montrer qu'on ne peut pas obtenir de meilleur score.

Exemple 2 :

Entrée : nums = [1,4,4,2,4], k = 0
Sortie : 3
Explication : Nous ne pouvons appliquer aucune opération donc notre score sera la fréquence de l'élément le plus fréquent dans le tableau original, qui est 3.

Contraintes :

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

On vous donne un tableau d'entiers indexé à 0, nommé nums, et un entier k.
Vous pouvez effectuer l'opération suivante sur le tableau au plus k fois :

Choisissez n'importe quel indice i du tableau et augmentez ou diminuez nums[i] de 1.

Le score du tableau final est la fréquence de l'élément le plus fréquent dans le tableau.
Renvoyez le score maximum que vous pouvez atteindre.
La fréquence d'un élément est le nombre d'occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,6,4], k = 3
Sortie : 3
Explication : Nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0, et augmentez la valeur de nums[0] de 1. Le tableau résultant est [2,2,6,4].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,3].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,2].
L'élément 2 est le plus fréquent dans le tableau final donc notre score est 3.
On peut montrer qu'on ne peut pas obtenir un meilleur score.

Exemple 2 :

Entrée : nums = [1,4,4,2,4], k = 0
Sortie : 3
Explication : Nous ne pouvons appliquer aucune opération donc notre score sera la fréquence de l'élément le plus fréquent dans le tableau original, qui est 3.

Contraintes :

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

On vous donne un tableau d'entiers indexés à 0, nommé nums, et un entier k.
Vous pouvez effectuer l'opération suivante sur le tableau au plus k fois :

Choisissez n'importe quel indice i du tableau et augmentez ou diminuez nums[i] de 1.

Le score du tableau final est la fréquence de l'élément le plus fréquent dans le tableau.
Retournez le score maximum que vous pouvez atteindre.
La fréquence d'un élément est le nombre d'occurrences de cet élément dans le tableau.

Exemple 1 :

Entrée : nums = [1,2,6,4], k = 3
Sortie : 3
Explication : nous pouvons effectuer les opérations suivantes sur le tableau :
- Choisissez i = 0, et augmentez la valeur de nums[0] de 1. Le tableau résultant est [2,2,6,4].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,3].
- Choisissez i = 3, et diminuez la valeur de nums[3] de 1. Le tableau résultant est [2,2,6,2].
L'élément 2 est le plus fréquent dans le tableau final, donc notre score est 3.
On peut montrer qu'on ne peut pas obtenir un meilleur score.

Exemple 2 :

Entrée : nums = [1,4,4,2,4], k = 0
Sortie : 3
Explication : nous ne pouvons appliquer aucune opération, donc notre score sera la fréquence de l'élément le plus fréquent dans le tableau original, qui est 3.

Contraintes :

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


On vous donne deux entiers positifs n et limit.
Retournez le nombre total de façons de distribuer n bonbons parmi 3 enfants de sorte qu'aucun enfant ne reçoive plus de limit bonbons.

Exemple 1 :

Entrée : n = 5, limit = 2
Sortie : 3
Explication : Il y a 3 façons de distribuer 5 bonbons de sorte qu'aucun enfant ne reçoive plus de 2 bonbons : (1, 2, 2), (2, 1, 2) et (2, 2, 1).

Exemple 2 :

Entrée : n = 3, limit = 3
Sortie : 10
Explication : Il y a 10 façons de distribuer 3 bonbons de sorte qu'aucun enfant ne reçoive plus de 3 bonbons : (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) et (3, 0, 0).

Contraintes :

1 <= n <= 50
1 <= limit <= 50

On vous donne deux entiers positifs n et limit.
Renvoyez le nombre total de façons de distribuer n bonbons parmi 3 enfants de sorte qu'aucun enfant ne reçoive plus de limit bonbons.

Exemple 1 :

Entrée : n = 5, limit = 2
Sortie : 3
Explication : Il y a 3 façons de distribuer 5 bonbons de sorte qu'aucun enfant ne reçoive plus de 2 bonbons : (1, 2, 2), (2, 1, 2) et (2, 2, 1).

Exemple 2 :

Entrée : n = 3, limit = 3
Sortie : 10
Explication : Il y a 10 façons de distribuer 3 bonbons de sorte qu'aucun enfant ne reçoive plus de 3 bonbons : (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) et (3, 0, 0).

Contraintes :

1 <= n <= 50
1 <= limit <= 50


On vous donne un entier n.
Une chaîne s est dite bonne si elle contient uniquement des caractères anglais en minuscules et s'il est possible de réarranger les caractères de s de sorte que la nouvelle chaîne contienne "leet" comme sous-chaîne.
Par exemple :

La chaîne "lteer" est bonne car nous pouvons la réarranger pour former "leetr".
"letl" n'est pas bonne car nous ne pouvons pas la réarranger pour contenir "leet" comme sous-chaîne.

Retournez le nombre total de chaînes bonnes de longueur n.
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.
Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.

Exemple 1 :

Entrée : n = 4
Sortie : 12
Explication : Les 12 chaînes qui peuvent être réarrangées pour avoir "leet" comme sous-chaîne sont : "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" et "tlee".

Exemple 2 :

Entrée : n = 10
Sortie : 83943898
Explication : Le nombre de chaînes de longueur 10 qui peuvent être réarrangées pour avoir "leet" comme sous-chaîne est 526083947580. D'où la réponse qui est 526083947580 % (10^9 + 7) = 83943898.

Contraintes :

1 <= n <= 10^5

On vous donne un entier n.
Une chaîne s est dite bonne si elle ne contient que des caractères anglais minuscules et qu'il est possible de réorganiser les caractères de s de telle sorte que la nouvelle chaîne contienne "leet" comme sous-chaîne.
Par exemple :

La chaîne "lteer" est bonne car nous pouvons la réorganiser pour former "leetr".
"letl" n'est pas bonne car nous ne pouvons pas la réorganiser pour contenir "leet" comme sous-chaîne.

Renvoie le nombre total de bonnes chaînes de longueur n.
Comme la réponse peut être grande, renvoyez-la modulo 10^9 + 7.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.

Exemple 1 :

Entrée : n = 4
Sortie : 12
Explication : Les 12 chaînes qui peuvent être réorganisées pour avoir « leet » comme sous-chaîne sont : "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" et "tlee".

Exemple 2 :

Entrée : n = 10
Sortie : 8 394 3898
Explication : Le nombre de chaînes de longueur 10 qui peuvent être réorganisées pour avoir « leet » comme sous-chaîne est de 5 260 8394 7580. La réponse est donc 5 260 8394 7580 % (10^9 + 7) = 8 394 3898.

Contraintes :

1 <= n <= 10^5

Vous avez un entier n.
Une chaîne s est appelée bonne si elle contient uniquement des caractères anglais en minuscules et s'il est possible de réorganiser les caractères de s de sorte que la nouvelle chaîne contienne "leet" comme sous-chaîne.
Par exemple :

La chaîne "lteer" est bonne car nous pouvons la réorganiser pour former "leetr".
"letl" n'est pas bonne car nous ne pouvons pas la réorganiser pour contenir "leet" comme sous-chaîne.

Renvoyez le nombre total de chaînes bonnes de longueur n.
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.
Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.

Exemple 1 :

Entrée : n = 4
Sortie : 12
Explication : Les 12 chaînes qui peuvent être réorganisées pour avoir "leet" comme sous-chaîne sont : "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" et "tlee".

Exemple 2 :

Entrée : n = 10
Sortie : 83943898
Explication : Le nombre de chaînes de longueur 10 qui peuvent être réorganisées pour avoir "leet" comme sous-chaîne est 526083947580. D'où la réponse est 526083947580 % (10^9 + 7) = 83943898.

Contraintes :

1 <= n <= 10^5


On vous donne une chaîne de caractères s, indexée à partir de 0, de longueur paire n.
On vous donne également un tableau 2D d'entiers, queries, où queries[i] = [a_i, b_i, c_i, d_i].
Pour chaque requête i, vous êtes autorisé à effectuer les opérations suivantes :

Réorganisez les caractères dans la sous-chaîne s[a_i:b_i], où 0 <= a_i <= b_i < n / 2.
Réorganisez les caractères dans la sous-chaîne s[c_i:d_i], où n / 2 <= c_i <= d_i < n.

Pour chaque requête, votre tâche consiste à déterminer s'il est possible de faire de s un palindrome en effectuant les opérations spécifiées.
Chaque requête est traitée indépendamment des autres.
Retournez un tableau indexé à partir de 0, answer, où answer[i] == true s'il est possible de faire de s un palindrome en effectuant les opérations spécifiées par la i^ème requête, et false sinon.

Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.
s[x:y] représente la sous-chaîne constituée des caractères allant de l'indice x à l'indice y dans s, les deux étant inclus.

Exemple 1 :

Entrée : s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Sortie : [true,true]
Explication : Dans cet exemple, il y a deux requêtes :
Dans la première requête :
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Donc, vous êtes autorisé à réorganiser s[1:1] => abcabc et s[3:5] => abcabc.
- Pour faire de s un palindrome, s[3:5] peut être réorganisé pour devenir => abccba.
- Maintenant, s est un palindrome. Donc, answer[0] = true.
Dans la seconde requête :
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Donc, vous êtes autorisé à réorganiser s[0:2] => abcabc et s[5:5] => abcabc.
- Pour faire de s un palindrome, s[0:2] peut être réorganisé pour devenir => cbaabc.
- Maintenant, s est un palindrome. Donc, answer[1] = true.

Exemple 2 :

Entrée : s = "abbcdecbba", queries = [[0,2,7,9]]
Sortie : [false]
Explication : Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Donc, vous êtes autorisé à réorganiser s[0:2] => abbcdecbba et s[7:9] => abbcdecbba.
Il n'est pas possible de faire de s un palindrome en réorganisant ces sous-chaînes car s[3:6] n'est pas un palindrome.
Donc, answer[0] = false.
Exemple 3 :

Entrée : s = "acbcab", queries = [[1,2,4,5]]
Sortie : [true]
Explication : Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Donc, vous êtes autorisé à réorganiser s[1:2] => acbcab et s[4:5] => acbcab.
Pour faire de s un palindrome, s[1:2] peut être réorganisé pour devenir abccab.
Ensuite, s[4:5] peut être réorganisé pour devenir abccba.
Maintenant, s est un palindrome. Donc, answer[0] = true.

Contraintes :

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n est pair.
s est composé uniquement de lettres minuscules anglaises.

On vous donne une chaîne indexée 0 ayant une longueur paire n.
Vous avez également un tableau entier 2D indexé 0, des queries, où les queries [i] = [a_i, b_i, c_i, d_i].
Pour chaque requête I, vous êtes autorisé à effectuer les opérations suivantes:

Réorganisez les caractères dans la sous-chaîne s [a_i: b_i], où 0 <= a_i <= b_i <n / 2.
Réorganisez les caractères dans la sous-chaîne s [c_i: d_i], où n / 2 <= c_i <= d_i <n.

Pour chaque requête, votre tâche consiste à déterminer s'il est possible de faire de S palindrome en effectuant les opérations.
Chaque requête est répondue indépendamment des autres.
Renvoyez une réponse à 0 indexée indexée, où la réponse [i] == true s'il est possible de faire un palindrome en effectuant des opérations spécifiées par la question i ^ th, et false autrement.

Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
s [x: y] représente la sous-chaîne composée de caractères de l'index x à l'index y en s, tous deux inclus.

Exemple 1:

Entrée: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Sortie: [true, true]
Explication: Dans cet exemple, il y a deux queries:
Dans la première requête:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Ainsi, vous êtes autorisé à réorganiser s [1: 1] => abcabc et s [3: 5] => abcabc.
- Pour faire de s un palindrome, s [3: 5] peut être réorganisé pour devenir => abccba.
- Maintenant, s est un palindrome. Donc, réponse [0] = true.
Dans la deuxième requête:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Ainsi, vous êtes autorisé à réorganiser s [0: 2] => abcabc. et s [5: 5] => abcabc.
- Faire de s palindrome, s [0: 2] peut être réorganisé pour devenir => cbaabc.
- Maintenant, s est un palindrome. Donc, réponse [1] = true.

Exemple 2:

Entrée: s = "acbcab", queries = [[1,2,4,5]]
Sortie: [false]
Explication: Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Ainsi, vous êtes autorisé à réorganiser S [0: 2] => abbcdecbba et s [7: 9] => abbcdecbba.
Il n'est pas possible de faire de s un palindrome en réorganisant ces sous-chaînes car s [3: 6] n'est pas un palindrome.
Donc, réponse [0] = false.
Exemple 3:

Entrée: s = "acbcab", queries = [[1,2,4,5]]
Sortie: [true]
Explication: Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Ainsi, vous êtes autorisé à réorganiser s [1: 2] => acbcab et s [4: 5] => acbcab.
Faire de s palindrome s [1: 2] peut être réorganisé pour devenir abccab.
Ensuite, s [4: 5] peut être réorganisé pour devenir abccab.
Maintenant, s est un palindrome. Donc, réponse [0] = true.

Contraintes:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i <n / 2
n / 2 <= c_i <= d_i <n
n est pair.
s se compose uniquement de lettres anglaises minuscules.

On vous donne une chaîne de caractères s, indexée à partir de 0, ayant une longueur paire n.
On vous donne également un tableau 2D d'entiers, queries, où queries[i] = [a_i, b_i, c_i, d_i].
Pour chaque requête i, vous êtes autorisé à effectuer les opérations suivantes :

Réorganisez les caractères dans la sous-chaîne s[a_i:b_i], où 0 <= a_i <= b_i < n / 2.
Réorganisez les caractères dans la sous-chaîne s[c_i:d_i], où n / 2 <= c_i <= d_i < n.

Pour chaque requête, votre tâche est de déterminer s'il est possible de faire de s un palindrome en effectuant les opérations.
Chaque requête est traitée indépendamment des autres.
Renvoyez un tableau indexé à partir de 0, answer, où answer[i] == true s'il est possible de faire de s un palindrome en effectuant les opérations spécifiées par la i^ème requête, et false sinon.

Une sous-chaîne est une séquence contiguë de caractères au sein d'une chaîne.
s[x:y] représente la sous-chaîne constituée des caractères allant de l'indice x à l'indice y dans s, les deux inclus.

Exemple 1 :

Entrée : s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Sortie : [true,true]
Explication : Dans cet exemple, il y a deux requêtes :
Dans la première requête :
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Donc, vous êtes autorisé à réorganiser s[1:1] => abcabc et s[3:5] => abcabc.
- Pour faire de s un palindrome, s[3:5] peut être réorganisé pour devenir => abccba.
- Maintenant, s est un palindrome. Donc, answer[0] = true.
Dans la seconde requête :
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Donc, vous êtes autorisé à réorganiser s[0:2] => abcabc et s[5:5] => abcabc.
- Pour faire de s un palindrome, s[0:2] peut être réorganisé pour devenir => cbaabc.
- Maintenant, s est un palindrome. Donc, answer[1] = true.

Exemple 2 :

Entrée : s = "abbcdecbba", queries = [[0,2,7,9]]
Sortie : [false]
Explication : Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Donc, vous êtes autorisé à réorganiser s[0:2] => abbcdecbba et s[7:9] => abbcdecbba.
Il n'est pas possible de faire de s un palindrome en réorganisant ces sous-chaînes car s[3:6] n'est pas un palindrome.
Donc, answer[0] = false.

Exemple 3 :

Entrée : s = "acbcab", queries = [[1,2,4,5]]
Sortie : [true]
Explication : Dans cet exemple, il n'y a qu'une seule requête.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Donc, vous êtes autorisé à réorganiser s[1:2] => acbcab et s[4:5] => acbcab.
Pour faire de s un palindrome, s[1:2] peut être réorganisé pour devenir abccab.
Ensuite, s[4:5] peut être réorganisé pour devenir abccba.
Maintenant, s est un palindrome. Donc, answer[0] = true.

Contraintes :

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n est pair.
s se compose uniquement de lettres minuscules anglaises.


Vous disposez de deux tableaux d'entiers nums1 et nums2 indexés à partir de 0, respectivement de tailles n et m.
Considérez le calcul des valeurs suivantes :

Le nombre d'indices i tels que 0 <= i < n et nums1[i] apparaît au moins une fois dans nums2.
Le nombre d'indices i tels que 0 <= i < m et nums2[i] apparaît au moins une fois dans nums1.

Retournez un tableau d'entiers answer de taille 2 contenant les deux valeurs dans l'ordre ci-dessus.

Exemple 1 :

Entrée : nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Sortie : [3,4]
Explication : Nous calculons les valeurs comme suit :
- Les éléments aux indices 1, 2, et 3 dans nums1 apparaissent au moins une fois dans nums2. Donc la première valeur est 3.
- Les éléments aux indices 0, 1, 3 et 4 dans nums2 apparaissent au moins une fois dans nums1. Donc la deuxième valeur est 4.

Exemple 2 :

Entrée : nums1 = [3,4,2,3], nums2 = [1,5]
Sortie : [0,0]
Explication : Il n'y a pas d'éléments communs entre les deux tableaux, donc les deux valeurs seront 0.

Contraintes :

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Vous disposez de deux tableaux d'entiers à indices 0, nums1 et nums2, de tailles n et m, respectivement.
Considérez le calcul des valeurs suivantes :

Le nombre d'indices i tels que 0 <= i < n et nums1[i] apparaît au moins une fois dans nums2.
Le nombre d'indices i tels que 0 <= i < m et nums2[i] apparaît au moins une fois dans nums1.

Renvoyez un tableau d'entiers answer de taille 2 contenant les deux valeurs dans l'ordre ci-dessus.

Exemple 1 :

Entrée : nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Sortie : [3,4]
Explication : Nous calculons les valeurs comme suit :
- Les éléments aux indices 1, 2, et 3 dans nums1 apparaissent au moins une fois dans nums2. Donc la première valeur est 3.
- Les éléments aux indices 0, 1, 3 et 4 dans nums2 apparaissent au moins une fois dans nums1. Donc la deuxième valeur est 4.

Exemple 2 :

Entrée : nums1 = [3,4,2,3], nums2 = [1,5]
Sortie : [0,0]
Explication : Il n'y a pas d'éléments communs entre les deux tableaux, donc les deux valeurs seront 0.

Contraintes :

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Vous disposez de deux tableaux d'entiers à indices 0, nums1 et nums2, de tailles n et m, respectivement.
Considérez le calcul des valeurs suivantes :

Le nombre d'indices i tels que 0 <= i < n et nums1[i] apparaît au moins une fois dans nums2.
Le nombre d'indices i tels que 0 <= i < m et nums2[i] apparaît au moins une fois dans nums1.

Retournez un tableau d'entiers answer de taille 2 contenant les deux valeurs dans l'ordre ci-dessus.

Exemple 1 :

Entrée : nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Sortie : [3,4]
Explication : Nous calculons les valeurs comme suit :
- Les éléments aux indices 1, 2, et 3 dans nums1 apparaissent au moins une fois dans nums2. Donc la première valeur est 3.
- Les éléments aux indices 0, 1, 3 et 4 dans nums2 apparaissent au moins une fois dans nums1. Donc la deuxième valeur est 4.

Exemple 2 :

Entrée : nums1 = [3,4,2,3], nums2 = [1,5]
Sortie : [0,0]
Explication : Il n'y a pas d'éléments communs entre les deux tableaux, donc les deux valeurs seront 0.

Contraintes :

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100


Vous avez trois chaînes de caractères s1, s2 et s3. Vous devez effectuer l'opération suivante sur ces trois chaînes autant de fois que vous le souhaitez.
Dans une opération, vous pouvez choisir l'une de ces trois chaînes dont la longueur est d'au moins 2 et supprimer le caractère le plus à droite.
Retournez le nombre minimal d'opérations nécessaires pour rendre les trois chaînes égales s'il est possible de les rendre égales, sinon, retournez -1.

Exemple 1 :

Entrée : s1 = "abc", s2 = "abb", s3 = "ab"
Sortie : 2
Explication : Effectuer des opérations sur s1 et s2 une fois conduira à trois chaînes égales.
Il peut être démontré qu'il n'y a pas de moyen de les rendre égales en moins de deux opérations.

Exemple 2 :

Entrée : s1 = "dac", s2 = "bac", s3 = "cac"
Sortie : -1
Explication : Parce que les premières lettres de s1 et s2 ne sont pas égales, elles ne peuvent être égales après un quelconque nombre d'opérations. Donc la réponse est -1.

Contraintes :

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 et s3 sont composés uniquement de lettres minuscules anglaises.

Vous avez trois chaînes de caractères s1, s2 et s3. Vous devez effectuer l'opération suivante sur ces trois chaînes autant de fois que vous le souhaitez.
Dans une opération, vous pouvez choisir l'une de ces trois chaînes dont la longueur est d'au moins 2 et supprimer le caractère le plus à droite.
Renvoyez le nombre minimal d'opérations nécessaires pour rendre les trois chaînes égales s'il est possible de les rendre égales, sinon, renvoyez -1.

Exemple 1 :

Entrée : s1 = "abc", s2 = "abb", s3 = "ab"
Sortie : 2
Explication : Effectuer des opérations sur s1 et s2 une fois conduira à trois chaînes égales.
Il peut être démontré qu'il n'y a pas de moyen de les rendre égales avec moins de deux opérations.

Exemple 2 :

Entrée : s1 = "dac", s2 = "bac", s3 = "cac"
Sortie : -1
Explication : Parce que les premières lettres de s1 et s2 ne sont pas égales, elles ne peuvent être égales après un quelconque nombre d'opérations. Donc la réponse est -1.

Contraintes :

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 et s3 sont composés uniquement de lettres minuscules anglaises.

Vous avez trois chaînes de caractères s1, s2 et s3. Vous devez effectuer l'opération suivante sur ces trois chaînes autant de fois que vous le souhaitez.
Dans une opération, vous pouvez choisir l'une de ces trois chaînes dont la longueur est d'au moins 2 et supprimer le caractère le plus à droite.
Retournez le nombre minimal d'opérations nécessaires pour rendre les trois chaînes égales s'il est possible de les rendre égales, sinon, retournez -1.

Exemple 1 :

Entrée : s1 = "abc", s2 = "abb", s3 = "ab"
Sortie : 2
Explication : Effectuer des opérations sur s1 et s2 une fois conduira à trois chaînes égales.
Il peut être démontré qu'il n'y a pas de moyen de les rendre égales avec moins de deux opérations.
Exemple 2 :

Entrée : s1 = "dac", s2 = "bac", s3 = "cac"
Sortie : -1
Explication : Parce que les premières lettres de s1 et s2 ne sont pas égales, elles ne peuvent être égales après un quelconque nombre d'opérations. Donc la réponse est -1.

Contraintes :

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 et s3 sont composés uniquement de lettres minuscules anglaises.


Vous êtes à un marché aux fruits avec différents types de fruits exotiques en exposition.
On vous donne un tableau prices indexé à partir de 1, où prices[i] indique le nombre de pièces nécessaires pour acheter le i-ème fruit.
Le marché aux fruits propose l'offre suivante :

Si vous achetez le i-ème fruit à prices[i] pièces, vous pouvez obtenir les i fruits suivants gratuitement.

Notez que même si vous pouvez prendre le fruit j gratuitement, vous pouvez toujours l'acheter pour prices[j] pièces pour bénéficier d'une nouvelle offre.
Retournez le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 1 :

Entrée : prices = [3,1,2]
Sortie : 4
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1er fruit avec 3 pièces, vous pouvez prendre le 2ème fruit gratuitement.
- Achetez le 2ème fruit avec 1 pièce, vous pouvez prendre le 3ème fruit gratuitement.
- Prenez le 3ème fruit gratuitement.
Notez que même si vous pouviez prendre le 2ème fruit gratuitement, vous l'avez acheté car c'est plus optimal.
Il peut être prouvé que 4 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 2 :

Entrée : prices = [1,10,1,1]
Sortie : 2
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1er fruit avec 1 pièce, vous pouvez prendre le 2ème fruit gratuitement.
- Prenez le 2ème fruit gratuitement.
- Achetez le 3ème fruit pour 1 pièce, vous pouvez prendre le 4ème fruit gratuitement.
- Prenez le 4ème fruit gratuitement.
Il peut être prouvé que 2 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Contraintes :

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Vous êtes sur un marché aux fruits avec différents types de fruits exotiques exposés.
On vous donne un tableau de prix indexé à 1, où prix[i] désigne le nombre de pièces nécessaires pour acheter le i^ème fruit.
Le marché aux fruits propose l'offre suivante :

Si vous achetez le i^ème fruit à prix[i] pièces, vous pouvez obtenir gratuitement les i fruits suivants.

Notez que même si vous pouvez prendre le fruit j gratuitement, vous pouvez toujours l'acheter pour prix[j] pièces pour recevoir une nouvelle offre.
Renvoie le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 1 :

Entrée : prices = [3,1,2]
Sortie : 4
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1^er fruit avec 3 pièces, vous êtes autorisé à prendre gratuitement le 2^ème fruit.
- Achetez le 2^ème fruit avec 1 pièce, vous êtes autorisé à prendre gratuitement le 3^ème fruit.
- Prenez gratuitement le 3^ème fruit.
Notez que même si vous avez été autorisé à prendre le 2e fruit gratuitement, vous l'avez acheté parce qu'il est plus optimal.
Il peut être prouvé que 4 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 2 :

Entrée : prices = [1,10,1,1]
Sortie : 2
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1er fruit avec 1 pièce, vous êtes autorisé à prendre le 2e fruit gratuitement.
- Prenez le 2e fruit gratuitement.
- Achetez le 3e fruit pour 1 pièce, vous êtes autorisé à prendre le 4e fruit gratuitement.
- Prenez le 4e fruit gratuitement.
Il peut être prouvé que 2 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Contraintes :

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Vous êtes à un marché de fruits avec différents types de fruits exotiques exposés.
Vous recevez un tableau de prix à indice 1, où prices[i] indique le nombre de pièces nécessaires pour acheter le ième fruit.
Le marché de fruits propose l'offre suivante :

Si vous achetez le ième fruit à prices[i] pièces, vous pouvez obtenir les i fruits suivants gratuitement.

Notez que même si vous pouvez prendre le fruit j gratuitement, vous pouvez toujours l'acheter pour prices[j] pièces pour bénéficier d'une nouvelle offre.
Rentrez le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 1 :

Entrée : prix = [3,1,2]
Sortie : 4
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1er fruit avec 3 pièces, vous pouvez prendre le 2ème fruit gratuitement.
- Achetez le 2ème fruit avec 1 pièce, vous pouvez prendre le 3ème fruit gratuitement.
- Prenez le 3ème fruit gratuitement.
Notez que même si vous pouviez prendre le 2ème fruit gratuitement, vous l'avez acheté car c'est plus optimal.
Il peut être prouvé que 4 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Exemple 2 :

Entrée : prix = [1,10,1,1]
Sortie : 2
Explication : Vous pouvez acquérir les fruits comme suit :
- Achetez le 1er fruit avec 1 pièce, vous pouvez prendre le 2ème fruit gratuitement.
- Prenez le 2ème fruit gratuitement.
- Achetez le 3ème fruit pour 1 pièce, vous pouvez prendre le 4ème fruit gratuitement.
- Prenez le 4ème fruit gratuitement.
Il peut être prouvé que 2 est le nombre minimum de pièces nécessaires pour acquérir tous les fruits.

Contraintes :

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


On vous donne une chaîne de caractères \(s\) et d'un entier positif \(k\).
Les voyelles et consonnes sont respectivement le nombre de voyelles et de consonnes dans une chaîne.
Une chaîne est belle si :

voyelles == consonnes.
(voyelles * consonnes) % k == 0, c'est-à-dire que la multiplication de voyelles et de consonnes est divisible par \(k\).

Renvoyez le nombre de sous-chaînes non vides et belles dans la chaîne donnée \(s\).
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Les lettres de voyelles en anglais sont 'a', 'e', 'i', 'o' et 'u'.
Les lettres de consonnes en anglais sont toutes les lettres sauf les voyelles.

Exemple 1 :

Input: s = "baeyh", k = 2
Output: 2
Explication : Il y a 2 sous-chaînes belles dans la chaîne donnée.
- Sous-chaîne "baeyh", voyelles = 2 (["a",e"]), consonnes = 2 (["y","h"]).
Vous pouvez voir que la chaîne "aeyh" est belle car les voyelles == consonnes et voyelles * consonnes % k == 0.
- Sous-chaîne "baeyh", voyelles = 2 (["a",e"]), consonnes = 2 (["b","y"]).
Vous pouvez voir que la chaîne "baey" est belle car les voyelles == consonnes et voyelles * consonnes % k == 0.
Il peut être démontré qu'il n'y a que 2 sous-chaînes belles dans la chaîne donnée.

Exemple 2 :

Input: s = "abba", k = 1
Output: 3
Explication : Il y a 3 sous-chaînes belles dans la chaîne donnée.
- Sous-chaîne "abba", voyelles = 1 (["a"]), consonnes = 1 (["b"]).
- Sous-chaîne "abba", voyelles = 1 (["a"]), consonnes = 1 (["b"]).
- Sous-chaîne "abba", voyelles = 2 (["a","a"]), consonnes = 2 (["b","b"]).
Il peut être démontré qu'il n'y a que 3 sous-chaînes belles dans la chaîne donnée.

Exemple 3 :

Input: s = "bcdf", k = 1
Output: 0
Explication : Il n'y a pas de sous-chaînes belles dans la chaîne donnée.

Contraintes :

1 <= s.length <= 1000
1 <= k <= 1000
s est composée uniquement de lettres minuscules anglaises.

Vous disposez d'une chaîne de caractères \(s\) et d'un entier positif \(k\).
Soit voyelles et consonnes respectivement le nombre de voyelles et de consonnes dans une chaîne.
Une chaîne est dite belle si :

voyelles == consonnes.
(voyelles * consonnes) % k == 0, c'est-à-dire que la multiplication de voyelles et de consonnes est divisible par \(k\).

Retournez le nombre de sous-chaînes non vides et belles dans la chaîne donnée \(s\).
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Les lettres de voyelles en anglais sont 'a', 'e', 'i', 'o' et 'u'.
Les lettres de consonnes en anglais sont toutes les lettres sauf les voyelles.

Exemple 1 :

Entrée : s = "baeyh", k = 2
Sortie : 2
Explication : Il y a 2 sous-chaînes belles dans la chaîne donnée.
- Sous-chaîne "baeyh", voyelles = 2 (["a",e"]), consonnes = 2 (["y","h"]).
Vous pouvez voir que la chaîne "aeyh" est belle car les voyelles == consonnes et voyelles * consonnes % k == 0.
- Sous-chaîne "baeyh", voyelles = 2 (["a",e"]), consonnes = 2 (["b","y"]).
Vous pouvez voir que la chaîne "baey" est belle car les voyelles == consonnes et voyelles * consonnes % k == 0.
Il peut être démontré qu'il n'y a que 2 sous-chaînes belles dans la chaîne donnée.

Exemple 2 :

Entrée : s = "abba", k = 1
Sortie : 3
Explication : Il y a 3 sous-chaînes belles dans la chaîne donnée.
- Sous-chaîne "abba", voyelles = 1 (["a"]), consonnes = 1 (["b"]).
- Sous-chaîne "abba", voyelles = 1 (["a"]), consonnes = 1 (["b"]).
- Sous-chaîne "abba", voyelles = 2 (["a","a"]), consonnes = 2 (["b","b"]).
Il peut être démontré qu'il n'y a que 3 sous-chaînes belles dans la chaîne donnée.

Exemple 3 :

Entrée : s = "bcdf", k = 1
Sortie : 0
Explication : Il n'y a pas de sous-chaînes belles dans la chaîne donnée.

Contraintes :

1 <= s.length <= 1000
1 <= k <= 1000
s est composée uniquement de lettres minuscules anglaises.

On vous donne une chaîne S et un entier positif k.
Soient les voyelles et les consonnes le nombre de voyelles et de consonnes dans une chaîne.
Une chaîne est belle si:

vowels == consonants.
(vowels * consonants) % k == 0, en d'autres termes, la multiplication des voyelles et des consonnes est divisible par k.

Renvoie le nombre de belles sous-chaînes non vides dans la chaîne s donnée.
Une sous-chaîne est une séquence contiguë de caractères dans une chaîne.
Les lettres de voyelle en anglais sont «a», «e», «i», «o» et «u».
Les lettres consonantes en anglais sont toutes les lettres sauf les voyelles.

Exemple 1:

Entrée: s = "baeyh", k = 2
Sortie: 2
Explication: Il y a 2 belles sous-chaînes dans la chaîne donnée.
- sous-chaîne "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["y","h"]).
Vous pouvez voir que la chaîne "aeyh" est magnifique comme vowels == consonants et vowels * consonants % k == 0.
- sous-chaîne "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["b","y"]).
Vous pouvez voir que la chaîne "baey" est magnifique comme vowels == consonants et vowels * consonants % k == 0.
On peut montrer qu'il n'y a que 2 belles sous-chaînes dans la chaîne donnée.

Exemple 2:

Entrée: s = "abba", k = 1
Sortie: 3
Explication: Il y a 3 belles sous-chaînes dans la chaîne donnée.
- sous-chaîne "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
- sous-chaîne "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
- sous-chaîne "abba", vowels = 2 (["a","a"]), consonants = 2 (["b","b"]).
On peut montrer qu'il n'y a que 3 belles sous-chaînes dans la chaîne donnée.

Exemple 3:

Entrée: s = "bcdf", k = 1
Sortie: 0
Explication: Il n'y a pas de belles sous-chaînes dans la chaîne donnée.

Contraintes:

1 <= s.length <= 1000
1 <= k <= 1000
s se compose uniquement de lettres minuscules anglaises.


On vous donne un tableau d'entiers nums indexé à partir de 0.
Vous pouvez effectuer un nombre quelconque d'opérations, où chaque opération consiste à sélectionner un sous-tableau et à le remplacer par la somme de ses éléments. Par exemple, si le tableau donné est [1,3,5,6] et que vous sélectionnez le sous-tableau [3,5], le tableau deviendra [1,8,6].
Retournez la longueur maximale d'un tableau non décroissant qui peut être obtenu après avoir appliqué les opérations.
Un sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [5,2,2]
Sortie : 1
Explication : Ce tableau de longueur 3 n'est pas non-décroissant.
Nous avons deux manières de rendre le tableau de longueur deux.
La première en choisissant le sous-tableau [2,2], ce qui transforme le tableau en [5,4].
La deuxième en choisissant le sous-tableau [5,2], ce qui transforme le tableau en [7,2].
Dans ces deux cas, le tableau n'est pas non-décroissant.
Et si nous choisissons le sous-tableau [5,2,2] et le remplaçons par [9], il devient non-décroissant.
Donc la réponse est 1.

Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : 4
Explication : Le tableau est non-décroissant. Donc la réponse est 4.

Exemple 3 :

Entrée : nums = [4,3,2,6]
Sortie : 3
Explication : Remplacer [3,2] par [5] transforme le tableau donné en [4,5,6] qui est non-décroissant.
Comme le tableau donné n'est pas non-décroissant, la réponse maximale possible est 3.

Contraintes :

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

On vous donne un tableau d'entiers indexé à 0 nums.
Vous pouvez effectuer n'importe quel nombre d'opérations, où chaque opération implique la sélection d'un sous-tableau du tableau et son remplacement par la somme de ses éléments. Par exemple, si le tableau donné est [1,3,5,6] et que vous sélectionnez le sous-tableau [3,5], le tableau sera converti en [1,8,6].
Renvoie la longueur maximale d'un tableau non décroissant qui peut être créé après l'application des opérations.
Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [5,2,2]
Sortie : 1
Explication : Ce tableau de longueur 3 n'est pas non décroissant.
Nous avons deux façons de faire en sorte que la longueur du tableau soit de deux.
Tout d'abord, choisir le sous-tableau [2,2] convertit le tableau en [5,4].
Deuxièmement, choisir le sous-tableau [5,2] convertit le tableau en [7,2].
De ces deux manières, le tableau n'est pas non décroissant.
Et si nous choisissons le sous-tableau [5,2,2] et le remplaçons par [9], il devient non décroissant.
La réponse est donc 1.

Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : 4
Explication : Le tableau n'est pas décroissant. La réponse est donc 4.

Exemple 3 :

Entrée : nums = [4,3,2,6]
Sortie : 3
Explication : Le remplacement de [3,2] par [5] convertit le tableau donné en [4,5,6] qui est non décroissant.
Comme le tableau donné n'est pas non décroissant, la réponse maximale possible est 3.

Contraintes :

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

Vous avez un tableau numérique nums, composé d'entiers numéroté à partir de 0.
Vous pouvez effectuer un nombre quelconque d'opérations, où chaque opération consiste à sélectionner un sous-tableau de ce tableau et le remplacer par la somme de ses éléments. Par exemple, si le tableau donné est [1,3,5,6] et que vous sélectionnez le sous-tableau [3,5], le tableau sera converti en [1,8,6].
Retournez la longueur maximale d'un tableau non décroissant qui peut être obtenu après avoir appliqué les opérations.
Un sous-tableau est une séquence contiguë non vide d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [5,2,2]
Sortie : 1
Explication : Ce tableau de longueur 3 n'est pas non décroissant.
Nous avons deux manières de rendre le tableau de longueur deux.
Premièrement, en choisissant le sous-tableau [2,2], on convertit le tableau en [5,4].
Deuxièmement, en choisissant le sous-tableau [5,2], on convertit le tableau en [7,2].
Dans ces deux cas, le tableau n'est pas non décroissant.
Et si nous choisissons le sous-tableau [5,2,2] et le remplaçons par [9], il devient non décroissant.
Donc, la réponse est 1.

Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : 4
Explication : Le tableau est non décroissant. Donc, la réponse est 4.

Exemple 3 :

Entrée : nums = [4,3,2,6]
Sortie : 3
Explication : Remplacer [3,2] par [5] convertit le tableau donné en [4,5,6] qui est non décroissant.
Comme le tableau donné n'est pas non décroissant, la réponse maximale possible est 3.

Contraintes :

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


Vous avez un tableau indexé à partir de 0, `nums`, composé d'entiers positifs.
Une partition d'un tableau en un ou plusieurs sous-tableaux contigus est dite bonne si aucun des sous-tableaux ne contient le même nombre.
Retournez le nombre total de bonnes partitions de `nums`.
Puisque la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 8
Explication : Les 8 partitions possibles sont : ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), et ([1,2,3,4]).

Exemple 2 :

Entrée : nums = [1,1,1,1]
Sortie : 1
Explication : La seule partition possible est : ([1,1,1,1]).

Exemple 3 :

Entrée : nums = [1,2,1,3]
Sortie : 2
Explication : Les 2 partitions possibles sont : ([1,2,1], [3]) et ([1,2,1,3]).

Contraintes :

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

On vous donne un tableau nums indexé 0 et composé d'entiers positifs.
Une partition d'un tableau en un ou plusieurs sous-ensembles contigus est dite bonne si deux sous-ensembles ne contiennent pas le même nombre.
Retournez le nombre total de bonnes partitions de nums.
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 8
Explication : Les 8 bonnes partitions possibles sont : ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) et ([1,2,3,4]).

Exemple 2 :

Entrée : nums = [1,1,1,1]
Sortie : 1
Explication : La seule bonne partition possible est : ([1,1,1,1,1]).

Exemple 3 :

Entrée : nums = [1,2,1,3]
Sortie : 2
Explication : Les 2 bonnes partitions possibles sont : ([1,2,1], [3]) et ([1,2,1,3]).

Contraintes :

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

Vous avez un tableau nums indexé à partir de 0 composé d'entiers positifs.
Une partition d'un tableau en un ou plusieurs sous-tableaux contigus est dite bonne si aucun des sous-tableaux ne contient le même nombre.
Retournez le nombre total de bonnes partitions de nums.
Puisque la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : nums = [1,2,3,4]
Sortie : 8
Explication : Les 8 partitions possibles sont : ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), et ([1,2,3,4]).

Exemple 2 :

Entrée : nums = [1,1,1,1]
Sortie : 1
Explication : La seule partition possible est : ([1,1,1,1]).

Exemple 3 :

Entrée : nums = [1,2,1,3]
Sortie : 2
Explication : Les 2 partitions possibles sont : ([1,2,1], [3]) et ([1,2,1,3]).

Contraintes :

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


On vous donne un tableau d'entiers nums et un entier positif k.
Renvoie le nombre de sous-tableaux où l'élément maximal de nums apparaît au moins k fois dans ce sous-tableau.
Un sous-tableau est une séquence contiguë d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [1,3,2,3,3], k = 2
Sortie : 6
Explication : Les sous-tableaux qui contiennent l'élément 3 au moins 2 fois sont : [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] et [3,3].

Exemple 2 :

Entrée : nums = [1,4,2,1], k = 3
Sortie : 0
Explication : Aucun sous-tableau ne contient l'élément 4 au moins 3 fois.

Contraintes :

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

Vous avez un tableau d'entiers nums et un entier positif k.
Retournez le nombre de sous-tableaux où l'élément maximum de nums apparaît au moins k fois dans ce sous-tableau.
Un sous-tableau est une séquence contiguë d'éléments au sein d'un tableau.

Exemple 1:

Entrée : nums = [1,3,2,3,3], k = 2
Sortie : 6
Explication : Les sous-tableaux qui contiennent l'élément 3 au moins 2 fois sont : [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] et [3,3].

Exemple 2:

Entrée : nums = [1,4,2,1], k = 3
Sortie : 0
Explication : Aucun sous-tableau ne contient l'élément 4 au moins 3 fois.

Contraintes:

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

On vous donne un tableau d'entiers nums et un entier positif k.
Retournez le nombre de sous-tableaux où l'élément maximum de nums apparaît au moins k fois dans ce sous-tableau.
Un sous-tableau est une séquence contiguë d'éléments au sein d'un tableau.

Exemple 1 :

Entrée : nums = [1,3,2,3,3], k = 2
Sortie : 6
Explication : Les sous-tableaux qui contiennent l'élément 3 au moins 2 fois sont : [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] et [3,3].

Exemple 2 :

Entrée : nums = [1,4,2,1], k = 3
Sortie : 0
Explication : Aucun sous-tableau ne contient l'élément 4 au moins 3 fois.

Contraintes :

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


Un tableau indexé à partir de 0 d'entiers positifs `nums` et un entier positif `limit` vous sont donnés.
Dans une opération, vous pouvez choisir deux indices `i` et `j` et échanger `nums[i]` et `nums[j]` si `|nums[i] - nums[j]| <= limit`.
Retournez le tableau lexicographiquement le plus petit qui peut être obtenu en effectuant l'opération un nombre quelconque de fois.
Un tableau `a` est plus petit lexicographiquement qu'un tableau `b` si à la première position où `a` et `b` diffèrent, le tableau `a` a un élément qui est inférieur à l'élément correspondant dans `b`. Par exemple, le tableau `[2,10,3]` est plus petit lexicographiquement que le tableau `[10,2,3]` car ils diffèrent à l'indice 0 et 2 < 10.

Exemple 1 :

Entrée : nums = [1,5,3,9,8], limit = 2
Sortie : [1,3,5,8,9]
Explication : Appliquez l'opération 2 fois :
- Échangez `nums[1]` avec `nums[2]`. Le tableau devient [1,3,5,9,8]
- Échangez `nums[3]` avec `nums[4]`. Le tableau devient [1,3,5,8,9]
Nous ne pouvons pas obtenir un tableau lexicographiquement plus petit en appliquant plus d'opérations.
Notez qu'il est possible d'obtenir le même résultat en effectuant des opérations différentes.

Exemple 2 :

Entrée : nums = [1,7,6,18,2,1], limit = 3
Sortie : [1,6,7,18,1,2]
Explication : Appliquez l'opération 3 fois :
- Échangez `nums[1]` avec `nums[2]`. Le tableau devient [1,6,7,18,2,1]
- Échangez `nums[0]` avec `nums[4]`. Le tableau devient [2,6,7,18,1,1]
- Échangez `nums[0]` avec `nums[5]`. Le tableau devient [1,6,7,18,1,2]
Nous ne pouvons pas obtenir un tableau lexicographiquement plus petit en appliquant plus d'opérations.

Exemple 3 :

Entrée : nums = [1,7,28,19,10], limit = 3
Sortie : [1,7,28,19,10]
Explication : [1,7,28,19,10] est le tableau lexicographiquement le plus petit que nous pouvons obtenir, car nous ne pouvons pas appliquer l'opération sur deux indices quelconques.

Contraintes :

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

On considère un tableau d'entiers positifs nums indexé à partir de 0 et un entier positif limit.
Dans une opération, vous pouvez choisir deux indices i et j et échanger nums[i] et nums[j] si |nums[i] - nums[j]| <= limit.
Retournez le tableau lexicographiquement le plus petit qui peut être obtenu en effectuant l'opération un nombre quelconque de fois.
Un tableau a est lexicographiquement plus petit qu'un tableau b si à la première position où a et b diffèrent, le tableau a a un élément qui est inférieur à l'élément correspondant dans b. Par exemple, le tableau [2,10,3] est lexicographiquement plus petit que le tableau [10,2,3] car ils diffèrent à l'indice 0 et 2 < 10.

Exemple 1 :

Entrée : nums = [1,5,3,9,8], limit = 2
Sortie : [1,3,5,8,9]
Explication : Appliquez l'opération 2 fois :
- Échangez nums[1] avec nums[2]. Le tableau devient [1,3,5,9,8]
- Échangez nums[3] avec nums[4]. Le tableau devient [1,3,5,8,9]
Nous ne pouvons pas obtenir un tableau lexiographiquement plus petit en appliquant plus d'opérations.
Notez qu'il est possible d'obtenir le même résultat en effectuant des opérations différentes.

Exemple 2 :

Entrée : nums = [1,7,6,18,2,1], limit = 3
Sortie : [1,6,7,18,1,2]
Explication : Appliquez l'opération 3 fois :
- Échangez nums[1] avec nums[2]. Le tableau devient [1,6,7,18,2,1]
- Échangez nums[0] avec nums[4]. Le tableau devient [2,6,7,18,1,1]
- Échangez nums[0] avec nums[5]. Le tableau devient [1,6,7,18,1,2]
Nous ne pouvons pas obtenir un tableau lexicographiquement plus petit en appliquant plus d'opérations.

Exemple 3 :

Entrée : nums = [1,7,28,19,10], limit = 3
Sortie : [1,7,28,19,10]
Explication : [1,7,28,19,10] est le tableau lexicographiquement le plus petit que nous pouvons obtenir car nous ne pouvons pas appliquer l'opération sur deux indices quelconques.

Contraintes :

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

On vous donne un tableau à index 0 de nombres entiers positifs et une limite entière positive.
Dans une opération, vous pouvez choisir deux indices i et j et échanger num[i] et num[j] si | num[i] - num[j] | <= limite.
Renvoyez le plus petit tableau lexicographique qui puisse être obtenu en effectuant l'opération un certain nombre de fois.
Un tableau A est lexicographique plus petit qu'un tableau B si dans la première position où A et B diffèrent, le tableau A a un élément qui est inférieur à l'élément correspondant en b. Par exemple, le tableau [2,10,3] est lexicographiquement plus petit que le tableau [10,2,3] car ils diffèrent à l'indice 0 et 2 <10.

Exemple 1:

Entrée: nnums = [1,5,3,9,8], limit = 2
Sortie: [1,3,5,8,9]
Explication: appliquez l'opération 2 fois:
- échanger num[1] avec num[2]. Le tableau devient [1,3,5,8,9]
- échanger num[3] avec num[4]. Le tableau devient [1,3,5,8,9]
Nous ne pouvons pas obtenir un tableau lexicographique plus petit en appliquant d'autres opérations.
Notez qu'il peut être possible d'obtenir le même résultat en effectuant différentes opérations.

Exemple 2:

Entrée: nums = [1,7,6,18,2,1], limit = 3
Sortie: [1,6,7,18,1,2]
Explication: appliquez l'opération 3 fois:
- échanger num[1] avec num[2]. Le tableau devient [1,6,7,18,2,1]
- échanger num[0] avec num[4]. Le tableau devient [2,6,7,18,1,1]
- échanger num[0] avec num[5]. Le tableau devient [1,6,7,18,1,2]
Nous ne pouvons pas obtenir un tableau lexicographique plus petit en appliquant d'autres opérations.

Exemple 3:

Entrée: nums = [1,7,28,19,10], limit = 3
Sortie: [1,7,28,19,10]
Explication: [1,7,28,19,10] est le plus petit tableau lexicographique que nous pouvons obtenir car nous ne pouvons pas appliquer l'opération sur deux indices.

Contraintes:

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


On vous donne un tableau d'entiers 0-indexé batteryPercentages de longueur n, représentant les pourcentages de batterie des n appareils indexés à partir de 0.
Votre tâche est de tester chaque appareil i dans l'ordre de 0 à n - 1, en effectuant les opérations de test suivantes :

Si batteryPercentages[i] est supérieur à 0 :

Incrémenter le nombre d'appareils testés.
Diminuer le pourcentage de batterie de tous les appareils avec les indices j dans la plage [i + 1, n - 1] de 1, en s'assurant que leur pourcentage de batterie ne soit jamais inférieur à 0, c'est-à-dire, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Passer à l'appareil suivant.

Sinon, passer à l'appareil suivant sans effectuer de test.

Retourner un entier indiquant le nombre d'appareils qui seront testés après avoir effectué les opérations de test dans l'ordre.

Exemple 1 :

Input: batteryPercentages = [1,1,2,1,3]
Output: 3
Explication: Effectuer les opérations de test dans l'ordre en commençant par l'appareil 0 :
Pour l'appareil 0, batteryPercentages[0] > 0, il y a donc maintenant 1 appareil testé, et batteryPercentages devient [1,0,1,0,2].
Pour l'appareil 1, batteryPercentages[1] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés, et batteryPercentages devient [1,0,1,0,1].
Pour l'appareil 3, batteryPercentages[3] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 4, batteryPercentages[4] > 0, il y a donc maintenant 3 appareils testés, et batteryPercentages reste inchangé.
Donc, la réponse est 3.

Exemple 2 :

Input: batteryPercentages = [0,1,2]
Output: 2
Explication: Effectuer les opérations de test dans l'ordre en commençant par l'appareil 0 :
Pour l'appareil 0, batteryPercentages[0] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 1, batteryPercentages[1] > 0, il y a donc maintenant 1 appareil testé, et batteryPercentages devient [0,1,1].
Pour l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés, et batteryPercentages reste inchangé.
Donc, la réponse est 2.

Contraintes :

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

On vous donne un tableau d'entiers indexés 0 batteryPercentages de longueur n, indiquant les pourcentages de batterie de n appareils indexés 0.
Votre tâche consiste à tester chaque appareil i dans l'ordre de 0 à n - 1, en effectuant les opérations de test suivantes :

Si batteryPercentages[i] est supérieur à 0 :

Incrémentez le nombre d'appareils testés.
Diminuez le pourcentage de batterie de tous les appareils avec des indices j dans la plage [i + 1, n - 1] de 1, en vous assurant que leur pourcentage de batterie ne descend jamais en dessous de 0, c'est-à-dire batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Passez à l'appareil suivant.

Sinon, passez à l'appareil suivant sans effectuer de test.

Renvoie un entier indiquant le nombre d'appareils qui seront testés après avoir effectué les opérations de test dans l'ordre.

Exemple 1 :

Entrée : batteryPercentages = [1,1,2,1,3]
Sortie : 3
Explication : Exécution des opérations de test dans l'ordre à partir de l'appareil 0 :
Sur l'appareil 0, batteryPercentages[0] > 0, il y a donc maintenant 1 appareil testé et batteryPercentages devient [1,0,1,0,2].
Sur l'appareil 1, batteryPercentages[1] == 0, nous passons donc à l'appareil suivant sans effectuer de test.
Sur l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés et batteryPercentages devient [1,0,1,0,1].
Sur l'appareil 3, batteryPercentages[3] == 0, nous passons donc à l'appareil suivant sans effectuer de test.
Sur l'appareil 4, batteryPercentages[4] > 0, il y a donc maintenant 3 appareils testés et batteryPercentages reste le même.
Donc, la réponse est 3.

Exemple 2 :

Entrée : batteryPercentages = [0,1,2]
Sortie : 2
Explication : Exécution des opérations de test dans l'ordre à partir de l'appareil 0 :
Au niveau de l'appareil 0, batteryPercentages[0] == 0, nous passons donc à l'appareil suivant sans effectuer de test.
Au niveau de l'appareil 1, batteryPercentages[1] > 0, il y a donc maintenant 1 appareil testé, et batteryPercentages devient [0,1,1].
Au niveau de l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés, et batteryPercentages reste le même.
Donc, la réponse est 2.

Contraintes :

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Vous avez un tableau d'entiers batteryPercentages indexé à partir de 0 de longueur n, représentant les pourcentages de batterie des n appareils indexés à partir de 0.
Votre tâche est de tester chaque appareil i dans l'ordre de 0 à n - 1, en effectuant les opérations de test suivantes :

Si batteryPercentages[i] est supérieur à 0 :

Incrémenter le nombre d'appareils testés.
Diminuer le pourcentage de batterie de tous les appareils avec les indices j dans la plage [i + 1, n - 1] de 1, en s'assurant que leur pourcentage de batterie ne soit jamais inférieur à 0, c'est-à-dire, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Passer à l'appareil suivant.

Sinon, passer à l'appareil suivant sans effectuer de test.

Retourner un entier indiquant le nombre d'appareils qui seront testés après avoir effectué les opérations de test dans l'ordre.

Exemple 1 :

Input: batteryPercentages = [1,1,2,1,3]
Output: 3
Explication: Effectuer les opérations de test dans l'ordre en commençant par l'appareil 0 :
Pour l'appareil 0, batteryPercentages[0] > 0, il y a donc maintenant 1 appareil testé, et batteryPercentages devient [1,0,1,0,2].
Pour l'appareil 1, batteryPercentages[1] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés, et batteryPercentages devient [1,0,1,0,1].
Pour l'appareil 3, batteryPercentages[3] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 4, batteryPercentages[4] > 0, il y a donc maintenant 3 appareils testés, et batteryPercentages reste inchangé.
Donc, la réponse est 3.

Exemple 2 :

Input: batteryPercentages = [0,1,2]
Output: 2
Explication: Effectuer les opérations de test dans l'ordre en commençant par l'appareil 0 :
Pour l'appareil 0, batteryPercentages[0] == 0, nous passons donc à l'appareil suivant sans tester.
Pour l'appareil 1, batteryPercentages[1] > 0, il y a donc maintenant 1 appareil testé, et batteryPercentages devient [0,1,1].
Pour l'appareil 2, batteryPercentages[2] > 0, il y a donc maintenant 2 appareils testés, et batteryPercentages reste inchangé.
Donc, la réponse est 2.

Contraintes :

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100