id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
28ad272cb8e78ac1cc78159e4fce63b4 | [
{
"content": "On te donne deux listes d'entiers, `values` et `weights`, toutes deux de la même longueur. Ta tâche est de calculer la moyenne pondérée de la liste `values`, où chaque valeur est multipliée par son poids correspondant dans la liste `weights`. La fonction ne doit utiliser aucune fonction ou bibliot... | ["\nassert weighted_average([1, 2, 3], [1, 1, 1]) == 2\n", "\nassert weighted_average([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted_average([-1, -2, -3], [1, 1, 1]) == -2\n", "\nassert weighted_average([1, -1, 1], [1, 1, 1]) == 1/3\n", "\nassert weighted_average([0, 0, 0], [1, 1, 1]) == 0\n", "\... |
7ba2c6e72d76b033e79b8da75eea8fff | [
{
"content": "Implémente une classe Python nommée `Car` avec les spécifications suivantes :\n- Attributs : `make`, `model`, `year` et `mileage`.\n- Méthodes :\n - `display_details` : Affiche les détails de la voiture au format : \"Car Make: {make}, Model: {model}, Year: {year}, Mileage: {mileage} miles\".\n -... | ["\nassert my_car.make == \"Toyota\"\n", "\nassert my_car.model == \"Corolla\"\n", "\nassert my_car.year == 2020\n", "\nassert my_car.mileage == 15000\n", "\nmy_car.update_mileage(18000); assert my_car.mileage == 18000\n", "\nmy_car.update_mileage(10000); assert my_car.mileage == 18000\n", "\nmy_car.update_mileage(2000... |
849083df2e0c2827e8752197272d69bd | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `rotate_string(s, n)` qui renvoie une nouvelle chaîne qui est le résultat de la rotation de la chaîne d'origine `s` vers la droite de `n` positions. Si `n` dépasse la longueur de la chaîne, elle... | ["\nassert rotate_string(\"abcdefg\", 3) == \"efgabcd\"\n", "\nassert rotate_string(\"abcdefg\", 0) == \"abcdefg\"\n", "\nassert rotate_string(\"abcdefg\", 7) == \"abcdefg\"\n", "\nassert rotate_string(\"abcdefg\", 10) == \"efgabcd\"\n", "\nassert rotate_string(\"hello\", 2) == \"lohel\"\n", "\nassert rotate_string(\"w... |
5a6f0d3ca230641638c419c4c9ddff6f | [
{
"content": "On te donne un ensemble de données d'images, chacune représentée comme un vecteur de 100 dimensions. Ta tâche est d'implémenter une fonction `calculate_similarity` qui calcule la similarité entre deux images en fonction de leurs représentations vectorielles. La similarité est déterminée en utilisa... | ["\nassert calculate_similarity(np.array([0]*100), np.array([0]*100), np.eye(100)) == 99.0\n", "\nassert calculate_similarity(np.array([0]*100), np.array([0.1]*100), np.eye(100)) == 95.7\n", "\nassert calculate_similarity(np.array([0]*100), np.array([0.3]*100), np.eye(100)) == 62.31\n", "\nassert calculate_similarity(n... |
70d45b983fb889dab095989a5f8bd5c7 | [
{
"content": "On te donne un fichier texte nommé `graph.txt` qui contient une liste d'arêtes pour un graphe non orienté. Chaque ligne du fichier représente une arête unique, avec les deux sommets de l'arête donnés sous forme d'entiers à un seul chiffre séparés par un espace. Ta tâche est d'écrire une fonction q... | ["\nassert read_and_sort_edges('test1.txt') == [[1, 2], [2, 3], [3, 4]]\n", "\nassert read_and_sort_edges('test2.txt') == [[1, 5], [2, 4], [3, 3]]\n", "\nassert read_and_sort_edges('test3.txt') == [[1, 2], [1, 3], [2, 3]]\n", "\nassert read_and_sort_edges('test4.txt') == [[1, 1], [2, 2], [3, 3]]\n", "\nassert read_and_... |
dcc05c9e1fb1b999a282fd8c45b15d1f | [
{
"content": "On te donne une liste d'entiers `seq`. Ta tâche est d'implémenter une fonction `find_unique_elements(seq)` qui renvoie une liste d'entiers qui apparaissent exactement une fois dans `seq`. La liste renvoyée doit d'abord être triée par la somme des chiffres de chaque nombre par ordre croissant, puis... | ["\nassert find_unique_elements([4, 3, 2, 7, 8, 2, 3, 1]) == [1, 4, 7, 8]\n", "\nassert find_unique_elements([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert find_unique_elements([111, 222, 333, 444, 555]) == [111, 222, 333, 444, 555]\n", "\nassert find_unique_elements([1, 1, 2, 2, 3, 3, 4, 5]) == [4, 5]\n",... |
6bbad6a438fe9f532bd09fa38d45a529 | [
{
"content": "On te donne une liste de séquences d'ADN, chacune représentée comme une chaîne de caractères. Ta tâche est de créer une fonction `compile_dna_regex` qui prend cette liste en entrée et renvoie une liste d'expressions régulières compilées, une pour chaque séquence d'ADN. Ces expressions régulières d... | ["\nassert [regex.pattern for regex in compile_dna_regex(['AT', 'GC'])] == ['AT', 'GC']\n", "\nassert [regex.flags for regex in compile_dna_regex(['AT', 'GC'])] == [32, 32]\n", "\nassert [regex.pattern for regex in compile_dna_regex(['RY', 'NN'])] == ['[AG][CT]', '[ACGT][ACGT]']\n", "\nassert [regex.pattern for regex i... |
313b252a01c9861e9f80980b80d00f13 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `filter_strings` qui traite cette liste en effectuant les opérations suivantes sur chaque chaîne :\n1. Supprimer tous les caractères numériques.\n2. Supprimer les espaces blancs au début et à la fin.\n3. Exclur... | ["\nassert filter_strings([\" 123abc \", \"def456 \", \" \", \"ghi\", \"789\"]) == ['abc', 'def', 'ghi']\n", "\nassert filter_strings([\"123\", \"456\", \"789\"]) == []\n", "\nassert filter_strings([\"abc\", \"def\", \"ghi\"]) == ['abc', 'def', 'ghi']\n", "\nassert filter_strings([\" 123abc456 \", \" def \", \" ghi78... |
77f44f3510c35f9b0da5bac085dadeeb | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python qui renvoie une nouvelle liste contenant uniquement les éléments communs uniques des deux listes d'entrée. L'ordre des éléments dans la liste résultante n'a pas d'importance.\n\n**Exemple d'entrée :**\n```\nlist1 = [1, 2,... | ["\nassert find_common_elements([1, 2, 3], [3, 4, 5]) == [3]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert ... |
222f3c2a9bb9a3ad200c7abc8e645781 | [
{
"content": "Tu es chargé d'implémenter une fonction pour déterminer le sentiment d'un texte donné. Le sentiment doit être classifié comme \"positif\", \"négatif\" ou \"neutre\". Utilise la bibliothèque `TextBlob` pour l'analyse des sentiments. Ta fonction doit gérer diverses entrées textuelles et renvoyer la ... | ["\nassert analyze_sentiment(\"I love sunny days!\") == \"positive\"\n", "\nassert analyze_sentiment(\"This is the worst experience I've ever had.\") == \"negative\"\n", "\nassert analyze_sentiment(\"It's okay, not great but not bad.\") == \"neutral\"\n", "\nassert analyze_sentiment(\"Absolutely fantastic!\") == \"posi... |
1c289a752f496381fd3dcc787153d2db | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier donné `n`. La fonction doit gérer les entrées positives et négatives. Pour les entrées négatives, la fonction doit renvoyer `None`. Ta solution doit être efficace et gérer correctement les cas limites.\n\n*... | ["\nassert factorial(5) == 120\n", "\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(-1) == None\n", "\nassert factorial(-5) == None\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(15) == 1307674368000\n"... |
02899ebc4fa515b7d2ba40860e86f348 | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire représente le dossier d'un étudiant avec les clés \"name\", \"age\" et \"grade\". Ta tâche est d'écrire une fonction Python qui calcule la moyenne des notes de tous les étudiants. Suppose que toutes les notes sont numériques.\n\n**Entr... | ["\nassert calculate_average_grade([{\"name\": \"Alice\", \"age\": 20, \"grade\": 88}, {\"name\": \"Bob\", \"age\": 22, \"grade\": 75}, {\"name\": \"Charlie\", \"age\": 19, \"grade\": 92}]) == 85.0\n", "\nassert calculate_average_grade([{\"name\": \"Alice\", \"age\": 20, \"grade\": 100}, {\"name\": \"Bob\", \"age\": 22... |
8bfb5a9006c56c8e28e49766fc8315c3 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `longest_unique_word(text)` qui renvoie le mot le plus long de la chaîne qui apparaît exactement une fois, sans tenir compte de la casse. S'il y a plusieurs mots de lo... | ["\nassert longest_unique_word(\"a quick brown fox jumps over the lazy dog with a quick brown dog\") == \"jumps\"\n", "\nassert longest_unique_word(\"hello world hello\") == \"world\"\n", "\nassert longest_unique_word(\"one two three four five six seven eight nine ten eleven\") == \"eleven\"\n", "\nassert longest_uniqu... |
4b58ecf574f6df236e64d9b71dbf0656 | [
{
"content": "On te demande d'implémenter une fonction `parse_email_addresses` qui prend une chaîne de caractères en entrée et renvoie une liste de toutes les adresses e-mail valides trouvées dans la chaîne. Une adresse e-mail est considérée comme valide si elle correspond au modèle suivant : un ou plusieurs ca... | ["\nassert parse_email_addresses(\"Please contact us at info@example.com or support@sample.org for further inquiries.\") == ['info@example.com', 'support@sample.org']\n", "\nassert parse_email_addresses(\"No emails here!\") == []\n", "\nassert parse_email_addresses(\"Multiple emails: test1@test.com, test2@test.co.uk, t... |
0410d7b52152421d608b56ea1a9c923a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction `reverse_vowels(s)` qui renvoie une nouvelle chaîne où toutes les voyelles (a, e, i, o, u) sont inversées dans leur ordre, tandis que tous les autres caractères restent à leurs positions d'origine. La fonction doit être i... | ["\nassert reverse_vowels(\"Hello, World!\") == \"Holle, Werld!\"\n", "\nassert reverse_vowels(\"Programming\") == \"Prigrammong\"\n", "\nassert reverse_vowels(\"Python\") == \"Pythpn\"\n", "\nassert reverse_vowels(\"AEIOU\") == \"UOIEA\"\n", "\nassert reverse_vowels(\"aeiou\") == \"uoiea\"\n", "\nassert reverse_vowels... |
65ba20d8df4e22fb377af2c3c47c0f0b | [
{
"content": "On te donne un dictionnaire imbriqué. Ta tâche est d'écrire une fonction `flatten_dict` qui transforme ce dictionnaire imbriqué en un dictionnaire à un seul niveau. Les clés dans le dictionnaire résultant doivent être formées en concaténant les clés du dictionnaire imbriqué, séparées par des tiret... | ["\nassert flatten_dict({\"a\": {\"b\": {\"c\": 1}}}) == {\"a_b_c\": 1}\n", "\nassert flatten_dict({\"x\": 1, \"y\": {\"z\": 2}}) == {\"x\": 1, \"y_z\": 2}\n", "\nassert flatten_dict({\"level1\": {\"level2\": {\"level3\": {\"level4\": 5}}}}) == {\"level1_level2_level3_level4\": 5}\n", "\nassert flatten_dict({\"single\"... |
62305d5259fe3bb90c7d35324b92de84 | [
{
"content": "On te donne une liste de quatre points distincts dans un plan 2D, représentant les sommets d'un rectangle. Les points sont fournis dans un ordre arbitraire. Ta tâche est de déterminer le centre du rectangle. Le centre est défini comme la moyenne des coordonnées x et y des sommets du rectangle.\n\n... | ["\nassert find_center([(1, 1), (4, 1), (4, 5), (1, 5)]) == (2.5, 3.0)\n", "\nassert find_center([(0, 0), (2, 0), (2, 2), (0, 2)]) == (1.0, 1.0)\n", "\nassert find_center([(-1, -1), (1, -1), (1, 1), (-1, 1)]) == (0.0, 0.0)\n", "\nassert find_center([(5, 5), (10, 5), (10, 10), (5, 10)]) == (7.5, 7.5)\n", "\nassert find_... |
c4c40d06320ba19245075628c3ec4604 | [
{
"content": "On te donne un entier positif `number`. Convertis ce nombre en sa représentation en base 5. Ensuite, sépare les chiffres en deux groupes en fonction de leur parité (pair ou impair). Détermine le chiffre qui apparaît le plus fréquemment dans chaque groupe. S'il y a plusieurs chiffres avec la même f... | ["\nassert max_occurring_digit(1) == None\n", "\nassert max_occurring_digit(5) == 0\n", "\nassert max_occurring_digit(10) == 0\n", "\nassert max_occurring_digit(23) == 1\n", "\nassert max_occurring_digit(123) == 1\n", "\nassert max_occurring_digit(124) == 2\n", "\nassert max_occurring_digit(125) == 0\n", "\nassert max_... |
81f406fed0b64f25003c11cd10ddb6df | [
{
"content": "Tu développes une application sécurisée qui nécessite une clé secrète pour le chiffrement des données. La clé secrète est stockée dans un objet de configuration sous forme de chaîne ASCII encodée en hexadécimal sous l'option de ligne de commande `--secret-key`. Ta tâche est de mettre en œuvre une ... | ["\nassert get_secret_key({'--secret-key': '48656c6c6f20576f726c64'}) == \"Hello World\"\n", "\nassert get_secret_key({'--secret-key': '54657374204b6579'}) == \"Test Key\"\n", "\nassert get_secret_key({'--secret-key': '536563726574'}) == \"Secret\"\n", "\nassert get_secret_key({'--secret-key': '4142434445464748494a4b4c... |
a15c3c8067e200bae17a28b59419fb2c | [
{
"content": "On te demande d'implémenter une fonction `extract_text_from_html` qui traite une chaîne HTML donnée et extrait tout le contenu textuel, en excluant les balises HTML, les attributs et les commentaires. La fonction doit renvoyer une seule chaîne de caractères contenant le texte extrait, où les mots ... | ["\nassert extract_text_from_html(\"<p>Hello, world!</p>\") == \"Hello, world!\"\n", "\nassert extract_text_from_html(\"<!-- This is a comment -->Hello, world!\") == \"Hello, world!\"\n", "\nassert extract_text_from_html(\"Hello, <!-- This is a comment -->world!\") == \"Hello, world!\"\n", "\nassert extract_text_from_h... |
4949427b4c7efc48986dd2dc6f607fc5 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes palindromiques de longueur maximale identique, renvoie celle qui apparaît en premier dans la chaîne. Si la chaîne d'entrée est vide, renvoie une c... | ["\nassert longest_palindrome(\"babad\") == \"bab\"\n", "\nassert longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert longest_palindrome(\"a\") == \"a\"\n", "\nassert longest_palindrome(\"ac\") == \"a\"\n", "\nassert longest_palindrome(\"racecar\") == \"racecar\"\n", "\nassert longest_palindrome(\"noon high it is\") =... |
bff15d5e10a3beb79a9f4d19d10afc3f | [
{
"content": "On te donne un fichier JSON nommé `contacts.json` qui contient une liste de dictionnaires. Chaque dictionnaire représente une personne avec les clés suivantes : `name`, `age`, `email` et `phone`. Ta tâche est d'écrire un script Python qui lit ce fichier et valide chaque dictionnaire. Un dictionnai... | ["\nassert validate_email(\"test@example.com\") == True\n", "\nassert validate_email(\"invalid-email\") == False\n", "\nassert validate_email(\"another.test@domain.co.uk\") == True\n", "\nassert validate_email(\"user@domain\") == False\n", "\nassert validate_email(\"user@domain.c\") == False\n", "\nassert validate_emai... |
c246d9b37b7fc97c9c1964dee9641b7e | [
{
"content": "On te donne une liste de tuples, où chaque tuple consiste en deux entiers : un point de départ `x0` et un pas `step`. Ta tâche est de mettre en œuvre une fonction qui calcule le résultat de la formule `(x - x0) / step` pour chaque tuple de la liste, arrondi à l'entier le plus proche. Si `step` est... | ["\nassert compute_results([(1, 2), (3, 4)], 5) == [2, 0]\n", "\nassert compute_results([(0, 1), (5, 5)], 10) == [10, 1]\n", "\nassert compute_results([(10, 0), (20, 0)], 15) == [None, None]\n", "\nassert compute_results([(2, 3), (4, 2)], 11) == [3, 3]\n", "\nassert compute_results([(5, 5), (10, 10)], 15) == [2, 0]\n",... |
395be8f385e4a86243d06886fdf5277e | [
{
"content": "On te demande d'implémenter une fonction `find_nth_prime(n)` qui calcule efficacement le `n`ième nombre premier en utilisant un algorithme de crible segmenté. La fonction doit gérer efficacement les grandes valeurs de `n`.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^6)\n\n**Sortie :**\n- Le `n`iè... | ["\nassert find_nth_prime(1) == 2\n", "\nassert find_nth_prime(2) == 3\n", "\nassert find_nth_prime(3) == 5\n", "\nassert find_nth_prime(4) == 7\n", "\nassert find_nth_prime(5) == 11\n", "\nassert find_nth_prime(10) == 29\n", "\nassert find_nth_prime(20) == 71\n", "\nassert find_nth_prime(50) == 229\n", "\nassert find_... |
c9b2511921fbd166f517927c5f9887e1 | [
{
"content": "Implémente une classe `Book` avec les spécifications suivantes :\n\n- **Attributs :**\n - `title` : Une chaîne de caractères représentant le titre du livre.\n - `author` : Une chaîne de caractères représentant l'auteur du livre.\n - `isbn` : Une chaîne de caractères représentant l'ISBN du livre... | ["\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\", 3).title == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\", 3).author == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\", 3).isbn == \"9780451524935\"\n", "\nassert Book(\"1984\", \"George Orw... |
37e74ed0c1f6c3a7c63c2ef59810a8b2 | [
{
"content": "On te demande d'implémenter une classe `Product` pour gérer les produits dans une boutique en ligne. Chaque produit est identifié par un `product_id` unique, a un `price` et une `quantity` en stock. Ta classe doit supporter les opérations suivantes :\n\n- `__init__(self, product_id, price, quantit... | ["\nassert Product(1, 10.99, 5).product_id == 1\n", "\nassert Product(1, 10.99, 5).price == 10.99\n", "\nassert Product(1, 10.99, 5).quantity == 5\n", "\nproduct = Product(1, 10.99, 5)\nproduct.update_price(15.99)\nassert product.price == 15.99\n", "\nproduct = Product(1, 10.99, 5)\nproduct.update_quantity(10)\nassert ... |
f3ba36cb0e0ab9441905aec7b6a2dcb7 | [
{
"content": "On te donne un dictionnaire imbriqué `data` où certaines valeurs peuvent être elles-mêmes des dictionnaires. Ta tâche est d'écrire une fonction `create_unique_id` qui génère un identifiant unique pour l'ensemble de la structure. L'identifiant doit être un tuple imbriqué reflétant la structure hiér... | ["\nassert create_unique_id({'a': 1, 'b': 2}) == frozenset({('a', 1), ('b', 2)})\n", "\nassert create_unique_id({'b': 2, 'a': 1}) == frozenset({('a', 1), ('b', 2)})\n", "\nassert create_unique_id({'a': {'b': 1}}) == frozenset({('a', frozenset({('b', 1)}))})\n", "\nassert create_unique_id({'a': {'b': 1, 'c': 2}}) == fro... |
959326d6761e85010a740661b74f5cd0 | [
{
"content": "On te donne un arbre binaire représenté sous forme de tableau en ordre de parcours en largeur. Ta tâche est d'afficher l'arbre de manière en zigzag. Le parcours en zigzag en ordre de largeur d'un arbre binaire est défini comme suit : pour le premier niveau, parcours de gauche à droite ; pour le de... | ["\nassert zigzag_level_order_traversal([3, 9, 20, None, None, 15, 7]) == [[3], [20, 9], [15, 7]]\n", "\nassert zigzag_level_order_traversal([1, 2, 3, 4, 5, 6, 7]) == [[1], [3, 2], [4, 5, 6, 7]]\n", "\nassert zigzag_level_order_traversal([1, None, 2, None, None, 3]) == [[1], [2], [3]]\n", "\nassert zigzag_level_order_t... |
bf434e413a1836c60f32043976a62071 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `alternate_title_case(s)` qui transforme la chaîne de sorte que la casse de chaque caractère alphabétique alterne, en ignorant les espaces. Le premier caractère alphabétique doit être en majuscule, le second en minus... | ["\nassert alternate_title_case(\"hello world\") == \"HeLlO WoRlD\"\n", "\nassert alternate_title_case(\"Python Programming\") == \"PyThOn PrOgRaMmInG\"\n", "\nassert alternate_title_case(\"123abc456def\") == \"123AbC456DeF\"\n", "\nassert alternate_title_case(\"aBcDeFgHiJ\") == \"AbCdEfGhIj\"\n", "\nassert alternate_t... |
3e7c5298ead4ee28a91b8ba0ea783929 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction qui renvoie un dictionnaire contenant la fréquence de chaque mot unique dans la liste. La fonction doit ignorer la ponctuation et traiter les mots sans tenir compte de la casse.\n\n**Entrée :**\n- Une liste... | ["\nassert word_frequencies(['Hello, world!', 'Hello there', 'world of code']) == {'hello': 3, 'world': 2, 'there': 1, 'of': 1, 'code': 1}\n", "\nassert word_frequencies(['Python is great.', 'Python is fun!']) == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert word_frequencies(['A quick brown fox.', 'The qui... |
a74269087df28816a6de37d5c96a162a | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de trouver la longueur de la plus longue sous-chaîne palindromique dans `s`. Une sous-chaîne palindromique se lit de la même manière de gauche à droite et de droite à gauche. S'il existe plu... | ["\nassert longest_palindromic_substring(\"babad\") == 3\n", "\nassert longest_palindromic_substring(\"cbbd\") == 2\n", "\nassert longest_palindromic_substring(\"a\") == 1\n", "\nassert longest_palindromic_substring(\"ac\") == 1\n", "\nassert longest_palindromic_substring(\"racecar\") == 7\n", "\nassert longest_palindr... |
5b02484446dddaffb9cb336c2504bfad | [
{
"content": "On te demande d'implémenter une fonction `generate_prime_numbers(n)` qui génère efficacement tous les nombres premiers jusqu'à et y compris `n`. La fonction doit renvoyer une liste de ces nombres premiers. Ta solution doit gérer les cas limites, tels que lorsque `n` est inférieur à 2, en renvoyant... | ["\nassert generate_prime_numbers(10) == [2, 3, 5, 7]\n", "\nassert generate_prime_numbers(1) == []\n", "\nassert generate_prime_numbers(0) == []\n", "\nassert generate_prime_numbers(2) == [2]\n", "\nassert generate_prime_numbers(19) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_prime_numbers(20) == [2, 3, 5, ... |
14627366ef670d674eaa2d06069152f6 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `remove_vowels` qui traite chaque chaîne de caractères de la liste en supprimant toutes les voyelles (majuscules et minuscules) et renvoie une nouvelle liste avec les chaînes modifiées.\n\n**Entrée :**\n- Une l... | ["\nassert remove_vowels([\"hello\", \"world\", \"python\"]) == ['hll', 'wrld', 'pythn']\n", "\nassert remove_vowels([\"AEIOU\", \"aeiou\"]) == ['', '']\n", "\nassert remove_vowels([\"bcd\", \"fgh\", \"jkl\"]) == ['bcd', 'fgh', 'jkl']\n", "\nassert remove_vowels([\"\"]) == ['']\n", "\nassert remove_vowels([\"a\", \"e\"... |
58783c718a54f7cf132f1087b06a1372 | [
{
"content": "On te demande d'implémenter une fonction `greet_user(name: str) -> str` pour une application de salutation. La fonction doit générer un message de salutation personnalisé en insérant un adverbe sélectionné aléatoirement dans une liste prédéfinie entre \"Hello\" et le nom de l'utilisateur. La salut... | ["\nassert greet_user(\"Alice\").endswith(\"!\")\n", "\nassert greet_user(\"Bob\").startswith(\"Hello \")\n", "\nassert greet_user(\"Charlie\").split(\", \")[1] == \"Charlie!\"\n", "\nassert greet_user(\"David\") in [\"Hello cheerfully, David!\", \"Hello merrily, David!\", \"Hello happily, David!\", \"Hello joyfully, D... |
ab7db90460eacddf2f482d6289d403b0 | [
{
"content": "On te demande d'implémenter une fonction `validate_input(input_string)` qui détermine si une chaîne de caractères donnée est une URL valide. Une URL valide doit respecter les critères suivants :\n\n1. Elle doit commencer par `http://` ou `https://`.\n2. Elle ne doit pas contenir de caractères d'es... | ["\nassert validate_input('http://www.google.com') == True\n", "\nassert validate_input('https://stackoverflow.com/questions/1633641') == True\n", "\nassert validate_input('ftp://example.com') == False\n", "\nassert validate_input('http:/ /example.com') == False\n", "\nassert validate_input('example.com') == False\n", ... |
1ea0e6afae19d5051fafd428fc9f7697 | [
{
"content": "Implémente deux classes, `Stack` et `Queue`, pour démontrer les comportements Last-In-First-Out (LIFO) et First-In-First-Out (FIFO) respectivement. Tes classes doivent supporter les opérations suivantes :\n- `push(item)` : Ajouter un élément à la pile.\n- `pop()` : Supprimer et retourner l'élément... | ["\nassert stack.is_empty() == False\n", "\nassert stack.size() == 2\n", "\nassert stack.peek() == 2\n", "\nassert stack.pop() == 2\n", "\nassert stack.pop() == 1\n", "\nassert stack.is_empty() == True\n", "\nassert queue.is_empty() == False\n", "\nassert queue.size() == 2\n", "\nassert queue.peek() == 'b'\n", "\nasser... |
c69b276c16872a4ebf2678c9a06d5d0e | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres anglaises minuscules et majuscules et d'espaces. Ta tâche est d'écrire une fonction `reverse_vowels` qui inverse l'ordre des voyelles dans la chaîne `s`. Les voyelles sont 'a', 'e', 'i', 'o' et 'u', et elles peuvent apparaître en minuscu... | ["\nassert reverse_vowels(\"hello world\") == \"holle werld\"\n", "\nassert reverse_vowels(\"leetcode\") == \"leotcede\"\n", "\nassert reverse_vowels(\"aA\") == \"Aa\"\n", "\nassert reverse_vowels(\"racecar\") == \"racecar\"\n", "\nassert reverse_vowels(\"AEIOU\") == \"UOIEA\"\n", "\nassert reverse_vowels(\"bcd\") == \... |
c1d793e05c4ee3614e4c9389eae9b538 | [
{
"content": "On te demande d'implémenter une fonction `fibonacci_numbers_up_to` qui génère tous les nombres de Fibonacci jusqu'à un entier donné `n`. La suite de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somme des deux nombres précédents. Ta fonction doit renvoyer une liste de nombres de F... | ["\nassert fibonacci_numbers_up_to(0) == [0]\n", "\nassert fibonacci_numbers_up_to(1) == [0, 1, 1]\n", "\nassert fibonacci_numbers_up_to(2) == [0, 1, 1, 2]\n", "\nassert fibonacci_numbers_up_to(10) == [0, 1, 1, 2, 3, 5, 8]\n", "\nassert fibonacci_numbers_up_to(15) == [0, 1, 1, 2, 3, 5, 8, 13]\n", "\nassert fibonacci_nu... |
4e8dcd551bdb2410c8679b80da746474 | [
{
"content": "On te donne une liste d'entiers `numbers` et un dictionnaire `subtractors` où les clés sont les indices de `numbers` et les valeurs sont les montants à soustraire des éléments correspondants dans `numbers`. Ta tâche est de mettre en œuvre une fonction `calculate_adjusted_sum(numbers, subtractors)`... | ["\nassert calculate_adjusted_sum([10, 20, 30, 40], {1: 5, 2: 10, 3: 15}) == 95\n", "\nassert calculate_adjusted_sum([2, 3, 5, 7], {1: 1, 2: 2, 3: 3}) == 14\n", "\nassert calculate_adjusted_sum([11, 13, 17, 19], {0: 2, 1: 3, 2: 5, 3: 7}) == 59\n", "\nassert calculate_adjusted_sum([4, 6, 8, 10], {1: 1, 2: 2, 3: 3}) == 2... |
7036cb5b93142788f2047798fe90b6f6 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est de trouver la paire de nombres dans la liste qui donne le produit maximal. S'il y a plusieurs paires avec le même produit maximal, renvoie la première paire rencontrée. La liste contiendra au moins deux entiers.\n\n**Exemple d'entrée :**\n```\n[1, ... | ["\nassert max_product_pair([1, 2, 3, 4]) == (3, 4)\n", "\nassert max_product_pair([-10, -20, 5, 6]) == (-10, -20)\n", "\nassert max_product_pair([0, 2, 3, 5]) == (3, 5)\n", "\nassert max_product_pair([1, 1, 1, 1]) == (1, 1)\n", "\nassert max_product_pair([100, 200, 3, 400]) == (100, 400)\n", "\nassert max_product_pair... |
37c564d4e2d549284cf2b7de90eb6214 | [
{
"content": "Implémente une classe nommée `Car` avec les spécifications suivantes :\n\n- **Attributs :**\n - `make` : Une chaîne de caractères représentant le constructeur de la voiture.\n - `model` : Une chaîne de caractères représentant le modèle de la voiture.\n - `year` : Un entier représentant l'année ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020).get_description() == \"2020 Toyota Corolla with 0 miles\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018, 15000).get_description() == \"2018 Honda Civic with 15000 miles\"\n", "\ncar = Car(\"Ford\", \"Mustang\", 2021)\ncar.update_odometer(5000)\nassert car.get_description() =... |
2380c629464fa77b7ec310797c6d76d2 | [
{
"content": "On te donne une liste d'entiers, `numbers`. Implémente une fonction `alternate_signs(numbers)` qui renvoie une nouvelle liste où le signe de chaque deuxième nombre est inversé, en commençant par le deuxième élément. Le premier nombre doit conserver son signe d'origine. La fonction doit gérer les l... | ["\nassert alternate_signs([1, 2, 3, 4, 5]) == [1, -2, 3, -4, 5]\n", "\nassert alternate_signs([-1, -2, -3, -4, -5]) == [-1, 2, -3, 4, -5]\n", "\nassert alternate_signs([0, 0, 0, 0, 0]) == [0, 0, 0, 0, 0]\n", "\nassert alternate_signs([1000000000, -1000000000, 1000000000, -1000000000]) == [1000000000, 1000000000, 10000... |
bc277935521740efc486142e292b7b23 | [
{
"content": "Tu dois implémenter une fonction qui construit une chaîne d'identifiant unique pour les opérations cryptographiques. L'identifiant doit respecter le format : `ID;<prime>;<base>;<public_key>`. Ici, `<prime>` est un nombre premier, `<base>` est un nombre de base, et `<public_key>` est une clé publiq... | ["\nassert generate_unique_identifier(997, 5, 'ABCDEF123') == 'ID;997;5;ABCDEF123'\n", "\nassert generate_unique_identifier(1000, 5, 'ABCDEF123') == 'ID;997;5;ABCDEF123'\n", "\nassert generate_unique_identifier(1001, 5, 'ABCDEF123') == 'ID;997;5;ABCDEF123'\n", "\nassert generate_unique_identifier(999, 5, 'ABCDEF123') =... |
157e9d1638ff73ba119bbb3bbc84380c | [
{
"content": "On te donne un entier non négatif `data` inférieur à \\(2^{32}\\). Ta tâche est d'écrire une fonction `swapNibbleOrder` qui traite cet entier en inversant d'abord les bits à l'intérieur de chaque nibble de 4 bits, puis en inversant l'ordre de ces nibbles. Retourne l'entier résultant.\n\n**Entrée :... | ["\nassert swapNibbleOrder(0x00000000) == 0x00000000\n", "\nassert swapNibbleOrder(0xFFFFFFFF) == 0xFFFFFFFF\n", "\nassert swapNibbleOrder(0x12345678) == 0x1E6A2C48\n", "\nassert swapNibbleOrder(0x87654321) == 0x1248367E\n", "\nassert swapNibbleOrder(0x11111111) == 0x11111111\n", "\nassert swapNibbleOrder(0xABCDEF01) =... |
90e2aa2840cdc532174470c3d4485768 | [
{
"content": "On te donne une chaîne de caractères `text` contenant plusieurs sous-chaînes. Ta tâche est d'identifier et d'extraire tous les UUID valides de cette chaîne. Un UUID est défini comme une séquence de caractères au format `xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx`, où `x` est un chiffre hexadécimal (0-9,... | ["\nassert validate_and_extract_uuids(\"[123e4567-e89b-12d3-a456-426614174000]\") == [\"123e4567-e89b-12d3-a456-426614174000\"]\n", "\nassert validate_and_extract_uuids(\"[123e4567-e89b-12d3-a456-42661417400g]\") == []\n", "\nassert validate_and_extract_uuids(\"No UUID here.\") == []\n", "\nassert validate_and_extract_... |
e8b63352db8e424eb17c0540d192bdb2 | [
{
"content": "On te demande d'implémenter une fonction récursive `vector_to_str` qui construit la représentation sous forme de chaîne de caractères d'un vecteur 3D. Le vecteur est représenté par une classe `Vector` avec des attributs entiers `x`, `y` et `z`. Ta fonction doit renvoyer une chaîne de caractères au... | ["\nassert vector_to_str(Vector(1, 2, 3)) == \"Vector(1, 2, 3)\"\n", "\nassert vector_to_str(Vector(0, 0, 0)) == \"Vector(0, 0, 0)\"\n", "\nassert vector_to_str(Vector(-1, -2, -3)) == \"Vector(-1, -2, -3)\"\n", "\nassert vector_to_str(Vector(10, 20, 30)) == \"Vector(10, 20, 30)\"\n", "\nassert vector_to_str(Vector(100,... |
bccf78d4c184ac43316e730cb1ee4fd6 | [
{
"content": "On te donne une liste de `n-1` entiers distincts allant de `1` à `n`. Ta tâche est d'identifier l'entier manquant dans la liste. Les entiers sont fournis dans un ordre aléatoire. Conçois un algorithme efficace pour trouver l'entier manquant avec une complexité temporelle de O(n) et une complexité ... | ["\nassert find_missing_element([1, 2, 4, 5, 6]) == 3\n", "\nassert find_missing_element([3, 7, 1, 2, 8, 4, 5]) == 6\n", "\nassert find_missing_element([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == 11\n", "\nassert find_missing_element([1]) == 2\n", "\nassert find_missing_element([2, 3, 4, 5, 6, 7, 8, 9, 10, 1]) == 11\n", "\nass... |
bc1c51f6113cb653545b04ca4d31dbf5 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules et de parenthèses équilibrées. Ta tâche est d'écrire une fonction `calculate_depth` qui calcule la profondeur de chaque caractère de la chaîne. La profondeur d'un caractère est définie comme le nombre de parenthèses imbriquées... | ["\nassert calculate_depth(\"(a(b)c)\") == [1, 2, 2, 1, 0]\n", "\nassert calculate_depth(\"((()))\") == [1, 2, 3, 3, 3, 2, 1]\n", "\nassert calculate_depth(\"()()()\") == [1, 0, 1, 0, 1, 0]\n", "\nassert calculate_depth(\"a(b(c)d)e\") == [0, 1, 2, 2, 1, 0]\n", "\nassert calculate_depth(\"\") == []\n", "\nassert calcula... |
af83dcdc2e7105e8a212d9047b5545d6 | [
{
"content": "On te demande d'implémenter une fonction `validate_email(email)` qui détermine la validité d'une adresse e-mail en fonction de critères spécifiques. La fonction doit renvoyer `True` si l'e-mail est valide, et `False` sinon. Un e-mail est considéré comme valide s'il répond aux conditions suivantes ... | ["\nassert validate_email(\"test@example.com\") == True\n", "\nassert validate_email(\"user.name@domain.co\") == True\n", "\nassert validate_email(\"user_name@sub.domain.com\") == True\n", "\nassert validate_email(\"user-name@domain.com\") == True\n", "\nassert validate_email(\"user@domain.c\") == False\n", "\nassert v... |
92c1dfd9bf6c8505907c900912e7e3ee | [
{
"content": "On te donne un dictionnaire `freqs` où chaque clé est une chaîne de caractères unique et chaque valeur est un nombre réel représentant la fréquence d'occurrence d'un mot dans un document texte. Ta tâche est de normaliser ces fréquences de sorte que la somme de leurs carrés soit égale à 1. Implémen... | ["\nassert normalize_frequencies({'a': 1.0, 'b': 1.0}) == {'a': 0.7071067811865475, 'b': 0.7071067811865475}\n", "\nassert normalize_frequencies({'x': 3.0, 'y': 4.0}) == {'x': 0.6, 'y': 0.8}\n", "\nassert normalize_frequencies({'word': 0.0}) == {'word': 0.0}\n", "\nassert normalize_frequencies({'hello': 2.0, 'world': 2... |
716a94f9ec3f35812c5fa2d256e455fe | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python qui renvoie une nouvelle liste contenant l'intersection de ces deux listes, c'est-à-dire les éléments qui sont présents dans les deux listes sans doublons. L'ordre des éléments dans la liste résultante n'a pas d'importanc... | ["\nassert find_intersection([1, 2, 3], [2, 3, 4]) == [2, 3] or find_intersection([1, 2, 3], [2, 3, 4]) == [3, 2]\n", "\nassert find_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert find_intersection([... |
d556103f9c5962faba11eb3a75bfe9e4 | [
{
"content": "On te donne une liste d'entiers `nums` et un entier `target`. Ta tâche est de trouver toutes les paires uniques de nombres dans `nums` qui s'additionnent pour donner `target`. Chaque paire doit être représentée sous forme de tuple, et les paires doivent être renvoyées dans une liste. L'ordre des p... | ["\nassert find_pairs([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10) == [(1, 9), (2, 8), (3, 7), (4, 6)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 5) == [(1, 4), (2, 3)]\n", "\nassert find_pairs([10, 15, 3, 7], 17) == [(10, 7)]\n", "\nassert find_pairs([1, 1, 1, 1], 2) == [(1, 1)]\n", "\nassert find_pairs([], 10) == []\n", "\nas... |
2abe9bf0696d16ef9622428b91c6489f | [
{
"content": "On te demande d'implémenter une fonction `create_list` qui construit une liste d'une longueur spécifiée, où chaque élément est une valeur donnée. La fonction doit ajouter manuellement chaque élément à la liste en utilisant une boucle et ne doit pas utiliser d'affectation directe de liste ou d'opér... | ["\nassert create_list(5, 1) == [1, 1, 1, 1, 1]\n", "\nassert create_list(0, 7) == []\n", "\nassert create_list(3, 'a') == ['a', 'a', 'a']\n", "\nassert create_list(1, True) == [True]\n", "\nassert create_list(4, None) == [None, None, None, None]\n", "\nassert create_list(2, [1, 2]) == [[1, 2], [1, 2]]\n", "\nassert cr... |
8579a281d3f896bea7233d9e81e0b53a | [
{
"content": "Dans le royaume mystique d'ElfLand, les elfes utilisent un ascenseur unique pour naviguer entre les étages. Le mouvement de l'ascenseur est régi par une séquence de commandes. La commande '(' signifie monter d'un étage, tandis que la commande ')' indique descendre d'un étage. Cependant, l'ascenseu... | ["\nassert elf_elevator(\"()\") == 0\n", "\nassert elf_elevator(\"(((\") == 3\n", "\nassert elf_elevator(\")))\") == -3\n", "\nassert elf_elevator(\"(()())\") == 0\n", "\nassert elf_elevator(\"(((((((\") == 5\n", "\nassert elf_elevator(\")))))))\") == -5\n", "\nassert elf_elevator(\"(()(()))\") == 0\n", "\nassert elf_e... |
0bff914ebee34a807dd020a192eef4ea | [
{
"content": "On te donne un entier `n`. Ta tâche est de trouver la somme consécutive de carrés la plus proche de `n`. La fonction doit renvoyer le nombre de carrés utilisés pour atteindre cette somme. Si `n` est négatif, trouve la somme consécutive de carrés la plus proche qui est inférieure ou égale à la vale... | ["\nassert closest_square_sum(1) == 1\n", "\nassert closest_square_sum(2) == 2\n", "\nassert closest_square_sum(3) == 2\n", "\nassert closest_square_sum(10) == 3\n", "\nassert closest_square_sum(17) == 4\n", "\nassert closest_square_sum(26) == 3\n", "\nassert closest_square_sum(50) == 4\n", "\nassert closest_square_sum... |
20eae51e9fcb106e422898d6cdca340b | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est d'écrire une fonction qui calcule le nombre de sous-tableaux contigus dont la somme est exactement zéro. La fonction doit être efficace et fonctionner avec une complexité temporelle de O(n).\n\n**Exemple d'entrée :**\n```\narr = [1, -1, 3, -3, 4, -4, ... | ["\nassert count_zero_sum_subarrays([1, -1]) == 1\n", "\nassert count_zero_sum_subarrays([1, 2, 3, -6, 1]) == 2\n", "\nassert count_zero_sum_subarrays([0, 0, 0, 0]) == 10\n", "\nassert count_zero_sum_subarrays([1, 2, -3, 3]) == 2\n", "\nassert count_zero_sum_subarrays([1, 2, 3, 4, 5]) == 0\n", "\nassert count_zero_sum_... |
bbe517110cbea237d9f3fb3dd02c748b | [
{
"content": "Tu développes un système pour gérer les dossiers des employés dans une entreprise. Le système doit prendre en charge l'ajout de nouveaux employés et la mise à jour des employés existants. Chaque dossier d'employé comprend un identifiant, un nom, un poste et un salaire. Chaque modification du dossi... | ["\nassert isinstance(EmployeeManager().employees, dict)\n", "\nassert EmployeeManager().add_employee(1, 'John Doe', 'Software Engineer', 95000) is None\n", "\nassert EmployeeManager().update_employee(1, position='Senior Software Engineer', salary=100000) is None\n", "\nassert EmployeeManager().report_employee(1) is No... |
22839c7e621cd1ef077e7acb672c9dfa | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `title` : une chaîne de caractères représentant le titre du livre.\n - `author` : une chaîne de caractères représentant l'auteur du livre.\n - `pages` : un... | ["\nassert Book(\"1984\", \"George Orwell\", 328).get_title() == \"1984\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 281).get_author() == \"Harper Lee\"\n", "\nassert Book(\"War and Peace\", \"Leo Tolstoy\", 1225).get_pages() == 1225\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1... |
f84de303628098c4898046e620dddb4c | [
{
"content": "On te demande d'implémenter une classe `Bookshelf` en Python pour gérer une collection de livres. Chaque livre est représenté comme un dictionnaire avec les clés `title`, `author` et `year`. Ta classe doit supporter les opérations suivantes :\n\n- `add_book(book)` : Ajoute un livre à l'étagère. Si... | ["\nassert Bookshelf().list_books() == []\n", "\nassert Bookshelf().get_books_by_author('George Orwell') == []\n", "\nassert Bookshelf().get_books_by_year(1949) == []\n", "\nbookshelf = Bookshelf()\nbookshelf.add_book({'title': '1984', 'author': 'George Orwell', 'year': 1949})\nassert bookshelf.list_books() == [{'title... |
d921457d20bbc6923cfaf962233ffce5 | [
{
"content": "On te donne deux dataframes, `df_students` et `df_grades`, représentant les informations des étudiants et leurs notes respectives. Le dataframe `df_students` est composé des colonnes `['student_id', 'student_name', 'student_age']`, et le dataframe `df_grades` est composé des colonnes `['student_id... | ["\nassert merge_students_grades(df_students_test, df_grades_test).equals(pd.DataFrame({\n 'student_id': [1, 1, 2, 2],\n 'student_name': ['Alice', 'Alice', 'Bob', 'Bob'],\n 'student_age': [23, 23, 24, 24],\n 'subject': ['Math', 'Science', 'Math', 'Literature'],\n 'grade': [90, 85, 78, 82]\n}))\n", "\nass... |
b3e4f0eb703eff4488e91e2ee28e4532 | [
{
"content": "On te donne deux listes de nombres à virgule flottante, `list1` et `list2`, chacune contenant `N` éléments. Ta tâche est de trouver une paire d'éléments (un de `list1` et un de `list2`) telle que leur somme soit la plus proche d'une valeur cible donnée `target`. De plus, la concaténation des repré... | ["\nassert find_closest_sum([1.2, 3.4, 5.6], [2.2, 4.4, 6.6], 10) == 0.2\n", "\nassert find_closest_sum([1.5, 2.5, 3.5], [4.5, 5.5, 6.5], 10) == 0.0\n", "\nassert find_closest_sum([1.1, 2.1, 3.1], [4.1, 5.1, 6.1], 10) == 0.9\n", "\nassert find_closest_sum([1.0, 2.0, 3.0], [3.0, 2.0, 1.0], 6) == 0.0\n", "\nassert find_c... |
cddf25c8f794d80ae8506c02696dba0f | [
{
"content": "On te donne une liste de dictionnaires, où chaque dictionnaire représente un employé avec au moins les clés suivantes : 'name', 'age' et 'department'. Ta tâche est de mettre en œuvre une fonction `sort_and_filter` qui traite cette liste. La fonction doit d'abord filtrer les employés de moins de 18... | ["\nassert sort_and_filter([{'name': 'Alice', 'age': 25, 'department': 'HR'}, {'name': 'Bob', 'age': 17, 'department': 'Engineering'}, {'name': 'Charlie', 'age': 30, 'department': 'Marketing'}, {'name': 'David', 'age': 22, 'department': 'Engineering'}]) == [{'name': 'Alice', 'age': 25, 'department': 'HR'}, {'name': 'Da... |
50f28b9baf3b2605e315a79ff968d320 | [
{
"content": "Tu es chargé d'implémenter une fonction `calculate_fibonacci(n)` qui génère les `n` premiers nombres de la suite de Fibonacci. La suite de Fibonacci commence par 0 et 1, chaque nombre suivant étant la somme des deux nombres précédents. Ta fonction doit gérer les cas limites où `n` est 0 ou 1.\n\n*... | ["\nassert calculate_fibonacci(0) == []\n", "\nassert calculate_fibonacci(1) == [0]\n", "\nassert calculate_fibonacci(2) == [0, 1]\n", "\nassert calculate_fibonacci(3) == [0, 1, 1]\n", "\nassert calculate_fibonacci(5) == [0, 1, 1, 2, 3]\n", "\nassert calculate_fibonacci(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\na... |
2b1cf39b619d9d2030fe16331c873d30 | [
{
"content": "On te donne une liste triée d'entiers et une valeur cible. Implémente une fonction pour effectuer une recherche binaire sur la liste. La fonction doit renvoyer l'index de la valeur cible si elle existe dans la liste, ou -1 si elle n'existe pas.\n\n**Entrée :**\n- Une liste triée d'entiers : `[1, 3... | ["\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 7) == 3\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 1) == 0\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 19) == 9\n", "\nassert binary_search([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], 10) == -1\n", "\nassert binary_search(... |
0b06209669e68a402555c95ffda90888 | [
{
"content": "On te donne un fichier CSV nommé `stock_market_data.csv` contenant des données quotidiennes du marché boursier avec les colonnes suivantes : \"Date\", \"Open\", \"High\", \"Low\", \"Close\" et \"Volume\". Ta tâche est d'écrire un script Python qui lit ce fichier CSV et calcule les statistiques sui... | ["\nassert load_csv_data('test_data.csv').shape == (5, 6)\n", "\nassert calculate_statistics(pd.DataFrame({'Close': [100, 200, 300, 400, 500]})) == None # This checks if the function prints without error\n", "\nassert load_csv_data('test_data.csv')['Date'].dtype == 'object'\n", "\nassert load_csv_data('test_data.csv')... |
f7b8b11ab0652d96761d463a1b71963f | [
{
"content": "On te donne deux matrices `matrixA` et `matrixB` représentées comme des listes de listes. Ta tâche est d'implémenter une fonction `multiplyMatrices` qui renvoie le produit de ces deux matrices. On suppose que les matrices d'entrée sont bien formées et que le nombre de colonnes dans `matrixA` est é... | ["\nassert multiplyMatrices([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == [[19, 22], [43, 50]]\n", "\nassert multiplyMatrices([[1, 0], [0, 1]], [[1, 2], [3, 4]]) == [[1, 2], [3, 4]]\n", "\nassert multiplyMatrices([[2, 0, 1], [3, 0, 0], [5, 1, 1]], [[1, 0, 1], [2, 2, 3], [4, 0, 5]]) == [[6, 0, 7], [3, 0, 8], [11, 2, 13]]\n", "... |
e4ac4ff25f825b6eb86b59cd1c10cb65 | [
{
"content": "On te demande d'implémenter une classe Python nommée `Graph` pour représenter un graphe non orienté en utilisant une liste d'adjacence. La classe doit prendre en charge les opérations suivantes :\n- `add_node(node)` : Ajoute un nœud au graphe.\n- `add_edge(node1, node2)` : Ajoute une arête non ori... | ["\nassert list(g.graph.keys()) == ['A', 'B', 'C', 'D', 'E']\n", "\nassert g.graph['A'] == ['B', 'C']\n", "\nassert g.graph['B'] == ['A', 'D']\n", "\nassert g.graph['C'] == ['A', 'E']\n", "\nassert g.graph['D'] == ['B', 'E']\n", "\nassert g.graph['E'] == ['C', 'D']\n", "\nassert g.add_node('F') is None # add_node does... |
1a4b36ef0603b5e767337d2181759e9a | [
{
"content": "On te donne deux listes triées d'entiers, `list1` et `list2`, qui peuvent contenir `float('inf')` comme valeur sentinelle pour indiquer la fin de la liste. Ta tâche est de fusionner ces deux listes en une nouvelle liste triée, en excluant les valeurs sentinelles. Implémente la fonction `merge_sort... | ["\nassert merge_sorted_lists([1, 3, 5, float('inf')], [2, 4, 6, float('inf')]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_sorted_lists([1, 2, 3, float('inf')], [4, 5, 6, float('inf')]) == [1, 2, 3, 4, 5, 6]\n", "\nassert merge_sorted_lists([1, float('inf')], [2, 3, 4, float('inf')]) == [1, 2, 3, 4]\n", "\nassert merge_... |
a77fd6962114b29f16292db0cbd28bff | [
{
"content": "On te demande d'implémenter un système simple de gestion de bibliothèque en utilisant une classe Python. Le système doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un livre** : Ajouter un livre à la bibliothèque avec son titre, son auteur et son ISBN. Si un livre avec le même ISB... | ["\nassert \"The Great Gatsby\" in library.available_books[\"1234567890\"].values()\n", "\nassert \"George Orwell\" in library.available_books[\"0987654321\"].values()\n", "\nassert \"1234567890\" in library.available_books\n", "\nassert \"0987654321\" in library.available_books\n", "\nassert \"1234567890\" not in libr... |
6c5a89fe4812332487caa834c81b28a3 | [
{
"content": "On te donne une chaîne de caractères représentant la docstring d'une fonction Python, qui peut contenir des commentaires multilignes et des extraits de code imbriqués entre parenthèses. Ta tâche est d'extraire ces extraits de code sous forme de liste de chaînes de caractères tout en préservant leu... | ["\nassert parse_docstring(\"No snippets here.\") == []\n", "\nassert parse_docstring(\"(single)\") == [\"(single)\"]\n", "\nassert parse_docstring(\"Text (first) and (second) snippets.\") == [\"(first)\", \"(second)\"]\n", "\nassert parse_docstring(\"Nested (outer (inner)) structure.\") == [\"(outer (inner))\"]\n", "\... |
0b471395fd8999901f01d3685717fa7d | [
{
"content": "On te donne un prisme droit dont la base est un polygone régulier et dont les faces latérales sont des rectangles. Ta tâche est d'écrire une fonction `prism_surface_area` qui calcule l'aire totale de ce prisme. Le polygone de base peut avoir jusqu'à 20 côtés. Ta fonction doit être efficace et gére... | ["\nassert prism_surface_area(3, 1, 1) == 3 * math.sqrt(3) / 4 + 3\n", "\nassert prism_surface_area(4, 1, 1) == 2 + 4\n", "\nassert prism_surface_area(5, 1, 1) == 5 * math.sqrt(5 * (5 + 2 * math.sqrt(5))) / 4 + 5\n", "\nassert prism_surface_area(6, 1, 1) == 3 * math.sqrt(3) + 6\n", "\nassert prism_surface_area(10, 2, 5... |
8bb6958c89dbe891687035301aa9bd34 | [
{
"content": "On te demande d'implémenter une fonction `convert_to_json(data)` qui prend un dictionnaire Python `data` en entrée et renvoie une représentation sous forme de chaîne JSON du dictionnaire. La chaîne JSON doit être formatée avec une indentation de 4 espaces. Le dictionnaire d'entrée peut contenir di... | ["\nassert convert_to_json({'key1': 'value1', 'key2': [1, 2, 3], 'key3': {'nested_key': 'nested_value'}, 'key4': {1, 2, 3}}) == '{\\n \"key1\": \"value1\",\\n \"key2\": [1, 2, 3],\\n \"key3\": {\\n \"nested_key\": \"nested_value\"\\n },\\n \"key4\": [1, 2, 3]\\n}'\n", "\nassert convert_to_json({'k... |
9ab0e2a2a927b5723d956bdc826468ac | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les entiers uniques de la liste originale, en préservant l'ordre de leur première apparition.\n\n**Entrée :**\n- Une liste d'entiers `input_list` (1 ≤ len(input_list) ≤ 10^5)... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([7, 8, 9]) == [7, 8, 9]\n", "\nassert remove_dupl... |
d1287c308eacf1675edf39e64f374396 | [
{
"content": "Tu participes à un défi de traitement du langage naturel où l'on te donne une matrice `embed_matrix` de forme `(vocab_size, embed_dim)` représentant les plongements de mots pour un vocabulaire de `vocab_size` mots, chacun ayant `embed_dim` dimensions. De plus, on te fournit un tenseur `embedding` ... | ["\nassert np.allclose(calculate_logits(np.array([[1, 0], [0, 1]]), np.array([[[1, 0]], [[0, 1]]])), np.array([[[1, 0]], [[0, 1]]]))\n", "\nassert np.allclose(calculate_logits(np.array([[1, 1], [1, -1]]), np.array([[[1, 1]], [[1, -1]]])), np.array([[[1, 1]], [[1, 1]]]))\n", "\nassert np.allclose(calculate_logits(np.arr... |
f9606cf62336487d50c0294ade50330c | [
{
"content": "On te donne un entier non négatif `value` avec au plus 100 chiffres, une position de départ `start_position`, et une longueur `length`. Ta tâche est d'extraire une séquence de `length` bits de `value`, en commençant à la position `start_position` (où le bit le moins significatif est à la position ... | ["\nassert extract_bits(0b101010, 0, 3) == \"110\"\n", "\nassert extract_bits(0b101010, 1, 3) == \"101\"\n", "\nassert extract_bits(0b101010, 2, 3) == \"010\"\n", "\nassert extract_bits(0b101010, 3, 3) == \"101\"\n", "\nassert extract_bits(0b101010, 4, 3) == \"010\"\n", "\nassert extract_bits(0b101010, 5, 1) == \"1\"\n... |
03f933adc8893c5cfc7c3db1d8042caa | [
{
"content": "On te donne la tâche d'implémenter une fonction qui traite un fichier texte. Ta fonction doit prendre un seul argument, une chaîne de caractères représentant le chemin du fichier, et renvoyer un tuple contenant trois entiers : le nombre de lignes, le nombre de mots et le nombre de caractères dans ... | ["\nassert count_file_contents(\"test.txt\") == (3, 15, 85)\n", "\nassert count_file_contents(\"empty.txt\") == (0, 0, 0)\n", "\nassert count_file_contents(\"single_line.txt\") == (1, 5, 25)\n", "\nassert count_file_contents(\"non_existent_file.txt\") == \"File not found\"\n", "\nassert count_file_contents(\"file_with_... |
ccbe46109e0e5be3401b93bd3e2909fb | [
{
"content": "On te donne une chaîne de caractères représentant une expression mathématique composée d'entiers non négatifs, d'opérateurs `+`, `-`, `*`, `/`, et de parenthèses `()`. Ta tâche est d'évaluer l'expression et de renvoyer le résultat sous forme de nombre à virgule flottante. L'expression doit être év... | ["\nassert evaluate_expression(\"3 + 5\") == 8.0\n", "\nassert evaluate_expression(\"10 - 2\") == 8.0\n", "\nassert evaluate_expression(\"4 * 6\") == 24.0\n", "\nassert evaluate_expression(\"20 / 4\") == 5.0\n", "\nassert evaluate_expression(\"3 + 5 * 2 - 8\") == 5.0\n", "\nassert evaluate_expression(\"3 + 5 * (2 - 8)\... |
dcf71c9e4bd60e26a36a47d3173698b7 | [
{
"content": "On te donne une liste d'entiers `nums`. Ton objectif est d'implémenter une fonction `remove_duplicates(nums: list) -> list` qui renvoie une nouvelle liste contenant uniquement les éléments uniques de `nums`, en préservant leur ordre d'apparition d'origine.\n\n**Contraintes :**\n- La longueur de `n... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 20, 30, 40, 50]) == [10, 20, 30, 40, 50]\n", "\nassert remove_duplicates([5, 4, 3, 2, 1, 1, 2, 3, 4, 5]) == [5, 4,... |
085fa0b9c10f319ea42cd466826b7e64 | [
{
"content": "On te donne un tableau trié `nums` d'entiers distincts et un entier cible `target`. Ta tâche est de déterminer l'index auquel `target` doit être inséré pour maintenir l'ordre trié du tableau. Si `target` est déjà présent dans le tableau, retourne son index. La solution doit être efficace avec une ... | ["\nassert search_insert([1, 3, 5, 6], 5) == 2\n", "\nassert search_insert([1, 3, 5, 6], 2) == 1\n", "\nassert search_insert([1, 3, 5, 6], 7) == 4\n", "\nassert search_insert([1, 3, 5, 6], 0) == 0\n", "\nassert search_insert([], 1) == 0\n", "\nassert search_insert([1], 1) == 0\n", "\nassert search_insert([1], 2) == 1\n... |
103c6a0d9dbcd3fb73b0d436d9a08bf5 | [
{
"content": "On te donne un graphe non orienté avec `n` nœuds, représenté comme une liste d'adjacence. Chaque nœud est étiqueté avec un entier de `0` à `n-1`. Le graphe peut contenir des boucles et des arêtes parallèles. Ta tâche est de déterminer le nœud ayant la somme la plus élevée de sa propre valeur et de... | ["\nassert node_with_highest_sum([[1, 2], [0, 2], [0, 1]]) == 0\n", "\nassert node_with_highest_sum([[1, 2, 3], [0, 2], [0, 1, 3], [0, 2]]) == 2\n", "\nassert node_with_highest_sum([[0], [1], [2], [3]]) == 0\n", "\nassert node_with_highest_sum([[1, 1, 1], [0, 0, 0], [0, 0, 0]]) == 0\n", "\nassert node_with_highest_sum(... |
6043c9b3bb38186837d8fbc59b2f26e4 | [
{
"content": "On te donne une liste `numbers` contenant des entiers, des nombres à virgule flottante et des valeurs booléennes. Ta tâche est de mettre en œuvre une fonction `filter_integers` qui renvoie une nouvelle liste ne contenant que les valeurs entières de la liste d'entrée, en excluant toutes les valeurs... | ["\nassert filter_integers([1, 2.5, True, 3, False, 4.7, 5]) == [1, 3, 5]\n", "\nassert filter_integers([True, False, True, False]) == []\n", "\nassert filter_integers([10, 20, 30, 40]) == [10, 20, 30, 40]\n", "\nassert filter_integers([1.1, 2.2, 3.3, 4.4]) == []\n", "\nassert filter_integers([1, 2, 3, True, False, 4, ... |
c6c0a87aad496fe0ef7e1fc9cc9eed8a | [
{
"content": "On te donne une chaîne de caractères `s` qui peut contenir plusieurs espaces entre les mots et des espaces au début et à la fin. Ta tâche est d'écrire une fonction `capitalize_words` qui renvoie une nouvelle chaîne de caractères où la première lettre de chaque mot est en majuscule. Les mots sont d... | ["\nassert capitalize_words(\"hello world\") == \"Hello World\"\n", "\nassert capitalize_words(\" hello world \") == \"Hello World\"\n", "\nassert capitalize_words(\"multiple spaces\") == \"Multiple Spaces\"\n", "\nassert capitalize_words(\" leading and trailing spaces \") == \"Leading And Trailing Spaces\"\n"... |
e520394f82d81fc9e60c8ea0faae0bee | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui prend en charge les opérations bancaires de base. La classe doit permettre les dépôts, les retraits et les demandes de solde. De plus, elle doit conserver un historique des transactions et gérer les opérations non valides avec élég... | ["\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount().get_balance() == 0\n", "\naccount = BankAccount(100)\naccount.deposit(50)\nassert account.get_balance() == 150\n", "\naccount = BankAccount(100)\naccount.deposit(50)\naccount.withdraw(30)\nassert account.get_balance() == 120\n", "\naccount = B... |
b65070f15e5da68f6848e8d5479a0c2b | [
{
"content": "On te demande d'implémenter une fonction `encode_message` qui traite une chaîne de caractères donnée et renvoie un tuple constitué d'une étiquette de type et d'un message encodé. Le processus d'encodage implique les étapes suivantes :\n\n1. Calcule la longueur de la chaîne d'entrée.\n2. Calcule la... | ["\nassert encode_message(\"hello\") == ('x', b'\\x00\\x05hello\\x00\\x00\\x00')\n", "\nassert encode_message(\"hi\") == ('x', b'\\x00\\x02hi\\x00\\x00\\x00\\x00\\x00')\n", "\nassert encode_message(\"a\") == ('x', b'\\x00\\x01a\\x00\\x00\\x00\\x00\\x00')\n", "\nassert encode_message(\"abcdefghij\") == ('x', b'\\x00\\x0... |
7487265d8d7be08b289dfab648daa643 | [
{
"content": "On te donne une liste d'entiers `numbers` et deux indices `start` et `end`. La liste `numbers` est garantie de ne pas être vide et peut contenir des valeurs négatives. Ta tâche est de mettre en œuvre une fonction `find_max_index` qui renvoie l'indice de la valeur maximale dans le segment de la lis... | ["\nassert find_max_index([1, 3, 7, 7, 2, 5], 1, 4) == 3\n", "\nassert find_max_index([10, 20, 30, 40, 50], 0, 4) == 4\n", "\nassert find_max_index([-10, -20, -30, -40, -5], 0, 4) == 4\n", "\nassert find_max_index([5, 5, 5, 5, 5], 0, 4) == 4\n", "\nassert find_max_index([1, 2, 3, 4, 5], 2, 2) == 2\n", "\nassert find_ma... |
241cfabea3fc869846af193f00132df9 | [
{
"content": "On te donne deux listes : `messages` et `indent_levels`. Ta tâche est d'implémenter une fonction `indented_print` qui affiche chaque message de la liste `messages` avec le niveau d'indentation correspondant de la liste `indent_levels`. Le niveau d'indentation représente le nombre d'espaces à ajout... | ["\nassert indented_print([\"hello\", \"world\"], [0, 4]) == None\n", "\nassert indented_print([\"hello\", \"world\"], [2, 2]) == None\n", "\nassert indented_print([\"hello\", \"world\"], [5]) == None\n", "\nassert indented_print([\"hello\"], [0, 4]) == None\n", "\nassert indented_print([\"hello\", \"world\"], [-1, 4])... |
94f825e3b77c809489f08a58c69ab992 | [
{
"content": "On te donne une chaîne de caractères `code` représentant un fragment de code Python. Ta tâche est d'écrire une fonction `optimize_code` qui applique des optimisations de base au code. Les optimisations incluent la suppression des espaces inutiles (à l'exception de l'indentation), la simplification... | ["\nassert optimize_code(\"def foo():\\n x = 0\\n for i in range(10):\\n x += i\\n return x\") == \"def foo():\\nx = sum(range(10))\\nreturn x\"\n", "\nassert optimize_code(\"def bar():\\n y = 0\\n for j in lst:\\n y += j\\n return y\") == \"def bar():\\ny = sum(lst)\\nreturn y\"\n", "\n... |
da01643eab7dad37ab08c89a1407d101 | [
{
"content": "On te donne une liste d'entiers, `nums`, qui peut contenir des doublons et des zéros. Ta tâche est de réorganiser les éléments de la liste de sorte que tous les éléments non nuls apparaissent en premier, suivis de tous les zéros, tout en maintenant l'ordre des éléments non nuls et des zéros. De pl... | ["\nassert rearrange([0, 1, 0, 3, 12]) == []\n", "\nassert rearrange([0, 2, 0, 3, 5]) == []\n", "\nassert rearrange([0, 1, 0, 2, 0, 3]) == []\n", "\nassert rearrange([0, 1, 0, 2, 0, 3, 5]) == [1, 2, 3, 5, 0, 0, 0]\n", "\nassert rearrange([0, 0, 0, 0]) == []\n", "\nassert rearrange([1, 2, 3, 4]) == [1, 2, 3, 4]\n", "\na... |
d2cd3ff73c52e31aaf051b77531fcf6e | [
{
"content": "On te donne une chaîne de caractères `text` et un motif `pattern`. Ta tâche est de mettre en œuvre une fonction `find_pattern_ranges` qui identifie toutes les occurrences non chevauchantes de `pattern` dans `text`, sans tenir compte de la casse. La fonction doit renvoyer une liste de tuples, où ch... | ["\nassert find_pattern_ranges(\"Hello world\", \"hello\") == [(0, 5)]\n", "\nassert find_pattern_ranges(\"abcABCabc\", \"abc\") == [(0, 3), (3, 6), (6, 9)]\n", "\nassert find_pattern_ranges(\"mississippi\", \"issi\") == [(1, 5)]\n", "\nassert find_pattern_ranges(\"aaaaa\", \"aa\") == [(0, 2), (2, 4)]\n", "\nassert fin... |
d6fc0e1ff1d316247c7ede4a6e7214d4 | [
{
"content": "On te donne un chemin de répertoire. Ta tâche est d'écrire un programme Python qui compte le nombre de fichiers dans chaque sous-répertoire du répertoire donné. Le programme doit afficher les noms des sous-répertoires et leurs nombres de fichiers respectifs. Suppose que la structure de répertoires... | ["\nassert count_files_in_subdirectories('/path/to/empty') == None\n", "\nassert count_files_in_subdirectories('/path/to/single_file') == None\n", "\nassert count_files_in_subdirectories('/path/to/multiple_files') == None\n", "\nassert count_files_in_subdirectories('/path/to/nested_subdirs') == None\n", "\nassert count... |
7277d431502a81fbd3b475592e598f17 | [
{
"content": "On te donne un tableau d'entiers. Pour chaque élément du tableau, trouve l'élément le plus petit à sa gauche. Si un tel élément n'existe pas, renvoie -1 pour cette position. Renvoie un tableau de la même longueur où chaque élément à l'index `i` contient l'index de l'élément le plus petit à gauche ... | ["\nassert nearest_smaller_left([1, 3, 2, 4]) == [-1, 0, 0, 2]\n", "\nassert nearest_smaller_left([15, 18, 5, 3, 6, 2, 9]) == [-1, 0, -1, -1, 3, -1, 5]\n", "\nassert nearest_smaller_left([10, 9, 8, 7, 6, 5]) == [-1, -1, -1, -1, -1, -1]\n", "\nassert nearest_smaller_left([1, 2, 3, 4, 5]) == [-1, 0, 1, 2, 3]\n", "\nasser... |
707617294e0b5035f7ddcfdd39523bc8 | [
{
"content": "On te donne une liste d'entiers et une liste de signatures de fonctions sous forme de chaînes de caractères. Ta tâche est d'analyser et d'appliquer ces fonctions à la liste d'entiers. Chaque signature de fonction doit assigner une valeur à la variable `result`. Si une signature de fonction contien... | ["\nassert apply_functions([1, 2, 3], [\"result = sum(x)\"]) == [6]\n", "\nassert apply_functions([1, 2, 3], [\"result = len(x)\"]) == [3]\n", "\nassert apply_functions([1, 2, 3], [\"result = sum(x) + max(x)\"]) == [9]\n", "\nassert apply_functions([1, 2, 3], [\"resultAAA = len(x)\"]) == [\"Function signature 'resultAA... |
a5ee0be70f961fac1caa438ffea2604c | [
{
"content": "On te donne une matrice 2D `matrix` représentant les distances entre différents points, où `matrix[i][j]` représente la distance entre le point `i` et le point `j`. Ta tâche est d'implémenter la fonction `extract_submatrix(matrix, indices)` qui construit et renvoie une nouvelle matrice ne contenan... | ["\nassert extract_submatrix([[0, 2, 9, 10], [1, 0, 6, 4], [15, 7, 0, 8], [6, 3, 12, 0]], [0, 2, 3]) == [[0, 9, 10], [15, 0, 8], [6, 12, 0]]\n", "\nassert extract_submatrix([[1, 2], [3, 4]], [0]) == [[1]]\n", "\nassert extract_submatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1, 2]) == [[5, 6], [8, 9]]\n", "\nassert extrac... |
43eafe7ad75faea6bce54514bf7f9af7 | [
{
"content": "On te donne une série temporelle représentée comme une liste d'objets `datetime`. Ta tâche est de créer une fonction `generate_time_offsets` qui calcule tous les décalages temporels possibles pour cette série. Un décalage est défini comme un objet `timedelta` qui peut être ajouté ou soustrait d'un... | ["\nassert generate_time_offsets([datetime(2022, 1, 1, 0, 0, 0)]) == [timedelta(hours=-1), timedelta(hours=1)]\n", "\nassert generate_time_offsets([datetime(2022, 1, 1, 0, 0, 0), datetime(2022, 1, 1, 1, 0, 0)]) == [timedelta(hours=-1), timedelta(hours=1), timedelta(hours=1)]\n", "\nassert generate_time_offsets([datetim... |
7e5b08cf706994313e090d1b7e079296 | [
{
"content": "On te donne une liste de `books` et une liste de `tags`. Chaque livre est représenté comme un dictionnaire avec les clés suivantes : `title`, `author`, et `tags`. La clé `tags` contient une liste de chaînes de caractères représentant les tags associés au livre. Implémente la fonction `filter_books... | ["\nassert filter_books(books, [\"fiction\"]) == [{'title': 'Book A', 'author': 'Author X', 'tags': ['fiction', 'classic']}, {'title': 'Book C', 'author': 'Author X', 'tags': ['fiction', 'modern']}, {'title': 'Book D', 'author': 'Author Z', 'tags': ['graphic', 'fiction']}]\n", "\nassert filter_books(books, [\"graphic\"... |
b3872c3baa612b5f6d1a42cd53a145d7 | [
{
"content": "On te donne une liste de listes, où chaque sous-liste contient un nombre variable d'entiers. Ta tâche est d'écrire une fonction qui calcule la médiane de chaque sous-liste et renvoie une nouvelle liste contenant ces médianes. Tu dois utiliser une implémentation personnalisée de l'algorithme de tri... | ["\nassert calculate_medians([[3, 1, 2]]) == [2]\n", "\nassert calculate_medians([[4, 5, 6, 7]]) == [5.5]\n", "\nassert calculate_medians([[10, 2, 5, 1, 3]]) == [3]\n", "\nassert calculate_medians([[1, 2, 3, 4, 5, 6]]) == [3.5]\n", "\nassert calculate_medians([[7]]) == [7]\n", "\nassert calculate_medians([[1, 3, 3, 6, ... |
f586cb58ace26db3941bc608e5e76c68 | [
{
"content": "Implémente une classe Python nommée `Calculator` qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. Chaque méthode doit prendre deux arguments numériques et renvoyer le résultat de l'opération. La méthode de division doit gérer la divisio... | ["\nassert Calculator().add(2, 3) == 5\n", "\nassert Calculator().subtract(5, 3) == 2\n", "\nassert Calculator().multiply(4, 6) == 24\n", "\nassert Calculator().divide(10, 2) == 5.0\n", "\nassert Calculator().add(-1, -1) == -2\n", "\nassert Calculator().subtract(0, 0) == 0\n", "\nassert Calculator().multiply(0, 5) == 0... |
602ac6b9e64f602091c878d6a3f002fc | [
{
"content": "On te demande d'implémenter une fonction `is_valid_url` qui détermine si une chaîne de caractères donnée est une URL valide. Une URL valide doit commencer par `http://`, `https://` ou `ftp://`, suivi d'un nom de domaine valide et d'un chemin d'accès facultatif. La fonction doit renvoyer `True` si ... | ["\nassert is_valid_url(\"https://www.example.com\") == True\n", "\nassert is_valid_url(\"ftp://example.com/resource\") == True\n", "\nassert is_valid_url(\"not-a-url\") == False\n", "\nassert is_valid_url(\"http://example\") == True\n", "\nassert is_valid_url(\"https://example.com/path/to/resource?query=param#fragment... |
9f5e7032bfe683945f41f681e781a382 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'implémenter une fonction `remove_duplicates(strings)` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les chaînes de caractères uniques, en préservant l'ordre de leur première occurrence.\n\n**Entrée :**\n... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"cherry\", \"apple\", \"date\", \"banana\", \"elderberry\", \"fig\", \"grape\", \"date\"]) == [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"]\n", "\nassert remove_duplicates([\"a\", \"b\", \"c\", \"a\", \"b\", \"c\"]) == [\"a\", \"b... |
6421e7c7bd243f720fcdfb5ac07f4304 | [
{
"content": "On te donne un fichier texte contenant plusieurs lignes de texte. Ta tâche est d'écrire une fonction `find_unique_words` qui lit ce fichier et renvoie un ensemble de tous les mots uniques trouvés dans le fichier. La fonction doit être insensible à la casse et doit supprimer la ponctuation des mots... | ["\nassert find_unique_words(\"test1.txt\") == {\"hello\", \"world\"}\n", "\nassert find_unique_words(\"test2.txt\") == {\"this\", \"is\", \"a\", \"test\", \"file\"}\n", "\nassert find_unique_words(\"test3.txt\") == {\"unique\", \"words\", \"here\"}\n", "\nassert find_unique_words(\"test4.txt\") == {\"punctuation,\", \... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.