Vous disposez d'un tableau d'entiers indexé à partir de 0, `nums`, et d'un entier positif `x`.
Vous êtes initialement à la position 0 dans le tableau et vous pouvez visiter d'autres positions selon les règles suivantes :

Si vous êtes actuellement à la position `i`, vous pouvez vous déplacer vers n'importe quelle position `j` telle que `i < j`.
Pour chaque position `i` que vous visitez, vous obtenez un score de `nums[i]`.
Si vous vous déplacez d'une position `i` à une position `j` et que les parités de `nums[i]` et `nums[j]` diffèrent, alors vous perdez un score de `x`.

Retournez le score total maximal que vous pouvez obtenir.
Notez qu'initialement, vous avez `nums[0]` points.

Exemple 1 :

Entrée : nums = [2,3,6,1,9,2], x = 5
Sortie : 13
Explication : Nous pouvons visiter les positions suivantes dans le tableau : 0 -> 2 -> 3 -> 4.
Les valeurs correspondantes sont 2, 6, 1 et 9. Étant donné que les entiers 6 et 1 ont des parités différentes, le déplacement 2 -> 3 vous fera perdre un score de x = 5.
Le score total sera : 2 + 6 + 1 + 9 - 5 = 13.

Exemple 2 :

Entrée : nums = [2,4,6,8], x = 3
Sortie : 20
Explication : Tous les entiers du tableau ont la même parité, donc nous pouvons les visiter tous sans perdre de score.
Le score total est : 2 + 4 + 6 + 8 = 20.

Contraintes :

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

Vous disposez d'un tableau nums d'entiers indexé à partir de 0 et d'un entier positif x.
Vous êtes initialement à la position 0 dans le tableau et vous pouvez visiter d'autres positions selon les règles suivantes :

Si vous êtes actuellement à la position i, vous pouvez vous déplacer vers n'importe quelle position j telle que i < j.
Pour chaque position i que vous visitez, vous obtenez un score de nums[i].
Si vous vous déplacez d'une position i à une position j et que les parités de nums[i] et nums[j] diffèrent, alors vous perdez un score de x.

Retournez le score total maximal que vous pouvez obtenir.
Notez qu'initialement, vous avez nums[0] points.

Exemple 1 :

Entrée : nums = [2,3,6,1,9,2], x = 5
Sortie : 13
Explication : Nous pouvons visiter les positions suivantes dans le tableau : 0 -> 2 -> 3 -> 4.
Les valeurs correspondantes sont 2, 6, 1 et 9. Étant donné que les entiers 6 et 1 ont des parités différentes, le déplacement 2 -> 3 vous fera perdre un score de x = 5.
Le score total sera : 2 + 6 + 1 + 9 - 5 = 13.

Exemple 2 :

Entrée : nums = [2,4,6,8], x = 3
Sortie : 20
Explication : Tous les entiers du tableau ont la même parité, donc nous pouvons les visiter tous sans perdre de score.
Le score total est : 2 + 4 + 6 + 8 = 20.

Contraintes :

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

On vous donne Un tableau d'entiers indexé à 0 et un entier positif x.
Vous êtes initialement à la position 0 dans le tableau et vous pouvez visiter d'autres postes selon les règles suivantes:

Si vous êtes actuellement en position I, vous pouvez passer à n'importe quelle position j telle que i < j.
Pour chaque position que vous visitez, vous obtenez un score de nums[i].
Si vous passez d'une position I à une position j et les parités de nums[i] et nums[j] diffèrent, alors vous perdez un score de x.

Renvoyez le score total maximum que vous pouvez obtenir.
Notez qu'au départ, vous avez des points nums[0].

Exemple 1:

Entrée: nums = [2,3,6,1,9,2], x = 5
Sortie: 13
Explication: Nous pouvons visiter les positions suivantes dans le tableau: 0 -> 2 -> 3 -> 4.
Les valeurs correspondantes sont 2, 6, 1 et 9. Comme les entiers 6 et 1 ont des parités différentes, le mouvement 2 -> 3 vous fera perdre un score de x = 5.
Le score total sera: 2 + 6 + 1 + 9 - 5 = 13.

Exemple 2:

Entrée: nums = [2,4,6,8], x = 3
Sortie: 20
Explication: Tous les entiers du tableau ont les mêmes parités, nous pouvons donc les visiter tous sans perdre de score.
Le score total est: 2 + 4 + 6 + 8 = 20.

Contraintes:

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


On vous donne un tableau d'entiers nums indexé à partir de 0. Vous devez trouver la somme maximale d'une paire de nombres de nums telle que le chiffre maximal dans les deux nombres soit égal.
Retournez la somme maximale ou -1 si aucune paire n'existe.

Exemple 1 :

Entrée : nums = [51,71,17,24,42]
Sortie : 88
Explication :
Pour i = 1 et j = 2, nums[i] et nums[j] ont des chiffres maximaux égaux avec une somme de paire de 71 + 17 = 88.
Pour i = 3 et j = 4, nums[i] et nums[j] ont des chiffres maximaux égaux avec une somme de paire de 24 + 42 = 66.
Il peut être montré qu'il n'existe pas d'autres paires avec des chiffres maximaux égaux, donc la réponse est 88.
Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : -1
Explication : Aucune paire n'existe dans nums avec des chiffres maximaux égaux.

Contraintes :

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

On vous donne un tableau d'entiers indexé à 0, nums. Vous devez trouver la somme maximale d'une paire de nombres de nums de telle sorte que le chiffre maximal des deux nombres soit égal.
Renvoie la somme maximale ou -1 si aucune paire de ce type n'existe.

Exemple 1 :

Entrée : nums = [51,71,17,24,42]
Sortie : 88
Explication :
Pour i = 1 et j = 2, nums[i] et nums[j] ont un chiffre maximal égal avec une somme de paires de 71 + 17 = 88.
Pour i = 3 et j = 4, nums[i] et nums[j] ont un chiffre maximal égal avec une somme de paires de 24 + 42 = 66.
On peut montrer qu'il n'existe pas d'autres paires avec un chiffre maximal égal, donc la réponse est 88.
Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : -1
Explication : Aucune paire n'existe dans nums avec un chiffre maximal égal.

Contraintes :

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

On vous donne un tableau d'entiers nums indexé à partir de 0. Vous devez trouver la somme maximale d'une paire de nombres de nums telle que le chiffre maximal dans les deux nombres soit égal.
Retournez la somme maximale ou -1 si aucune paire n'existe.

Exemple 1 :

Entrée : nums = [51,71,17,24,42]
Sortie : 88
Explication :
Pour i = 1 et j = 2, nums[i] et nums[j] ont des chiffres maximaux égaux avec une somme de paire de 71 + 17 = 88.
Pour i = 3 et j = 4, nums[i] et nums[j] ont des chiffres maximaux égaux avec une somme de paire de 24 + 42 = 66.
Il peut être montré qu'il n'existe pas d'autres paires avec des chiffres maximaux égaux, donc la réponse est 88.
Exemple 2 :

Entrée : nums = [1,2,3,4]
Sortie : -1
Explication : aucune paire n'existe dans nums avec des chiffres maximaux égaux.

Contraintes :

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


On vous donne un tableau d'entiers indexé à partir de 0, `nums`, un entier `modulo` et un entier `k`.
Votre tâche est de trouver le nombre de sous-tableaux qui sont intéressants.
Un sous-tableau `nums[l..r]` est intéressant si la condition suivante est remplie :

Soit `cnt` le nombre d'indices `i` dans la plage `[l, r]` tel que `nums[i] % modulo == k`. Alors, `cnt % modulo == k`.

Renvoyez un entier représentant le nombre de sous-tableaux intéressants.
Remarque : Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [3,2,4], modulo = 2, k = 1
Sortie : 3
Explication : Dans cet exemple, les sous-tableaux intéressants sont :
Le sous-tableau `nums[0..0]` qui est [3].
- Il n'y a qu'un seul indice, `i = 0`, dans la plage `[0, 0]` qui satisfait `nums[i] % modulo == k`.
- Donc, `cnt = 1` et `cnt % modulo == k`.
Le sous-tableau `nums[0..1]` qui est [3,2].
- Il n'y a qu'un seul indice, `i = 0`, dans la plage `[0, 1]` qui satisfait `nums[i] % modulo == k`.
- Donc, `cnt = 1` et `cnt % modulo == k`.
Le sous-tableau `nums[0..2]` qui est [3,2,4].
- Il n'y a qu'un seul indice, `i = 0`, dans la plage `[0, 2]` qui satisfait `nums[i] % modulo == k`.
- Donc, `cnt = 1` et `cnt % modulo == k`.
Il peut être montré qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 3.

Exemple 2 :

Entrée : nums = [3,1,9,6], modulo = 3, k = 0
Sortie : 2
Explication : Dans cet exemple, les sous-tableaux intéressants sont :
Le sous-tableau `nums[0..3]` qui est [3,1,9,6].
- Il y a trois indices, `i = 0`, `2`, `3`, dans la plage `[0, 3]` qui satisfont `nums[i] % modulo == k`.
- Donc, `cnt = 3` et `cnt % modulo == k`.
Le sous-tableau `nums[1..1]` qui est [1].
- Il n'y a aucun indice, `i`, dans la plage `[1, 1]` qui satisfait `nums[i] % modulo == k`.
- Donc, `cnt = 0` et `cnt % modulo == k`.
Il peut être montré qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 2.

Contraintes :

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

Vous avez un tableau d'entiers nums indexé à partir de 0, un entier modulo et un entier k.
Votre tâche est de trouver le nombre de sous-tableaux qui sont intéressants.
Un sous-tableau nums[l..r] est dit intéressant si la condition suivante est remplie :

Soit cnt le nombre d'indices i dans la plage [l, r] tel que nums[i] % modulo == k. Alors, cnt % modulo == k.

Retournez un entier représentant le nombre de sous-tableaux intéressants.
Remarque : Un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [3,2,4], modulo = 2, k = 1
Sortie : 3
Explication : Dans cet exemple, les sous-tableaux intéressants sont :
Le sous-tableau nums[0..0] qui est [3].
- Il n'y a qu'un seul indice, i = 0, dans la plage [0, 0] qui satisfait nums[i] % modulo == k.
- Donc, cnt = 1 et cnt % modulo == k.
Le sous-tableau nums[0..1] qui est [3,2].
- Il n'y a qu'un seul indice, i = 0, dans la plage [0, 1] qui satisfait nums[i] % modulo == k.
- Donc, cnt = 1 et cnt % modulo == k.
Le sous-tableau nums[0..2] qui est [3,2,4].
- Il n'y a qu'un seul indice, i = 0, dans la plage [0, 2] qui satisfait nums[i] % modulo == k.
- Donc, cnt = 1 et cnt % modulo == k.
Il peut être montré qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 3.
Exemple 2 :

Entrée : nums = [3,1,9,6], modulo = 3, k = 0
Sortie : 2
Explication : Dans cet exemple, les sous-tableaux intéressants sont :
Le sous-tableau nums[0..3] qui est [3,1,9,6].
- Il y a trois indices, i = 0, 2, 3, dans la plage [0, 3] qui satisfont nums[i] % modulo == k.
- Donc, cnt = 3 et cnt % modulo == k.
Le sous-tableau nums[1..1] qui est [1].
- Il n'y a aucun indice, i, dans la plage [1, 1] qui satisfait nums[i] % modulo == k.
- Donc, cnt = 0 et cnt % modulo == k.
Il peut être montré qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 2.

Contraintes :

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

On vous donne un tableau entier indexé à 0, un modulo entier et un entier k.
Votre tâche consiste à trouver le décompte des sous-tableaux qui sont intéressants.
Un nombre de sous-réseau [l..r] est intéressant si la condition suivante est valable:

Soit cnt le nombre d'indices I dans la plage [l, r] tel que nums[i]% modulo == k. Ensuite, cnt% modulo == k.

Renvoyez un entier indiquant le décompte de sous-tableaux intéressants.
Remarque: Un sous-réseau est une séquence contigu non vide d'éléments dans un tableau.

Exemple 1:

Entrée: nums = [3,2,4], modulo = 2, k = 1
Sortie: 3
Explication: Dans cet exemple, les sous-tableaux intéressants sont:
Le sous-réseau nums[0..0] qui est [3].
- Il n'y a qu'un seul index, i = 0, dans la plage [0, 0] qui satisfait nums [i]% modulo == k.
- Par conséquent, cnt = 1 et cnt% modulo == k.
Le sous-réseau nums[0..1] qui est [3,2].
- Il n'y a qu'un seul index, i = 0, dans la plage [0, 1] qui satisfait nums [i]% modulo == k.
- Par conséquent, cnt = 1 et cnt% modulo == k.
Le sous-réseau nums[0..2] qui est [3,2,4].
- Il n'y a qu'un seul index, i = 0, dans la plage [0, 2] qui satisfait nums [i]% modulo == k.
- Par conséquent, cnt = 1 et cnt% modulo == k.
On peut montrer qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 3.
Exemple 2:

