On vous donne une grille matricielle 2D composée d’entiers positifs.
Vous devez sélectionner une ou plusieurs cellules de la matrice de manière à satisfaire les conditions suivantes :

Aucune des cellules sélectionnées ne se trouve sur la même ligne de la matrice.
Les valeurs dans l'ensemble des cellules sélectionnées sont uniques.

Votre score sera la somme des valeurs des cellules sélectionnées.
Retournez le score maximal que vous pouvez obtenir.

Exemple 1 :

Entrée : grid = [[1,2,3],[4,3,2],[1,1,1]]
Sortie : 8
Explication :

Nous pouvons sélectionner les cellules avec les valeurs 1, 3, et 4 qui sont colorées ci-dessus.

Exemple 2 :

Entrée : grid = [[8,7,6],[8,3,2]]
Sortie : 15
Explication :

Nous pouvons sélectionner les cellules avec les valeurs 7 et 8 qui sont colorées ci-dessus.

Contraintes :

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

On vous donne une grille matricielle 2D composée d'entiers positifs.
Vous devez sélectionner une ou plusieurs cellules de la matrice de telle sorte que les conditions suivantes soient remplies:

Il n'y a pas deux cellules sélectionnées dans la même rangée de la matrice.
Les valeurs de l'ensemble des cellules sélectionnées sont uniques.

Votre score sera la somme des valeurs des cellules sélectionnées.
Renvoyez le score maximum que vous pouvez atteindre.

Exemple 1:

Entrée: grid = [[1,2,3], [4,3,2], [1,1,1]]
Sortie: 8
Explication:

Nous pouvons sélectionner les cellules avec des valeurs 1, 3 et 4 colorées ci-dessus.

Exemple 2:

Entrée: grid = [[8,7,6], [8,3,2]]
Sortie: 15
Explication:

Nous pouvons sélectionner les cellules avec des valeurs 7 et 8 colorées ci-dessus.

Contraintes:

1 <= grid.length, grid [i] .length <= 10
1 <= grid [i] [j] <= 100

On donne une matrice 2D grid composée d'entiers positifs.
Vous devez sélectionner une ou plusieurs cellules de la matrice de manière à satisfaire les conditions suivantes :

Aucune des cellules sélectionnées ne se trouve sur la même ligne de la matrice.
Les valeurs dans l'ensemble des cellules sélectionnées sont uniques.

Votre score sera la somme des valeurs des cellules sélectionnées.
Retournez le score maximal que vous pouvez atteindre.

Exemple 1 :

Entrée : grid = [[1,2,3],[4,3,2],[1,1,1]]
Sortie : 8
Explication :

Nous pouvons sélectionner les cellules avec les valeurs 1, 3, et 4 qui sont colorées ci-dessus.

Exemple 2 :

Entrée : grid = [[8,7,6],[8,3,2]]
Sortie : 15
Explication :

Nous pouvons sélectionner les cellules avec les valeurs 7 et 8 qui sont colorées ci-dessus.

Contraintes :

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100


On vous donne un tableau nums de n entiers et un tableau 2D queries de taille q, où queries[i] = [l_i, r_i].
Pour chaque requête, vous devez trouver le score XOR maximal de tout sous-tableau de nums[l_i..r_i].
Le score XOR d'un tableau a est trouvé en appliquant à plusieurs reprises les opérations suivantes sur a pour qu'il ne reste qu'un seul élément, qui est le score :

Remplacez simultanément a[i] par a[i] XOR a[i+1] pour tous les indices i sauf le dernier.
Supprimez le dernier élément de a.

Retournez un tableau answer de taille q où answer[i] est la réponse à la requête i.

Exemple 1 :

Entrée : nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Sortie : [12,60,60]
Explication :
Dans la première requête, nums[0..2] a 6 sous-tableaux [2], [8], [4], [2, 8], [8, 4], et [2, 8, 4] chacun avec un score XOR respectif de 2, 8, 4, 10, 12, et 6. La réponse pour la requête est 12, le plus grand de tous les scores XOR.
Dans la deuxième requête, le sous-tableau de nums[1..4] avec le plus grand score XOR est nums[1..4] avec un score de 60.
Dans la troisième requête, le sous-tableau de nums[0..5] avec le plus grand score XOR est nums[1..4] avec un score de 60.

Exemple 2 :

Entrée : nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Sortie : [7,14,11,14,5]
Explication :

Index
nums[l_i..r_i]
Sous-tableau Maximum Score XOR
Score Maximum Sous-tableau XOR

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Contraintes :

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

On vous donne un tableau nums de n entiers, et un tableau 2D d'entiers queries de taille q, où queries[i] = [l_i, r_i].
Pour chaque requête, vous devez trouver le score XOR maximum de n'importe quel sous-réseau de nums[l_i..r_i].
Le score XOR d'un tableau a est trouvé en appliquant de manière répétée les opérations suivantes sur a de manière à ce qu'il ne reste qu'un seul élément, à savoir le score :

Remplacer simultanément a[i] par a[i] XOR a[i + 1] pour tous les indices i sauf le dernier.
Supprimer le dernier élément de a.

Retourner un tableau answer de taille q où answer[i] est la réponse à la requête i.

Exemple 1 :

Entrée : nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Sortie : [12,60,60]
Explication :
Dans la première requête, nums[0..2] comporte 6 sous-réseaux [2], [8], [4], [2, 8], [8, 4] et [2, 8, 4], chacun ayant un score XOR respectif de 2, 8, 4, 10, 12 et 6. La réponse à la requête est 12, soit le plus grand des scores XOR.
Dans la deuxième requête, le sous-réseau de nums[1..4] ayant le plus grand score XOR est nums[1..4] avec un score de 60.
Dans la troisième requête, le sous-ensemble de nums[0..5] ayant le plus grand score XOR est nums[1..4] avec un score de 60.

Exemple 2 :

Entrée : nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Sortie : [7,14,11,14,5]
Explication :

Index
nums[l_i..r_i]
Score XOR maximal du sous-réseau
Score XOR maximal du sous-réseau

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Contraintes :

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

On vous donne un tableau nums de n entiers, et un tableau 2D queries de taille q, où queries[i] = [l_i, r_i].
Pour chaque requête, vous devez trouver le score XOR maximal de tout sous-tableau de nums[l_i..r_i].
Le score XOR d'un tableau a est obtenu en appliquant à plusieurs reprises les opérations suivantes sur a jusqu'à ce qu'il ne reste qu'un seul élément, qui est le score :

Remplacez simultanément a[i] par a[i] XOR a[i+1] pour tous les indices i sauf le dernier.
Supprimez le dernier élément de a.

Retournez un tableau answer de taille q où answer[i] est la réponse à la requête i.

Exemple 1 :

Entrée : nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Sortie : [12,60,60]
Explication :
Dans la première requête, nums[0..2] a 6 sous-tableaux [2], [8], [4], [2, 8], [8, 4], et [2, 8, 4] chacun avec un score XOR respectif de 2, 8, 4, 10, 12, et 6. La réponse pour la requête est 12, le plus grand de tous les scores XOR.
Dans la deuxième requête, le sous-tableau de nums[1..4] avec le plus grand score XOR est nums[1..4] avec un score de 60.
Dans la troisième requête, le sous-tableau de nums[0..5] avec le plus grand score XOR est nums[1..4] avec un score de 60.

Exemple 2 :

Entrée : nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Sortie : [7,14,11,14,5]
Explication :

Index
nums[l_i..r_i]
Sous-tableau Maximum Score XOR
Score Maximum Sous-tableau XOR

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Contraintes :

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1


On vous donne une chaîne de caractères date représentant une date du calendrier grégorien au format yyyy-mm-dd.
La date peut être écrite dans sa représentation binaire obtenue en convertissant l'année, le mois et le jour en leurs représentations binaires sans aucun zéro non significatif et en les écrivant dans le format année-mois-jour.
Retournez la représentation binaire de la date.

Exemple 1 :

Entrée : date = "2080-02-29"
Sortie : "100000100000-10-11101"
Explication :
100000100000, 10, et 11101 sont les représentations binaires de 2080, 02, et 29 respectivement.

Exemple 2 :

Entrée : date = "1900-01-01"
Sortie : "11101101100-1-1"
Explication :
11101101100, 1, et 1 sont les représentations binaires de 1900, 1, et 1 respectivement.

Contraintes :

date.length == 10
date[4] == date[7] == '-', et tous les autres date[i] sont des chiffres.
L'entrée est générée de sorte que la date représente une date valide du calendrier grégorien entre le 1er janvier 1900 et le 31 décembre 2100 (inclus).

On vous donne une date de chaîne représentant une date de calendrier grégorienne au format yyyy-mm-dd.
La date peut être écrite dans sa représentation binaire obtenue en convertissant l'année, le mois et la jour en leurs représentations binaires sans aucun zéros de premier plan et les écrivant dans le format année-mois-jour.
Retourner la représentation binaire de la date.

Exemple 1:

Entrée: date = "2080-02-29"
Sortie: "100000100000-10-11101"
Explication:
100000100000, 10 et 11101 sont les représentations binaires de 2080, 02 et 29 respectivement.

Exemple 2:

Entrée: date = "1900-01-01"
Sortie: "11101101100-1-1"
Explication:
11101101100, 1 et 1 sont les représentations binaires de 1900, 1 et 1 respectivement.

Contraintes:

date.length == 10
date [4] == date [7] == '-', et toutes les autres date [i] sont des chiffres.
L'entrée est générée de telle sorte que la date représente une date de calendrier grégorien valide entre le 1er janvier, 1900 et 31 décembre ^ st, 2100 (les deux inclusifs).

On vous donne une chaîne de caractères date représentant une date du calendrier grégorien au format aaaa-mm-jj.
La date peut être écrite dans sa représentation binaire obtenue en convertissant l'année, le mois et le jour en leurs représentations binaires sans aucun zéro de tête et en les écrivant dans le format année-mois-jour.
Retournez la représentation binaire de la date.

Exemple 1 :

Entrée : date = "2080-02-29"
Sortie : "100000100000-10-11101"
Explication :
100000100000, 10, et 11101 sont les représentations binaires de 2080, 02, et 29 respectivement.

Exemple 2 :

Entrée : date = "1900-01-01"
Sortie : "11101101100-1-1"
Explication :
11101101100, 1, et 1 sont les représentations binaires de 1900, 1, et 1 respectivement.

Contraintes :

date.length == 10
date[4] == date[7] == '-', et tous les autres date[i] sont des chiffres.
L'entrée est générée de sorte que la date représente une date valide du calendrier grégorien entre Jan 1^st, 1900 and Dec 31^st, 2100 (inclus).


Vous avez un tableau d'entiers start et un entier d, représentant n intervalles [start[i], start[i] + d].
Vous devez choisir n entiers où le i^ème entier doit appartenir au i^ème intervalle. Le score des entiers choisis est défini comme la différence absolue minimale entre deux entiers qui ont été choisis.
Retournez le score maximum possible des entiers choisis.

Exemple 1 :

Entrée : start = [6,0,3], d = 2
Sortie : 4
Explication :
Le score maximum possible peut être obtenu en choisissant les entiers : 8, 0, et 4. Le score de ces entiers choisis est min(|8 - 0|, |8 - 4|, |0 - 4|) qui est égal à 4.

Exemple 2 :

Entrée : start = [2,6,13,13], d = 5
Sortie : 5
Explication :
Le score maximum possible peut être obtenu en choisissant les entiers : 2, 7, 13, et 18. Le score de ces entiers choisis est min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) qui est égal à 5.

Contraintes :

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

On vous donne un tableau d'entiers start et un entier d, représentant n intervalles [start[i], start[i] + d]. Vous devez choisir n entiers où le i^ème entier doit appartenir au i^ème intervalle. Le score des entiers choisis est défini comme la différence absolue minimale entre deux entiers qui ont été choisis. Renvoyez le score maximum possible des entiers choisis.

Exemple 1 :

Entrée : start = [6,0,3], d = 2 Sortie : 4 Explication : Le score maximum possible peut être obtenu en choisissant les entiers : 8, 0, et 4. Le score de ces entiers choisis est min(|8 - 0|, |8 - 4|, |0 - 4|) qui est égal à 4.

Exemple 2 :

Entrée : start = [2,6,13,13], d = 5 Sortie : 5 Explication : Le score maximum possible peut être obtenu en choisissant les entiers : 2, 7, 13, et 18. Le score de ces entiers choisis est min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) qui est égal à 5.

Contraintes :

