id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
3254e607a5680ff0a6c70076e779e0fa | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ton objectif est d'implémenter une fonction qui identifie le premier caractère dans la chaîne qui apparaît plus d'une fois. Si tous les caractères de la chaîne sont uniques, la fonction doit renvoyer `No... | ["\nassert first_recurring_character(\"abc\") == None\n", "\nassert first_recurring_character(\"aabbcc\") == \"a\"\n", "\nassert first_recurring_character(\"abcdefgabc\") == \"a\"\n", "\nassert first_recurring_character(\"xyzzy\") == \"z\"\n", "\nassert first_recurring_character(\"hello world\") == \"l\"\n", "\nassert ... |
7eb06a299e69f5f3c6e999d543e58e09 | [
{
"content": "On te donne un fichier texte nommé `gene_mapping.txt` contenant des noms de gènes et leurs identifiants de protéines correspondants, séparés par un caractère de tabulation. Chaque ligne du fichier représente une paire gène-protéine unique. Certains gènes peuvent être associés à plusieurs identifia... | ["\nassert read_gene_mapping('test1.txt') == {'GeneA': ['Protein1'], 'GeneB': ['Protein2']}\n", "\nassert read_gene_mapping('test2.txt') == {'GeneX': ['ProteinX1', 'ProteinX2'], 'GeneY': ['ProteinY1']}\n", "\nassert read_gene_mapping('test3.txt') == {'Gene1': ['Protein1'], 'Gene2': ['Protein2'], 'Gene3': ['Protein3']}\... |
1032dcbcf195a2fc3554a6c90757a3ba | [
{
"content": "Étant donné une chaîne de caractères `s` de 100 caractères maximum, détermine la chaîne lexicographiquement la plus petite qui peut être formée en faisant tourner n'importe quelle sous-chaîne de `s`.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1 ≤ |s| ≤ 100) composée de lettres minuscul... | ["\nassert smallest_rotation(\"rotation\") == \"ationro\"\n", "\nassert smallest_rotation(\"abc\") == \"abc\"\n", "\nassert smallest_rotation(\"bca\") == \"abc\"\n", "\nassert smallest_rotation(\"cab\") == \"abc\"\n", "\nassert smallest_rotation(\"aaaa\") == \"aaaa\"\n", "\nassert smallest_rotation(\"abab\") == \"aabb\... |
9f432de79f458378609b7975a4a6e20b | [
{
"content": "On te donne une liste 2D `logprobs` où chaque ligne représente un ensemble de probabilités logarithmiques. Ta tâche est de normaliser ces probabilités de manière numériquement stable. Pour chaque ligne, identifie d'abord la probabilité logarithmique maximale, multiplie-la par un exposant donné, pu... | ["\nassert normalize_logprobs([[0, 0, 0]], 1) == [[1/3, 1/3, 1/3]]\n", "\nassert normalize_logprobs([[-1, -2, -3]], 1) == [1, 0, 0]\n", "\nassert normalize_logprobs([[1, 2, 3]], 1) == [0, 0, 1]\n", "\nassert normalize_logprobs([[0, 0, 0], [0, 0, 0]], 1) == [[1/3, 1/3, 1/3], [1/3, 1/3, 1/3]]\n", "\nassert normalize_logp... |
fb876368a8034b2fea7d9cdf2c32491a | [
{
"content": "Tu participes à une compétition d'apprentissage automatique où tu dois implémenter une fonction pour calculer la dérivée de la perte d'entropie croisée pour la classification binaire. La fonction doit gérer les cas où la sortie du modèle n'est pas strictement comprise entre 0 et 1 en raison de pro... | ["\nassert compute_derivative_cross_entropy(0.5, 1) == 1.0\n", "\nassert compute_derivative_cross_entropy(0.5, 0) == -1.0\n", "\nassert compute_derivative_cross_entropy(0.99, 1) == 0.010101010101010102\n", "\nassert compute_derivative_cross_entropy(0.01, 0) == -0.010101010101010102\n", "\nassert compute_derivative_cros... |
fd788a16625551636d9cfadf7d5a9cf1 | [
{
"content": "On te demande d'implémenter une fonction récursive nommée `factorial` qui calcule la factorielle d'un entier non négatif donné. 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 ... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(5) == 120\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(15) == 1307674368000\n", "\ntry:\n factorial(-1)\nexcept ValueError as e:\n assert str(e)... |
e1f9b10e37543d98bd9bba1c9bbe7b51 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction Python `find_largest_prime` qui identifie et renvoie le plus grand nombre premier de la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ l... | ["\nassert find_largest_prime([10, 15, 3, 7, 11, 19]) == 19\n", "\nassert find_largest_prime([4, 6, 8, 10]) == None\n", "\nassert find_largest_prime([2, 3, 5, 7, 11, 13]) == 13\n", "\nassert find_largest_prime([29, 15, 23, 17, 19]) == 29\n", "\nassert find_largest_prime([1, 0, -1, -3]) == None\n", "\nassert find_larges... |
bdf7abdead2528eeb7cedaf2bcf9c60c | [
{
"content": "On te demande d'implémenter une classe `Polynomial` qui représente une expression polynomiale. La classe doit avoir une méthode d'initialisation `__init__` qui prend une liste de coefficients en argument. Les coefficients doivent être stockés dans l'ordre du terme de plus haut degré au terme const... | ["\nassert Polynomial([1, 2, 3]).evaluate(0) == 3\n", "\nassert Polynomial([1, 2, 3]).evaluate(1) == 6\n", "\nassert Polynomial([1, 2, 3]).evaluate(2) == 15\n", "\nassert Polynomial([3, 2, 1]).evaluate(2) == 17\n", "\nassert Polynomial([1, 0, -1]).evaluate(1) == 0\n", "\nassert (Polynomial([3, 2, 1]) + Polynomial([1, 0... |
17080a4dbb0db1ab48a5937153f20b91 | [
{
"content": "On te donne un extrait de code Python qui effectue deux opérations distinctes : calculer une somme pondérée de produits et sommer une liste de nombres. Ta tâche est de refactoriser le code pour améliorer son efficacité et sa lisibilité sans en altérer la fonctionnalité.\n\n**Spécifications des fon... | ["\nassert calc(1, 2, 3, 4, 5, 6, 7, 8) == 60 + 120 + 56\n", "\nassert calc(0, 0, 0, 0, 0, 0, 0, 0) == 0\n", "\nassert calc(-1, -2, -3, -4, -5, -6, -7, -8) == -60 - 120 - 56\n", "\nassert calc(1, 1, 1, 1, 1, 1, 1, 1) == 3\n", "\nassert calc(2, 3, 4, 5, 6, 7, 8, 9) == 24 + 210 + 72\n", "\nassert process_data([1, 2, 3, 4... |
bc89210a905285deb9f199e96ebee9da | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne peut contenir des espaces au début et à la fin. Ton objectif est d'écrire une fonction Python qui renvoie une liste de tuples. Chaque tuple doit contenir une chaîne de caractères (avec les espaces de début et de fin supprimés) et sa ... | ["\nassert string_frequencies([\"apple\", \"banana\", \"apple \", \"orange\", \"banana\", \" apple\"]) == [(\"apple\", 3), (\"banana\", 2), (\"orange\", 1)]\n", "\nassert string_frequencies([\" hello\", \"hello \", \"hello\"]) == [(\"hello\", 3)]\n", "\nassert string_frequencies([\"test\", \"test\", \"test\", \"test\... |
8310d4f672b861a6ccbc3180d1da3cef | [
{
"content": "On te donne deux listes d'entiers positifs distincts, `A` et `B`, de longueurs `n` et `m` respectivement. Ta tâche est de trouver une paire d'entiers `(a, b)` où `a` provient de la liste `A` et `b` de la liste `B`, telle que le plus petit commun multiple (PPCM) de `a` et `b` soit minimisé. Retourn... | ["\nassert find_min_lcm(3, 3, [2, 3, 5], [4, 6, 10]) == (2, 4)\n", "\nassert find_min_lcm(2, 2, [7, 14], [21, 28]) == (7, 21)\n", "\nassert find_min_lcm(1, 1, [5], [10]) == (5, 10)\n", "\nassert find_min_lcm(4, 4, [1, 2, 3, 4], [5, 6, 7, 8]) == (1, 5)\n", "\nassert find_min_lcm(3, 2, [15, 25, 35], [5, 10]) == (5, 15)\n... |
cb0efea3880f6bee46fd49292452e2ef | [
{
"content": "On te demande de développer un programme pour aider un étudiant à suivre ses dépenses mensuelles. Implémente une classe nommée `ExpenseTracker` avec les fonctionnalités suivantes :\n\n- `add_expense(category, amount)` : Ajoute une dépense au suivi. Le paramètre `category` est une chaîne de caractè... | ["\nassert ExpenseTracker().get_total_expense() == 0.0\n", "\nassert ExpenseTracker().get_expenses_by_category('Food') == 0.0\n", "\nassert ExpenseTracker().get_category_summary() == {}\n", "\ntracker = ExpenseTracker()\ntracker.add_expense('Food', 50.0)\nassert tracker.get_total_expense() == 50.0\n", "\ntracker = Expe... |
cae36bdc590c28fb2e15a6ff7b1b54fc | [
{
"content": "On te donne une chaîne de caractères contenant plusieurs expressions mathématiques séparées par des points-virgules. Chaque expression est composée d'entiers et des opérateurs `+`, `-`, `*` et `/`. Ta tâche est d'évaluer chaque expression en respectant l'ordre des opérations (PEMDAS/BODMAS) et d'a... | ["\nassert evaluate_expressions(\"2 + 3 * 4; 5 / 2\") == None\n", "\nassert evaluate_expressions(\"10 - 2 * 3; 8 / 4\") == None\n", "\nassert evaluate_expressions(\"7 + 8 / 4; 9 * 2\") == None\n", "\nassert evaluate_expressions(\"15 / 3 + 2; 10 - 5 * 2\") == None\n", "\nassert evaluate_expressions(\"100 * 2 - 50; 200 /... |
1ed259fa60c581621cf9eff9410b17ac | [
{
"content": "Implémente un algorithme QuickSort récursif pour trier une liste d'entiers donnée. L'algorithme doit gérer les éléments dupliqués et maintenir l'ordre relatif des éléments égaux (c'est-à-dire qu'il doit s'agir d'un tri stable).\n\n**Entrée :**\n- Une liste d'entiers `iterable` (1 ≤ len(iterable) ≤... | ["\nassert recursive_quick_sort([3, 6, 8, 10, 1, 2, 1]) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert recursive_quick_sort([5, 3, 8, 4, 2, 7, 1, 10]) == [1, 2, 3, 4, 5, 7, 8, 10]\n", "\nassert recursive_quick_sort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert recursive_quick_sort([1, 2, 3,... |
96e2658eb0e86d77b3409688ff394e0e | [
{
"content": "On te donne un dictionnaire représentant un objet JSON. Ta tâche est d'écrire une fonction Python qui convertit toutes les clés du dictionnaire en camelCase. La fonction doit également gérer les dictionnaires et les listes imbriqués. Par exemple, étant donné l'entrée `{\"first_name\": \"John\", \"... | ["\nassert convert_to_camel_case({\"first_name\": \"John\", \"last_name\": \"Doe\"}) == {\"firstName\": \"John\", \"lastName\": \"Doe\"}\n", "\nassert convert_to_camel_case({\"person\": {\"first_name\": \"John\", \"last_name\": \"Doe\"}}) == {\"person\": {\"firstName\": \"John\", \"lastName\": \"Doe\"}}\n", "\nassert c... |
a026649ea5f7c2f8fa13643f0c132707 | [
{
"content": "Étant donné une liste d'entiers positifs d'une longueur minimale de 4, détermine la somme des deux plus petits nombres pairs qui ne sont pas divisibles par 10. Si le nombre de tels nombres est inférieur à deux, renvoie -1.\n\n**Exemple d'entrée :**\n```\n[12, 14, 21, 25, 8, 34, 10]\n```\n\n**Exemp... | ["\nassert sum_of_two_smallest_evens_not_divisible_by_10([2, 4, 6, 8]) == 6\n", "\nassert sum_of_two_smallest_evens_not_divisible_by_10([10, 20, 30, 40]) == -1\n", "\nassert sum_of_two_smallest_evens_not_divisible_by_10([12, 14, 16, 18]) == 26\n", "\nassert sum_of_two_smallest_evens_not_divisible_by_10([8, 12, 14, 10])... |
c9d57acd41e39be57112bd76c7f6da58 | [
{
"content": "On te donne une chaîne de caractères `text` et une liste de `patterns`. Ta tâche est de diviser la chaîne `text` en utilisant les `patterns`, en tenant compte des séquences d'échappement et des délimiteurs imbriqués à l'intérieur des sous-chaînes entre guillemets. Plus précisément, les sous-chaîne... | ["\nassert split_by_patterns('This is a test', ['is']) == ['Th', ' ', ' a test']\n", "\nassert split_by_patterns('This is a \"test with quotes\"', ['is']) == ['Th', ' ', ' a \"test with quotes\"']\n", "\nassert split_by_patterns('This is a \"test with | quotes\"', ['|']) == ['This is a \"test with ', ' quotes\"']\n", "... |
208ef2656975ae1cbed91b72b52759c5 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui identifie et renvoie les deux plus grands nombres distincts de la liste. Si la liste contient moins de deux nombres distincts, la fonction doit renvoyer un tuple avec `None` pour les nombres manquants. La fonction d... | ["\nassert find_two_largest_distinct([7, 1, 3, 7, 4]) == (7, 4)\n", "\nassert find_two_largest_distinct([1, 2, 3, 4, 5]) == (5, 4)\n", "\nassert find_two_largest_distinct([5, 5, 5, 5, 5]) == (5, None)\n", "\nassert find_two_largest_distinct([10]) == (10, None)\n", "\nassert find_two_largest_distinct([]) == (None, None)... |
44cde980dcc4e3b83698aabd6a354809 | [
{
"content": "On te demande d'implémenter une fonction `div_mod` qui effectue des opérations de division et de modulo sans utiliser d'opérateurs de division ou de modulo intégrés. Ta fonction doit gérer à la fois les entiers positifs et négatifs et renvoyer le résultat comme spécifié.\n\n**Signature de la fonct... | ["\nassert div_mod(10, 3, True) == \"3, 1\"\n", "\nassert div_mod(-10, 3, True) == \"-3, 2\"\n", "\nassert div_mod(10, -3, True) == \"-3, 2\"\n", "\nassert div_mod(-10, -3, True) == \"3, 1\"\n", "\nassert div_mod(5, 2, False) == \"2\"\n", "\nassert div_mod(0, 5, True) == \"0, 0\"\n", "\nassert div_mod(5, 0, True) == \"... |
8fe6e7139090d230eced4b363c683a6e | [
{
"content": "On te donne un dictionnaire imbriqué `data`. Ton objectif est d'écrire une fonction `get_data_types` qui renvoie un nouveau dictionnaire où chaque valeur est remplacée par son type de données sous forme de chaîne de caractères. La fonction doit gérer correctement les dictionnaires imbriqués.\n\n**... | ["\nassert get_data_types({\"key\": 123}) == {\"key\": \"int\"}\n", "\nassert get_data_types({\"key\": \"value\"}) == {\"key\": \"str\"}\n", "\nassert get_data_types({\"key\": [1, 2, 3]}) == {\"key\": \"list\"}\n", "\nassert get_data_types({\"key\": {\"subkey\": 45.67}}) == {\"key\": {\"subkey\": \"float\"}}\n", "\nass... |
0ecef150e019d3428f2e7c876150306f | [
{
"content": "On te donne une collection d'ensembles, `part_sets`, où chaque ensemble contient des éléments uniques. Ta tâche est d'implémenter une fonction `add_and_reduce_sets(part_sets, newset, reduce_callback=None)` qui ajoute un nouvel ensemble `newset` à `part_sets` et réduit les ensembles existants dans ... | ["\nassert add_and_reduce_sets({frozenset({1, 2}), frozenset({3})}, {1, 2, 3}) == True\n", "\nassert add_and_reduce_sets({frozenset({1, 2}), frozenset({3})}, {1, 2}) == False\n", "\nassert add_and_reduce_sets({frozenset({1}), frozenset({2}), frozenset({3})}, {1, 2, 3}) == True\n", "\nassert add_and_reduce_sets({frozens... |
b32edc747d66145620bb29dcb5dec9b2 | [
{
"content": "On te donne une liste 2D `table` représentant un tableau, où chaque liste interne est une ligne du tableau. Le tableau est constitué de plusieurs lignes d'en-tête au début, suivies de lignes de données. Chaque cellule du tableau est une chaîne de caractères. Une ligne d'en-tête est définie comme u... | ["\nassert extract_headers([[\"a\", \"bb\", \"ccc\"], [\"dddd\", \"eeeee\"], [\"ffffff\"]]) == [[\"a\", \"bb\", \"ccc\"]]\n", "\nassert extract_headers([[\"p\", \"qr\", \"stuv\"], [\"wxyz\", \"12345\"], [\"6789\"]]) == [[\"p\", \"qr\", \"stuv\"]]\n", "\nassert extract_headers([[\"ab\", \"cde\", \"fghi\"], [\"jklm\", \"... |
66b442dfd2782698d75dbeed8799dbdd | [
{
"content": "On te demande d'implémenter une fonction `analyze_text` qui traite une chaîne de texte donnée et renvoie un dictionnaire contenant diverses statistiques sur le texte. Le dictionnaire doit inclure les clés suivantes :\n\n- `word_count` : Le nombre total de mots dans le texte.\n- `sentence_count` : ... | ["\nassert analyze_text(\"Hello world! Hello everyone. Welcome to the world of programming.\") == {'word_count': 11, 'sentence_count': 3, 'letter_count': 56, 'average_word_length': 5.090909090909091, 'most_common_word': 'hello'}\n", "\nassert analyze_text(\"This is a test. This test is only a test.\") == {'word_count':... |
42740e1187405137749dbc5305efaa47 | [
{
"content": "On te donne la tâche de traiter un fichier CSV contenant une liste de produits et de leurs prix. Ton objectif est d'écrire une fonction Python qui lit ce fichier, trie les produits par prix par ordre décroissant et affiche la liste triée. Le fichier CSV a le format suivant : `product_name,price`. ... | ["\nassert print_sorted_products(\"non_existent_file.csv\") is None\n", "\nassert print_sorted_products(\"invalid_data.csv\") is None\n", "\nassert print_sorted_products(\"empty_file.csv\") is None\n", "\nassert print_sorted_products(\"single_product.csv\") is None\n", "\nassert print_sorted_products(\"multiple_product... |
87521479a6be33c43a9c792935da3970 | [
{
"content": "On te donne une chaîne de caractères `text` contenant des expressions de liaison de données. Chaque expression est encadrée par des accolades `{}` et commence par un `prefix` spécifié. Ta tâche est de mettre en œuvre la fonction `extract_data_bindings` qui extrait toutes les expressions de liaison... | ["\nassert extract_data_bindings(\"Here is a {prefix:some} example.\", \"prefix:\", is_singular) == ['{prefix:some}']\n", "\nassert extract_data_bindings(\"{prefix:one} {prefix:two} {prefix:three}\", \"prefix:\", is_singular) == ['{prefix:one}', '{prefix:two}', '{prefix:three}']\n", "\nassert extract_data_bindings(\"{p... |
ea3029bade01289cb80936a55e66c197 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction `alpha_only_v2` qui traite cette chaîne et renvoie une nouvelle chaîne composée uniquement des caractères alphabétiques minuscules de `s` dans leur ordre d'origine. La fonction doit ignorer tous les caractères a... | ["\nassert alpha_only_v2(\"Hello, World!\") == \"helloworld\"\n", "\nassert alpha_only_v2(\"Caf\u00e9 123\") == \"cafe\"\n", "\nassert alpha_only_v2(\"\u3053\u3093\u306b\u3061\u306f\") == \"\"\n", "\nassert alpha_only_v2(\"Python 3.8\") == \"python\"\n", "\nassert alpha_only_v2(\"A quick brown fox jumps over the lazy d... |
56269a4367afe763fbdb23fa52f5e22f | [
{
"content": "On te donne une liste de `n` intervalles sur la droite numérique, où chaque intervalle est représenté comme un tuple de deux entiers `(début, fin)`. Ta tâche est de fusionner tous les intervalles qui se chevauchent et de renvoyer une nouvelle liste d'intervalles non chevauchants triés par leurs te... | ["\nassert merge_intervals([(1, 3), (2, 6), (8, 10), (15, 18)]) == [(1, 6), (8, 10), (15, 18)]\n", "\nassert merge_intervals([(1, 4), (4, 5)]) == [(1, 5)]\n", "\nassert merge_intervals([(1, 2), (3, 4), (5, 6)]) == [(1, 2), (3, 4), (5, 6)]\n", "\nassert merge_intervals([(1, 2), (2, 3)]) == [(1, 3)]\n", "\nassert merge_i... |
2fa096d3511932276425547fef26dc22 | [
{
"content": "Tu participes à un défi de shopping en ligne où l'on te fournit un dictionnaire `products` contenant les noms des produits comme clés et leurs prix respectifs comme valeurs. De plus, on te donne un `budget` qui représente le montant maximum d'argent que tu peux dépenser. Ta tâche est d'écrire une ... | ["\nassert find_affordable_products({'laptop': 1000, 'phone': 500, 'tablet': 300}, 700) == ['phone', 'tablet']\n", "\nassert find_affordable_products({'book': 15, 'pen': 5, 'notebook': 10}, 10) == ['pen', 'notebook']\n", "\nassert find_affordable_products({'guitar': 200, 'drums': 500, 'piano': 1000}, 100) == []\n", "\n... |
4083916c4e606034f785933ba652f29f | [
{
"content": "On te donne une liste de chaînes de caractères non vides. Ta tâche est de mettre en œuvre une fonction qui trouve le plus long préfixe commun parmi toutes les chaînes de caractères de la liste. S'il n'y a pas de préfixe commun, renvoie une chaîne vide.\n\n**Entrée :**\n- Une liste de chaînes de ca... | ["\nassert longest_common_prefix([\"flower\", \"flow\", \"flight\"]) == \"fl\"\n", "\nassert longest_common_prefix([\"dog\", \"racecar\", \"car\"]) == \"\"\n", "\nassert longest_common_prefix([\"interspecies\", \"interstellar\", \"interstate\"]) == \"inters\"\n", "\nassert longest_common_prefix([\"throne\", \"throne\"]... |
d99f6b0b54ed6956acc0320a43f910ca | [
{
"content": "On te demande d'écrire une fonction `generate_pyramid(n)` qui construit un motif de pyramide centré d'astérisques (*) d'une hauteur de `n`. Chaque niveau de la pyramide doit contenir un nombre croissant d'astérisques, en commençant par un au sommet. Si `n` est inférieur à 1, la fonction doit renvo... | ["\nassert generate_pyramid(1) == \"*\\n\"\n", "\nassert generate_pyramid(2) == \" *\\n***\\n\"\n", "\nassert generate_pyramid(3) == \" *\\n ***\\n*****\\n\"\n", "\nassert generate_pyramid(4) == \" *\\n ***\\n *****\\n*******\\n\"\n", "\nassert generate_pyramid(5) == \" *\\n ***\\n *****\\n *******\\n********... |
7b43efa265d3d3647661167b561697d0 | [
{
"content": "On te donne trois listes de longueur égale : `observed_values`, `expected_values` et `errors`. Chaque liste contient `n` nombres à virgule flottante représentant les valeurs observées, les valeurs attendues et les erreurs associées à une série de mesures, respectivement. De plus, on te donne un en... | ["\nassert calculate_reduced_chi_squared([1.0, 2.0, 3.0], [1.1, 1.9, 3.1], [0.1, 0.1, 0.1], 2) == 2.0\n", "\nassert calculate_reduced_chi_squared([1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [0.1, 0.1, 0.1], 3) == 0.0\n", "\nassert calculate_reduced_chi_squared([2.0, 4.0, 6.0], [2.1, 3.9, 6.1], [0.1, 0.1, 0.1], 2) == 2.0\n", "\na... |
b51aa1733c2348ed2464eb6cb8f209fa | [
{
"content": "On te demande d'implémenter une fonction de vue Django nommée `book_list` qui récupère toutes les entrées du modèle `Book` et les renvoie au format JSON. Le modèle `Book` contient au moins les champs `title` et `author`. Ta fonction doit renvoyer une réponse JSON avec une clé `books` qui correspon... | ["\nassert book_list(None).json() == {'books': []}\n", "\nassert book_list(None).status_code == 200\n", "\nassert book_list(None).content_type == 'application/json'\n", "\nassert book_list(None).json()['books'] == [{'title': 'Book1', 'author': 'Author1'}] if Book.objects.create(title='Book1', author='Author1') else Tru... |
2c75cae0419eaa17ad581946e04476ee | [
{
"content": "On te demande d'implémenter un arbre de recherche binaire (ARB) en Python. Ton ARB doit prendre en charge les opérations suivantes :\n\n- **Insert** : Insérer un nouveau nœud avec une valeur donnée dans l'ARB.\n- **Delete** : Supprimer un nœud avec une valeur donnée de l'ARB.\n- **Search** : Vérif... | ["\nassert BinaryTree().inorder_traversal() == []\n", "\nassert BinaryTree().search(10) == False\n", "\ntree = BinaryTree()\ntree.insert(10)\nassert tree.inorder_traversal() == [10]\n", "\ntree = BinaryTree()\ntree.insert(10)\ntree.insert(5)\ntree.insert(15)\nassert tree.inorder_traversal() == [5, 10, 15]\n", "\ntree =... |
a4ec92a6339e5387f0318335c5ce7a40 | [
{
"content": "Tu participes à un concours de programmation où tu dois implémenter une fonction pour interagir avec un fournisseur de services cloud, \"CloudX\". Ta tâche est de créer une fonction nommée `get_storage_info` qui récupère des informations de stockage depuis CloudX.\n\nLa fonction `get_storage_info`... | ["\nassert get_storage_info(client, \"rg1\", \"storage1\") == {'storage_name': 'storage1', 'storage_type': 'SSD', 'storage_size': 100, 'creation_time': '2023-01-01 12:00:00'}\n", "\nassert get_storage_info(client, \"rg2\", \"storage2\") == {'storage_name': 'storage2', 'storage_type': 'HDD', 'storage_size': 500, 'creati... |
ad277d737b107d33a6778144ab451295 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `power`. Ta tâche est d'implémenter une fonction `compute_sum_of_powers` qui calcule la somme de chaque nombre dans la liste élevé à la puissance fournie. La fonction doit gérer les cas suivants :\n- Si `numbers` n'est pas une liste, lève une ... | ["\nassert compute_sum_of_powers([1, 2, 3], 2) == 14\n", "\nassert compute_sum_of_powers([2, 3, 4], 3) == 99\n", "\nassert compute_sum_of_powers([], 2) == 0\n", "\nassert compute_sum_of_powers([1, 1, 1, 1], 4) == 4\n", "\nassert compute_sum_of_powers([5], 2) == 25\n", "\nassert compute_sum_of_powers([1, 2, 3], 2, 10) =... |
098636b8a8f43638ac662406b9265afc | [
{
"content": "On te demande de développer un script Python pour traiter un fichier CSV contenant des données clients. Le fichier CSV comprend les colonnes suivantes : identifiant client, prénom, nom, adresse e-mail et numéro de téléphone. Ton script doit effectuer les opérations de nettoyage de données suivante... | ["\nassert process_csv('test_input_1.csv', 'test_output_1.csv') is None\n", "\nassert pd.read_csv('test_output_1.csv').equals(pd.DataFrame({\n 'customer ID': [1, 2],\n 'first name': ['John', 'Jane'],\n 'last name': ['Doe', 'Smith'],\n 'email': ['john.doe@example.com', 'jane.smith@example.com'],\n 'phone ... |
6b939b41bbe7f0b4a1d2309967ea33f4 | [
{
"content": "Dans ce problème, tu dois implémenter une fonction `capitalize_words(sentence)` qui traite une chaîne de caractères donnée `sentence`. La fonction doit renvoyer une nouvelle chaîne où la première lettre de chaque mot est mise en majuscule, à condition que le mot ait 3 caractères ou plus. Les mots ... | ["\nassert capitalize_words(\"the quick brown fox jumps over the lazy dog\") == \"The Quick Brown Fox Jumps Over the Lazy Dog\"\n", "\nassert capitalize_words(\"a\") == \"a\"\n", "\nassert capitalize_words(\"ab\") == \"ab\"\n", "\nassert capitalize_words(\"abc\") == \"Abc\"\n", "\nassert capitalize_words(\"hello world\... |
59fd37dc70796476238b901da50aff52 | [
{
"content": "On te demande d'implémenter une fonction pour calculer l'indice de masse corporelle (IMC) d'un individu donné. L'IMC est une mesure de la graisse corporelle basée sur la taille et le poids. Ta fonction doit accepter deux nombres à virgule flottante en entrée : le poids en kilogrammes et la taille ... | ["\nassert calculate_bmi(70, 1.75) == 22.86\n", "\nassert calculate_bmi(50, 1.60) == 19.53\n", "\nassert calculate_bmi(80, 1.80) == 24.69\n", "\nassert calculate_bmi(90, 1.70) == 31.13\n", "\nassert calculate_bmi(60, 1.65) == 22.04\n", "\nassert calculate_bmi(100, 2.00) == 25.00\n", "\nassert calculate_bmi(45, 1.55) ==... |
c87292000785814d0eddb326d6fda2eb | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'implémenter une fonction `format_number` qui formate le nombre selon les règles suivantes :\n- Si `n` est supérieur ou égal à 1 000 000, formate-le en notation scientifique avec deux décimales.\n- Si `n` est compris entre 1 000 et 999 999, formate-... | ["\nassert format_number(999) == \"999\"\n", "\nassert format_number(1000) == \"1,000\"\n", "\nassert format_number(12345) == \"12,345\"\n", "\nassert format_number(999999) == \"999,999\"\n", "\nassert format_number(1000000) == \"1.00e+06\"\n", "\nassert format_number(1234567) == \"1.23e+06\"\n", "\nassert format_numbe... |
871be4a43268609b9f7884c14e63e6ac | [
{
"content": "On te donne une liste de tuples, où chaque tuple représente un point de données avec trois éléments : `(valeur, horodatage, unité)`. La `valeur` est un nombre à virgule flottante, `horodatage` est un entier représentant le temps en microsecondes, et `unité` est une chaîne de caractères représentan... | ["\nassert calculate_sampling_frequency([]) == 0.0\n", "\nassert calculate_sampling_frequency([(1.0, 1000000, 'm')]) == 0.0\n", "\nassert calculate_sampling_frequency([(1.0, 1000000, 'm'), (2.0, 2000000, 'm')]) == 1.0\n", "\nassert calculate_sampling_frequency([(1.0, 1000000, 'm'), (2.0, 2500000, 'm')]) == 0.8\n", "\na... |
6b09d825c8943491cf46b9ea63bfd621 | [
{
"content": "On te donne un nombre de départ. Génère une séquence où chaque nombre suivant est la somme des carrés des chiffres du nombre précédent. Continue à générer la séquence jusqu'à ce qu'un cycle soit détecté. Un cycle est détecté lorsqu'un nombre se répète dans la séquence. Retourne la séquence jusqu'a... | ["\nassert generate_sequence(123) == [123, 14, 17, 50, 25, 29, 85, 89, 145, 42, 20, 4, 16, 37, 58, 89]\n", "\nassert generate_sequence(1) == [1, 1]\n", "\nassert generate_sequence(10) == [10, 1, 1]\n", "\nassert generate_sequence(100) == [100, 1, 1]\n", "\nassert generate_sequence(13) == [13, 10, 1, 1]\n", "\nassert ge... |
8137d29d348e4b68b9e43dcbec1f37bf | [
{
"content": "On te donne une chaîne de caractères `quantity` représentant un nombre en notation scientifique ou décimale, qui désigne une quantité en mégaoctets. Ton objectif est d'écrire une fonction `convert_to_bytes(quantity: str) -> int` qui convertit cette quantité en octets. La conversion doit être préci... | ["\nassert convert_to_bytes(\"1\") == 1048576\n", "\nassert convert_to_bytes(\"2.34\") == 2452725\n", "\nassert convert_to_bytes(\"1.60E+01\") == 16777216\n", "\nassert convert_to_bytes(\"0.5\") == 524288\n", "\nassert convert_to_bytes(\"0.001\") == 1048\n", "\nassert convert_to_bytes(\"1048576\") == 1099511627776\n", ... |
d295d12d87b9dca8ec17c5c99ef4c019 | [
{
"content": "On te donne deux listes de distances, `distances1` et `distances2`, représentant les distances entre les points clés correspondants dans deux images différentes. Ta tâche est de calculer la précision moyenne pour un seuil de correction donné. Tu dois implémenter ton propre algorithme de tri et ne ... | ["\nassert compute_average_precision([0.1, 0.3], [0.2, 0.4], 0.5) == 0.75\n", "\nassert compute_average_precision([0.1, 0.2], [0.3, 0.4], 0.1) == 1.0\n", "\nassert compute_average_precision([0.6, 0.7], [0.1, 0.2], 0.5) == 0.0\n", "\nassert compute_average_precision([0.1, 0.2, 0.3], [0.4, 0.5, 0.6], 0.35) == 0.833333333... |
471e8afa863b05f581e8567d230e1b41 | [
{
"content": "Tu développes un jeu qui nécessite une carte basée sur une grille. La carte est représentée comme une liste 2D où chaque cellule est initialement définie sur 0. Ta tâche est de créer une fonction `generate_game_map` qui génère cette carte. La fonction doit accepter trois paramètres : `width` et `h... | ["\nassert generate_game_map(0, 0, []) == [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n", "\nassert generate_game_map(1, 1, []) == [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n", "\nassert generate_game_map(2, 2, [(1, 1)]) == [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]\n", "\nassert generate_game_map(3, 3, [(0, 0), (2, 2)]) =... |
7d95cdbfe8bb6d77cef0e1b8a7253b71 | [
{
"content": "On te demande d'implémenter une classe `EmailValidator` en Python pour vérifier la validité des adresses e-mail en fonction de critères spécifiques. La classe doit inclure les méthodes suivantes :\n\n- `__init__(self, email)` : Initialise le validateur avec l'adresse e-mail à valider.\n- `is_valid... | ["\nassert EmailValidator(\"example@example.com\").is_valid() == True\n", "\nassert EmailValidator(\"user.name@domain.co\").is_valid() == True\n", "\nassert EmailValidator(\"user_name@domain.com\").is_valid() == True\n", "\nassert EmailValidator(\"user-name@domain.co.uk\").is_valid() == False\n", "\nassert EmailValidat... |
4c20e072f0426bb30e7d7ab388232d88 | [
{
"content": "On te demande d'implémenter une fonction `validate_padding` qui vérifie si une chaîne d'octets donnée `padded_msg` est correctement remplie selon la norme PKCS#7 avec une taille de bloc spécifiée `block_size`. La fonction doit renvoyer le message non rempli si le remplissage est valide, ou `None` ... | ["\nassert validate_padding(b'\\x01', 1) == b''\n", "\nassert validate_padding(b'\\x02\\x02', 2) == b''\n", "\nassert validate_padding(b'abc\\x03\\x03\\x03', 3) == b'abc'\n", "\nassert validate_padding(b'hello\\x05\\x05\\x05\\x05\\x05', 5) == b'hello'\n", "\nassert validate_padding(b'padding\\x07\\x07\\x07\\x07\\x07\\x... |
31902d9b4db31ff56bc60a2e96a5c02d | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction qui trouve et renvoie la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes palindromiques de longueur maximale identique, renvoie l'une d'entre elles. Si aucune sous-chaîne palin... | ["\nassert longest_palindromic_substring(\"babad\") == \"bab\" or longest_palindromic_substring(\"babad\") == \"aba\"\n", "\nassert longest_palindromic_substring(\"cbbd\") == \"bb\"\n", "\nassert longest_palindromic_substring(\"a\") == \"a\"\n", "\nassert longest_palindromic_substring(\"ac\") == \"a\" or longest_palind... |
9d0bb98f81ed21dcdf66ba452588d1b6 | [
{
"content": "Tu es chargé d'implémenter une classe `Book` qui encapsule les détails d'un livre. La classe doit avoir les attributs suivants : `title`, `author` et `year`. Ton implémentation doit inclure une méthode d'initialisation `__init__` pour définir ces attributs et une méthode `get_details` qui renvoie ... | ["\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... |
f8da07c0e3c5040ff7a89f2517c6cf7d | [
{
"content": "Dans une suite de Fibonacci non standard, chaque terme est la somme des trois termes précédents, en commençant par 0, 1, 1. Étant donné un entier `n`, calcule la factorielle du nième terme de cette suite. Si `n` est inférieur à 0, retourne 0.\n\n**Entrée :**\n- Un entier `n` (0 ≤ n ≤ 20)\n\n**Sort... | ["\nassert fib_factorial(-1) == 0\n", "\nassert fib_factorial(0) == 1\n", "\nassert fib_factorial(1) == 1\n", "\nassert fib_factorial(2) == 1\n", "\nassert fib_factorial(3) == 2\n", "\nassert fib_factorial(4) == 6\n", "\nassert fib_factorial(5) == 6\n", "\nassert fib_factorial(6) == 120\n", "\nassert fib_factorial(7) =... |
338db8dbc2a697ba2d34942adcffe8c1 | [
{
"content": "On te donne une matrice représentée comme une liste de listes d'entiers. Ta tâche est d'implémenter une fonction `count_negatives` qui compte le nombre d'entiers négatifs dans la matrice. Si un entier dans la matrice est inférieur à -100, la fonction doit renvoyer -1 pour indiquer une erreur.\n\n*... | ["\nassert count_negatives([[1, 2, 3], [4, 5, 6]]) == 0\n", "\nassert count_negatives([[-1, -2, -3], [-4, -5, -6]]) == 6\n", "\nassert count_negatives([[1, -2, 3], [-4, 5, -6]]) == 3\n", "\nassert count_negatives([[-101, 2, 3], [4, 5, 6]]) == -1\n", "\nassert count_negatives([[100, 200, 300], [-100, -200, -300]]) == 3\... |
55a52dfe5496f4fe2fa9c594ac0a51bd | [
{
"content": "On te donne une chaîne de caractères `S` représentant une image encodée en base64. Ta tâche est de mettre en œuvre une fonction qui décode cette chaîne et renvoie l'image originale sous forme de flux binaire. La fonction doit gérer toute chaîne d'image encodée en base64 valide et garantir l'intégr... | ["\nassert base64_to_binary_stream(\"SGVsbG8gV29ybGQh\") == b\"Hello World!\"\n", "\nassert base64_to_binary_stream(\"SGVsbG8gV29ybGQh==\") == b\"Hello World!\"\n", "\nassert base64_to_binary_stream(\"SGVsbG8gV29ybGQh====\") == b\"Hello World!\"\n", "\nassert base64_to_binary_stream(\"SGVsbG8gV29ybGQ\") == b\"Hello Wor... |
ec549e898e8dc81262a1c016f472426e | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates` qui renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, en conservant l'ordre de leur première apparition.\n\n**Entrée :**\n- Une liste d'entiers `input_list` (1 ≤ l... | ["\nassert remove_duplicates([1, 2, 2, 3, 1, 4]) == [1, 2, 3, 4]\n", "\nassert remove_duplicates([5, 5, 5, 5, 5]) == [5]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 20, 30, 40]) == [10, 20, 30, 40]\n", "\nassert remove_duplicates([1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == [1, 2, 3, 4]\n... |
b5ed0982bc8d4d2c7d33b161ce7f2892 | [
{
"content": "On te donne deux fichiers CSV, chacun contenant des enregistrements des notes des élèves d'une classe. Chaque fichier a le format suivant : `student_name, assignment_name, grade`. Ta tâche est d'écrire une fonction Python qui lit ces deux fichiers et fusionne leur contenu dans un seul DataFrame. L... | ["\nassert merge_grades(\"test1.csv\", \"test2.csv\").equals(pd.DataFrame({\n \"student_name\": [\"Alice\", \"Bob\", \"Charlie\", \"David\"],\n \"assignment_name\": [\"Math\", \"Science\", \"Math\", \"Science\"],\n \"grade\": [88, 92, 78, 85]\n}))\n", "\nassert merge_grades(\"test1.csv\", \"test2.csv\").shape ... |
69aa61c84f34d5b116d92916e0f0880e | [
{
"content": "On te demande d'implémenter une fonction `deep_copy` qui construit une copie profonde d'un objet donné. La fonction doit gérer divers types de données, notamment les listes, les dictionnaires et les objets personnalisés. Tu n'es pas autorisé à utiliser des fonctions ou des bibliothèques de copie p... | ["\nassert deep_copy([1, 2, 3]) == [1, 2, 3]\n", "\nassert deep_copy({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert deep_copy([{'a': 1}, {'b': 2}]) == [{'a': 1}, {'b': 2}]\n", "\nassert deep_copy([1, [2, [3, 4]]]) == [1, [2, [3, 4]]]\n", "\nassert deep_copy({'a': {'b': {'c': 3}}}) == {'a': {'b': {'c': 3}}}\n", "\n... |
a94d2adb135c40ea68af92ea5ad29424 | [
{
"content": "On te donne un tableau trié par ordre non décroissant `arr` et une valeur `val`. Ta tâche est de trouver le plus grand élément dans `arr` qui est strictement inférieur à `val` en utilisant un algorithme de recherche binaire. Si un tel élément n'existe pas, retourne `None`. Après avoir trouvé cet é... | ["\nassert find_strict_lower_bound([1, 2, 4, 5, 6], 3) == [2, 1, 4, 5, 6]\n", "\nassert find_strict_lower_bound([1, 3, 5, 7, 9], 10) == [9, 7, 5, 3, 1]\n", "\nassert find_strict_lower_bound([1, 3, 5, 7, 9], 1) == None\n", "\nassert find_strict_lower_bound([1, 2, 3, 4, 5], 6) == [5, 4, 3, 2, 1]\n", "\nassert find_strict... |
4ba1cbad33769948e51afac4dfefd75f | [
{
"content": "Tu es chargé de mettre en œuvre un simple jeu de devinettes de mots basé sur du texte. Le jeu aura une liste prédéfinie de mots. Le joueur doit deviner un mot choisi aléatoirement dans cette liste. Après chaque tentative, le programme doit informer le joueur si la tentative est correcte ou incorre... | ["\nassert text_based_game(['python']) == [\"Congratulations! You guessed the correct word!\"]\n", "\nassert text_based_game(['development']) == [\"Congratulations! You guessed the correct word!\"]\n", "\nassert text_based_game(['programming']) == [\"Congratulations! You guessed the correct word!\"]\n", "\nassert text_... |
bb97ed4c8ae415237d219d557223cf57 | [
{
"content": "On te donne un graphe acyclique orienté (DAG) représentant une hiérarchie de catégories. Chaque catégorie a un nom unique et peut avoir plusieurs catégories parentes. Les catégories racines n'ont pas de parents. Ta tâche est de mettre en œuvre une fonction qui, étant donné une catégorie, renvoie u... | ["\nassert get_ancestor_list(\"Mac\", category_map) == ['Mac', 'Dell', 'Laptops', 'Electronics']\n", "\nassert get_ancestor_list(\"Gaming Mouse\", category_map) == ['Gaming Mouse', 'Mouse', 'Accessories', 'Electronics']\n", "\nassert get_ancestor_list(\"Logitech\", category_map) == ['Logitech', 'Gaming Mouse', 'Mouse',... |
c183b49bd860006f9e1b40c4052de3cf | [
{
"content": "On te donne une liste non triée d'entiers `arr`. Ton objectif est d'écrire une fonction `find_missing_numbers(arr)` qui renvoie une liste de tous les entiers manquants dans la plage définie par les valeurs minimale et maximale de `arr`. La fonction doit gérer les tableaux de n'importe quelle taill... | ["\nassert find_missing_numbers([1, 2, 4, 6, 7]) == [3, 5]\n", "\nassert find_missing_numbers([10, 14, 11, 13]) == [12]\n", "\nassert find_missing_numbers([5, 3, 1, 2]) == []\n", "\nassert find_missing_numbers([1, 3, 5, 7, 9]) == [2, 4, 6, 8]\n", "\nassert find_missing_numbers([]) == []\n", "\nassert find_missing_numbe... |
9b13a10c54ab53282d184a4b4bece0a8 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `custom_sort(arr)` qui trie la liste de sorte que tous les nombres pairs apparaissent avant tous les nombres impairs. Au sein des groupes pairs et impairs, les nombres doivent être triés par ordre croissant.\n\n**Entrée :... | ["\nassert custom_sort([1, 2, 3, 4, 5, 6]) == [2, 4, 6, 1, 3, 5]\n", "\nassert custom_sort([10, 15, 20, 25, 30]) == [10, 20, 30, 15, 25]\n", "\nassert custom_sort([7, 8, 9, 10, 11]) == [8, 10, 7, 9, 11]\n", "\nassert custom_sort([2, 4, 6, 8, 10]) == [2, 4, 6, 8, 10]\n", "\nassert custom_sort([1, 3, 5, 7, 9]) == [1, 3, ... |
a062d2cfbf6283243cac9d2c4d69f31a | [
{
"content": "On te donne deux chaînes de caractères, `s1` et `s2`. Ta tâche est de déterminer si elles sont des anagrammes l'une de l'autre. Deux chaînes sont considérées comme des anagrammes si elles contiennent les mêmes caractères avec la même fréquence, mais peut-être dans un ordre différent. Refactorise l... | ["\nassert is_anagram(\"listen\", \"silent\") == True\n", "\nassert is_anagram(\"triangle\", \"integral\") == True\n", "\nassert is_anagram(\"apple\", \"pale\") == False\n", "\nassert is_anagram(\"aabbcc\", \"abcabc\") == True\n", "\nassert is_anagram(\"abc\", \"def\") == False\n", "\nassert is_anagram(\"\", \"\") == T... |
661e0ebe0c53bd61c96d2924e482cf59 | [
{
"content": "On te donne la tâche d'implémenter une fonction `log_gradient(val)` qui calcule un gradient de couleur basé sur une valeur flottante `val` comprise entre 0 et 1. La fonction doit renvoyer un tuple de trois nombres flottants représentant les valeurs de couleur RVB. La transition entre les couleurs ... | ["\nassert log_gradient(0.0) == (0.0, 0.0, 1.0)\n", "\nassert log_gradient(0.1) == (0.0, 0.3690702464285425, 0.7924812503605781)\n", "\nassert log_gradient(0.3333) == (0.0, 1.0, 0.0)\n", "\nassert log_gradient(0.43) == (0.3690702464285425, 1.0, 0.0)\n", "\nassert log_gradient(0.6667) == (1.0, 1.0, 0.0)\n", "\nassert lo... |
cdc4285fed93fe27bf93f862ec399e5f | [
{
"content": "On te donne une liste de dictionnaires et une clé. Ta tâche est de mettre en œuvre une fonction `sort_dicts(dict_list, key)` qui trie la liste de dictionnaires en fonction de la clé spécifiée par ordre croissant. Si un dictionnaire ne contient pas la clé spécifiée, il doit être ignoré lors du proc... | ["\nassert sort_dicts([{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 20}, {'name': 'Charlie'}, {'name': 'David', 'age': 30}], 'age') == [{'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'David', 'age': 30}]\n", "\nassert sort_dicts([{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 20}, {'na... |
8545893ed885ad1ba05eb181d9fba329 | [
{
"content": "On te donne pour tâche d'écrire une fonction qui construit une requête SQL `INSERT` pour une table nommée `word_combinations`. La table se compose de deux colonnes : `combination` et `combination_type_id`. La colonne `combination` contient des combinaisons de mots, et la colonne `combination_type_... | ["\nassert generate_insert_query([], 1) == (\"\", [])\n", "\nassert generate_insert_query([(\"hello\", \"world\")], 1) == (\"INSERT INTO word_combinations (combination, combination_type_id) VALUES (%s, %s)\", [((\"hello\", \"world\"), 1)])\n", "\nassert generate_insert_query([(\"foo\", \"bar\"), (\"hello\", \"world\")]... |
48ab1e01242b778fa98a379d451fd676 | [
{
"content": "On te demande d'implémenter une fonction `calculate_bmi` qui calcule l'Indice de Masse Corporelle (IMC) pour une personne donnée. L'IMC est calculé en utilisant la formule suivante :\n\n\\[ \\text{IMC} = \\frac{\\text{poids en kilogrammes}}{(\\text{taille en mètres})^2} \\]\n\nTa fonction doit acc... | ["\nassert calculate_bmi(70, 1.75) == 22.86\n", "\nassert calculate_bmi(50, 1.6) == 19.53\n", "\nassert calculate_bmi(90, 1.8) == 27.78\n", "\nassert calculate_bmi(68, 1.73) == 22.99\n", "\nassert calculate_bmi(0, 1.75) == \"Invalid input. Please provide positive numeric values for weight and height.\"\n", "\nassert ca... |
fecce2974c9d69132ab840ecff8be4bb | [
{
"content": "On te donne un fichier texte nommé `data.txt` dans le répertoire courant. Ta tâche est d'écrire un script Python qui lit ce fichier, compte la fréquence de chaque mot, et affiche les 10 mots les plus courants ainsi que leurs fréquences. Les mots sont considérés comme des séquences de caractères sé... | ["\nassert print_top_10_words('nonexistentfile.txt') == None\n", "\nassert print_top_10_words('emptyfile.txt') == None\n", "\nassert print_top_10_words('singlewordfile.txt') == None\n", "\nassert print_top_10_words('twowordsfile.txt') == None\n", "\nassert print_top_10_words('tenwordsfile.txt') == None\n", "\nassert pr... |
c8e5ae71ca271cdf2c68d2be11c3fe87 | [
{
"content": "On te donne deux listes, `list1` et `list2`, contenant des éléments de n'importe quel type de données. Ta tâche est de mettre en œuvre une fonction `find_common_elements` qui renvoie une liste des éléments présents à la fois dans `list1` et `list2`. La fonction doit être optimisée pour la performa... | ["\nassert find_common_elements([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert find_common_elements(['a', 'b', 'c'], ['b', 'c', 'd']) == ['b', 'c']\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == [... |
6a33a049793653c2a0e898f093c9567d | [
{
"content": "On te donne un sac contenant `n_fair` billes équitables et `n_unfair` billes inéquitables. Les billes équitables ont une probabilité égale d'être rouges ou bleues, tandis que les billes inéquitables ont une probabilité `p_unfair` d'être rouges. Ta tâche est de calculer la probabilité de tirer `n_r... | ["\nassert probability_of_reds(n_fair=0, n_unfair=0, p_unfair=0.7, n_reds=0) == 1.0\n", "\nassert probability_of_reds(n_fair=1, n_unfair=0, p_unfair=0.7, n_reds=1) == 0.5\n", "\nassert probability_of_reds(n_fair=0, n_unfair=1, p_unfair=1.0, n_reds=1) == 1.0\n", "\nassert probability_of_reds(n_fair=0, n_unfair=1, p_unfa... |
122786eb4141e62ded1063e8ec4648af | [
{
"content": "On te donne un descripteur de fichier `fd` et trois indicateurs booléens `readable`, `writable` et `error`. Ta tâche est de mettre en œuvre une fonction `file_descriptor_monitor` qui surveille le descripteur de fichier pour la lisibilité, l'écrivabilité ou les erreurs dans un délai spécifié. La fo... | ["\nassert file_descriptor_monitor(0, True, False, False, 0.1) == (True, 1)\n", "\nassert file_descriptor_monitor(1, False, True, False, 0.1) == (True, 1)\n", "\nassert file_descriptor_monitor(2, False, False, True, 0.1) == (False, 0)\n", "\nassert file_descriptor_monitor(0, True, True, True, 0.1) == (True, 1)\n", "\na... |
38bd0a1c5da1f13d494e8e1632fd6960 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si tous les caractères de la chaîne sont uniques. Implémente une fonction `unique_characters(s: str) -> bool` qui renvoie `True` si tous les caractères de la chaîne sont uniques, et `False` sinon. Tu n'es pas autorisé à utiliser ... | ["\nassert unique_characters(\"abcdef\") == True\n", "\nassert unique_characters(\"hello\") == False\n", "\nassert unique_characters(\"1234567890\") == True\n", "\nassert unique_characters(\"aabbcc\") == False\n", "\nassert unique_characters(\"!@#$%^&*()\") == True\n", "\nassert unique_characters(\"a\") == True\n", "\n... |
40880820967c2abbb09a46ec17dabe18 | [
{
"content": "On te donne une liste de dictionnaires. Ta tâche est d'écrire une fonction `merge_dictionaries(dict_list)` qui fusionne ces dictionnaires en un seul dictionnaire. Les clés du dictionnaire résultant doivent être l'union de toutes les clés des dictionnaires d'entrée. Pour chaque clé, la valeur doit ... | ["\nassert merge_dictionaries([{\"a\": 1, \"b\": 2}, {\"b\": 3, \"c\": 4}]) == {\"a\": [1], \"b\": [2, 3], \"c\": [4]}\n", "\nassert merge_dictionaries([{\"x\": 10}, {\"y\": 20}, {\"z\": 30}]) == {\"x\": [10], \"y\": [20], \"z\": [30]}\n", "\nassert merge_dictionaries([{\"key1\": \"value1\"}, {\"key1\": \"value2\"}, {\... |
aeb82e6a179bbd898b5a7ce58d89a3f7 | [
{
"content": "Tu développes une fonctionnalité pour une plateforme éducative qui nécessite de déterminer la primalité d'une liste d'entiers. Ta tâche est d'implémenter une fonction qui accepte une liste d'entiers et renvoie une liste de booléens indiquant si chaque entier est premier.\n\n**Entrée :**\n- Une lis... | ["\nassert check_prime_numbers([2, 3, 5, 7, 11]) == [True, True, True, True, True]\n", "\nassert check_prime_numbers([4, 6, 8, 9, 10]) == [False, False, False, False, False]\n", "\nassert check_prime_numbers([1, 0, -1, -3, -5]) == [False, False, False, False, False]\n", "\nassert check_prime_numbers([13, 17, 19, 23, 29... |
20bd6c6e64ad6d75ea6485adc993e46e | [
{
"content": "Tu es chargé d'implémenter une fonction `generate_fibonacci` qui génère la suite de Fibonacci jusqu'au n-ième nombre et la renvoie sous forme de liste. 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. Ta fonction doit gérer les entrées invali... | ["\nassert generate_fibonacci(1) == [0]\n", "\nassert generate_fibonacci(2) == [0, 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 generate_fibonacci(0) == []\n", "\nassert generate_fibonacci(-5) == []\n", "\nassert genera... |
ba71a858557cdd1d28bbd72d652e58d7 | [
{
"content": "On te donne une liste de `n` points dans un plan 2D, où chaque point est représenté comme un tuple de coordonnées `(x, y)`. Ta tâche est de mettre en œuvre une fonction `find_closest_points` qui identifie et renvoie un tuple contenant les coordonnées des deux points les plus proches en fonction de... | ["\nassert find_closest_points([(0, 0), (1, 1), (2, 2), (3, 3), (0.5, 0.5)]) == ((0, 0), (0.5, 0.5))\n", "\nassert find_closest_points([(1, 2), (3, 4), (5, 6), (7, 8)]) == ((1, 2), (3, 4))\n", "\nassert find_closest_points([(0, 0), (0, 1), (1, 0), (1, 1)]) == ((0, 0), (0, 1))\n", "\nassert find_closest_points([(10, 10)... |
16dc82823edb506067546a90b687d26d | [
{
"content": "On te donne deux matrices 2D, `mat1` et `mat2`, chacune de taille `N x M`. Ta tâche est de mettre en œuvre une fonction `add_matrices_with_rotation(mat1, mat2)` qui effectue les opérations suivantes :\n1. Additionne les éléments correspondants de `mat1` et `mat2`.\n2. Fait pivoter la matrice résul... | ["\nassert add_matrices_with_rotation([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == [[10, 6], [14, 8]]\n", "\nassert add_matrices_with_rotation([[0, 0], [0, 0]], [[0, 0], [0, 0]]) == [[0, 0], [0, 0]]\n", "\nassert add_matrices_with_rotation([[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[9, 8, 7], [6, 5, 4], [3, 2, 1]]) == [[12, 8, 4], ... |
888292ec2e828fbe2d04de76246bc5bd | [
{
"content": "On te donne une liste de chaînes de caractères `str_lst`. Ton objectif est d'écrire une fonction `alternate_concatenate(str_lst)` qui traite cette liste comme suit :\n- Tout d'abord, filtre les chaînes dont les longueurs ne sont pas des nombres premiers.\n- Ensuite, concatène les chaînes restantes... | ["\nassert alternate_concatenate([\"a\", \"bb\", \"ccc\", \"dddd\", \"eeeee\"]) == \"acceeee\"\n", "\nassert alternate_concatenate([\"hello\", \"world\", \"abc\", \"defg\", \"hijkl\"]) == \"abc\"\n", "\nassert alternate_concatenate([\"prime\", \"test\", \"code\", \"fun\", \"yes\"]) == \"primefun\"\n", "\nassert alterna... |
68f079ccf73f35088faf380a76675103 | [
{
"content": "On te donne une liste d'entiers non négatifs. Ta tâche est d'écrire une fonction Python qui renvoie un dictionnaire contenant le nombre d'occurrences de chaque nombre unique dans la liste. Les clés du dictionnaire doivent être les nombres uniques, et les valeurs doivent être leurs décomptes respec... | ["\nassert count_unique_numbers([1, 2, 3, 2, 4, 3, 1, 1, 5]) == {1: 3, 2: 2, 3: 2, 4: 1, 5: 1}\n", "\nassert count_unique_numbers([10, 20, 10, 20, 30]) == {10: 2, 20: 2, 30: 1}\n", "\nassert count_unique_numbers([5, 5, 5, 5, 5]) == {5: 5}\n", "\nassert count_unique_numbers([]) == {}\n", "\nassert count_unique_numbers([... |
a1a2336bc4207ad85f4c339742fd775c | [
{
"content": "On te demande d'implémenter une fonction pour récupérer la dernière édition d'un livre dans une base de données de bibliothèque. Chaque livre est identifié de manière unique par un `book_id`, et chaque édition d'un livre est identifiée de manière unique par un `edition_id`. La base de données stoc... | ["\nassert get_latest_edition(trans, 1) == {'book_id': 1, 'edition_id': 3, 'publication_date': '2023-10-01', 'historical_data': '[{\"timestamp\": 1695244800, \"change\": \"Initial release\"}, {\"timestamp\": 1696368000, \"change\": \"Updated cover\"}]'}\n", "\nassert get_latest_edition(trans, 2) == {'book_id': 2, 'edit... |
2485cfde923993af1a31cc87ab0e972f | [
{
"content": "On te donne une liste de chaînes de caractères `S` et deux sous-chaînes `X` et `Y`. Ta tâche est de remplacer toutes les occurrences de `X` par `Y` dans chaque chaîne de caractères de `S`, mais seulement lorsque `X` apparaît comme un mot indépendant. Un mot indépendant est défini comme une séquenc... | ["\nassert replace_substring([\"cat\"], \"cat\", \"dog\") == [\"dog\"]\n", "\nassert replace_substring([\"catalog\"], \"cat\", \"dog\") == [\"catalog\"]\n", "\nassert replace_substring([\"caterpillar\"], \"cat\", \"dog\") == [\"caterpillar\"]\n", "\nassert replace_substring([\"the cat sat on the mat\"], \"cat\", \"dog\... |
24fa001696f1e566e683dd82d141c300 | [
{
"content": "Tu participes à un défi d'extraction de données où l'on te fournit une fonction `parse_data` qui accepte deux paramètres : `query_fields` et `resultset`. Le paramètre `query_fields` est une liste de chaînes de caractères représentant les noms des champs que tu dois extraire du `resultset`. Le `res... | ["\nassert extract_data(['id', 'name'], [('1', 'Alice'), ('2', 'Bob')]) == [{'id': '1', 'name': 'Alice'}, {'id': '2', 'name': 'Bob'}]\n", "\nassert extract_data(['name'], [('Alice',), ('Bob',)]) == [{'name': 'Alice'}, {'name': 'Bob'}]\n", "\nassert extract_data(['first_name', 'last_name'], [('John', 'Doe'), ('Jane', 'S... |
bcd3b5ace694882e9b72b9b7c51dca63 | [
{
"content": "On te donne une chaîne de caractères `text` contenant du texte arbitraire. Ta tâche est d'identifier et de renvoyer une liste de codes postaux canadiens valides trouvés dans ce texte. Un code postal canadien valide suit le modèle `X9X 9X9`, où `X` est une lettre et `9` est un chiffre. Le code post... | ["\nassert find_canadian_postal_codes(\"a1a 1a1\") == []\n", "\nassert find_canadian_postal_codes(\"a2a 2a2\") == [\"A2A 2A2\"]\n", "\nassert find_canadian_postal_codes(\"b3b 3b3\") == [\"B3B 3B3\"]\n", "\nassert find_canadian_postal_codes(\"1a1 a1a 1a1\") == [\"A1A 1A1\"]\n", "\nassert find_canadian_postal_codes(\"a1a... |
ed2e84f007835a69f53c82f8285aa8df | [
{
"content": "Tu développes une fonction pour un logiciel nommé \"DocGen\" qui a besoin de récupérer son fichier de configuration. Le fichier de configuration est stocké dans un répertoire spécifié par la variable d'environnement `DOCGEN_CONFIG_DIR`. Ta tâche est d'implémenter une fonction `get_docgen_config` q... | ["\nassert get_docgen_config(host) == os.fdopen(os.open(os.path.join(os.environ['DOCGEN_CONFIG_DIR'], 'docgen.conf'), os.O_RDONLY), 'r')\n", "\nassert get_docgen_config(host).name == os.path.join(os.environ['DOCGEN_CONFIG_DIR'], 'docgen.conf')\n", "\nassert get_docgen_config(host).mode == 'r'\n", "\nassert get_docgen_c... |
208490297d8014a343e94f14d4da9385 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de trier la liste d'abord par la longueur de chaque chaîne, par ordre croissant. Pour les chaînes de même longueur, trie-les par ordre alphabétique. Implémente une fonction `sort_strings` qui prend une liste de chaînes de caractères en e... | ["\nassert sort_strings([\"banana\", \"apple\", \"pear\", \"peach\", \"kiwi\", \"plum\", \"orange\", \"grape\"]) == [\"kiwi\", \"pear\", \"plum\", \"grape\", \"apple\", \"peach\", \"orange\", \"banana\"]\n", "\nassert sort_strings([\"dog\", \"cat\", \"elephant\", \"ant\", \"bat\"]) == [\"ant\", \"bat\", \"cat\", \"dog\... |
083f4036a5643e55914020fb095905f9 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter la fonction `count_words` qui traite cette liste et renvoie un dictionnaire avec le nombre cumulé de chaque mot unique, en ignorant la casse et la ponctuation.\n\n**Entrée :**\n- Une liste de chaînes de caractères `strings_... | ["\nassert count_words([\"Hello, world!\", \"Hello again.\"]) == {\"hello\": 2, \"world\": 1, \"again\": 1}\n", "\nassert count_words([\"Python, python, PYTHON!\"]) == {\"python\": 3}\n", "\nassert count_words([\"A quick brown fox.\", \"The quick brown fox jumps over the lazy dog.\"]) == {\"a\": 1, \"quick\": 2, \"brow... |
fd19365901a31cb74fa6e30bebed5ab6 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui extrait tous les nombres pairs de la liste et les renvoie triés par ordre décroissant.\n\n**Entrée :**\n- Une liste d'entiers `lst` (1 ≤ len(lst) ≤ 1000), où chaque entier `num` satisfait -1000 ≤ num ≤ 1000.\n\n**Sortie :**\n-... | ["\nassert even_numbers_descending([10, 3, 5, 20, 11, 14, 7]) == [20, 14, 10]\n", "\nassert even_numbers_descending([2, 4, 6, 8, 10]) == [10, 8, 6, 4, 2]\n", "\nassert even_numbers_descending([1, 3, 5, 7, 9]) == []\n", "\nassert even_numbers_descending([12, 15, 18, 21, 24]) == [24, 18, 12]\n", "\nassert even_numbers_de... |
c0c738b67bcfab14dcaeb28480c88e1e | [
{
"content": "Tu es chargé d'implémenter un test unitaire pour une fonction Python donnée `add_numbers`. La fonction `add_numbers` accepte deux paramètres entiers, `a` et `b`, et renvoie leur somme. Ton objectif est d'écrire un cas de test en utilisant le framework `unittest` pour vérifier que `add_numbers` cal... | ["\nassert add_numbers(2, 3) == 5\n", "\nassert add_numbers(-1, 1) == 0\n", "\nassert add_numbers(0, 0) == 0\n", "\nassert add_numbers(-5, -5) == -10\n", "\nassert add_numbers(100, 200) == 300\n", "\nassert add_numbers(123456, 654321) == 777777\n", "\nassert add_numbers(-100, 50) == -50\n", "\nassert add_numbers(1, -1)... |
0549fd78d8688fa5ec6b8d07372ccf50 | [
{
"content": "Implémente une classe nommée `Employee` pour gérer les détails des employés dans une entreprise. La classe doit inclure les attributs suivants :\n- `name` : une chaîne de caractères représentant le nom de l'employé.\n- `position` : une chaîne de caractères représentant le poste actuel de l'employé... | ["\nassert Employee(\"Alice\", \"Developer\", 70000, \"2020-01-01\").years_of_service() == 3\n", "\nassert Employee(\"Bob\", \"Manager\", 90000, \"2015-05-20\").years_of_service() == 8\n", "\nassert Employee(\"Charlie\", \"Intern\", 40000, \"2023-01-01\").years_of_service() == 0\n", "\nemp = Employee(\"David\", \"Analy... |
b93456906f8993f8cb50d5dec6e14bd7 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `generate_unique_pairs` qui génère toutes les paires uniques possibles d'éléments de `list1` et `list2`. Chaque paire doit consister en un élément de `list1` et un élément de `list2`. Si `list2` n'e... | ["\nassert generate_unique_pairs([1, 2, 2, 3], [3, 4, 4, 5]) == [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5]]\n", "\nassert generate_unique_pairs([1, 2, 3]) == [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]\n", "\nassert generate_unique_pairs([1, 2], [3, 4]) == [[1, ... |
73ec373599eb65602f43b9593ace3870 | [
{
"content": "On te donne un dictionnaire où chaque clé est une chaîne de caractères représentant une catégorie et chaque valeur est une liste d'entiers représentant des scores. Ton objectif est d'écrire une fonction qui renvoie un nouveau dictionnaire avec les scores triés par ordre croissant pour chaque catég... | ["\nassert sort_scores_by_category({'Math': [55, 23, 78, 12], 'Science': [88, 67, 91, 29], 'History': [45, 83, 19, 60]}) == {'Math': [12, 23, 55, 78], 'Science': [29, 67, 88, 91], 'History': [19, 45, 60, 83]}\n", "\nassert sort_scores_by_category({'Math': [100, 90, 80], 'Science': [70, 60, 50], 'History': [40, 30, 20]}... |
c0329bbb9ae0674325128fad589fd6a0 | [
{
"content": "On te donne une chaîne de caractères composée de lettres minuscules en anglais séparées par des espaces. Ton objectif est de mettre en œuvre une fonction qui renvoie un dictionnaire où chaque clé est un mot unique de la chaîne, et la valeur correspondante est le nombre de fois que ce mot apparaît ... | ["\nassert word_count(\"the quick brown fox jumps over the lazy dog\") == {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert word_count(\"hello hello world\") == {'hello': 2, 'world': 1}\n", "\nassert word_count(\"a a a a a\") == {'a': 5}\n", "\nassert word_count(\"py... |
1af217d780dc3abb60adca4e3f3fcca3 | [
{
"content": "Dans une variante du jeu 2048, on te donne une ligne ou une colonne représentée comme une liste d'entiers où chaque entier est soit 1, 2, 3, ou 4. Les tuiles ne peuvent fusionner que si elles sont adjacentes et dans un ordre strictement croissant. Implémente une fonction `merge_tiles` qui prend un... | ["\nassert merge_tiles([1, 2, 3, 4]) == [2, 3, 4, 0]\n", "\nassert merge_tiles([4, 3, 2, 1]) == [4, 3, 2, 1]\n", "\nassert merge_tiles([1, 0, 2, 0, 3, 0, 4]) == [2, 3, 4, 0, 0, 0, 0]\n", "\nassert merge_tiles([1, 2, 0, 2, 3, 4]) == [2, 3, 4, 0, 0, 0]\n", "\nassert merge_tiles([1, 1, 2, 3, 4]) == [2, 3, 4, 0, 0]\n", "\n... |
159fcf50f2cb12496c23b0d93e96bb1d | [
{
"content": "On te donne une liste de chaînes de caractères et une fonction de conversion. Ton objectif est d'implémenter une fonction `convert_list` qui applique la fonction de conversion à chaque chaîne de caractères de la liste. Si la conversion réussit, le résultat doit être ajouté à une nouvelle liste. Si... | ["\nassert convert_list([\"1\", \"2\", \"3\"], int) == [1, 2, 3]\n", "\nassert convert_list([\"true\", \"false\"], bool_from_str) == [True, False]\n", "\nassert convert_list([\"1\", \"a\", \"3\"], int) == [1, None, 3]\n", "\nassert convert_list([\"True\", \"FALSE\", \"true\"], bool_from_str) == [True, False, True]\n", ... |
126952c9c5029ea6675aa25a6559aee3 | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de mettre en œuvre une fonction qui calcule la distance de Levenshtein entre ces deux chaînes en utilisant une approche récursive. La distance de Levenshtein est définie comme le nombre minimum de modifications d'un seul caract... | ["\nassert levenshtein_distance_recursive(\"kitten\", \"sitting\") == 3\n", "\nassert levenshtein_distance_recursive(\"flaw\", \"lawn\") == 2\n", "\nassert levenshtein_distance_recursive(\"intention\", \"execution\") == 5\n", "\nassert levenshtein_distance_recursive(\"abc\", \"abc\") == 0\n", "\nassert levenshtein_dist... |
b50e0d34afcf93f3996cc3010ce19a16 | [
{
"content": "On te donne une liste d'entiers, où chaque entier représente un nombre de minutes (0-59). Ta tâche est d'écrire une fonction `format_minutes` qui convertit chaque entier en une chaîne formatée comme \"MM:00\". Si un entier est en dehors de la plage de 0-59, la fonction doit lever une `ValueError` ... | ["\nassert format_minutes([0, 5, 30, 59]) == ['00:00', '05:00', '30:00', '59:00']\n", "\nassert format_minutes([10, 20, 30, 40, 50]) == ['10:00', '20:00', '30:00', '40:00', '50:00']\n", "\nassert format_minutes([59, 58, 57, 56, 55]) == ['59:00', '58:00', '57:00', '56:00', '55:00']\n", "\nassert format_minutes([0, 1, 2,... |
177ce7da0081a576de8bc3ec71b8a037 | [
{
"content": "On te demande d'implémenter une machine à états simple pour simuler un distributeur automatique en Python. Le distributeur automatique prend en charge les opérations suivantes :\n- Insertion de pièces de monnaie de différentes valeurs.\n- Sélection d'articles dans une liste prédéfinie.\n- Rendre l... | ["\nassert vm.state == 'Idle'\n", "\nvm.insert_coin(10); assert vm.balance == 10\n", "\nvm.insert_coin(20); assert vm.balance == 30\n", "\nvm.select_item('A'); assert vm.balance == 0\n", "\nvm.insert_coin(100); vm.select_item('B'); assert vm.balance == 0\n", "\nvm.insert_coin(50); vm.select_item('C'); assert vm.balance... |
c8e4462ac1161e3aa0dd2a78ab316509 | [
{
"content": "On te donne un fichier texte. Ta tâche est d'écrire un script Python qui lit ce fichier, compte le nombre de mots, et écrit ce nombre dans un nouveau fichier texte. Le script doit gérer tout fichier texte valide en entrée et ne doit pas modifier le fichier original. Les noms des fichiers d'entrée ... | ["\nassert count_words_in_file(\"test_input.txt\", \"test_output.txt\") is None and open(\"test_output.txt\").read() == \"Number of words: 0\"\n", "\nassert count_words_in_file(\"test_input.txt\", \"test_output.txt\") is None and open(\"test_output.txt\").read() == \"Number of words: 5\" if open(\"test_input.txt\", \"w... |
c973869c72082aad7f57c394724e1751 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de générer une nouvelle liste qui inclut uniquement les nombres pairs de la liste originale. Implémente ceci en utilisant la compréhension de liste en Python.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 1000), où chaque entier ... | ["\nassert filter_even_numbers([1, 2, 3, 4, 5, 6]) == [2, 4, 6]\n", "\nassert filter_even_numbers([11, 22, 33, 44, 55]) == [22, 44]\n", "\nassert filter_even_numbers([0, -2, -4, -5]) == [0, -2, -4]\n", "\nassert filter_even_numbers([]) == []\n", "\nassert filter_even_numbers([1, 3, 5, 7, 9]) == []\n", "\nassert filter_... |
549ebb66eeca88c989219844fa68a0ad | [
{
"content": "On te donne un dictionnaire `user_activities` où chaque clé est un identifiant utilisateur et chaque valeur est une liste d'activités effectuées par cet utilisateur. Ta tâche est de mettre en œuvre une fonction `get_top_activities` qui renvoie un dictionnaire avec les identifiants utilisateur comm... | ["\nassert get_top_activities({1: ['run', 'swim', 'run', 'bike', 'swim', 'run']}) == {1: 'run'}\n", "\nassert get_top_activities({2: ['hike', 'run', 'hike', 'bike', 'run']}) == {2: 'run'}\n", "\nassert get_top_activities({3: ['swim', 'swim', 'run', 'run']}) == {3: 'swim'}\n", "\nassert get_top_activities({4: ['bike', '... |
5ed6783d8134df5c979d75e8fc3bd6c5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `remove_duplicates` qui traite cette liste et renvoie une nouvelle liste contenant uniquement les éléments uniques de la liste originale, en préservant leur ordre d'apparition initial.\n\n**Entrée :**\n- Une liste d'entiers `... | ["\nassert remove_duplicates([1, 2, 3, 2, 4, 5, 3, 6, 1]) == [1, 2, 3, 4, 5, 6]\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([7, 8, 9]) == [7, 8, 9]\n", "\nassert re... |
85fb0160ee55c2c2387512bab6725dfb | [
{
"content": "On te donne une liste d'éléments uniques `elements` et une liste d'ensembles `subsets`, où chaque ensemble est une liste d'éléments provenant de `elements`. De plus, on te fournit une liste `exclude` contenant les éléments qui ne doivent pas apparaître dans un ensemble quelconque. Ta tâche est de ... | ["\nassert filter_subsets([1, 2, 3, 4], [[1, 2], [3, 4], [1, 3]], [1]) == [[3, 4]]\n", "\nassert filter_subsets(['a', 'b', 'c'], [['a', 'b'], ['b', 'c'], ['a', 'c']], ['b']) == [['a', 'c']]\n", "\nassert filter_subsets([10, 20, 30], [[10], [20], [30]], [10, 20]) == [[30]]\n", "\nassert filter_subsets([1, 2, 3], [[1, 2,... |
506b0c412cec51a021db02edd72e001d | [
{
"content": "On te donne un tableau d'entiers `numbers` et un entier `target`. Ta tâche est d'identifier toutes les paires uniques de nombres dans le tableau qui s'additionnent à la valeur `target`. Retourne ces paires sous forme de liste de tuples, où chaque tuple contient une paire de nombres dans l'ordre cr... | ["\nassert find_pairs([1, 2, 3, 4, 5], 6) == [(1, 5), (2, 4)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_pairs([1, 2, 3, 4, 5], 7) == [(2, 5), (3, 4)]\n", "\nassert find_pairs([1, 1, 2, 45, 46, 46], 47) == [(1, 46)]\n", "\nassert find_pairs([0, 0, 0, 0], 0) == [(0, 0)]\n", "\nassert find_pai... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.