Entrée: nums = [3,1,9,6], modulo = 3, k = 0
Sortie: 2
Explication: Dans cet exemple, les sous-tableaux intéressants sont:
Le sous-réseau nums[0..3] qui est [3,1,9,6].
- Il y a trois indices, i = 0, 2, 3, dans la plage [0, 3] qui satisfont les nums [i]% modulo == k.
- Par conséquent, cnt = 3 et cnt% modulo == k.
Le sous-réseau nums[1..1] qui est [1].
- Il n'y a pas d'indice, i, dans la plage [1, 1] qui satisfait nums [i]% modulo == k.
- Par conséquent, cnt = 0 et cnt% modulo == k.
On peut montrer qu'il n'y a pas d'autres sous-tableaux intéressants. Donc, la réponse est 2.

Contraintes:

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


Vous avez un tableau `nums` de longueur `n` et un entier `m`. Vous devez déterminer s'il est possible de diviser le tableau en `n` tableaux non vides en effectuant une série d'étapes.
À chaque étape, vous pouvez choisir un tableau existant (qui peut être le résultat des étapes précédentes) d'une longueur d'au moins deux et le diviser en deux sous-tableaux, si pour chaque sous-tableau résultant, au moins l'une des conditions suivantes est remplie :

La longueur du sous-tableau est un, ou
La somme des éléments du sous-tableau est supérieure ou égale à `m`.

Renvoyez `true` si vous pouvez diviser le tableau donné en `n` tableaux, sinon renvoyez `false`.
Remarque : Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2, 2, 1], m = 4
Sortie : true
Explication : Nous pouvons diviser le tableau en [2, 2] et [1] lors de la première étape. Ensuite, à la deuxième étape, nous pouvons diviser [2, 2] en [2] et [2]. En conséquence, la réponse est true.

Exemple 2 :

Entrée : nums = [2, 1, 3], m = 5
Sortie : false
Explication : Nous pouvons essayer de diviser le tableau de deux manières différentes : la première façon est d'avoir [2, 1] et [3], et la deuxième façon est d'avoir [2] et [1, 3]. Cependant, ces deux manières ne sont pas valides. Donc, la réponse est false.

Exemple 3 :

Entrée : nums = [2, 3, 3, 2, 3], m = 6
Sortie : true
Explication : Nous pouvons diviser le tableau en [2, 3, 3, 2] et [3] lors de la première étape. Ensuite, à la deuxième étape, nous pouvons diviser [2, 3, 3, 2] en [2, 3, 3] et [2]. Ensuite, à la troisième étape, nous pouvons diviser [2, 3, 3] en [2] et [3, 3]. Et à la dernière étape, nous pouvons diviser [3, 3] en [3] et [3]. En conséquence, la réponse est true.

Contraintes :

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

On vous donne un tableau nums de longueur n et un entier m. Vous devez déterminer s'il est possible de diviser le tableau en n tableaux non vides en effectuant une série d'étapes.
À chaque étape, vous pouvez sélectionner un tableau existant (qui peut être le résultat des étapes précédentes) d'une longueur d'au moins deux et le diviser en deux sous-tableaux, si, pour chaque sous-tableau résultant, au moins l'une des conditions suivantes est remplie :

La longueur du sous-tableau est un, ou
La somme des éléments du sous-tableau est supérieure ou égale à m.

Renvoie true si vous pouvez diviser le tableau donné en n tableaux, sinon renvoie false.
Remarque : un sous-tableau est une séquence contiguë non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2, 2, 1], m = 4
Sortie : true
Explication : nous pouvons diviser le tableau en [2, 2] et [1] à la première étape. Ensuite, dans la deuxième étape, nous pouvons diviser [2, 2] en [2] et [2]. En conséquence, la réponse est true.
Exemple 2 :

Entrée : nums = [2, 1, 3], m = 5
Sortie : false
Explication : Nous pouvons essayer de diviser le tableau de deux manières différentes : la première consiste à avoir [2, 1] et [3], et la deuxième consiste à avoir [2] et [1, 3]. Cependant, ces deux manières ne sont pas valides. Donc, la réponse est false.
Exemple 3 :

Entrée : nums = [2, 3, 3, 2, 3], m = 6
Sortie : true
Explication : Nous pouvons diviser le tableau en [2, 3, 3, 2] et [3] dans la première étape. Ensuite, dans la deuxième étape, nous pouvons diviser [2, 3, 3, 2] en [2, 3, 3] et [2]. Ensuite, dans la troisième étape, nous pouvons diviser [2, 3, 3] en [2] et [3, 3]. Et dans la dernière étape, nous pouvons diviser [3, 3] en [3] et [3]. En conséquence, la réponse est true.

Contraintes :

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

On vous donne un tableau nums de longueur n et un entier m. Vous devez déterminer s'il est possible de diviser le tableau en n tableaux non vides en effectuant une série d'étapes.
À chaque étape, vous pouvez choisir un tableau existant (qui peut être le résultat des étapes précédentes) d'une longueur d'au moins deux et le diviser en deux sous-tableaux, si pour chaque sous-tableau résultant, au moins l'une des conditions suivantes est remplie :

La longueur du sous-tableau est un, ou
La somme des éléments du sous-tableau est supérieure ou égale à m.

Retournez true si vous pouvez diviser le tableau donné en n tableaux, sinon retournez false.
Remarque : Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2, 2, 1], m = 4
Sortie : true
Explication : Nous pouvons diviser le tableau en [2, 2] et [1] lors de la première étape. Ensuite, à la deuxième étape, nous pouvons diviser [2, 2] en [2] et [2]. En conséquence, la réponse est true.
Exemple 2 :

Entrée : nums = [2, 1, 3], m = 5
Sortie : false
Explication : Nous pouvons essayer de diviser le tableau de deux manières différentes : la première façon est d'avoir [2, 1] et [3], et la deuxième façon est d'avoir [2] et [1, 3]. Cependant, ces deux manières ne sont pas valides. Donc, la réponse est false.
Exemple 3 :

Entrée : nums = [2, 3, 3, 2, 3], m = 6
Sortie : true
Explication : Nous pouvons diviser le tableau en [2, 3, 3, 2] et [3] lors de la première étape. Ensuite, à la deuxième étape, nous pouvons diviser [2, 3, 3, 2] en [2, 3, 3] et [2]. Ensuite, à la troisième étape, nous pouvons diviser [2, 3, 3] en [2] et [3, 3]. Et à la dernière étape, nous pouvons diviser [3, 3] en [3] et [3]. En conséquence, la réponse est true.

Contraintes :

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Étant donné un tableau d'entiers nums indexé à partir de 0 de longueur n et un entier target, renvoyez le nombre de paires (i, j) où 0 <= i < j < n et nums[i] + nums[j] < target.

Exemple 1 :

Entrée : nums = [-1,1,2,3,1], target = 2
Sortie : 3
Explication : Il y a 3 paires d'indices qui satisfont les conditions de l'énoncé :
- (0, 1) car 0 < 1 et nums[0] + nums[1] = 0 < target
- (0, 2) car 0 < 2 et nums[0] + nums[2] = 1 < target
- (0, 4) car 0 < 4 et nums[0] + nums[4] = 0 < target
Notez que (0, 3) n'est pas compté car nums[0] + nums[3] n'est pas strictement inférieur à target.

Exemple 2 :

Entrée : nums = [-6,2,5,-2,-7,-1,3], target = -2
Sortie : 10
Explication : Il y a 10 paires d'indices qui satisfont les conditions de l'énoncé :
- (0, 1) car 0 < 1 et nums[0] + nums[1] = -4 < target
- (0, 3) car 0 < 3 et nums[0] + nums[3] = -8 < target
- (0, 4) car 0 < 4 et nums[0] + nums[4] = -13 < target
- (0, 5) car 0 < 5 et nums[0] + nums[5] = -7 < target
- (0, 6) car 0 < 6 et nums[0] + nums[6] = -3 < target
- (1, 4) car 1 < 4 et nums[1] + nums[4] = -5 < target
- (3, 4) car 3 < 4 et nums[3] + nums[4] = -9 < target
- (3, 5) car 3 < 5 et nums[3] + nums[5] = -3 < target
- (4, 5) car 4 < 5 et nums[4] + nums[5] = -8 < target
- (4, 6) car 4 < 6 et nums[4] + nums[6] = -4 < target

Contraintes :

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Étant donné un tableau d'entiers indexé à partir de 0 nommé nums de longueur n et un entier target, renvoyez le nombre de paires (i, j) où 0 <= i < j < n et nums[i] + nums[j] < target.

Exemple 1 :

Entrée : nums = [-1,1,2,3,1], target = 2
Sortie : 3
Explication : Il y a 3 paires d'indices qui satisfont les conditions de l'énoncé :
- (0, 1) car 0 < 1 et nums[0] + nums[1] = 0 < target
- (0, 2) car 0 < 2 et nums[0] + nums[2] = 1 < target
- (0, 4) car 0 < 4 et nums[0] + nums[4] = 0 < target
Notez que (0, 3) n'est pas compté car nums[0] + nums[3] n'est pas strictement inférieur à target.

Exemple 2 :

Entrée : nums = [-6,2,5,-2,-7,-1,3], target = -2
Sortie : 10
Explication : Il y a 10 paires d'indices qui satisfont les conditions de l'énoncé :
- (0, 1) car 0 < 1 et nums[0] + nums[1] = -4 < target
- (0, 3) car 0 < 3 et nums[0] + nums[3] = -8 < target
- (0, 4) car 0 < 4 et nums[0] + nums[4] = -13 < target
- (0, 5) car 0 < 5 et nums[0] + nums[5] = -7 < target
- (0, 6) car 0 < 6 et nums[0] + nums[6] = -3 < target
- (1, 4) car 1 < 4 et nums[1] + nums[4] = -5 < target
- (3, 4) car 3 < 4 et nums[3] + nums[4] = -9 < target
- (3, 5) car 3 < 5 et nums[3] + nums[5] = -3 < target
- (4, 5) car 4 < 5 et nums[4] + nums[5] = -8 < target
- (4, 6) car 4 < 6 et nums[4] + nums[6] = -4 < target

Contraintes :

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50


Vous avez un tableau usageLimits indexé à partir de 0 de longueur n.
Votre tâche est de créer des groupes en utilisant les nombres de 0 à n - 1, en veillant à ce que chaque nombre, i, soit utilisé au plus usageLimits[i] fois au total dans tous les groupes. Vous devez également satisfaire les conditions suivantes :

Chaque groupe doit être constitué de nombres distincts, ce qui signifie qu'aucun nombre en double n'est autorisé dans un seul groupe.
Chaque groupe (excepté le premier) doit avoir une longueur strictement supérieure à celle du groupe précédent.

Retournez un entier indiquant le nombre maximal de groupes que vous pouvez créer tout en satisfaisant ces conditions.

Exemple 1 :

Entrée : usageLimits = [1,2,5]
Sortie : 3
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus une fois, 1 au plus deux fois, et 2 au plus cinq fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [2].
Groupe 2 contient les nombres [1,2].
Groupe 3 contient les nombres [0,1,2].
Il peut être démontré que le nombre maximal de groupes est 3.
Donc, la sortie est 3.
Exemple 2 :

Entrée : usageLimits = [2,1,2]
Sortie : 2
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus deux fois, 1 au plus une fois, et 2 au plus deux fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Groupe 2 contient les nombres [1,2].
Il peut être démontré que le nombre maximal de groupes est 2.
Donc, la sortie est 2.

Exemple 3 :

Entrée : usageLimits = [1,1]
Sortie : 1
Explication : Dans cet exemple, nous pouvons utiliser à la fois 0 et 1 au plus une fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Il peut être démontré que le nombre maximal de groupes est 1.
Donc, la sortie est 1.

Contraintes :

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

On a un tableau usageLimits indexé à partir de 0 de longueur n.
Votre tâche est de créer des groupes en utilisant les nombres de 0 à n - 1, en veillant à ce que chaque nombre, i, soit utilisé au plus usageLimits[i] fois au total dans tous les groupes. Vous devez également satisfaire les conditions suivantes :

Chaque groupe doit être constitué de nombres distincts, ce qui signifie qu'aucun nombre en double n'est autorisé au sein d'un même groupe.
Chaque groupe (excepté le premier) doit avoir une longueur strictement supérieure à celle du groupe précédent.

