id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
d53a64ae9604e40d8ae16c56a2090bc7 | [
{
"content": "On te demande d'implémenter une simulation simple d'un magasin en ligne. Le magasin propose au moins cinq articles distincts, chacun avec un prix prédéfini. Ton programme doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un article au panier** : Ajouter une quantité spécifiée d'un ... | ["\nassert store.calculate_total() == 1600\n", "\nstore.add_to_cart(\"laptop\", 2)\nassert store.calculate_total() == 3600\n", "\nstore.remove_from_cart(\"laptop\", 1)\nassert store.calculate_total() == 2600\n", "\nstore.add_to_cart(\"tablet\", 3)\nassert store.calculate_total() == 3500\n", "\nstore.remove_from_cart(\"... |
f9f461c5879d82bd4533d223822e93cd | [
{
"content": "On te charge de préparer un ensemble de données pour un modèle d'apprentissage automatique qui prédit les prix des logements. Ton objectif est d'implémenter une fonction `preprocess_data` qui traite l'ensemble de données selon les règles suivantes :\n- Supprimer toutes les lignes contenant des val... | ["\nassert preprocess_data(pd.DataFrame({'A': [1, 2, 3], 'B': ['x', 'y', 'z']})).equals(pd.DataFrame({'A': [1, 2, 3], 'B_x': [1, 0, 0], 'B_y': [0, 1, 0]}))\n", "\nassert preprocess_data(pd.DataFrame({'A': [1, 2, 3], 'B': ['x', 'y', 'x']})).equals(pd.DataFrame({'A': [1, 2, 3], 'B_y': [0, 1, 0]}))\n", "\nassert preproces... |
97f400b24c5e8df10493460da6efbac4 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `remove_duplicates` qui traite cette liste pour éliminer tous les éléments dupliqués, en veillant à ce que seule la première occurrence de chaque élément soit conservée dans l'ordre où ils apparaissent.\n\n**Entrée :**\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,... |
89cba7768fb8558a56e3c8e0d66c39a2 | [
{
"content": "On te demande d'implémenter une classe `Matrix` en Python qui puisse gérer des matrices de n'importe quelle taille. La classe doit avoir un initialisateur `__init__` qui prend une liste bidimensionnelle en entrée pour construire la matrice. Implémente une méthode `transpose` qui renvoie un nouvel ... | ["\nassert Matrix([[1, 2], [3, 4]]).transpose().data == [[1, 3], [2, 4]]\n", "\nassert Matrix([[5, 6, 7], [8, 9, 10]]).transpose().data == [[5, 8], [6, 9], [7, 10]]\n", "\nassert Matrix([[11, 12, 13, 14], [15, 16, 17, 18]]).transpose().data == [[11, 15], [12, 16], [13, 17], [14, 18]]\n", "\nassert Matrix([[19]]).transp... |
f6869c225902d4a4aceacb45f9705861 | [
{
"content": "On te donne une chaîne de caractères `S` et un entier `L`. Ta tâche est de générer toutes les combinaisons possibles de la chaîne `S` de longueur `L`. Les combinaisons doivent être renvoyées sous forme de liste de chaînes de caractères. Note que l'ordre des combinaisons dans la liste n'a pas d'imp... | ["\nassert generate_combinations(\"abc\", 2) == ['ab', 'ac', 'bc']\n", "\nassert generate_combinations(\"abcd\", 3) == ['abc', 'abd', 'acd', 'bcd']\n", "\nassert generate_combinations(\"a\", 1) == ['a']\n", "\nassert generate_combinations(\"abc\", 0) == ['']\n", "\nassert generate_combinations(\"\", 2) == []\n", "\nass... |
e6661d8aab1d63a355e15fb7106f8e58 | [
{
"content": "On te donne une liste d'images représentées comme des tableaux numpy, où chaque image a des dimensions `[hauteur, largeur, canaux]`. Ta tâche est de créer une nouvelle liste d'images où chaque image est répétée `K` fois. L'ordre des images doit être maintenu, c'est-à-dire que les images répétées d... | ["\nassert repeat_images([np.array([[1, 2], [3, 4]])], 1) == [np.array([[1, 2], [3, 4]])]\n", "\nassert repeat_images([np.array([[1, 2], [3, 4]])], 2) == [np.array([[1, 2], [3, 4]]), np.array([[1, 2], [3, 4]])]\n", "\nassert repeat_images([np.array([[1, 2], [3, 4]]), np.array([[5, 6], [7, 8]])], 2) == [np.array([[1, 2]... |
aae3f6c8b5e2dfdb94e20f85022e6ae0 | [
{
"content": "Tu développes une fonction pour un système de gestion de dispositifs IoT qui gère plusieurs dispositifs et leurs paramètres de contrôle. Chaque dispositif est identifié de manière unique par un `device_id`, et chaque paramètre de contrôle au sein d'un dispositif est identifié de manière unique par... | ["\nassert retrieve_device_control_setting_by_id('device_1', 'setting_1') == {'id': 'setting_1', 'name': 'Temperature', 'value': 22.5, 'unit': 'Celsius'}\n", "\nassert retrieve_device_control_setting_by_id('device_2', 'setting_3') == {'id': 'setting_3', 'name': 'Light Intensity', 'value': 500, 'unit': 'LUX'}\n", "\nass... |
2b32e8556be294e8ef0512d1ea7c80dd | [
{
"content": "On te donne une base de données avec une table `orders` qui contient des informations sur chaque commande, y compris l'état vers lequel la commande a été expédiée. Ta tâche est d'écrire une requête SQL pour déterminer le nombre de commandes expédiées aux clients de l'état de Californie (CA).\n\n**... | ["\nassert generate_fibonacci(0) == []\n", "\nassert generate_fibonacci(1) == [0]\n", "\nassert generate_fibonacci(2) == [0, 1]\n", "\nassert generate_fibonacci(3) == [0, 1, 1]\n", "\nassert generate_fibonacci(5) == [0, 1, 1, 2, 3]\n", "\nassert generate_fibonacci(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert ... |
fa40b1eec94af720d672fefe754eb941 | [
{
"content": "On te donne une liste de relevés de température quotidiens en Celsius. Ta tâche est de mettre en œuvre une fonction `calculate_average_temperature(temperatures)` qui calcule la température moyenne à partir de la liste. Le résultat doit être arrondi à deux décimales. Ta fonction doit gérer les cas ... | ["\nassert calculate_average_temperature([20, 22, 24, 26, 28]) == 24.0\n", "\nassert calculate_average_temperature([15.5, 16.5, 17.5]) == 16.5\n", "\nassert calculate_average_temperature([0, 0, 0, 0]) == 0.0\n", "\nassert calculate_average_temperature([-5, -10, -15, -20]) == -12.5\n", "\nassert calculate_average_temper... |
7020c618a88faba4a9baf25ee190c60a | [
{
"content": "On te donne un nouvel algorithme de conversion de réseau creux vers dense, inspiré de la méthode Sparse Networks from Scratch (SNFS). L'algorithme fonctionne comme suit :\n\n1. Un modèle creux est entraîné pendant un certain nombre d'itérations.\n2. Après chaque `mask_interval` itérations, les poi... | ["\nassert calculate_total_FLOPs(1000, 2000, 10, 500, 100) == 17500\n", "\nassert calculate_total_FLOPs(500, 1000, 5, 200, 25) == 17500\n", "\nassert calculate_total_FLOPs(100, 200, 1, 50, 10) == 1400\n", "\nassert calculate_total_FLOPs(0, 0, 10, 0, 100) == 0\n", "\nassert calculate_total_FLOPs(1000, 0, 10, 0, 100) == ... |
9905cedfff36e4dfb478b85c7a7f28be | [
{
"content": "On te donne une URL de base et deux horodatages, `timestamp1` et `timestamp2`, représentant le début et la fin d'une période spécifique. Ta tâche est de construire une nouvelle URL en insérant ces horodatages dans l'URL de base aux positions appropriées, en veillant à ce que l'URL soit valide même... | ["\nassert construct_url(\"https://example.com/api/data?start={timestamp1}&end={timestamp2}\", \"2023-10-01 15:30:00\", \"2023-09-30 15:30:00\") == \"https://example.com/api/data?start=2023-09-30 15:30:00&end=2023-10-01 15:30:00\"\n", "\nassert construct_url(\"https://example.com/api/data?start={timestamp1}&end={timest... |
0c15a2618e4688c377ff4e0c31e2d725 | [
{
"content": "Implémente une classe Python nommée `BankAccount` avec les spécifications suivantes :\n\n- **Attributs :**\n - `account_holder_name` : une chaîne de caractères représentant le nom du titulaire du compte.\n - `balance` : un flottant représentant le solde actuel du compte, initialisé par défaut à ... | ["\nassert BankAccount(\"John Doe\").get_balance() == 0.0\n", "\nassert BankAccount(\"Jane Smith\", 100.0).get_balance() == 100.0\n", "\nassert BankAccount(\"Alice\", 50.0).deposit(50.0) is None and BankAccount(\"Alice\", 50.0).get_balance() == 100.0\n", "\nassert BankAccount(\"Bob\", 100.0).withdraw(50.0) is None and ... |
45778daac579df3c93dd703840821d44 | [
{
"content": "On te donne une séquence d'entiers. Ta tâche est de trouver la plus longue sous-séquence strictement croissante dans cette séquence. S'il existe plusieurs sous-séquences de longueur maximale identique, tu peux en retourner n'importe laquelle. Si la séquence d'entrée est vide, retourne une liste vi... | ["\nassert longest_increasing_subsequence([5, 7, 4, 8, 6, 7, 9, 2]) == [5, 7, 8, 9]\n", "\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 18]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7]) =... |
2494a05b2a2e2b527489ab7d14c65618 | [
{
"content": "On te demande d'implémenter une fonction `validate_path(path)` qui vérifie si une chaîne de caractères représentant un chemin est valide selon des règles spécifiques. La fonction doit renvoyer `True` si le chemin est valide et `False` sinon. Un chemin est considéré comme valide s'il répond aux cri... | ["\nassert validate_path(\"/\") == True\n", "\nassert validate_path(\"/valid/path\") == True\n", "\nassert validate_path(\"/valid/path/\") == False\n", "\nassert validate_path(\"invalid/path\") == False\n", "\nassert validate_path(\"/path/with/{wildcards}\") == False\n", "\nassert validate_path(\"/path/with/}\") == Fal... |
d567b5f25c5e6e9313669bafcf0563b4 | [
{
"content": "On te demande d'implémenter une fonction `clean_string(input_string)` qui traite une chaîne de caractères donnée pour la rendre appropriée pour une utilisation comme nom de fichier. La fonction doit remplacer des caractères spécifiques par des alternatives prédéfinies et simplifier les séquences d... | ["\nassert clean_string(\"hello#world\") == \"hello_sharp_world\"\n", "\nassert clean_string(\"path/to/file\") == \"path_on_to_on_file\"\n", "\nassert clean_string(\"bottle\") == \"_flat_ottle\"\n", "\nassert clean_string(\"(example)\") == \"_example_\"\n", "\nassert clean_string(\"!!!\") == \"_\"\n", "\nassert clean_s... |
093b4ae5bfa71a45453236d49318cde0 | [
{
"content": "Tu es chargé d'implémenter une fonction `extract_emails(text)` qui traite une chaîne de caractères `text` donnée et extrait toutes les adresses e-mail uniques à l'aide d'expressions régulières. La fonction doit renvoyer une liste d'adresses e-mail valides trouvées dans la chaîne. Les adresses e-ma... | ["\nassert extract_emails(\"test@example.com\") == [\"test@example.com\"]\n", "\nassert extract_emails(\"hello world\") == []\n", "\nassert extract_emails(\"contact: john.doe@example.com, jane.doe@example.org\") == [\"john.doe@example.com\", \"jane.doe@example.org\"]\n", "\nassert extract_emails(\"multiple emails: test... |
0619b4f4934e627c60aac6270ed080b7 | [
{
"content": "On te demande d'implémenter une fonction pour analyser un fichier de configuration dans un format personnalisé. Le fichier de configuration est constitué de paires clé-valeur séparées par deux-points (`:`), chaque paire étant sur une nouvelle ligne. Ta fonction doit lire le fichier de configuratio... | ["\nassert parse_config(\"name: John\\nage: 30\\ncity: New York\") == {\"name\": \"John\", \"age\": \"30\", \"city\": \"New York\"}\n", "\nassert parse_config(\"username: admin\\npassword: secret\") == {\"username\": \"admin\", \"password\": \"secret\"}\n", "\nassert parse_config(\"key1: value1\\nkey2: value2\\nkey3: v... |
13a31ec7c37b9f9149b91be483fc0eb8 | [
{
"content": "On te demande de créer une fonction `generate_html_table` qui construit un tableau HTML à partir d'une liste de dictionnaires. Chaque dictionnaire de la liste représente une ligne du tableau, les clés servant d'en-têtes de colonne. Ta fonction doit renvoyer une chaîne de caractères contenant le co... | ["\nassert generate_html_table([{\"Name\": \"Alice\", \"Age\": 30, \"City\": \"New York\"}]) == \"<table>\\n <tr>\\n\\t<th>Name</th>\\n\\t<th>Age</th>\\n\\t<th>City</th>\\n </tr>\\n <tr>\\n\\t<td>Alice</td>\\n\\t<td>30</td>\\n\\t<td>New York</td>\\n </tr>\\n</table>\"\n", "\nassert generate_html_table([]) == \"<tab... |
a9522faaf2470287cd6e5ed401789884 | [
{
"content": "Étant donné une liste d'entiers, écris une fonction pour déterminer la somme maximale réalisable en sélectionnant n'importe quels trois nombres distincts de la liste. Suppose que la liste contient au moins trois entiers.\n\n**Exemple d'entrée :**\n```\n[1, 10, 3, 5, 7, 8]\n```\n\n**Exemple de sort... | ["\nassert max_sum_of_three([1, 2, 3]) == 6\n", "\nassert max_sum_of_three([10, 20, 30, 40, 50]) == 120\n", "\nassert max_sum_of_three([-1, -2, -3, -4, -5]) == -6\n", "\nassert max_sum_of_three([100, 200, 300, 400, 500, 600]) == 1500\n", "\nassert max_sum_of_three([1, 1, 1, 1, 1, 1]) == 3\n", "\nassert max_sum_of_three... |
5f974b5d71907874f9b5ff7886cd7c57 | [
{
"content": "On te demande d'écrire un script Python qui interagit avec une base de données SQLite. Ton script doit demander à l'utilisateur d'entrer le chemin d'un fichier de base de données SQLite et une requête SQL à exécuter. Le script doit ensuite se connecter à la base de données, exécuter la requête fou... | ["\nassert fetch_data(':memory:', 'SELECT name FROM test_table WHERE id = 1') == [('Alice',)]\n", "\nassert fetch_data(':memory:', 'SELECT name FROM test_table WHERE id = 2') == [('Bob',)]\n", "\nassert fetch_data(':memory:', 'SELECT name FROM test_table WHERE id = 3') == [('Charlie',)]\n", "\nassert fetch_data(':memor... |
d93d27975bc2be1b71f5625bf0486dd2 | [
{
"content": "Tu es chargé d'implémenter une classe Python nommée `Book` pour représenter un livre. La classe doit avoir les attributs suivants : `title`, `author` et `publication_year`. De plus, la classe doit inclure une méthode `get_details` qui renvoie une chaîne formatée avec les détails du livre sous la f... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_details() == \"Title: 1984, Author: George Orwell, Year: 1949\"\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960).get_details() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year: 1960\"\n", "\nassert Book(\"The Great Gatsby\", \"F. Scott... |
3be31b34cb526fd29a40adff8a0dd0fb | [
{
"content": "On te donne un entier non négatif `n`. Ta tâche est d'implémenter une fonction optimisée `compute_factorial(n)` qui calcule la factorielle de `n` en utilisant une approche itérative. La fonction doit renvoyer la factorielle de `n`.\n\n**Contraintes :**\n- `0 ≤ n ≤ 20`\n\n**Exemple d'entrée :**\n``... | ["\nassert compute_factorial(0) == 1\n", "\nassert compute_factorial(1) == 1\n", "\nassert compute_factorial(2) == 2\n", "\nassert compute_factorial(3) == 6\n", "\nassert compute_factorial(4) == 24\n", "\nassert compute_factorial(5) == 120\n", "\nassert compute_factorial(6) == 720\n", "\nassert compute_factorial(10) ==... |
e6ca2e6e72f3e5412120c74d2d145bc9 | [
{
"content": "On te donne un entier `n`. Ta tâche est de déterminer si `n` est un carré parfait. Un carré parfait est un entier qui est le carré d'un entier. Par exemple, 1, 4, 9, 16 sont des carrés parfaits (1^2, 2^2, 3^2, 4^2), tandis que 2, 3, 5, 14 ne le sont pas.\n\n**Entrée :**\n- Un seul entier `n` (-10^... | ["\nassert is_perfect_square(0) == True\n", "\nassert is_perfect_square(1) == True\n", "\nassert is_perfect_square(4) == True\n", "\nassert is_perfect_square(9) == True\n", "\nassert is_perfect_square(16) == True\n", "\nassert is_perfect_square(25) == True\n", "\nassert is_perfect_square(2) == False\n", "\nassert is_pe... |
00fce2b1f1f238b0e1e31e20d343affd | [
{
"content": "On te donne une fonction simple en JavaScript qui prend deux nombres en entrée et renvoie leur somme. Ta tâche est de réécrire cette fonction en Python tout en conservant la même fonctionnalité.\n\n**Signature de la fonction :**\n```python\ndef add(a, b):\n```\n\n**Entrée :**\n- Deux entiers `a` e... | ["\nassert add(2, 3) == 5\n", "\nassert add(-1, 1) == 0\n", "\nassert add(0, 0) == 0\n", "\nassert add(-5, -5) == -10\n", "\nassert add(1.5, 2.5) == 4.0\n", "\nassert add(-3.5, 2) == -1.5\n", "\nassert add(100, 200) == 300\n", "\nassert add(1000000, 1) == 1000001\n", "\nassert add(0.1, 0.2) == 0.3\n", "\nassert add(10,... |
b378b037eecf1f4b2d24bac60099b8e6 | [
{
"content": "On te donne une liste de vecteurs de mots `word_vecs`, où chaque vecteur représente un mot dans une phrase. De plus, on te fournit un dictionnaire `lexicon` qui associe chaque mot à un score de sentiment. Ta tâche est de calculer la moyenne pondérée des vecteurs de mots en fonction de leurs scores... | ["\nassert np.allclose(weighted_vector_average([np.array([1, 2, 3]), np.array([4, 5, 6]), np.array([7, 8, 9])], {\"word1\": 0.2, \"word2\": -0.3, \"word3\": 0}, [\"word1\", \"word2\", \"word3\"]), np.array([4.000002, 5.000002, 6.000002]))\n", "\nassert np.allclose(weighted_vector_average([np.array([1, 1, 1]), np.array(... |
914deabda2e946508f43dbb42095d52c | [
{
"content": "Tu développes un système de journalisation pour une application à grande échelle avec plusieurs modules. Chaque module nécessite un objet logger unique. Implémente une fonction `get_logger` qui renvoie un objet logger pour un nom de module donné. Le nom du logger doit suivre le format `<root_logge... | ["\nassert get_logger('my_application').name == 'my_application'\n", "\nassert get_logger('my_application', 'module1').name == 'my_application.module1'\n", "\nassert get_logger('app', 'module2').name == 'app.module2'\n", "\nassert get_logger('root').hasHandlers() == True\n", "\nassert get_logger('root', 'submodule').ha... |
f92887702d3a92051a9bba7aeeb1f47b | [
{
"content": "On te donne une chaîne de caractères `text` qui peut contenir divers types de texte entre parenthèses et de caractères spéciaux. Ta tâche est de mettre en œuvre une fonction `clean_text(text)` qui traite la chaîne selon les règles suivantes :\n\n1. Supprime tout texte inclus entre parenthèses `()`... | ["\nassert clean_text(\"This is a test (with some) [bracketed text] and \u300cquotes\u300d\") == \"This is a test and \u3002\"\n", "\nassert clean_text(\"Hello\uff01World\uff1aThis\uff1bis\uff1fa\uff1ftest\") == \"Hello\u3002World\u3002This\u3002is\u3002a\u3002test\u3002\"\n", "\nassert clean_text(\"abcba\") == \"\"\n... |
42c10f1638d9311a8089e420a140c865 | [
{
"content": "On te donne une structure de liste imbriquée composée d'entiers et d'autres listes. Ta tâche est d'écrire une fonction `flatten_list(input_list)` qui renvoie une seule liste aplatie contenant tous les entiers de la liste imbriquée dans l'ordre où ils apparaissent.\n\n**Entrée :**\n- Une liste imbr... | ["\nassert flatten_list([1, 2, 3]) == [1, 2, 3]\n", "\nassert flatten_list([1, [2, 3], 4]) == [1, 2, 3, 4]\n", "\nassert flatten_list([[1, 2], [3, 4], [5, 6]]) == [1, 2, 3, 4, 5, 6]\n", "\nassert flatten_list([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten_list([]) == []\n", "\nassert flatten_list([[]... |
7c95df89cb9db981d0a439b3caeadd5d | [
{
"content": "On te demande d'implémenter une fonction `format_number(num, unit='B')` qui convertit un nombre donné dans un format lisible par l'homme en fonction de l'unité spécifiée. La fonction doit gérer les unités suivantes : 'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB' et 'YB'. La sortie doit être une ch... | ["\nassert format_number(123456789) == '117.740 MB'\n", "\nassert format_number(1024) == '1.000 KB'\n", "\nassert format_number(1048576) == '1.000 MB'\n", "\nassert format_number(1073741824) == '1.000 GB'\n", "\nassert format_number(1099511627776) == '1.000 TB'\n", "\nassert format_number(1125899906842624) == '1.000 PB... |
238ecfa16a0dcf547249879a04ab6236 | [
{
"content": "On te demande d'implémenter une fonction `create_html_table` en Python. Cette fonction doit générer un tableau HTML à partir d'une liste de listes donnée, où chaque liste interne représente une ligne du tableau. La première ligne de la liste doit être traitée comme la ligne d'en-tête du tableau. D... | ["\nassert create_html_table([['Name', 'Age'], ['Alice', 30]]) == '<table>\\n <thead>\\n\t<tr>\\n\t <th>Name</th>\\n\t <th>Age</th>\\n\t</tr>\\n </thead>\\n <tbody>\\n\t<tr>\\n\t <td>Alice</td>\\n\t <td>30</td>\\n\t</tr>\\n </tbody>\\n</table>'\n", "\nassert create_html_table([['Name', 'Age'], ['Alice', 30]], '... |
cc561d8ad3e69a0f612d0d61589079d6 | [
{
"content": "Dans un système de traitement de données, tu dois implémenter une fonction `round_to_nearest_ten` qui arrondit un entier donné `value` au multiple de 10 le plus proche. Cependant, si `value` est inférieur à 5, la fonction doit renvoyer 1. Tu n'es pas autorisé à utiliser des fonctions d'arrondi int... | ["\nassert round_to_nearest_ten(3) == 1\n", "\nassert round_to_nearest_ten(4) == 1\n", "\nassert round_to_nearest_ten(5) == 10\n", "\nassert round_to_nearest_ten(7) == 10\n", "\nassert round_to_nearest_ten(10) == 10\n", "\nassert round_to_nearest_ten(12) == 10\n", "\nassert round_to_nearest_ten(15) == 20\n", "\nassert ... |
8726a8fa82a616daf7c7d1ca19704b5d | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui identifie les deux plus grands nombres distincts de la liste et de les renvoyer sous forme de tuple dans l'ordre décroissant. Si la liste contient moins de deux nombres distincts, renvoie un tuple vide.\n\n**Exemple d'entr... | ["\nassert find_two_largest_numbers([1, 2, 3, 4, 5]) == (5, 4)\n", "\nassert find_two_largest_numbers([10, 20, 30, 40, 50]) == (50, 40)\n", "\nassert find_two_largest_numbers([50, 40, 30, 20, 10]) == (50, 40)\n", "\nassert find_two_largest_numbers([100]) == ()\n", "\nassert find_two_largest_numbers([]) == ()\n", "\nass... |
812f6c118cd4d573376885c2fec7a14b | [
{
"content": "On te donne une structure imbriquée composée de dictionnaires et de listes. Ta tâche est de mettre en œuvre une fonction `get_nested_value` qui récupère une valeur de cette structure en utilisant une séquence de clés. La fonction doit ignorer toute clé de dictionnaire qui consiste uniquement en de... | ["\nassert get_nested_value({\"a\": 1, \"bb\": {\"ccc\": 2}}, [\"bb\", \"ccc\"]) == 2\n", "\nassert get_nested_value({\"a\": 1, \"bb\": {\"ccc\": 2}}, [\"a\"]) == 1\n", "\nassert get_nested_value({\"a\": 1, \"bb\": {\"ccc\": 2}}, [\"bb\", \"ddd\"]) == None\n", "\nassert get_nested_value({\"a\": 1, \"bb\": {\"ccc\": 2}}... |
10e6554f89a53ed595bf9fccfefaf0e4 | [
{
"content": "On te donne un dictionnaire `employees` où chaque clé est le nom d'un employé et chaque valeur est son salaire. Implémente une fonction `increase_salaries(employees, percentage)` qui renvoie un nouveau dictionnaire avec le salaire de chaque employé augmenté du pourcentage spécifié. Assure-toi que ... | ["\nassert increase_salaries({'Alice': 50000, 'Bob': 60000}, 10) == {'Alice': 55000.0, 'Bob': 66000.0}\n", "\nassert increase_salaries({'Alice': 50000, 'Bob': 60000}, 0) == {'Alice': 50000.0, 'Bob': 60000.0}\n", "\nassert increase_salaries({'Alice': 50000, 'Bob': 60000}, 50) == {'Alice': 75000.0, 'Bob': 90000.0}\n", "\... |
404db972e7e0a03094debda24177eceb | [
{
"content": "On te demande d'écrire une fonction Python qui génère les `n` premiers nombres premiers. Ta fonction doit être efficace et gérer de grandes valeurs de `n` jusqu'à 10^4.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 10^4) représentant le nombre de nombres premiers à générer.\n\n**Sortie :**\n- Une list... | ["\nassert generate_primes(0) == []\n", "\nassert generate_primes(1) == [2]\n", "\nassert generate_primes(2) == [2, 3]\n", "\nassert generate_primes(5) == [2, 3, 5, 7, 11]\n", "\nassert generate_primes(10) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert generate_primes(15) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ... |
c86243a2bd69e403ed7829edc115df83 | [
{
"content": "Dans un monde numérique, la racine numérique d'un entier positif `n` est définie comme le chiffre unique obtenu par un processus itératif consistant à additionner les chiffres, à chaque itération utilisant le résultat de l'itération précédente pour calculer une nouvelle somme, jusqu'à ce qu'un nom... | ["\nassert digital_root(0) == 0\n", "\nassert digital_root(1) == 1\n", "\nassert digital_root(9) == 9\n", "\nassert digital_root(10) == 1\n", "\nassert digital_root(138) == 3\n", "\nassert digital_root(456) == 6\n", "\nassert digital_root(1111) == 4\n", "\nassert digital_root(9999) == 9\n", "\nassert digital_root(16) =... |
b42cf845dda41a246faf05ef6e60e094 | [
{
"content": "On te donne pour tâche d'implémenter une fonction qui génère une date et une heure dans une plage spécifiée, en tenant compte des changements d'heure d'été. La fonction doit accepter les paramètres suivants :\n\n- `start` : une chaîne de caractères représentant la date et l'heure de début au forma... | ["\nassert generate_datetime(\"2023/01/01 00:00:00\", \"2023/01/02 00:00:00\", 0.5, \"%Y/%m/%d %H:%M:%S\") == \"2023/01/01 12:00:00\"\n", "\nassert generate_datetime(\"2023/03/10 01:00:00\", \"2023/03/11 04:00:00\", 0.5, \"%Y/%m/%d %H:%M:%S\", timezone_name='America/New_York') == \"2023/03/10 12:30:00\"\n", "\nassert g... |
517e2281a430e2638beb31f9490b6dc2 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour calculer le nième nombre de Fibonacci. Pour ce faire, tu dois utiliser la mémoïsation pour optimiser l'approche récursive. Ta fonction doit avoir la signature suivante :\n\n```python\ndef fibonacci(n: int) -> int:\n```\n\n**Entrée :**\n- Un s... | ["\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... |
789e87fb37c7c1ff4bf599eaad9e0fe7 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'une chaîne de caractères et d'une liste d'entiers. Ta tâche est de mettre en œuvre une fonction qui convertit cette liste en un dictionnaire. Les clés du dictionnaire doivent être les chaînes de caractères des tuples, et les valeurs do... | ["\nassert transform_tuples_to_dict([(\"key1\", [3, 1, 2, 1]), (\"key2\", [4, 5, 6]), (\"key1\", [2, 3, 7])]) == {'key1': [1, 2, 3, 7], 'key2': [4, 5, 6]}\n", "\nassert transform_tuples_to_dict([(\"a\", [1, 2, 3]), (\"b\", [4, 5, 6]), (\"a\", [3, 4, 5])]) == {'a': [1, 2, 3, 4, 5], 'b': [4, 5, 6]}\n", "\nassert transfor... |
7f2a67edf9b9b3929224d602c931f4a3 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui supprime toutes les voyelles de la chaîne et renvoie la chaîne résultante. La fonction doit être insensible à la casse, ce qui signifie qu'elle doit supprimer les voyelles majuscules et minuscules.\n\n**Entrée :**\n- ... | ["\nassert remove_vowels(\"Hello World\") == \"Hll Wrld\"\n", "\nassert remove_vowels(\"Python Programming\") == \"Pythn Prgrmmng\"\n", "\nassert remove_vowels(\"AEIOUaeiou\") == \"\"\n", "\nassert remove_vowels(\"abcdefghijklmnopqrstuvwxyz\") == \"bcdfghjklmnpqrstvwxyz\"\n", "\nassert remove_vowels(\"BCDFGHJKLMNPQRSTV... |
33cd90457ef82111e25eecfd35e0687e | [
{
"content": "On te donne un ensemble de données d'images, chacune contenant un ensemble de boîtes englobantes autour d'objets d'intérêt. Chaque boîte englobante est représentée comme un tuple à 4 éléments `(x1, y1, x2, y2)`, où `(x1, y1)` est la coordonnée supérieure gauche et `(x2, y2)` est la coordonnée infé... | ["\nassert random_pixel_sampler([(1, 1, 5, 5)], 1)[0][0] == 0\n", "\nassert random_pixel_sampler([(1, 1, 5, 5)], 1)[0][1] in range(1, 5)\n", "\nassert random_pixel_sampler([(1, 1, 5, 5)], 1)[0][2] in range(1, 5)\n", "\nassert random_pixel_sampler([(1, 1, 5, 5), (2, 2, 6, 6)], 1)[0][1] in range(2, 6)\n", "\nassert rando... |
4b44d5334457727a208f1c08a3499019 | [
{
"content": "On te donne un tableau 3D de points de données, où les deux premières dimensions représentent les coordonnées x et y, et la troisième dimension représente la coordonnée z. Ta tâche est de mettre en œuvre une fonction `surface_plot` qui génère un graphique de surface 3D de ces données en utilisant ... | ["\nassert isinstance(surface_plot(np.array([0, 1]), np.array([0, 1]), np.array([[0, 1], [1, 0]]), plt.figure().add_subplot(111, projection='3d')), plt.collections.PolyCollection)\n", "\nassert isinstance(surface_plot(np.array([0, 1, 2]), np.array([0, 1, 2]), np.array([[0, 1, 2], [1, 0, 1], [2, 1, 0]]), plt.figure().ad... |
ba1eb68715d1cf4e6ea9a5fde5bf096c | [
{
"content": "Tu développes un outil en ligne de commande nommé `ftmgr` pour des transferts de fichiers efficaces et sécurisés entre différents systèmes de stockage. L'outil doit prendre en charge les fonctionnalités suivantes :\n\n- **Spécifier les systèmes de stockage source et de destination** à l'aide d'arg... | ["\nassert compress_file(\"test.txt\", \"test.txt.gz\") is None\n", "\nassert decompress_file(\"test.txt.gz\", \"test_decompressed.txt\") is None\n", "\nassert os.path.exists(\"test.txt.gz\") == True\n", "\nassert os.path.exists(\"test_decompressed.txt\") == True\n", "\nassert open(\"test.txt\").read() == open(\"test_d... |
fbb01ee3061776e2cf69ddcf93005f75 | [
{
"content": "On te donne un arbre binaire où chaque nœud contient un seul chiffre (0-9). Ta tâche est de calculer la somme de tous les nombres formés en parcourant de la racine à chaque nœud feuille. Chaque nombre est construit en concaténant les chiffres rencontrés le long du chemin de la racine à la feuille.... | ["\nassert sumNumbers(TreeNode(1, TreeNode(2), TreeNode(3))) == 25\n", "\nassert sumNumbers(TreeNode(4, TreeNode(9, TreeNode(5), TreeNode(1)), TreeNode(0))) == 1026\n", "\nassert sumNumbers(TreeNode(0)) == 0\n", "\nassert sumNumbers(TreeNode(1, TreeNode(0), TreeNode(1))) == 21\n", "\nassert sumNumbers(TreeNode(1, TreeN... |
e03d1f22c5887839bf35ebe77df7e935 | [
{
"content": "On te donne une chaîne de caractères `S` et une liste de commandes `C`. Chaque commande est un tuple `(i, c)` où `i` est un index dans la chaîne et `c` est un caractère. Ta tâche est d'appliquer chaque commande dans l'ordre où elles apparaissent, en insérant le caractère `c` à l'index spécifié `i`... | ["\nassert apply_commands(\"hello\", [(1, 'a')]) == \"haello\"\n", "\nassert apply_commands(\"world\", [(0, 'x')]) == \"xworld\"\n", "\nassert apply_commands(\"test\", [(4, '!')]) == \"test!\"\n", "\nassert apply_commands(\"python\", [(3, 'z'), (5, 'y')]) == \"pythzony\"\n", "\nassert apply_commands(\"abc\", [(0, 'a'),... |
d4d7b89da0970fd40de1b8496dd480bb | [
{
"content": "On te donne une chaîne de caractères représentant une URL. Ta tâche est d'écrire une fonction Python qui extrait les paramètres de requête de l'URL et les renvoie sous forme de dictionnaire. Chaque clé du dictionnaire doit correspondre à un nom de paramètre, et chaque valeur doit être la valeur co... | ["\nassert get_query_params(\"http://example.com/?name=John\") == {\"name\": \"John\"}\n", "\nassert get_query_params(\"https://example.com/?name=John&age=30\") == {\"name\": \"John\", \"age\": \"30\"}\n", "\nassert get_query_params(\"http://example.com/?name=John+Doe\") == {\"name\": \"John Doe\"}\n", "\nassert get_qu... |
73b1a3cd3168c91d4db73cbce2595af7 | [
{
"content": "On te donne une liste de nombres premiers, `prime_list`, et une liste d'entiers `queries`. Ta tâche est de déterminer pour chaque entier dans `queries` s'il s'agit d'un nombre premier. Tu dois utiliser la `prime_list` fournie pour optimiser ta solution. La fonction doit renvoyer une liste de valeu... | ["\nassert is_prime_optimized([2, 3, 5, 7, 11], [2, 3, 5, 7, 11]) == [True, True, True, True, True]\n", "\nassert is_prime_optimized([4, 6, 8, 9, 10], [2, 3, 5, 7, 11]) == [False, False, False, False, False]\n", "\nassert is_prime_optimized([13, 17, 19, 23, 29], [2, 3, 5, 7, 11]) == [True, True, True, True, True]\n", "... |
9fb096fe0db7747a7c2d6102bbec3453 | [
{
"content": "On te donne une matrice carrée de taille `n x n` où `1 ≤ n ≤ 5`. Ta tâche est de calculer la somme de tous les mineurs de la matrice. Un mineur d'un élément de la matrice est le déterminant de la sous-matrice formée en supprimant la ligne et la colonne contenant cet élément. Tu dois implémenter ce... | ["\nassert matrix_minor_sum([[1]]) == 0\n", "\nassert matrix_minor_sum([[1, 2], [3, 4]]) == 0\n", "\nassert matrix_minor_sum([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 0\n", "\nassert matrix_minor_sum([[2, 3], [1, 4]]) == 5\n", "\nassert matrix_minor_sum([[5, 7], [3, 6]]) == 9\n", "\nassert matrix_minor_sum([[1, 0, 0], [0, ... |
b642c1f550bedb441e7be48e8dd3ed17 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, triés par ordre décroissant. La fonction doit être suffisamment efficace pour gérer des listes contenant jusqu'à 10^6 éléments.\n... | ["\nassert unique_sorted_descending([4, 2, 7, 3, 2, 4, 8, 1, 9, 7]) == [9, 8, 7, 4, 3, 2, 1]\n", "\nassert unique_sorted_descending([1, 1, 1, 1, 1]) == [1]\n", "\nassert unique_sorted_descending([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n", "\nassert unique_sorted_descending([]) == []\n", "\na... |
13a7a0ffcf6121e6b447551e2d3bc00c | [
{
"content": "On te donne une chaîne de caractères `text` qui peut contenir du formatage Markdown. Ta tâche est de mettre en œuvre une fonction `count_unique_words` qui renvoie le nombre de mots uniques dans la chaîne `text`. Les mots sont définis comme des séquences de caractères alphanumériques séparées par d... | ["\nassert count_unique_words(\"This is a *test* text with _Markdown_ formatting and a [link](http://example.com).\") == 10\n", "\nassert count_unique_words(\"Hello, world!\") == 2\n", "\nassert count_unique_words(\"Hello, hello, HELLO!\") == 3\n", "\nassert count_unique_words(\"One [link](http://example.com) and anoth... |
237196b13ef59f84c55cff2993c1dc53 | [
{
"content": "On te donne trois dictionnaires, `dict1`, `dict2` et `dict3`, qui peuvent contenir des dictionnaires imbriqués. Ta tâche est de mettre en œuvre la fonction `merge_and_filter` qui effectue les opérations suivantes :\n\n1. Fusionne `dict1` et `dict2` dans un nouveau dictionnaire `merged_dict`. Si un... | ["\nassert merge_and_filter({}, {}, {}) == {}\n", "\nassert merge_and_filter({'a': 1}, {'b': 2}, {'a': 3}) == {'a': 1}\n", "\nassert merge_and_filter({'a': 1}, {'a': 2}, {'a': 3}) == {'a': 2}\n", "\nassert merge_and_filter({'a': {'b': 1}}, {'a': {'b': 2}}, {'a': {'b': 3}}) == {'a': {'b': 2}}\n", "\nassert merge_and_fil... |
28ef26e5aa5bf0a587efd85af8a92027 | [
{
"content": "Dans un espace à 4 dimensions, on te donne deux quaternions représentés comme des listes de quatre composantes chacune. Ta tâche est de calculer la Distance Quaternion entre ces deux quaternions. La Distance Quaternion est définie comme l'angle θ entre les quaternions, calculé en utilisant la form... | ["\nassert quaternion_distance([1, 0, 0, 0], [1, 0, 0, 0]) == 0.0\n", "\nassert quaternion_distance([1, 0, 0, 0], [-1, 0, 0, 0]) == math.pi\n", "\nassert quaternion_distance([0, 1, 0, 0], [0, 0, 1, 0]) == math.pi / 2\n", "\nassert quaternion_distance([0.7071, 0.7071, 0, 0], [0.7071, -0.7071, 0, 0]) == math.pi / 2\n", "... |
9216695f0185eacc3c1844f023ca2dc9 | [
{
"content": "On te donne une grille 3D où chaque cellule est définie par ses coordonnées (x, y, z). Chaque cellule contient un cube avec six faces. Ta tâche est de déterminer l'orientation des faces verticales du cube, qui sont parallèles à l'axe y. L'orientation est déterminée par la règle suivante : si la so... | ["\nassert face_direction(1, 1, 1) == \"Downward\"\n", "\nassert face_direction(2, 2, 2) == \"Upward\"\n", "\nassert face_direction(3, 3, 3) == \"Downward\"\n", "\nassert face_direction(4, 4, 4) == \"Upward\"\n", "\nassert face_direction(1, 0, 0) == \"Upward\"\n", "\nassert face_direction(1, 1, 0) == \"Downward\"\n", "... |
e79d8bca9c4ad413d513d148b4652a7f | [
{
"content": "Tu es un astronome analysant des données photométriques provenant d'une observation récente. Les données incluent des magnitudes dans les bandes \"g\", \"r\" et \"i\" pour plusieurs étoiles, qui ont été affectées par l'extinction due à la poussière interstellaire. Pour corriger cela, tu dois appli... | ["\nassert apply_schlafly_dereddening({'star1': {'g': 22.0, 'r': 21.5, 'i': 21.0}}, {'star1': 0.1}, 3.1) == {'star1': {'g': 21.6207, 'r': 21.3018, 'i': 21.0047}}\n", "\nassert apply_schlafly_dereddening({'star1': {'g': 22.0, 'r': 21.5, 'i': 21.0}}, {'star1': 0.0}, 3.1) == {'star1': {'g': 22.0, 'r': 21.5, 'i': 21.0}}\n"... |
3533379518d01e6f517c770f9db307c8 | [
{
"content": "On te donne une représentation d'un automate à états finis (AEF) sous forme de dictionnaire. Les clés du dictionnaire sont les états de l'AEF, et les valeurs sont des listes de transitions à partir de chaque état. Chaque transition est un tuple constitué d'une étiquette d'entrée et d'un état suiva... | ["\nassert is_deterministic_fsa({'q0': [('a', 'q1'), ('b', 'q2')], 'q1': [('a', 'q0')], 'q2': []}) == True\n", "\nassert is_deterministic_fsa({'q0': [('a', 'q1'), ('a', 'q2')], 'q1': [('b', 'q0')], 'q2': []}) == False\n", "\nassert is_deterministic_fsa({'q0': [('a', 'q1')], 'q1': [('a', 'q0'), ('a', 'q2')], 'q2': []}) ... |
20e36099d330f4dddab6164a7f516e82 | [
{
"content": "On te donne un nombre `n` qui peut être un entier ou un nombre à virgule flottante. Ta tâche est d'écrire une fonction `adjust_array_size(n)` qui renvoie le plus petit entier impair `m` tel que `m` est supérieur ou égal au plafond de `n`.\n\n**Contraintes :**\n- `1 <= n <= 10^9`\n\n**Exemples :**\... | ["\nassert adjust_array_size(10) == 11\n", "\nassert adjust_array_size(15) == 15\n", "\nassert adjust_array_size(10.2) == 11\n", "\nassert adjust_array_size(15.7) == 17\n", "\nassert adjust_array_size(0) == 1\n", "\nassert adjust_array_size(-1) == -1\n", "\nassert adjust_array_size(-2) == -1\n", "\nassert adjust_array_... |
0a1459489e4a7bca8e8d0e2547611e21 | [
{
"content": "On te donne la tâche de concevoir un décorateur Python nommé `log_decorator` qui améliore toute méthode avec des capacités de journalisation. Le décorateur doit accepter un nombre variable de messages de journalisation en tant qu'arguments et ajouter ces messages à un fichier journal chaque fois q... | ["\nassert test_instance.log_file == [\"Method called\", \"Processing data\"]\n", "\nassert result == \"Example data\"\n", "\nassert test_instance_file.log_file == \"log.txt\"\n", "\nassert result_file == \"Example data\"\n", "\nassert os.path.exists(\"log.txt\")\n", "\nwith open(\"log.txt\", 'r') as file:\n log_con... |
1e39fc4af0a3aff11f893ae7482062e3 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `count_words(text)` qui renvoie un dictionnaire avec la fréquence de chaque mot dans le texte. Les mots doivent être convertis en minuscules, et toute la ponctuation doit être ignorée.\n\n**Entrée :**\n- Une s... | ["\nassert count_words(\"Hello, world! Hello, Python.\") == {'hello': 2, 'world': 1, 'python': 1}\n", "\nassert count_words(\"This is a test. This test is only a test.\") == {'this': 2, 'is': 2, 'a': 2, 'test': 3, 'only': 1}\n", "\nassert count_words(\"One fish, two fish, red fish, blue fish.\") == {'one': 1, 'fish': 4... |
b769cc7d636edd8fdf29d4be27bd4530 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_second_largest(numbers: list)` qui renvoie le deuxième entier distinct le plus grand de la liste. Si la liste contient moins de deux entiers distincts, la fonction doit renvoyer `None`. Ta solution doit gérer effica... | ["\nassert find_second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert find_second_largest([5, 1, 4, 3, 2]) == 4\n", "\nassert find_second_largest([2, 2, 3, 3, 4, 4]) == 3\n", "\nassert find_second_largest([1]) == None\n", "\nassert find_second_largest([]) == None\n", "\nassert find_second_largest([7, 7, 7, 7]) == None\n",... |
ef49f49b84df58aee0f3fa46ea657eb4 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python `find_prime_factors` qui calcule et renvoie une liste des facteurs premiers du produit de tous les entiers de la liste. Si la liste est vide, la fonction doit renvoyer une liste vide.\n\n**Entrée :**\n- Une liste d'entiers ... | ["\nassert find_prime_factors([6, 10, 15]) == [2, 2, 3, 3, 5, 5]\n", "\nassert find_prime_factors([2, 3, 5]) == [2, 3, 5]\n", "\nassert find_prime_factors([4, 6, 8]) == [2, 2, 2, 2, 3]\n", "\nassert find_prime_factors([7, 11, 13]) == [7, 11, 13]\n", "\nassert find_prime_factors([1, 1, 1]) == []\n", "\nassert find_prime... |
6b8871a3f1bcfed238f679968552ee99 | [
{
"content": "Dans le jeu \"Isolation\", deux joueurs jouent à tour de rôle en déplaçant une seule pièce sur un plateau de `n x n`, dans le but de bloquer l'adversaire de faire un mouvement légal. Le jeu se termine lorsqu'un joueur est incapable de bouger, et l'autre joueur est déclaré vainqueur. Ta tâche est d... | ["\nassert custom_score_3(game, game.__player_1__) == float(\"inf\") if game.is_winner(game.__player_1__) else True\n", "\nassert custom_score_3(game, game.__player_2__) == float(\"-inf\") if game.is_loser(game.__player_2__) else True\n", "\nassert custom_score_3(game, game.__player_1__) == float(\"-inf\") if game.is_l... |
93fb5c4b45e278b3bb53764f19e395f6 | [
{
"content": "On te donne une grille 2D de taille N x M, où chaque cellule contient un entier unique de 1 à N*M. Ta tâche est de concevoir une fonction de hachage qui mappe chaque cellule à un index unique dans une table de hachage de taille B, où B est un nombre premier et B < N*M. La fonction doit être suffis... | ["\nassert hash_function(0, 0, 3, 3, 5) == 0\n", "\nassert hash_function(0, 1, 3, 3, 5) == 1\n", "\nassert hash_function(0, 2, 3, 3, 5) == 2\n", "\nassert hash_function(1, 0, 3, 3, 5) == 3\n", "\nassert hash_function(1, 1, 3, 3, 5) == 4\n", "\nassert hash_function(1, 2, 3, 3, 5) == 0\n", "\nassert hash_function(2, 0, 3... |
cbd18f975dad79654267dbed14a9ceb1 | [
{
"content": "On te donne un tableau trié `arr` de `n` entiers distincts et un entier cible `x`. Ta tâche est de mettre en œuvre une fonction `binary_search(arr, x)` qui renvoie l'index de `x` dans `arr` s'il existe, sinon renvoie `-1`.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5),... | ["\nassert binary_search([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 7) == 6\n", "\nassert binary_search([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10) == 9\n", "\nassert binary_search([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5, 6,... |
fa31365dfed10decaf0619dfdcb28c6c | [
{
"content": "On te donne une liste d'éléments uniques. Ta tâche est de générer toutes les combinaisons possibles de ces éléments dans un ordre spécifique. L'ordre est le suivant :\n\n1. Générer toutes les combinaisons de longueur 1.\n2. Générer toutes les combinaisons de longueur 2.\n3. Continuer ce schéma jus... | ["\nassert ordered_combinations([1, 2, 3]) == [(1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]\n", "\nassert ordered_combinations([4, 5]) == [(4,), (5,), (4, 5)]\n", "\nassert ordered_combinations([7]) == [(7,)]\n", "\nassert ordered_combinations([]) == []\n", "\nassert ordered_combinations(['a', 'b', 'c']) == [('... |
b4caa5368e9e01e9c3ad03d10a11cfd4 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui convertit cette chaîne en une liste de tuples. Chaque tuple doit contenir un mot de la chaîne et sa longueur correspondante. Toute la ponctuation dans la chaîne doit être ignorée.\n\n**Entrée :**\n- Une seule chaîne d... | ["\nassert string_to_word_length_tuples(\"Hello, world!\") == [(\"Hello\", 5), (\"world\", 5)]\n", "\nassert string_to_word_length_tuples(\"Python is fun.\") == [(\"Python\", 6), (\"is\", 2), (\"fun\", 3)]\n", "\nassert string_to_word_length_tuples(\"A quick brown fox.\") == [(\"A\", 1), (\"quick\", 5), (\"brown\", 5),... |
19f5aa998f565373bb5e485d8dfbcc16 | [
{
"content": "Étant donné deux chaînes de caractères `str1` et `str2`, et un entier positif `min_length`, détermine la longueur du suffixe le plus long de `str1` qui correspond à un préfixe de `str2`, qui est d'au moins `min_length` caractères et qui ne contient pas de caractères répétés. Si aucune paire suffix... | ["\nassert longest_unique_suffix_prefix(\"abcdefg\", \"defghij\", 3) == 0\n", "\nassert longest_unique_suffix_prefix(\"abcde\", \"cdefg\", 2) == 2\n", "\nassert longest_unique_suffix_prefix(\"abcde\", \"cdefg\", 3) == 0\n", "\nassert longest_unique_suffix_prefix(\"abcde\", \"bcdef\", 2) == 2\n", "\nassert longest_uniqu... |
ae150ab789c855afe528158e6315f66e | [
{
"content": "On te donne une fonction `f(x) = 1 - x^2` définie pour `-1 <= x <= 1`. Ta tâche est de calculer la somme de `f(x)` pour un ensemble spécifique de valeurs de `x`. L'ensemble des valeurs de `x` est déterminé par une liste de `n` entiers. Chaque entier `i` (1 ≤ i ≤ n) dans la liste indique combien de... | ["\nassert sum_of_function_values(1, [1]) == 0.0\n", "\nassert sum_of_function_values(2, [1, 1]) == 1.0\n", "\nassert sum_of_function_values(3, [1, 2, 0]) == 1.5\n", "\nassert sum_of_function_values(4, [0, 0, 0, 0]) == 0.0\n", "\nassert sum_of_function_values(5, [1, 1, 1, 1, 1]) == 2.5\n", "\nassert sum_of_function_val... |
f8840b3acebc1614a7e59c9610830989 | [
{
"content": "Implémente une classe `Stack` en Python qui supporte les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et retourne l'élément au sommet de la pile. Si la pile est vide, lève une exception `IndexError` avec le message \"pop from empty stack\".... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().push(1) is None\n", "\nassert Stack().push(1) or Stack().pop() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.pop() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s... |
a874e60275d17700204cb7546b0d2fae | [
{
"content": "On te donne une liste d'identifiants de processus (PIDs) et un délai d'attente maximal en secondes. Ta tâche est d'identifier et de renvoyer un ensemble de PIDs qui correspondent aux processus zombies. Un processus est considéré comme un zombie si son état dans le fichier `/proc/[pid]/status` est ... | ["\nassert find_zombie_processes([], 1) == set()\n", "\nassert find_zombie_processes([1, 2, 3], 0) == set()\n", "\nassert find_zombie_processes([999999999], 1) == set()\n", "\nassert find_zombie_processes([1, 2, 3, 4, 5], 1) == set() # Assuming no zombie processes are running with these PIDs\n", "\nassert find_zombie_... |
7f7fbe070042720312809b9cbe871180 | [
{
"content": "Tu es chargé d'implémenter une classe `Circle` en Python. La classe doit avoir un constructeur qui initialise le rayon du cercle avec une valeur par défaut de 1.0. La classe doit inclure les méthodes suivantes :\n\n- `area()` : Cette méthode doit calculer et renvoyer l'aire du cercle.\n- `circumfe... | ["\nassert Circle().area() == math.pi\n", "\nassert Circle(0).area() == 0\n", "\nassert Circle(2).area() == 4 * math.pi\n", "\nassert Circle().circumference() == 2 * math.pi\n", "\nassert Circle(0).circumference() == 0\n", "\nassert Circle(5).circumference() == 10 * math.pi\n", "\nassert Circle().diameter() == 2\n", "\... |
6721337e361737715e90265703bb81df | [
{
"content": "On te demande d'implémenter une fonction `is_valid_hex_id` qui détermine si une chaîne de caractères donnée est un identifiant hexadécimal valide. Un identifiant hexadécimal valide doit satisfaire les critères suivants :\n\n1. La chaîne n'est pas vide.\n2. La chaîne est composée exactement de 16 c... | ["\nassert is_valid_hex_id(\"1a2b3c4d5e6f7890\") == True\n", "\nassert is_valid_hex_id(\"1a2b3c4d5e6f789g\") == False\n", "\nassert is_valid_hex_id(\"1234567890abcdef\") == True\n", "\nassert is_valid_hex_id(\"1234567890abcde\") == False\n", "\nassert is_valid_hex_id(\"0000000000000000\") == False\n", "\nassert is_vali... |
19af6ba4df9e0e04cdf7277bd9a1d278 | [
{
"content": "Implémente une fonction `traffic_light(t, duration=1., gap=1.)` qui simule un système de feux de signalisation. La fonction doit renvoyer l'état du feu de signalisation (\"Green\" ou \"Red\") à un moment donné `t` (en secondes). Le feu de signalisation alterne entre les états \"Green\" et \"Red\",... | ["\nassert traffic_light(0) == \"Green\"\n", "\nassert traffic_light(0.5) == \"Green\"\n", "\nassert traffic_light(1) == \"Red\"\n", "\nassert traffic_light(1.5) == \"Red\"\n", "\nassert traffic_light(2) == \"Green\"\n", "\nassert traffic_light(2.5) == \"Green\"\n", "\nassert traffic_light(3) == \"Red\"\n", "\nassert t... |
512bf7b36dae6cd5f337dd9632d3a8e8 | [
{
"content": "On te demande d'implémenter une fonction `rotate_file(filename, text)` qui manipule le contenu d'un fichier. La fonction doit prendre en charge l'ajout de plusieurs chaînes de caractères au fichier en un seul appel, la suppression de la première ligne après tous les ajouts, et la création du fichi... | ["\nassert rotate_file(\"test.txt\", \"hello\") == 6\n", "\nassert rotate_file(\"test.txt\", [\"world\", \"again\"]) == 12\n", "\nassert rotate_file(\"test.txt\", [\"line1\", \"line2\", \"line3\"]) == 18\n", "\nassert rotate_file(\"newfile.txt\", \"single\") == 7\n", "\nassert rotate_file(\"emptyfile.txt\", \"\") == 1\... |
fe420b4a748105e81607b58185978cd6 | [
{
"content": "On te donne un dictionnaire `category_dict` où chaque clé représente une catégorie et chaque valeur est une liste d'éléments qui appartiennent à cette catégorie. Ta tâche est de créer une fonction `invert_dict` qui renvoie un nouveau dictionnaire `item_dict` où chaque clé est un élément et chaque ... | ["\nassert invert_dict({\"Fruits\": [\"Apple\", \"Banana\", \"Cherry\"], \"Vegetables\": [\"Carrot\", \"Broccoli\", \"Cucumber\"], \"Berries\": [\"Blueberry\", \"Strawberry\", \"Cherry\"]}) == {\"Apple\": [\"Fruits\"], \"Banana\": [\"Fruits\"], \"Cherry\": [\"Fruits\", \"Berries\"], \"Carrot\": [\"Vegetables\"], \"Broc... |
e5f4f5a02f0db80cda630e669773cd8b | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme un tuple de ses coordonnées x et y. Ta tâche est de trouver la paire de points la plus proche et de renvoyer la distance euclidienne entre eux. La distance euclidienne entre deux points `(x1, y1)` et `(x2, y2... | ["\nassert find_closest_pair([(0, 0), (1, 1)]) == math.sqrt(2)\n", "\nassert find_closest_pair([(0, 0), (1, 0), (2, 0)]) == 1.0\n", "\nassert find_closest_pair([(0, 0), (0, 1), (0, 2)]) == 1.0\n", "\nassert find_closest_pair([(1, 2), (3, 4), (5, 6), (7, 8)]) == math.sqrt(8)\n", "\nassert find_closest_pair([(1, 1), (1, ... |
837551dac7a12307970c722d1920de00 | [
{
"content": "On te demande d'écrire un programme Python pour calculer la suite de Fibonacci jusqu'au nième terme en utilisant la récursion. Ton programme doit lire un entier `n` depuis l'entrée standard, qui représente le nombre de termes de la suite de Fibonacci à générer. Le programme doit afficher la suite ... | ["\nassert generate_fibonacci_sequence(1) == [0]\n", "\nassert generate_fibonacci_sequence(2) == [0, 1]\n", "\nassert generate_fibonacci_sequence(3) == [0, 1, 1]\n", "\nassert generate_fibonacci_sequence(4) == [0, 1, 1, 2]\n", "\nassert generate_fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert generate_fibonacci_... |
ce5e267e703dc7f69fa7963e38a92cb2 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour calculer le nième nombre de Fibonacci. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Pour optimiser ta solution, utilise la mémoïsation afin d'éviter les calculs redondants. Ta foncti... | ["\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... |
67234171d95c8eaa2b0d1ed0343e23f8 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python. La classe doit avoir les attributs suivants : `make`, `model`, `year` et `mileage`. Ton implémentation doit inclure les méthodes suivantes :\n\n- `__init__(self, make, model, year, mileage)` : Initialise les attributs de la voiture.\n- `displ... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).make == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).model == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).year == 2020\n", "\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).mileage == 15000\n", "\ncar = Car(\"Honda\", \... |
792bd60999575e5c2f075e041326f9ad | [
{
"content": "On te demande d'implémenter une classe Python nommée `Employee` pour gérer les données des employés. La classe doit avoir les attributs suivants : `name`, `employee_id`, `department` et `salary`. Le constructeur doit initialiser ces attributs. De plus, la classe doit inclure deux méthodes :\n- `ca... | ["\nassert Employee(\"John Doe\", 12345, \"Engineering\", 75000).calculate_bonus() == 7500.0\n", "\nassert Employee(\"Jane Smith\", 67890, \"HR\", 50000).calculate_bonus() == 5000.0\n", "\nassert Employee(\"Alice Johnson\", 11223, \"Marketing\", 60000).calculate_bonus() == 6000.0\n", "\nassert Employee(\"Bob Brown\", 4... |
345058dbfc7098d9a4681dac470fedc8 | [
{
"content": "On te donne une image en niveaux de gris représentée comme un tenseur PyTorch `x` avec des valeurs de pixels allant de 0 à 255. Ta tâche est de mettre en œuvre une fonction `add_uniform_noise_and_rescale(x)` qui ajoute un bruit uniforme dans la plage [-10, 10] à l'image, puis remet à l'échelle les... | ["\nassert torch.all(add_uniform_noise_and_rescale(torch.tensor([0, 255], dtype=torch.uint8)) >= 0)\n", "\nassert torch.all(add_uniform_noise_and_rescale(torch.tensor([0, 255], dtype=torch.uint8)) <= 255)\n", "\nassert add_uniform_noise_and_rescale(torch.tensor([128], dtype=torch.uint8)).dtype == torch.uint8\n", "\nass... |
738c090a124a7c26679b682a8e213477 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la plus longue sous-séquence strictement croissante dans cette liste. La sous-séquence doit avoir la longueur maximale possible. Par exemple, étant donné la liste `[10, 9, 2, 5, 3, 7, 101, 18]`, la plus longue sous-séquence croissante est `[... | ["\nassert longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]) == [2, 3, 7, 101]\n", "\nassert longest_increasing_subsequence([0, 1, 0, 3, 2, 3]) == [0, 1, 2, 3]\n", "\nassert longest_increasing_subsequence([7, 7, 7, 7, 7, 7, 7]) == [7]\n", "\nassert longest_increasing_subsequence([1, 2, 3, 4, 5]) == [1, 2, 3,... |
c0b723c75116a2b4e58fbc4472d0c2e2 | [
{
"content": "On te demande d'écrire une fonction `NormalizeLogMessages` qui traite une chaîne de messages de journal provenant d'un programme exécuté sur différents systèmes d'exploitation. Chaque message de journal peut utiliser différents marqueurs pour les erreurs, les avertissements et les messages de succ... | ["\nassert NormalizeLogMessages(\"error: critical issue\") == \"Failure\\n critical issue\"\n", "\nassert NormalizeLogMessages(\"warning: important notice\") == \"Caution\\n important notice\"\n", "\nassert NormalizeLogMessages(\"success: successful operation\") == \"Triumph\\n successful operation\"\n", "\nassert Norm... |
d0a6863059cb2730cf900fe1a3b4e4cd | [
{
"content": "On te donne un tableau `nums` contenant `n` nombres distincts pris dans la plage de `0` à `n`. Ta tâche est de trouver le nombre qui manque dans le tableau. Le tableau n'est pas trié et ne contient pas de doublons autres que le nombre manquant.\n\n**Entrée :**\n- La première ligne contient un enti... | ["\nassert find_missing_number([3, 0, 1]) == 2\n", "\nassert find_missing_number([9, 6, 4, 2, 3, 5, 7, 0, 1]) == 8\n", "\nassert find_missing_number([0]) == 1\n", "\nassert find_missing_number([1]) == 0\n", "\nassert find_missing_number([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, ... |
20b733edfb7deb271212949322d004ee | [
{
"content": "Tu es chargé d'implémenter une fonction `parse_input` qui traite des données d'entrée qui peuvent être soit une chaîne de caractères, soit un objet fichier. La fonction doit gérer les cas suivants :\n\n1. **Entrée de type chaîne de caractères** : Si l'entrée est une chaîne de caractères, renvoie l... | ["\nassert parse_input(\"Hello, World!\") == \"Hello World\"\n", "\nassert parse_input(\"No punctuation\") == \"No punctuation\"\n", "\nassert parse_input(\"!@#$%^&*()\") == \"\"\n", "\nassert parse_input(12345) == None\n", "\nassert parse_input(None) == None\n", "\nassert parse_input(b\"Hello, World!\") == b\"Hello Wo... |
81eabb587c50747540dc5781359e4e5a | [
{
"content": "On te donne un tableau non trié d'entiers. Ta tâche est de trouver le plus petit entier positif qui n'apparaît pas dans le tableau. L'algorithme que tu conçois doit fonctionner en temps O(n) et utiliser un espace supplémentaire de O(1).\n\n**Entrée :**\n- La première ligne contient un entier `n` (... | ["\nassert first_missing_positive([3, 4, -1, 1]) == 2\n", "\nassert first_missing_positive([1, 2, 0]) == 3\n", "\nassert first_missing_positive([7, 8, 9, 11, 12]) == 1\n", "\nassert first_missing_positive([1, 2, 3]) == 4\n", "\nassert first_missing_positive([0, -1, -2]) == 1\n", "\nassert first_missing_positive([1]) ==... |
03f196e1f9f2d299cc35a4f50ee1384a | [
{
"content": "On te donne une liste d'éléments distincts. Ta tâche est d'écrire une fonction Python qui génère toutes les combinaisons possibles de ces éléments. La fonction doit renvoyer une liste de tuples, où chaque tuple représente une combinaison unique des éléments. L'ordre des éléments dans chaque tuple ... | ["\nassert generate_combinations([1, 2, 3]) == [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]\n", "\nassert generate_combinations([]) == [()]\n", "\nassert generate_combinations([1]) == [(), (1,)]\n", "\nassert generate_combinations(['a', 'b']) == [(), ('a',), ('b',), ('a', 'b')]\n", "\nassert generate_combi... |
1c3d456bbd52898148cccaf64e20b906 | [
{
"content": "On te donne deux listes de mots : `vocablist` et `inputset`. Ta tâche est de créer une fonction `generate_vector_representation` qui génère une représentation vectorielle de `inputset` basée sur `vocablist`. Le vecteur doit être une liste d'entiers de la même longueur que `vocablist`. Chaque indic... | ["\nassert generate_vector_representation([\"apple\", \"banana\", \"cherry\"], [\"Apple\", \"banana\", \"Cherry\", \"apple\"]) == [2, 1, 1]\n", "\nassert generate_vector_representation([\"dog\", \"cat\", \"mouse\"], [\"Dog\", \"Cat\", \"Mouse\", \"elephant\"]) == [1, 1, 1]\n", "\nassert generate_vector_representation([... |
614cbedaef586ce2a1dca3f7fc9e59b4 | [
{
"content": "On te donne la racine d'un arbre de recherche binaire (BST) avec `n` nœuds. Ta tâche est d'implémenter une fonction `kth_smallest` qui renvoie le k-ième plus petit élément dans le BST. La fonction doit avoir une complexité temporelle de O(h + k), où `h` est la hauteur de l'arbre. Suppose que `1 ≤ ... | ["\nassert kth_smallest(root, 1) == 1\n", "\nassert kth_smallest(root, 2) == 2\n", "\nassert kth_smallest(root, 3) == 3\n", "\nassert kth_smallest(root, 4) == 4\n", "\nassert kth_smallest(root, 5) == 5\n", "\nassert kth_smallest(root, 6) == 6\n", "\nassert kth_smallest(TreeNode(10), 1) == 10\n", "\nassert kth_smallest(... |
5ffb7b946f886377ca7e63085001236f | [
{
"content": "On te donne une chaîne de caractères `sequence` représentant une séquence d'ADN. Ta tâche est d'implémenter deux fonctions :\n\n1. `is_valid_dna(sequence)` : Cette fonction doit renvoyer `True` si la séquence est composée uniquement de nucléotides d'ADN valides ('A', 'T', 'C', 'G'), et `False` sin... | ["\nassert is_valid_dna(\"ATCG\") == True\n", "\nassert is_valid_dna(\"ATCX\") == False\n", "\nassert is_valid_dna(\"GCTA\") == True\n", "\nassert is_valid_dna(\"GCTAX\") == False\n", "\nassert is_valid_dna(\"\") == True\n", "\nassert reverse_complement(\"ATCG\") == \"CGAT\"\n", "\nassert reverse_complement(\"GCTA\") =... |
14cdb3d16aa8ae5093f0964bf5760fd6 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Dépôt** : Ajouter un montant spécifié au solde du compte. Le montant doit être supérieur à zéro ; sinon, lever une exc... | ["\nassert isinstance(BankAccount(\"John Doe\").account_number, int)\n", "\nassert len(str(BankAccount(\"John Doe\").account_number)) == 8\n", "\nassert BankAccount(\"John Doe\").account_holder == \"John Doe\"\n", "\naccount = BankAccount(\"Jane Smith\")\naccount.deposit(500)\nassert account.get_balance() == 500.0\n", ... |
a7e1550392fccf934f238f7aa0220501 | [
{
"content": "On te donne un message et un mot-clé. Ta tâche est de mettre en œuvre un chiffrement de César modifié qui utilise une séquence de nombres premiers dérivés du mot-clé pour chiffrer et déchiffrer le message. Le chiffrement et le déchiffrement doivent suivre ces règles :\n\n1. Convertis le mot-clé en... | ["\nassert encrypt(\"hello\", \"abc\") == \"hfnos\"\n", "\nassert decrypt(\"hfnos\", \"abc\") == \"hello\"\n", "\nassert encrypt(\"world\", \"xyz\") == \"zruog\"\n", "\nassert decrypt(\"zruog\", \"xyz\") == \"world\"\n", "\nassert encrypt(\"abc\", \"a\") == \"ace\"\n", "\nassert decrypt(\"ace\", \"a\") == \"abc\"\n", "... |
209ea5e52ef25b860e06dcd63e7ca73c | [
{
"content": "On te demande d'implémenter une simulation simple de machine à sous en Python. La machine à sous affiche trois symboles aléatoires choisis dans une liste prédéfinie. Le joueur gagne si les trois symboles sont identiques. Ton programme doit afficher les trois symboles et indiquer si le joueur a gag... | ["\nassert slot_machine.__name__ == \"slot_machine\"\n", "\nassert 'symbols' in slot_machine.__code__.co_varnames or 'symbols' in slot_machine.__code__.co_names\n", "\nassert 'random.choice' in slot_machine.__code__.co_names\n", "\nassert 'set(result)' in slot_machine.__code__.co_names or 'set(result)' in slot_machine.... |
c6ba01b62ff7d91f37e1a66b227a7e38 | [
{
"content": "On te donne un graphe orienté représenté par une liste d'arêtes, qui peut inclure des boucles et des arêtes dupliquées. Ta tâche est d'identifier et de renvoyer l'ensemble de tous les nœuds qui n'ont pas d'arêtes entrantes. La solution doit être efficace et capable de gérer de grands ensembles de ... | ["\nassert nodes_with_no_incoming_edges([(1, 2), (2, 3), (3, 4)]) == {1}\n", "\nassert nodes_with_no_incoming_edges([(1, 1), (2, 2), (3, 3)]) == set()\n", "\nassert nodes_with_no_incoming_edges([(1, 2), (3, 4), (5, 6), (7, 8)]) == {1, 3, 5, 7}\n", "\nassert nodes_with_no_incoming_edges([(1, 2), (2, 1)]) == set()\n", "\... |
e77c171b80fd5111d2c8922926b9c974 | [
{
"content": "On te demande d'implémenter une simulation simple d'un jeu de dés pour deux joueurs. Chaque joueur lance un dé à six faces, et le joueur avec le résultat le plus élevé gagne le tour. En cas d'égalité, aucun point n'est attribué pour ce tour. Le jeu consiste en un nombre spécifié de tours, et le jo... | ["\nassert play_round() in [(1, 0), (0, 1), (0, 0)]\n", "\nassert play_game(0) == None # No rounds, no scores to compare\n", "\nassert play_game(1) == None # Single round, checks if the function runs without errors\n", "\nassert play_game(10) == None # Multiple rounds, checks if the function runs without errors\n", ... |
020d87e2198743e094a4d5de4a538c5e | [
{
"content": "On te demande d'optimiser une fonction récursive pour calculer la factorielle d'un entier non négatif donné `n`. La fonction doit gérer efficacement plusieurs appels avec la même entrée en utilisant la mémoïsation. Implémente la fonction factorielle optimisée.\n\n**Entrée :**\n- Un seul entier `n`... | ["\nassert factorial_memoization(0) == 1\n", "\nassert factorial_memoization(1) == 1\n", "\nassert factorial_memoization(5) == 120\n", "\nassert factorial_memoization(6) == 720\n", "\nassert factorial_memoization(10) == 3628800\n", "\nassert factorial_memoization(15) == 1307674368000\n", "\nassert factorial_memoization... |
ac8262cd10cd56122a7dc3e5cea4c47b | [
{
"content": "On te donne un tenseur 2D `data` de forme `(n, m)` où chaque ligne représente un vecteur dans un espace à `m` dimensions. Ta tâche est d'implémenter une fonction `vector_magnitude(data, eps=0)` qui calcule la magnitude modifiée de chaque vecteur. La magnitude modifiée est définie comme la racine q... | ["\nassert torch.allclose(vector_magnitude(torch.tensor([[1, 2, 3]], dtype=torch.float32)), torch.tensor([3.6593], dtype=torch.float32))\n", "\nassert torch.allclose(vector_magnitude(torch.tensor([[0, 0, 0]], dtype=torch.float32)), torch.tensor([0.0000], dtype=torch.float32))\n", "\nassert torch.allclose(vector_magnitu... |
261bc952ff8543213cff5283d0a268bf | [
{
"content": "On te donne une liste d'entiers représentant les scores des élèves à un test. Ta tâche est de mettre en œuvre une fonction qui calcule et renvoie la moyenne, la médiane et le(s) mode(s) des scores. S'il y a plusieurs modes, renvoie-les tous dans une liste. Si tous les scores sont uniques, renvoie ... | ["\nassert calculate_statistics([88, 92, 80, 85, 92, 88, 80]) == (86.42857142857143, 88, [80, 88, 92])\n", "\nassert calculate_statistics([100, 100, 100]) == (100, 100, [100])\n", "\nassert calculate_statistics([1, 2, 3, 4, 5]) == (3, 3, [])\n", "\nassert calculate_statistics([5, 5, 5, 5, 5]) == (5, 5, [5])\n", "\nasse... |
46100d915471d45016dc5c888d518873 | [
{
"content": "On te donne un fichier texte nommé `data.txt` qui contient une liste d'entiers, chacun sur une nouvelle ligne. Ta tâche est d'écrire un script Python qui lit ces entiers, calcule leur moyenne et affiche la moyenne sur la console. Les entiers peuvent être positifs, négatifs ou nuls. Ton script doit... | ["\nassert calculate_average_from_file('data_single_positive.txt') == None # Assuming 'data_single_positive.txt' contains '5'\n", "\nassert calculate_average_from_file('data_single_negative.txt') == None # Assuming 'data_single_negative.txt' contains '-5'\n", "\nassert calculate_average_from_file('data_multiple_integ... |
7d072a710a14e08817813763c82788fd | [
{
"content": "On te donne un fichier texte contenant uniquement des lettres minuscules en anglais. Implémente une fonction `toggle_compression(file_path)` qui lit le fichier, bascule son contenu entre des états compressé et décompressé en utilisant l'encodage en longueur de série. Le schéma d'encodage en longue... | ["\nassert compress_file(\"test1.txt\") is None\n", "\nassert open(\"test1.txt\").read() == \"a3b3c3\" if open(\"test1.txt\").read() == \"aaabbbccc\" else open(\"test1.txt\").read() == \"aaabbbccc\"\n", "\nassert open(\"test2.txt\").read() == \"a1\" if open(\"test2.txt\").read() == \"a\" else open(\"test2.txt\").read()... |
f5c0878299f53e870b44fcd355a79c38 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome. Une chaîne est considérée comme un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche. Optimise la fonction pour réduire sa complexité temporelle.\n\n**Entrée :**... | ["\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"hello\") == False\n", "\nassert is_palindrome(\"a\") == True\n", "\nassert is_palindrome(\"abba\") == True\n", "\nassert is_palindrome(\"abcba\") == True\n", "\nassert is_palindrome(\"abc\") == False\n", "\nassert is_palindrome(\"\") == True\n"... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.