2 <= start.length <= 10^5 0 <= start[i] <= 10^9 0 <= d <= 10^9

On vous donne un tableau d'entiers de démarrage et un entier d, représentant n intervalles [démarrage [i], démarrage [i] + d].
On vous demande de choisir n entiers où le i-ème intervalle doit appartenir à le i-ème intervalle. Le score des entiers choisis est défini comme la différence absolue minimale entre deux entiers qui ont été choisis.
Renvoyez le score maximal possible des entiers choisis.

Exemple 1:

Entrée: start = [6,0,3], d = 2
Sortie: 4
Explication:
Le score maximal possible peut être obtenu en choisissant des entiers: 8, 0 et 4. Le score de ces entiers choisis est min(| 8 - 0 |, | 8 - 4 |, | 0 - 4 |)qui équivaut à 4.

Exemple 2:

Entrée: start = [2,6,13,13], d = 5
Sortie: 5
Explication:
Le score maximal possible peut être obtenu en choisissant des entiers: 2, 7, 13 et 18. Le score de ces entiers choisis est min (| 2 - 7 |, | 2 - 13 |, | 2 - 18 |, | 7 - 13 |, | 7 - 18 |, | 13 - 18 |) qui équivaut à 5.

Contraintes:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


On vous donne un tableau d'entiers `nums` de longueur n.
Votre objectif est de commencer à l'indice 0 et d'atteindre l'indice n - 1. Vous pouvez uniquement sauter vers des indices supérieurs à votre indice actuel.
Le score pour un saut de l'indice i à l'indice j est calculé comme (j - i) * nums[i].
Retournez le score total maximum possible au moment où vous atteignez le dernier indice.

Exemple 1 :

Input: nums = [1,3,1,5]
Output: 7
Explication :
D'abord, sautez à l'indice 1 puis sautez au dernier indice. Le score final est 1 * 1 + 2 * 3 = 7.

Exemple 2 :

Input: nums = [4,3,1,3,2]
Output: 16
Explication :
Sautez directement au dernier indice. Le score final est 4 * 4 = 16.

Contraintes :

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

On donne un tableau d'entiers nums de longueur n.
Votre objectif est de commencer à l'indice 0 et d'atteindre l'indice n - 1. Vous pouvez uniquement sauter vers des indices supérieurs à votre indice actuel.
Le score pour un saut de l'indice i à l'indice j est calculé comme (j - i) * nums[i].
Retournez le score total maximum possible au moment où vous atteignez le dernier indice.

Exemple 1 :

Entrée : nums = [1,3,1,5]
Sortie : 7
Explication :
D'abord, sautez à l'indice 1 puis sautez au dernier indice. Le score final est 1 * 1 + 2 * 3 = 7.

Exemple 2 :

Entrée : nums = [4,3,1,3,2]
Sortie : 16
Explication :
Sautez directement au dernier indice. Le score final est 4 * 4 = 16.

Contraintes :

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

On vous donne un tableau d'entiers nums de longueur n.
Votre objectif est de commencer à l'index 0 et d'atteindre l'index n - 1. Vous ne pouvez sauter que vers des indices supérieurs à votre index actuel.
Le score pour un saut de l'index i à l'index j est calculé comme (j - i) * nums[i].
Renvoie le score total maximum possible au moment où vous atteignez le dernier index.

Exemple 1 :

Entrée : nums = [1,3,1,5]
Sortie : 7
Explication :
Tout d'abord, sautez à l'index 1, puis au dernier index. Le score final est 1 * 1 + 2 * 3 = 7.

Exemple 2 :

Entrée : nums = [4,3,1,3,2]
Sortie : 16
Explication :
Allez directement au dernier index. Le score final est de 4 * 4 = 16.

Contraintes :

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


Il y a un échiquier de 50 x 50 sur lequel se trouvent un cavalier et quelques pions. On vous donne deux entiers kx et ky où (kx, ky) représente la position du cavalier, et un tableau 2D positions où positions[i] = [x_i, y_i] représente la position des pions sur l'échiquier.
Alice et Bob jouent un jeu à tour de rôle, Alice jouant la première. Au tour de chaque joueur :

Le joueur choisit un pion qui existe encore sur l'échiquier et le capture avec le cavalier en un minimum de coups. Le joueur peut choisir n'importe quel pion, mais pas forcément celui qui peut être capturé en un minimum de coups.
Lors de la capture du pion sélectionné, le cavalier peut passer devant d'autres pions sans les capturer. Seul le pion sélectionné peut être capturé au cours de ce tour.

Alice essaie de maximiser la somme du nombre de coups effectués par les deux joueurs jusqu'à ce qu'il n'y ait plus de pions sur le plateau, tandis que Bob essaie de les minimiser.
Retournez le nombre total maximum de coups effectués au cours de la partie qu'Alice peut atteindre, en supposant que les deux joueurs jouent de façon optimale.
Notez qu'en un coup, un cavalier d'échecs a huit positions possibles vers lesquelles il peut se déplacer, comme illustré ci-dessous. Chaque déplacement est de deux cellules dans une direction cardinale, puis d'une cellule dans une direction orthogonale.

Exemple 1 :

Entrée : kx = 1, ky = 1, positions = [[0,0]]
Sortie : 4
Explication :

Le cavalier a besoin de 4 coups pour atteindre le pion en (0, 0).

Exemple 2 :

Entrée : kx = 0, ky = 2, positions = [[1,1], [2,2], [3,3]]
Résultat : 8
Explication :