Retournez un entier indiquant le nombre maximal de groupes que vous pouvez créer tout en satisfaisant ces conditions.

Exemple 1 :

Entrée : usageLimits = [1,2,5]
Sortie : 3
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus une fois, 1 au plus deux fois, et 2 au plus cinq fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [2].
Groupe 2 contient les nombres [1,2].
Groupe 3 contient les nombres [0,1,2].
Il peut être démontré que le nombre maximal de groupes est 3.
Donc, la sortie est 3.
Exemple 2 :

Entrée : usageLimits = [2,1,2]
Sortie : 2
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus deux fois, 1 au plus une fois, et 2 au plus deux fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Groupe 2 contient les nombres [1,2].
Il peut être démontré que le nombre maximal de groupes est 2.
Donc, la sortie est 2.

Exemple 3 :

Entrée : usageLimits = [1,1]
Sortie : 1
Explication : Dans cet exemple, nous pouvons utiliser à la fois 0 et 1 au plus une fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Il peut être démontré que le nombre maximal de groupes est 1.
Donc, la sortie est 1.

Contraintes :

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

Vous avez un tableau usageLimits indexé à partir de 0 de longueur n.
Votre tâche est de créer des groupes en utilisant les nombres de 0 à n - 1, en veillant à ce que chaque nombre, i, soit utilisé au plus usageLimits[i] fois au total dans tous les groupes. Vous devez également satisfaire les conditions suivantes :

Chaque groupe doit être constitué de nombres distincts, ce qui signifie qu'aucun dioublon n'est autorisé dans un seul groupe.
Chaque groupe (excepté le premier) doit avoir une longueur strictement supérieure à celle du groupe précédent.

Retournez un entier indiquant le nombre maximal de groupes que vous pouvez créer tout en satisfaisant ces conditions.

Exemple 1 :

Entrée : usageLimits = [1,2,5]
Sortie : 3
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus une fois, 1 au plus deux fois, et 2 au plus cinq fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [2].
Groupe 2 contient les nombres [1,2].
Groupe 3 contient les nombres [0,1,2].
Il peut être démontré que le nombre maximal de groupes est 3.
Donc, la sortie est 3.

Exemple 2 :

Entrée : usageLimits = [2,1,2]
Sortie : 2
Explication : Dans cet exemple, nous pouvons utiliser 0 au plus deux fois, 1 au plus une fois, et 2 au plus deux fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Groupe 2 contient les nombres [1,2].
Il peut être démontré que le nombre maximal de groupes est 2.
Donc, la sortie est 2.

Exemple 3 :

Entrée : usageLimits = [1,1]
Sortie : 1
Explication : Dans cet exemple, nous pouvons utiliser à la fois 0 et 1 au plus une fois.
Une façon de créer le nombre maximal de groupes tout en satisfaisant les conditions est :
Groupe 1 contient le nombre [0].
Il peut être démontré que le nombre maximal de groupes est 1.
Donc, la sortie est 1.

Contraintes :

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


Vous avez un tableau indexé à partir de 0, `nums`, contenant `n` entiers.
Chaque seconde, vous effectuez l'opération suivante sur le tableau :

Pour chaque indice `i` dans la plage [0, n - 1], remplacez `nums[i]` par soit `nums[i]`, `nums[(i - 1 + n) % n]` ou `nums[(i + 1) % n]`.

Notez que tous les éléments sont remplacés simultanément.
Retournez le nombre minimum de secondes nécessaires pour rendre tous les éléments du tableau `nums` égaux.

Exemple 1 :

Entrée : nums = [1,2,1,2]
Sortie : 1
Explication : Nous pouvons égaliser le tableau en 1 seconde de la manière suivante :
- À la 1^re seconde, remplacez les valeurs à chaque indice par [nums[3],nums[1],nums[3],nums[3]]. Après remplacement, nums = [2,2,2,2].
On peut prouver qu'une seconde est le temps minimum nécessaire pour égaliser le tableau.

Exemple 2 :

Entrée : nums = [2,1,3,3,2]
Sortie : 2
Explication : Nous pouvons égaliser le tableau en 2 secondes de la manière suivante :
- À la 1^re seconde, remplacez les valeurs à chaque indice par [nums[0],nums[2],nums[2],nums[2],nums[3]]. Après remplacement, nums = [2,3,3,3,3].
- À la 2^e seconde, remplacez les valeurs à chaque indice par [nums[1],nums[1],nums[2],nums[3],nums[4]]. Après remplacement, nums = [3,3,3,3,3].
On peut prouver que 2 secondes est le temps minimum nécessaire pour égaliser le tableau.

Exemple 3 :

Entrée : nums = [5,5,5,5]
Sortie : 0
Explication : Nous n'avons pas besoin d'effectuer d'opérations car tous les éléments dans le tableau initial sont les mêmes.

Contraintes :

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

On vous donne un tableau nums indexé à 0 contenant n entiers.
À chaque seconde, vous effectuez l'opération suivante sur le tableau :

Pour chaque index i dans la plage [0, n - 1], remplacez nums[i] par nums[i], nums[(i - 1 + n) % n] ou nums[(i + 1) % n].

Notez que tous les éléments sont remplacés simultanément.
Renvoie le nombre minimum de secondes nécessaires pour rendre tous les éléments du tableau nums égaux.

Exemple 1 :

Entrée : nums = [1,2,1,2]
Sortie : 1
Explication : Nous pouvons égaliser le tableau en 1 seconde de la manière suivante :
- À la 1re seconde, remplacez les valeurs de chaque index par [nums[3],nums[1],nums[3],nums[3]]. Après remplacement, nums = [2,2,2,2].
Il peut être prouvé que 1 seconde est le nombre minimum de secondes nécessaires pour égaliser le tableau.

Exemple 2 :

Entrée : nums = [2,1,3,3,2]
Sortie : 2
Explication : Nous pouvons égaliser le tableau en 2 secondes de la manière suivante :
- À la 1re seconde, remplacez les valeurs de chaque index par [nums[0],nums[2],nums[2],nums[2],nums[3]]. Après remplacement, nums = [2,3,3,3,3].
- À la 2e seconde, remplacez les valeurs de chaque index par [nums[1],nums[1],nums[2],nums[3],nums[4]]. Après remplacement, nums = [3,3,3,3,3].
Il peut être prouvé que 2 secondes sont le nombre minimum de secondes nécessaires pour égaliser le tableau.

Exemple 3 :

Entrée : nums = [5,5,5,5]
Sortie : 0
Explication : Nous n'avons pas besoin d'effectuer d'opérations car tous les éléments du tableau initial sont identiques.

Contraintes :

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

Vous avez un tableau nums indexé à partir de 0 contenant n entiers.
À chaque seconde, vous effectuez l'opération suivante sur le tableau :

Pour chaque indice i dans la plage [0, n - 1], remplacez nums[i] par soit nums[i], nums[(i - 1 + n) % n] ou nums[(i + 1) % n].

Notez que tous les éléments sont remplacés simultanément.
Retournez le nombre minimum de secondes nécessaires pour rendre tous les éléments du tableau nums égaux.

Exemple 1 :

Entrée : nums = [1,2,1,2]
Sortie : 1
Explication : Nous pouvons égaliser le tableau en 1 seconde de la manière suivante :
- À la 1^re seconde, remplacez les valeurs à chaque indice par [nums[3],nums[1],nums[3],nums[3]]. Après remplacement, nums = [2,2,2,2].
On peut prouver qu'une seconde est le temps minimum nécessaire pour égaliser le tableau.

Exemple 2 :

Entrée : nums = [2,1,3,3,2]
Sortie : 2
Explication : Nous pouvons égaliser le tableau en 2 secondes de la manière suivante :
- À la 1^re seconde, remplacez les valeurs à chaque indice par [nums[0],nums[2],nums[2],nums[2],nums[3]]. Après remplacement, nums = [2,3,3,3,3].
- À la 2^e seconde, remplacez les valeurs à chaque indice par [nums[1],nums[1],nums[2],nums[3],nums[4]]. Après remplacement, nums = [3,3,3,3,3].
On peut prouver que 2 secondes est le temps minimum nécessaire pour égaliser le tableau.

Exemple 3 :

Entrée : nums = [5,5,5,5]
Sortie : 0
Explication : Nous n'avons pas besoin d'effectuer d'opérations car tous les éléments dans le tableau initial sont les mêmes.

Contraintes :

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


Étant donnés deux entiers positifs low et high représentés sous forme de chaînes de caractères, trouvez le nombre de nombres de type stepping dans l'intervalle inclusif [low, high].
Un nombre de type stepping est un entier dont tous les chiffres adjacents ont une différence absolue exactement égale à 1.
Retournez un entier indiquant le nombre de nombres de type stepping dans l'intervalle inclusif [low, high].
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.
Remarque : Un nombre  de type stepping ne doit pas avoir de zéro en tête.

Exemple 1 :

Entrée : low = "1", high = "11"
Sortie : 10
Explication : Les nombres de type stepping dans l'intervalle [1,11] sont 1, 2, 3, 4, 5, 6, 7, 8, 9 et 10. Il y a un total de 10 nombres de type stepping dans l'intervalle. Par conséquent, le résultat est 10.
Exemple 2 :

Entrée : low = "90", high = "101"
Sortie : 2
Explication : Les nombres de type stepping dans l'intervalle [90,101] sont 98 et 101. Il y a un total de 2 nombres de type stepping dans l'intervalle. Par conséquent, le résultat est 2.

Contraintes :

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low et high sont composés uniquement de chiffres.
low et high n'ont pas de zéros en tête.

Étant donné deux entiers positifs low et high représentés sous forme de chaînes de caractères, trouvez le nombre de nombres "stepping" dans l'intervalle inclusif [low, high].
Un nombre "stepping" est un entier tel que tous ses chiffres adjacents ont une différence absolue exactement égale à 1.
Retournez un entier indiquant le nombre de nombres "stepping" dans l'intervalle inclusif [low, high].
Comme la réponse peut être très grande, retournez-la modulo 10^9 + 7.
Remarque : Un nombre "stepping" ne doit pas avoir de zéro en tête.

Exemple 1 :

Entrée : low = "1", high = "11"
Sortie : 10
Explication : Les nombres "stepping" dans l'intervalle [1,11] sont 1, 2, 3, 4, 5, 6, 7, 8, 9 et 10. Il y a un total de 10 nombres "stepping" dans l'intervalle. Par conséquent, la sortie est 10.
Exemple 2 :

Entrée : low = "90", high = "101"
Sortie : 2
Explication : Les nombres "stepping" dans l'intervalle [90,101] sont 98 et 101. Il y a un total de 2 nombres "stepping" dans l'intervalle. Par conséquent, la sortie est 2.

Contraintes :

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low et high sont composés uniquement de chiffres.
low et high n'ont pas de zéros en tête.

Étant donné deux entiers positifs low et high représentés sous forme de chaînes, trouvez le nombre de nombres échelonnés dans la plage inclusive [low, high].
Un nombre échelonné est un entier tel que tous ses chiffres adjacents ont une différence absolue d'exactement 1.
Renvoie un entier indiquant le nombre de nombres échelonnés dans la plage inclusive [low, high].
Comme la réponse peut être très grande, renvoie-la modulo 10^9 + 7.
Remarque : un nombre échelonné ne doit pas avoir de zéro non significatif.

Exemple 1 :

Entrée : low = "1", high = "11"
Sortie : 10
Explication : Les nombres échelonnés dans la plage [1,11] sont 1, 2, 3, 4, 5, 6, 7, 8, 9 et 10. Il y a un total de 10 nombres échelonnés dans la plage. Par conséquent, la sortie est 10.
Exemple 2 :

Entrée : low = "90", high = "101"
Sortie : 2
Explication : Les nombres de pas dans la plage [90,101] sont 98 et 101. Il y a au total 2 nombres de pas dans la plage. Par conséquent, la sortie est 2.

Contraintes :

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low et high ne sont constitués que de chiffres.
low et high n'ont pas de zéros non significatifs.


On vous donne deux tableaux d'entiers de même longueur, nums1 et nums2, indexés à partir de 0. Chaque seconde, pour tous les indices 0 <= i < nums1.length, la valeur de nums1[i] est incrémentée de nums2[i]. Après cela, vous pouvez effectuer l'opération suivante :

Choisissez un indice 0 <= i < nums1.length et faites nums1[i] = 0.

On vous donne également un entier x. Retournez le temps minimum nécessaire pour que la somme de tous les éléments de nums1 soit inférieure ou égale à x, ou -1 si cela n'est pas possible.

Exemple 1 :

