- Résolvez chaque de telle sorte que la complexité d'exécution et d'espace de votre solution soit optimale.
- Déterminez la complexité d'exécution.
- Déterminez la complexité d'espace.
Convention concernant le nom de branche de chaque nouvelle fonctionnalité à implémenter :
- solution_easy-id # id est l'id du problème
- solution_medium-id
- solution_hard-id
Étant donné un tableau d'entiers, renvoyer les indices des deux nombres tels que leur somme atteigne une cible
spécifique.
Vous pouvez supposer que chaque entrée aura exactement une solution.
Inverse les chiffres d'un nombre entier.
Exemple 1 : x = 123, renvoie 321
Exemple 2 : x = -123, renvoie -321
Déterminez si un nombre entier est un palindrome. Faites-le sans espace supplémentaire.
Exemple 1: 1 renvoie True
Exemple 2: 1111 renvoie True
Exemple 3: 13731 renvoie True
Exemple 4: 123 renvoie False
Étant donné un chiffre romain, convertissez-le en un nombre entier.
L'entrée est garantie dans l'intervalle de 1 à 3999.
Exemple 1: I renvoie 1
Exemple 2: V renvoie 5
Exemple 3: X renvoie 10
Exemple 4: L renvoie 50
Exemple 5: C renvoie 100
Exemple 6: D renvoie 500
Exemple 7: M renvoie 1000
Exemple 8: III renvoie 3
Exemple 9: IV renvoie 4
Exemple 10: MCMLXXXVIII renvoie 1988
Exemple 11: MMXXII renvoie 2022
Exemple 12: MMMCMXCIX renvoie 3999
Écrivez une fonction pour trouver le préfixe commun le plus long parmi un tableau de chaînes de caractères.
['django', 'python', 'exit', 'framework'] renvoie ''
['papaye', 'python', 'papa', 'pater'] renvoie 'p'
['examen', 'example', 'examinateur', 'examiner'] renvoie 'exam'
Étant donné une chaîne s contenant uniquement les caractères '(', ')', '{', '}', '[' et ']', déterminez si la
chaîne d'entrée est valide.
Une chaîne d'entrée est valide si :
Les parenthèses ouvertes doivent être fermées par le même type de parenthèses.
Les parenthèses ouvertes doivent être fermées dans le bon ordre.
Entrée : s = "()"
Sortie : true
Entrée : s = "()[]{}"
Sortie : true
Entrée : s = "(]"
Sortie : false
1 <= s.length <= 104
s se compose uniquement de parenthèses '()[]{}'.
On vous donne les têtes de deux listes chaînées triées, list1 et list2.
Fusionnez les deux listes en une seule liste triée. La liste doit être faite en épissant les noeuds des deux premières
listes.
Retournez la tête de la liste fusionnée.
Entrée : liste1 = [1,2,4], liste2 = [1,3,4].
Sortie : [1,1,2,3,4,4]
Entrée : list1 = [], list2 = []
Sortie : []
Entrée : list1 = [], list2 = [0]
Sortie : [0]
Le nombre de nœuds dans les deux listes est compris dans l'intervalle [0, 50].
-100 <= Node.val <= 100
La liste1 et la liste2 sont triées dans un ordre non décroissant.
Étant donné un tableau d'entiers nums triés par ordre non décroissant, supprimez les doublons en place de sorte que
chaque élément unique n'apparaisse qu'une seule fois. L'ordre relatif des éléments doit rester le même.
Comme il est impossible de modifier la longueur du tableau dans certains langages, il faut plutôt faire en sorte que
le résultat soit placé dans la première partie du tableau nums. Plus formellement, s'il reste k éléments après avoir
supprimé les doublons, alors les k premiers éléments de nums doivent contenir le résultat final. Ce que vous laissez
au-delà des k premiers éléments n'a pas d'importance.
Retournez k après avoir placé le résultat final dans les k premiers emplacements de nums.
N'allouez pas d'espace supplémentaire pour un autre tableau. Vous devez le faire en modifiant le tableau d'entrée en
place avec O(1) de mémoire supplémentaire.
Le juge testera votre solution avec le code suivant :
int[] nums = [...] ; // Tableau d'entrée
int[] expectedNums = [...] ; // La réponse attendue avec la longueur correcte
int k = removeDuplicates(nums) ; // Appelle votre implémentation
assert k == expectedNums.length ;
for (int i = 0 ; i < k ; i++) {
assert nums[i] == expectedNums[i] ;
}
Si toutes les assertions passent, alors votre solution sera acceptée.
Entrée : nums = [1,1,2]
Sortie : 2, nums = [1,2,_]
Explication :
Votre fonction doit retourner k = 2, les deux premiers éléments de nums étant respectivement 1 et 2.
Ce que vous laissez au-delà de k retourné n'a pas d'importance (d'où les caractères de soulignement).
Entrée : nums = [0,0,1,1,1,2,2,3,3,4]
Sortie : 5, nums = [0,1,2,3,4,,,,,_]
Explication :
Votre fonction devrait renvoyer k = 5, les cinq premiers éléments de nums étant respectivement 0, 1, 2, 3 et 4.
Ce que vous laissez au-delà de k retourné n'a pas d'importance (d'où les caractères de soulignement).
1 <= nums.length <= 3 * 104
-100 <= nums[i] <= 100
nums est trié dans un ordre non décroissant.
Étant donné un tableau de nombres entiers et un nombre entier val, supprime toutes les occurrences de val dans nums en
place. L'ordre relatif des éléments peut être modifié.
Comme il est impossible de modifier la longueur du tableau dans certains langages, il faut plutôt faire en sorte que
le résultat soit placé dans la première partie du tableau nums. Plus formellement, s'il reste k éléments après avoir
supprimé les doublons, alors les k premiers éléments de nums doivent contenir le résultat final. Ce que vous laissez
au-delà des k premiers éléments n'a pas d'importance.
Retournez k après avoir placé le résultat final dans les k premiers emplacements de nums.
N'allouez pas d'espace supplémentaire pour un autre tableau. Vous devez le faire en modifiant le tableau d'entrée en place avec O(1) de mémoire supplémentaire.
Le juge testera votre solution avec le code suivant :
int[] nums = [...] ; // Tableau d'entrée
int val = ... ; // Valeur à supprimer
int[] expectedNums = [...] ; // La réponse attendue avec la longueur correcte.
// Elle est triée et aucune valeur n'est égale à val.
int k = removeElement(nums, val) ; // Appelle votre implémentation
assert k == expectedNums.length ;
sort(nums, 0, k) ; // Trie les k premiers éléments de nums
for (int i = 0 ; i < actualLength ; i++) {
assert nums[i] == expectedNums[i] ;
}
Si toutes les assertions passent, alors votre solution sera acceptée.
Entrée : nums = [3,2,2,3], val = 3
Sortie : 2, nums = [2,2,,]
Explication :
Votre fonction doit renvoyer k = 2, les deux premiers éléments de nums étant 2.
Ce que vous laissez au-delà de k retourné n'a pas d'importance (d'où les caractères de soulignement).
Entrée : nums = [0,1,2,2,3,0,4,2], val = 2
Sortie : 5, nums = [0,1,4,0,3,,,_]
Explication :
Votre fonction devrait retourner k = 5, avec les cinq premiers éléments de nums contenant 0, 0, 1, 3, et 4.
Notez que les cinq éléments peuvent être retournés dans n'importe quel ordre.
Ce que vous laissez au-delà de k retourné n'a pas d'importance (d'où les caractères de soulignement).
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100
Étant donné deux chaînes de caractères, aiguille et botte de foin, retourne l'indice de la première occurrence d'aiguille dans botte de foin, ou -1 si aiguille ne fait pas partie de botte de foin.
Clarification :
Que devrions-nous retourner si aiguille est une chaîne vide ? C'est une excellente question à poser lors d'un entretien.
Pour les besoins de ce problème, nous renverrons 0 lorsque aiguille est une chaîne vide. Ceci est cohérent avec strstr() en C et indexOf() en Java.
Entrée : botte de foin = "hello", aiguille = "ll". Sortie : 2
Entrée : botte de foin = "aaaaa", aiguille = "bba". Résultat : -1
1 <= botte de foin.longueur, aiguille.longueur <= 104
La meule de foin et l'aiguille ne sont constituées que de caractères anglais minuscules.
Étant donné un tableau trié d'entiers distincts et une valeur cible, retournez l'index si la cible est trouvée. Si ce
n'est pas le cas, renvoyez l'indice où il se trouverait s'il était inséré dans l'ordre.
Vous devez écrire un algorithme dont la complexité d'exécution est de O(log n).
Entrée : nums = [1,3,5,6], cible = 5
Sortie : 2
Entrée : nums = [1,3,5,6], cible = 2
Sortie : 1
Entrée : nums = [1,3,5,6], cible = 7
Sortie : 4
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums contient des valeurs distinctes triées par ordre croissant.
-104 <= cible <= 104
Étant donné un tableau de nombres entiers, trouvez le sous-groupe contigu (contenant au moins un nombre) qui a la plus grande somme et renvoyez sa somme.
Un sous-groupe est une partie contiguë d'un tableau.
Entrée : nums = [-2,1,-3,4,-1,2,1,-5,4]
Sortie : 6
Explication : [4,-1,2,1] a la plus grande somme = 6.
Entrée : nums = [1]
Sortie : 1
Entrée : nums = [5,4,-1,7,8]
Sortie : 23
1 <= nums.length <= 105
-104 <= nums[i] <= 104
Suivi : Si vous avez compris la solution O(n), essayez de coder une autre solution en utilisant l'approche diviser pour régner, qui est plus subtile.
1! = 1
2! = 2x1 = 2
3! = 3x2x1 = 6
5! = 5x4x3x2x1 = 120
F0 = 0
F1 = F2 = 1
F3 = F2 + F1 = 1 + 1 = 2
F5 = F4+F3 = (F3 + F2) + (F2 + F1) = ((F2 + F1) + F2) + (F2 + F1) = 5
La séquence count-and-say est une séquence de chaînes de chiffres définie par la formule récursive :
countAndSay(1) = "1"
countAndSay(n) est la façon dont vous "dites" la chaîne de chiffres de countAndSay(n-1), qui est ensuite convertie en
une chaîne de chiffres différente.
Pour déterminer la façon dont vous "dites" une chaîne de chiffres, divisez-la en un nombre minimal de sous-chaînes de
sorte que chaque sous-chaîne contienne exactement un chiffre unique. Ensuite, pour chaque sous-chaîne, dites le nombre
de chiffres, puis dites le chiffre. Enfin, concaténer chaque chiffre.
Par exemple, l'énoncé et la conversion pour la chaîne de chiffres "3322251" :
Étant donné un nombre entier positif n, retourner le nième terme de la séquence de comptage et de conversion.
Entrée : n = 1
Sortie : "1"
Explication : C'est le cas de base.
Entrée : n = 4
Sortie : "1211"
Explication :
countAndSay(1) = "1" (compte et dit)
countAndSay(2) = dites "1" = un 1 = "11"
countAndSay(3) = dites "11" = deux 1 = "21"
Comptez et dites(4) = dites "21" = un 2 + un 1 = "12" + "11" = "1211".
Entrée : n = 5
Sortie : "111221"
Explication :
countAndSay(1) = "1" (compte et dit)
countAndSay(2) = dites "1" = un 1 = "11"
countAndSay(3) = dites "11" = deux 1 = "21"
Comptez et dites(4) = dites "21" = un 2 + un 1 = "12" + "11" = "1211".
Comptez et dites(5) = dites "1211" = 1 un + un 2 + deux 1 = "11" + "12" + "21" = "111221".
1 <= n <= 30
Étant donné une chaîne de caractères s constituée de mots et d'espaces, la fonction renvoie la longueur du dernier mot de la chaîne. Un mot est une sous-chaîne maximale composée uniquement de caractères sans espace.
Entrée : s = "Hello World" (Bonjour le monde)
Sortie : 5
Explication : Le dernier mot est "Monde" avec une longueur de 5.
Entrée : s = " fly me to the moon " (vole jusqu'à la lune)
Sortie : 4
Explication : Le dernier mot est "lune" avec une longueur de 4.
Entrée : s = "luffy est toujours joyboy"
Sortie : 6
Explication : Le dernier mot est "joyboy" avec une longueur de 6.
1 <= s.length <= 104
s est composé uniquement de lettres anglaises et d'espaces ' '.
Il y aura au moins un mot dans s.
On vous donne un grand nombre entier représenté sous la forme d'un tableau de chiffres, où chaque chiffre [i] est le ième chiffre du nombre entier. Les chiffres sont classés de gauche à droite, du plus significatif au moins significatif. Le grand nombre entier ne contient pas de 0 de tête. Incrémentez le grand nombre entier de un et renvoyez le tableau de chiffres résultant.
Entrée : chiffres = [1,2,3]
Sortie : [1,2,4]
Explication : Le tableau représente le nombre entier 123.
En l'incrémentant de un, on obtient 123 + 1 = 124.
Ainsi, le résultat devrait être [1,2,4].
Entrée : chiffres = [4,3,2,1]
Résultat : [4,3,2,2]
Explication : Le tableau représente le nombre entier 4321.
En l'incrémentant de un, on obtient 4321 + 1 = 4322.
Le résultat devrait donc être [4,3,2,2].
Entrée : chiffres = [9]
Résultat : [1,0]
Explication : Le tableau représente le nombre entier 9.
En l'incrémentant de un, on obtient 9 + 1 = 10.
Ainsi, le résultat devrait être [1, 0].
Entrée : chiffres = [2, 5, 9, 9]
Résultat : [2, 6, 0, 0]
Entrée : chiffres = [7, 9, 9]
Résultat : [8, 0, 0]
Entrée : chiffres = [9, 9, 9]
Résultat : [1, 0, 0, 0]
1 <= chiffres.longueur <= 100
0 <= chiffres[i] <= 9
digits ne contient pas de 0 en tête.