id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
af7d283f8c839ad384522eed87ad49aa | [
{
"content": "On te donne deux listes de vecteurs 3D, `vector_list_a` et `vector_list_b`, chacune contenant `n` vecteurs. Chaque vecteur est représenté comme une liste de trois nombres à virgule flottante. Avant de calculer le produit scalaire, transforme chaque vecteur dans `vector_list_a` en utilisant la matr... | ["\nassert vector_dot_product([[1.0, 2.0, 3.0]], [[3.0, 2.0, 1.0]]) == [7.0]\n", "\nassert vector_dot_product([[0.0, 0.0, 0.0]], [[1.0, 1.0, 1.0]]) == [0.0]\n", "\nassert vector_dot_product([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], [[0.0, 1.0, 0.0], [1.0, 0.0, 0.0]]) == [0.0, 0.0]\n", "\nassert vector_dot_product([[1.0, 2.0,... |
dd328af228b2e36e8a219fbdd8ecdf4c | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente un point dans l'espace 2D sous la forme (x, y). Ta tâche est d'écrire une fonction qui calcule l'angle en degrés entre la ligne reliant le premier point au dernier point et l'axe des x. L'angle doit être mesuré dans le sens inverse des ai... | ["\nassert angle_between_points([(0, 0), (1, 1)]) == 45.0\n", "\nassert angle_between_points([(1, 1), (0, 0)]) == -135.0\n", "\nassert angle_between_points([(0, 0), (0, 1)]) == 90.0\n", "\nassert angle_between_points([(0, 0), (1, 0)]) == 0.0\n", "\nassert angle_between_points([(0, 0), (0, -1)]) == -90.0\n", "\nassert a... |
f98ecf91581681e83846209b92187c64 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une chaîne de caractères et d'un entier. La chaîne de caractères représente une clé, et l'entier représente une valeur. Ta tâche est de mettre en œuvre une fonction qui transforme cette liste en un dictionnaire. Le dictionnaire doit êt... | ["\nassert tuples_to_sorted_dict([('apple', 2), ('banana', 5), ('apple', 3), ('orange', 1), ('banana', 2)]) == {'orange': 1, 'banana': 7, 'apple': 5}\n", "\nassert tuples_to_sorted_dict([('a', 1), ('b', 2), ('c', 3)]) == {'c': 3, 'b': 2, 'a': 1}\n", "\nassert tuples_to_sorted_dict([('z', 10), ('y', 20), ('z', 30)]) == ... |
e4d59375dbf502d6a0d7c2ad6f74811d | [
{
"content": "On te demande de traiter une liste de boîtes englobantes détectées dans une image. Chaque boîte englobante est représentée comme un dictionnaire avec les clés \"text\", \"conf\", \"left\", \"top\", \"width\" et \"height\". Ton objectif est de filtrer les boîtes englobantes qui n'intersectent pas a... | ["\nassert filter_bounding_boxes([{\"text\": \"test\", \"conf\": 0.9, \"left\": 10, \"top\": 10, \"width\": 50, \"height\": 50}], (0, 0, 100, 100)) == [(10, 10, 50, 50)]\n", "\nassert filter_bounding_boxes([{\"text\": \"test\", \"conf\": 0.9, \"left\": 10, \"top\": 10, \"width\": 50, \"height\": 50}], (60, 60, 100, 100... |
08bbf4b07f959e7c1ae2e65cd9d161a0 | [
{
"content": "On te donne une fraction représentée par deux entiers, le numérateur et le dénominateur. Ta tâche est d'écrire une fonction `simplify_fraction(numerator, denominator)` qui renvoie la fraction sous sa forme la plus simple sous la forme d'un tuple de deux entiers. La fraction doit être réduite à ses... | ["\nassert simplify_fraction(10, 20) == (1, 2)\n", "\nassert simplify_fraction(45, 10) == (9, 2)\n", "\nassert simplify_fraction(100, 25) == (4, 1)\n", "\nassert simplify_fraction(0, 1) == (0, 1)\n", "\nassert simplify_fraction(1, 0) == ValueError(\"Invalid fraction\")\n", "\nassert simplify_fraction(-10, 20) == (-1, 2... |
89590b722c7eedcf6c4d0e6cdeda93e3 | [
{
"content": "On te donne une séquence d'entiers. Ta tâche est d'implémenter une fonction `find_first_even` qui identifie le premier nombre pair positif dans la séquence. Si un tel nombre n'existe pas, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Un itérable d'entiers.\n\n**Sortie :**\n- Le premier enti... | ["\nassert find_first_even([1, 3, 5, 7]) == None\n", "\nassert find_first_even([2, 4, 6, 8]) == 2\n", "\nassert find_first_even([-2, -4, 6, 8]) == 6\n", "\nassert find_first_even([0, 1, 2, 3]) == 2\n", "\nassert find_first_even([-1, -3, -5, -7, 2]) == 2\n", "\nassert find_first_even([]) == None\n", "\nassert find_first... |
b28d5d8455aaac02787c4c990e5771f9 | [
{
"content": "On te donne une liste de noms et un dictionnaire qui associe certains de ces noms à leurs surnoms respectifs. Implémente une fonction `get_nickname_or_capitalize` qui prend un nom en entrée et renvoie le surnom correspondant s'il existe dans le dictionnaire. Si le nom n'a pas de surnom, renvoie le... | ["\nassert get_nickname_or_capitalize(\"John\", {\"Alice\": \"Al\", \"Bob\": \"Bobby\"}) == \"JOhN\"\n", "\nassert get_nickname_or_capitalize(\"Alice\", {\"Alice\": \"Al\", \"Bob\": \"Bobby\"}) == \"Al\"\n", "\nassert get_nickname_or_capitalize(\"Bob\", {\"Alice\": \"Al\", \"Bob\": \"Bobby\"}) == \"Bobby\"\n", "\nasser... |
4ca27a1d59ecf364ee7e167080813f61 | [
{
"content": "On te donne un ensemble de données de transactions de vente pour un magasin de détail. Chaque transaction est représentée comme un dictionnaire avec les clés suivantes : 'transaction_id', 'customer_id', 'items', 'amount', 'timestamp'. Ta tâche est d'écrire une fonction Python `aggregate_sales_data... | ["\nassert aggregate_sales_data([]) == {}\n", "\nassert aggregate_sales_data([{\"transaction_id\": 1, \"customer_id\": 101, \"items\": [\"apple\"], \"amount\": 5.00, \"timestamp\": \"2021-07-21T12:34:56Z\"}]) == {101: {'total_amount': 5.00, 'unique_items_count': 1}}\n", "\nassert aggregate_sales_data([{\"transaction_id... |
8951dba1e2a267fbbd6442e6f858d06b | [
{
"content": "On te donne une chaîne de caractères `s` et un ensemble de sous-chaînes `substrings`. Ta tâche est de mettre en œuvre une fonction `count_substrings` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les sous-chaînes de l'ensemble `substrings`, et les valeurs doivent être le nombr... | ["\nassert count_substrings(\"Hello, hello, HELLO!\", {\"hello\"}) == {\"hello\": 3}\n", "\nassert count_substrings(\"Hello, hello, HELLO!\", {\"world\"}) == {\"world\": 0}\n", "\nassert count_substrings(\"Hello, hello, HELLO!\", {\"hello\", \"world\"}) == {\"hello\": 3, \"world\": 0}\n", "\nassert count_substrings(\"a... |
2929a667dddbcd5671c92713003644c4 | [
{
"content": "Implémente l'algorithme du crible d'Ératosthène pour trouver tous les nombres premiers jusqu'à une limite donnée `N`. En plus de la liste des nombres premiers, ta fonction doit renvoyer une liste de \"paires de nombres premiers\" - des paires de nombres premiers qui ont une différence de 2. De plu... | ["\nassert sieve_of_eratosthenes(10) == ([2, 3, 5, 7], [(3, 5)], {2: 3, 3: 5, 5: 7, 7: None})\n", "\nassert sieve_of_eratosthenes(20) == ([2, 3, 5, 7, 11, 13, 17, 19], [(3, 5), (11, 13), (17, 19)], {2: 3, 3: 5, 5: 7, 7: 11, 11: 13, 13: 17, 17: 19, 19: None})\n", "\nassert sieve_of_eratosthenes(1) == ([], [])\n", "\nass... |
939e57460f13e4fa37716d721d56c6b9 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses e-mail selon des règles spécifiques. Une adresse e-mail est considérée comme valide si elle répond aux critères suivants :\n- Elle contient exactement un symbole \"@\".\n- La partie domaine (après le \"@\") contient au moins un poi... | ["\nassert validate_email(\"test.email@example.com\") == True\n", "\nassert validate_email(\".testemail@example.com\") == False\n", "\nassert validate_email(\"testemail.@example.com\") == False\n", "\nassert validate_email(\"test..email@example.com\") == False\n", "\nassert validate_email(\"test.email@.example.com\") =... |
1a8f8745eb0b227f25c69df80eda3e03 | [
{
"content": "On te donne trois tableaux : `source_indices`, `source_values` et `destination_values`. Le tableau `source_indices` contient des indices qui correspondent à un sous-ensemble du tableau `destination_values`. Ta tâche est de créer une fonction `map_values` qui mappe les `source_values` aux indices c... | ["\nassert map_values([0, 2, 4], [10, 20, 30], [0, 0, 0, 0, 0]) == [10, 0, 20, 0, 30]\n", "\nassert map_values([1, 3], [5, 15], [0, 0, 0, 0]) == [0, 5, 0, 15]\n", "\nassert map_values([0, 1, 2], [1, 2, 3], [0, 0, 0]) == [1, 2, 3]\n", "\nassert map_values([], [], [1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert map_val... |
a0029d3e3ea7c8fc70695fcf9e30a2ad | [
{
"content": "On te donne une fonction `func` et un entier `interval`. Implémente la fonction `scheduled_execution` qui renvoie une nouvelle fonction. Cette nouvelle fonction, lorsqu'elle est appelée, doit exécuter `func` de manière répétée à l'intervalle spécifié (en secondes). Assure-toi qu'aucune exécution c... | ["\nassert callable(scheduled_execution(lambda: None, 1))\n", "\nassert isinstance(scheduled_execution(lambda: None, 1), threading.Thread)\n", "\nassert scheduled_execution(lambda: None, 1).is_alive()\n", "\nassert scheduled_execution(lambda: None, 1).daemon\n", "\nassert scheduled_execution(lambda: None, 1).name.start... |
8f11e4469c5d66c4cbd476fc67f7d9cf | [
{
"content": "On te donne un entier `n`. Ta tâche est d'implémenter une fonction `funB(n)` qui renvoie une liste de cinq entiers. Chaque entier de la liste doit être le double du précédent, en commençant par `n`. La liste doit être renvoyée dans l'ordre inverse. Tu n'es pas autorisé à utiliser des fonctions de ... | ["\nassert funB(1) == [32, 16, 8, 4, 2]\n", "\nassert funB(2) == [64, 32, 16, 8, 4]\n", "\nassert funB(3) == [48, 24, 12, 6, 3]\n", "\nassert funB(5) == [80, 40, 20, 10, 5]\n", "\nassert funB(10) == [160, 80, 40, 20, 10]\n", "\nassert funB(0) == [0, 0, 0, 0, 0]\n", "\nassert funB(-1) == [-16, -8, -4, -2, -1]\n", "\nass... |
33daf776c29f66fda0c86f9208ebd108 | [
{
"content": "On te demande de concevoir un modèle Django pour un système d'articles de blog. Le modèle d'article de blog doit inclure les champs suivants :\n\n- `title` : un champ de caractères avec une longueur maximale de 200 caractères.\n- `author` : une clé étrangère faisant référence au modèle User intégr... | ["\nassert BlogPost._meta.get_field('title').max_length == 200\n", "\nassert BlogPost._meta.get_field('author').remote_field.model == User\n", "\nassert BlogPost._meta.get_field('author').remote_field.on_delete == models.CASCADE\n", "\nassert isinstance(BlogPost._meta.get_field('content'), models.TextField)\n", "\nasse... |
eb08bc189db90cfc04dcb4f02d980d23 | [
{
"content": "On te donne une liste multidimensionnelle en Python, qui peut contenir des entiers, des chaînes de caractères et d'autres listes. Ta tâche est d'écrire une fonction récursive qui compte le nombre d'éléments entiers dans chaque sous-liste et stocke ces décomptes dans une liste séparée. La fonction ... | ["\nassert count_integers_recursive([1, 2, 3], []) == [3]\n", "\nassert count_integers_recursive([[1, 2, 3], [4, 5], [6, 7, 8, 9]], []) == [3, 2, 4]\n", "\nassert count_integers_recursive([[1, 'a', 3], [4, [5, 'b'], 6], [7, 8, 9], [10, 'c']], []) == [3, 3, 2, 1, 1]\n", "\nassert count_integers_recursive([['a', 'b', 'c'... |
0acb2a91ae89632602a2164cd037106f | [
{
"content": "On te donne un graphe non orienté représenté sous forme de liste d'adjacence à l'aide d'un dictionnaire. Les clés du dictionnaire sont les nœuds, et les valeurs sont des listes de nœuds directement connectés au nœud clé respectif. Ta tâche est de renvoyer une liste de nœuds dans un ordre aléatoire... | ["\nassert max_color_change_order({'a': ['b'], 'b': ['a']}) in [['a', 'b'], ['b', 'a']]\n", "\nassert max_color_change_order({'a': ['b', 'c'], 'b': ['a'], 'c': ['a']}) in [['a', 'b', 'c'], ['a', 'c', 'b'], ['b', 'a', 'c'], ['c', 'a', 'b']]\n", "\nassert max_color_change_order({'a': ['b'], 'b': ['c'], 'c': ['a']}) in [[... |
40dd5536f2b4e4485d4a959e416cebad | [
{
"content": "On te donne un fichier texte nommé `animals.txt` contenant une liste de noms d'animaux, un par ligne. Ta tâche est de mettre en œuvre une fonction `count_animals` qui lit ce fichier et renvoie un dictionnaire. Les clés du dictionnaire doivent être les noms d'animaux en minuscules, et les valeurs d... | ["\nassert count_animals(\"animals.txt\") == {\"cat\": 2, \"dog\": 1, \"elephant\": 1} if open(\"animals.txt\", \"w\").write(\"Cat\\ndog\\nCAT\\nElephant\\n123\\n!@#\") is None else None\n", "\nassert count_animals(\"animals.txt\") == {\"lion\": 1, \"tiger\": 1, \"bear\": 1} if open(\"animals.txt\", \"w\").write(\"Lion... |
1151af8dbae722152058493f6ebe6dee | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer si `n` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Optimise ta solution pour gérer efficacement les grandes valeurs de `n`.\n\n**Entrée :**\n- ... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(9) == False\n", "\nassert is_prime(11) == True\n", "\nassert is_prime(15) == False\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(19) == True\n", "\nass... |
ab27dd7578eed69d1f9a8f1130b095d7 | [
{
"content": "On te demande de créer un script Python qui interagit avec une base de données SQLite. Ton script doit effectuer les opérations suivantes :\n\n1. Créer une base de données SQLite nommée `sample.db`.\n2. Créer une table nommée `people` avec les colonnes suivantes :\n - `id` : Un entier qui sert d... | ["\nassert create_database_and_table('test.db', 'test_table') is None\n", "\nassert query_database('test.db', 'test_table') is None\n", "\nassert create_database_and_table('another_test.db', 'another_test_table') is None\n", "\nassert query_database('another_test.db', 'another_test_table') is None\n", "\nassert create_... |
73c9d64a5d7e29e08c105c9460bb4314 | [
{
"content": "On te demande de traiter un fichier nommé \"university_data.txt\" qui contient des enregistrements de départements universitaires. Chaque ligne du fichier représente un département et est formatée comme suit :\n\n`<department_code> <department_name> <number_of_students> <number_of_faculty> <budget... | ["\nassert get_department_stats() == [('CS', 'Computer', 'Science', '550', '25', '1100000'), ('EE', 'Electrical', 'Engineering', '300', '15', '600000')]\n", "\nassert get_department_stats() == [('MATH', 'Mathematics', '400', '30', '800000')]\n", "\nassert get_department_stats() == [('PHYS', 'Physics', '250', '18', '450... |
21acb624dfeb207fd5596b0672d8607a | [
{
"content": "On te demande d'implémenter une fonction `validate_credit_card` pour vérifier la validité d'un numéro de carte de crédit en utilisant un algorithme de Luhn modifié. L'algorithme est défini comme suit :\n\n1. En commençant par l'avant-dernier chiffre et en allant vers la gauche, double la valeur de... | ["\nassert validate_credit_card(\"1234567890123456789\") == False\n", "\nassert validate_credit_card(\"9876543210987654321\") == True\n", "\nassert validate_credit_card(\"1111111111111111111\") == False\n", "\nassert validate_credit_card(\"2222222222222222222\") == True\n", "\nassert validate_credit_card(\"333333333333... |
e991e69256927484259a5689db353384 | [
{
"content": "On te demande d'implémenter une classe `CircularQueue` en Python qui supporte les opérations suivantes :\n- `enqueue(item)` : Ajoute un élément à la fin de la file d'attente. Lève une exception si la file d'attente est pleine.\n- `dequeue()` : Supprime et renvoie l'élément en tête de la file d'att... | ["\nassert CircularQueue(3).is_empty() == True\n", "\nassert CircularQueue(3).size() == 0\n", "\ncq = CircularQueue(3)\ncq.enqueue(1)\ncq.enqueue(2)\nassert cq.size() == 2\n", "\ncq = CircularQueue(3)\ncq.enqueue(1)\ncq.enqueue(2)\ncq.enqueue(3)\nassert cq.is_full() == True\n", "\ncq = CircularQueue(3)\ncq.enqueue(1)\n... |
c777a91f0a7a395f176f20750ef3e946 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discounted_price` qui calcule le prix final d'un produit après avoir appliqué un pourcentage de réduction donné. La fonction doit accepter deux paramètres : `price`, un nombre à virgule flottante représentant le prix initial du produit, et `disco... | ["\nassert calculate_discounted_price(100.0, 20.0) == 80.0\n", "\nassert calculate_discounted_price(200.0, 50.0) == 100.0\n", "\nassert calculate_discounted_price(50.0, 0.0) == 50.0\n", "\nassert calculate_discounted_price(150.0, 100.0) == 0.0\n", "\nassert calculate_discounted_price(0.0, 20.0) == 0.0\n", "\nassert cal... |
2ca25f8c2fcb4a38c4decd5a0b68172c | [
{
"content": "On te donne une structure de répertoires où chaque sous-répertoire représente une catégorie identifiée par un UUID. Dans chaque sous-répertoire, il y a plusieurs fichiers texte. Ta tâche est d'écrire une fonction qui prend le chemin du répertoire principal en entrée et renvoie une liste de tous le... | ["\nassert sorted_text_files(\"/path/to/valid/directory\") == [\"/path/to/valid/directory/123e4567-e89b-12d3-a456-426614174000/file3.txt\", \"/path/to/valid/directory/123e4567-e89b-12d3-a456-426614174000/file2.txt\", \"/path/to/valid/directory/123e4567-e89b-12d3-a456-426614174000/file1.txt\", \"/path/to/valid/directory... |
2dc3dcef4c313ac4f1aa9d96c17bf0b5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates` qui renvoie une nouvelle liste avec tous les éléments dupliqués supprimés tout en préservant l'ordre de la liste originale. La liste originale doit rester inchangée.\n\n**Entrée :**\n- Une liste d'entiers ... | ["\nassert remove_duplicates([1, 2, 3, 2, 1]) == [1, 2, 3]\n", "\nassert remove_duplicates(['a', 'b', 'c', 'a', 'b']) == ['a', 'b', 'c']\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert r... |
5f62e2248d2526c4f2ef54b0ca7a54eb | [
{
"content": "On te donne un fichier texte nommé `filename`. Ta tâche est d'écrire une fonction `count_unique_words(filename)` qui traite le fichier et renvoie un dictionnaire. Le dictionnaire doit contenir des mots uniques comme clés et leurs décomptes respectifs comme valeurs. La fonction doit respecter les r... | ["\nassert count_unique_words(\"test1.txt\") == {'hello': 3, 'world': 2, 'this': 1, 'is': 1, 'a': 1, 'test': 1}\n", "\nassert count_unique_words(\"test2.txt\") == {'another': 2, 'file': 2, 'with': 1, 'some': 1, 'words': 1}\n", "\nassert count_unique_words(\"test3.txt\") == {'punctuation': 1, 'should': 1, 'be': 1, 'igno... |
500412a3cb02d9dbe65f1c53b368b220 | [
{
"content": "On te demande d'implémenter une fonction `cheer_for_word(word, enthusiasm_level)` qui construit une chaîne de joie en fonction du `word` et du `enthusiasm_level` donnés. La chaîne de joie est formée en ajoutant un point d'exclamation après chaque caractère du `word`, puis en ajoutant le `word` lui... | ["\nassert cheer_for_word(\"hello\", 3) == \"h!e!l!l!o!hello!hello!hello!\"\n", "\nassert cheer_for_word(\"world\", 1) == \"w!o!r!l!d!world\"\n", "\nassert cheer_for_word(\"abc\", 2) == \"a!b!c!abc!abc\"\n", "\nassert cheer_for_word(\"python\", 0) == \"p!y!t!h!o!n!\"\n", "\nassert cheer_for_word(\"\", 5) == \"\"\n", "\... |
081e33d815d3923f4347078b1c824b31 | [
{
"content": "On te donne la date de naissance d'une personne sous forme d'objet `datetime` et un entier `years`. Ta tâche est d'implémenter une fonction `calculate_next_birthday(birthdate, years)` qui renvoie un objet `datetime` représentant le prochain anniversaire de la personne après avoir ajouté le nombre ... | ["\nassert calculate_next_birthday(datetime(2000, 2, 29), 4) == datetime(2004, 2, 29)\n", "\nassert calculate_next_birthday(datetime(2001, 2, 28), 1) == datetime(2002, 2, 28)\n", "\nassert calculate_next_birthday(datetime(2001, 2, 28), 4) == datetime(2005, 2, 28)\n", "\nassert calculate_next_birthday(datetime(2020, 2, ... |
ae33e0f8d41764bdd16efd746741c4ee | [
{
"content": "On te donne une chaîne de caractères `result` qui représente la sortie de l'inférence d'un modèle d'apprentissage automatique. La chaîne contient deux listes : `probs` et `labels`. Ta tâche est d'écrire une fonction `extract_top_two_labels` qui extrait les deux étiquettes avec les probabilités les... | ["\nassert extract_top_two_labels(\"probs: [0.1, 0.5, 0.2, 0.6, 0.3], labels: ['dog', 'cat!', 'fish&', 'bird%', 'human']\") == ['bird', 'human']\n", "\nassert extract_top_two_labels(\"probs: [0.9, 0.8, 0.7, 0.6, 0.5], labels: ['apple', 'banana', 'cherry', 'date', 'elderberry']\") == ['banana', 'cherry']\n", "\nassert e... |
8a4addd946792890c041b39b421b2bda | [
{
"content": "On te donne un espace 3D avec plusieurs objets et électrodes. Chaque objet et électrode a un identifiant unique et une position dans l'espace 3D représentée par un tuple (x, y, z). On te donne également une liste de dimensions à considérer pour les calculs de distance. Ta tâche est de calculer la ... | ["\nassert calculate_distances([(1, (0, 0, 0))], [(10, (1, 1, 1))], [0, 1, 2]) == {1: {10: np.sqrt(3)}}\n", "\nassert calculate_distances([(1, (1, 1, 1))], [(10, (1, 1, 1))], [0, 1, 2]) == {1: {10: 0.0}}\n", "\nassert calculate_distances([(1, (0, 0, 0))], [(10, (3, 4, 0))], [0, 1]) == {1: {10: 5.0}}\n", "\nassert calcu... |
443bd18b80ca26c2c3abdfeb2154fcfb | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de regrouper ces chaînes en anagrammes et de renvoyer une liste de ces groupes. Chaque groupe doit être une liste de mots qui sont des anagrammes les uns des autres. L'ordre des groupes et l'ordre des mots dans chaque groupe n'ont pas d'... | ["\nassert sort_by_anagram_groups([\"listen\", \"silent\", \"enlist\"]) == [[\"listen\", \"silent\", \"enlist\"]]\n", "\nassert sort_by_anagram_groups([\"google\", \"gooegl\"]) == [[\"google\", \"gooegl\"]]\n", "\nassert sort_by_anagram_groups([\"rat\", \"tar\", \"art\"]) == [[\"rat\", \"tar\", \"art\"]]\n", "\nassert ... |
bbff477af26c560191ca1834badcba7f | [
{
"content": "On te donne une liste de températures en Fahrenheit. Ta tâche est d'écrire une fonction Python qui convertit chaque température de la liste en Celsius et renvoie la nouvelle liste. La formule de conversion de Fahrenheit en Celsius est \\( C = \\frac{5}{9} \\times (F - 32) \\).\n\n**Entrée :**\n- U... | ["\nassert fahrenheit_to_celsius([32]) == [0.0]\n", "\nassert fahrenheit_to_celsius([212]) == [100.0]\n", "\nassert fahrenheit_to_celsius([68]) == [20.0]\n", "\nassert fahrenheit_to_celsius([0]) == [-17.77777777777778]\n", "\nassert fahrenheit_to_celsius([-40]) == [-40.0]\n", "\nassert fahrenheit_to_celsius([32, 68, 77... |
abc746470cf8de3ac1a2945d9f115cd6 | [
{
"content": "Tu es chargé de traiter un grand fichier CSV contenant des millions de lignes. Ton objectif est de lire et de traiter efficacement le fichier par blocs. Implémente une fonction `process_large_csv` qui lit un fichier CSV par blocs d'une taille spécifiée et traite chaque bloc. À des fins de démonstr... | ["\nassert process_large_csv('empty.csv') is None\n", "\nassert process_large_csv('single_row.csv') is None\n", "\nassert process_large_csv('multiple_rows.csv') is None\n", "\nassert process_large_csv('large_dataset.csv', chunk_size=50000) is None\n", "\nassert process_large_csv('large_dataset.csv', chunk_size=1) is No... |
6c98b410bf058ffddb07ff07fc491a2a | [
{
"content": "Tu développes une simulation pour un jeu de pêche qui se déroule sur une grille de 20x20. Deux joueurs s'affrontent en utilisant des cannes à pêche pour attraper et ramener des poissons. Chaque joueur a un hameçon à une coordonnée x spécifique sur la grille. Les poissons sont situés à différentes ... | ["\nassert simulate_fishing_game([(5, 18), (10, 19)], {1: 5, 2: 10})[2] in [['caught', 'pulled in'], ['pulled in', 'caught'], ['missed', 'pulled in'], ['pulled in', 'missed'], ['caught', 'missed'], ['missed', 'caught'], ['missed', 'missed']]\n", "\nassert simulate_fishing_game([(5, 18), (10, 19)], {1: 5, 2: 10})[0] in ... |
84cecc2f3f0a6258dd385153e3f7cfdf | [
{
"content": "On te donne une liste triée d'entiers `arr` et un entier `target`. Ta tâche est de mettre en œuvre un algorithme de recherche binaire itératif pour trouver l'index de `target` dans la liste. Si `target` n'est pas trouvé, retourne `-1`. Ta solution ne doit pas utiliser de fonctions de recherche int... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
98003dc64e7a0e21ff3812c1f8b77680 | [
{
"content": "On te demande d'implémenter une fonction `get_uid_gid` qui récupère l'identifiant utilisateur (UID) et l'identifiant de groupe (GID) pour un nom d'utilisateur donné à partir d'une base de données d'utilisateurs simulée. La fonction doit renvoyer un tuple contenant l'UID et le GID si le nom d'utili... | ["\nassert get_uid_gid(\"alice\") == (1001, 1001)\n", "\nassert get_uid_gid(\"bob\") == (1002, 1002)\n", "\nassert get_uid_gid(\"carol\") == (1003, 1003)\n", "\nassert get_uid_gid(\"dave\") == (1004, 1004)\n", "\nassert get_uid_gid(\"zorro\") == (1050, 1050)\n", "\nassert get_uid_gid(\"unknown\") == (None, None)\n", "\... |
941080160a987c62455e56a630da25a3 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `count_words` qui traite cette chaîne et renvoie un dictionnaire avec la fréquence de chaque mot, en ignorant la casse, la ponctuation et les mots vides anglais courants. Utilise la bibliothèque `nltk` pour ob... | ["\nassert count_words(\"Hello, world! Hello, Python programming.\") == {'hello': 2, 'world': 1, 'python': 1, 'programming': 1}\n", "\nassert count_words(\"This is a test. This test is only a test.\") == {'test': 3, 'this': 2, 'is': 2, 'a': 2, 'only': 1}\n", "\nassert count_words(\"An apple a day keeps the doctor away.... |
40adbec5fe21185266e31cf34ea6f278 | [
{
"content": "On te demande d'implémenter une calculatrice simple en ligne de commande qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. La calculatrice doit inviter de manière répétée l'utilisateur à sélectionner une opération et à entrer deux nombre... | ["\nassert add(2, 3) == 5\n", "\nassert subtract(5, 3) == 2\n", "\nassert multiply(4, 3) == 12\n", "\nassert divide(10, 2) == 5.0\n", "\nassert add(-1, 1) == 0\n", "\nassert subtract(0, 0) == 0\n", "\nassert multiply(-2, -2) == 4\n", "\nassert divide(10, 0) == \"Error! Division by zero.\"\n", "\nassert add(0, 0) == 0\n... |
952e2510a508d0a954051bd6faf86420 | [
{
"content": "On te donne un graphe non orienté représenté sous forme de liste d'adjacence. Chaque sommet est représenté comme une liste de ses sommets voisins. Ta tâche est de déterminer si le graphe est semi-Eulerien. Un graphe est considéré comme semi-Eulerien s'il possède exactement deux sommets de degré im... | ["\nassert is_semi_eulerian([[1], [0]]) == False\n", "\nassert is_semi_eulerian([[1, 2], [0, 2], [0, 1]]) == False\n", "\nassert is_semi_eulerian([[1], [0, 2], [1]]) == True\n", "\nassert is_semi_eulerian([[1, 2], [0], [0]]) == True\n", "\nassert is_semi_eulerian([[1, 2, 3], [0, 3], [0, 3], [0, 1, 2]]) == False\n", "\n... |
973925b9eade7f04c988331c2a7c93c5 | [
{
"content": "On te donne un grand fichier texte où chaque ligne contient un seul mot. Ta tâche est de mettre en œuvre une fonction `get_word_info` qui lit ce fichier efficacement sans charger l'intégralité du fichier en mémoire. La fonction doit accepter le chemin du fichier, un entier `start` et un autre enti... | ["\nassert get_word_info('words.txt', 1, 0) == ('word1', len('word1'))\n", "\nassert get_word_info('words.txt', 2, 1) == ('word2', len('word3'))\n", "\nassert get_word_info('words.txt', 5, 5) == ('word5', len('word10'))\n", "\nassert get_word_info('words.txt', 10, 0) == ('word10', len('word10'))\n", "\nassert get_word_... |
c26ca3c53a9302668ae0739b06cf58fa | [
{
"content": "On te donne une chaîne de caractères `s` composée uniquement des caractères `(` et `)`. Ta tâche est de déterminer si la chaîne est équilibrée. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante a une parenthèse fermante correspondante et qu'elles sont correctement imbriquées... | ["\nassert is_balanced(\"()\") == True\n", "\nassert is_balanced(\"(())\") == True\n", "\nassert is_balanced(\"(()())\") == True\n", "\nassert is_balanced(\")(\") == False\n", "\nassert is_balanced(\"(((((\") == False\n", "\nassert is_balanced(\")))))\") == False\n", "\nassert is_balanced(\"(()\") == False\n", "\nasser... |
91792809d850c63f194a6b6adb11aa61 | [
{
"content": "On te donne un graphe orienté avec `N` nœuds et `M` arêtes. Chaque arête est représentée par un tuple contenant le nœud de destination et la distance parcourue à l'extérieur. Ta tâche est de calculer la distance totale parcourue à l'extérieur par un chemin donné dans le graphe. Le chemin ne doit p... | ["\nassert total_outside_distance({'A': [('B', 10)], 'B': []}, ['A', 'B']) == 10\n", "\nassert total_outside_distance({'A': [('B', 10), ('C', 15)], 'B': [('C', 10)], 'C': []}, ['A', 'B', 'C']) == 20\n", "\nassert total_outside_distance({'A': [('B', 10), ('C', 15)], 'B': [('C', 10), ('D', 5)], 'C': [('D', 20)], 'D': []}... |
e1a0f4eb86563f2b1e144609c9bcbfad | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci efficacement. Utilise la programmation dynamique pour optimiser le calcul, en t'assurant que ta solution peut gérer de grandes valeurs de `n` jusqu'à 10^6. Ta fonction doit renvoyer 0 pour `n = 0` et 1 pour `n = 1`... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
e86b3c91fd42d88368eeb67af3be4292 | [
{
"content": "Tu participes à un concours de traitement de données où l'on te fournit un fichier nommé \"word_bags.pkl\". Ce fichier est un objet pickle contenant un dictionnaire où chaque clé représente un nom de groupe et chaque valeur est une liste de mots associés à ce groupe. Ta tâche est d'implémenter une... | ["\nassert extract_unique_words(\"word_bags.pkl\") == {'group1': frozenset({'apple', 'banana', 'cherry'}), 'group2': frozenset({'dog', 'elephant', 'frog'})}\n", "\nassert extract_unique_words(\"word_bags.pkl\") == {'group1': frozenset({'cat', 'dog'}), 'group2': frozenset({'elephant', 'frog', 'giraffe'})}\n", "\nassert ... |
a64b392e5a54e61fd33748d483c89a2e | [
{
"content": "On te donne deux matrices, `A` et `B`, représentées comme des listes de listes. Ta tâche est d'écrire une fonction qui multiplie ces deux matrices et renvoie la matrice résultante. Suppose que le nombre de colonnes de la matrice `A` est égal au nombre de lignes de la matrice `B`. Si les matrices n... | ["\nassert matrix_multiply([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == [[19, 22], [43, 50]]\n", "\nassert matrix_multiply([[1, 0], [0, 1]], [[1, 2], [3, 4]]) == [[1, 2], [3, 4]]\n", "\nassert matrix_multiply([[2, 0], [1, 2]], [[3, 4], [1, 0]]) == [[6, 8], [5, 4]]\n", "\nassert matrix_multiply([[1, 2, 3]], [[4], [5], [6]]) =... |
6d870aa457d86436d91bb166d31d48a6 | [
{
"content": "On te donne un graphe non orienté connexe représenté sous forme de liste d'adjacence. Ta tâche est de déterminer le nombre de composantes connexes dans le graphe. Le graphe est fourni sous forme de dictionnaire où chaque clé est un identifiant de nœud et la valeur correspondante est une liste des ... | ["\nassert connected_components({0: [1, 2], 1: [0, 2], 2: [0, 1], 3: [4], 4: [3], 5: []}) == 3\n", "\nassert connected_components({0: [1], 1: [0], 2: [3], 3: [2], 4: [5], 5: [4]}) == 3\n", "\nassert connected_components({0: [], 1: [], 2: [], 3: [], 4: [], 5: []}) == 6\n", "\nassert connected_components({0: [1, 2, 3], 1... |
a76acf50048746331e5721dba8a8b14f | [
{
"content": "On te demande d'implémenter une fonction `generate_html_table(data, headers)` qui construit un tableau HTML à partir d'une liste 2D `data` fournie et d'une liste d'en-têtes de colonnes `headers`. La fonction doit renvoyer une chaîne de caractères contenant le code HTML du tableau. Le tableau doit ... | ["\nassert generate_html_table([['John', 28, 'Engineer']], ['Name', 'Age', 'Occupation']) == '<table border=\"1\">\\n <tr>\\n\t<th>Name</th>\\n\t<th>Age</th>\\n\t<th>Occupation</th>\\n </tr>\\n <tr>\\n\t<td>John</td>\\n\t<td>28</td>\\n\t<td>Engineer</td>\\n </tr>\\n</table>'\n", "\nassert generate_html_table([], ['... |
f17ca7750cc2514483f74c4986c9ab58 | [
{
"content": "On te donne un dictionnaire `original_dict` où chaque clé est associée à une valeur unique. Ta tâche est de créer une fonction `swap_keys_values` qui renvoie un nouveau dictionnaire avec les clés et les valeurs échangées. Suppose que toutes les valeurs dans le dictionnaire d'entrée sont uniques et... | ["\nassert swap_keys_values({\"a\": 1, \"b\": 2, \"c\": 3}) == {1: \"a\", 2: \"b\", 3: \"c\"}\n", "\nassert swap_keys_values({}) == {}\n", "\nassert swap_keys_values({\"x\": \"y\"}) == {\"y\": \"x\"}\n", "\nassert swap_keys_values({\"key1\": \"value1\", \"key2\": \"value2\"}) == {\"value1\": \"key1\", \"value2\": \"key... |
ec0e25eb8b3879ee4ff012e164fa78dc | [
{
"content": "On te demande d'implémenter un système de compte bancaire simple en utilisant des classes en Python. Ton programme doit prendre en charge les opérations suivantes :\n\n1. **Créer un compte** : Initialiser un nouveau compte bancaire avec le nom du titulaire du compte et un solde initial facultatif ... | ["\nassert BankAccount(\"Alice\").check_balance() == \"Current balance is 0.0.\"\n", "\nassert BankAccount(\"Bob\", 100).check_balance() == \"Current balance is 100.0.\"\n", "\nassert BankAccount(\"Charlie\").deposit(50) == \"Deposited 50. New balance is 50.0.\"\n", "\nassert BankAccount(\"David\", 100).deposit(-50) ==... |
fa4d6cabd5c45efb815aef5e4c2012b4 | [
{
"content": "Conçois et implémente une application web utilisant le framework Flask qui sert une liste de livres. L'application doit avoir une route `/books` qui, lorsqu'elle est accessible, renvoie une page HTML affichant un tableau de livres. Chaque ligne du tableau doit contenir le titre, l'auteur et l'ISBN... | ["\nassert book_list().startswith('<html>')\n", "\nassert \"The Great Gatsby\" in book_list()\n", "\nassert \"F. Scott Fitzgerald\" in book_list()\n", "\nassert \"9780743273565\" in book_list()\n", "\nassert \"1984\" in book_list()\n", "\nassert \"George Orwell\" in book_list()\n", "\nassert \"9780451524935\" in book_l... |
bcbf58138f5a9929ee3ab87c25ad5249 | [
{
"content": "On te donne une liste d'entiers représentant le nombre de pas effectués par une personne chaque jour. Chaque entrée de la liste est une paire `[\"AAAA-MM-JJ\", nombre_de_pas]`, où `AAAA-MM-JJ` est la date au format chaîne de caractères et `nombre_de_pas` est le nombre de pas effectués à cette date... | ["\nassert weekly_steps([[\"2023-01-01\", 10000], [\"2023-01-02\", 11000]]) == {1: 21000}\n", "\nassert weekly_steps([[\"2023-01-08\", 12000], [\"2023-01-15\", 13000]]) == {2: 25000}\n", "\nassert weekly_steps([[\"2023-01-22\", 14000], [\"2023-01-29\", 15000]]) == {3: 29000}\n", "\nassert weekly_steps([[\"2023-02-05\",... |
eb0fcd4d836caba8472ca5a92a584838 | [
{
"content": "On te donne une série de dictionnaires. Ta tâche est de fusionner ces dictionnaires en un seul dictionnaire en suivant ces règles :\n- Toutes les valeurs du premier dictionnaire sont incluses dans le dictionnaire final.\n- Pour les dictionnaires suivants, n'inclus que les valeurs qui n'ont pas déj... | ["\nassert merge_dictionaries({'a': 1, 'b': 2}, {'b': 2, 'c': 3}) == {'a': 1, 'c': 3}\n", "\nassert merge_dictionaries({'x': 10, 'y': 20}, {'y': 20, 'z': 30}, {'z': 30, 'w': 40}) == {'x': 10, 'w': 40}\n", "\nassert merge_dictionaries({'one': 1, 'two': 2}, {'three': 3, 'four': 4}, {'five': 5, 'six': 6}) == {'one': 1, 't... |
3362c23488049e51a929df83f15caa73 | [
{
"content": "On te demande d'implémenter une classe `Calculator` en Python qui prenne en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit permettre l'enchaînement de méthodes pour effectuer plusieurs opérations dans une seule expression. Elle doit... | ["\nassert Calculator().add(5).result == 5.0\n", "\nassert Calculator().add(5).subtract(3).result == 2.0\n", "\nassert Calculator().multiply(4).add(2).result == 6.0\n", "\nassert Calculator().divide(2).multiply(4).result == 2.0\n", "\nassert Calculator().add(5).multiply(2).subtract(10).divide(2).result == 0.0\n", "\nas... |
9124fa46860d09b973ab0853baa39a3f | [
{
"content": "Conçois une API RESTful pour un système de gestion de bibliothèque. Le système doit prendre en charge les opérations suivantes :\n- **Ajouter un livre** : Accepte une charge utile JSON avec les champs `title` et `author`. Renvoie un message de succès si le livre est ajouté avec succès, ou un messa... | ["\nassert add_book() == jsonify({\"error\": \"Invalid request. Please provide 'title' and 'author'.\"}), 400\n", "\nassert add_book({\"title\": \"1984\", \"author\": \"George Orwell\"}) == jsonify({\"message\": \"Book '1984' by George Orwell added successfully.\"}), 201\n", "\nassert add_book({\"title\": \"To Kill a M... |
45faec8c17dcf35e477829ed013a4152 | [
{
"content": "Dans le pays mystique de Codegard, les guerriers sont classés en fonction de leur prouesse au combat, qui est déterminée par leur niveau de compétence effectif et leur bonus d'équipement. L'efficacité de l'équipement d'un guerrier diminue avec son niveau d'expérience au combat, calculée comme `1 -... | ["\nassert calculate_max_damage(150, 50, 100) == 75\n", "\nassert calculate_max_damage(100, 0, 0) == 1\n", "\nassert calculate_max_damage(200, 100, 200) == 100\n", "\nassert calculate_max_damage(0, 0, 0) == 0\n", "\nassert calculate_max_damage(1280, 128, 0) == 256\n", "\nassert calculate_max_damage(1280, 128, 200) == 1... |
659641caeccad1bb4b6ed9a7fd4f263c | [
{
"content": "On te demande d'implémenter une fonction `validate_input(is_float=True, is_positive=True)` qui interagit avec l'utilisateur pour obtenir un nombre valide en fonction de critères spécifiés. La fonction doit inviter l'utilisateur à entrer une valeur de manière répétée jusqu'à ce qu'un nombre valide ... | ["\nassert validate_input(is_float=True, is_positive=True) == 123.45\n", "\nassert validate_input(is_float=False, is_positive=True) == 123\n", "\nassert validate_input(is_float=True, is_positive=False) == -123.45\n", "\nassert validate_input(is_float=False, is_positive=False) == -123\n", "\nassert validate_input(is_flo... |
d6094098b9af05cdc4aea2c0eefb84d6 | [
{
"content": "On te donne une liste de chaînes de caractères, chacune représentant une valeur numérique potentielle. Ta tâche est de convertir ces chaînes en leurs nombres à virgule flottante correspondants. Certaines chaînes peuvent ne pas être convertibles en nombres à virgule flottante valides. Dans de tels ... | ["\nassert convert_strings_to_floats([\"3.14\", \"2e10\", \"not_a_number\", \"0.001\", \"-5.5\", \"+1.23e-4\"]) == ([3.14, 20000000000.0, 0, 0.001, -5.5, 0.000123], [\"could not convert string to float: 'not_a_number'\"])\n", "\nassert convert_strings_to_floats([\"1.0\", \"2.0\", \"3.0\"]) == ([1.0, 2.0, 3.0], [])\n", ... |
035b586ce39ed7ba7ee55bcb50affc66 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_duplicates` qui identifie et renvoie une liste de nombres premiers qui apparaissent plus d'une fois dans la liste d'entrée. La liste renvoyée doit contenir chaque nombre premier en double une seule fois et doit préserve... | ["\nassert find_duplicates([2, 3, 5, 7, 11, 2, 3, 5]) == [2, 3, 5]\n", "\nassert find_duplicates([4, 6, 8, 9, 10, 12]) == []\n", "\nassert find_duplicates([13, 17, 19, 13, 17, 23, 19]) == [13, 17, 19]\n", "\nassert find_duplicates([29, 29, 29, 29]) == [29]\n", "\nassert find_duplicates([31, 37, 41, 43, 47, 53, 59]) == ... |
b920071073c1388c70463f599d31501f | [
{
"content": "Tu es chargé d'implémenter une classe Python nommée `Employee` qui encapsule les détails d'un employé. La classe doit avoir les attributs et méthodes suivants :\n\n- `name` : une chaîne de caractères représentant le nom de l'employé.\n- `position` : une chaîne de caractères représentant le poste d... | ["\nassert Employee(\"Alice\", \"Developer\", 50000).get_name() == \"Alice\"\n", "\nassert Employee(\"Bob\", \"Manager\", 60000).get_position() == \"Manager\"\n", "\nassert Employee(\"Charlie\", \"Analyst\", 55000).get_salary() == 55000\n", "\nemp = Employee(\"David\", \"Designer\", 45000)\nemp.give_raise(10)\nassert e... |
a66062d944b778a95ea8c3c591ca4247 | [
{
"content": "On te demande d'implémenter une fonction `palindrome_sentence` qui détermine si une phrase donnée est un palindrome. Une phrase est considérée comme un palindrome si, en ignorant les espaces, la ponctuation et la casse, elle se lit de la même manière de gauche à droite et de droite à gauche. Tu do... | ["\nassert palindrome_sentence(\"A man, a plan, a canal: Panama\") == True\n", "\nassert palindrome_sentence(\"race a car\") == False\n", "\nassert palindrome_sentence(\"No lemon, no melon\") == True\n", "\nassert palindrome_sentence(\"Was it a car or a cat I saw?\") == True\n", "\nassert palindrome_sentence(\"Not a pa... |
bcb8119c58d84cbabc951438103da381 | [
{
"content": "On te donne une liste d'entiers et une somme cible. Ta tâche est d'écrire une fonction `find_unique_pairs` qui identifie toutes les paires uniques de nombres dans la liste qui s'additionnent à la somme cible. Chaque paire doit être représentée sous forme de tuple et renvoyée dans une liste triée p... | ["\nassert find_unique_pairs([1, 2, 3, 7, 8, 9], 10) == [(1, 9), (2, 8), (3, 7)]\n", "\nassert find_unique_pairs([5, 5, 5, 5], 10) == [(5, 5)]\n", "\nassert find_unique_pairs([1, 2, 3, 4, 5], 9) == [(4, 5)]\n", "\nassert find_unique_pairs([10, 15, 3, 7], 17) == [(10, 7)]\n", "\nassert find_unique_pairs([], 5) == []\n",... |
0438c759d34033644b1ca31776c6ad8e | [
{
"content": "On te donne une chaîne de caractères `s` composée des caractères '(' et ')'. Ta tâche est de déterminer si les parenthèses dans la chaîne sont équilibrées. Une chaîne est considérée comme équilibrée si chaque parenthèse ouvrante '(' a une parenthèse fermante correspondante ')' et qu'elles sont cor... | ["\nassert is_balanced_parentheses(\"()\") == True\n", "\nassert is_balanced_parentheses(\"(())\") == True\n", "\nassert is_balanced_parentheses(\"(()\") == False\n", "\nassert is_balanced_parentheses(\")(\") == False\n", "\nassert is_balanced_parentheses(\"()()\") == True\n", "\nassert is_balanced_parentheses(\"((()))... |
2e5613d236b4bb39ed3c0e26c13c223f | [
{
"content": "Dans le domaine des cryptomonnaies, le processus de minage consiste à ajouter de nouveaux blocs à la blockchain. Pour ce problème, nous allons simuler une version simplifiée du processus de minage.\n\nOn te fournit une fonction `valid_proof(last_proof, proof, last_hash)` qui vérifie si une preuve ... | ["\nassert find_proof(100, 'abc') == 100\n", "\nassert find_proof(0, '0000') == 256\n", "\nassert find_proof(1, '123') == 1\n", "\nassert find_proof(5, '5678') == 10\n", "\nassert find_proof(123456, 'abcdef') == 1024\n", "\nassert find_proof(999999, 'ghijkl') == 1000000\n", "\nassert find_proof(10, 'mnopqr') == 10\n", ... |
452cb8e88109bff75080370a511f7307 | [
{
"content": "On te demande d'implémenter une fonction `json_to_lowercase_dict_list` qui lit un fichier de configuration JSON et renvoie une liste contenant un seul dictionnaire. Le dictionnaire doit avoir toutes les clés converties en minuscules, et il doit gérer les objets JSON imbriqués. Utilise le module `j... | ["\nassert json_to_lowercase_dict_list('test1.json') == [{'name': 'john', 'age': 30, 'city': 'new york'}]\n", "\nassert json_to_lowercase_dict_list('test2.json') == [{'user': {'username': 'jane_doe', 'email': 'jane@example.com'}}]\n", "\nassert json_to_lowercase_dict_list('test3.json') == [{'settings': {'theme': 'dark'... |
256bdd6bef286c2f897b34823074e32c | [
{
"content": "On te donne une chaîne binaire `s` de longueur `n` au format Little Endian, où le bit le moins significatif est au début de la chaîne. Ta tâche est d'écrire une fonction `binary_string_to_decimal(s)` qui convertit cette chaîne binaire en son équivalent décimal sans utiliser de fonctions intégrées ... | ["\nassert binary_string_to_decimal(\"0\") == 0\n", "\nassert binary_string_to_decimal(\"1\") == 1\n", "\nassert binary_string_to_decimal(\"10\") == 2\n", "\nassert binary_string_to_decimal(\"11\") == 3\n", "\nassert binary_string_to_decimal(\"101\") == 5\n", "\nassert binary_string_to_decimal(\"1101\") == 13\n", "\nas... |
d04209e0e80605dcca1e188c4a8f4994 | [
{
"content": "Étant donné un tableau d'entiers `numbers` et un entier `target`, ta tâche est de trouver deux indices distincts `i` et `j` tels que `numbers[i] + numbers[j] = target`. Retourne les indices sous forme de liste `[i, j]`. Si aucune paire de ce type n'existe, retourne une liste vide. Les indices doiv... | ["\nassert find_two_sum([2, 7, 11, 15], 9) == [0, 1]\n", "\nassert find_two_sum([3, 2, 4], 6) == [1, 2]\n", "\nassert find_two_sum([3, 3], 6) == [0, 1]\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 10) == [3, 4]\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 8) == [2, 4]\n", "\nassert find_two_sum([1, 2, 3, 4, 5], 11) == []... |
08c270a21eb1ae5ba1f9c631de8ced5d | [
{
"content": "On te donne un dictionnaire Python représentant une structure de données hiérarchique. Ta tâche est d'écrire une fonction `to_xml` qui convertit ce dictionnaire en une chaîne XML sérialisée. Le XML doit avoir les propriétés suivantes :\n- Tous les tags doivent être triés lexicographiquement.\n- Le... | ["\nassert to_xml({'a': 1}) == '<root><a value=\"1\"/></root>'\n", "\nassert to_xml({'b': 'text'}) == '<root><b>text</b></root>'\n", "\nassert to_xml({'a': {'b': 2, 'c': 1}}) == '<root><a><b value=\"2\"/><c value=\"1\"/></a></root>'\n", "\nassert to_xml({'c': {'d': {'e': 3, 'f': 2}}, 'g': 1}) == '<root><c><d><e value=\... |
89c00b92b0c64acc7839ba9d0c4cbe3b | [
{
"content": "On te donne une liste de chemins de fichiers, où chaque chemin de fichier est une chaîne de caractères représentant l'emplacement d'un fichier dans un système de fichiers. Ta tâche est de mettre en œuvre une fonction qui identifie tous les répertoires parents contenant au moins deux noms de fichie... | ["\nassert get_parent_directories_with_at_least_two_files([\"/a/b/c.txt\", \"/a/b/d.txt\"]) == {\"/a/b\"}\n", "\nassert get_parent_directories_with_at_least_two_files([\"/x/y/z.txt\"]) == set()\n", "\nassert get_parent_directories_with_at_least_two_files([\"/p/q/r.txt\", \"/p/q/s.txt\", \"/p/q/t.txt\"]) == {\"/p/q\"}\n... |
fbe8e87146ae14a15c3701b83f89794f | [
{
"content": "On te donne une liste d'entiers `items`. Ta tâche est de déterminer si la liste est triée de manière alternée. Une liste est considérée comme triée de manière alternée si les éléments aux indices pairs sont triés par ordre non décroissant, et les éléments aux indices impairs sont triés par ordre n... | ["\nassert is_alternating_sorted([1, 5, 2, 4, 3]) == True\n", "\nassert is_alternating_sorted([1, 5, 2, 6, 3]) == False\n", "\nassert is_alternating_sorted([1, 4, 2, 5, 3, 4]) == False\n", "\nassert is_alternating_sorted([1, 3, 2, 5, 4, 7]) == True\n", "\nassert is_alternating_sorted([1, 2, 3, 4, 5]) == False\n", "\nas... |
341c6289c570a1f9fbe99b517362d3d5 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais et de chiffres. Ta tâche est de réorganiser la chaîne de manière à ce que tous les chiffres soient déplacés à la fin de la chaîne tout en conservant l'ordre relatif des lettres et des chiffres. Implémente... | ["\nassert rearrangeString(\"a1b2c3\") == \"abc123\"\n", "\nassert rearrangeString(\"123abc\") == \"abc123\"\n", "\nassert rearrangeString(\"abc\") == \"abc\"\n", "\nassert rearrangeString(\"123\") == \"123\"\n", "\nassert rearrangeString(\"\") == \"\"\n", "\nassert rearrangeString(\"a\") == \"a\"\n", "\nassert rearran... |
029b27b0249cf2b6303526c7a47bb0b9 | [
{
"content": "Tu participes à un concours de programmation et on te donne une liste d'entiers positifs `numbers`. Ton objectif est de déterminer le plus grand commun diviseur (PGCD) de tous les nombres de la liste. Cependant, tu as la possibilité de supprimer au plus un nombre de la liste pour potentiellement a... | ["\nassert max_gcd([48, 64, 80]) == 16\n", "\nassert max_gcd([10, 20, 30, 40]) == 10\n", "\nassert max_gcd([7, 14, 28, 35]) == 7\n", "\nassert max_gcd([3, 5, 7, 11]) == 1\n", "\nassert max_gcd([100, 200, 300, 400]) == 100\n", "\nassert max_gcd([1, 2, 3, 4, 5]) == 1\n", "\nassert max_gcd([12, 15, 21]) == 3\n", "\nassert... |
bccb31f2cf80d037525921b50eed2885 | [
{
"content": "On te donne une liste d'épisodes, où chaque épisode est représenté comme un dictionnaire avec les clés 'start', 'end' et 'interval'. Ta tâche est de déterminer le nombre total de trames uniques dans tous les épisodes, en tenant compte des chevauchements de temps et des intervalles variables. Chaqu... | ["\nassert unique_frames([{'start': 0, 'end': 10, 'interval': 1}]) == 11\n", "\nassert unique_frames([{'start': 0, 'end': 10, 'interval': 2}, {'start': 5, 'end': 15, 'interval': 3}]) == 13\n", "\nassert unique_frames([{'start': 0, 'end': 0, 'interval': 1}]) == 1\n", "\nassert unique_frames([{'start': 1, 'end': 1, 'inte... |
2ec78b91623a43ad035b396ada04b925 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python qui identifie le plus petit nombre dans la liste et renvoie à la fois l'index de ce nombre et le nombre lui-même. Si la liste est vide, la fonction doit renvoyer `None` pour l'index et le nombre.\n\n**Exemple d'entrée :**\n... | ["\nassert find_smallest_number([3, 1, 4, 1, 5, 9]) == (1, 1)\n", "\nassert find_smallest_number([10, 20, 30, 5, 15]) == (3, 5)\n", "\nassert find_smallest_number([-1, -2, -3, -4]) == (3, -4)\n", "\nassert find_smallest_number([100]) == (0, 100)\n", "\nassert find_smallest_number([]) == (None, None)\n", "\nassert find_... |
39973f1e69387ecfd1d46690f2eb44bd | [
{
"content": "On te demande d'implémenter une classe `MaxHeap` en Python qui prend en charge les opérations suivantes :\n\n- `insert(val)` : Insère un nouvel élément `val` dans le tas.\n- `extract_max()` : Supprime et renvoie l'élément maximal du tas. Si le tas est vide, renvoie `None`.\n- `peek_max()` : Renvoi... | ["\nassert MaxHeap().size() == 0\n", "\nassert MaxHeap().peek_max() == None\n", "\nassert MaxHeap().extract_max() == None\n", "\nheap = MaxHeap(); heap.insert(10); assert heap.size() == 1\n", "\nheap = MaxHeap(); heap.insert(10); assert heap.peek_max() == 10\n", "\nheap = MaxHeap(); heap.insert(10); assert heap.extract... |
da6c8b9a880320de264e9c0f08f2f852 | [
{
"content": "On te donne une fonction `func` et une liste d'entiers `lst`. La fonction `func` prend un entier en entrée et renvoie un entier. Ta tâche est de créer une fonction `apply_to_elements` qui applique `func` à chaque élément de `lst` et renvoie une nouvelle liste contenant uniquement les éléments tran... | ["\nassert apply_to_elements(lambda x: x + 1, [1, 2, 3, 4]) == [2, 3, 4]\n", "\nassert apply_to_elements(lambda x: x * x, [1, 2, 3, 4]) == []\n", "\nassert apply_to_elements(lambda x: x - 5, [1, 6, 11, 16]) == [1, 6, 11]\n", "\nassert apply_to_elements(lambda x: -x, [1, 2, 3, 4]) == []\n", "\nassert apply_to_elements(l... |
2f8d7612bc0bb50206b9a1e1e4da7fc6 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui identifie et renvoie le plus grand nombre premier de la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer -1.\n\n**Entrée :**\n- Une liste d'entiers, `lst`, où `1 <= len(lst) <= 10^3` et... | ["\nassert largest_prime([10, 15, 3, 7, 11]) == 11\n", "\nassert largest_prime([4, 6, 8, 10]) == -1\n", "\nassert largest_prime([2, 3, 5, 7, 11, 13]) == 13\n", "\nassert largest_prime([17, 19, 23, 29, 31]) == 31\n", "\nassert largest_prime([1, 0, -1, -3]) == -1\n", "\nassert largest_prime([29, 15, 29, 10]) == 29\n", "\... |
a5ec939c472110a815aa472685e10ee8 | [
{
"content": "Tu développes une application en ligne de commande conçue pour traiter et analyser de gros fichiers journaux, potentiellement de plus de 1 Go. L'application doit gérer efficacement plusieurs fichiers journaux dans un répertoire spécifié en utilisant le traitement parallèle pour accélérer l'analyse... | ["\nassert process_log_file(\"test_logs/valid_log_1.log\") == Counter({'INFO': 3, 'ERROR': 1})\n", "\nassert process_log_file(\"test_logs/valid_log_2.log\") == Counter({'DEBUG': 2, 'WARNING': 1})\n", "\nassert process_log_file(\"test_logs/empty_log.log\") == Counter()\n", "\nassert process_log_file(\"test_logs/corrupte... |
6f6533ea5061a139d5ca78ac1a75fc5f | [
{
"content": "On te charge de déterminer le nombre maximal de familles qui peuvent être assises ensemble dans un avion avec `N` rangées et 10 sièges par rangée. Chaque siège est identifié de manière unique par un numéro de rangée (de 1 à `N`) et une lettre de colonne (de A à J). Une famille est composée de 4 me... | ["\nassert max_families(3, \"1A 2B 3C 2E 3F\") == 1\n", "\nassert max_families(5, \"1A 1B 1C 1D 1E 1F 1G 1H 1I 1J\") == 0\n", "\nassert max_families(5, \"2A 2B 2C 2D 2E 2F 2G 2H 2I 2J\") == 0\n", "\nassert max_families(5, \"3A 3B 3C 3D 3E 3F 3G 3H 3I 3J\") == 0\n", "\nassert max_families(5, \"4A 4B 4C 4D 4E 4F 4G 4H 4I... |
4abf5fc9ff98ee8f275f183ed00270f9 | [
{
"content": "On te donne une chaîne de caractères multiligne `s`. Ta tâche est de traiter cette chaîne selon les règles suivantes :\n1. Divise la chaîne en lignes individuelles.\n2. Supprime les espaces blancs en début et en fin de chaque ligne.\n3. Conserve uniquement les lignes qui contiennent au moins un ca... | ["\nassert process_text(\" abc \\n defg\\nhijkl\\nmnopqr\\n stuv\\n wxyz \") == \"hijkl\"\n", "\nassert process_text(\"a\\nbb\\nccc\\ndddd\\neeeee\") == \"ccc\"\n", "\nassert process_text(\" hello \\nworld\\n python\\nis\\nawesome \") == \"worldpython\"\n", "\nassert process_text(\" \\n \\n \\n \") == \"\"\n... |
4106bf077394097403168f3c85d5ee0b | [
{
"content": "On te donne une liste de lignes représentées sous forme de tuples `(m, b)`, où `m` est la pente et `b` est l'ordonnée à l'origine de la ligne. Ta tâche est de déterminer les abscisses à l'origine de ces lignes. Si une abscisse à l'origine est une décimale périodique avec une période de 1 ou plus, ... | ["\nassert find_x_intercepts([(1, 1)]) == {\"-1.0\"}\n", "\nassert find_x_intercepts([(2, 4)]) == {\"-2.0\"}\n", "\nassert find_x_intercepts([(0, 5)]) == set()\n", "\nassert find_x_intercepts([(1, -1)]) == {\"1.0\"}\n", "\nassert find_x_intercepts([(0.5, 2)]) == {\"-4.0\"}\n", "\nassert find_x_intercepts([(1/3, 1)]) ==... |
5a3434a01bea4011a7f7a62fffb69d74 | [
{
"content": "On te donne une chaîne de caractères représentant une expression mathématique composée d'entiers positifs et des opérateurs '+', '-', '*', '/'. Ta tâche est d'évaluer l'expression en utilisant l'algorithme de la cour de triage (Shunting Yard) pour la convertir de la notation infixe à la notation p... | ["\nassert evaluate_expression(\"3 + 5 * ( 2 - 8 )\") == -17.0\n", "\nassert evaluate_expression(\"10 + 2 * 6\") == 22.0\n", "\nassert evaluate_expression(\"100 * 2 + 12\") == 212.0\n", "\nassert evaluate_expression(\"100 * ( 2 + 12 )\") == 1400.0\n", "\nassert evaluate_expression(\"100 * ( 2 + 12 ) / 14\") == 100.0\n"... |
f591f344f8eb2a1496b81fe1e8b41788 | [
{
"content": "On te donne une liste d'entiers positifs distincts `candidates` et un entier cible `target`. Ta tâche est de trouver toutes les combinaisons uniques de nombres de la liste `candidates` qui s'additionnent à `target`. Chaque nombre dans `candidates` peut être utilisé un nombre illimité de fois dans ... | ["\nassert combinationSum([2, 3, 6, 7], 7) == [[2, 2, 3], [7]]\n", "\nassert combinationSum([2, 3, 5], 8) == [[2, 2, 2, 2], [2, 3, 3], [3, 5]]\n", "\nassert combinationSum([1], 1) == [[1]]\n", "\nassert combinationSum([1], 2) == [[1, 1]]\n", "\nassert combinationSum([1, 2], 4) == [[1, 1, 1, 1], [1, 1, 2], [2, 2]]\n", "... |
2faf5d58ce4fb27baa6fa11cfa491208 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie le deuxième plus grand entier distinct de la liste. Si la liste contient moins de deux entiers distincts, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 10^5)... | ["\nassert second_largest([3, 6, -2, -5, 7, 3]) == 6\n", "\nassert second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert second_largest([5, 5, 5, 5]) == None\n", "\nassert second_largest([10]) == None\n", "\nassert second_largest([1, 1, 2, 2, 3, 3]) == 2\n", "\nassert second_largest([-1, -2, -3, -4]) == -2\n", "\nassert s... |
922790c254eccd4bd16f3d49f8dad3de | [
{
"content": "On te demande d'implémenter une fonction pour évaluer la performance des algorithmes de détection d'objets en calculant le score d'Intersection over Union (IoU) entre deux boîtes englobantes. Le score d'IoU est une mesure du chevauchement entre deux boîtes englobantes, défini comme l'aire de l'int... | ["\nassert calculate_iou((50, 50, 100, 100), (60, 60, 110, 110)) == 0.25\n", "\nassert calculate_iou((0, 0, 10, 10), (5, 5, 15, 15)) == 0.25\n", "\nassert calculate_iou((0, 0, 10, 10), (10, 10, 20, 20)) == 0.0\n", "\nassert calculate_iou((0, 0, 10, 10), (0, 0, 10, 10)) == 1.0\n", "\nassert calculate_iou((0, 0, 5, 5), (... |
78f4abac7a00f466e2050407dab3ca57 | [
{
"content": "On te donne une chaîne de caractères `input_string`. Ta tâche est d'écrire une fonction Python qui renvoie un dictionnaire où les clés sont les mots de la chaîne, et les valeurs sont le nombre de fois que chaque mot apparaît dans la chaîne. La fonction doit être insensible à la casse et doit ignor... | ["\nassert word_count(\"Hello, world! Hello, Python.\") == {'hello': 2, 'world': 1, 'python': 1}\n", "\nassert word_count(\"This is a test. This test is only a test.\") == {'this': 2, 'is': 2, 'a': 2, 'test': 3, 'only': 1}\n", "\nassert word_count(\"One fish, two fish, red fish, blue fish.\") == {'one': 1, 'fish': 4, '... |
81bbeabb9e398bfc4b1de98fc434e68f | [
{
"content": "On te donne un document XML volumineux sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `extract_text_from_xml` qui extrait tout le texte de ce document XML, en excluant les espaces blancs de début ou de fin, et le concatène en une seule chaîne de caractères. La fonction doit... | ["\nassert extract_text_from_xml(\"<root><child>Hello</child></root>\") == \"Hello\"\n", "\nassert extract_text_from_xml(\"<root><child> Hello </child></root>\") == \"Hello\"\n", "\nassert extract_text_from_xml(\"<root><child>Hello</child><child>World</child></root>\") == \"HelloWorld\"\n", "\nassert extract_text_from_... |
a91f4d0613403ceefd2e989a00ffa906 | [
{
"content": "On te demande d'implémenter une fonction `button_to_url_redirect` qui construit une page HTML avec un bouton. Lorsqu'on clique sur le bouton, l'utilisateur doit être redirigé vers une URL spécifiée. Si aucune URL n'est fournie, le bouton doit rediriger vers une URL par défaut construite en ajoutan... | ["\nassert button_to_url_redirect(\"123abc\", \"https://example.com\") == \"\"\"<!DOCTYPE html>\n<html>\n<head>\n\t<title>Redirect Button</title>\n\t<script>\n\t\t\tfunction redirectToURL() {\n\t\t\t\twindow.location.href = \"https://example.com\";\n\t\t\t}\n\t\t</script>\n</head>\n<body>\n\t<button onclick=\"redirectT... |
a88b643ed39213851eb80bfc324f565e | [
{
"content": "On te demande d'implémenter une classe `Library` en Python. La classe doit prendre en charge les opérations suivantes :\n\n1. `add_book(book)` : Ajoute un livre à la bibliothèque. Chaque livre est représenté comme un dictionnaire avec les clés `title` et `author`.\n2. `remove_book(book_title)` : S... | ["\nassert Library().list_books() == []\n", "\nassert Library().add_book({'title': '1984', 'author': 'George Orwell'}) is None\n", "\nassert Library().list_books() == []\n", "\nlib = Library()\nlib.add_book({'title': '1984', 'author': 'George Orwell'})\nassert lib.list_books() == [{'title': '1984', 'author': 'George Or... |
a20ea1bf2042e1934fc97d6abb1a0591 | [
{
"content": "On te demande d'implémenter une fonction d'ordre supérieur nommée `check_any`. Cette fonction accepte un seul argument, `predicate`, qui est une fonction qui prend exactement un argument et renvoie une valeur booléenne. La fonction `check_any` doit renvoyer une autre fonction qui peut accepter n'i... | ["\nassert check_any(lambda x: x > 0)(1, -2, 3) == True\n", "\nassert check_any(lambda x: x < 0)(1, 2, 3) == False\n", "\nassert check_any(lambda x: x == 5)(1, 2, 5) == True\n", "\nassert check_any(lambda x: x == 10)(1, 2, 3) == False\n", "\nassert check_any(lambda x: x % 2 == 0)(1, 3, 5, 7, 8) == True\n", "\nassert ch... |
45d84afaed20e7739f628a3ad953820b | [
{
"content": "On te donne un document HTML représenté comme un objet BeautifulSoup et une liste de balises HTML. Ta tâche est de mettre en œuvre une fonction `extract_content` qui renvoie un dictionnaire. Le dictionnaire doit mapper chaque balise de la liste au contenu textuel de sa première occurrence dans le ... | ["\nassert extract_content(BeautifulSoup('<div><p>Hello <b>world</b>!</p></div>', 'html.parser'), ['p']) == {'p': 'Hello !'}\n", "\nassert extract_content(BeautifulSoup('<div><span> Test </span></div>', 'html.parser'), ['span']) == {'span': 'Test'}\n", "\nassert extract_content(BeautifulSoup('<div><h1>Header</h1><p... |
1d8b2b0437265a88760e989613cdd8ca | [
{
"content": "On te donne un objet JSON représentant une configuration imbriquée. Ta tâche est d'écrire une fonction Python qui aplatit l'objet JSON en un dictionnaire avec des clés séparées par des points. Par exemple, la clé `database.host` devrait être le résultat de l'aplatissement de `{\"database\": {\"hos... | ["\nassert flatten_json({\"a\": 1}) == {\"a\": 1}\n", "\nassert flatten_json({\"a\": {\"b\": 2}}) == {\"a.b\": 2}\n", "\nassert flatten_json({\"a\": {\"b\": {\"c\": 3}}}) == {\"a.b.c\": 3}\n", "\nassert flatten_json({\"a\": [1, 2, 3]}) == {\"a0\": 1, \"a1\": 2, \"a2\": 3}\n", "\nassert flatten_json({\"a\": {\"b\": [4, ... |
a7a5ed7bb98e5399e5060742ff40e575 | [
{
"content": "Tu dois implémenter un programme qui simule un jeu de « Pendu ». Le jeu consiste à sélectionner un mot aléatoire dans une liste de mots récupérée dynamiquement via une API et à permettre au joueur de deviner le mot en proposant des lettres. Le programme doit gérer les fonctionnalités suivantes :\n... | ["\nassert fetch_word_list('https://example.com/api/words', 'words_cache.json') == ('apple', 'banana', 'cherry')\n", "\nassert select_random_word(('apple', 'banana', 'cherry')) in ('apple', 'banana', 'cherry')\n", "\nassert reveal_letter('hello', 'l', '_____') == 'h_ll_'\n", "\nassert reveal_letter('world', 'z', '_____... |
afcb4016356824f718872abb7c79abb5 | [
{
"content": "On te donne un fichier script Python. Ta tâche est d'écrire une fonction `count_code_elements(file_path)` qui lit le fichier et renvoie un dictionnaire contenant les informations suivantes :\n- Le nombre total de lignes dans le fichier.\n- Le nombre total de caractères dans le fichier.\n- Le nombr... | ["\nassert count_code_elements(\"test_script.py\") == {'lines': 3, 'characters': 35, 'identifiers': 2, 'unique_comments': 1} if open(\"test_script.py\", 'w').write(\"def test():\\n x = 5\\n# This is a comment\\n\") else None\n", "\nassert count_code_elements(\"empty_script.py\") == {'lines': 0, 'characters': 0, 'ide... |
568351db819735c71d5f7b35d0c95515 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n\n1. **Initialisation** : Créer une instance de `BankAccount` avec un numéro de compte et initialiser le solde à 0.\n2. **Dépôt** : Ajouter un montant spécifié au solde du c... | ["\nassert BankAccount(\"12345\").get_balance() == 0\n", "\nassert BankAccount(\"67890\").account_number == \"67890\"\n", "\nassert BankAccount(\"11111\").deposit(100) is None\n", "\nassert BankAccount(\"22222\").deposit(50).get_balance() == 50\n", "\nassert BankAccount(\"33333\").deposit(100).withdraw(50) is True\n", ... |
06531de732587d505222ee24a87331b7 | [
{
"content": "On te demande d'implémenter une classe Python nommée `Summable` qui encapsule trois attributs entiers privés. La classe doit fournir un constructeur pour initialiser ces attributs, des méthodes getter pour chaque attribut, et une méthode pour calculer et renvoyer leur somme.\n\n**Entrée :**\n- Le ... | ["\nassert MyClass(1, 2, 3).get_var1() == 1\n", "\nassert MyClass(1, 2, 3).get_var2() == 2\n", "\nassert MyClass(1, 2, 3).get_var3() == 3\n", "\nassert MyClass(10, 20, 30).get_sum() == 60\n", "\nassert MyClass(-1, -2, -3).get_sum() == -6\n", "\nassert MyClass(0, 0, 0).get_sum() == 0\n", "\nassert MyClass(1.5, 2.5, 3.5)... |
67f91e83fc330d1ed9b0738a82e264fa | [
{
"content": "On te donne la tâche de calculer le prix réduit d'un produit en utilisant exclusivement des opérations au niveau du bit. Ta fonction doit accepter deux entiers : le prix initial du produit et le pourcentage de réduction. La fonction doit renvoyer le prix réduit sous forme d'entier. Note que tu ne ... | ["\nassert calculate_discounted_price(100, 20) == 80\n", "\nassert calculate_discounted_price(200, 50) == 100\n", "\nassert calculate_discounted_price(150, 0) == 150\n", "\nassert calculate_discounted_price(0, 10) == 0\n", "\nassert calculate_discounted_price(100, 100) == 0\n", "\nassert calculate_discounted_price(50, ... |
5532a231e2f976fb7e59f8cfceab9f5c | [
{
"content": "On te demande d'implémenter la fonction `format_label` qui traite deux chaînes de caractères en entrée, `name` et `element`, et renvoie une chaîne formatée selon des règles spécifiques. La fonction doit fonctionner avec une complexité temporelle constante, O(1).\n\n**Règles :**\n- Si la longueur d... | ["\nassert format_label(\"abcd\", \"e\") == \" abcd\"\n", "\nassert format_label(\"abc\", \"e\") == \" abc\"\n", "\nassert format_label(\"ab\", \"e\") == \" ab\"\n", "\nassert format_label(\"a\", \"e\") == \" a\"\n", "\nassert format_label(\"abcd\", \"ef\") == \"abcd\"\n", "\nassert format_label(\"abcde\", \"ef\"... |
b14ee78b3109e7eada55a9e9ece46767 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé du nom d'une personne et de son âge. Ta tâche est d'écrire une fonction Python qui trie cette liste par ordre croissant en fonction de l'âge des individus.\n\n**Entrée :**\n- Une liste de tuples, où chaque tuple contient une chaîne de ca... | ["\nassert sort_people_by_age([(\"Alice\", 34), (\"Bob\", 23), (\"Charlie\", 29), (\"David\", 41), (\"Eve\", 18)]) == [(\"Eve\", 18), (\"Bob\", 23), (\"Charlie\", 29), (\"Alice\", 34), (\"David\", 41)]\n", "\nassert sort_people_by_age([(\"John\", 25), (\"Jane\", 25), (\"Doe\", 25)]) == [(\"John\", 25), (\"Jane\", 25), ... |
dde75305c7785c68d69bd8a396355bba | [
{
"content": "On te donne un dictionnaire `word_counts` où chaque clé est un mot et la valeur correspondante est le nombre d'occurrences de ce mot dans un texte donné. Ta tâche est d'implémenter la fonction `sort_words_by_frequency(word_counts)` qui renvoie une liste de tuples. Chaque tuple doit contenir un mot... | ["\nassert sort_words_by_frequency({'apple': 4, 'banana': 2, 'pear': 4, 'peach': 1}) == [('apple', 4), ('pear', 4), ('banana', 2), ('peach', 1)]\n", "\nassert sort_words_by_frequency({'cat': 3, 'dog': 3, 'bird': 2}) == [('cat', 3), ('dog', 3), ('bird', 2)]\n", "\nassert sort_words_by_frequency({'hello': 1, 'world': 1})... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.