Entrée : nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Sortie : 3
Explication :
Pour la 1ère seconde, nous appliquons l'opération sur i = 0. Donc nums1 = [0,2+2,3+3] = [0,4,6].
Pour la 2ème seconde, nous appliquons l'opération sur i = 1. Donc nums1 = [0+1,0,6+3] = [1,0,9].
Pour la 3ème seconde, nous appliquons l'opération sur i = 2. Donc nums1 = [1+1,0+2,0] = [2,2,0].
La somme de nums1 est maintenant 4. Il peut être démontré que ces opérations sont optimales, donc nous renvoyons 3.

Exemple 2 :

Entrée : nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Sortie : -1
Explication : Il peut être démontré que la somme de nums1 sera toujours supérieure à x, quelle que soit les opérations effectuées.

Contraintes :

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

On vous donne deux tableaux d'entiers indexés 0, nums1 et nums2, de longueur égale. Chaque seconde, pour tous les indices 0 <= i < nums1.length, la valeur de nums1[i] est incrémentée de nums2[i]. Une fois cette opération effectuée, vous pouvez effectuer l'opération suivante :

Choisissez un index 0 <= i < nums1.length et définissez nums1[i] = 0.

On vous donne également un entier x.
Renvoie le temps minimum pendant lequel vous pouvez faire en sorte que la somme de tous les éléments de nums1 soit inférieure ou égale à x, ou -1 si cela n'est pas possible.

Exemple 1 :

Entrée : nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Sortie : 3
Explication :
Pour la 1ère seconde, on applique l'opération sur i = 0. Donc nums1 = [0,2+2,3+3] = [0,4,6].
Pour la 2ème seconde, on applique l'opération sur i = 1. Donc nums1 = [0+1,0,6+3] = [1,0,9].
Pour la 3ème seconde, on applique l'opération sur i = 2. Donc nums1 = [1+1,0+2,0] = [2,2,0].
Maintenant, la somme de nums1 = 4. On peut montrer que ces opérations sont optimales, donc on renvoie 3.

Exemple 2 :

Entrée : nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Sortie : -1
Explication : On peut montrer que la somme de nums1 sera toujours supérieure à x, quelles que soient les opérations effectuées.

Contraintes :

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Vous avez deux tableaux d'entiers de même longueur, nums1 et nums2, indexés à partir de 0. Chaque seconde, pour tous les indices 0 <= i < nums1.length, la valeur de nums1[i] est incrémentée de nums2[i]. Après cela, vous pouvez effectuer l'opération suivante :

Choisissez un indice 0 <= i < nums1.length et faites nums1[i] = 0.

On vous donne également un entier x. Retournez le temps minimum nécessaire pour que la somme de tous les éléments de nums1 soit inférieure ou égale à x, ou -1 si cela n'est pas possible.

Exemple 1 :

Entrée : nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Sortie : 3
Explication :
Pour la 1ère seconde, nous appliquons l'opération sur i = 0. Donc nums1 = [0,2+2,3+3] = [0,4,6].
Pour la 2ème seconde, nous appliquons l'opération sur i = 1. Donc nums1 = [0+1,0,6+3] = [1,0,9].
Pour la 3ème seconde, nous appliquons l'opération sur i = 2. Donc nums1 = [1+1,0+2,0] = [2,2,0].
La somme de nums1 est maintenant 4. Il peut être démontré que ces opérations sont optimales, donc nous retournons 3.

Exemple 2 :

Entrée : nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Sortie : -1
Explication : Il peut être démontré que la somme de nums1 sera toujours supérieure à x, quelle que soit les opérations effectuées.

Contraintes :

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6


On vous donne les coordonnées d’un tableau d’entiers 2D et d’un entier k, où les coordonnées[i] = [x_i, y_i] sont les coordonnées du i^ème point dans un plan 2D.
Nous définissons la distance entre deux points (x_1, y_1) et (x_2, y_2) comme (x1 XOR x2) + (y1 XOR y2) où XOR est l’opération XOR au niveau du bit.
Renvoie le nombre de paires (i, j) tel que i < j et que la distance entre les points i et j soit égale à k.

Exemple 1 :

Entrée : coordonnées = [[1,2],[4,2],[1,3],[5,2]], k = 5
Sortie : 2
Explication : Nous pouvons choisir les paires suivantes :
- (0,1) : Parce que nous avons (1 XOR 4) + (2 XOR 2) = 5.
- (2,3) : Parce que nous avons (1 XOR 5) + (3 XOR 2) = 5.

Exemple 2 :

Entrée : coordonnées = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Sortie : 10
Explication : Deux paires choisies auront une distance de 0. Il y a 10 façons de choisir deux paires.

Contraintes:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Vous avez un tableau d'entiers 2D coordinates et un entier k, où coordinates[i] = [x_i, y_i] sont les coordonnées du i-ème point dans un plan 2D.
Nous définissons la distance entre deux points (x_1, y_1) et (x_2, y_2) comme (x1 XOR x2) + (y1 XOR y2) où XOR est l'opération bit à bit XOR.
Retournez le nombre de paires (i, j) telles que i < j et que la distance entre les points i et j soit égale à k.

Exemple 1 :

Entrée : coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Sortie : 2
Explication : Nous pouvons choisir les paires suivantes :
- (0,1) : Parce que nous avons (1 XOR 4) + (2 XOR 2) = 5.
- (2,3) : Parce que nous avons (1 XOR 5) + (3 XOR 2) = 5.

Exemple 2 :

Entrée : coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Sortie : 10
Explication : Toute paire choisie aura une distance de 0. Il y a 10 façons de choisir deux paires.

Contraintes :

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Vous avez un tableau 2D d'entiers coordinates et un entier k, où coordinates[i] = [x_i, y_i] sont les coordonnées du i-ème point dans un plan 2D.
Nous définissons la distance entre deux points (x_1, y_1) et (x_2, y_2) comme (x1 XOR x2) + (y1 XOR y2) où XOR est l'opération bitwise XOR.
Retournez le nombre de paires (i, j) telles que i < j et que la distance entre les points i et j soit égale à k.

Exemple 1 :

Entrée : coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Sortie : 2
Explication : Nous pouvons choisir les paires suivantes :
- (0,1) : car (1 XOR 4) + (2 XOR 2) = 5.
- (2,3) : car (1 XOR 5) + (3 XOR 2) = 5.

Exemple 2 :

Entrée : coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Sortie : 10
Explication : Toute paire choisie aura une distance de 0. Il y a 10 façons de choisir deux paires.

Contraintes :

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


Vous avez un tableau d'entiers nums et deux entiers positifs m et k.
Retournez la somme maximale parmi tous les sous-tableaux presque uniques de longueur k de nums. Si aucun sous-tableau de ce type n'existe, retournez 0.
Un sous-tableau de nums est presque unique s'il contient au moins m éléments distincts.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2,6,7,3,1,7], m = 3, k = 4
Sortie : 18
Explication : Il y a 3 sous-tableaux presque uniques de taille k = 4. Ces sous-tableaux sont [2, 6, 7, 3], [6, 7, 3, 1], et [7, 3, 1, 7]. Parmi ces sous-tableaux, celui avec la somme maximale est [2, 6, 7, 3] qui a une somme de 18.

Exemple 2 :

Entrée : nums = [5,9,9,2,4,5,4], m = 1, k = 3
Sortie : 23
Explication : Il y a 5 sous-tableaux presque uniques de taille k. Ces sous-tableaux sont [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], et [4, 5, 4]. Parmi ces sous-tableaux, celui avec la somme maximale est [5, 9, 9] qui a une somme de 23.

Exemple 3 :

Entrée : nums = [1,2,1,2,1,2,1], m = 3, k = 3
Sortie : 0
Explication : Il n'y a pas de sous-tableaux de taille k = 3 qui contiennent au moins m = 3 éléments distincts dans le tableau donné [1,2,1,2,1,2,1]. Par conséquent, aucun sous-tableau presque unique n'existe, et la somme maximale est 0.

Contraintes :

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

Vous avez un tableau de nombres entiers et deux entiers positifs m et k.
Renvoyez la somme maximale parmi tous les sous-tableaux presque uniques de longueur k de nombres. Si aucun sous-tableau de ce type n'existe, renvoyez 0.
Un sous-tableau de nombres est presque unique s'il contient au moins m éléments distincts.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nombres = [2,6,7,3,1,7], m = 3, k = 4
Sortie : 18
Explication : Il y a 3 sous-tableaux presque uniques de taille k = 4. Ces sous-tableaux sont [2, 6, 7, 3], [6, 7, 3, 1], et [7, 3, 1, 7]. Parmi ces sous-tableaux, celui avec la somme maximale est [2, 6, 7, 3] qui a une somme de 18.

Exemple 2 :

Entrée : nombres = [5,9,9,2,4,5,4], m = 1, k = 3
Sortie : 23
Explication : Il y a 5 sous-tableaux presque uniques de taille k. Ces sous-tableaux sont [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], et [4, 5, 4]. Parmi ces sous-tableaux, celui avec la somme maximale est [5, 9, 9] qui a une somme de 23.

Exemple 3 :

Entrée : nombres = [1,2,1,2,1,2,1], m = 3, k = 3
Sortie : 0
Explication : Il n'y a pas de sous-tableaux de taille k = 3 qui contiennent au moins m = 3 éléments distincts dans le tableau donné [1,2,1,2,1,2,1]. Par conséquent, aucun sous-tableau presque unique n'existe, et la somme maximale est 0.

Contraintes :

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

Vous avez un tableau d'entiers nums et deux entiers positifs m et k.
Retournez la somme maximale parmi tous les sous-tableaux presque uniques de longueur k de nums. Si aucun sous-tableau de ce type n'existe, retournez 0.
Un sous-tableau de nums est presque unique s'il contient au moins m éléments distincts.
Un sous-tableau est une séquence contiguë et non vide d'éléments dans un tableau.

Exemple 1 :

Entrée : nums = [2,6,7,3,1,7], m = 3, k = 4
Sortie : 18
Explication : il y a 3 sous-tableaux presque uniques de taille k = 4. Ces sous-tableaux sont [2, 6, 7, 3], [6, 7, 3, 1], et [7, 3, 1, 7]. Parmi ces sous-tableaux, celui avec la somme maximale est [2, 6, 7, 3] qui a une somme de 18.

Exemple 2 :

Entrée : nums = [5,9,9,2,4,5,4], m = 1, k = 3
Sortie : 23
Explication : il y a 5 sous-tableaux presque uniques de taille k. Ces sous-tableaux sont [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], et [4, 5, 4]. Parmi ces sous-tableaux, celui avec la somme maximale est [5, 9, 9] qui a une somme de 23.

Exemple 3 :

Entrée : nums = [1,2,1,2,1,2,1], m = 3, k = 3
Sortie : 0
Explication : il n'y a pas de sous-tableaux de taille k = 3 qui contiennent au moins m = 3 éléments distincts dans le tableau donné [1,2,1,2,1,2,1]. Par conséquent, aucun sous-tableau presque unique n'existe, et la somme maximale est 0.

Contraintes :

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9


Initialement, vous avez un solde de compte bancaire de 100 dollars.
On vous donne un entier purchaseAmount représentant le montant que vous dépenserez pour un achat en dollars.
Dans le magasin où vous allez effectuer l'achat, le montant de l'achat est arrondi au multiple de 10 le plus proche. Autrement dit, vous payez un montant non négatif, roundedAmount, tel que roundedAmount soit un multiple de 10 et abs(roundedAmount - purchaseAmount) soit minimisé.
S'il existe plusieurs multiples de 10 voisins, le plus grand multiple est choisi.
Retournez un entier indiquant votre solde de compte après avoir effectué un achat d'une valeur de purchaseAmount dollars dans le magasin.
Remarque : 0 est considéré comme un multiple de 10 dans ce problème.

Exemple 1 :

Entrée : purchaseAmount = 9
Sortie : 90
Explication : Dans cet exemple, le multiple de 10 le plus proche de 9 est 10. Ainsi, votre solde de compte devient 100 - 10 = 90.

Exemple 2 :

Entrée : purchaseAmount = 15
Sortie : 80
Explication : Dans cet exemple, il y a deux multiples de 10 les plus proches de 15 : 10 et 20. Donc, le plus grand multiple, 20, est choisi.
Ainsi, votre solde de compte devient 100 - 20 = 80.

Contraintes :

0 <= purchaseAmount <= 100

Initialement, vous avez un solde de compte bancaire de 100 dollars.
On vous donne un entier purchaseAmount représentant le montant que vous dépenserez pour un achat en dollars.
Dans le magasin où vous allez effectuer l'achat, le montant de l'achat est arrondi au multiple de 10 le plus proche. En d'autres termes, vous payez un montant non négatif, roundedAmount, tel que roundedAmount soit un multiple de 10 et abs(roundedAmount - purchaseAmount) soit minimisé.
S'il existe plus d'un multiple de 10 le plus proche, le plus grand multiple est choisi.
Retournez un entier indiquant votre solde de compte après avoir effectué un achat d'une valeur de purchaseAmount dollars dans le magasin.
Remarque : 0 est considéré comme un multiple de 10 dans ce problème.