Alice choisit le pion en (2, 2) et le capture en deux coups : (0, 2) -> (1, 4) -> (2, 2).
Bob prend le pion en (3, 3) et le capture en deux coups : (2, 2) -> (4, 1) -> (3, 3).
Alice prend le pion en (1, 1) et le capture en quatre coups : (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Exemple 3 :

Entrée : kx = 0, ky = 0, positions = [[1,2], [2,4]]
Sortie : 3
Explication :

Alice choisit le pion en (2, 4) et le capture en deux coups : (0, 0) -> (1, 2) -> (2, 4). Notez que le pion en (1, 2) n'est pas capturé.
Bob choisit le pion en (1, 2) et le capture en un coup : (2, 4) -> (1, 2).

Contraintes :

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Toutes les positions[i] sont uniques.
L'entrée est générée de telle sorte que positions[i] != [kx, ky] pour tous les 0 <= i < positions.length.

Il y a un échiquier 50 x 50 avec un cavalier et quelques pions dessus. On vous donne deux entiers kx et ky où (kx, ky) désigne la position du cavalier, et un tableau 2D positions où positions[i] = [x_i, y_i] désigne la position des pions sur l'échiquier. Alice et Bob jouent à tour de rôle, où Alice joue en premier. À chaque tour de joueur :

Le joueur sélectionne un pion qui est encore sur le plateau et le capture avec le cavalier en le minimum de coups possible. Notez que le joueur peut sélectionner n'importe quel pion, il se peut qu'il ne soit pas capturable en le moins de coups possibles.
Dans le processus de capture du pion sélectionné, le cavalier peut passer d'autres pions sans les capturer. Seul le pion sélectionné peut être capturé à ce tour-ci.

Alice essaie de maximiser la somme du nombre de mouvements effectués par les deux joueurs jusqu'à ce qu'il n'y ait plus de pions sur le plateau, tandis que Bob tente de la minimiser.
Renvoyez le nombre maximum total de mouvements effectués pendant le jeu qu'Alice peut atteindre, en supposant que les deux joueurs jouent de façon optimale.
Notez que dans un mouvement, un cavalier d'échecs a huit positions possibles vers lesquelles il peut se déplacer, comme illustré ci-dessous. Chaque mouvement est de deux cases dans une direction cardinale, puis une case dans une direction orthogonale.

Exemple 1 :

Entrée : kx = 1, ky = 1, positions = [[0,0]]
Sortie : 4
Explication :

Le cavalier prend 4 mouvements pour atteindre le pion en (0, 0).

Exemple 2 :

Entrée : kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Sortie : 8
Explication :

Alice choisit le pion en (2, 2) et le capture en deux mouvements : (0, 2) -> (1, 4) -> (2, 2).
Bob choisit le pion en (3, 3) et le capture en deux mouvements : (2, 2) -> (4, 1) -> (3, 3).
Alice choisit le pion en (1, 1) et le capture en quatre mouvements : (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Exemple 3 :

Entrée : kx = 0, ky = 0, positions = [[1,2],[2,4]]
Sortie : 3
Explication :

Alice choisit le pion en (2, 4) et le capture en deux mouvements : (0, 0) -> (1, 2) -> (2, 4). Notez que le pion en (1, 2) n'est pas capturé.
Bob choisit le pion en (1, 2) et le capture en un mouvement : (2, 4) -> (1, 2).

Contraintes :

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Toutes les positions[i] sont uniques.
L'entrée est générée de manière que positions[i] != [kx, ky] pour tout 0 <= i < positions.length.

On a un échiquier 50 x 50 avec un cavalier et quelques pions dessus. On vous donne deux entiers kx et ky où (kx, ky) désigne la position du cavalier, et un tableau 2D positions où positions[i] = [x_i, y_i] désigne la position des pions sur l'échiquier.
Alice et Bob jouent à tour de rôle, et Alice joue en premier. À chaque tour de joueur :

Le joueur sélectionne un pion qui est encore sur le plateau et le capture avec le cavalier en le minimum de coups possible. Notez que le joueur peut sélectionner n'importe quel pion, il se peut qu'il ne soit pas capturable en le moins de coups possibles.
Dans le processus de capture du pion sélectionné, le cavalier peut passer d'autres pions sans les capturer. Seul le pion sélectionné peut être capturé à ce tour-ci.

Alice essaie de maximiser la somme du nombre de mouvements effectués par les deux joueurs jusqu'à ce qu'il n'y ait plus de pions sur le plateau, tandis que Bob tente de la minimiser.
Retournez le nombre maximum total de mouvements effectués qu'Alice peut atteindre pendant le jeu, en supposant que les deux joueurs jouent de façon optimale.
Notez que lors d'un mouvement, un cavalier d'échecs a huit positions possibles vers lesquelles il peut se déplacer, comme illustré ci-dessous. Chaque mouvement consiste en deux cases dans une direction cardinale, puis une case dans une direction orthogonale.

Exemple 1 :

Entrée : kx = 1, ky = 1, positions = [[0,0]]
Sortie : 4
Explication :

Le cavalier prend 4 mouvements pour atteindre le pion en (0, 0).

Exemple 2 :

Entrée : kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Sortie : 8
Explication :

Alice choisit le pion en (2, 2) et le capture en deux mouvements : (0, 2) -> (1, 4) -> (2, 2).
Bob choisit le pion en (3, 3) et le capture en deux mouvements : (2, 2) -> (4, 1) -> (3, 3).
Alice choisit le pion en (1, 1) et le capture en quatre mouvements : (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Exemple 3 :

Entrée : kx = 0, ky = 0, positions = [[1,2],[2,4]]
Sortie : 3
Explication :

Alice choisit le pion en (2, 4) et le capture en deux mouvements : (0, 0) -> (1, 2) -> (2, 4). Notez que le pion en (1, 2) n'est pas capturé.
Bob choisit le pion en (1, 2) et le capture en un mouvement : (2, 4) -> (1, 2).

Contraintes :

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Toutes les positions[i] sont uniques.
L'entrée est générée de manière que positions[i] != [kx, ky] pour tout 0 <= i < positions.length.


On vous donne un tableau d'entiers a de taille 4 et un autre tableau d'entiers b de taille au moins 4.
Vous devez choisir 4 indices i_0, i_1, i_2 et i_3 du tableau b tels que i_0 < i_1 < i_2 < i_3.
Votre score sera égal à la valeur a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Retournez le score maximum que vous pouvez obtenir.

Exemple 1 :

Entrée : a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Sortie : 26
Explication :
Nous pouvons choisir les indices 0, 1, 2, et 5. Le score sera 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Exemple 2 :

Entrée : a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Sortie : -1
Explication : Nous pouvons choisir les indices 0, 1, 3, et 4. Le score sera (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Contraintes :

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

On vous donne un tableau d'entiers a de taille 4 et un autre tableau d'entiers b de taille au moins 4.
Vous devez choisir 4 indices i_0, i_1, i_2 et i_3 du tableau b tels que i_0 < i_1 < i_2 < i_3. Votre score sera égal à la valeur a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Renvoyez le score maximum que vous pouvez obtenir.

Exemple 1 :

Entrée : a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Sortie : 26
Explication :
Nous pouvons choisir les indices 0, 1, 2, et 5. Le score sera 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Exemple 2 :

Entrée : a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Sortie : -1
Explication :
Nous pouvons choisir les indices 0, 1, 3, et 4. Le score sera (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Contraintes :

a.length == 4 4 <= b.length <= 10^5 -10^5 <= a[i], b[i] <= 10^5

On vous donne un tableau d'entiers a de taille 4 et un autre tableau d'entiers b de taille au moins 4.
Vous devez choisir 4 indices i_0, i_1, i_2 et i_3 dans le tableau b tels que i_0 < i_1 < i_2 < i_3. Votre score sera égal à la valeur a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Renvoie le score maximum que vous pouvez atteindre.

Exemple 1 :

Entrée : a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Sortie : 26
Explication :
Nous pouvons choisir les indices 0, 1, 2 et 5. Le score sera 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Exemple 2 :

Entrée : a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Sortie : -1
Explication :
Nous pouvons choisir les indices 0, 1, 3 et 4. Le score sera (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Contraintes :

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


On vous donne un tableau de chaînes de caractères `words` et une chaîne `target`.
Une chaîne `x` est dite valide si `x` est un préfixe de n'importe quelle chaîne dans `words`.
Renvoyez le nombre minimum de chaînes valides pouvant être concaténées pour former `target`. S'il est impossible de former `target`, renvoyez -1.

Exemple 1 :

Entrée : words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Sortie : 3
Explication :
La chaîne cible peut être formée en concaténant :

Préfixe de longueur 2 de words[1], c'est-à-dire "aa".
Préfixe de longueur 3 de words[2], c'est-à-dire "bcd".
Préfixe de longueur 3 de words[0], c'est-à-dire "abc".

Exemple 2 :

Entrée : words = ["abababab","ab"], target = "ababaababa"
Sortie : 2
Explication :
La chaîne cible peut être formée en concaténant :

Préfixe de longueur 5 de words[0], c'est-à-dire "ababa".
Préfixe de longueur 5 de words[0], c'est-à-dire "ababa".

Exemple 3 :

Entrée : words = ["abcdef"], target = "xyz"
Sortie : -1

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
L'entrée est générée de sorte que la somme(words[i].length) <= 10^5.
words[i] ne contient que des lettres minuscules anglaises.
1 <= target.length <= 5 * 10^3
target ne contient que des lettres minuscules anglaises.

On vous donne un tableau de chaînes de caractères words et une chaîne de caractères target.
Une chaîne x est dite valide si x est un préfixe de n'importe quelle chaîne dans words.
Retournez le nombre minimum de chaînes valides pouvant être concaténées pour former target. Si cela n'est pas possible, retournez -1.

Exemple 1 :

Entrée : words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Sortie : 3
Explication :
La chaîne cible peut être formée en concaténant :

Préfixe de longueur 2 de words[1], c'est-à-dire "aa".
Préfixe de longueur 3 de words[2], c'est-à-dire "bcd".
Préfixe de longueur 3 de words[0], c'est-à-dire "abc".

Exemple 2 :

Entrée : words = ["abababab","ab"], target = "ababaababa"
Sortie : 2
Explication :
La chaîne cible peut être formée en concaténant :

Préfixe de longueur 5 de words[0], c'est-à-dire "ababa".
Préfixe de longueur 5 de words[0], c'est-à-dire "ababa".

Exemple 3 :

Entrée : words = ["abcdef"], target = "xyz"
Sortie : -1

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
L'entrée est générée de sorte que la somme(words[i].length) <= 10^5.
words[i] ne contient que des lettres minuscules anglaises.
1 <= target.length <= 5 * 10^3
target ne contient que des lettres minuscules anglaises.

On vous donne un tableau de chaînes de caractères words et une chaîne de caractères target.
Une chaîne x est dite valide si x est un préfixe de n'importe quelle chaîne dans words.
Retournez le nombre minimum de chaînes valides qui peuvent être concaténées pour former cible. S'il n'est pas possible de former cible, renvoyer -1.

Exemple 1 :

Entrée : words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Sortie : 3
Explication :
La chaîne cible peut être formée en concaténant :

Le préfixe de longueur 2 de words[1], c'est-à-dire "aa".
Préfixe de longueur 3 des mots[2], soit "bcd".
Préfixe de longueur 3 des mots[0], soit "abc".

Exemple 2 :

Entrée : words = ["abababab","ab"], target = "ababaababa"
Sortie : 2
Explication :
La chaîne cible peut être formée en concaténant :

Le préfixe de longueur 5 de words[0], c'est-à-dire "ababa"
Préfixe de longueur 5 de mots[0], soit "ababa".

Exemple 3 :

Entrée : words = ["abcdef"], target = "xyz"
Sortie : -1

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
L'entrée est générée de telle sorte que sum(words[i].length) <= 10^5.
words[i] se compose uniquement de lettres minuscules anglaises.
1 <= target.length <= 5 * 10^3
target est composé uniquement de lettres minuscules anglaises.


Vous avez un tableau d'entiers `nums` de longueur `n` et un entier positif `k`.
La puissance d'un tableau est définie comme suit :

Son élément maximum si tous ses éléments sont consécutifs et triés dans l'ordre croissant.
-1 sinon.

Vous devez trouver la puissance de tous les sous-tableaux de `nums` de taille `k`.
Retournez un tableau d'entiers `results` de taille `n - k + 1`, où `results[i]` est la puissance de `nums[i..(i + k - 1)]`.

Exemple 1 :

Entrée : nums = [1,2,3,4,3,2,5], k = 3
Sortie : [3,4,-1,-1,-1]
Explication :
Il y a 5 sous-tableaux de `nums` de taille 3 :

[1, 2, 3] avec l'élément maximum 3.
[2, 3, 4] avec l'élément maximum 4.
[3, 4, 3] dont les éléments ne sont pas consécutifs.
[4, 3, 2] dont les éléments ne sont pas triés.
[3, 2, 5] dont les éléments ne sont pas consécutifs.

Exemple 2 :

Entrée : nums = [2,2,2,2,2], k = 4
Sortie : [-1,-1]

Exemple 3 :

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

Contraintes :

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

On vous donne un tableau de nombres entiers de la longueur n et un entier positif k.
La puissance d'un tableau est définie comme:

Son élément maximum si tous ses éléments sont consécutifs et triés par ordre croissant.
-1 sinon.

Vous devez trouver la puissance de tous les Sous-tableaux de taille k.
Renvoie un tableau entier Résultats de la taille n - k + 1, où les résultats [i] sont la puissance de nums [i .. (i + k - 1)].

Exemple 1:

Entrée: nums = [1,2,3,4,3,2,5], k = 3
Sortie: [3,4, -1, -1, -1]
Explication:
Il y a 5 Sous-tableaux de taille 3:

[1, 2, 3] avec l'élément maximum 3.
[2, 3, 4] avec l'élément maximum 4.
[3, 4, 3] dont les éléments ne sont pas consécutifs.
[4, 3, 2] dont les éléments ne sont pas triés.
[3, 2, 5] dont les éléments ne sont pas consécutifs.

Exemple 2:

Entrée: nums = [2,2,2,2,2], k = 4
Sortie: [-1, -1]

Exemple 3:

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

Contraintes:

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

Vous avez un tableau d'entiers nums de longueur n et un entier positif k.
La puissance d'un tableau est définie comme suit :

Son élément maximum si tous ses éléments sont consécutifs et triés dans l'ordre croissant.
-1 sinon.

Vous devez trouver la puissance de tous les sous-tableaux de nums de taille k.
Retournez un tableau d'entiers results de taille n - k + 1, où results[i] est la puissance de nums[i..(i + k - 1)].

Exemple 1 :

Entrée : nums = [1,2,3,4,3,2,5], k = 3
Sortie : [3,4,-1,-1,-1]
Explication :
Il y a 5 sous-tableaux de nums de taille 3 :

[1, 2, 3] avec l'élément maximum 3.
[2, 3, 4] avec l'élément maximum 4.
[3, 4, 3] dont les éléments ne sont pas consécutifs.
[4, 3, 2] dont les éléments ne sont pas triés.
[3, 2, 5] dont les éléments ne sont pas consécutifs.

Exemple 2 :

Entrée : nums = [2,2,2,2,2], k = 4
Sortie : [-1,-1]

Exemple 3 :

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

Contraintes :

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


On vous donne un tableau 2D m x n représentant un échiquier, où board[i][j] représente la valeur de la cellule (i, j).
Les tours d'une même ligne ou d'une même colonne s'attaquent les unes les autres. Vous devez placer trois tours sur l'échiquier de telle sorte qu'elles ne s'attaquent pas les unes les autres.
Renvoie la somme maximale des valeurs des cellules sur lesquelles les tours sont placées.

Exemple 1 :

Entrée : board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Sortie : 4
Explication :

Nous pouvons placer les tours dans les cellules (0, 2), (1, 3) et (2, 1) pour une somme de 1 + 1 + 2 = 4.

Exemple 2 :

Entrée : board = [[1,2,3],[4,5,6],[7,8,9]]
Sortie : 15
Explication :
Nous pouvons placer les tours dans les cellules (0, 0), (1, 1) et (2, 2) pour une somme de 1 + 5 + 9 = 15.

Exemple 3 :

Entrée : board = [[1,1,1],[1,1,1],[1,1,1]]
Sortie : 3
Explication :
Nous pouvons placer les tours dans les cellules (0, 2), (1, 1) et (2, 0) pour une somme de 1 + 1 + 1 = 3.

Contraintes :

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

On vous donne un plateau d'échecs représenté par un tableau 2D m x n, où board[i][j] représente la valeur de la cellule (i, j).
Les tours sur une même ligne ou colonne s'attaquent. Vous devez placer trois tours sur le plateau de manière à ce qu'elles ne s'attaquent pas entre elles.
Retournez la somme maximale des valeurs des cellules sur lesquelles les tours sont placées.

Exemple 1 :

Entrée : board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Sortie : 4
Explication :

Nous pouvons placer les tours sur les cellules (0, 2), (1, 3) et (2, 1) pour une somme de 1 + 1 + 2 = 4.

Exemple 2 :

Entrée : board = [[1,2,3],[4,5,6],[7,8,9]]
Sortie : 15
Explication :
Nous pouvons placer les tours sur les cellules (0, 0), (1, 1) et (2, 2) pour une somme de 1 + 5 + 9 = 15.

Exemple 3 :

Entrée : board = [[1,1,1],[1,1,1],[1,1,1]]
Sortie : 3
Explication :
Nous pouvons placer les tours sur les cellules (0, 2), (1, 1) et (2, 0) pour une somme de 1 + 1 + 1 = 3.

Contraintes :

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


On vous donne trois entiers positifs num1, num2, et num3.
La clé de num1, num2, et num3 est définie comme un nombre à quatre chiffres de telle sorte que :

Initialement, si un nombre a moins de quatre chiffres, il est complété par des zéros à gauche.
Le i^ème chiffre (1 <= i <= 4) de la clé est généré en prenant le plus petit chiffre parmi les i^èmes chiffres de num1, num2, et num3.

Retournez la clé des trois nombres sans les zéros à gauche (le cas échéant).

Exemple 1 :

Entrée : num1 = 1, num2 = 10, num3 = 1000
Sortie : 0
Explication :
En ajoutant des zéros, num1 devient "0001", num2 devient "0010", et num3 reste "1000".

Le 1^er chiffre de la clé est min(0, 0, 1).
Le 2^ème chiffre de la clé est min(0, 0, 0).
Le 3^ème chiffre de la clé est min(0, 1, 0).
Le 4^ème chiffre de la clé est min(1, 0, 0).

Ainsi, la clé est "0000", c'est-à-dire 0.

Exemple 2 :

Entrée : num1 = 987, num2 = 879, num3 = 798
Sortie : 777

Exemple 3 :

Entrée : num1 = 1, num2 = 2, num3 = 3
Sortie : 1

Contraintes :

1 <= num1, num2, num3 <= 9999

On donne trois entiers positifs num1, num2, et num3.
La clé de num1, num2, et num3 est définie comme un nombre à quatre chiffres de telle sorte que :

Initialement, si un nombre a moins de quatre chiffres, il est complété par des zéros en tête.
Le i^ème chiffre (1 <= i <= 4) de la clé est généré en prenant le plus petit chiffre parmi les i^èmes chiffres de num1, num2, et num3.

Retournez la clé des trois nombres sans les zéros de tête (le cas échéant).

Exemple 1 :

Entrée : num1 = 1, num2 = 10, num3 = 1000
Sortie : 0
Explication :
En ajoutant des zéros, num1 devient "0001", num2 devient "0010", et num3 reste "1000".

Le 1^er chiffre de la clé est min(0, 0, 1).
Le 2^ème chiffre de la clé est min(0, 0, 0).
Le 3^ème chiffre de la clé est min(0, 1, 0).
Le 4^ème chiffre de la clé est min(1, 0, 0).

Par conséquent, la clé est "0000", c'est-à-dire 0.

Exemple 2 :

Entrée : num1 = 987, num2 = 879, num3 = 798
Sortie : 777

Exemple 3 :

Entrée : num1 = 1, num2 = 2, num3 = 3
Sortie : 1

Contraintes :

1 <= num1, num2, num3 <= 9999

On vous donne trois entiers positifs num1, num2 et num3.
La clé de num1, num2 et num3 est définie comme un nombre à quatre chiffres tel que :

Au départ, si un nombre comporte moins de quatre chiffres, il est complété par des zéros non significatifs.
Le i^ème chiffre (1 <= i <= 4) de la clé est généré en prenant le plus petit chiffre parmi les i^èmes chiffres de num1, num2 et num3.

Renvoie la clé des trois nombres sans zéros non significatifs (le cas échéant).

Exemple 1 :

Entrée : num1 = 1, num2 = 10, num3 = 1000
Sortie : 0
Explication :
Lors du remplissage, num1 devient « 0001 », num2 devient "0010", et num3 reste "1000".

Le 1^er chiffre de la clé est min(0, 0, 1).
Le 2e chiffre de la clé est min(0, 0, 0).
Le 3e chiffre de la clé est min(0, 1, 0).
Le 4e chiffre de la clé est min(1, 0, 0).

La clé est donc "0000", c'est-à-dire 0.

Exemple 2 :

Entrée : num1 = 987, num2 = 879, num3 = 798
Sortie : 777

Exemple 3 :

Entrée : num1 = 1, num2 = 2, num3 = 3
Sortie : 1

Contraintes :

1 <= num1, num2, num3 <= 9999


On vous donne une chaîne de caractères s de longueur n et un entier k, où n est un multiple de k. Votre tâche est de hacher la chaîne s en une nouvelle chaîne appelée résultat, qui a une longueur de n / k.
Tout d'abord, divisez s en n / k sous-chaînes, chacune de longueur k. Ensuite, initialisez résultat comme une chaîne vide.
Pour chaque sous-chaîne, dans l'ordre depuis le début :

La valeur de hachage d'un caractère est l'indice de ce caractère dans l'alphabet anglais (par exemple, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Calculez la somme de toutes les valeurs de hachage des caractères de la sous-chaîne.
Trouvez le reste de cette somme quand elle est divisée par 26, appelé hashedChar.
Identifiez le caractère dans l'alphabet anglais en minuscules qui correspond à hashedChar.
Ajoutez ce caractère à la fin de résultat.

Renvoyez le résultat.

Exemple 1 :

Entrée : s = "abcd", k = 2
Sortie : "bf"
Explication :
Première sous-chaîne : "ab", 0 + 1 = 1, 1 % 26 = 1, résultat[0] = 'b'.
Deuxième sous-chaîne : "cd", 2 + 3 = 5, 5 % 26 = 5, résultat[1] = 'f'.

Exemple 2 :

Entrée : s = "mxz", k = 3
Sortie : "i"
Explication :
La seule sous-chaîne : "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, résultat[0] = 'i'.

Contraintes :

1 <= k <= 100
k <= s.length <= 1000
s.length est divisible par k.
s consiste uniquement en lettres minuscules anglaises.

Vous avez une chaîne de caractères s de longueur n et un entier k, où n est un multiple de k. Votre tâche est de hacher la chaîne s en une nouvelle chaîne appelée résultat, qui a une longueur de n / k.
Tout d'abord, divisez s en n / k sous-chaînes, chacune de longueur k. Ensuite, initialisez résultat comme une chaîne vide.
Pour chaque sous-chaîne, dans l'ordre depuis le début :

La valeur de hachage d'un caractère est l'indice de ce caractère dans l'alphabet anglais (par exemple, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Calculez la somme de toutes les valeurs de hachage des caractères de la sous-chaîne.
Trouvez le reste de cette somme quand elle est divisée par 26, appelé hashedChar.
Identifiez le caractère dans l'alphabet anglais en minuscules qui correspond à hashedChar.
Ajoutez ce caractère à la fin de résultat.

Retournez le résultat.

Exemple 1 :

Entrée : s = "abcd", k = 2
Sortie : "bf"
Explication :
Première sous-chaîne : "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Deuxième sous-chaîne : "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Exemple 2 :

Entrée : s = "mxz", k = 3
Sortie : "i"
Explication :
La seule sous-chaîne : "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

Contraintes :

1 <= k <= 100
k <= s.length <= 1000
s.length est divisible par k.
s consiste uniquement en lettres minuscules anglaises.

On vous donne une chaîne s de longueur n et un entier k, où n est un multiple de k. Votre tâche consiste à hacher la chaîne s dans une nouvelle chaîne appelée résultat, qui a une longueur de n / k.
D'abord, divisez s en n / k sous-chaînes, chacune d'une longueur de k. Ensuite, initialisez résultat comme une chaîne vide.
Pour chaque sous-chaîne dans l'ordre depuis le début :

La valeur de hachage d'un caractère est l'index de ce caractère dans l'alphabet anglais (par exemple, 'a' → 0, 'b' → 1, ..., 'z' → 25).
Calculez la somme de toutes les valeurs de hachage des caractères de la sous-chaîne.
Trouvez le reste de cette somme lorsqu'elle est divisée par 26, qui est appelée hashedChar.
Identifiez le caractère de l'alphabet minuscule anglais qui correspond à hashedChar.
Ajoutez ce caractère à la fin de résultat.

Renvoyer résultat.

Exemple 1 :

Entrée : s = "abcd", k = 2
Sortie : "bf"
Explication :
Première sous-chaîne : "ab", 0 + 1 = 1, 1 % 26 = 1, résultat[0] = 'b'.
Deuxième sous-chaîne : "cd", 2 + 3 = 5, 5 % 26 = 5, résultat[1] = 'f'.

Exemple 2 :

Entrée : s = "mxz", k = 3
Sortie : "i"
Explication :
La seule sous-chaîne : "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, résultat[0] = 'i'.

Contraintes :

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


On a deux entiers positifs n et k.
Un entier x est appelé k-palindromique si :

x est un palindrome.
x est divisible par k.

Un entier est dit bon si ses chiffres peuvent être réarrangés pour former un entier k-palindromique. Par exemple, pour k = 2, 2020 peut être réarrangé pour former l'entier k-palindromique 2002, tandis que 1010 ne peut pas être réarrangé pour former un entier k-palindromique.
Retournez le nombre d'entiers bons contenant n chiffres.
Notez qu'aucun entier ne doit avoir de zéros en tête, ni avant ni après le réarrangement. Par exemple, 1010 ne peut pas être réarrangé pour former 101.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : 27
Explication :
Certains des bons entiers sont :

551 car il peut être réarrangé pour former 515.
525 car il est déjà k-palindromique.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : 2
Explication :
Les deux bons entiers sont 4 et 8.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : 2468

Contraintes :

1 <= n <= 10
1 <= k <= 9

Vous avez deux entiers positifs n et k.
Un entier x est appelé k-palindromique si :

x est un palindrome.
x est divisible par k.

Un entier est appelé bon si ses chiffres peuvent être réarrangés pour former un entier k-palindromique. Par exemple, pour k = 2, 2020 peut être réarrangé pour former l'entier k-palindromique 2002, tandis que 1010 ne peut pas être réarrangé pour former un entier k-palindromique.
Retournez le nombre d'entiers bons contenant n chiffres.
Notez qu'aucun entier ne doit avoir de zéros initiaux, ni avant ni après le réarrangement. Par exemple, 1010 ne peut pas être réarrangé pour former 101.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : 27
Explication :
Certains des bons entiers sont :

551 car il peut être réarrangé pour former 515.
525 car il est déjà k-palindromique.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : 2
Explication :
Les deux bons entiers sont 4 et 8.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : 2468

Contraintes :

1 <= n <= 10
1 <= k <= 9

On vous donne deux entiers positifs n et k.
Un entier x est appelé k-palindromique si:

x est un palindrome.
x est divisible par k.

Un entier est considéré bon si ses chiffres peuvent être réarrangés pour former un entier k-palindromique. Par exemple, pour k = 2, 2020 peut être réarrangé pour former l'entier k-palindromique 2002, tandis que 1010 ne peut pas être réarrangé pour former un entier k-palindromique.
Renvoyez le nombre d'entiers bons contenant n chiffres.
Notez qu'aucun entier ne doit avoir de zéros initiaux, ni avant ni après le réarrangement. Par exemple, 1010 ne peut pas être réarrangé pour former 101.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : 27
Explication :
Certains des bons entiers sont :

551 car il peut être réarrangé pour former 515.
525 car il est déjà k-palindromique.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : 2
Explication :
Les deux bons entiers sont 4 et 8.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : 2468

Contraintes :

1 <= n <= 10
1 <= k <= 9


Vous disposez d'un entier power et de deux tableaux d'entiers, damage et health, chacun de longueur n.
Bob a n ennemis, où l'ennemi i infligera à Bob damage[i] points de dégâts par seconde tant qu'il est en vie (c'est-à-dire quand health[i] > 0).
Chaque seconde, après que les ennemis ont infligé des dégâts à Bob, il choisit l'un des ennemis encore en vie et lui inflige power points de dégâts.
Déterminez le montant total minimal des points de dégâts qui seront infligés à Bob avant que tous les n ennemis soient morts.

Exemple 1 :

Entrée : power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Sortie : 39
Explication :

Attaquez l'ennemi 3 dans les deux premières secondes, après quoi l'ennemi 3 tombera, le nombre de points de dégâts infligés à Bob sera de 10 + 10 = 20 points.
Attaquez l'ennemi 2 dans les deux secondes suivantes, après quoi l'ennemi 2 tombe, le nombre de points de dégâts infligés à Bob est alors de 6 + 6 = 12 points.
Attaquez l'ennemi 0 dans la seconde suivante, après quoi l'ennemi 0 tombe, le nombre de points de dégâts infligés à Bob est alors de 3 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 tombe, le nombre de points de dégâts infligés à Bob est alors de 2 + 2 = 4 points.

Exemple 2 :

Entrée : power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Sortie : 20
Explication :

Attaquez l'ennemi 0 dans la première seconde, après quoi l'ennemi 0 tombe, le nombre de points de dégâts infligés à Bob est alors de 4 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 tombe, le nombre de points de dégâts infligés à Bob est alors de 3 + 3 = 6 points.
Attaquez l'ennemi 2 dans les trois secondes suivantes, après quoi l'ennemi 2 tombe, le nombre de points de dégâts infligés à Bob est alors de 2 + 2 + 2 = 6 points.
Attaquez l'ennemi 3 dans les quatre secondes suivantes, après quoi l'ennemi 3 tombe, le nombre de points de dégâts infligés à Bob est alors de 1 + 1 + 1 + 1 = 4 points.

Exemple 3 :

Entrée : power = 8, damage = [40], health = [59]
Sortie : 320

Contraintes :

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Vous disposez d'une puissance entière et de deux tableaux d'entiers, damage et health, chacun de longueur n.
Bob a n ennemis, où l'ennemi i infligera à Bob damage[i] points de dégâts par seconde tant qu'il est en vie (c'est-à-dire que health[i] > 0).
Chaque seconde, après que les ennemis ont infligé des dégâts à Bob, il choisit l'un des ennemis encore en vie et lui inflige des points de puissance de dégâts.
Déterminez le montant total minimal des points de dégâts qui seront infligés à Bob avant que tous les n ennemis soient morts.

Exemple 1 :

Entrée : power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Sortie : 39
Explication :

Attaquez l'ennemi 3 dans les deux premières secondes, après quoi l'ennemi 3 tombera, le nombre de points de dégâts infligés à Bob est de 10 + 10 = 20 points.
Attaquez l'ennemi 2 dans les deux secondes suivantes, après quoi l'ennemi 2 tombera, le nombre de points de dégâts infligés à Bob est de 6 + 6 = 12 points.
Attaquez l'ennemi 0 dans la seconde suivante, après quoi l'ennemi 0 tombera, le nombre de points de dégâts infligés à Bob est de 3 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 tombera, le nombre de points de dégâts infligés à Bob est de 2 + 2 = 4 points.

Exemple 2 :

Entrée : power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Sortie : 20
Explication :

Attaquez l'ennemi 0 dans la première seconde, après quoi l'ennemi 0 tombera, le nombre de points de dégâts infligés à Bob est de 4 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 tombera, le nombre de points de dégâts infligés à Bob est de 3 + 3 = 6 points.
Attaquez l'ennemi 2 dans les trois secondes suivantes, après quoi l'ennemi 2 tombera, le nombre de points de dégâts infligés à Bob est de 2 + 2 + 2 = 6 points.
Attaquez l'ennemi 3 dans les quatre secondes suivantes, après quoi l'ennemi 3 tombera, le nombre de points de dégâts infligés à Bob est de 1 + 1 + 1 + 1 = 4 points.

Exemple 3 :

Entrée : power = 8, damage = [40], health = [59]
Sortie : 320

Contraintes :

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

On vous donne une puissance entière et deux tableaux entiers dommages et santé, tous deux ayant une longueur n.
Bob a n ennemis, où ennemi, l'ennemi i infligera à Bob [i] points de dégâts par seconde pendant qu'ils sont en vie (c'est-à-dire la santé [i]> 0).
Chaque seconde, après que les ennemis aient infligé des dégâts à Bob, il choisit l'un des ennemis qui est toujours en vie et et lui inflige [power] points de dégâts.
Déterminez la quantité totale minimale de points de dégâts qui seront traités à Bob avant que tous les n ennemis ne soient morts.

Exemple 1:

Entrée: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Sortie: 39
Explication:

Attaquez l'ennemi 3 dans les deux premières secondes, après quoi l'ennemi 3 sera vaincu, le nombre de points de dégâts infligés à Bob est de 10 + 10 = 20 points.
Attaquez l'ennemi 2 dans les deux secondes suivantes, après quoi l'ennemi 2 baissera, le nombre de points de dégâts infligés à Bob est de 6 + 6 = 12 points.
Attaquez l'ennemi 0 dans la seconde suivante, après quoi l'ennemi 0 baissera, le nombre de points de dégâts infligés à Bob est de 3 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 baissera, le nombre de points de dégâts infligés à Bob est de 2 + 2 = 4 points.

Exemple 2:

Entrée: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Sortie: 20
Explication:

Attaquez l'ennemi 0 dans la première seconde, après quoi l'ennemi 0 baissera, le nombre de points de dégâts infligés à Bob est de 4 points.
Attaquez l'ennemi 1 dans les deux secondes suivantes, après quoi l'ennemi 1 baissera, le nombre de points de dégâts infligés à Bob est de 3 + 3 = 6 points.
Attaquez l'ennemi 2 dans les trois secondes suivantes, après quoi l'ennemi 2 baissera, le nombre de points de dégâts infligés à Bob est de 2 + 2 + 2 = 6 points.
Attaquez l'ennemi 3 dans les quatre secondes suivantes, après quoi l'ennemi 3 baissera, le nombre de points de dégâts infligés à Bob est de 1 + 1 + 1 + 1 = 4 points.

Exemple 3:

Entrée: power = 8, damage = [40], health = [59]
Sortie: 320

Contraintes:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


On vous donne une matrice binaire m x n appelée grid et un entier health.
Vous commencez dans le coin supérieur gauche (0, 0) et souhaitez atteindre le coin inférieur droit (m - 1, n - 1).
Vous pouvez vous déplacer vers le haut, le bas, la gauche ou la droite d'une cellule à une autre cellule adjacente tant que votre santé reste positive.
Les cellules (i, j) avec grid[i][j] = 1 sont considérées comme dangereuses et réduisent votre santé de 1.
Retournez true si vous pouvez atteindre la cellule finale avec une valeur de santé de 1 ou plus, et false sinon.

Exemple 1 :

Entrée : grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Sortie : true
Explication :
La cellule finale peut être atteinte en toute sécurité en marchant le long des cellules grises ci-dessous.

Exemple 2 :

Entrée : grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Sortie : false
Explication :
Un minimum de 4 points de santé est nécessaire pour atteindre la cellule finale en toute sécurité.

Exemple 3 :

Entrée : grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Sortie : true
Explication :
La cellule finale peut être atteinte en toute sécurité en marchant le long des cellules grises ci-dessous.

Tout chemin qui ne passe pas par la cellule (1, 1) est dangereux car votre santé tombera à 0 en atteignant la cellule finale.

Contraintes :

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] est soit 0, soit 1.

On vous donne une matrice binaire m x n appelée grid et un entier health.

Vous commencez dans le coin supérieur gauche (0, 0) et souhaitez atteindre le coin inférieur droit (m - 1, n - 1).

Vous pouvez vous déplacer vers le haut, le bas, la gauche ou la droite d'une cellule à une autre cellule adjacente tant que votre santé reste positive.

Les cellules (i, j) avec grid[i][j] = 1 sont considérées comme dangereuses et réduisent votre santé de 1.

Retournez true si vous pouvez atteindre la cellule finale avec une valeur de santé de 1 ou plus, et false sinon.

Exemple 1:

Entrée: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1

Sortie: true

Explication:

La cellule finale peut être atteinte en toute sécurité en marchant le long des cellules grises ci-dessous.

Exemple 2:

Entrée: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3

Sortie: false

Explication:

Un minimum de 4 points de santé est nécessaire pour atteindre la cellule finale en toute sécurité.

Exemple 3:

Entrée: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5

Sortie: true

Explication:

La cellule finale peut être atteinte en toute sécurité en marchant le long des cellules grises ci-dessous.

Tout chemin qui ne passe pas par la cellule (1, 1) est dangereux car votre santé tombera à 0 en atteignant la cellule finale.

Contraintes:

m == grid.length

n == grid[i].length

1 <= m, n <= 50

2 <= m * n

1 <= health <= m + n

grid[i][j] est soit 0, soit 1.

On vous donne une grille de matrice binaire m x n et une santé entière.
Vous commencez dans le coin supérieur gauche (0, 0) et souhaitez atteindre le coin inférieur droit (m - 1, n - 1).
Vous pouvez vous déplacer vers le haut, le bas, la gauche ou la droite d'une cellule à une autre cellule adjacente tant que votre santé reste positive.
Les cellules (i, j) avec grid[i][j] = 1 sont considérées comme dangereuses et réduisent votre santé de 1.
Renvoyez true si vous pouvez atteindre la cellule finale avec une valeur de santé de 1 ou plus, et false sinon.

Exemple 1 :

Entrée : grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Sortie : true
Explication :
La dernière cellule peut être atteinte en toute sécurité en marchant le long des cellules grises ci-dessous.

Exemple 2 :

Entrée : grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Sortie : false
Explication :
Un minimum de 4 points de santé est nécessaire pour atteindre la dernière cellule en toute sécurité.

Exemple 3 :

Entrée : grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Sortie : true
Explication :
La dernière cellule peut être atteinte en toute sécurité en longeant les cellules grises ci-dessous.

Tout chemin qui ne passe pas par la cellule (1, 1) est dangereux puisque votre santé tombera à 0 lorsque vous atteindrez la dernière cellule.

Contraintes :

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] est soit 0, soit 1.


Vous avez un tableau d'entiers `nums` et un entier positif `k`.
La valeur d'une séquence `seq` de taille `2 * x` est définie comme :

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Retournez la valeur maximale de toute sous-séquence de `nums` de taille `2 * k`.

Exemple 1 :

Entrée : `nums = [2,6,7], k = 1`
Sortie : `5`
Explication :
La sous-séquence `[2, 7]` a la valeur maximale de `2 XOR 7 = 5`.

Exemple 2 :

Entrée : `nums = [4,2,5,6,7], k = 2`
Sortie : `2`
Explication :
La sous-séquence `[4, 5, 6, 7]` a la valeur maximale de `(4 OR 5) XOR (6 OR 7) = 2`.

Contraintes :

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Vous avez un tableau d'entiers nums et un entier positif k.
La valeur d'une séquence seq de taille 2 * x est définie comme :

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Retournez la valeur maximale de toute sous-séquence de nums de taille 2 * k.

Exemple 1 :

Entrée : nums = [2,6,7], k = 1
Sortie : 5
Explication :
La sous-séquence [2, 7] a la valeur maximale de 2 XOR 7 = 5.

Exemple 2 :

Entrée : nums = [4,2,5,6,7], k = 2
Sortie : 2
Explication :
La sous-séquence [4, 5, 6, 7] a la valeur maximale de (4 OR 5) XOR (6 OR 7) = 2.

Contraintes :

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

On vous donne un tableau d'entiers nums et un entier positif k.
La valeur d'une séquence seq de taille 2 * x est définie comme suit :

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Renvoie la valeur maximale de toute sous-séquence de nums de taille 2 * k.

Exemple 1 :

Entrée : nums = [2,6,7], k = 1
Sortie : 5
Explication :
La sous-séquence [2, 7]a la valeur maximale de 2 XOR 7 = 5.

Exemple 2 :

Entrée : nums = [4,2,5,6,7], k = 2
Sortie : 2
Explication :
La sous-séquence [4, 5, 6, 7] a la valeur maximale de (4 OR 5) XOR (6 OR 7) = 2.

Contraintes :

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


On vous donne un tableau 2D d'entiers coordinates de longueur n et un entier k, où 0 <= k < n.
coordinates[i] = [x_i, y_i] indique le point (x_i, y_i) dans un plan 2D.
Un chemin croissant de longueur m est défini comme une liste de points (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) telle que :

x_i < x_i + 1 et y_i < y_i + 1 pour tout i où 1 <= i < m.
(x_i, y_i) est dans les coordonnées données pour tout i où 1 <= i <= m.

Retournez la longueur maximale d'un chemin croissant qui contient coordinates[k].

Exemple 1 :

Entrée : coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Sortie : 3
Explication :
(0, 0), (2, 2), (5, 3) est le plus long chemin croissant qui contient (2, 2).

Exemple 2 :

Entrée : coordinates = [[2,1],[7,0],[5,6]], k = 2
Sortie : 2
Explication :
(2, 1), (5, 6) est le plus long chemin croissant qui contient (5, 6).

Contraintes :

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Tous les éléments de coordinates sont distincts.
0 <= k <= n - 1

On donne un tableau 2D d'entiers coordinates de longueur n et un entier k, où 0 <= k < n.
coordinates[i] = [x_i, y_i] indique le point (x_i, y_i) dans un plan 2D.
Un chemin croissant de longueur m est défini comme une liste de points (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) telle que :

x_i < x_i + 1 et y_i < y_i + 1 pour tout i où 1 <= i < m.
(x_i, y_i) est dans les coordonnées données pour tout i où 1 <= i <= m.

Retournez la longueur maximale d'un chemin croissant qui contient coordinates[k].

Exemple 1 :

Entrée : coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Sortie : 3
Explication :
(0, 0), (2, 2), (5, 3) est le plus long chemin croissant qui contient (2, 2).

Exemple 2 :

Entrée : coordinates = [[2,1],[7,0],[5,6]], k = 2
Sortie : 2
Explication :
(2, 1), (5, 6) est le plus long chemin croissant qui contient (5, 6).

Contraintes :

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Tous les éléments de coordinates sont distincts.
0 <= k <= n - 1

On vous donne un tableau 2D de coordonnées entières de longueur n et un entier k, où 0 <= k < n.
coordonnées[i] = [x_i, y_i] indique le point (x_i, y_i) dans un plan 2D.
Un chemin croissant de longueur m est défini comme une liste de points (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) tels que :

x_i < x_i + 1 et y_i < y_i + 1 pour tout i où 1 <= i < m.
(x_i, y_i) est dans les coordonnées données pour tout i où 1 <= i <= m.

Renvoie la longueur maximale d'un chemin croissant qui contient les coordonnées[k].

Exemple 1 :

Entrée : coordonnées = [[3,1], [2,2], [4,1], [0,0], [5,3]], k = 1
Sortie : 3
Explication :
(0, 0), (2, 2), (5, 3) est le plus long chemin croissant qui contient (2, 2).

Exemple 2 :

Entrée : coordonnées = [[2,1], [7,0], [5,6]], k = 2
Sortie : 2
Explication :
(2, 1), (5, 6) est le plus long chemin croissant qui contient (5, 6).

Contraintes :

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Tous les éléments des coordonnées sont distincts.
0 <= k <= n - 1


On vous donne un tableau de chaînes de caractères message et un tableau de chaînes de caractères bannedWords.
Un tableau de mots est considéré comme spam s'il contient au moins deux mots qui correspondent exactement à un mot dans bannedWords.
Retournez true si le tableau message est du spam, sinon false.

Exemple 1 :

Entrée : message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Sortie : true
Explication :
Les mots "hello" et "world" du tableau message apparaissent tous deux dans le tableau bannedWords.

Exemple 2 :

Entrée : message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Sortie : false
Explication :
Un seul mot du tableau message ("programming") apparaît dans le tableau bannedWords.

Contraintes :

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] et bannedWords[i] ne contiennent que des lettres minuscules anglaises.

On vous donne un tableau de chaînes message et un tableau de chaînes forbiddenWords.
Un tableau de mots est considéré comme du spam s'il contient au moins deux mots qui correspondent exactement à n'importe quel mot de forbiddenWords.
Renvoie true si le tableau message est du spam, et false sinon.

Exemple 1 :

Entrée : message = ["hello","world","leetcode"], forbiddenWords = ["world","hello"]
Sortie : true
Explication :
Les mots "hello" et "world" du tableau message apparaissent tous les deux dans le tableau forbiddenWords.

Exemple 2 :

Entrée : message = ["hello","programming","fun"], forbiddenWords = ["world","programming","leetcode"]
Sortie : false
Explication :
Un seul mot du tableau message ("programming") apparaît dans le tableau forbiddenWords.

Contraintes :

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] et bannedWords[i] ne contiennent que des lettres minuscules anglaises.

On vous donne un tableau de chaînes de caractères message et un tableau de chaînes de caractères bannedWords.
Un tableau de mots est considéré comme spam s'il contient au moins deux mots qui correspondent exactement à un mot dans bannedWords.
Retournez true si le tableau message est du spam, sinon false.

Exemple 1 :

Input: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Output: true
Explication :
Les mots "hello" et "world" du tableau message apparaissent tous deux dans le tableau bannedWords.

Exemple 2 :

Input: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Output: false
Explication :
Un seul mot du tableau message ("programming") apparaît dans le tableau bannedWords.

Contraintes :

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] et bannedWords[i] ne contiennent que des lettres minuscules anglaises.


Vous disposez d'un entier mountainHeight représentant la hauteur d'une montagne.
Vous disposez également d'un tableau d'entiers workerTimes représentant le temps de travail des ouvriers en secondes.
Les ouvriers travaillent simultanément pour réduire la hauteur de la montagne. Pour l'ouvrier i :

Pour diminuer la hauteur de la montagne de x, il faut workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x secondes. Par exemple :

Pour réduire la hauteur de la montagne de 1, il faut workerTimes[i] secondes.
Pour réduire la hauteur de la montagne de 2, il faut workerTimes[i] + workerTimes[i] * 2 secondes, et ainsi de suite.

Retournez un entier représentant le nombre minimum de secondes nécessaires pour que les ouvriers ramènent la hauteur de la montagne à 0.

Exemple 1 :

Entrée : mountainHeight = 4, workerTimes = [2,1,1]
Sortie : 3
Explication :
Une façon de réduire la hauteur de la montagne à 0 est :

L'ouvrier 0 réduit la hauteur de 1, ce qui prend workerTimes[0] = 2 secondes.
L'ouvrier 1 réduit la hauteur de 2, ce qui prend workerTimes[1] + workerTimes[1] * 2 = 3 secondes.
L'ouvrier 2 réduit la hauteur de 1, ce qui prend workerTimes[2] = 1 seconde.

Puisqu'ils travaillent simultanément, le temps minimum nécessaire est max(2, 3, 1) = 3 secondes.

Exemple 2 :

Entrée : mountainHeight = 10, workerTimes = [3,2,2,4]
Sortie : 12
Explication :

L'ouvrier 0 réduit la hauteur de 2, ce qui prend workerTimes[0] + workerTimes[0] * 2 = 9 secondes.
L'ouvrier 1 réduit la hauteur de 3, ce qui prend workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 secondes.
L'ouvrier 2 réduit la hauteur de 3, ce qui prend workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 secondes.
L'ouvrier 3 réduit la hauteur de 2, ce qui prend workerTimes[3] + workerTimes[3] * 2 = 12 secondes.

Le nombre de secondes nécessaires est max(9, 12, 12, 12) = 12 secondes.

Exemple 3 :

Entrée : mountainHeight = 5, workerTimes = [1]
Sortie : 15
Explication :
Il n'y a qu'un seul ouvrier dans cet exemple, donc la réponse est workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Contraintes :

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

On vous donne un entier mountainHeight représentant la hauteur d'une montagne.
On vous donne également un tableau d'entiers workerTimes représentant le temps de travail des ouvriers en secondes.
Les ouvriers travaillent simultanément pour réduire la hauteur de la montagne. Pour l'ouvrier i :

Pour réduire la hauteur de la montagne de x, il faut workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x secondes. Par exemple :

Pour réduire la hauteur de la montagne de 1, cela prend workerTimes[i] secondes.
Pour réduire la hauteur de la montagne de 2, il faut workerTimes[i] + workerTimes[i] * 2 secondes, et ainsi de suite.

Retourne un entier représentant le nombre minimum de secondes nécessaires aux ouvriers pour que la hauteur de la montagne soit égale à 0.

Exemple 1 :

Entrée : mountainHeight = 4, workerTimes = [2,1,1]
Sortie : 3
Explication :
La hauteur de la montagne peut être ramenée à 0 de l'une des façons suivantes : le ouvrier 0 réduit la hauteur de 1:

Le ouvrier 0 réduit la hauteur de 1, ce qui prend workerTimes[0] = 2 secondes.
Le ouvrier 1 réduit la hauteur de 2, ce qui prend workerTimes[1] + workerTimes[1] * 2 = 3 secondes.
Le ouvrier 2 réduit la hauteur de 1, ce qui prend workerTimes[2] = 1 seconde.

Comme ils travaillent simultanément, le temps minimum nécessaire est max(2, 3, 1) = 3 secondes.

Exemple 2 :

Entrée : mountainHeight = 10, workerTimes = [3,2,2,4]
Sortie : 12
Explication :

Le ouvrier 0 réduit la hauteur de 2, ce qui prend workerTimes[0] + workerTimes[0] * 2 = 9 secondes.
L'ouvrier 1 réduit la hauteur de 3, en prenant workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 secondes.
L'ouvrier 2 réduit la hauteur de 3, en prenant workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 secondes.
L'ouvrier 3 réduit la hauteur de 2, ce qui prend workerTimes[3] + workerTimes[3] * 2 = 12 secondes.

Le nombre de secondes nécessaires est max(9, 12, 12, 12) = 12 secondes.

Exemple 3 :

Entrée : mountainHeight = 5, workerTimes = [1]
Sortie : 15
Explication :
Il n'y a qu'un seul ouvrier dans cet exemple, la réponse est donc workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Contraintes :

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

On vous donne un entier mountainHeight représentant la hauteur d'une montagne.
On vous donne également d'un tableau d'entiers workerTimes représentant le temps de travail des ouvriers en secondes.
Les ouvriers travaillent simultanément pour réduire la hauteur de la montagne. Pour l'ouvrier i :

Pour diminuer la hauteur de la montagne de x, il faut workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x secondes. Par exemple :

Pour réduire la hauteur de la montagne de 1, il faut workerTimes[i] secondes.
Pour réduire la hauteur de la montagne de 2, il faut workerTimes[i] + workerTimes[i] * 2 secondes, et ainsi de suite.

Renvoyez un entier représentant le nombre minimum de secondes nécessaires pour que les ouvriers ramènent la hauteur de la montagne à 0.

Exemple 1 :

Entrée : mountainHeight = 4, workerTimes = [2,1,1]
Sortie : 3
Explication :
Une façon de réduire la hauteur de la montagne à 0 est :

L'ouvrier 0 réduit la hauteur de 1, prenant workerTimes[0] = 2 secondes.
L'ouvrier 1 réduit la hauteur de 2, prenant workerTimes[1] + workerTimes[1] * 2 = 3 secondes.
L'ouvrier 2 réduit la hauteur de 1, prenant workerTimes[2] = 1 seconde.

Puisqu'ils travaillent simultanément, le temps minimum nécessaire est max(2, 3, 1) = 3 secondes.

Exemple 2 :

Entrée : mountainHeight = 10, workerTimes = [3,2,2,4]
Sortie : 12
Explication :

L'ouvrier 0 réduit la hauteur de 2, prenant workerTimes[0] + workerTimes[0] * 2 = 9 secondes.
L'ouvrier 1 réduit la hauteur de 3, prenant workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 secondes.
L'ouvrier 2 réduit la hauteur de 3, prenant workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 secondes.
L'ouvrier 3 réduit la hauteur de 2, prenant workerTimes[3] + workerTimes[3] * 2 = 12 secondes.

Le nombre de secondes nécessaires est max(9, 12, 12, 12) = 12 secondes.

Exemple 3 :

Entrée : mountainHeight = 5, workerTimes = [1]
Sortie : 15
Explication :
Il n'y a qu'un seul ouvrier dans cet exemple, donc la réponse est workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Contraintes :

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6


On vous donne deux chaînes de caractères word1 et word2.
Une chaîne x est dite valide si x peut être réarrangée pour avoir word2 comme préfixe.
Retournez le nombre total de sous-chaînes valides de word1.

Exemple 1 :

Entrée : word1 = "bcca", word2 = "abc"
Sortie : 1
Explication :
La seule sous-chaîne valide est "bcca" qui peut être réarrangée en "abcc" ayant "abc" comme préfixe.

Exemple 2 :

Entrée : word1 = "abcabc", word2 = "abc"
Sortie : 10
Explication :
Toutes les sous-chaînes sauf celles de taille 1 et taille 2 sont valides.

Exemple 3 :

Entrée : word1 = "abcabc", word2 = "aaabc"
Sortie : 0

Contraintes :

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 et word2 sont composés uniquement de lettres minuscules anglaises.

On vous donne deux chaînes de caractères word1 et word2.
Une chaîne x est dite valide si x peut être réorganisée pour avoir word2 comme préfixe.
Retournez le nombre total de sous-chaînes valides de word1.

Exemple 1 :

Entrée : word1 = "bcca", word2 = "abc"
Sortie : 1
Explication :
La seule sous-chaîne valide est "bcca" qui peut être réarrangée en "abcc" ayant "abc" comme préfixe.

Exemple 2 :

Entrée : word1 = "abcabc", word2 = "abc"
Sortie : 10
Explication :
Toutes les sous-chaînes sauf celles de taille 1 et taille 2 sont valides.

Exemple 3 :

Entrée : word1 = "abcabc", word2 = "aaabc"
Sortie : 0

Contraintes :

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 et word2 sont composés uniquement de lettres minuscules anglaises.

On vous donne deux chaînes word1 et word2.
Une chaîne x est dite valide si x peut être réorganisée pour avoir word2 comme préfixe.
Renvoie le nombre total de sous-chaînes valides de word1.

Exemple 1 :

Entrée : word1 = "bcca", word2 = "abc"
Sortie : 1
Explication :
La seule sous-chaîne valide est "bcca" qui peut être réorganisée en "abcc" avec "abc" comme préfixe.

Exemple 2 :

Entrée : word1 = "abcabc", word2 = "abc"
Sortie : 10
Explication :
Toutes les sous-chaînes, à l'exception des sous-chaînes de taille 1 et de taille 2, sont valides.

Exemple 3 :

Entrée : word1 = "abcabc", word2 = "aaabc"
Sortie : 0

Contraintes :

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 et word2 sont composés uniquement de lettres minuscules anglaises.


Alice et Bob jouent à un jeu. Initialement, Alice a une chaîne word = "a".
On vous donne un entier positif k.
Maintenant, Bob demandera à Alice de réaliser l'opération suivante indéfiniment :

Générer une nouvelle chaîne en changeant chaque caractère de word en son caractère suivant dans l'alphabet anglais et l'ajouter à la chaîne d'origine.

Par exemple, effectuer l'opération sur "c" génère "cd" et effectuer l'opération sur "zb" génère "zbac".
Retournez la valeur du k^ème caractère dans word, après avoir effectué suffisamment d'opérations pour que word ait au moins k caractères.
Notez que le caractère 'z' peut être changé en 'a' lors de l'opération.

Exemple 1 :

Entrée : k = 5
Sortie : "b"
Explication :
Initialement, word = "a". Nous devons effectuer l'opération trois fois :

La chaîne générée est "b", word devient "ab".
La chaîne générée est "bc", word devient "abbc".
La chaîne générée est "bccd", word devient "abbcbccd".

Exemple 2 :

Entrée : k = 10
Sortie : "c"

Contraintes :

1 <= k <= 500

Alice et Bob jouent à un jeu. Au départ, Alice a une chaîne word = "a".
On vous donne un entier positif k.
Maintenant Bob va demander à Alice d'effectuer l'opération suivante indéfiniment :

Générer une nouvelle chaîne en remplaçant chaque caractère de word par son caractère suivant dans l'alphabet anglais, et l'ajouter au mot d'origine.

Par exemple, effectuer l'opération sur "c" génère "cd" et effectuer l'opération sur "zb" génère "zbac".
Renvoyer la valeur du k^ième caractère de word, après avoir effectué suffisamment d'opérations pour que word ait au moins k caractères.
Notez que le caractère 'z' peut être remplacé par 'a' dans l'opération.

Exemple 1 :

Entrée : k = 5
Sortie : "b"
Explication :
Au départ, word = "a". Nous devons effectuer l'opération trois fois :

La chaîne générée est "b", word devient "ab".
La chaîne générée est "bc", word devient "abbc".
La chaîne générée est « bccd », le mot devient "abbcbccd".

Exemple 2 :

Entrée : k = 10
Sortie : "c"

Contraintes :

1 <= k <= 500


On vous donne une chaîne de caractères "word" et un entier non négatif k.
Retournez le nombre total de sous-chaînes de "word" qui contiennent chaque voyelle ('a', 'e', 'i', 'o', et 'u') au moins une fois et exactement k consonnes.

Exemple 1 :

Entrée : word = "aeioqq", k = 1
Sortie : 0
Explication :
Il n'y a pas de sous-chaîne avec chaque voyelle.

Exemple 2 :

Entrée : word = "aeiou", k = 0
Sortie : 1
Explication :
La seule sous-chaîne avec chaque voyelle et zéro consonne est word[0..4], qui est "aeiou".

Exemple 3 :

Entrée : word = "ieaouqqieaouqq", k = 1
Sortie : 3
Explication :
Les sous-chaînes avec chaque voyelle et une consonne sont :

word[0..5], qui est "ieaouq".
word[6..11], qui est "qieaou".
word[7..12], qui est "ieaouq".

Contraintes :

5 <= word.length <= 250
word est constitué uniquement de lettres minuscules anglaises.
0 <= k <= word.length - 5

On vous donne un mot et un entier non négatif k.
Renvoie le nombre total de sous-chaînes du mot contenant chaque voyelle ('a', 'e', 'i', 'o' et 'u') au moins une fois et exactement k consonnes.

Exemple 1:

Entrée: word = "aeioqq", k = 1
Sortie: 0
Explication:
Il n'y a pas de sous-chaîne contenant chaque voyelle.

Exemple 2:

Entrée: word = "aeiou", k = 0
Sortie: 1
Explication:
La seule sous-chaîne contenant chaque voyelle et zéro consonne est word[0..4], qui est "aeiou".

Exemple 3:

Entrée: word = "ieaouqqieaouqq", k = 1
Sortie: 3
Explication:
Les sous-chaînes contenant chaque voyelle et une consonne:

Word [0..5], qui est "ieaouq".
Word [6..11], qui est "qieaou".
Word [7..12], qui est "ieaouq".

Contraintes:

5 <= word.length <= 250
Le mot ne se compose que de lettres anglaises minuscules.
0 <= k <= word.length - 5

Vous avez une chaîne de caractères word et un entier non négatif k.
Retournez le nombre total de sous-chaînes de word qui contiennent chaque voyelle ('a', 'e', 'i', 'o', et 'u') au moins une fois et exactement k consonnes.

Exemple 1 :

Entrée : word = "aeioqq", k = 1
Sortie : 0
Explication :
Il n'y a pas de sous-chaîne avec chaque voyelle.

Exemple 2 :

Entrée : word = "aeiou", k = 0
Sortie : 1
Explication :
La seule sous-chaîne avec chaque voyelle et zéro consonne est word[0..4], qui est "aeiou".

Exemple 3 :

Entrée : word = "ieaouqqieaouqq", k = 1
Sortie : 3
Explication :
Les sous-chaînes avec chaque voyelle et une consonne sont :

word[0..5], qui est "ieaouq".
word[6..11], qui est "qieaou".
word[7..12], qui est "ieaouq".

Contraintes :

5 <= word.length <= 250
word est constitué uniquement de lettres minuscules anglaises.
0 <= k <= word.length - 5


On vous donne un tableau d'entiers nums de taille 3.
Retournez le nombre maximum possible dont la représentation binaire peut être formée en concaténant la représentation binaire de tous les éléments de nums dans un certain ordre.
Notez que la représentation binaire de tout nombre ne contient pas de zéros initiaux.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 30
Explication :
Concaténer les nombres dans l'ordre [3, 1, 2] pour obtenir le résultat "11110", qui est la représentation binaire de 30.

Exemple 2 :

Entrée : nums = [2,8,16]
Résultat : 1296
Explication :
Concaténer les nombres dans l'ordre [2, 8, 16] pour obtenir le résultat"10100010000", qui est la représentation binaire de 1296.

Contraintes :

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

On donne un tableau d'entiers nums de taille 3.
Retournez le plus grand nombre possible dont la représentation binaire peut être formée en concaténant les représentations binaires de tous les éléments de nums dans un ordre quelconque.
Notez que la représentation binaire de tout nombre ne contient pas de zéros en tête.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 30
Explication :
Concaténez les nombres dans l'ordre [3, 1, 2] pour obtenir le résultat "11110", qui est la représentation binaire de 30.

Exemple 2 :

Entrée : nums = [2,8,16]
Sortie : 1296
Explication :
Concaténez les nombres dans l'ordre [2, 8, 16] pour obtenir le résultat "10100010000", qui est la représentation binaire de 1296.

Contraintes :

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

Vous avez un tableau d'entiers nums de taille 3.
Retournez le nombre maximum possible dont la représentation binaire peut être formée en concaténant la représentation binaire de tous les éléments de nums dans un certain ordre.
Notez que la représentation binaire de tout nombre ne contient pas de zéros en tête.

Exemple 1 :

Entrée : nums = [1,2,3]
Sortie : 30
Explication :
Concaténez les nombres dans l'ordre [3, 1, 2] pour obtenir le résultat "11110", qui est la représentation binaire de 30.

Exemple 2 :

Entrée : nums = [2,8,16]
Sortie : 1296
Explication :
Concaténez les nombres dans l'ordre [2, 8, 16] pour obtenir le résultat "10100010000", qui est la représentation binaire de 1296.

Contraintes :

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


On vous donne un tableau d'entiers nums de longueur n et un tableau d'entiers queries.
Soit gcdPairs un tableau obtenu en calculant le PGCD de toutes les paires possibles (nums[i], nums[j]), où 0 <= i < j < n, puis en triant ces valeurs par ordre croissant.
Pour chaque requête queries[i], vous devez trouver l'élément à l'indice queries[i] dans gcdPairs.
Retournez un tableau d'entiers answer, où answer[i] est la valeur de gcdPairs[queries[i]] pour chaque requête.
Le terme gcd(a, b) désigne le plus grand diviseur commun de a et b.

Exemple 1 :

Entrée : nums = [2,3,4], queries = [0,2,2]
Sortie : [1,2,2]
Explication :
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Après tri par ordre croissant, gcdPairs = [1, 1, 2].
Donc, la réponse est [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Exemple 2 :

Entrée : nums = [4,4,2,1], queries = [5,3,1,0]
Sortie : [4,2,1,1]
Explication :
gcdPairs trié par ordre croissant est [1, 1, 1, 2, 2, 4].

Exemple 3 :

Entrée : nums = [2,2], queries = [0,0]
Sortie : [2,2]
Explication :
gcdPairs = [2].

Contraintes :

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Vous avez un tableau d'entiers nums de longueur n et un tableau d'entiers queries.
Soit gcdPairs un tableau obtenu en calculant le PGCD de toutes les paires possibles (nums[i], nums[j]), où 0 <= i < j < n, puis en triant ces valeurs par ordre croissant.
Pour chaque requête queries[i], vous devez trouver l'élément à l'indice queries[i] dans gcdPairs.
Retournez un tableau d'entiers answer, où answer[i] est la valeur de gcdPairs[queries[i]] pour chaque requête.
Le terme gcd(a, b) désigne le plus grand diviseur commun de a et b.

Exemple 1 :

Entrée : nums = [2,3,4], queries = [0,2,2]
Sortie : [1,2,2]
Explication :
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Après tri par ordre croissant, gcdPairs = [1, 1, 2].
Donc, la réponse est [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Exemple 2 :

Entrée : nums = [4,4,2,1], queries = [5,3,1,0]
Sortie : [4,2,1,1]
Explication :
gcdPairs trié par ordre croissant est [1, 1, 1, 2, 2, 4].

Exemple 3 :

Entrée : nums = [2,2], queries = [0,0]
Sortie : [2,2]
Explication :
gcdPairs = [2].

Contraintes :

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

On donne un tableau d'entiers nums de longueur n et un tableau d'entiers queries.
Soit gcdPairs un tableau obtenu en calculant le PGCD de toutes les paires possibles (nums[i], nums[j]), où 0 <= i < j < n, puis en triant ces valeurs par ordre croissant.
Pour chaque requête queries[i], vous devez trouver l'élément à l'indice queries[i] dans gcdPairs.
Retournez un tableau d'entiers answer, où answer[i] est la valeur de gcdPairs[queries[i]] pour chaque requête.
Le terme gcd(a, b) désigne le plus grand diviseur commun de a et b.

Exemple 1 :

Entrée : nums = [2,3,4], queries = [0,2,2]
Sortie : [1,2,2]
Explication :
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Après tri par ordre croissant, gcdPairs = [1, 1, 2].
Donc, la réponse est [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Exemple 2 :

Entrée : nums = [4,4,2,1], queries = [5,3,1,0]
Sortie : [4,2,1,1]
Explication :
gcdPairs trié par ordre croissant est [1, 1, 1, 2, 2, 4].

Exemple 3 :

Entrée : nums = [2,2], queries = [0,0]
Sortie : [2,2]
Explication :
gcdPairs = [2].

Contraintes :

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2


On vous donne un tableau d'entiers `nums`.
Vous remplacez chaque élément de `nums` par la somme de ses chiffres.
Renvoyez l'élément minimum dans `nums` après tous les remplacements.

Exemple 1 :

Entrée : nums = [10,12,13,14]
Sortie : 1
Explication :
`nums` devient [1, 3, 4, 5] après tous les remplacements, avec l'élément minimum 1.

Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : 1
Explication :
`nums` devient [1, 2, 3, 4] après tous les remplacements, avec l'élément minimum 1.

Exemple 3 :

Entrée : nums = [999,19,199]
Sortie : 10
Explication :
`nums` devient [27, 10, 19] après tous les remplacements, avec l'élément minimum 10.

Contraintes :

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

Vous avez un tableau d'entiers nums.
Vous remplacez chaque élément de nums par la somme de ses chiffres.
Retournez l'élément minimum dans nums après tous les remplacements.

Exemple 1 :

Entrée : nums = [10,12,13,14]
Sortie : 1
Explication :
nums devient [1, 3, 4, 5] après tous les remplacements, avec l'élément minimum 1.

Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : 1
Explication :
nums devient [1, 2, 3, 4] après tous les remplacements, avec l'élément minimum 1.

Exemple 3 :

Entrée : nums = [999,19,199]
Sortie : 10
Explication :
nums devient [27, 10, 19] après tous les remplacements, avec l'élément minimum 10.

Contraintes :

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

Vous avez un tableau d'entiers nums.
Vous remplacez chaque élément de nums par la somme de ses chiffres.
Retournez l'élément minimum dans nums après tous les remplacements.

Exemple 1:

Entrée: nums = [10,12,13,14]
Sortie: 1
Explication:
nums devient [1, 3, 4, 5] après tous les remplacements, avec l'élément minimum 1.

Exemple 2:

Entrée: nums = [1,2,3,4]
Sortie: 1
Explication:
nums devient [1, 2, 3, 4] après tous les remplacements, avec l'élément minimum 1.

Exemple 3:

Entrée: nums = [999,19,199]
Sortie: 10
Explication:
nums devient [27, 10, 19] après tous les remplacements, avec l'élément minimum 10.

Contraintes:

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


On a un tableau maximumHeight, où maximumHeight[i] désigne la hauteur maximale qui peut être attribuée à la i-ème tour.
Votre tâche est d'attribuer une hauteur à chaque tour de sorte que :

La hauteur de la i-ème tour soit un entier positif et ne dépasse pas maximumHeight[i].
Deux tours ne peuvent pas avoir la même hauteur.

Retournez la somme totale maximale possible des hauteurs des tours. S'il n'est pas possible d'attribuer des hauteurs, retournez -1.

Exemple 1 :

Entrée : maximumHeight = [2,3,4,3]
Sortie : 10
Explication :
Nous pouvons attribuer des hauteurs de la manière suivante : [1, 2, 4, 3].

Exemple 2 :

Entrée : maximumHeight = [15,10]
Sortie : 25
Explication :
Nous pouvons attribuer des hauteurs de la manière suivante : [15, 10].

Exemple 3 :

Entrée : maximumHeight = [2,2,1]
Sortie : -1
Explication :
Il est impossible d'attribuer des hauteurs positives à chaque indice afin que deux tours ne puissent pas avoir la même hauteur.

Contraintes :

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

On vous donne un tableau maximumHeight, où maximumHeight[i] désigne la hauteur maximale à laquelle la i^ème tour peut être assignée.
Votre tâche consiste à assigner une hauteur à chaque tour de sorte que :

La hauteur de la i^ème tour soit un entier positif et ne dépasse pas maximumHeight[i].
Il n'y a pas deux tours ayant la même hauteur.

Renvoie la somme totale maximale possible des hauteurs des tours. S'il n'est pas possible d'assigner des hauteurs, renvoie -1.

Exemple 1 :

Entrée : maximumHeight = [2,3,4,3]
Sortie : 10
Explication :
Nous pouvons assigner des hauteurs de la manière suivante : [1, 2, 4, 3].

Exemple 2 :

Entrée : maximumHeight = [15,10]
Sortie : 25
Explication :
Nous pouvons assigner des hauteurs de la manière suivante : [15, 10].

Exemple 3 :

Entrée : maximumHeight = [2,2,1]
Sortie : -1
Explication :
Il est impossible d'attribuer des hauteurs positives à chaque index afin qu'aucune tour n'ait la même hauteur.

Contraintes :

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

On vous donne un tableau maximumHeight, où maximumHeight[i] désigne la hauteur maximale qui peut être attribuée à la i^ème tour.
Votre tâche est d'attribuer une hauteur à chaque tour de sorte que :

La hauteur de la i^ème tour soit un entier positif et ne dépasse pas maximumHeight[i].
Deux tours ne peuvent pas avoir la même hauteur.

Retournez la somme totale maximale possible des hauteurs des tours. S'il n'est pas possible d'attribuer des hauteurs, retournez -1.

Exemple 1 :

Entrée : maximumHeight = [2,3,4,3]
Sortie : 10
Explication :
Nous pouvons attribuer des hauteurs de la manière suivante : [1, 2, 4, 3].

Exemple 2 :

Entrée : maximumHeight = [15,10]
Sortie : 25
Explication :
Nous pouvons attribuer des hauteurs de la manière suivante : [15, 10].

Exemple 3 :

Entrée : maximumHeight = [2,2,1]
Sortie : -1
Explication :
Il est impossible d'attribuer des hauteurs positives à chaque index afin que deux tours ne puissent pas avoir la même hauteur.

Contraintes :

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


On vous donne deux chaînes de caractères word1 et word2.
Une chaîne x est appelée presque égale à y si vous pouvez changer au plus un caractère dans x pour la rendre identique à y.
Une séquence d'indices seq est appelée valide si :

Les indices sont triés par ordre croissant.
La concaténation des caractères à ces indices dans word1 dans le même ordre donne une chaîne qui est presque égale à word2.

Retournez un tableau de taille word2.length représentant la plus petite séquence d'indices valide du point de vue lexicographique. Si une telle séquence d'indices n'existe pas, retournez un tableau vide.
Notez que la réponse doit représenter le tableau le plus petit du point de vue lexicographique, et non la chaîne correspondante formée par ces indices.

Exemple 1 :

Entrée : word1 = "vbcca", word2 = "abc"
Sortie : [0,1,2]
Explication :
La plus petite séquence d'indices valide du point de vue lexicographique est [0, 1, 2] :

Changez word1[0] en 'a'.
word1[1] est déjà 'b'.
word1[2] est déjà 'c'.

Exemple 2 :

Entrée : word1 = "bacdc", word2 = "abc"
Sortie : [1,2,4]
Explication :
La plus petite séquence d'indices valide du point de vue lexicographique est [1, 2, 4] :

word1[1] est déjà 'a'.
Changez word1[2] en 'b'.
word1[4] est déjà 'c'.

Exemple 3 :

Entrée : word1 = "aaaaaa", word2 = "aaabc"
Sortie : []
Explication :
Il n'y a pas de séquence d'indices valide.

Exemple 4 :

Entrée : word1 = "abc", word2 = "ab"
Sortie : [0,1]

Contraintes :

1 <= word2.length < word1.length <= 3 * 10^5
word1 et word2 ne consistent qu'en des lettres minuscules anglaises.

On vous donne deux chaînes de caractères mot1 et mot2.
Une chaîne x est dite presque égale à y si vous pouvez changer au plus un caractère dans x pour la rendre identique à y.
Une séquence d’indices seq est dite valide si :

Les indices sont triés par ordre croissant.
La concaténation des caractères de ces indices dans le mot 1 dans le même ordre donne une chaîne presque égale au mot 2.

Renvoie un tableau de taille word2.length représentant la plus petite séquence valide d’indices lexicographiquement la plus petite. S’il n’existe aucune séquence d’indices de ce type, renvoyez un tableau vide.
Notez que la réponse doit représenter le tableau lexicographiquement le plus petit, et non la chaîne correspondante formée par ces indices.

Exemple 1 :

Entrée : word1 = "vbcca", word2 = "abc"
Sortie : [0,1,2]
Explication:
La plus petite séquence d’indices valide lexicographiquement est [0, 1, 2] :

Remplacez le mot 1[0] par 'a'.
word1[1] est déjà 'b'.
word1[2] est déjà 'c'.

Exemple 2 :

Entrée : word1 = "bacdc", word2 = "abc"
Sortie : [1,2,4]
Explication:
La plus petite séquence d’indices valide lexicographiquement est [1, 2, 4] :

le mot1[1] est déjà 'a'.
Remplacez le mot 1[2] par 'b'.
word1[4] est déjà 'c'.

Exemple 3 :

Entrée : word1 = "aaaaaa", word2 = "aaabc"
Sortie : []
Explication:
Il n’y a pas de séquence valide d’indices.

Exemple 4 :

Entrée : word1 = "abc", word2 = "ab"
Sortie : [0,1]

Contraintes:

1 <= word2.length < word1.length <= 3 * 10^5
word1 et word2 sont uniquement constitués de lettres anglaises minuscules.

On vous donne deux chaînes de caractères word1 et word2.
Une chaîne x est appelée presque égale à y si vous pouvez changer au plus un caractère dans x pour la rendre identique à y.
Une séquence d'indices seq est dite valide si :

Les indices sont triés par ordre croissant.
La concaténation des caractères à ces indices dans word1 dans le même ordre donne une chaîne qui est presque égale à word2.

Retournez un tableau de taille word2.length représentant la plus petite séquence d'indices valide du point de vue lexicographique. Si une telle séquence d'indices n'existe pas, retournez un tableau vide.
Notez que la réponse doit représenter le tableau le plus petit du point de vue lexicographique, et non la chaîne correspondante formée par ces indices.

Exemple 1 :

Entrée : word1 = "vbcca", word2 = "abc"
Sortie : [0,1,2]
Explication :
La plus petite séquence d'indices valide du point de vue lexicographique est [0, 1, 2] :

Changez word1[0] en 'a'.
word1[1] est déjà 'b'.
word1[2] est déjà 'c'.

Exemple 2 :

Entrée : word1 = "bacdc", word2 = "abc"
Sortie : [1,2,4]
Explication :
La plus petite séquence d'indices valide du point de vue lexicographique est [1, 2, 4] :

word1[1] est déjà 'a'.
Changez word1[2] en 'b'.
word1[4] est déjà 'c'.

Exemple 3 :

Entrée : word1 = "aaaaaa", word2 = "aaabc"
Sortie : []
Explication :
Il n'y a pas de séquence d'indices valide.

Exemple 4 :

Entrée : word1 = "abc", word2 = "ab"
Sortie : [0,1]

Contraintes :

1 <= word2.length < word1.length <= 3 * 10^5
word1 et word2 ne consistent qu'en des lettres minuscules anglaises.


Vous disposez de deux chaînes de caractères s et pattern.
Une chaîne x est appelée presque égale à y si vous pouvez changer au plus un caractère dans x pour la rendre identique à y.
Retournez l'indice de départ le plus petit d'une sous-chaîne dans s qui est presque égale à pattern. Si aucun indice n'existe, retournez -1.
Une sous-chaîne est une séquence contiguë de caractères non vide dans une chaîne.

Exemple 1 :

Input: s = "abcdefg", pattern = "bcdffg"
Output: 1
Explication :
La sous-chaîne s[1..6] == "bcdefg" peut être convertie en "bcdffg" en changeant s[4] en "f".

Exemple 2 :

Input: s = "ababbababa", pattern = "bacaba"
Output: 4
Explication :
La sous-chaîne s[4..9] == "bababa" peut être convertie en "bacaba" en changeant s[6] en "c".

Exemple 3 :

Input: s = "abcd", pattern = "dba"
Output: -1

Exemple 4 :

Input: s = "dde", pattern = "d"
Output: 0

Contraintes :

1 <= pattern.length < s.length <= 10^5
s et pattern sont constitués uniquement de lettres minuscules anglaises.

Suivi : Pourriez-vous résoudre le problème si au plus k caractères consécutifs peuvent être changés ?

On vous donne deux chaînes s et pattern.
Une chaîne x est dite presque égale à y si vous pouvez modifier au plus un caractère de x pour le rendre identique à y.
Renvoie le plus petit index de départ d'une sous-chaîne de s qui est presque égale à pattern. Si aucun index de ce type n'existe, renvoie -1.
Une sous-chaîne est une séquence contiguë non vide de caractères dans une chaîne.

Exemple 1 :

Entrée : s = "abcdefg", pattern = "bcdffg"
Sortie : 1
Explication :
La sous-chaîne s[1..6] == "bcdefg" peut être convertie en "bcdffg" en remplaçant s[4] par "f".

Exemple 2 :

Entrée : s = "ababbababa", pattern = "bacaba"
Sortie : 4
Explication :
La sous-chaîne s[4..9] == "bababa" peut être convertie en « bacaba » en remplaçant s[6] par"c".

Exemple 3 :

Entrée : s = "abcd", pattern = "dba"
Sortie : -1

Exemple 4 :

Entrée : s = "abcd", pattern = "dba"
Sortie : 0

Contraintes :

1 <= pattern.length < s.length <= 10^5
s et pattern ne sont constitués que de lettres minuscules anglaises.

Suivi : Pourriez-vous résoudre le problème si au plus k caractères consécutifs peuvent être modifiés ?

Vous disposez de deux chaînes de caractères s et pattern.
Une chaîne x est appelée presque égale à y si vous pouvez changer au plus un caractère dans x pour la rendre identique à y.
Retournez le plus petit indice d'une sous-chaîne dans s qui est presque égal à pattern. Si aucun indice n'existe, retournez -1.
Une sous-chaîne est une séquence contiguë de caractères non vide dans une chaîne.

Exemple 1 :

Input: s = "abcdefg", pattern = "bcdffg"
Output: 1
Explication :
La sous-chaîne s[1..6] == "bcdefg" peut être convertie en "bcdffg" en changeant s[4] en "f".

Exemple 2 :

Input: s = "ababbababa", pattern = "bacaba"
Output: 4
Explication :
La sous-chaîne s[4..9] == "bababa" peut être convertie en "bacaba" en changeant s[6] en "c".

Exemple 3 :

Input: s = "abcd", pattern = "dba"
Output: -1

Exemple 4 :

Input: s = "dde", pattern = "d"
Output: 0

Contraintes :

1 <= pattern.length < s.length <= 10^5
s et pattern sont constitués uniquement de lettres minuscules anglaises.

Suivi : Pourriez-vous résoudre le problème si au plus k caractères consécutifs peuvent être changés ?