id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
29c52d447f5c393a0c4db97717f462cc | [
{
"content": "On te donne une chaîne JSON représentant un objet simple avec des paires clé-valeur. Ta tâche est d'écrire une fonction Python `extract_json_values` qui extrait et renvoie toutes les valeurs de la chaîne JSON dans une liste. La chaîne JSON ne contiendra que des types de données primitifs (chaînes ... | ["\nassert extract_json_values('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}') == [\"John\", 30, \"New York\"]\n", "\nassert extract_json_values('{\"a\": 1, \"b\": 2, \"c\": 3}') == [1, 2, 3]\n", "\nassert extract_json_values('{\"key\": \"value\"}') == [\"value\"]\n", "\nassert extract_json_values('{}') ==... |
fab833da3ca216cff2318c3c6af8c9aa | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres anglaises minuscules et majuscules. Ta tâche est de mettre en œuvre une fonction `count_vowels` qui renvoie le nombre de voyelles dans la chaîne. La fonction doit être insensible à la casse, en traitant les voyelles majuscules et minuscu... | ["\nassert count_vowels(\"Hello World!\") == 3\n", "\nassert count_vowels(\"This is a test string with vowels.\") == 11\n", "\nassert count_vowels(\"Python Programming\") == 4\n", "\nassert count_vowels(\"AEIOU\") == 5\n", "\nassert count_vowels(\"abcdefghijklmnopqrstuvwxyz\") == 5\n", "\nassert count_vowels(\"BCDFGHJK... |
179b654e31abe06c24054b17b3c14d2e | [
{
"content": "On te donne une liste triée d'entiers et un entier cible. Implémente une fonction pour effectuer une recherche binaire afin de trouver la cible dans la liste. Ta fonction doit renvoyer l'index de la cible si elle existe dans la liste, sinon renvoyer `-1`. La fonction doit gérer les cas où la liste... | ["\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], 0) == -1\n", "\nassert binary_search([1, 2, 3, 4, 5, 6... |
a5d99a67fff008c703bc51d0e8473aa7 | [
{
"content": "Dans un système calendaire fictif, les unités de temps sont définies comme suit :\n- 1 semaine = 13 jours\n- 1 jour = 28 heures\n- 1 heure = 60 minutes\n- 1 minute = 60 secondes\n\nOn te donne un entier positif `time` et une chaîne de caractères `unit` représentant l'unité de temps dans laquelle `... | ["\nassert convert_time(1, \"seconds\") == 0.0002777777777777778\n", "\nassert convert_time(1, \"minutes\") == 0.016666666666666666\n", "\nassert convert_time(1, \"hours\") == 1.0\n", "\nassert convert_time(1, \"days\") == 28.0\n", "\nassert convert_time(1, \"weeks\") == 364.0\n", "\nassert convert_time(60, \"seconds\"... |
90575d163d3ba236300999d0039e982e | [
{
"content": "On te demande de concevoir une API RESTful en utilisant Flask qui gère le statut des commandes stockées dans une base de données SQLite. L'API doit prendre en charge les opérations suivantes :\n\n1. **Récupérer les commandes** : Une requête GET vers `/orders` doit renvoyer un tableau JSON de toute... | ["\nassert get_orders().json == []\n", "\nupdate_order(1, \"shipped\")\nassert get_orders().json == [{'id': 1, 'status': 'shipped', 'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] # This will fail because the created_at timestamp will not match exactly\n", "\nupdate_order(2, \"pending\")\nassert get_orders... |
368d9a81bfef8e440b9e5a1ea38576ea | [
{
"content": "On te donne les résultats de plusieurs tests diagnostiques sous la forme de quatre tableaux : `A`, `B`, `C` et `D`. Chaque tableau a la même longueur, et chaque indice correspond aux résultats d'un test différent. Les tableaux représentent respectivement le nombre de vrais positifs, de faux positi... | ["\nassert calculate_diagnostic_metrics([10], [5], [2], [85]) == [(0.8333333333333334, 0.9411764705882353, 0.17241379310344827, 0.8260869565217391)]\n", "\nassert calculate_diagnostic_metrics([100, 50], [10, 20], [5, 10], [85, 115]) == [(0.9523809523809523, 0.8076923076923077, 0.9090909090909091, 0.5454545454545454), (... |
92c09b459dcbd912d671c5d2ccf4625a | [
{
"content": "On te donne un fichier CSV nommé `temperature_data.csv` contenant des relevés de température quotidiens. Chaque ligne du fichier CSV se compose de deux colonnes : `date` et `temperature`. La colonne `date` est formatée comme 'AAAA-MM-JJ'. Ta tâche est d'écrire une fonction Python `calculate_averag... | ["\nassert calculate_average_temperature('test_data_1.csv') == {'2022-01': 10.0, '2022-02': 15.0}\n", "\nassert calculate_average_temperature('test_data_2.csv') == {'2021-12': 5.0, '2022-01': 10.0, '2022-02': 15.0}\n", "\nassert calculate_average_temperature('test_data_3.csv') == {'2022-03': 20.0}\n", "\nassert calcula... |
e3ed8c851a27b05b317605c0ce02f61f | [
{
"content": "On te donne une série géométrique avec le premier terme `a = 1` et une raison commune `r = -0.5`. Ta tâche est de calculer la somme des `n` premiers termes de cette série, en excluant tout terme dont la valeur absolue est inférieure à `0.01`.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n ≤ 100), représe... | ["\nassert geometric_series_sum(1) == 1\n", "\nassert geometric_series_sum(2) == 0.5\n", "\nassert geometric_series_sum(3) == 0.25\n", "\nassert geometric_series_sum(4) == 0.375\n", "\nassert geometric_series_sum(5) == 0.3125\n", "\nassert geometric_series_sum(6) == 0.34375\n", "\nassert geometric_series_sum(7) == 0.33... |
696e0d1b166adf4491b3c8135b3c5043 | [
{
"content": "On te donne un entier non négatif `number`. Ta tâche est d'implémenter la fonction `count_binary_gaps(number)` en utilisant uniquement des opérations au niveau du bit, sans convertir le nombre en sa représentation sous forme de chaîne binaire. La fonction doit renvoyer la longueur de la plus longu... | ["\nassert count_binary_gaps(9) == 2\n", "\nassert count_binary_gaps(529) == 4\n", "\nassert count_binary_gaps(20) == 1\n", "\nassert count_binary_gaps(15) == 0\n", "\nassert count_binary_gaps(32) == 0\n", "\nassert count_binary_gaps(1041) == 5\n", "\nassert count_binary_gaps(0) == 0\n", "\nassert count_binary_gaps(1) ... |
4413ed00c2b03f20f28091b9334bbb1b | [
{
"content": "On te demande d'implémenter une classe `Calculator` en Python qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit également avoir une méthode pour réinitialiser la mémoire de la calculatrice à zéro. La mémoire de la calculat... | ["\nassert Calculator().add(5) == 5\n", "\nassert Calculator().subtract(5) == -5\n", "\nassert Calculator().multiply(5) == 0\n", "\nassert Calculator().divide(5) == 0\n", "\nassert Calculator().add(10).subtract(5).memory == 5\n", "\nassert Calculator().add(10).multiply(2).memory == 20\n", "\nassert Calculator().add(10)... |
f7170338f2a2bf54a2d66a870717e11e | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ta tâche est d'implémenter une fonction `count_vowels(words)` qui renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique de la liste au nombre de voyelles qu'il contient. Les voyelles sont définies comme 'a', 'e', 'i', 'o', ... | ["\nassert count_vowels([\"hello\", \"world\", \"python\", \"programming\"]) == {'hello': 2, 'world': 1, 'python': 1, 'programming': 3}\n", "\nassert count_vowels([\"\"]) == {'': 0}\n", "\nassert count_vowels([\"AEIOU\"]) == {'AEIOU': 5}\n", "\nassert count_vowels([\"bcdfg\"]) == {'bcdfg': 0}\n", "\nassert count_vowels... |
61ace7f8cac9ef216a048c9b16c4e898 | [
{
"content": "Tu participes à un concours de classification d'images. On t'a fourni un ensemble de données d'images et leurs étiquettes correspondantes. L'ensemble de données est stocké dans deux tableaux numpy distincts, `images` et `labels`, où `images` contient les valeurs de pixels des images et `labels` co... | ["\nassert split_dataset(np.array([[1, 2], [3, 4], [5, 6], [7, 8]]), np.array([0, 1, 0, 1]), 2)[0].shape == (2, 2)\n", "\nassert split_dataset(np.array([[1, 2], [3, 4], [5, 6], [7, 8]]), np.array([0, 1, 0, 1]), 2)[1].shape == (2, 2)\n", "\nassert split_dataset(np.array([[1, 2], [3, 4], [5, 6], [7, 8]]), np.array([0, 1,... |
248523d6c6b48618692f9c1c3e541095 | [
{
"content": "On te donne une température en Celsius. Ta tâche est d'écrire une fonction qui convertit cette température en Fahrenheit. La formule pour convertir Celsius en Fahrenheit est \\( F = C \\times \\frac{9}{5} + 32 \\).\n\n**Entrée :**\n- Un seul nombre à virgule flottante représentant la température e... | ["\nassert celsius_to_fahrenheit(0) == 32.0\n", "\nassert celsius_to_fahrenheit(100) == 212.0\n", "\nassert celsius_to_fahrenheit(-40) == -40.0\n", "\nassert celsius_to_fahrenheit(37) == 98.6\n", "\nassert celsius_to_fahrenheit(25) == 77.0\n", "\nassert celsius_to_fahrenheit(10) == 50.0\n", "\nassert celsius_to_fahrenh... |
3e26d085886f16d67a0a22da956374e7 | [
{
"content": "On te donne une chaîne de caractères `html` représentant un document HTML contenant exactement un tableau avec une structure simple utilisant les balises `<table>`, `<tr>` et `<td>`. Ta tâche est d'analyser ce HTML et de renvoyer une liste de listes, où chaque liste interne représente une ligne du... | ["\nassert parse_html_table(\"<table><tr><td>One</td><td>Two</td></tr></table>\") == [[\"One\", \"Two\"]]\n", "\nassert parse_html_table(\"<table><tr><td>First</td></tr><tr><td>Second</td></tr></table>\") == [[\"First\"], [\"Second\"]]\n", "\nassert parse_html_table(\"<table><tr><td>Alpha</td><td>Beta</td><td>Gamma</td... |
9ee823d1de88b2a14d22069815eb6809 | [
{
"content": "On te donne un dictionnaire `d` où chaque clé est une chaîne de caractères et chaque valeur est une liste d'entiers. On te fournit également une liste de clés `keys` et une chaîne de caractères `prefix`. Ta tâche est de construire un nouveau dictionnaire. Pour chaque clé dans `keys` qui existe dan... | ["\nassert prefix_values({'a': [1, 2], 'b': [3, 4]}, ['a'], 'pre_') == {'a': ['pre_1', 'pre_2'], 'b': [3, 4]}\n", "\nassert prefix_values({'x': [5, 6], 'y': [7, 8]}, ['x', 'y'], '') == {'x': ['5', '6'], 'y': ['7', '8']}\n", "\nassert prefix_values({'m': [9, 10], 'n': [11, 12]}, ['m'], 'test_') == {'m': ['test_9', 'test... |
d37a441eff69c4cff80d4b0369a1bfe6 | [
{
"content": "On te donne une chaîne de caractères représentant un bloc de code Python qui contient plusieurs boucles `for` imbriquées. Ta tâche est d'écrire une fonction qui exécute ce bloc de code. La chaîne d'entrée sera formatée de telle manière que chaque boucle soit correctement indentée et que le bloc de... | ["\nassert execute_nested_loops(\"for i in range(2):\\n print(i)\") == None\n", "\nassert execute_nested_loops(\"for i in range(2):\\n for j in range(2):\\n print(i, j)\") == None\n", "\nassert execute_nested_loops(\"for i in range(1):\\n for j in range(1):\\n for k in range(1):\\n pri... |
df7d21bd89d13e900cbe0e5f5cb36ad1 | [
{
"content": "Tu es chargé d'implémenter une classe Python pour représenter un nombre complexe sous la forme \\(a + bi\\). Ta classe doit prendre en charge les opérations arithmétiques suivantes : addition, soustraction, multiplication et division. Implémente les méthodes nécessaires pour effectuer ces opératio... | ["\nassert str(ComplexNumber(2, 3)) == \"2 + 3i\"\n", "\nassert str(ComplexNumber(0, 0)) == \"0 + 0i\"\n", "\nassert str(ComplexNumber(-1, -1)) == \"-1 + -1i\"\n", "\nassert str(ComplexNumber(2, 3) + ComplexNumber(5, 4)) == \"7 + 7i\"\n", "\nassert str(ComplexNumber(2, 3) - ComplexNumber(5, 4)) == \"-3 + -1i\"\n", "\na... |
9ea7c9417ed6647ec3aebb4fe30452b0 | [
{
"content": "On te donne une chaîne JSON représentant une structure imbriquée d'objets et de tableaux. Ta tâche est d'écrire une fonction Python `extract_keys` qui extrait récursivement toutes les clés de la chaîne JSON. La fonction doit renvoyer un ensemble de clés uniques trouvées dans la structure JSON. La ... | ["\nassert extract_keys('{\"name\": \"John\", \"age\": 30}') == {\"name\", \"age\"}\n", "\nassert extract_keys('{\"person\": {\"name\": \"John\", \"age\": 30}}') == {\"person\", \"name\", \"age\"}\n", "\nassert extract_keys('{\"person\": {\"name\": \"John\", \"age\": 30, \"address\": {\"city\": \"New York\", \"zip\": \... |
49e776086a8cc3ad5a16fa0d4ac3e2c6 | [
{
"content": "Étant donné une chaîne de caractères `s`, ta tâche consiste à écrire une fonction qui renvoie une liste de toutes les sous-chaînes non vides uniques de `s`. Les sous-chaînes doivent être triées par ordre lexicographique.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 10).\n\n**So... | ["\nassert unique_substrings(\"abc\") == ['a', 'ab', 'abc', 'b', 'bc', 'c']\n", "\nassert unique_substrings(\"a\") == ['a']\n", "\nassert unique_substrings(\"\") == []\n", "\nassert unique_substrings(\"aaa\") == ['a', 'aa', 'aaa']\n", "\nassert unique_substrings(\"abab\") == ['a', 'ab', 'aba', 'abab', 'b', 'ba', 'bab']... |
0c77602212338b5ec05fdcba9e4baab8 | [
{
"content": "On te donne une chaîne encodée en base64 qui pourrait ne pas être correctement complétée et qui pourrait contenir des caractères non alphanumériques. Ta tâche est de créer une fonction `decode_base64` qui décode cette chaîne. La fonction doit gérer le remplissage incorrect en ajoutant les caractèr... | ["\nassert decode_base64(\"SGVsbG8gV29ybGQh\") == \"Hello World!\"\n", "\nassert decode_base64(\"SGVsbG8gV29ybGQh==\") == \"Hello World!\"\n", "\nassert decode_base64(\"SGVsbG8gV29ybGQh===\") == \"Hello World!\"\n", "\nassert decode_base64(\"SGVsbG8gV29ybGQh====\") == \"Hello World!\"\n", "\nassert decode_base64(\"SGVs... |
552e3cbc7706d805416d681b5e6663a8 | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci en utilisant une approche récursive. Pour optimiser ta solution, tu dois utiliser la mémoïsation pour éviter les calculs redondants. Ta fonction doit gérer efficacement les grandes valeurs de n.\n\n**Entrée :**\n- ... | ["\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... |
596c9697c8e870596e03eb6f721ad621 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres anglaises majuscules et minuscules, sans ponctuation. Ta tâche est d'écrire une fonction qui supprime toutes les voyelles de la chaîne et renvoie la chaîne résultante. L'ordre des caractères restants doit être préservé.\n\n**Entrée :**\n... | ["\nassert remove_vowels(\"Beautiful Day\") == \"Btfl Dy\"\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(\"Quick Brown Fox\") == \"Qck Brwn Fx\"\n", "\... |
6ddd13a110dacb6cbdec62128c7bf440 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de trier ces chaînes par ordre décroissant en fonction du nombre de voyelles qu'elles contiennent. Les voyelles sont définies comme 'a', 'e', 'i', 'o', 'u' (en majuscules et en minuscules).\n\n**Entrée :**\n- Une liste de chaînes de cara... | ["\nassert sort_strings_by_vowel_count([\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"]) == [\"elderberry\", \"banana\", \"apple\", \"grape\", \"cherry\", \"date\", \"fig\"]\n", "\nassert sort_strings_by_vowel_count([\"kiwi\", \"orange\", \"pear\", \"peach\"]) == [\"orange\", \"peach\",... |
2f77525dbdc26400ad3d36c1202a0750 | [
{
"content": "On te demande de traiter un ensemble de données contenant des informations sur les clients d'un magasin de détail, représentées sous forme de DataFrame pandas `df`. Le DataFrame comprend les colonnes suivantes : `CustomerID`, `Gender`, `AgeGroup`, `IncomeGroup`, `MaritalStatus`, `ProductCategory`,... | ["\nassert get_feature_drop_list(pd.DataFrame(columns=['CustomerID', 'Gender', 'AgeGroup', 'IncomeGroup', 'MaritalStatus', 'ProductCategory', 'PurchaseAmount', 'PurchaseDate'])) == (['Gender', 'AgeGroup', 'IncomeGroup', 'MaritalStatus', 'ProductCategory', 'PurchaseDate'], ['Male', '30-40', 'Low', 'Single', 'Electronics... |
89ddacc94795b559655f84c7f5507c2f | [
{
"content": "Tu participes à un concours de programmation où tu dois implémenter une fonction pour télécharger un fichier depuis un serveur distant et l'enregistrer à un chemin d'accès local spécifié. La fonction doit prendre deux paramètres : `file_id` (une chaîne de caractères représentant l'identifiant uniq... | ["\nassert download_file(\"file123\", \"/tmp/file123\") == \"/tmp/file123.pdf\"\n", "\nassert download_file(\"doc456\", \"/tmp/doc456\") == \"/tmp/doc456.docx\"\n", "\nassert download_file(\"image789\", \"/tmp/image789\") == \"/tmp/image789.jpg\"\n", "\nassert download_file(\"png101\", \"/tmp/png101\") == \"/tmp/png101... |
fac226717f48ddb6d7ef6a92c2f0ce00 | [
{
"content": "On te donne une liste doublement chaînée et une valeur `x`. Ta tâche est d'implémenter une fonction `insert_at_end` qui insère un nouveau nœud avec la valeur `x` à la fin de la liste. La liste doublement chaînée est définie par les classes `Node` et `DoublyLinkedList` fournies ci-dessous. Ta fonct... | ["\nassert DoublyLinkedList().head is None\n", "\ndll = DoublyLinkedList(); dll.insert_at_end(1); assert dll.head.data == 1\n", "\ndll = DoublyLinkedList(); dll.insert_at_end(1); dll.insert_at_end(2); assert dll.head.next.data == 2\n", "\ndll = DoublyLinkedList(); dll.insert_at_end(1); dll.insert_at_end(2); assert dll.... |
8bdc4edc2caa9c57412de33dc45fdc34 | [
{
"content": "On te donne une liste de dictionnaires et une clé spécifique. Ta tâche est de mettre en œuvre une fonction qui trie cette liste de dictionnaires en fonction des valeurs associées à la clé donnée. Si un dictionnaire ne contient pas la clé spécifiée, il doit être traité comme ayant une valeur de 0 à... | ["\nassert sort_dicts_by_key([{\"a\": 3}, {\"a\": 1}, {\"a\": 2}], \"a\") == [{\"a\": 1}, {\"a\": 2}, {\"a\": 3}]\n", "\nassert sort_dicts_by_key([{\"b\": 3}, {\"a\": 1}, {\"a\": 2}], \"a\") == [{\"b\": 3}, {\"a\": 1}, {\"a\": 2}]\n", "\nassert sort_dicts_by_key([{\"a\": 3}, {\"b\": 1}, {\"a\": 2}], \"b\") == [{\"a\": ... |
0d2886265e01045eb4220a6a00652a9e | [
{
"content": "On te donne une liste de `posts` et un dictionnaire `user_data`. Chaque post est représenté comme un dictionnaire avec les clés suivantes : `'PID'` (ID du post), `'title'`, `'content'`, `'author'`, `'timestamp'`. Le dictionnaire `user_data` contient les clés suivantes : `'UserUpvoted'`, `'UserDown... | ["\nassert add_post_data([{'PID': 1, 'title': 'Post 1', 'content': 'Content 1', 'author': 'Author 1', 'timestamp': '2023-01-01'}], {'UserUpvoted': [1], 'UserDownvoted': [], 'FavouritePosts': []}) == [{'PID': 1, 'title': 'Post 1', 'content': 'Content 1', 'author': 'Author 1', 'timestamp': '2023-01-01', 'isUpvoted': True... |
e6cfb74968844db769173816f7191386 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour trouver tous les nombres premiers inférieurs ou égaux à un entier donné `n`. Ta solution doit utiliser la méthode du crible d'Ératosthène. La fonction doit renvoyer une liste de nombres premiers dans l'ordre croissant.\n\n**Entrée :**\n- Un e... | ["\nassert sieve_of_eratosthenes(10) == [2, 3, 5, 7]\n", "\nassert sieve_of_eratosthenes(1) == []\n", "\nassert sieve_of_eratosthenes(0) == []\n", "\nassert sieve_of_eratosthenes(2) == [2]\n", "\nassert sieve_of_eratosthenes(19) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert sieve_of_eratosthenes(30) == [2, 3, 5, 7, 11,... |
82706c2b44731e1712829ce535b0e0e3 | [
{
"content": "Implémente une structure de données pile en Python en utilisant une classe. Ta pile doit prendre en charge les opérations suivantes :\n- `is_empty()` : Renvoie `True` si la pile est vide, sinon `False`.\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'él... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\ns = Stack(); s.push(1); assert s.peek() == 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.size() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.pe... |
76eff00d385ad15fa44ddcd3816ffe33 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `add_numbers_in_list(numbers)` qui calcule la somme de tous les entiers non négatifs de la liste. Si la liste ne contient que des nombres négatifs ou est vide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une list... | ["\nassert add_numbers_in_list([1, 2, 3, 4, 5]) == 15\n", "\nassert add_numbers_in_list([-1, -2, -3, -4, -5]) == None\n", "\nassert add_numbers_in_list([1, -2, 3, -4, 5]) == 9\n", "\nassert add_numbers_in_list([]) == None\n", "\nassert add_numbers_in_list([0, 0, 0, 0]) == 0\n", "\nassert add_numbers_in_list([10, 20, -3... |
ad23a57c53cb46c20aa360f257f105eb | [
{
"content": "On te donne une grille 2D représentant un labyrinthe, où chaque cellule est soit un mur (indiqué par `'#'`) soit un espace libre (indiqué par `'.'`). On te fournit également la position de départ `(sx, sy)` et la position cible `(tx, ty)` dans le labyrinthe. Ta tâche est de trouver tous les chemin... | ["\nassert find_shortest_paths([['.', '.', '.'], ['.', '.', '.'], ['.', '.', '.']], (0, 0), (2, 2)) == [[(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)], [(0, 0), (0, 1), (1, 1), (1, 2), (2, 2)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)], [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]]\n", "\nassert find_shortest_paths([['.', '.', '.... |
9159cae0e4909c41ead9ff628f57240f | [
{
"content": "On te donne une substance radioactive avec une demi-vie connue `T`. Tu as une liste de périodes de temps `times` pendant lesquelles tu observes la décroissance. Ta tâche est de calculer la fraction de la substance qui reste après chaque période de temps en utilisant la formule de décroissance radi... | ["\nassert remaining_fraction([0], 1) == [1.0]\n", "\nassert remaining_fraction([1], 1) == [0.5]\n", "\nassert remaining_fraction([2], 1) == [0.25]\n", "\nassert remaining_fraction([0.5], 1) == [0.7071067811865476]\n", "\nassert remaining_fraction([1, 2, 3], 1) == [0.5, 0.25, 0.125]\n", "\nassert remaining_fraction([0,... |
b89b79c6fe3cc95417ed6d921deb3bff | [
{
"content": "On te donne une liste de phrases, où chaque phrase est représentée comme une liste de mots. Ta tâche est d'implémenter une fonction `filter_long_words` qui traite cette liste et renvoie une nouvelle liste de phrases. Chaque phrase dans la sortie ne doit contenir que des mots de plus de 4 caractère... | ["\nassert filter_long_words([[\"this\", \"is\", \"a\", \"test\"]]) == [[\"test\"]]\n", "\nassert filter_long_words([[\"another\", \"example\", \"with\", \"short\", \"words\"]]) == [[\"another\", \"example\"]]\n", "\nassert filter_long_words([[\"hi\", \"there\"], [\"hello\", \"world\"]]) == [[], [\"hello\", \"world\"]]... |
6a0bacc9ac3f3db30387bc2d5850fb61 | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Détermine si elles sont des anagrammes l'une de l'autre. Un anagramme est défini comme un réarrangement des lettres d'une chaîne pour former une autre chaîne en utilisant toutes les lettres originales exactement une fois. La comparaison doit êtr... | ["\nassert are_anagrams(\"Listen\", \"Silent\") == True\n", "\nassert are_anagrams(\"Triangle\", \"Integral\") == True\n", "\nassert are_anagrams(\"Apple\", \"Pabble\") == False\n", "\nassert are_anagrams(\"Astronomer\", \"Moon starer\") == False\n", "\nassert are_anagrams(\"School master\", \"The classroom\") == False... |
b526fc23776c5772ad679353d47d855b | [
{
"content": "On te donne deux listes, `main_list` et `sub_list`. Ta tâche est d'implémenter une fonction `find_sublist(main_list, sub_list)` qui renvoie l'indice de début de la première occurrence de `sub_list` dans `main_list`. Si `sub_list` n'apparaît pas dans `main_list`, renvoie `-1`. Les listes peuvent co... | ["\nassert find_sublist([1, 2, 3, 4, 5], [3, 4]) == 2\n", "\nassert find_sublist([1, 2, 3, 4, 5], [5]) == 4\n", "\nassert find_sublist([1, 2, 3, 4, 5], [6]) == -1\n", "\nassert find_sublist([1, 2, [3, 4], [5, 6]], [3, 4]) == -1\n", "\nassert find_sublist([1, 2, [3, 4], [5, 6]], [[3, 4]]) == 2\n", "\nassert find_sublist... |
6635d5ad3bb6aaf702d3eb3d3ecc275a | [
{
"content": "On te demande d'implémenter une fonction `calculate_discount` qui calcule le prix final d'un article après application d'une réduction. La fonction doit accepter deux paramètres : `price`, représentant le prix initial de l'article, et `discount`, représentant le pourcentage de réduction (un flotta... | ["\nassert calculate_discount(100, 0) == 100\n", "\nassert calculate_discount(100, 100) == 0\n", "\nassert calculate_discount(200, 50) == 100\n", "\nassert calculate_discount(150, 25) == 112.5\n", "\nassert calculate_discount(0, 20) == 0\n", "\nassert calculate_discount(50, 0.5) == 49.75\n", "\nassert calculate_discoun... |
1e9f00a33746e3b61f36d6de6ac6049f | [
{
"content": "On te demande d'implémenter une classe Python `Employee` qui modélise les détails d'un employé et les opérations liées à son emploi. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Un employé est initialisé avec un nom, un poste, un salaire et des années ... | ["\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, 5).name == \"John Doe\"\n", "\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, 5).position == \"Software Engineer\"\n", "\nassert Employee(\"John Doe\", \"Software Engineer\", 75000, 5).salary == 75000\n", "\nassert Employee(\"John Doe\", \"Sof... |
07495c3afae49fb1b4c1f8c86e719b9a | [
{
"content": "On te donne une liste d'entiers uniques. Ta tâche est de générer l'ensemble des parties de cette liste. L'ensemble des parties consiste en tous les sous-ensembles possibles, y compris l'ensemble vide et l'ensemble lui-même. Chaque sous-ensemble doit être représenté comme une liste. L'ordre des sou... | ["\nassert generate_power_set([]) == [[]]\n", "\nassert generate_power_set([1]) == [[], [1]]\n", "\nassert generate_power_set([1, 2]) == [[], [1], [2], [1, 2]]\n", "\nassert generate_power_set([1, 2, 3]) == [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]\n", "\nassert generate_power_set([4, 5, 6]) == [[], [4], [... |
2632863cc8e92329c8fc50179c4ce715 | [
{
"content": "On te donne une fonction `parse_data` qui prend un seul argument `input_str`, une chaîne de caractères qui est censée être au format JSON. La chaîne peut contenir des erreurs ou être mal formatée. Ton objectif est d'implémenter la fonction de telle sorte qu'elle tente d'analyser la chaîne JSON et ... | ["\nassert parse_data('{\"key\": \"value\"}') == {\"key\": \"value\"}\n", "\nassert parse_data('{\"key\": \"value\", \"number\": 123}') == {\"key\": \"value\", \"number\": 123}\n", "\nassert parse_data('{\"key\": \"value\", \"list\": [1, 2, 3]}') == {\"key\": \"value\", \"list\": [1, 2, 3]}\n", "\nassert parse_data('{\... |
9ad340a4045378b40b5a080e87e936c9 | [
{
"content": "On te demande d'implémenter une classe `Book` qui modélise un livre avec les attributs et les méthodes suivants :\n\n- **Attributs :**\n - `title` : une chaîne de caractères représentant le titre du livre.\n - `author` : une chaîne de caractères représentant l'auteur du livre.\n - `ISBN` : une ... | ["\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\", 1949).get_description() == \"'1984' by George Orwell, ISBN: 9780451524935, published in 1949.\"\n", "\nassert Book(\"1984\", \"George Orwell\", \"9780451524935\", 1949).is_out_of_print() == True\n", "\nassert Book(\"To Kill a Mockingbird\", \"Harper Lee\",... |
3e4df4d548b6b7c9ca0e97cfa1d0b869 | [
{
"content": "On te donne une fonction `comment_block` qui prend un dictionnaire `context` et une chaîne de caractères `value`. Le dictionnaire `context` contient deux clés : `\"start\"` et `\"middle\"`, représentant respectivement le début et la fin d'un commentaire de bloc. Ta tâche est d'implémenter la fonct... | ["\nassert comment_block({\"start\": \"/*\", \"middle\": \"*/\"}, \"This is a test.\") == \"/*This is a test.*/\"\n", "\nassert comment_block({\"start\": \"/*\", \"middle\": \"*/\"}, \"/*This is a test.*/\") == \"/**//*This is a test.****/*/\"\n", "\nassert comment_block({\"start\": \"/*\", \"middle\": \"*/\"}, \"This ... |
8ffad2f64643353ded60ed78ea226014 | [
{
"content": "On te donne un chemin de répertoire en entrée. Ta tâche est d'écrire une fonction Python qui liste récursivement tous les fichiers dans le répertoire et ses sous-répertoires, en excluant tous les fichiers avec une extension `.tmp`. La fonction doit renvoyer une liste de chemins de fichiers. Seuls ... | ["\nassert list_files(\"/empty_directory\") == []\n", "\nassert list_files(\"/directory_with_one_file\") == [\"/directory_with_one_file/file.txt\"]\n", "\nassert list_files(\"/directory_with_tmp_file\") == []\n", "\nassert list_files(\"/directory_with_subdirectories\") == [\"/directory_with_subdirectories/file1.txt\", ... |
41978e56c3a33ef10d978095240f1aa1 | [
{
"content": "On te charge d'évaluer l'efficacité d'un nouveau programme de vaccination. L'efficacité est mesurée par la couverture, définie comme la fraction de la population cible qui a été vaccinée. La relation entre les dépenses engagées pour le programme et sa couverture peut être modélisée à l'aide d'une ... | ["\nassert calculate_coverage(0, 50000, 0.8, 10, 10000, 0.01) == 0.0\n", "\nassert calculate_coverage(50000, 50000, 0.8, 10, 10000, 0.01) == 0.42000000000000004\n", "\nassert calculate_coverage(100000, 50000, 0.8, 10, 10000, 0.01) == 0.84\n", "\nassert calculate_coverage(100000, 50000, 1, 10, 10000, 0.01) == 1.0\n", "\... |
efacadff6ae3151594291398b6c45288 | [
{
"content": "On te donne un modèle de classification binaire qui produit un score de probabilité entre 0 et 1 pour chaque entrée, indiquant la probabilité que l'entrée appartienne à la classe positive. Ta tâche est de mettre en œuvre une fonction qui calcule les métriques de rappel et de faux positifs pour un ... | ["\nassert compute_recall_fallout(torch.tensor([0.1, 0.4, 0.35, 0.8]), torch.tensor([0, 0, 1, 1]), 0.5) == (1.0, 0.0)\n", "\nassert compute_recall_fallout(torch.tensor([0.9, 0.2, 0.7, 0.3]), torch.tensor([1, 0, 1, 0]), 0.5) == (1.0, 0.5)\n", "\nassert compute_recall_fallout(torch.tensor([0.2, 0.3, 0.4, 0.5]), torch.ten... |
3601c9b854c0d526887d941854887e4e | [
{
"content": "On te charge de développer un programme pour traiter un document texte non structuré de grande taille. Ton objectif est d’identifier et d’extraire toutes les adresses e-mail et tous les numéros de téléphone uniques du document. Les données extraites doivent être écrites dans un fichier de sortie d... | ["\nassert open(output_file_path, 'r', encoding='utf-8').read().strip() == \"test@example.com\\n123-456-7890\" if open(input_file_path, 'w', encoding='utf-8').write(\"Contact us at test@example.com or call 123-456-7890.\") else False\n", "\nassert open(output_file_path, 'r', encoding='utf-8').read().strip() == \"user12... |
4181feca58270080a7e093bef6bad7a2 | [
{
"content": "On te demande d'implémenter une classe `Employee` qui modélise un employé avec les attributs `name`, `position` et `salary`. Ton objectif est de définir une méthode `give_raise` dans cette classe. La méthode doit accepter un seul paramètre, `percentage`, qui représente le pourcentage d'augmentatio... | ["\nassert Employee(\"John Doe\", \"Developer\", 50000).give_raise(10) is None\n", "\nemp = Employee(\"John Doe\", \"Developer\", 50000); emp.give_raise(10); assert emp.salary == 55000.0\n", "\nemp = Employee(\"Jane Smith\", \"Manager\", 75000); emp.give_raise(5); assert emp.salary == 78750.0\n", "\nemp = Employee(\"Al... |
aea7ad81246382b5fde6cac4e1a03844 | [
{
"content": "On te donne une structure de liste imbriquée contenant des entiers, des chaînes de caractères et d'autres listes imbriquées. Ta tâche est d'écrire une fonction `flatten_nested_lists` qui aplatit cette structure en une seule liste tout en préservant l'ordre des éléments. Cependant, toute liste imbr... | ["\nassert flatten_nested_lists([1, \"a\", [2, 3], [\"b\", \"c\"], [\"hello\"], [4, [\"world\"]], [\"skip\"], \"end\"]) == [1, 'a', 2, 3, 'b', 'c', 4, 'world', 'end']\n", "\nassert flatten_nested_lists([[\"single\"], 1, 2, 3]) == [1, 2, 3]\n", "\nassert flatten_nested_lists([\"a\", [\"b\"], [\"c\", \"d\"], [\"e\"]]) ==... |
62de81df1860c848d488a058ed0e428e | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est d'implémenter une fonction `find_max_difference(nums)` qui calcule la différence maximale entre deux éléments quelconques de la liste, où l'élément le plus grand apparaît après l'élément le plus petit. Si aucune paire de ce type n'existe, la fon... | ["\nassert find_max_difference([2, 3, 10, 6, 4, 8, 1]) == 8\n", "\nassert find_max_difference([7, 9, 5, 6, 3, 2]) == 2\n", "\nassert find_max_difference([1, 2, 90, 10, 110]) == 109\n", "\nassert find_max_difference([10, 8, 7, 6, 5]) == -1\n", "\nassert find_max_difference([1]) == -1\n", "\nassert find_max_difference([]... |
e9aa58aa00c2b0742d6f94993adb0d9b | [
{
"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 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 i... | ["\nassert is_balanced_parentheses(\"()[]{}\") == True\n", "\nassert is_balanced_parentheses(\"(]\") == False\n", "\nassert is_balanced_parentheses(\"([{}])\") == True\n", "\nassert is_balanced_parentheses(\"\") == True\n", "\nassert is_balanced_parentheses(\"((((()))))\") == True\n", "\nassert is_balanced_parentheses(... |
97c68afc4b0e60e719fff78d3ba85100 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif. La factorielle d'un entier non négatif \\( n \\) est le produit de tous les entiers positifs inférieurs ou égaux à \\( n \\). La factorielle de 0 est définie comme 1. Ta fonction doit gérer le ... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factor... |
f86c33973a6ae6598d187af44a9bc9f4 | [
{
"content": "On te donne les dimensions de deux matrices, `A` et `B`, représentées comme des tuples `(m, k)` et `(k, n)` respectivement. Ta tâche est de calculer le nombre total d'opérations en virgule flottante (FLOPs) nécessaires pour multiplier ces matrices. Les FLOPs sont calculés comme suit :\n\n1. Calcul... | ["\nassert calculate_flops((100, 50), (50, 200)) == 1990000\n", "\nassert calculate_flops((1, 1), (1, 1)) == 2\n", "\nassert calculate_flops((2, 3), (3, 4)) == 42\n", "\nassert calculate_flops((0, 5), (5, 0)) == 0\n", "\nassert calculate_flops((10, 10), (10, 10)) == 1800\n", "\nassert calculate_flops((1000, 1000), (100... |
e284e3a2941dff259fd71ab6e81eb016 | [
{
"content": "On te donne une grille 2D de taille `cell_l x cell_l` et une liste de `N` particules, chacune représentée par ses coordonnées `(x, y)`. La grille a une frontière périodique avec une séquence de motifs spécifique `P` de longueur `k`. Chaque élément de `P` est soit `0` soit `1`, où `0` indique des c... | ["\nassert relocate_particles(5, [(6, 3), (-1, 2)], [0, 0, 0, 0, 0]) == [(1, 3), (4, 2)]\n", "\nassert relocate_particles(5, [(6, 3), (-1, 2)], [1, 1, 1, 1, 1]) == [(4, 3), (0, 2)]\n", "\nassert relocate_particles(5, [(5, 5), (0, 0)], [0, 1, 0, 1, 0]) == [(0, 0), (0, 0)]\n", "\nassert relocate_particles(5, [(5, 5), (0,... |
c8a9871dd59c26eaaed782ded6eb01cf | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie le deuxième plus grand nombre unique de la liste. Si la liste contient moins de deux nombres uniques, la fonction doit lever une exception `ValueError`.\n\n**Exemple d'entrée :**\n```\n[10, 20, 30, 40, 50]\n... | ["\nassert second_largest([10, 20, 30, 40, 50]) == 40\n", "\nassert second_largest([50, 40, 30, 20, 10]) == 40\n", "\nassert second_largest([1, 2, 3, 4, 5]) == 4\n", "\nassert second_largest([5, 5, 5, 5, 5]) == ValueError\n", "\nassert second_largest([100, 100, 100, 90]) == 90\n", "\nassert second_largest([1]) == Value... |
69ddc9e8030d63b2ef6c358366d19eff | [
{
"content": "On te demande d'implémenter une classe `DataProcessor` en Python qui gérera une liste de données numériques. La classe doit fournir des fonctionnalités pour filtrer, trier et calculer la moyenne des données. Ton implémentation doit inclure les méthodes suivantes :\n\n- `filter_data(min_val, max_va... | ["\nassert DataProcessor([1, 2, 3, 4, 5]).filter_data(2, 4) == [2, 3, 4]\n", "\nassert DataProcessor([10, 20, 30, 40, 50]).sort_data() == [10, 20, 30, 40, 50]\n", "\nassert DataProcessor([5, 15, 25, 35, 45]).average_data() == 25.0\n", "\nassert DataProcessor([1, 2, 3, 4, 5]).filter_data(0, 10) == [1, 2, 3, 4, 5]\n", "\... |
233d3f06956854df2509c3e779bc78bb | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de construire un nouveau tableau `result` tel que `result[i]` soit le produit de tous les éléments de `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division.\n\n**Contraintes :**\n- `1 <= len(nums) <= 10^5`\n- `-10^4 <= n... | ["\nassert product_except_self([1, 2, 3, 4, 5]) == [120, 60, 40, 30, 24]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [0, 0, 8, 0]\n", "\nassert product_except_self([1, 2, 3, 0]) == [0,... |
772b7281ff6896caf34c6df9ab313334 | [
{
"content": "On te donne un graphe représenté comme un objet `torch_geometric.Data`, un modèle de réseau convolutionnel de graphes (GCN) pré-entraîné et une matrice de poids. Le modèle GCN prend en charge la génération d'embeddings de nœuds à l'aide de la méthode `model.project(x, pool=False)`. Ta tâche est de... | ["\nassert np.array_equal(calculate_node_activations(torch_geometric.data.Data(x=torch.tensor([[1.0, 2.0], [3.0, 4.0]]), edge_index=torch.tensor([[0, 1], [1, 0]])), nn.Linear(2, 2), torch.tensor([[1.0, 0.0], [0.0, 1.0]])), np.array([5.0, 11.0]))\n", "\nassert np.array_equal(calculate_node_activations(torch_geometric.da... |
729f58b00194a721b4fddb8c901a96f0 | [
{
"content": "On te demande d'implémenter un jeu de devinettes de nombres. Le jeu consiste à deviner un entier généré aléatoirement entre 1 et 100. Le joueur dispose d'un maximum de 10 tentatives pour deviner le nombre. Après chaque tentative, le programme doit fournir un retour d'information indiquant si la su... | ["\nassert check_guess(50, 50, 1) == \"Congratulations! You've guessed the number 50 correctly in 1 attempts.\"\n", "\nassert check_guess(25, 50, 1) == \"Your guess is too low.\"\n", "\nassert check_guess(75, 50, 1) == \"Your guess is too high.\"\n", "\nassert check_guess(1, 1, 1) == \"Congratulations! You've guessed t... |
35008f9119e37bf80fe21741d3ea79bb | [
{
"content": "On te charge de calculer le nombre moyen de connexions d'utilisateurs par jour à partir d'une liste triée d'horodatages. Chaque horodatage est représenté par un tuple de six entiers : (année, mois, jour, heure, minute, seconde). Ta fonction ne doit pas utiliser de bibliothèque de date ou d'heure i... | ["\nassert average_logins_per_day([(2023, 1, 1, 0, 0, 0), (2023, 1, 2, 0, 0, 0)]) == 2.0\n", "\nassert average_logins_per_day([(2023, 1, 1, 0, 0, 0), (2023, 1, 1, 12, 0, 0)]) == None\n", "\nassert average_logins_per_day([(2023, 1, 1, 0, 0, 0), (2023, 1, 1, 0, 0, 1)]) == None\n", "\nassert average_logins_per_day([(2023,... |
61760f47f969032143495accfd07b40e | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver le sous-tableau contigu le plus court dans `nums` dont la somme est égale à `target`. Si un tel sous-tableau n'existe pas, renvoie une liste vide. La fonction doit renvoyer les indices de début et de fin du sous... | ["\nassert find_subarray([1, 4, 20, 3, 10, 5], 33) == [2, 4]\n", "\nassert find_subarray([1, 4, 0, 0, 3, 10, 5], 7) == [1, 4]\n", "\nassert find_subarray([1, 4, 20, 3, 10, 5], 50) == []\n", "\nassert find_subarray([1, 4, 20, 3, 10, 5], 3) == [3, 3]\n", "\nassert find_subarray([1, 4, 20, 3, 10, 5], 38) == [1, 5]\n", "\n... |
ad0fac9f8ca24d3051889466b6a4ec0d | [
{
"content": "On te demande de concevoir une API RESTful en utilisant Flask qui supporte les opérations CRUD sur une collection de livres. Chaque livre est identifié de manière unique par son numéro ISBN et contient des informations supplémentaires telles que le titre et l'auteur. Ton API doit exposer les point... | ["\nassert app.test_client().post('/books', json={'title': '1984', 'author': 'George Orwell', 'isbn': '1234567890'}).status_code == 201\n", "\nassert app.test_client().post('/books', json={'title': '1984', 'author': 'George Orwell'}).status_code == 400\n", "\nassert app.test_client().post('/books', json={'title': '1984... |
27f0c7435b250a7e8959a0755312747a | [
{
"content": "Tu développes une fonction pour une plateforme de diffusion vidéo nommée \"StreamFlow\". La fonction doit accepter un identifiant vidéo encodé en entrée, le décoder en utilisant un chiffrement de César avec un décalage de 3, et générer une URL en utilisant l'identifiant vidéo décodé. Le décodage d... | ["\nassert generate_url(\"khoor\") == \"https://streamflow.com/watch/hello\"\n", "\nassert generate_url(\"zruog\") == \"https://streamflow.com/watch/world\"\n", "\nassert generate_url(\"abc\") == \"https://streamflow.com/watch/xyz\"\n", "\nassert generate_url(\"xyz\") == \"https://streamflow.com/watch/uvw\"\n", "\nasse... |
c7d8a691fc3d8a96aec21d707be6556a | [
{
"content": "On te donne un nombre à virgule flottante `x` et un entier `n`. Ta tâche est d'implémenter une fonction `round_to_n_decimals(x, n)` qui arrondit le nombre `x` à `n` décimales sans utiliser de fonctions ou de méthodes intégrées qui effectuent un arrondi ou un formatage (par exemple, `round()`, `for... | ["\nassert round_to_n_decimals(3.14159, 2) == 3.14\n", "\nassert round_to_n_decimals(2.71828, 3) == 2.718\n", "\nassert round_to_n_decimals(1.5, 0) == 2.0\n", "\nassert round_to_n_decimals(1.49, 0) == 1.0\n", "\nassert round_to_n_decimals(-2.345, 2) == -2.35\n", "\nassert round_to_n_decimals(0.0, 5) == 0.0\n", "\nasser... |
cad71c6eedcd1c781cb08f6513ff428a | [
{
"content": "On te demande d'implémenter une fonction `convert_pressure` qui effectue des conversions d'unités de pression entre les Pascals (Pa), les Atmosphères (atm) et les Livres par Pouce Carré (psi). La fonction doit gérer la conversion avec précision et arrondir le résultat à un nombre de chiffres signi... | ["\nassert convert_pressure(\"Pa\", \"atm\", 101325, 3) == 1.000\n", "\nassert convert_pressure(\"atm\", \"Pa\", 1, 5) == 101325.00000\n", "\nassert convert_pressure(\"psi\", \"Pa\", 1, 4) == 6894.7600\n", "\nassert convert_pressure(\"Pa\", \"psi\", 6894.76, 3) == 1.000\n", "\nassert convert_pressure(\"atm\", \"psi\", ... |
edb5dd5880f0660bda5ca744fbd7ce33 | [
{
"content": "On te donne une liste de chaînes de caractères `words` et une chaîne de caractères `pattern`. Ta tâche est de mettre en œuvre une fonction `find_matching_words(words, pattern)` qui renvoie une liste de tous les mots de `words` qui correspondent au `pattern`. Un mot correspond au pattern s'il exist... | ["\nassert find_matching_words([\"meme\", \"sasa\", \"aaaa\", \"lool\"], \"abba\") == [\"meme\", \"sasa\", \"lool\"]\n", "\nassert find_matching_words([\"test\", \"tset\", \"sett\", \"best\"], \"abba\") == [\"tset\", \"best\"]\n", "\nassert find_matching_words([\"deed\", \"deed\", \"deed\"], \"deed\") == [\"deed\", \"d... |
0709cf0cd0bacfa70484e0eb31ee0632 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `tribonacci_sum(n)` qui calcule la somme des `n` premiers nombres de la suite de Tribonacci. La suite de Tribonacci est définie comme suit : les trois premiers nombres sont 0, 1 et 1, et chaque nombre suivant est la somme des tr... | ["\nassert fibonacci_sum(0) == 0\n", "\nassert fibonacci_sum(1) == 0\n", "\nassert fibonacci_sum(2) == 1\n", "\nassert fibonacci_sum(3) == 2\n", "\nassert fibonacci_sum(4) == 4\n", "\nassert fibonacci_sum(5) == 7\n", "\nassert fibonacci_sum(6) == 13\n", "\nassert fibonacci_sum(7) == 24\n", "\nassert fibonacci_sum(8) ==... |
d2ea4dbf4e3a3bc8b76b29cb5144c0a4 | [
{
"content": "On te donne une chaîne de caractères `s` formatée comme `%u:%s`, où `%u` est un entier non signé et `%s` est un nom descriptif pour l'entier. Ta tâche est d'implémenter une fonction `extract_id` qui extrait l'entier non signé de la chaîne et le renvoie sous forme d'entier. Si la chaîne d'entrée `s... | ["\nassert extract_id(\"123:sample\") == 123\n", "\nassert extract_id(\"0:name\") == 0\n", "\nassert extract_id(\"999999999:max_value\") == 999999999\n", "\nassert extract_id(\"1:one\") == 1\n", "\nassert extract_id(\"1234567890:large_number\") == 1234567890\n", "\nassert extract_id(\"1234:valid\") == 1234\n", "\nasser... |
1178d52d5b2b55de7235843582e22090 | [
{
"content": "Implémente une classe Python `BankAccount` qui simule des opérations bancaires de base. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur doit accepter un `account_number` et un `initial_deposit` pour configurer le compte.\n- **Dépôt** : Une... | ["\nassert BankAccount(\"12345\", 100).get_balance() == 100\n", "\nassert BankAccount(\"12345\", 0).get_balance() == 0\n", "\nassert BankAccount(\"12345\", 100).get_transaction_history() == []\n", "\naccount = BankAccount(\"12345\", 100); account.deposit(50, \"2023-10-01\"); assert account.get_balance() == 150\n", "\na... |
b6ac6288ebb5c1b9ef62233f60b90718 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de déterminer le nombre de zéros traînants dans la factorielle de `n` sans utiliser de fonctions intégrées pour calculer les factorielles ou convertir des nombres en chaînes de caractères.\n\n**Entrée :**\n- Un seul entier `n` (1 ≤ n ≤ 10^9)\n\n**Sor... | ["\nassert count_trailing_zeros(5) == 1\n", "\nassert count_trailing_zeros(10) == 2\n", "\nassert count_trailing_zeros(25) == 6\n", "\nassert count_trailing_zeros(100) == 24\n", "\nassert count_trailing_zeros(125) == 31\n", "\nassert count_trailing_zeros(1) == 0\n", "\nassert count_trailing_zeros(20) == 4\n", "\nassert... |
57c319ca1e678858e10f0f362897828e | [
{
"content": "Tu es chargé de créer une fonction Python `generate_email_template` qui construit un modèle d'e-mail personnalisé en fonction des données fournies. La fonction doit accepter un dictionnaire `data` avec les clés suivantes :\n- `name` : une chaîne de caractères représentant le nom du destinataire.\n... | ["\nassert generate_email_template({\"name\": \"Alice\", \"product\": \"Wireless Bluetooth Headphones\", \"price\": 59.99, \"discount\": 15, \"expiration\": \"October 15, 2023\"}) == \"Subject: Exclusive Offer for You, Alice!\\n\\nDear Alice,\\n\\nWe hope this email finds you well. We are excited to offer you an exclus... |
7fd4c62184bd2d219bcd06a27c6f5fee | [
{
"content": "On te demande de développer un système pour surveiller les performances des serveurs. Chaque serveur se voit attribuer un score de performance, et ton objectif est d'identifier les `k` meilleurs serveurs en fonction de ces scores. Implémente une fonction `top_k_servers` qui renvoie les identifiant... | ["\nassert top_k_servers(6, [100, 200, 150, 300, 250, 50], 3) == [3, 4, 1]\n", "\nassert top_k_servers(5, [10, 20, 30, 40, 50], 2) == [4, 3]\n", "\nassert top_k_servers(4, [50, 50, 50, 50], 4) == [0, 1, 2, 3]\n", "\nassert top_k_servers(3, [100, 200, 300], 1) == [2]\n", "\nassert top_k_servers(7, [1, 2, 3, 4, 5, 6, 7],... |
fced2979d3c9b7cc294b44a6909d9cef | [
{
"content": "On te donne une liste de chaînes de caractères `words`. Ta tâche est d'implémenter une fonction `find_anagrams(word_list)` qui regroupe les mots en anagrammes. Chaque groupe doit être représenté comme une liste d'anagrammes, et la fonction doit renvoyer une liste de ces groupes. Les anagrammes son... | ["\nassert find_anagrams([\"listen\", \"silent\", \"enlist\", \"google\", \"gooegl\", \"rat\", \"tar\", \"art\"]) == [[\"listen\", \"silent\", \"enlist\"], [\"google\", \"gooegl\"], [\"rat\", \"tar\", \"art\"]]\n", "\nassert find_anagrams([\"a\", \"A\", \"b\", \"B\"]) == [[\"a\", \"A\"], [\"b\", \"B\"]]\n", "\nassert f... |
648ad5a569bf0d5cba3de82b80185bd9 | [
{
"content": "On te demande de calculer le débit de production total de pétrole d'un réservoir divisé en plusieurs sections, chacune ayant des débits et des chutes de pression distincts. Le débit de production est déterminé par la formule suivante :\n\n\\[ \\text{Débit de production} = \\left(\\frac{0.007082 \\... | ["\nassert calculate_total_production_rate([100, 150, 200], [500, 600, 700], 1.2, 3.5, 100, 30) == 127476.57142857142\n", "\nassert calculate_total_production_rate([10, 20, 30], [10, 20, 30], 1, 1, 1, 1) == 42.328\n", "\nassert calculate_total_production_rate([0, 0, 0], [100, 200, 300], 1, 1, 1, 1) == 0\n", "\nassert c... |
63aace1de8982828e0482b3964f41a30 | [
{
"content": "On te demande d'écrire un script Python qui utilise la bibliothèque `requests` pour récupérer des données depuis le point de terminaison de l'API `https://api.example.com/data`. Ton script doit gérer les erreurs potentielles telles que les problèmes de réseau, les délais d'attente et les réponses ... | ["\nassert fetch_data() == {\"key\": \"value\"} # Assuming the API returns this JSON\n", "\nassert isinstance(fetch_data(), dict) # Assuming the API returns a JSON object\n", "\nassert \"HTTP error occurred\" in fetch_data() # Simulate an HTTP error\n", "\nassert \"Connection error occurred\" in fetch_data() # Simu... |
048c2d87b793ce4e93c9f7fd1e0bc00e | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui renvoie une nouvelle chaîne où chaque mot de la chaîne originale est remplacé par sa longueur. La fonction doit ignorer tous les caractères de ponctuation. On suppose que les... | ["\nassert words_to_lengths(\"Hello, world!\") == \"5 5\"\n", "\nassert words_to_lengths(\"Python is fun.\") == \"6 2 3\"\n", "\nassert words_to_lengths(\"A quick brown fox.\") == \"1 5 5 3\"\n", "\nassert words_to_lengths(\"OpenAI's GPT-3 model.\") == \"6 4 5\"\n", "\nassert words_to_lengths(\"No punctuation\") == \"2... |
717f8ffaa34410180f2f98fd2004f0ae | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction qui renvoie le deuxième plus petit élément distinct de la liste. Si la liste contient moins de deux éléments distincts, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ... | ["\nassert find_second_smallest([1, 2, 3, 4, 5]) == 2\n", "\nassert find_second_smallest([5, 4, 3, 2, 1]) == 2\n", "\nassert find_second_smallest([1, 1, 1, 1, 1]) == None\n", "\nassert find_second_smallest([2, 2, 3, 3, 4, 4]) == 3\n", "\nassert find_second_smallest([10]) == None\n", "\nassert find_second_smallest([]) =... |
ca6de24c0babb46bb96af53a6999b0a2 | [
{
"content": "On te donne une chaîne de caractères `sequence` représentant une séquence d'éléments séparés par des tirets ('-'). Ta tâche est de déterminer s'il existe deux éléments consécutifs identiques dans la séquence. Implémente la fonction `checkIfSequenceHasDuplicate` qui renvoie `True` si une telle pair... | ["\nassert checkIfSequenceHasDuplicate(\"A-B-C-C-D\") == True\n", "\nassert checkIfSequenceHasDuplicate(\"A-B-C-D-E\") == False\n", "\nassert checkIfSequenceHasDuplicate(\"X-Y-Z-Z-X\") == True\n", "\nassert checkIfSequenceHasDuplicate(\"1-2-3-4-5-5-6\") == True\n", "\nassert checkIfSequenceHasDuplicate(\"a-b-c-d-e-f-g\... |
424cfeb77faf7c85691e9e273d71d7bd | [
{
"content": "On te demande d'implémenter une fonction `sanitize_filename` qui traite une chaîne de caractères `filename` donnée pour produire un nom de fichier valide, adapté à une utilisation sur divers systèmes d'exploitation. La fonction doit respecter les règles suivantes :\n\n1. Convertir le nom de fichie... | ["\nassert sanitize_filename(\"My File.txt\") == \"my_file.txt\"\n", "\nassert sanitize_filename(\" Leading and trailing spaces \") == \"leading_and_trailing_spaces\"\n", "\nassert sanitize_filename(\"Multiple...dots...here\") == \"multiple.dots.here\"\n", "\nassert sanitize_filename(\"Invalid:<>\\\"/\\\\|?* chars\")... |
03f9afdca9cf89d2c1257038c7fc6b12 | [
{
"content": "Tu es chargé d'implémenter une simulation simple du jeu classique \"Pierre-Feuille-Ciseaux\" entre un joueur humain et un ordinateur. Le choix de l'ordinateur doit être généré aléatoirement. Ton programme doit demander au joueur humain d'entrer son choix, le valider, puis déterminer le gagnant en ... | ["\nassert determine_winner(\"rock\", \"scissors\") == \"You win!\"\n", "\nassert determine_winner(\"scissors\", \"paper\") == \"You win!\"\n", "\nassert determine_winner(\"paper\", \"rock\") == \"You win!\"\n", "\nassert determine_winner(\"rock\", \"paper\") == \"Computer wins!\"\n", "\nassert determine_winner(\"sciss... |
c99978e746700c338efb4918bad058f5 | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `find_most_common_word` qui renvoie le mot le plus fréquemment rencontré dans la chaîne. En cas d'égalité, la fonction doit renvoyer le mot qui apparaît en premier dans la chaîne. La fonction doit être insensi... | ["\nassert find_most_common_word(\"Hello, hello, world!\") == \"hello\"\n", "\nassert find_most_common_word(\"This is a test. This test is only a test.\") == \"test\"\n", "\nassert find_most_common_word(\"One fish, two fish, red fish, blue fish.\") == \"fish\"\n", "\nassert find_most_common_word(\"To be or not to be, t... |
0694845983ab61eeaf2c3f386adab8bc | [
{
"content": "On te donne une liste de phrases, où chaque phrase est une chaîne de caractères. Ta tâche est de mettre en œuvre une fonction `count_unique_words` qui traite chaque phrase pour produire un dictionnaire. Le dictionnaire doit associer chaque phrase à un ensemble de mots uniques trouvés dans cette ph... | ["\nassert count_unique_words([\"Hello, world!\"]) == {\"Hello, world!\": {\"hello\", \"world\"}}\n", "\nassert count_unique_words([\"Hello there!\", \"Hello there!\"]) == {\"Hello there!\": {\"hello\", \"there\"}}\n", "\nassert count_unique_words([\"How are you?\", \"World of wonders.\"]) == {\"How are you?\": {\"how\... |
1178eec38d4739202d361a5f3ed34502 | [
{
"content": "On te donne les sommets d'un polygone simple dans un plan 2D. Ta tâche est de calculer l'aire du polygone en utilisant la formule des lacets (Shoelace formula). Le polygone peut être convexe ou concave. Les sommets sont fournis sous forme de liste de paires de coordonnées (x, y). Le premier sommet... | ["\nassert calculate_polygon_area([(0, 0), (4, 0), (4, 4), (0, 4)]) == 16.0\n", "\nassert calculate_polygon_area([(0, 0), (5, 0), (5, 5), (0, 5)]) == 25.0\n", "\nassert calculate_polygon_area([(1, 1), (4, 1), (4, 5)]) == 6.0\n", "\nassert calculate_polygon_area([(0, 0), (10, 0), (5, 5)]) == 25.0\n", "\nassert calculate... |
5e8a95eccc75c3ce5a6b38d8c4822312 | [
{
"content": "On te donne un ensemble de données contenant des informations sur les ventes quotidiennes d'une entreprise sur une année. L'ensemble de données est représenté sous forme de DataFrame pandas nommé `sales_data` avec les colonnes suivantes : 'date' (formatée AAAA-MM-JJ), 'revenue' et 'expenses'. Ta t... | ["\nassert eval_revenue_volatility(pd.DataFrame({'date': ['2023-10-01', '2023-10-02', '2023-10-03'], 'revenue': [100, 200, 300], 'expenses': [50, 100, 150]})) == 0.47140452079103173\n", "\nassert eval_revenue_volatility(pd.DataFrame({'date': ['2023-10-01', '2023-10-02', '2023-10-03'], 'revenue': [100, 100, 100], 'expen... |
c2a804ddf510f4585476ffdf7314177e | [
{
"content": "Tu participes à un concours de traitement d'images numériques. On te donne une liste d'images, où chaque image est représentée comme un tableau NumPy 2D. Ta tâche est d'écrire une fonction `max_image_dimension(images)` qui prend une liste d'images en entrée et renvoie la dimension maximale (soit l... | ["\nassert max_image_dimension([np.array([[1, 2], [3, 4]])]) == 2\n", "\nassert max_image_dimension([np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])]) == 3\n", "\nassert max_image_dimension([np.array([[1]]), np.array([[1, 2], [3, 4]])]) == 2\n", "\nassert max_image_dimension([np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), np.arra... |
45e1048fed1904a1be4711cdb6924742 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente une date et une heure au format 'JJ-MMM-AAAA HH:mm:ss'. Ton objectif est d'écrire une fonction `convert_and_sort_dates` qui prend cette liste en entrée et renvoie une nouvelle liste contenant les objets `datetime` Python c... | ["\nassert convert_and_sort_dates([\"25-Dec-2021 12:34:56\", \"01-Jan-2022 00:00:01\", \"15-Jun-2021 23:59:59\"]) == [datetime(2022, 1, 1, 0, 0, 1), datetime(2021, 12, 25, 12, 34, 56), datetime(2021, 6, 15, 23, 59, 59)]\n", "\nassert convert_and_sort_dates([\"01-Jan-2020 00:00:00\", \"01-Jan-2021 00:00:00\", \"01-Jan-2... |
ed58cf9a57ce3e19a9821dfe6f1ae8c7 | [
{
"content": "On te donne un graphe représenté comme un dictionnaire où chaque clé est un nœud et la valeur correspondante est une liste de tuples. Chaque tuple consiste en un nœud connecté et le poids de l'arête reliant les deux nœuds. Ta tâche est de déterminer si le graphe est semi-Eulerien, en considérant u... | ["\nassert is_semi_eulerian({'A': [('B', 1), ('C', 2)], 'B': [('A', 1)], 'C': [('A', 2)]}, 3) == True\n", "\nassert is_semi_eulerian({'A': [('B', 1), ('C', 2)], 'B': [('A', 1)], 'C': [('A', 2)]}, 2) == False\n", "\nassert is_semi_eulerian({'A': [('B', 1)], 'B': [('A', 1), ('C', 1)], 'C': [('B', 1)]}, 2) == True\n", "\n... |
f570a98b22e5e1611182edd2572b92dc | [
{
"content": "Tu développes une fonction pour traiter une ligne de données provenant d'un moteur de jeu de poker. Chaque ligne contient des valeurs séparées par des espaces représentant les détails du jeu. Le format est le suivant : `gameID playerName [chipColor] [opponentStrategy] blindSize potSize`. Les champ... | ["\nassert parse_poker_game_line(\"game123 John Red Offensive 100 500\") == {\"gameID\": \"game123\", \"playerName\": \"John\", \"chipColor\": \"Red\", \"opponentStrategy\": \"Offensive\", \"blindSize\": 100, \"potSize\": 500}\n", "\nassert parse_poker_game_line(\"game456 Jane Blue Defensive 50 250\") == {\"gameID\": \... |
efdfacfe27bd9fd782bbdb57a386faee | [
{
"content": "On te donne un identifiant d'image unique `id` et un paramètre optionnel `dir_len` qui spécifie la longueur de chaque nom de sous-répertoire. Ta tâche est de concevoir une fonction `id_to_img_dir` qui construit un chemin de répertoire pour stocker les images. Le chemin du répertoire doit être stru... | ["\nassert id_to_img_dir(123456789) == \"01/91/23/18/27/09/49\"\n", "\nassert id_to_img_dir(1000000000, 3) == \"001/000/000/000/000/000/000/000/000/000\"\n", "\nassert id_to_img_dir(987654321, 2) == \"09/87/65/43/21\"\n", "\nassert id_to_img_dir(123, 1) == \"31/32/33\"\n", "\nassert id_to_img_dir(0, 2) == \"00/00\"\n",... |
0cb74cfe2e7b1e8dd7bb0e26b59a4651 | [
{
"content": "On te demande d'implémenter une fonction `generate_weather_report(city_name)` qui construit un rapport météo pour une ville spécifiée. La fonction doit utiliser une autre fonction fournie, `get_weather_info(city_name)`, qui renvoie un dictionnaire contenant les clés `temperature`, `humidity` et `d... | ["\nassert generate_weather_report(\"London\") == \"Weather Report for London:\\nTemperature: 15\u00b0C\\nHumidity: 80%\\nDescription: Light rain\"\n", "\nassert generate_weather_report(\"New York\") == \"Weather Report for New York:\\nTemperature: 22\u00b0C\\nHumidity: 60%\\nDescription: Clear sky\"\n", "\nassert gene... |
df8227fbb00fad3d258e8119484395b5 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `k`. Implémente une fonction `reverse_substrings` qui traite la chaîne en inversant chaque sous-chaîne de longueur `k`. Si une sous-chaîne est plus courte que `k`, inverse-la entièrement. Retourne la chaîne résultante.\n\n**Entrée :**\n- Une ch... | ["\nassert reverse_substrings(\"abcdefg\", 3) == \"cbadefg\"\n", "\nassert reverse_substrings(\"abcdefgh\", 2) == \"bacdfegh\"\n", "\nassert reverse_substrings(\"abcdefgh\", 4) == \"dcbaefgh\"\n", "\nassert reverse_substrings(\"abcdefgh\", 8) == \"hgfedcba\"\n", "\nassert reverse_substrings(\"abcdefgh\", 9) == \"hgfedc... |
99757af53a81e4524fe6f6f9749f172d | [
{
"content": "On te donne deux dictionnaires, `source` et `destination`, ainsi qu'une fonction `merge_criteria`. Ta tâche est d'implémenter une fonction `merge_dictionaries` qui fusionne `source` dans `destination` de manière profonde. Si une valeur dans `source` est un dictionnaire, la fonction doit la fusionn... | ["\nassert merge_dictionaries({}, {}, lambda k, s, d: True) == {}\n", "\nassert merge_dictionaries({'a': 1}, {'b': 2}, lambda k, s, d: True) == {'a': 1, 'b': 2}\n", "\nassert merge_dictionaries({'a': {'b': 1}}, {'a': {'c': 2}}, lambda k, s, d: True) == {'a': {'b': 1, 'c': 2}}\n", "\nassert merge_dictionaries({'a': [1, ... |
1bbb52287d6d52ceae6050ddbe86634c | [
{
"content": "On te charge de valider un vaste ensemble de données de produits dans l'inventaire d'un magasin. L'ensemble de données est représenté sous forme de DataFrame pandas `df` avec les colonnes suivantes : `product_id`, `product_name`, `price`, `quantity_in_stock` et `last_restock_date`. Chaque produit ... | ["\nassert check_valid_products(pd.DataFrame({\n 'product_id': [1, 2, 3],\n 'product_name': ['A', 'B', 'C'],\n 'price': [10.0, 20.0, 30.0],\n 'quantity_in_stock': [100, 200, 300],\n 'last_restock_date': ['2023-01-01', '2023-01-02', '2023-01-03']\n})) == True\n", "\nassert check_valid_products(pd.DataFram... |
12530937bd606e6ff6add350c17cf10e | [
{
"content": "Tu es un archéologue qui a découvert un ancien coffre au trésor d'une capacité de `C` unités. Tu as `N` objets, chacun ayant un poids et une valeur spécifiques. Ton objectif est de maximiser la valeur totale des objets placés dans le coffre sans dépasser sa capacité. Implémente une fonction récurs... | ["\nassert fill_treasure_chest(5, [(2, 3), (3, 4), (4, 5), (5, 6)]) == 7\n", "\nassert fill_treasure_chest(10, [(2, 3), (3, 4), (4, 5), (5, 6)]) == 13\n", "\nassert fill_treasure_chest(0, [(2, 3), (3, 4), (4, 5), (5, 6)]) == 0\n", "\nassert fill_treasure_chest(3, [(2, 3), (3, 4), (4, 5), (5, 6)]) == 3\n", "\nassert fil... |
02c58fb5441d49b388e21ee510fb9e67 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de trier le tableau par ordre croissant en utilisant l'algorithme de tri rapide (quicksort). Implémente la fonction quicksort et renvoie le tableau trié.\n\n**Entrée :**\n- Un tableau d'entiers `arr` (1 ≤ len(arr) ≤ 1000), où chaque élément `arr[i]` s... | ["\nassert quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]\n", "\nassert quicksort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert quicksort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert quicksort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert quicksort([]) == []\n", "... |
6e0a8f59c95b969574f76fe0839d738c | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'implémenter une fonction `count_odd_even` qui renvoie un dictionnaire avec les clés `\"odd\"` et `\"even\"`, représentant le nombre de nombres impairs et pairs dans la liste, respectivement.\n\n**Entrée :**\n- Une liste d'entiers `numbe... | ["\nassert count_odd_even([1, 2, 3, 4, 5]) == {'odd': 3, 'even': 2}\n", "\nassert count_odd_even([2, 4, 6, 8, 10]) == {'odd': 0, 'even': 5}\n", "\nassert count_odd_even([1, 3, 5, 7, 9]) == {'odd': 5, 'even': 0}\n", "\nassert count_odd_even([]) == {'odd': 0, 'even': 0}\n", "\nassert count_odd_even([0]) == {'odd': 0, 'ev... |
0852639c2c20b0fef177209a3c4cbbdc | [
{
"content": "Tu développes un système pour une base de données géospatiale et tu dois implémenter une fonction pour générer des filtres pour interroger des données géographiques. Les filtres peuvent être de deux types : `PointFilter` ou `PolygonFilter`. Chaque filtre est représenté comme un dictionnaire avec l... | ["\nassert generate_geospatial_filter(\"PointFilter\", [-75.7598, 41.8781]) == {\"type\": \"Filter\", \"field_name\": \"location\", \"config\": {\"type\": \"PointFilter\", \"coordinates\": [-75.7598, 41.8781]}}\n", "\nassert generate_geospatial_filter(\"PolygonFilter\", [[-75.7598, 41.8781], [-73.9352, 40.7306], [-118.... |
a2bcbe76dc55a8e697e7ed270e3be1b8 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie une nouvelle liste contenant uniquement les nombres impairs de la liste originale. La fonction doit être efficace et concise.\n\n**Exemple d'entrée :**\n```\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n```\n\n**Exemple de sortie ... | ["\nassert filter_odd_numbers([1, 2, 3, 4, 5]) == [1, 3, 5]\n", "\nassert filter_odd_numbers([10, 22, 35, 47, 53]) == [35, 47, 53]\n", "\nassert filter_odd_numbers([2, 4, 6, 8, 10]) == []\n", "\nassert filter_odd_numbers([-1, -3, -5, -2, -4]) == [-1, -3, -5]\n", "\nassert filter_odd_numbers([]) == []\n", "\nassert filt... |
0207f29f49735b42ed13c6776258387e | [
{
"content": "On te donne une liste d'entiers `numbers` et une liste de fonctions `functions`. Chaque fonction dans `functions` prend exactement deux arguments entiers et renvoie un entier. Ta tâche est de mettre en œuvre une fonction `combine_elements` qui traite ces entrées et renvoie une nouvelle liste d'ent... | ["\nassert combine_elements([1, 2, 3], [lambda x, y: x + y]) == [3, 5, 4]\n", "\nassert combine_elements([1, 2, 3], [lambda x, y: x * y]) == [2, 3, 6]\n", "\nassert combine_elements([1, 2, 3], [lambda x, y: x - y]) == [-1, -2, 1]\n", "\nassert combine_elements([1, 2, 3], [lambda x, y: x + y, lambda x, y: x * y]) == [3,... |
69751213eadfc7e16342332e9b2855ad | [
{
"content": "On te donne deux ensembles d'entiers. Ta tâche est d'écrire une fonction Python qui calcule la différence symétrique de ces deux ensembles. La différence symétrique de deux ensembles est définie comme l'ensemble des éléments qui sont dans l'un ou l'autre des ensembles mais pas dans leur intersecti... | ["\nassert symmetric_difference({1, 2, 3}, {3, 4, 5}) == {1, 2, 4, 5}\n", "\nassert symmetric_difference({10, 20, 30}, {30, 40, 50}) == {10, 20, 40, 50}\n", "\nassert symmetric_difference({1, 1, 2, 2}, {2, 2, 3, 3}) == {1, 3}\n", "\nassert symmetric_difference(set(), {1, 2, 3}) == {1, 2, 3}\n", "\nassert symmetric_diff... |
5f61f2ca685de31cc1cf7c52eb88f237 | [
{
"content": "Tu dois implémenter un programme qui simule une partie de Tic-Tac-Toe sur une grille 4x4 entre un joueur humain et un joueur IA. Le jeu doit inclure des conditions de victoire en diagonale. Le joueur humain utilise 'X' et le joueur IA utilise 'O'. Le plateau est initialement vide et est représenté... | ["\nassert check_winner([['X', 'X', 'X', 'X'], [' ', ' ', ' ', ' '], [' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ']]) == 'X'\n", "\nassert check_winner([[' ', ' ', ' ', ' '], ['O', 'O', 'O', 'O'], [' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ']]) == 'O'\n", "\nassert check_winner([['X', ' ', ' ', ' '], ['X', ' ', ' ', ' '], ['X... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.