Exemple 1 :

Entrée : purchaseAmount = 9
Sortie : 90
Explication : Dans cet exemple, le multiple de 10 le plus proche de 9 est 10. Ainsi, votre solde de compte devient 100 - 10 = 90.

Exemple 2 :

Entrée : purchaseAmount = 15
Sortie : 80
Explication : Dans cet exemple, il y a deux multiples de 10 les plus proches de 15 : 10 et 20. Donc, le plus grand multiple, 20, est choisi.
Ainsi, votre solde de compte devient 100 - 20 = 80.

Contraintes :

0 <= purchaseAmount <= 100

Initialement, vous avez un solde de compte bancaire de 100 dollars.
On vous donne un entier purchaseAmount représentant le montant que vous dépenserez pour un achat en dollars.
Dans le magasin où vous allez effectuer l'achat, le montant de l'achat est arrondi au multiple de 10 le plus proche. En d'autres termes, vous payez un montant non négatif, roundedAmount, tel que roundedAmount soit un multiple de 10 et abs(roundedAmount - purchaseAmount) soit minimisé.
S'il existe plus d'un multiple de 10 le plus proche, le plus grand multiple est choisi.
Retournez un entier indiquant votre solde de compte après avoir effectué un achat d'une valeur de purchaseAmount dollars dans le magasin.
Remarque : 0 est considéré comme un multiple de 10 dans ce problème.

Exemple 1:

Entrée: purchaseAmount = 9
Sortie: 90
Explication : Dans cet exemple, le multiple de 10 le plus proche de 9 est 10. Ainsi, votre solde de compte devient 100 - 10 = 90.

Exemple 2:

Entrée: purchaseAmount = 15
Sortie: 80
Explication : Dans cet exemple, il y a deux multiples de 10 les plus proches de 15 : 10 et 20. Donc, le plus grand multiple, 20, est choisi.
Ainsi, votre solde de compte devient 100 - 20 = 80.

Contraintes:

0 <= purchaseAmount <= 100


Étant donné un tableau de chaînes de caractères words et une chaîne de caractères s, déterminez si s est un acronyme de words.
La chaîne s est considérée comme un acronyme de words si elle peut être formée en concaténant le premier caractère de chaque chaîne dans words dans l'ordre. Par exemple, "ab" peut être formé à partir de ["apple", "banana"], mais ne peut pas être formé à partir de ["bear", "aardvark"].
Retournez true si s est un acronyme de words, et false sinon.

Exemple 1 :

Entrée : words = ["alice","bob","charlie"], s = "abc"
Sortie : true
Explication : Le premier caractère des mots "alice", "bob" et "charlie" sont respectivement 'a', 'b' et 'c'. Par conséquent, s = "abc" est l'acronyme.

Exemple 2 :

Entrée : words = ["an","apple"], s = "a"
Sortie : false
Explication : Le premier caractère des mots "an" et "apple" sont 'a' et 'a', respectivement.
L'acronyme formé en concaténant ces caractères est "aa".
Par conséquent, s = "a" n'est pas l'acronyme.

Exemple 3 :

Entrée : words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Sortie : true
Explication : En concaténant le premier caractère des mots dans le tableau, nous obtenons la chaîne "ngguoy".
Par conséquent, s = "ngguoy" est l'acronyme.

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] et s sont constitués de lettres minuscules anglaises.

Étant donné un tableau de chaînes de caractères words et une chaîne s, déterminez si s est un acronyme de words.
La chaîne s est considérée comme un acronyme de words si elle peut être formée en concaténant le premier caractère de chaque chaîne dans words dans l'ordre. Par exemple, "ab" peut être formé à partir de ["apple", "banana"], mais ne peut pas être formé à partir de ["bear", "aardvark"].
Renvoyez true si s est un acronyme de words, et false dans le cas contraire.

Exemple 1 :

Entrée: words = ["alice","bob","charlie"], s = "abc"
Sortie: true
Explication : Le premier caractère des mots "alice", "bob" et "charlie" sont respectivement 'a', 'b' et 'c'. Par conséquent, s = "abc" est l'acronyme.

Exemple 2 :

Entrée: words = ["an","apple"], s = "a"
Sortie: false
Explication : Le premier caractère des mots "an" et "apple" sont 'a' et 'a', respectivement.
L'acronyme formé en concaténant ces caractères est "aa".
Par conséquent, s = "a" n'est pas l'acronyme.

Exemple 3 :

Entrée: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Sortie: true
Explication : En concaténant le premier caractère des mots dans le tableau, nous obtenons la chaîne "ngguoy".
Par conséquent, s = "ngguoy" est l'acronyme.

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] et s sont constitués de lettres minuscules anglaises.

Étant donné un tableau de chaînes de mots et une chaîne s, déterminez si s est un acronyme de mots.
La chaîne s est considérée comme un acronyme de mots si elle peut être formée en concaténant le premier caractère de chaque chaîne de mots dans l'ordre. Par exemple, "ab" peut être formé à partir de ["apple", "banana"], mais il ne peut pas être formé à partir de ["bear", "aardvark"].
Renvoie true si s est un acronyme de mots, et false sinon.

Exemple 1 :

Entrée : words = ["alice","bob","charlie"], s = "abc"
Sortie : true
Explication : Le premier caractère des mots "alice", "bob" et "charlie" sont respectivement 'a', 'b' et 'c'. Par conséquent, s = "abc" est l'acronyme.

Exemple 2 :

Entrée : words = ["an","apple"], s = "a"
Sortie : false
Explication : Le premier caractère des mots "an" et "apple" sont 'a' et 'a', respectivement.
L'acronyme formé par la concaténation de ces caractères est "aa".
Par conséquent, s = "a " n'est pas l'acronyme.

Exemple 3 :

Entrée : mots = ["never","gonna","give","up","on","you"], s = "ngguoy"
Sortie : true
Explication : en concaténant le premier caractère des mots du tableau, nous obtenons la chaîne "ngguoy".
Par conséquent, s = "ngguoy" est l'acronyme.

Contraintes :

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] et s sont constitués de lettres minuscules anglaises.


On vous donne un entier n représentant le nombre de maisons sur une ligne numérique, numérotées de 0 à n - 1.
En outre, on vous donne un tableau d'entiers à 2 dimensions offers où offers[i] = [start_i, end_i, gold_i], indiquant que le ième acheteur souhaite acheter toutes les maisons de start_i à end_i pour une somme de gold_i en or.
En tant que vendeur, votre objectif est de maximiser vos gains en sélectionnant et en vendant stratégiquement des maisons aux acheteurs.
Retournez le montant maximum d'or que vous pouvez gagner.
Notez que différents acheteurs ne peuvent pas acheter la même maison, et certaines maisons peuvent rester invendues.

Exemple 1 :

Entrée : n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Sortie : 3
Explication : Il y a 5 maisons numérotées de 0 à 4 et il y a 3 offres d'achat.
Nous vendons les maisons dans la plage [0,0] au 1er acheteur pour 1 or et les maisons dans la plage [1,3] au 3ème acheteur pour 2 ors.
On peut prouver que 3 est le montant maximum d'or que nous pouvons atteindre.

Exemple 2 :

Entrée : n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Sortie : 10
Explication : Il y a 5 maisons numérotées de 0 à 4 et il y a 3 offres d'achat.
Nous vendons les maisons dans la plage [0,2] au 2ème acheteur pour 10 ors.
On peut prouver que 10 est le montant maximum d'or que nous pouvons atteindre.

Contraintes :

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

On vous donne un nombre entier n représentant le nombre de maisons sur une droite numérique, numérotée de 0 à n - 1.
En outre, vous disposez d'un tableau d'entiers 2D, Offres, où Offres[i] = [début_i, fin_i, or_i], indiquant que le i^e acheteur souhaite acheter toutes les maisons situées entre début_i et fin_i pour une quantité d'or égale à or_i.
En tant que vendeur, votre objectif est de maximiser vos gains en sélectionnant et en vendant stratégiquement des maisons aux acheteurs.
Retournez le montant maximum d'or que vous pouvez gagner.
Notez que des acheteurs différents ne peuvent pas acheter la même maison et que certaines maisons peuvent rester invendues.

Exemple 1 :

Entrée : n = 5, offres = [[0,0,1], [0,2,2], [1,3,2]]
Sortie : 3
Explication : Il y a 5 maisons numérotées de 0 à 4 et 3 offres d'achat.
Nous vendons les maisons de l'intervalle [0,0] au 1er acheteur pour 1 or et les maisons de l'intervalle [1,3] au 3ème acheteur pour 2 ors.
On peut prouver que 3 est la quantité maximale d'or que nous pouvons obtenir.

Exemple 2 :

Entrée : n = 5, offres = [[0,0,1], [0,2,10], [1,3,2]]
Sortie : 10
Explication : Il y a 5 maisons numérotées de 0 à 4 et 3 offres d'achat.
Nous vendons les maisons situées dans l'intervalle [0,2] au deuxième acheteur pour 10 pièces d'or.
On peut prouver que 10 est la quantité maximale d'or que nous pouvons obtenir.

Contraintes :

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3


Vous avez deux entiers positifs low et high.
Un entier x composé de 2 * n chiffres est symétrique si la somme des n premiers chiffres de x est égale à la somme des n derniers chiffres de x. Les nombres ayant un nombre impair de chiffres ne sont jamais symétriques.
Retournez le nombre d'entiers symétriques dans l'intervalle [low, high].

Exemple 1 :

Input: low = 1, high = 100
Output: 9
Explication : Il y a 9 entiers symétriques entre 1 et 100 : 11, 22, 33, 44, 55, 66, 77, 88, et 99.

Exemple 2 :

Input: low = 1200, high = 1230
Output: 4
Explication : Il y a 4 entiers symétriques entre 1200 et 1230 : 1203, 1212, 1221, et 1230.

Contraintes :

1 <= low <= high <= 10^4

On vous donne deux nombres entiers positifs, l'un faible et l'autre élevé.
Un entier x composé de 2 * n chiffres est symétrique si la somme des n premiers chiffres de x est égale à la somme des n derniers chiffres de x. Les nombres comportant un nombre impair de chiffres ne sont jamais symétriques.
Elle renvoie le nombre d'entiers symétriques dans l'intervalle [low, high].

Exemple 1 :

Entrée : low = 1, high = 100
Sortie : 9
Explication : Il existe 9 entiers symétriques compris entre 1 et 100 : 11, 22, 33, 44, 55, 66, 77, 88 et 99.

Exemple 2 :

Entrée :  low = 1200, high = 1230
Sortie : 4
Explication : Il y a 4 entiers symétriques entre 1200 et 1230 : 1203, 1212, 1221, et 1230.

Contraintes :

1 <= low <= high <= 10^4


Vous avez deux chaînes s1 et s2, toutes deux de longueur 4, composées de lettres minuscules anglaises.
Vous pouvez effectuer l'opération suivante sur l'une des deux chaînes un nombre quelconque de fois :

Choisissez deux indices i et j tels que j - i = 2, puis échangez les deux caractères à ces indices dans la chaîne.

Retournez true si vous pouvez rendre les chaînes s1 et s2 égales, et false sinon.

Exemple 1 :

Entrée : s1 = "abcd", s2 = "cdab"
Sortie : true
Explication : Nous pouvons effectuer les opérations suivantes sur s1 :
- Choisissez les indices i = 0, j = 2. La chaîne résultante est s1 = "cbad".
- Choisissez les indices i = 1, j = 3. La chaîne résultante est s1 = "cdab" = s2.

Exemple 2 :

Entrée : s1 = "abcd", s2 = "dacb"
Sortie : false
Explication : Il n'est pas possible de rendre les deux chaînes égales.

Contraintes :

s1.length == s2.length == 4
s1 et s2 consistent uniquement en lettres minuscules anglaises.

On vous donne deux chaînes S1 et S2, toutes deux de la longueur 4, composée de lettres anglaises minuscules.
Vous pouvez appliquer l'opération suivante sur l'une des deux chaînes un nombre quelconque de fois:

Choisissez deux indices I et J tels que j - i = 2, puis échangez les deux caractères à ces indices de la chaîne.

Retournez true si vous pouvez rendre les chaînes s1 et s2 égales, et false sinon.

Exemple 1:

Entrée:  s1 = "abcd", s2 = "cdab"
Sortie: true
Explication: Nous pouvons effectuer les opérations suivantes sur s1:
- Choisissez les indices i = 0, j = 2. La chaîne résultante est s1 = "cbad".
- Choisissez les indices i = 1, j = 3. La chaîne résultante est s1 = "cdab" = s2.

Exemple 2:

Entrée:  s1 = "abcd", s2 = "dacb"
Sortie: false
Explication: Il n'est pas possible de faire en sorte que les deux chaînes égales.

Contraintes:

s1.length == s2.length == 4
s1 et s2 se composent uniquement de lettres anglaises minuscules.

Vous avez deux chaînes s1 et s2, toutes deux de longueur 4, composées de lettres minuscules anglaises. Vous pouvez appliquer l'opération suivante sur l'une des deux chaînes un nombre quelconque de fois :

Choisissez deux indices i et j tels que j - i = 2, puis échangez les deux caractères à ces indices dans la chaîne.

Renvoyez vrai si vous pouvez rendre les chaînes s1 et s2 égales, et faux dans le cas contraire.

Exemple 1 :

Entrée : s1 = "abcd", s2 = "cdab"
Sortie : true
Explication : Nous pouvons effectuer les opérations suivantes sur s1 :
- Choisissez les indices i = 0, j = 2. La chaîne résultante est s1 = "cbad".
- Choisissez les indices i = 1, j = 3. La chaîne résultante est s1 = "cdab" = s2.

Exemple 2 :

Entrée : s1 = "abcd", s2 = "dacb"
Sortie : false
Explication : Il n'est pas possible de rendre les deux chaînes égales.

Contraintes :

s1.length == s2.length == 4
s1 et s2 consistent uniquement en lettres minuscules anglaises.


On vous donne un tableau d'entiers indexé à partir de 0 nommé `nums` et un entier `x`.
Trouvez la différence absolue minimale entre deux éléments du tableau qui sont séparés par au moins `x` indices.
En d'autres termes, trouvez deux indices `i` et `j` tels que `abs(i - j) >= x` et `abs(nums[i] - nums[j])` soit minimisé.
Retournez un entier représentant la différence absolue minimale entre deux éléments qui sont séparés par au moins `x` indices.

Exemple 1 :

Entrée : nums = [4,3,2,4], x = 2
Sortie : 0
Explication : Nous pouvons sélectionner `nums[0] = 4` et `nums[3] = 4`.
Ils sont séparés par au moins 2 indices, et leur différence absolue est la minimale, 0.
On peut démontrer que 0 est la réponse optimale.

Exemple 2 :

Entrée : nums = [5,3,2,10,15], x = 1
Sortie : 1
Explication : Nous pouvons sélectionner `nums[1] = 3` et `nums[2] = 2`.
Ils sont séparés par au moins 1 indice, et leur différence absolue est la minimale, 1.
On peut démontrer que 1 est la réponse optimale.

Exemple 3 :

Entrée : nums = [1,2,3,4], x = 3
Sortie : 3
Explication : Nous pouvons sélectionner `nums[0] = 1` et `nums[3] = 4`.
Ils sont séparés par au moins 3 indices, et leur différence absolue est la minimale, 3.
On peut démontrer que 3 est la réponse optimale.

Contraintes :

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

On vous donne un tableau nums d'entiers indexé à partir de 0 et un entier x.
Trouvez la différence absolue minimale entre deux éléments du tableau qui sont séparés par au moins x indices.
En d'autres termes, trouvez deux indices i et j tels que abs(i - j) >= x et abs(nums[i] - nums[j]) soit minimisé.
Retournez un entier représentant la différence absolue minimale entre deux éléments qui sont séparés par au moins x indices.

Exemple 1 :

Entrée : nums = [4,3,2,4], x = 2
Sortie : 0
Explication : Nous pouvons sélectionner nums[0] = 4 et nums[3] = 4.
Ils sont séparés par au moins 2 indices, et leur différence absolue est la minimale, 0.
On peut démontrer que 0 est la réponse optimale.

Exemple 2 :

Entrée : nums = [5,3,2,10,15], x = 1
Sortie : 1
Explication : Nous pouvons sélectionner nums[1] = 3 et nums[2] = 2.
Ils sont séparés par au moins 1 indice, et leur différence absolue est la minimale, 1.
On peut démontrer que 1 est la réponse optimale.

Exemple 3 :

Entrée : nums = [1,2,3,4], x = 3
Sortie : 3
Explication : Nous pouvons sélectionner nums[0] = 1 et nums[3] = 4.
Ils sont séparés par au moins 3 indices, et leur différence absolue est la minimale, 3.
On peut démontrer que 3 est la réponse optimale.

Contraintes :

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

On vous donne un tableau d'entiers indexés 0 nums et un entier x.
Trouvez la différence absolue minimale entre deux éléments du tableau qui sont séparés d'au moins x indices.
En d'autres termes, trouvez deux indices i et j tels que abs(i - j) >= x et abs(nums[i] - nums[j]) soit minimisé.
Renvoie un entier indiquant la différence absolue minimale entre deux éléments qui sont séparés d'au moins x indices.

Exemple 1 :

Entrée : nums = [4,3,2,4], x = 2
Sortie : 0
Explication : Nous pouvons sélectionner nums[0] = 4 et nums[3] = 4.
Ils sont séparés d'au moins 2 indices et leur différence absolue est le minimum, 0.
On peut montrer que 0 est la réponse optimale.

Exemple 2 :

Entrée : nums = [5,3,2,10,15], x = 1
Sortie : 1
Explication : Nous pouvons sélectionner nums[1] = 3 et nums[2] = 2.
Ils sont séparés d'au moins 1 indice et leur différence absolue est le minimum, 1.
Il peut être démontré que 1 est la réponse optimale.

Exemple 3 :

Entrée : nums = [1,2,3,4], x = 3
Sortie : 3
Explication : Nous pouvons sélectionner nums[0] = 1 et nums[3] = 4.
Ils sont séparés d'au moins 3 indices et leur différence absolue est le minimum, 3.
Il peut être démontré que 3 est la réponse optimale.

Contraintes :

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


Vous avez des entiers positifs low, high, et k.
Un nombre est dit beau s'il répond à ces deux conditions :

Le nombre de chiffres pairs dans le nombre est égal au nombre de chiffres impairs.
Le nombre est divisible par k.

Retournez le nombre de nombres beaux dans l'intervalle [low, high].

Exemple 1 :

Entrée : low = 10, high = 20, k = 3
Sortie : 2
Explication : Il y a 2 nombres beaux dans l'intervalle donné : [12,18].
- 12 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
- 18 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
De plus, nous pouvons voir que :
- 16 n'est pas beau car il n'est pas divisible par k = 3.
- 15 n'est pas beau car il ne contient pas un nombre égal de chiffres pairs et impairs.
Il peut être montré qu'il y a seulement 2 nombres beaux dans l'intervalle donné.

Exemple 2 :

Entrée : low = 1, high = 10, k = 1
Sortie : 1
Explication : Il y a 1 nombre beau dans l'intervalle donné : [10].
- 10 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 1.
Il peut être montré qu'il y a seulement 1 nombre beau dans l'intervalle donné.

Exemple 3 :

Entrée : low = 5, high = 5, k = 2
Sortie : 0
Explication : Il y a 0 nombres beaux dans l'intervalle donné.
- 5 n'est pas beau car il n'est pas divisible par k = 2 et il ne contient pas un nombre égal de chiffres pairs et impairs.

Contraintes :

0 < low <= high <= 10^9
0 < k <= 20

On vous donne des entiers positifs low, high, et k.
Un nombre est beau s'il répond à ces deux conditions :

Le nombre de chiffres pairs dans le nombre est égal au nombre de chiffres impairs.
Le nombre est divisible par k.

Renvoyez le nombre de nombres beaux dans l'intervalle [low, high].

Exemple 1 :

Entrée : low = 10, high = 20, k = 3
Sortie : 2
Explication : Il y a 2 nombres beaux dans l'intervalle donné : [12,18].
- 12 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
- 18 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
De plus, nous pouvons voir que :
- 16 n'est pas beau car il n'est pas divisible par k = 3.
- 15 n'est pas beau car il ne contient pas un nombre égal de chiffres pairs et impairs.
Il peut être montré qu'il y a seulement 2 nombres beaux dans l'intervalle donné.

Exemple 2 :

Entrée : low = 1, high = 10, k = 1
Sortie : 1
Explication : Il y a 1 nombre beau dans l'intervalle donné : [10].
- 10 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 1.
Il peut être montré qu'il y a seulement 1 nombre beau dans l'intervalle donné.

Exemple 3 :

Entrée : low = 5, high = 5, k = 2
Sortie : 0
Explication : Il y a 0 nombres beaux dans l'intervalle donné.
- 5 n'est pas beau car il n'est pas divisible par k = 2 et il ne contient pas un nombre égal de chiffres pairs et impairs.

Contraintes :

0 < low <= high <= 10^9
0 < k <= 20

On vous donne des entiers positifs low, high et k.
Un nombre est beau s'il remplit les deux conditions suivantes :

Le nombre de chiffres pairs dans le nombre est égal au nombre de chiffres impairs.
Le nombre est divisible par k.

Renvoie le nombre d'entiers beaux dans la plage [low, high].

Exemple 1 :

Entrée : low = 10, high = 20, k = 3
Sortie : 2
Explication : Il y a 2 entiers beaux dans la plage donnée : [12,18].
- 12 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
- 18 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 3.
De plus, nous pouvons voir que :
- 16 n'est pas beau car il n'est pas divisible par k = 3.
- 15 n'est pas beau car il ne contient pas autant de chiffres pairs et impairs.
On peut montrer qu'il n'y a que 2 beaux entiers dans la plage donnée.

Exemple 2 :

Entrée : low = 1, high = 10, k = 1
Sortie : 1
Explication : Il y a 1 bel entier dans la plage donnée : [10].
- 10 est beau car il contient 1 chiffre impair et 1 chiffre pair, et est divisible par k = 1.
On peut montrer qu'il n'y a qu'un seul bel entier dans la plage donnée.

Exemple 3 :

Entrée : low = 5, high = 5, k = 2
Sortie : 0
Explication : Il y a 0 beaux entiers dans la plage donnée.
- 5 n'est pas beau car il n'est pas divisible par k = 2 et il ne contient pas de chiffres pairs et impairs égaux.

Contraintes :

0 < low <= high <= 10^9
0 < k <= 20


Vous avez deux chaînes indexées à partir de 0, str1 et str2.
Lors d'une opération, vous sélectionnez un ensemble d'indices dans str1, et pour chaque indice i dans l'ensemble, vous incrémentez str1[i] au caractère suivant de manière cyclique. C'est-à-dire que 'a' devient 'b', 'b' devient 'c', et ainsi de suite, et 'z' devient 'a'.
Retournez true s'il est possible de faire de str2 une sous-séquence de str1 en effectuant l'opération au plus une fois, et false sinon.
Remarque : Une sous-séquence d'une chaîne est une nouvelle chaîne formée à partir de la chaîne originale en supprimant certains (éventuellement aucun) caractères sans perturber les positions relatives des caractères restants.

Exemple 1 :

Entrée : str1 = "abc", str2 = "ad"
Sortie : true
Explication : Sélectionnez l'indice 2 dans str1.
Incrémentez str1[2] pour devenir 'd'.
Ainsi, str1 devient "abd" et str2 est maintenant une sous-séquence. Par conséquent, true est retourné.
Exemple 2 :

Entrée : str1 = "zc", str2 = "ad"
Sortie : true
Explication : Sélectionnez les indices 0 et 1 dans str1.
Incrémentez str1[0] pour devenir 'a'.
Incrémentez str1[1] pour devenir 'd'.
Ainsi, str1 devient "ad" et str2 est maintenant une sous-séquence. Par conséquent, true est retourné.
Exemple 3 :

Entrée : str1 = "ab", str2 = "d"
Sortie : false
Explication : Dans cet exemple, il peut être démontré qu'il est impossible de faire de str2 une sous-séquence de str1 en utilisant l'opération au plus une fois.
Par conséquent, false est retourné.

Contraintes :

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 et str2 sont composées uniquement de lettres minuscules anglaises.

On vous donne deux chaînes indexées à 0, str1 et str2.
Dans une opération, vous sélectionnez un ensemble d'indices dans str1, et pour chaque index i dans l'ensemble, vous incrémentez str1[i] au caractère suivant de manière cyclique. C'est-à-dire que 'a' devient 'b', 'b' devient 'c', et ainsi de suite, et 'z' devient 'a'.
Renvoie true s'il est possible de faire de str2 une sous-séquence de str1 en effectuant l'opération au plus une fois, et false dans le cas contraire.
Remarque : une sous-séquence d'une chaîne est une nouvelle chaîne formée à partir de la chaîne d'origine en supprimant certains (éventuellement aucun) des caractères sans perturber les positions relatives des caractères restants.

Exemple 1 :

Entrée : str1 = "abc", str2 = "ad"
Sortie : true
Explication : sélectionnez l'index 2 dans str1.
Incrémentez str1[2] pour qu'il devienne 'd'.
Ainsi, str1 devient "abd" et str2 est maintenant une sous-séquence. Par conséquent, true est renvoyé.
Exemple 2 :

Entrée : str1 = "zc", str2 = "ad"
Sortie : true
Explication : Sélectionnez les indices 0 et 1 dans str1.
Incrémentez str1[0] pour qu'il devienne 'a'.
Incrémentez str1[1] pour qu'il devienne 'd'.
Par conséquent, str1 devient "ad" et str2 est maintenant une sous-séquence. Par conséquent, true est renvoyé.
Exemple 3 :

Entrée : str1 = "ab", str2 = "d"
Sortie : false
Explication : Dans cet exemple, il peut être démontré qu'il est impossible de faire de str2 une sous-séquence de str1 en utilisant l'opération au plus une fois.
Par conséquent, false est renvoyé.

Contraintes :

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

Vous avez deux chaînes à indices 0, str1 et str2.
Lors d'une opération, vous sélectionnez un ensemble d'indices dans str1, et pour chaque indice i dans l'ensemble, vous incrémentez str1[i] au caractère suivant de manière cyclique. C'est-à-dire que 'a' devient 'b', 'b' devient 'c', et ainsi de suite, et 'z' devient 'a'.
Renvoyez vrai s'il est possible de faire de str2 une sous-séquence de str1 en effectuant l'opération au plus une fois, et faux dans le cas contraire.
Remarque : Une sous-séquence d'une chaîne est une nouvelle chaîne formée à partir de la chaîne originale en supprimant certains (éventuellement aucun) caractères sans perturber les positions relatives des caractères restants.

Exemple 1 :

Entrée : str1 = "abc", str2 = "ad"
Sortie : true
Explication : Sélectionnez l'indice 2 dans str1.
Incrémentez str1[2] pour devenir 'd'.
Ainsi, str1 devient "abd" et str2 est maintenant une sous-séquence. Par conséquent, vrai est renvoyé.
Exemple 2 :

Entrée : str1 = "zc", str2 = "ad"
Sortie : true
Explication : Sélectionnez les indices 0 et 1 dans str1.
Incrémentez str1[0] pour devenir 'a'.
Incrémentez str1[1] pour devenir 'd'.
Ainsi, str1 devient "ad" et str2 est maintenant une sous-séquence. Par conséquent, vrai est renvoyé.
Exemple 3 :

Entrée : str1 = "ab", str2 = "d"
Sortie : false
Explication : Dans cet exemple, il peut être démontré qu'il est impossible de faire de str2 une sous-séquence de str1 en utilisant l'opération au plus une fois.
Par conséquent, faux est renvoyé.

Contraintes :

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 et str2 sont composées uniquement de lettres minuscules anglaises.


On vous donne une chaîne moves de longueur n composée uniquement de caractères 'L', 'R' et '_'. La chaîne représente votre mouvement sur une droite numérique à partir de l'origine 0.
Lors du i^ème mouvement, vous pouvez choisir une des directions suivantes :

se déplacer vers la gauche si moves[i] = 'L' ou moves[i] = '_'
se déplacer vers la droite si moves[i] = 'R' ou moves[i] = '_'

Renvoie la distance à partir de l'origine du point le plus éloigné que vous pouvez atteindre après n mouvements.

Exemple 1 :

Entrée : moves = "L_RL__R"
Sortie : 3
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -3 à travers la séquence de mouvements suivante "LLRLLLR".

Exemple 2 :

Entrée : moves = "_R__LL_"
Sortie : 5
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -5 à travers la séquence de mouvements suivante "LRLLLLL".

Exemple 3 :

Entrée : moves = "_______"
Sortie : 7
Explication : le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point 7 à travers la séquence de mouvements suivante "RRRRRRR".

Contraintes :

1 <= moves.length == n <= 50
moves se compose uniquement de caractères 'L', 'R' et '_'.

On donne une chaîne moves de longueur n composée uniquement de caractères 'L', 'R' et '_'. La chaîne représente votre mouvement sur une droite numérique à partir de l'origine 0.
Lors du i^ème mouvement, vous pouvez choisir une des directions suivantes :

se déplacer vers la gauche si moves[i] = 'L' ou moves[i] = '_'
se déplacer vers la droite si moves[i] = 'R' ou moves[i] = '_'

Retournez la distance depuis l'origine du point le plus éloigné auquel vous pouvez arriver après n mouvements.

Exemple 1 :

Entrée : moves = "L_RL__R"
Sortie : 3
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -3 à travers la séquence de mouvements suivante "LLRLLLR".

Exemple 2 :

Entrée : moves = "_R__LL_"
Sortie : 5
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -5 à travers la séquence de mouvements suivante "LRLLLLL".

Exemple 3 :

Entrée : moves = "_______"
Sortie : 7
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point 7 à travers la séquence de mouvements suivante "RRRRRRR".

Contraintes :

1 <= moves.length == n <= 50
moves se compose uniquement de caractères 'L', 'R' et '_'.

On vous donne une chaîne de mouvements de longueur n composée uniquement des caractères 'L', 'R' et '_'. La chaîne représente votre mouvement sur une droite numérique à partir de l'origine 0.
Au i^ème mouvement, vous pouvez choisir l'une des directions suivantes :

déplacement vers la gauche si moves[i] = 'L' ou moves[i] = '_'
déplacement vers la droite si moves[i] = 'R' ou moves[i] = '_'

Renvoie la distance depuis l'origine du point le plus éloigné que vous pouvez atteindre après n mouvements.

Exemple 1 :

Entrée : moves = "L_RL__R"
Sortie : 3
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -3 via la séquence de mouvements suivante "LLRLLLR".

Exemple 2 :

Entrée : moves = "_R__LL_"
Sortie : 5
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point -5 grâce à la séquence de mouvements suivante : "LRLLLLL".

Exemple 3 :

Entrée : moves = "_______"
Sortie : 7
Explication : Le point le plus éloigné que nous pouvons atteindre depuis l'origine 0 est le point 7 grâce à la séquence de mouvements suivante : "RRRRRRR".

Contraintes :

1 <= moves.length == n <= 50
moves se compose uniquement des caractères 'L', 'R' et '_'.


Vous avez deux chaînes de caractères s et t de longueur égale n. Vous pouvez effectuer l'opération suivante sur la chaîne s :

Retirez un suffixe de s de longueur l où 0 < l < n et ajoutez-le au début de s.
	Par exemple, si s = 'abcd', alors en une opération vous pouvez retirer le suffixe 'cd' et l'ajouter au début de s pour obtenir s = 'cdab'.

Vous avez également un entier k. Retournez le nombre de façons dont s peut être transformé en t en exactement k opérations.
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : s = "abcd", t = "cdab", k = 2
Sortie : 2
Explication :
Première façon :
Lors de la première opération, choisissez le suffixe à partir de l'index = 3, donc s = "dabc".
Lors de la deuxième opération, choisissez le suffixe à partir de l'index = 3, donc s = "cdab".

Deuxième façon :
Lors de la première opération, choisissez le suffixe à partir de l'index = 1, donc s = "bcda".
Lors de la deuxième opération, choisissez le suffixe à partir de l'index = 1, donc s = "cdab".

Exemple 2 :

Entrée : s = "ababab", t = "ababab", k = 1
Sortie : 2
Explication :
Première façon :
Choisissez le suffixe à partir de l'index = 2, donc s = "ababab".

Deuxième façon :
Choisissez le suffixe à partir de l'index = 4, donc s = "ababab".

Contraintes :

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s et t sont composées uniquement de lettres minuscules de l'alphabet anglais.

On vous donne deux chaînes s et t de longueur égale n. Vous pouvez effectuer l'opération suivante sur la chaîne s :

Supprimez un suffixe de s de longueur l où 0 < l < n et ajoutez-le au début de s.
Par exemple, soit s = 'abcd' puis en une seule opération vous pouvez supprimer le suffixe 'cd' et l'ajouter devant s, ce qui donne s = 'cdab'.

On vous donne également un entier k. Renvoie le nombre de façons dont s peut être transformé en t en exactement k opérations.
Étant donné que la réponse peut être grande, renvoyez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : s = "abcd", t = "cdab", k = 2
Sortie : 2
Explication :
Première méthode :
Dans la première opération, choisissez le suffixe à partir de l'index = 3, donc le résultat est s = "dabc".
Dans la deuxième opération, choisissez le suffixe à partir de l'index = 3, donc le résultat s = "cdab".

Deuxième méthode :
Dans la première opération, choisissez le suffixe à partir de l'index = 1, donc le résultat s = "bcda".

Dans la deuxième opération, choisissez le suffixe à partir de l'index = 1, donc le résultat s = "cdab".

Exemple 2 :

Entrée : s = "ababab", t = "ababab", k = 1
Sortie : 2
Explication :
Première méthode :
Choisissez le suffixe à partir de l'index = 2, donc le résultat s = "ababab".

Deuxième méthode :
Choisissez le suffixe à partir de l'index = 4, donc le résultat s = "ababab".

Contraintes :

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s et t sont constitués uniquement d'alphabets anglais minuscules.

On vous donne deux chaînes de caractères s et t de longueur égale n. Vous pouvez effectuer l'opération suivante sur la chaîne s :

Retirez un suffixe de s de longueur l où 0 < l < n et ajoutez-le au début de s.
	Par exemple, si s = 'abcd', alors en une opération vous pouvez retirer le suffixe 'cd' et l'ajouter au début de s pour obtenir s = 'cdab'.

On vous donne également un entier k. Retournez le nombre de façons dont s peut être transformé en t en exactement k opérations.
Comme la réponse peut être grande, retournez-la modulo 10^9 + 7.

Exemple 1 :

Entrée : s = "abcd", t = "cdab", k = 2
Sortie : 2
Explication :
Première façon :
Lors de la première opération, choisissez le suffixe à partir de l'indice = 3, ce qui donne s = "dabc".
Lors de la deuxième opération, choisissez le suffixe à partir de l'indice = 3, ce qui donne s = "cdab".

Deuxième façon :
Lors de la première opération, choisissez le suffixe à partir de l'indice = 1, ce qui donne s = "bcda".
Lors de la deuxième opération, choisissez le suffixe à partir de l'indice = 1, ce qui donne s = "cdab".

Exemple 2 :

Entrée : s = "ababab", t = "ababab", k = 1
Sortie : 2
Explication :
Première façon :
Choisissez le suffixe à partir de l'indice = 2, ce qui donne s = "ababab".

Deuxième façon :
Choisissez le suffixe à partir de l'index = 4, ce qui donne s = "ababab".

Contraintes :

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s et t ne contiennent que des lettres minuscules anglaises.


On vous donne un tableau indexé à partir de 0 nommé nums, composé de puissances non négatives de 2, et un entier target.
Dans une opération, vous devez appliquer les changements suivants au tableau :

Choisissez un élément du tableau nums[i] tel que nums[i] > 1.
Supprimez nums[i] du tableau.
Ajoutez deux occurrences de nums[i] / 2 à la fin de nums.

Retournez le nombre minimum d'opérations que vous devez effectuer pour que nums contienne une sous-séquence dont la somme des éléments est égale à target. S'il est impossible d'obtenir une telle sous-séquence, renvoyez -1.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains ou aucun élément sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,8], target = 7
Sortie : 1
Explication : Lors de la première opération, nous choisissons l'élément nums[2]. Le tableau devient égal à nums = [1,2,4,4].
À ce stade, nums contient la sous-séquence [1,2,4] qui somme à 7.
Il peut être démontré qu'il n'existe pas de séquence d'opérations plus courte qui aboutit à une sous-séquence qui somme à 7.

Exemple 2 :

Entrée : nums = [1,32,1,2], target = 12
Sortie : 2
Explication : Lors de la première opération, nous choisissons l'élément nums[1]. Le tableau devient égal à nums = [1,1,2,16,16].
Lors de la deuxième opération, nous choisissons l'élément nums[3]. Le tableau devient égal à nums = [1,1,2,16,8,8]
À ce stade, nums contient la sous-séquence [1,1,2,8] qui somme à 12.
Il peut être démontré qu'il n'existe pas de séquence d'opérations plus courte qui aboutit à une sous-séquence qui somme à 12.

Exemple 3 :

Entrée : nums = [1,32,1], target = 35
Sortie : -1
Explication : Il peut être démontré qu'aucune séquence d'opérations ne conduit à une sous-séquence qui somme à 35.

Contraintes :

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums se compose uniquement de puissances non négatives de deux.
1 <= target < 2^31

On vous donne un tableau nums indexé à partir de 0 nommé composé de puissances non négatives de 2, et un entier target.
Dans une opération, vous devez appliquer les changements suivants au tableau :

Choisissez un élément du tableau nums[i] tel que nums[i] > 1.
Supprimez nums[i] du tableau.
Ajoutez deux occurrences de nums[i] / 2 à la fin de nums.

Retournez le nombre minimum d'opérations que vous devez effectuer pour que nums contienne une sous-séquence dont la somme des éléments est égale à target. S'il est impossible d'obtenir une telle sous-séquence, retournez -1.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains ou aucun élément sans changer l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,8], target = 7
Sortie : 1
Explication : Lors de la première opération, nous choisissons l'élément nums[2]. Le tableau devient égal à nums = [1,2,4,4].
À ce stade, nums contient la sous-séquence [1,2,4] dont la somme est égale à 7.
On peut montrer qu'il n'existe pas de séquence d'opérations plus courte qui aboutit à une sous-séquence dont la somme est égale  à 7.

Exemple 2 :

Entrée : nums = [1,32,1,2], target = 12
Sortie : 2
Explication : Lors de la première opération, nous choisissons l'élément nums[1]. Le tableau devient égal à nums = [1,1,2,16,16].
Lors de la deuxième opération, nous choisissons l'élément nums[3]. Le tableau devient égal à nums = [1,1,2,16,8,8]
À ce stade, nums contient la sous-séquence [1,1,2,8] dont la somme est égale à 12.
On peut montrer qu'il n'existe pas de séquence d'opérations plus courte aboutissant à une sous-séquence dont la somme est égale  à 12.
Exemple 3 :

Entrée : nums = [1,32,1], target = 35
Sortie : -1
Explication : On peut montrer qu'aucune séquence d'opérations ne conduit à une sous-séquence dont la somme égale 35.

Contraintes :

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums se compose uniquement de puissances non négatives de deux.
1 <= target < 2^31

On vous donne un tableau indexé à 0 nums composé de puissances non négatives de 2 et d'un entier target.
En une seule opération, vous devez appliquer les modifications suivantes au tableau :

Choisissez un élément du tableau nums[i] tel que nums[i] > 1.
Supprimez nums[i] du tableau.
Ajoutez deux occurrences de nums[i] / 2 à la fin de nums.

Renvoie le nombre minimal d'opérations que vous devez effectuer pour que nums contienne une sous-séquence dont la somme des éléments correspond à target. S'il est impossible d'obtenir une telle sous-séquence, renvoie -1.
Une sous-séquence est un tableau qui peut être dérivé d'un autre tableau en supprimant certains ou aucun élément sans modifier l'ordre des éléments restants.

Exemple 1 :

Entrée : nums = [1,2,8], target = 7
Sortie : 1
Explication : Dans la première opération, nous choisissons l'élément nums[2]. Le tableau devient égal à nums = [1,2,4,4].
A ce stade, nums contient la sous-séquence [1,2,4] qui totalise 7.
On peut montrer qu'il n'existe pas de séquence d'opérations plus courte qui aboutisse à une sous-séquence dont la somme est égale à 7.

Exemple 2 :

Entrée : nums = [1,32,1,2], cible = 12
Sortie : 2
Explication : Dans la première opération, nous choisissons l'élément nums[1]. Le tableau devient égal à nums = [1,1,2,16,16].
Dans la deuxième opération, nous choisissons l'élément nums[3]. Le tableau devient égal à nums = [1,1,2,16,8,8]
A ce stade, nums contient la sous-séquence [1,1,2,8] qui totalise 12.
On peut montrer qu'il n'existe pas de séquence d'opérations plus courte qui aboutisse à une sous-séquence dont la somme est de 12.
Exemple 3 :

Entrée : nums = [1,32,1], cible = 35
Sortie : -1
Explication : On peut montrer qu'aucune séquence d'opérations n'aboutit à une sous-séquence dont la somme est de 35.

Contraintes :

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums se compose uniquement de puissances non négatives de deux.
1 <= target < 2^31


Étant donnée une matrice grid d'entiers 2D indexée à partir de 0 de taille n * m, nous définissons une matrice 2D indexée à partir de 0, p, de taille n * m comme la matrice produit de grid si la condition suivante est remplie :

Chaque élément p[i][j] est calculé comme le produit de tous les éléments de grid sauf l'élément grid[i][j]. Ce produit est ensuite pris modulo 12345.

Retourner la matrice produit de grid.

Exemple 1 :

Entrée : grid = [[1,2],[3,4]]
Sortie : [[24,12],[8,6]]
Explication : p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Donc, la réponse est [[24,12],[8,6]].
Exemple 2 :

Entrée : grid = [[12345],[2],[1]]
Sortie : [[2],[0],[0]]
Explication : p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Donc, p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Donc, p[0][2] = 0.
Donc, la réponse est [[2],[0],[0]].

Contraintes :

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Étant donné une matrice d'entiers 2D indexée à partir de 0, `grid`, de taille n * m, nous définissons une matrice 2D indexée à partir de 0, `p`, de taille n * m comme la matrice produit de `grid` si la condition suivante est remplie :

Chaque élément `p[i][j]` est calculé comme le produit de tous les éléments de `grid` sauf l'élément `grid[i][j]`. Ce produit est ensuite pris modulo 12345.

Retourner la matrice produit de `grid`.

Exemple 1 :

Entrée : grid = [[1,2],[3,4]]
Sortie : [[24,12],[8,6]]
Explication : p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Donc, la réponse est [[24,12],[8,6]].

Exemple 2 :

Entrée : grid = [[12345],[2],[1]]
Sortie : [[2],[0],[0]]
Explication : p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Donc, p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Donc, p[0][2] = 0.
Donc, la réponse est [[2],[0],[0]].

Contraintes :

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Étant donné une grille de matrice entière 2D à 0 indexée de taille n * m, nous définissons une matrice 2D 2D indexée à 0 de taille n * m comme matrice de produit de la grille si la condition suivante est remplie:

Chaque élément p [i] [j] est calculé comme le produit de tous les éléments de la grille à l'exception de la grille d'élément [i] [j]. Ce produit est ensuite pris modulo 12345.

Renvoyez la matrice du produit de la grille.

Exemple 1:

Entrée: grid = [[1,2], [3,4]]
Sortie: [[24,12], [8,6]]
Explication: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
La réponse est donc [[24,12], [8,6]].
Exemple 2:

Entrée: grid = [[12345], [2], [1]]
Sortie: [[2], [0], [0]]
Explication: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. So p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. So p[0][2] = 0.
La réponse est donc [[2], [0], [0]].

Contraintes:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


Vous disposez d'un tableau receiver d'entiers de longueur n indexé à partir de zéro, et d'un entier k.
Il y a n joueurs ayant un identifiant unique dans la plage [0, n - 1] qui joueront à un jeu de passe de ballon, et receiver[i] est l'id du joueur qui reçoit les passes du joueur avec l'id i. Les joueurs peuvent se passer le ballon à eux-mêmes, c'est-à-dire que receiver[i] peut être égal à i.
Vous devez choisir l'un des n joueurs comme joueur de départ pour le jeu, et le ballon sera passé exactement k fois à partir du joueur choisi.
Pour un joueur de départ choisi ayant l'id x, nous définissons une fonction f(x) qui désigne la somme de x et des ids de tous les joueurs qui reçoivent le ballon durant les k passes, y compris les répétitions. En d'autres termes, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Votre tâche est de choisir un joueur de départ ayant l'id x qui maximise la valeur de f(x).
Retournez un entier désignant la valeur maximale de la fonction.
Remarque: receiver peut contenir des doublons.

Exemple 1:

Nombre de Passes
ID Expéditeur
ID Récepteur
x + IDs Récepteur

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrée: receiver = [2,0,1], k = 4
Sortie: 6
Explication: Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'id x = 2.
D'après le tableau, f(2) est égal à 6.
Il peut être démontré que 6 est la valeur maximale atteignable de la fonction.
Par conséquent, le résultat est 6.

Exemple 2:

Nombre de Passes
ID Expéditeur
ID Récepteur
x + IDs Récepteur

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrée: receiver = [1,1,1,2,3], k = 3
Sortie: 10
Explication: Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'id x = 4.
D'après le tableau, f(4) est égal à 10.
Il peut être démontré que 10 est la valeur maximale atteignable de la fonction.
Par conséquent, le résultat est 10.

Contraintes:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Vous disposez d'un tableau d'entiers indexé à partir de zéro, `receiver`, de longueur n, et d'un entier k.
Il y a n joueurs ayant un identifiant unique dans la plage [0, n - 1] qui joueront à un jeu de passe de ballon, et `receiver[i]` est l'id du joueur qui reçoit les passes du joueur avec l'id i. Les joueurs peuvent se passer le ballon à eux-mêmes, c'est-à-dire que `receiver[i]` peut être égal à i.
Vous devez choisir l'un des n joueurs comme joueur de départ pour le jeu, et le ballon sera passé exactement k fois à partir du joueur choisi.
Pour un joueur de départ choisi ayant l'id x, nous définissons une fonction f(x) qui désigne la somme de x et des ids de tous les joueurs qui reçoivent le ballon durant les k passes, y compris les répétitions. En d'autres termes, f(x) = x + `receiver[x]` + `receiver[receiver[x]]` + ... + `receiver^(k)[x]`.
Votre tâche est de choisir un joueur de départ ayant l'id x qui maximise la valeur de f(x).
Retournez un entier désignant la valeur maximale de la fonction.
Remarque: `receiver` peut contenir des doublons.

Exemple 1:

Nombre de Passes
ID Expéditeur
ID Récepteur
x + IDs Récepteur

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrée: `receiver = [2,0,1], k = 4`
Sortie: 6
Explication: Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'id x = 2.
D'après le tableau, f(2) est égal à 6.
Il peut être démontré que 6 est la valeur maximale atteignable de la fonction.
Par conséquent, la sortie est 6.

Exemple 2:

Nombre de Passes
ID Expéditeur
ID Récepteur
x + IDs Récepteur

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrée: `receiver = [1,1,1,2,3], k = 3`
Sortie: 10
Explication: Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'id x = 4.
D'après le tableau, f(4) est égal à 10.
Il peut être démontré que 10 est la valeur maximale atteignable de la fonction.
Par conséquent, la sortie est 10.

Contraintes:

1 <= `receiver.length` == n <= 10^5
0 <= `receiver[i]` <= n - 1
1 <= k <= 10^10

On vous donne un tableau d'entiers indexés 0, receiver, de longueur n, et un entier k.
Il y a n joueurs ayant un identifiant unique dans la plage [0, n - 1] qui joueront un jeu de passes de balle, et receiver[i] est l'identifiant du joueur qui reçoit les passes du joueur avec l'identifiant i. Les joueurs peuvent se faire des passes à eux-mêmes, c'est-à-dire que receiver[i] peut être égal à i.
Vous devez choisir l'un des n joueurs comme joueur de départ pour le jeu, et le ballon sera passé exactement k fois à partir du joueur choisi.
Pour un joueur de départ choisi ayant l'identifiant x, nous définissons une fonction f(x) qui désigne la somme de x et des identifiants de tous les joueurs qui reçoivent le ballon pendant les k passes, y compris les répétitions. En d'autres termes, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Votre tâche consiste à choisir un joueur de départ ayant l'identifiant x qui maximise la valeur de f(x).
Renvoie un entier indiquant la valeur maximale de la fonction.
Remarque : le récepteur peut contenir des doublons.

Exemple 1 :

Numéro de passe
ID de l'expéditeur
ID du récepteur
x + ID du récepteur

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Entrée : receiver = [2,0,1], k = 4
Sortie : 6
Explication : Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'ID x = 2.
D'après le tableau, f(2) est égal à 6.
On peut montrer que 6 est la valeur maximale atteignable de la fonction.
Par conséquent, la sortie est 6.

Exemple 2 :

Numéro de passe
ID de l'expéditeur
ID du destinataire
x + ID du destinataire

4

1
4
3
7

2
3
2
9

3
2
1
10

Entrée : receiver = [1,1,1,2,3], k = 3
Sortie : 10
Explication : Le tableau ci-dessus montre une simulation du jeu commençant avec le joueur ayant l'ID x = 4.
D'après le tableau, f(4) est égal à 10.
On peut montrer que 10 est la valeur maximale atteignable de la fonction.
Par conséquent, la sortie est 10.

Contraintes :

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10