id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
884858bcaddeeb71e5da86deed5377ef | [
{
"content": "On te donne une liste de facteurs premiers et un décalage entier. Ta tâche est de mettre en œuvre une fonction `format_factors(factors, offset)` qui renvoie une représentation sous forme de chaîne des facteurs et du décalage selon les règles suivantes :\n\n- Si le décalage est de 1, la chaîne doit... | ["\nassert format_factors([2, 3, 5], 1) == \"2*3*5+1\"\n", "\nassert format_factors([2, 3, 5], -1) == \"2*3*5-1\"\n", "\nassert format_factors([2, 3, 5], 2) == \"[2^1*3^2*5^3]\"\n", "\nassert format_factors([7, 11, 13], 0) == \"[7^1*11^2*13^3]\"\n", "\nassert format_factors([2], 1) == \"2+1\"\n", "\nassert format_facto... |
353768bc7b7aab39f1a4f41780ce1f4d | [
{
"content": "On te donne une chaîne de caractères `line` représentant une ligne de séquence d'un fichier GenBank. La chaîne peut contenir des espaces, des chiffres et des lettres minuscules représentant des bases incertaines. Ta tâche est d'écrire une fonction `extract_sequence` qui traite cette chaîne et renv... | ["\nassert extract_sequence(\"ACGT\") == \"ACGT\"\n", "\nassert extract_sequence(\"acgt\") == \"\"\n", "\nassert extract_sequence(\"A C G T\") == \"ACGT\"\n", "\nassert extract_sequence(\"A1C2G3T4\") == \"ACGT\"\n", "\nassert extract_sequence(\"a1c2g3t4\") == \"\"\n", "\nassert extract_sequence(\"ACgt\") == \"AC\"\n", ... |
cbf9d05aaaa590b8f740b7492bcc273f | [
{
"content": "On te demande de concevoir un décorateur de classe qui garantit qu'une classe ne peut être instanciée qu'une seule fois pour chaque identifiant unique. La solution doit prendre en charge les opérations thread-safe et serialization-safe. Ton implémentation doit réussir les cas de test suivants :\n\... | ["\nassert Client('client1') is Client('client1'), \"Instances should be the same for the same identifier.\"\n", "\nassert Client('client1') is not Client('client2'), \"Instances should be different for different identifiers.\"\n", "\nassert Client('client3').data == \"data for client3\", \"Data attribute should be cor... |
f007952b3c2ee42ce0519203de8b3e94 | [
{
"content": "Tu développes un jeu où les joueurs naviguent dans un labyrinthe pour trouver un trésor caché. Le labyrinthe est représenté comme une grille 2D de taille `N x M`, où chaque cellule est soit vide (indiquée par `0`) soit bloquée (indiquée par `1`). Le joueur commence dans le coin supérieur gauche de... | ["\nassert can_reach_treasure([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) == True\n", "\nassert can_reach_treasure([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) == False\n", "\nassert can_reach_treasure([[0, 0, 1], [0, 1, 0], [1, 0, 0]]) == False\n", "\nassert can_reach_treasure([[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]) ==... |
ca3b112ea746303e80a01076ca385d6e | [
{
"content": "On te donne deux listes : `numbers` et `predictions`. Les deux listes ont la même longueur `n`. Chaque élément de `predictions` est une valeur booléenne qui prédit si l'élément correspondant dans `numbers` est positif (`True`) ou non positif (`False`). Ta tâche est de mettre en œuvre une fonction ... | ["\nassert calculate_score([1, -1, 2, -2], [True, False, True, False]) == 8\n", "\nassert calculate_score([0, 0, 0, 0], [False, False, False, False]) == 8\n", "\nassert calculate_score([1, 2, 3, 4], [True, True, True, True]) == 8\n", "\nassert calculate_score([-1, -2, -3, -4], [False, False, False, False]) == 8\n", "\n... |
f7738f94435e1a5266d2262f381f341f | [
{
"content": "On te donne une chaîne de caractères multiligne `text` et un entier `num`. Ta tâche est d'écrire une fonction `indent_text(text, num)` qui renvoie une nouvelle chaîne où chaque ligne de `text` est indentée de `num` blocs. Un bloc est défini comme un caractère de tabulation (`\\t`) suivi de deux es... | ["\nassert indent_text(\"hello\\nworld\", 1) == \"\\t hello\\n\\t world\"\n", "\nassert indent_text(\"line1\\nline2\\nline3\", 2) == \"\\t line1\\n\\t line2\\n\\t line3\"\n", "\nassert indent_text(\"singleline\", 3) == \"\\t singleline\"\n", "\nassert indent_text(\"\", 1) == \"\"\n", "\nassert indent_te... |
6cb518abcbd3bed4fd20745ae3d305ef | [
{
"content": "Étant donné une chaîne de caractères `s`, ta tâche est de déterminer et d'afficher une liste triée de tous les caractères uniques présents dans la chaîne.\n\n**Entrée :**\n- Une seule ligne contenant la chaîne `s` (1 ≤ |s| ≤ 100), composée de lettres minuscules de l'alphabet anglais.\n\n**Sortie :... | ["\nassert unique_sorted_characters(\"programming\") == ['a', 'g', 'i', 'm', 'n', 'o', 'p', 'r']\n", "\nassert unique_sorted_characters(\"hello\") == ['e', 'h', 'l', 'o']\n", "\nassert unique_sorted_characters(\"world\") == ['d', 'l', 'o', 'r', 'w']\n", "\nassert unique_sorted_characters(\"aabbcc\") == ['a', 'b', 'c']\... |
a4e9db5834a8cb2d8abd0f5632fce8b7 | [
{
"content": "On te donne une liste d'entiers. Implémente la fonction `merge_sort` pour trier la liste par ordre croissant en utilisant l'algorithme de tri fusion. Ta fonction doit gérer les listes avec des éléments dupliqués.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr) ≤ 10^4), où chaque entier ... | ["\nassert merge_sort([34, 7, 23, 32, 5, 62]) == [5, 7, 23, 32, 34, 62]\n", "\nassert merge_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert merge_sort([10, 7, 8, 9, 1, 5]) == [1, 5, 7, 8, 9, 10]\n", "\nassert merge_sort([1]) == [1]\n", "\nassert merge_... |
0b20b7285fb416f64015f7bdcd6cb7a0 | [
{
"content": "Implémente une classe `Car` avec les spécifications suivantes :\n\n- **Constructeur** : `__init__(self, make, model, year)` initialise la voiture avec la marque, le modèle et l'année donnés.\n- **Méthodes** :\n - `start(self)` : Affiche \"Engine started\".\n - `stop(self)` : Affiche \"Engine sto... | ["\nassert Car(\"Toyota\", \"Corolla\", 2021).make == \"Toyota\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).model == \"Corolla\"\n", "\nassert Car(\"Toyota\", \"Corolla\", 2021).year == 2021\n", "\nassert Car(\"Honda\", \"Civic\", 2019).make == \"Honda\"\n", "\nassert Car(\"Honda\", \"Civic\", 2019).model == \"Ci... |
6d2410e34abb57205a452fbb6a6aa370 | [
{
"content": "On te donne un fichier CSV contenant des données sur les véhicules. Ta tâche est d'écrire une fonction qui lit ce fichier et construit un dictionnaire imbriqué représentant les paramètres du véhicule. Le fichier CSV a les colonnes suivantes :\n\n- Marque (par exemple, 'Toyota', 'Ford', 'Chevrolet'... | ["\nassert read_vehicle_data('test_vehicles.csv') == {'Toyota': {'Sedan': [120, 26.0, 120, 15.0, 1000]}}\n", "\nassert read_vehicle_data('test_vehicles.csv') == {'Ford': {'SUV': [130, 20.0, 300, 30.0, 7000]}}\n", "\nassert read_vehicle_data('test_vehicles.csv') == {'Chevrolet': {'Truck': [110, 18.0, 400, 40.0, 12000]}}... |
458f800a6f851e2197926c4c8d7d3178 | [
{
"content": "Tu es chargé d'implémenter une fonction pour calculer les chiffres de contrôle IBAN pour un compte bancaire donné. L'IBAN (International Bank Account Number) est un format standardisé utilisé pour identifier les comptes bancaires en Europe et au Moyen-Orient. Ta fonction doit accepter un code pays... | ["\nassert calculate_iban_check_digits('GB', 'NWBK', '60161331926819') == '29'\n", "\nassert calculate_iban_check_digits('DE', '10010010', '0123456789') == '86'\n", "\nassert calculate_iban_check_digits('FR', '20041010', '05000500501337') == '37'\n", "\nassert calculate_iban_check_digits('ES', '1234', '1234567890123456... |
9069a642bea16e2d48e90a2537dea174 | [
{
"content": "On te donne une liste d'entiers qui peut contenir des listes imbriquées. Ta tâche est d'écrire une fonction qui calcule la somme de tous les entiers de la liste, y compris ceux qui se trouvent dans des listes imbriquées. La fonction doit gérer des niveaux de nidification arbitraires.\n\n**Entrée :... | ["\nassert sum_nested_list([1, 2, [3, 4], [5]]) == 15\n", "\nassert sum_nested_list([1, [2, [3, [4, [5]]]]]) == 15\n", "\nassert sum_nested_list([1, 2, 3, 4, 5]) == 15\n", "\nassert sum_nested_list([]) == 0\n", "\nassert sum_nested_list([[], [], []]) == 0\n", "\nassert sum_nested_list([1, [2, 3], [4, [5, 6]], 7]) == 28... |
3ab150284349e040bc321f6b439f0e16 | [
{
"content": "On te donne un dictionnaire `d` où chaque clé est un entier et chaque valeur est une chaîne de caractères. Ta tâche est de mettre en œuvre une fonction qui renvoie une liste des valeurs du dictionnaire triées selon les critères suivants :\n1. Tout d'abord, par la longueur de la chaîne (croissante)... | ["\nassert sort_dict_values({1: \"Apple\", 2: \"banana\", 3: \"Cherry\"}) == [\"apple\", \"banana\", \"cherry\"]\n", "\nassert sort_dict_values({1: \"dog\", 2: \"Cat\", 3: \"bat\"}) == [\"bat\", \"cat\", \"dog\"]\n", "\nassert sort_dict_values({1: \"zebra\", 2: \"antelope\", 3: \"ant\"}) == [\"ant\", \"antelope\", \"ze... |
20cd5acaf45ffe0272f2cc462b1192e1 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de calculer la factorielle de `n` en utilisant une approche itérative. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Elle est notée `n!`.\n\n**Entrée:**\n- Un seul entier `n` (1 ≤ n ... | ["\nassert iterative_factorial(0) == 1\n", "\nassert iterative_factorial(1) == 1\n", "\nassert iterative_factorial(2) == 2\n", "\nassert iterative_factorial(3) == 6\n", "\nassert iterative_factorial(4) == 24\n", "\nassert iterative_factorial(5) == 120\n", "\nassert iterative_factorial(6) == 720\n", "\nassert iterative_... |
555b083c3906fefbfdcb600192947c20 | [
{
"content": "On te donne un tableau d'octets `data` qui contient des données binaires encodées avec un simple chiffrement XOR utilisant la clé `0xAA` (binaire 10101010). Ta tâche est de décoder ces données en une chaîne de caractères lisible par un humain. Avant de décoder, tu dois XORer chaque octet de `data`... | ["\nassert decode_binary_data(bytearray([0xAA])) == \"\"\n", "\nassert decode_binary_data(bytearray([0xFF, 0xFF])) == \"\\uFFFF\"\n", "\nassert decode_binary_data(bytearray([0x55, 0x55])) == \"\\x00\\x00\"\n", "\nassert decode_binary_data(bytearray([0xAA, 0x55, 0xAA, 0x55])) == \"\\x00\\xFF\\x00\\xFF\"\n", "\nassert de... |
3fb35199892f34331442d082dde4c623 | [
{
"content": "On te donne un entier `num` compris entre 1 et 3999. Ta tâche est de convertir cet entier en sa représentation en chiffres romains. Le chiffre romain doit être renvoyé sous forme de chaîne de caractères. Assure-toi que ta solution gère tous les cas limites et produit un chiffre romain correctement... | ["\nassert int_to_roman(1) == \"I\"\n", "\nassert int_to_roman(4) == \"IV\"\n", "\nassert int_to_roman(9) == \"IX\"\n", "\nassert int_to_roman(58) == \"LVIII\"\n", "\nassert int_to_roman(1994) == \"MCMXCIV\"\n", "\nassert int_to_roman(3999) == \"MMMCMXCIX\"\n", "\nassert int_to_roman(400) == \"CD\"\n", "\nassert int_to... |
46d794555665e7562f34c2940db5efae | [
{
"content": "On te donne une grille 2D de taille `width x height` qui est un tore. Chaque cellule de la grille est représentée par ses coordonnées `(x, y)`, où `0 <= x < width` et `0 <= y < height`. Dans un tore, les cellules sur les bords sont connectées aux cellules sur les bords opposés. Par exemple, la cel... | ["\nassert get_neighbors((0, 0), 3, 3) == [(2, 0), (1, 0), (0, 2), (0, 1)]\n", "\nassert get_neighbors((1, 1), 3, 3) == [(0, 1), (2, 1), (1, 0), (1, 2)]\n", "\nassert get_neighbors((0, 0), 4, 4) == [(3, 0), (1, 0), (0, 3), (0, 1)]\n", "\nassert get_neighbors((0, 0), 5, 5) == [(4, 0), (1, 0), (0, 4), (0, 1), (4, 4), (4,... |
e8407e32a6731c2e1d7c27089d05aa81 | [
{
"content": "On te donne un arbre binaire enraciné représenté comme une liste imbriquée en Python. L'arbre est défini de telle sorte que chaque nœud est une liste `[valeur_nœud, sous_arbre_gauche, sous_arbre_droit]`, où `sous_arbre_gauche` et `sous_arbre_droit` sont soit `None`, soit un autre nœud dans le même... | ["\nassert unroot_tree([1, [2, None, None], [3, None, None]]) == {1: [2, 3], 2: [1], 3: [1]}\n", "\nassert unroot_tree([1, [2, [4, None, None], None], [3, None, [5, None, None]]]) == {1: [2, 3], 2: [1, 4], 3: [1, 5], 4: [2], 5: [3]}\n", "\nassert unroot_tree([1, None, None]) == {1: []}\n", "\nassert unroot_tree([1, [2,... |
9d983b73b0b0f8f8371f6a5c8b5e1d18 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier `target`. Ta tâche est de trouver la longueur minimale d'un sous-tableau contigu de `nums` dont la somme est supérieure ou égale à `target`. Si un tel sous-tableau n'existe pas, retourne 0. Le tableau `nums` peut contenir des nombres négatifs.\n... | ["\nassert minSubArrayLen(7, [2,3,1,2,4,3]) == 2\n", "\nassert minSubArrayLen(4, [1,4,4]) == 1\n", "\nassert minSubArrayLen(11, [1,1,1,1,1,1,1,1]) == 0\n", "\nassert minSubArrayLen(5, [2,3,1,1,1,1,1]) == 2\n", "\nassert minSubArrayLen(15, [1,2,3,4,5]) == 5\n", "\nassert minSubArrayLen(100, [1,2,3,4,5]) == 0\n", "\nasse... |
06ccb7fe763679844a1be7fe58c11bf5 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne est une phrase. Ta tâche est de mettre en œuvre une fonction qui divise chaque phrase en mots et renvoie une liste de listes, où chaque liste interne contient les mots de la phrase correspondante. Les mots sont séparés par des espace... | ["\nassert split_sentences_into_words([\"Hello world\"]) == [[\"Hello\", \"world\"]]\n", "\nassert split_sentences_into_words([\"This is a test\"]) == [[\"This\", \"is\", \"a\", \"test\"]]\n", "\nassert split_sentences_into_words([\"OpenAI is great\"]) == [[\"OpenAI\", \"is\", \"great\"]]\n", "\nassert split_sentences_... |
704865975a45cc6e54312d75102aa5d9 | [
{
"content": "On te donne une liste triée d'entiers `numbers` et un entier `target`. Ta tâche est de mettre en œuvre un algorithme de recherche binaire pour trouver l'index de `target` dans `numbers`. Si `target` n'est pas présent dans la liste, retourne -1.\n\n**Entrée :**\n- La première ligne contient un enti... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search(... |
80c48c94db19bee52edb6da60261d183 | [
{
"content": "On te donne un graphe représenté sous forme de liste d'adjacence. Chaque nœud est identifié par un identifiant unique. Le graphe peut être orienté ou non orienté. Ta tâche est de mettre en œuvre une fonction qui, étant donné un identifiant de sommet et une fonction de filtrage facultative, renvoie... | ["\nassert find_neighbors(1, {1: [(2, 'red'), (3, 'blue')]}) == [2, 3]\n", "\nassert find_neighbors(2, {2: [(4, 'green')]}) == [4]\n", "\nassert find_neighbors(3, {3: [(5, 'red')]}) == [5]\n", "\nassert find_neighbors(4, {4: []}) == []\n", "\nassert find_neighbors(5, {5: [(1, 'blue')]}) == [1]\n", "\nassert find_neighb... |
b0d1e6fa9c36b4f37f801057e1621a42 | [
{
"content": "On te demande d'implémenter une fonction pour générer une matrice de transformation 4x4 pour les transformations graphiques 3D. La matrice doit intégrer des rotations autour des axes x, y et z en utilisant les angles d'Euler, ainsi que des translations optionnelles le long de ces axes. Les rotatio... | ["\nassert create_transformation_matrix((0, 0, 0), (0, 0, 0)) == [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]\n", "\nassert create_transformation_matrix((90, 0, 0), (0, 0, 0)) == [0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1]\n", "\nassert create_transformation_matrix((0, 90, 0), (0, 0, 0)) == [0, -1, 0, 0, 1, 0,... |
62bb837f76207e0b13d1ff0f37be5004 | [
{
"content": "On te donne deux ensembles d'entiers. Ta tâche est d'implémenter une classe Python `SetOperations` avec une méthode `find_intersection` qui renvoie l'intersection de ces deux ensembles. L'intersection de deux ensembles est un ensemble contenant tous les éléments qui sont présents dans les deux ens... | ["\nassert SetOperations({1, 2, 3}, {3, 4, 5}).find_intersection() == {3}\n", "\nassert SetOperations({10, 20, 30}, {30, 40, 50}).find_intersection() == {30}\n", "\nassert SetOperations({1, 2, 3}, {4, 5, 6}).find_intersection() == set()\n", "\nassert SetOperations(set(), {1, 2, 3}).find_intersection() == set()\n", "\na... |
64d6a6c69d12d4f57137efb1205749ce | [
{
"content": "On te demande d'implémenter une fonction `compare_floats(x: float, y: float) -> int` qui compare deux nombres à virgule flottante `x` et `y`. La fonction doit renvoyer :\n\n- `-1` si `x` est strictement inférieur à `y`\n- `0` si `x` est égal à `y`\n- `1` si `x` est strictement supérieur à `y`\n\nL... | ["\nassert compare_floats(-0.0, 0.0) == -1\n", "\nassert compare_floats(0.0, -0.0) == 1\n", "\nassert compare_floats(0.0, 0.0) == 0\n", "\nassert compare_floats(-0.0, -0.0) == 0\n", "\nassert compare_floats(1.0, 2.0) == -1\n", "\nassert compare_floats(2.0, 1.0) == 1\n", "\nassert compare_floats(1.0, 1.0) == 0\n", "\nas... |
51539cb7f82c0920dd797b2dfccd43e7 | [
{
"content": "Tu participes à un concours de programmation où l'on te donne une liste de tâches. Chaque tâche a une durée spécifique et une valeur en points. Tu ne peux travailler que sur une tâche à la fois et ton temps total disponible est limité. Ton objectif est de maximiser le nombre total de points que tu... | ["\nassert max_points(10, [(2, 10), (3, 20), (4, 30), (5, 40)]) == 70\n", "\nassert max_points(5, [(2, 10), (3, 20), (4, 30), (5, 40)]) == 40\n", "\nassert max_points(0, [(2, 10), (3, 20), (4, 30), (5, 40)]) == 0\n", "\nassert max_points(1, [(2, 10), (3, 20), (4, 30), (5, 40)]) == 0\n", "\nassert max_points(15, [(2, 10... |
bf7a8623ebde9843c8b1d852f09cfae6 | [
{
"content": "On te demande d'implémenter une fonction récursive pour calculer la factorielle d'un entier non négatif `n`. La factorielle d'un entier non négatif `n` est le produit de tous les entiers positifs inférieurs ou égaux à `n`. Si `n` est négatif, la fonction doit renvoyer `None`. Ta fonction doit être... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(5) == 120\n", "\nassert factorial(7) == 5040\n", "\nassert factorial(-1) == None\n", "\nassert factorial(-5) == None\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(3) == 6\n", "\nassert factorial(12) == 479001600\n", "\... |
5b9d8693afded98a04fd31b7b3b424ea | [
{
"content": "Tu participes à un défi de prétraitement de données où l'on te fournit un ensemble de données `X` représenté comme un tableau numpy 2D avec `m` échantillons et `n` caractéristiques. Chaque échantillon est une ligne du tableau, et chaque caractéristique est une colonne. L'ensemble de données peut c... | ["\nassert np.array_equal(normalize_features(np.array([[1, 2], [3, 4]])), np.array([[0., 0.], [1., 1.]]))\n", "\nassert np.array_equal(normalize_features(np.array([[np.nan, 2], [3, np.nan]])), np.array([[np.nan, 0.], [0., np.nan]]))\n", "\nassert np.array_equal(normalize_features(np.array([[1, np.nan], [np.nan, 4]])), ... |
72d1c071e4cc42cb9052221268c55032 | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne représente une ligne de code dans un langage de programmation. Ta tâche est de déterminer si un jeton spécifié apparaît en tant qu'identifiant autonome dans l'une des lignes. Les commentaires et les chaînes de caractères doivent être... | ["\nassert is_standalone_identifier([\"x = 10\"], \"x\") == True\n", "\nassert is_standalone_identifier([\"y = 'x is a variable'\"], \"x\") == False\n", "\nassert is_standalone_identifier([\"print('x: ', x)\"], \"x\") == True\n", "\nassert is_standalone_identifier([\"# x is a comment\"], \"x\") == False\n", "\nassert i... |
2ab07ef9482021dde17c0164a9e339fd | [
{
"content": "On te demande de générer une chaîne de caractères aléatoire de 10 lettres minuscules de l'alphabet anglais. La chaîne doit contenir au moins une voyelle (a, e, i, o, u). Ton programme doit afficher une telle chaîne.\n\n**Exemple de sortie :**\n```\nxqjvotkznr\n```\n*Remarque : la sortie variera ca... | ["\nassert len(generate_random_string()) == 10\n", "\nassert any(char in 'aeiou' for char in generate_random_string())\n", "\nassert all(char in string.ascii_lowercase for char in generate_random_string())\n", "\nassert generate_random_string() != generate_random_string()\n", "\nassert set(generate_random_string()).iss... |
e03a3e0f427805d113f0807deca40d63 | [
{
"content": "On te donne un fichier CSV nommé `employee_data.csv` contenant des données sur les employés avec les colonnes suivantes : \"Name\", \"Department\" et \"Salary\". Ta tâche est d'écrire un script Python qui lit ce fichier, calcule le salaire moyen pour chaque département et affiche les résultats dan... | ["\nassert read_employee_data('test_data.csv') == {'HR': [50000.0, 60000.0], 'Engineering': [75000.0, 80000.0]}\n", "\nassert calculate_average_salaries({'HR': [50000.0, 60000.0], 'Engineering': [75000.0, 80000.0]}) == {'HR': 55000.0, 'Engineering': 77500.0}\n", "\nassert calculate_average_salaries({'Marketing': [55000... |
180baea58cc6125cfbf0d40643fab72d | [
{
"content": "Tu participes à une compétition de traitement du langage naturel et tu disposes d'un modèle Word2Vec pré-entraîné ainsi que de deux phrases, `sentence1` et `sentence2`. Ta tâche consiste à écrire une fonction qui calcule le score de similarité entre ces deux phrases en utilisant le modèle Word2Vec... | ["\nassert calculate_sentence_similarity(\"running fast\", \"gninnur fast\", wordmodel) == 1.0\n", "\nassert calculate_sentence_similarity(\"hello world\", \"world hello\", wordmodel) == 1.0\n", "\nassert calculate_sentence_similarity(\"hello\", \"world\", wordmodel) == 0.0\n", "\nassert calculate_sentence_similarity(\... |
0f5aee455812489f01d2ee10023f3498 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'un mot et de sa fréquence correspondante dans un corpus. Ta tâche est de mettre en œuvre une fonction qui calcule la fréquence de terme normalisée (TF) pour chaque mot. La TF doit être normalisée en utilisant la formule suivante :\n\n\... | ["\nassert calculate_normalized_tf([(\"apple\", 4), (\"banana\", 2), (\"cherry\", 4), (\"date\", 1)]) == [0.75, 0.75, 0.5, 0.25]\n", "\nassert calculate_normalized_tf([(\"apple\", 1), (\"banana\", 1), (\"cherry\", 1), (\"date\", 1)]) == [0.5, 0.5, 0.5, 0.5]\n", "\nassert calculate_normalized_tf([(\"apple\", 5), (\"bana... |
e4c2beb439bfa8c25e6ffa0d0ff4817c | [
{
"content": "On te donne une chaîne de caractères `s` contenant un mélange de texte et d'adresses e-mail. Ta tâche est d'écrire une fonction `parse_email_addresses` qui extrait toutes les adresses e-mail valides de la chaîne. La fonction doit renvoyer une liste de ces adresses e-mail. Suppose que les adresses ... | ["\nassert parse_email_addresses(\"Please contact us at support@example.com or sales@example.co.uk for further information.\") == [\"support@example.com\", \"sales@example.co.uk\"]\n", "\nassert parse_email_addresses(\"No emails here!\") == []\n", "\nassert parse_email_addresses(\"Emails: john.doe123@domain.co.uk, jane... |
450f78334508988e083bbaf9109267ab | [
{
"content": "On te donne une matrice binaire 2D `mask_image` de taille `N x M` où chaque cellule contient un entier représentant un masque de bits. Ta tâche est de mettre en œuvre une fonction `get_mask_plane(mask_image, bitmask)` qui extrait un plan de masque spécifique de `mask_image` en fonction du `bitmask... | ["\nassert get_mask_plane([[1, 0, 1], [0, 1, 0], [1, 0, 1]], 1) == [[1, 0, 1], [0, 1, 0], [1, 0, 1]]\n", "\nassert get_mask_plane([[1, 0, 1], [0, 1, 0], [1, 0, 1]], 2) == [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n", "\nassert get_mask_plane([[3, 2, 0], [1, 1, 3], [0, 2, 3]], 3) == [[1, 0, 0], [1, 1, 1], [0, 0, 1]]\n", "\nasse... |
9b838728414d63678c5adb0b2834ad5b | [
{
"content": "Implémente l'algorithme de tri rapide et analyse sa complexité temporelle. Ta fonction doit prendre un tableau d'entiers en entrée et renvoyer un tableau trié. Considère le scénario du cas moyen pour l'analyse de la complexité temporelle.\n\n**Exemple d'entrée :**\n```\n[3, 6, 8, 10, 1, 2, 1]\n```... | ["\nassert quicksort([3, 6, 8, 10, 1, 2, 1]) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert quicksort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert quicksort([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert quicksort([5, 3, 8, 4, 2, 7, 1, 10]) == [1, 2, 3, 4... |
890c6ed8df3237c0b0947eb996461ae4 | [
{
"content": "On te donne une liste d'entiers `elements` et un entier `group_size`. Ta tâche est d'implémenter une fonction `group_elements` qui regroupe les éléments en sous-listes de la taille spécifiée. N'inclus que les sous-listes qui ont exactement `group_size` éléments. Si le dernier groupe a moins de `gr... | ["\nassert group_elements([1, 2, 3, 4, 5, 6, 7, 8], 3) == [[1, 2, 3], [4, 5, 6]]\n", "\nassert group_elements([1, 2, 3, 4, 5, 6, 7], 3) == [[1, 2, 3], [4, 5, 6]]\n", "\nassert group_elements([1, 2, 3, 4, 5, 6], 2) == [[1, 2], [3, 4], [5, 6]]\n", "\nassert group_elements([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4]]\n", "\nas... |
1ec0d9f3584b0f50fcba1355f9ac3cdc | [
{
"content": "On te donne une liste de `n` chaînes de caractères et une chaîne cible `t`. Ta tâche est de mettre en œuvre une fonction qui renvoie une liste d'indices où la chaîne cible `t` apparaît dans la liste. Les indices doivent être dans l'ordre croissant.\n\n**Entrée :**\n- La première ligne contient un ... | ["\nassert find_target_indices([\"apple\", \"banana\", \"apple\", \"cherry\", \"apple\"], \"apple\") == [0, 2, 4]\n", "\nassert find_target_indices([\"dog\", \"cat\", \"bird\", \"dog\", \"dog\"], \"dog\") == [0, 3, 4]\n", "\nassert find_target_indices([\"hello\", \"world\"], \"world\") == [1]\n", "\nassert find_target_... |
7ce64959d8f63429b82150003e63adb8 | [
{
"content": "On te donne un tableau trié d'entiers `arr` et un entier `k`. Ta tâche est de déterminer s'il existe deux éléments distincts dans `arr` dont la somme est égale à `k`. Ta solution doit s'exécuter en temps O(n) et utiliser un espace supplémentaire de O(1).\n\n**Entrée :**\n- La première ligne contie... | ["\nassert has_pair_with_sum([1, 2, 3, 4, 5], 9) == True\n", "\nassert has_pair_with_sum([1, 2, 3, 4, 5], 10) == False\n", "\nassert has_pair_with_sum([1, 2, 3, 4, 5], 5) == True\n", "\nassert has_pair_with_sum([1, 2, 3, 4, 5], 8) == True\n", "\nassert has_pair_with_sum([1, 2, 3, 4, 5], 3) == True\n", "\nassert has_pai... |
51712e0836acfda205d2646302c442ad | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de trouver la plus longue sous-tableau contigu qui contient un nombre égal d'entiers pairs et impairs. Retourne les indices de début et de fin de ce sous-tableau. S'il existe plusieurs sous-tableaux de longueur maximale identique, retourne les indices... | ["\nassert find_longest_even_odd_subarray([1, 2, 3, 4, 5]) == (1, 4)\n", "\nassert find_longest_even_odd_subarray([2, 4, 6, 8]) == (-1, -1)\n", "\nassert find_longest_even_odd_subarray([1, 3, 5, 7]) == (-1, -1)\n", "\nassert find_longest_even_odd_subarray([1, 2, 3, 4, 5, 6]) == (1, 6)\n", "\nassert find_longest_even_od... |
1c5434695642d99c709191fb6f040bff | [
{
"content": "On te donne une liste d'entiers `numbers`. Ton objectif est d'écrire une fonction Python `find_largest_and_smallest_primes` qui identifie les nombres premiers les plus grand et le plus petit dans la liste. S'il n'y a pas de nombres premiers dans la liste, la fonction doit renvoyer `None` pour les ... | ["\nassert find_largest_and_smallest_primes([2, 3, 5, 7, 11]) == (2, 11)\n", "\nassert find_largest_and_smallest_primes([4, 6, 8, 10]) == (None, None)\n", "\nassert find_largest_and_smallest_primes([17, 19, 23, 29]) == (17, 29)\n", "\nassert find_largest_and_smallest_primes([29, 29, 29, 29]) == (29, 29)\n", "\nassert f... |
a9d922981c349f30adf2a90a3dfd1e73 | [
{
"content": "On te donne une chaîne de caractères `s` représentant un chemin de fichier et une liste de chaînes de caractères `forbidden_patterns`. Le chemin de fichier `s` peut contenir une ou plusieurs occurrences des motifs dans `forbidden_patterns`, où les motifs peuvent inclure le caractère générique `*` ... | ["\nassert clean_file_path(\"/usr/local/forbidden/example/path/\", [\"forbidden*\", \"example*\"]) == \"/usr/local/path\"\n", "\nassert clean_file_path(\"/home/user/documents/report.pdf\", [\"documents*\"]) == \"/home/user/report.pdf\"\n", "\nassert clean_file_path(\"/var/log/old_logs/backup/\", [\"old_logs*\"]) == \"/... |
cbb6bf752d68dd98130b4ce74fabe8a3 | [
{
"content": "On te donne un réseau constitué de nœuds et de connexions entre eux. Chaque nœud est identifié de manière unique par un identifiant entier, possède un nom et appartient à un groupe identifié par une chaîne de caractères. Les connexions entre les nœuds sont définies par un type. Ta tâche est de met... | ["\nassert generate_connection_string(1, 'NodeA', 'GroupX', 2, 'NodeB', 'GroupY', 'Direct').startswith(\"Node1[ID=1, Name=NodeA, Group=GroupX] -> Node2[ID=2, Name=NodeB, Group=GroupY] ConnectionType=Direct Timestamp=\")\n", "\nassert generate_connection_string(100, 'Server1', 'DataCenter1', 200, 'Server2', 'DataCenter2... |
361202a7a3e0f53808be8e996eba8ba0 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction qui renvoie une liste de ses facteurs premiers par ordre non décroissant. Les facteurs premiers doivent être listés autant de fois qu'ils apparaissent dans la factorisation.\n\n**Entrée :**\n- Un seul entier `n` (2 ≤ n ≤ 10^6)\n... | ["\nassert prime_factors(56) == [2, 2, 2, 7]\n", "\nassert prime_factors(15) == [3, 5]\n", "\nassert prime_factors(1) == []\n", "\nassert prime_factors(2) == [2]\n", "\nassert prime_factors(3) == [3]\n", "\nassert prime_factors(100) == [2, 2, 5, 5]\n", "\nassert prime_factors(13195) == [5, 7, 13, 29]\n", "\nassert prim... |
1d6086392a51a3d510a0208d7693b239 | [
{
"content": "On te donne une chaîne de caractères `text` et un caractère `placeholder`. Ta tâche est d'écrire une fonction `clean_text` qui traite la chaîne en remplaçant tous les caractères qui ne sont pas alphanumériques ou des underscores par le caractère `placeholder`. La fonction doit renvoyer la chaîne m... | ["\nassert clean_text(\"Hello, World! 123_\", '-') == \"Hello-World-123_\"\n", "\nassert clean_text(\"Python@3.8\", '*') == \"Python*3*8\"\n", "\nassert clean_text(\"Clean_this-text!\", '_') == \"Clean_this_text_\"\n", "\nassert clean_text(\"NoSpacesOrPunctuation\", '#') == \"NoSpacesOrPunctuation\"\n", "\nassert clean... |
d7a9b3bbaec06a1bf0c136e2c0469a43 | [
{
"content": "On te donne une configuration de plan tarifaire sous forme de dictionnaire avec les clés suivantes : `tariff`, `potencias`, `margen_potencia`, `alquiler_contador`, `imp_electrico`, et `iva`. La clé `tariff` peut être soit `\"2.0TD\"` soit `\"3.0TD\"`. La clé `potencias` est un dictionnaire avec le... | ["\nassert validate_power_plan({\"tariff\": \"2.0TD\", \"potencias\": {\"P1\": 10, \"P2\": 5}, \"margen_potencia\": 10.50, \"alquiler_contador\": 5.25, \"imp_electrico\": 0.0, \"iva\": 21.0}) == ([], True)\n", "\nassert validate_power_plan({\"tariff\": \"2.0TD\", \"potencias\": {\"P1\": 0, \"P2\": 5}, \"margen_potencia... |
587150559b75cfca9b2e023a9ee243f4 | [
{
"content": "On te donne deux listes d'entiers positifs, `nums` et `weights`. Ta tâche est de mettre en œuvre une fonction `weighted_mean(nums, weights)` qui calcule la moyenne pondérée des nombres dans `nums` en utilisant les poids correspondants dans `weights`. La fonction doit lever une exception `ValueErro... | ["\nassert weighted_mean([1, 2, 3], [1, 1, 1]) == 2.0\n", "\nassert weighted_mean([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted_mean([5, 10], [2, 1]) == 6.666666666666667\n", "\nassert weighted_mean([1, 1, 1, 1], [1, 1, 1, 1]) == 1.0\n", "\nassert weighted_mean([3, 6, 9], [1, 2, 3]) == 8.0\n", "... |
7602897012c5b80bd7313df1650657f2 | [
{
"content": "Tu es chargé d'implémenter une fonction `calculate_discounted_price(price, discount)` qui calcule le prix final d'un produit après avoir appliqué un pourcentage de réduction donné. La fonction doit respecter les contraintes suivantes :\n\n- Le prix initial (`price`) doit être un nombre non négatif... | ["\nassert calculate_discounted_price(100, 20) == 80.0\n", "\nassert calculate_discounted_price(200, 50) == 100.0\n", "\nassert calculate_discounted_price(0, 10) == 0.0\n", "\nassert calculate_discounted_price(150, 0) == 150.0\n", "\nassert calculate_discounted_price(100, 100) == 0.0\n", "\nassert calculate_discounted_... |
3784d0a8d283b81e1a5b8e12a04c0547 | [
{
"content": "On te donne une fonction récursive qui calcule le nième nombre de Fibonacci. Ta tâche est de convertir cette fonction en une fonction itérative. 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. Écris une fonction itérative pour calculer le ni... | ["\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(15) == 610\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(25... |
f1c6d6a288b942f6a71197998dbf4a1e | [
{
"content": "On te donne une chaîne de caractères `s` composée de parenthèses équilibrées `(` et `)`. Ta tâche est de déterminer la taille maximale d'un sous-arbre équilibré dans la chaîne. Un sous-arbre équilibré est défini comme une sous-séquence contiguë de `s` qui forme une expression parenthésée valide et... | ["\nassert max_subtree_size(\"(())(())\") == 4\n", "\nassert max_subtree_size(\"((()))\") == 6\n", "\nassert max_subtree_size(\"()()\") == 2\n", "\nassert max_subtree_size(\"(()(()))\") == 6\n", "\nassert max_subtree_size(\"()\") == 2\n", "\nassert max_subtree_size(\"\") == 0\n", "\nassert max_subtree_size(\"((())())\"... |
c8cceef24d63768a0c6f59199e77b616 | [
{
"content": "On te donne une liste de chemins de fichiers représentés sous forme de chaînes de caractères. Certains de ces chemins de fichiers peuvent être des doublons, ne différant que par leurs extensions. Ta tâche est d'écrire une fonction qui prend cette liste de chemins de fichiers et un identifiant uniq... | ["\nassert make_file_paths_unique([\"file.txt\", \"file.doc\", \"file.txt\"], \"_unique\") == [\"file.txt\", \"file.doc\", \"file1_unique.txt\"]\n", "\nassert make_file_paths_unique([\"report.pdf\", \"report.pdf\", \"report.pdf\"], \"_id\") == [\"report.pdf\", \"report1_id.pdf\", \"report2_id.pdf\"]\n", "\nassert make_... |
f42ed8185145b7c63c50b2dda0f76089 | [
{
"content": "On te demande de traiter une liste de projets de films. Chaque projet est représenté comme un dictionnaire avec les clés suivantes : 'id', 'name', 'release_year' et 'director'. Les noms de films peuvent contenir des espaces au début, à la fin ou plusieurs espaces internes. Ton objectif est de norm... | ["\nassert get_movie_projects([{'id': 1, 'name': 'Inception', 'release_year': 2010, 'director': 'Christopher Nolan'}]) == {'Inception': {'id': 1, 'name': 'Inception', 'release_year': 2010, 'director': 'Christopher Nolan'}}\n", "\nassert get_movie_projects([{'id': 2, 'name': ' The Matrix ', 'release_year': 1999, 'direct... |
43ba484384d4a4b8feaaa1405cff3523 | [
{
"content": "On te demande de traiter un ensemble de données provenant d'un service de diffusion de musique en continu qui enregistre les interactions des utilisateurs. Chaque ligne de l'ensemble de données est structurée comme `userId::songId::playCount::timestamp`. Ton objectif est de mettre en œuvre une fon... | ["\nassert parse_interaction(\"1::2::3.5\") == (4, (1, 2, \"3.5\"))\n", "\nassert parse_interaction(\" 10::20::30.1 \") == (1, (10, 20, \"30.1\"))\n", "\nassert parse_interaction(\"100::200::300.9\") == (1, (100, 200, \"300.9\"))\n", "\nassert parse_interaction(\"123::456::789.0\") == (9, (123, 456, \"789.0\"))\n", "... |
47e738b6a70e72cbf83a974002e98e3d | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de transformer la chaîne selon les règles suivantes :\n- Remplace toutes les occurrences de la lettre 'a' par '@'.\n- Remplace toutes les occurrences de la lettre 'e' par '3'.\n- Remplace to... | ["\nassert transform_string(\"education\") == \"3d1c@t10n\"\n", "\nassert transform_string(\"algorithm\") == \"@l1g0r1thm\"\n", "\nassert transform_string(\"university\") == \"#n1v3rs1ty\"\n", "\nassert transform_string(\"aeiou\") == \"310#\"\n", "\nassert transform_string(\"AEIOU\") == \"AEIOU\"\n", "\nassert transfor... |
e7395a2ae3bf81b3436cc74aabd7a094 | [
{
"content": "On te demande d'implémenter une fonction décorateur nommée `retry` qui accepte un entier `max_attempts` comme paramètre. Ce décorateur doit être capable d'encapsuler n'importe quelle fonction qu'il décore. La fonctionnalité principale du décorateur `retry` est de tenter d'exécuter la fonction déco... | ["\nassert retry(3)(lambda: 1/0) == 1/0\n", "\nassert retry(1)(lambda: 1) == 1\n", "\nassert retry(2)(lambda: \"hello\") == \"hello\"\n", "\nassert retry(5)(lambda x: x**2)(3) == 9\n", "\nassert retry(3)(lambda: [1, 2, 3]) == [1, 2, 3]\n", "\nassert retry(2)(lambda: {\"key\": \"value\"}) == {\"key\": \"value\"}\n", "\n... |
5c47619fc1b7de5e9b4c0db9354bd5dc | [
{
"content": "On te demande d'implémenter la fonction `is_atomic(value)` avec une contrainte de complexité temporelle de O(1) pour toutes les entrées. La fonction doit déterminer si une valeur donnée est atomique sans utiliser la fonction `type()`. Une valeur atomique est définie comme une valeur sur laquelle o... | ["\nassert is_atomic(42) == True\n", "\nassert is_atomic(3.14) == True\n", "\nassert is_atomic(True) == True\n", "\nassert is_atomic(None) == True\n", "\nassert is_atomic(\"hello\") == True\n", "\nassert is_atomic([1, 2, 3]) == False\n", "\nassert is_atomic((1, 2, 3)) == False\n", "\nassert is_atomic({1, 2, 3}) == Fals... |
0075b76b7ff501ea6113c3447f22229f | [
{
"content": "On te donne une liste de chaînes binaires, chacune représentant un chromosome dans une population. Chaque chromosome est constitué d'une série de gènes, représentés par des 1 et des 0, tous les chromosomes ayant la même longueur. Ta tâche est de convertir chaque chromosome binaire en son équivalen... | ["\nassert binary_to_golden_decimal([\"1010\"]) == [3.618033988749895]\n", "\nassert binary_to_golden_decimal([\"1100\"]) == [4.23606797749979]\n", "\nassert binary_to_golden_decimal([\"0011\"]) == [2.618033988749895]\n", "\nassert binary_to_golden_decimal([\"1111\"]) == [7.854101966249689]\n", "\nassert binary_to_gold... |
99a825df584e8c7c2fc27cfb2a6ac34b | [
{
"content": "On te donne une phrase constituée de mots séparés par des espaces et contenant éventuellement des signes de ponctuation. Ta tâche est de mettre en œuvre une fonction `scramble_sentence(sentence)` qui mélange les lettres centrales de chaque mot de la phrase, à condition que le mot comporte plus de ... | ["\nassert scramble_sentence(\"Hi\") == \"Hi\"\n", "\nassert scramble_sentence(\"Cat\") == \"Cat\"\n", "\nassert scramble_sentence(\"This is a test.\") == \"Tihs is a tset.\"\n", "\nassert scramble_sentence(\"Python is fun!\") == \"Pythno is fnu!\"\n", "\nassert scramble_sentence(\"Keep calm and code on.\") == \"Kepp a... |
7552af9b22aa7493797110a3e0cf2313 | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est d'implémenter une fonction `filter_string` qui traite chaque chaîne de caractères dans la liste et renvoie une nouvelle liste où chaque chaîne contient uniquement les caractères numériques de la chaîne d'entrée correspondante, en préserv... | ["\nassert filter_string([\"abc123\", \"def456ghi\", \"789jkl0\"]) == ['123', '456', '7890']\n", "\nassert filter_string([\"no numbers\", \"here either\"]) == ['', '']\n", "\nassert filter_string([\"123\", \"456\", \"789\"]) == ['123', '456', '789']\n", "\nassert filter_string([\"a1b2c3\", \"d4e5f6\", \"g7h8i9\"]) == [... |
4e1a7ebc106bd1fcdf0b2a39e07ce726 | [
{
"content": "Tu as pour tâche de créer une fonction `generate_test_cases` qui génère un ensemble complet de cas de test pour un algorithme de tri. La fonction doit accepter une liste d'entiers `numbers` et renvoyer une liste de tuples. Chaque tuple doit contenir une liste d'entiers non triée et la liste d'enti... | ["\nassert generate_test_cases([1, 2, 3, 4, 5]) == ([], []) in generate_test_cases([1, 2, 3, 4, 5])\n", "\nassert generate_test_cases([1, 2, 3, 4, 5]) == ([1], [1]) in generate_test_cases([1, 2, 3, 4, 5])\n", "\nassert generate_test_cases([1, 2, 3, 4, 5]) == ([1, 1, 1, 1, 1], [1, 1, 1, 1, 1]) in generate_test_cases([1,... |
27b613f7db7abca2bacfd1f615ce3b8d | [
{
"content": "On te donne un fichier CSV nommé `grades.csv` contenant une liste des notes des élèves. Chaque ligne du fichier représente un élève et ses notes dans trois matières. Le format de chaque ligne est `StudentID,Name,Grade1,Grade2,Grade3`. Ta tâche est d'écrire un script Python qui lit ce fichier et ca... | ["\nassert calculate_average_grades('test1.csv') == None # Assuming test1.csv contains \"1,John,85,90,78\" and output is \"1, 84.33\"\n", "\nassert calculate_average_grades('test2.csv') == None # Assuming test2.csv contains \"2,Jane,92,88,95\" and output is \"2, 91.67\"\n", "\nassert calculate_average_grades('test3.c... |
b3df2824d023cc9ffeb4c32dc4ae96ae | [
{
"content": "On te donne une liste d'entiers `intensity_levels` représentant l'intensité d'un signal à des intervalles de temps discrets. Ta tâche est de convertir cette séquence en une annotation basée sur des segments. Chaque segment doit être représenté par un tuple contenant l'heure de début, l'heure de fi... | ["\nassert segment_based_annotation([4, 5, 6, 2, 3]) == [(0.5, 1.5, 4), (1.5, 2.5, 5), (2.5, 3.5, 6), (3.5, 4.5, 2), (4.5, 5.5, 3)]\n", "\nassert segment_based_annotation([10]) == []\n", "\nassert segment_based_annotation([1, 2]) == [(0.5, 1.5, 1), (1.5, 2.5, 2)]\n", "\nassert segment_based_annotation([5, 5, 5, 5]) == ... |
3f4994d3a75de59c01d4455346d57016 | [
{
"content": "On te donne une liste d'entiers `sales` représentant les ventes quotidiennes d'un magasin. Implémente une fonction `cumulative_sales` qui calcule les ventes cumulées pour chaque jour en considérant une fenêtre glissante de taille `k`. La fonction doit renvoyer une nouvelle liste où chaque élément ... | ["\nassert cumulative_sales([1, 2, 3, 4], 3) == [1, 3, 6, 9]\n", "\nassert cumulative_sales([1, 2, 3, 4], 1) == [1, 2, 3, 4]\n", "\nassert cumulative_sales([1, 2, 3, 4], 4) == [1, 3, 6, 10]\n", "\nassert cumulative_sales([1, -2, 3, -4], 2) == [1, -1, 2, -2]\n", "\nassert cumulative_sales([10, 20, 30, 40, 50], 5) == [10... |
e2e9e97e3886cb023b3e6a68a099cde0 | [
{
"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 de caractères 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. ... | ["\nassert are_anagrams(\"listen\", \"silent\") == True\n", "\nassert are_anagrams(\"triangle\", \"integral\") == True\n", "\nassert are_anagrams(\"apple\", \"pale\") == False\n", "\nassert are_anagrams(\"a gentleman\", \"elegant man\") == True\n", "\nassert are_anagrams(\"Clint Eastwood\", \"Old West Action\") == True... |
088ddec2a787646300f1dc9de80b2a83 | [
{
"content": "On te donne deux chaînes de caractères `s1` et `s2`. Ta tâche est de mettre en œuvre une fonction `find_common_words` qui renvoie un ensemble de mots communs aux deux chaînes. Les mots doivent être comparés sans tenir compte de la casse, et la ponctuation doit être ignorée.\n\n**Entrée :**\n- Deux... | ["\nassert find_common_words(\"Hello, world!\", \"World of wonders\") == {\"world\"}\n", "\nassert find_common_words(\"Python is great.\", \"Great Python!\") == {\"python\", \"great\"}\n", "\nassert find_common_words(\"OpenAI\", \"AI Open\") == {\"openai\", \"ai\", \"open\"}\n", "\nassert find_common_words(\"No common ... |
05982fef041f4402e4d4d54c06358e70 | [
{
"content": "On te demande d'implémenter une fonction `generate_gradient` qui calcule une couleur dans un dégradé en fonction de paramètres spécifiques. La fonction doit gérer un nombre variable de teintes pour le dégradé et effectuer une transition en douceur entre ces teintes. La fonction doit également ajus... | ["\nassert generate_gradient(0.5, 0, [0, 120, 240], True) == (128, 128, 128)\n", "\nassert generate_gradient(0.0, 0, [0, 120, 240], True) == (255, 0, 0)\n", "\nassert generate_gradient(1.0, 0, [0, 120, 240], True) == (0, 0, 255)\n", "\nassert generate_gradient(0.5, 0, [0, 120, 240], False) == (127, 127, 127)\n", "\nass... |
a28fc26d0302003797a38fa273544e47 | [
{
"content": "On te donne une chaîne de caractères `s` et une liste de commandes `cmds`. Chaque commande est une chaîne de caractères de la forme `\"reverse <start> <end>\"`, où `<start>` et `<end>` sont des entiers représentant les indices de début et de fin d'une sous-chaîne dans `s`. Ta tâche est d'appliquer... | ["\nassert apply_commands(\"abcdefg\", [\"reverse 1 4\"]) == \"acbedfg\"\n", "\nassert apply_commands(\"abcdefg\", [\"reverse 2 6\"]) == \"abfedcg\"\n", "\nassert apply_commands(\"abcdefg\", [\"reverse 0 0\"]) == \"abcdefg\"\n", "\nassert apply_commands(\"abcdefg\", [\"reverse 0 7\"]) == \"gfedcba\"\n", "\nassert apply... |
599f4708ecbb224da14c434df3b666b0 | [
{
"content": "On te donne une chaîne de caractères `word` composée de lettres minuscules de l'alphabet anglais. Ta tâche est d'implémenter une fonction `find_vowels(word)` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les voyelles ('a', 'e', 'i', 'o', 'u'), et les valeurs doivent être des l... | ["\nassert find_vowels(\"example\") == {'e': [1, 7], 'a': [2], 'i': [], 'o': [], 'u': []}\n", "\nassert find_vowels(\"education\") == {'e': [0, 5], 'a': [3], 'i': [], 'o': [], 'u': []}\n", "\nassert find_vowels(\"beautiful\") == {'u': [2], 'e': [4], 'a': [], 'i': [], 'o': []}\n", "\nassert find_vowels(\"queueing\") == ... |
ec0702f9c585bba251c987f0e7eb2ba1 | [
{
"content": "On te donne un dictionnaire `d` où les clés sont des chaînes de caractères uniques et les valeurs peuvent être de n'importe quel type de données. Ta tâche est d'écrire une fonction `convert_values_to_uppercase` qui traite ce dictionnaire et renvoie un nouveau dictionnaire avec les mêmes clés. Pour... | ["\nassert convert_values_to_uppercase({\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}) == {\"name\": \"ALICE\", \"age\": 30, \"city\": \"NEW YORK\"}\n", "\nassert convert_values_to_uppercase({\"greeting\": \"hello\", \"number\": 123, \"flag\": True}) == {\"greeting\": \"HELLO\", \"number\": 123, \"flag\": T... |
4357772daa94cd0f5a21f648c914f5dc | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction qui trouve le deuxième plus grand nombre distinct de la liste. Si la liste contient moins de deux nombres distincts, la fonction doit renvoyer `None`. La solution doit être efficace et ne doit pas utiliser de fonctions de... | ["\nassert second_largest([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 9\n", "\nassert second_largest([10, 10, 10]) == None\n", "\nassert second_largest([10, 20]) == 10\n", "\nassert second_largest([10]) == None\n", "\nassert second_largest([10, 20, 20, 10]) == 10\n", "\nassert second_largest([5, 5, 5, 5, 5, 5, 5]) == None\n", ... |
d7382c013ee68eec097f955c48e75204 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discount` qui calcule le prix final d'un produit après avoir appliqué un pourcentage de réduction donné. La fonction doit prendre deux paramètres : le prix initial du produit et le pourcentage de réduction. Ta fonction doit renvoyer le prix final... | ["\nassert calculate_discount(100, 20) == 80.0\n", "\nassert calculate_discount(200, 50) == 100.0\n", "\nassert calculate_discount(150, 0) == 150.0\n", "\nassert calculate_discount(0, 10) == 0.0\n", "\nassert calculate_discount(100, 100) == 0.0\n", "\nassert calculate_discount(99.99, 5) == 94.9905\n", "\nassert calcula... |
0fac159939d5b750b1c0b4eb4e23bc29 | [
{
"content": "On te donne un entier `n` supérieur à 1. Ta tâche est d'écrire une fonction `find_largest_prime_factor(n)` qui renvoie le plus grand facteur premier de `n`.\n\n**Entrée :**\n- Un entier `n` (2 ≤ n ≤ 10^12)\n\n**Sortie :**\n- Un entier représentant le plus grand facteur premier de `n`.\n\n**Exemple... | ["\nassert find_largest_prime_factor(28) == 7\n", "\nassert find_largest_prime_factor(15) == 5\n", "\nassert find_largest_prime_factor(13195) == 29\n", "\nassert find_largest_prime_factor(2) == 2\n", "\nassert find_largest_prime_factor(3) == 3\n", "\nassert find_largest_prime_factor(5) == 5\n", "\nassert find_largest_p... |
d0c538fa248f0a6a339003be8891af00 | [
{
"content": "On te demande d'implémenter une classe `Circle` en Python qui modélise un cercle avec un rayon spécifié. La classe doit inclure les fonctionnalités suivantes :\n\n- Un constructeur qui accepte le rayon comme argument.\n- Une méthode `area` qui calcule et renvoie l'aire du cercle en utilisant la fo... | ["\nassert Circle(0).area() == 0\n", "\nassert Circle(1).area() == math.pi\n", "\nassert Circle(2).area() == 4 * math.pi\n", "\nassert Circle(0).circumference() == 0\n", "\nassert Circle(1).circumference() == 2 * math.pi\n", "\nassert Circle(2.5).circumference() == 5 * math.pi\n", "\nassert Circle(10).area() == 100 * m... |
d41d16fa0ad5f96950085171a3e6f390 | [
{
"content": "On te donne une chaîne de caractères `s` composée de mots séparés par le caractère `'/'`. Ton objectif est d'implémenter une fonction `extract_rightmost_word` qui renvoie un tuple contenant le mot le plus à droite dans la chaîne et la chaîne restante avec le mot le plus à droite supprimé. La fonct... | ["\nassert extract_rightmost_word(\"a/b/c/d\") == ('d', 'a/b/c')\n", "\nassert extract_rightmost_word(\"/a/b/c/d/\") == ('d', 'a/b/c')\n", "\nassert extract_rightmost_word(\"//\") == ('', '')\n", "\nassert extract_rightmost_word(\"a\") == ('a', '')\n", "\nassert extract_rightmost_word(\"\") == ('', '')\n", "\nassert ex... |
8c0a8a55e3df2f3112411f526099d025 | [
{
"content": "On te donne une chaîne de caractères représentant un extrait de code Python. Ta tâche est d'écrire une fonction `remove_comments` qui supprime tous les commentaires du code donné. Les commentaires peuvent être soit sur une seule ligne (commençant par `#` et se poursuivant jusqu'à la fin de la lign... | ["\nassert remove_comments(\"print('Hello') # Comment\") == \"print('Hello') \"\n", "\nassert remove_comments('\"\"\"Multi-line comment\"\"\"') == ''\n", "\nassert remove_comments('def func():\\n\\t\"\"\"Docstring\"\"\"\\n\\tpass') == 'def func():\\n\\tpass'\n", "\nassert remove_comments('a = 10\\n# a = 20') == 'a = 10... |
3c343db79435b8eee28df32789748ab1 | [
{
"content": "On te donne une liste de `n` mots et un dictionnaire `badwordinfo` contenant des informations sur certains « mauvais mots » dans la liste. Chaque entrée du dictionnaire est une paire clé-valeur où la clé est l'index original d'un mauvais mot dans la liste, et la valeur est le niveau de gravité de ... | ["\nassert find_max_severity([\"hello\", \"world\"], {}) == 0\n", "\nassert find_max_severity([\"damn\", \"it\", \"sucks\", \"f*ck\"], {0: 4, 3: 6, 2: 3}) == 6\n", "\nassert find_max_severity([\"good\", \"bad\", \"ugly\"], {1: 2, 2: 1}) == 2\n", "\nassert find_max_severity([\"a\", \"b\", \"c\", \"d\"], {0: 1, 1: 2, 2: ... |
7a3f0a091a0cec72691073e424fc7685 | [
{
"content": "On te donne un tableau de chaînes de caractères `strings` et une chaîne de caractères `target`. Ta tâche est de mettre en œuvre une fonction qui trouve le plus long préfixe commun parmi toutes les chaînes du tableau qui commence par la chaîne `target`. Si un tel préfixe n'existe pas, renvoie une c... | ["\nassert longest_common_prefix_with_target([\"flower\", \"flow\", \"flight\", \"flourish\"], \"fl\") == \"flow\"\n", "\nassert longest_common_prefix_with_target([\"dog\", \"racecar\", \"car\"], \"ca\") == \"\"\n", "\nassert longest_common_prefix_with_target([\"interspecies\", \"interstellar\", \"interstate\"], \"inte... |
aff3b80d586cb616fd8e692b2f2710fa | [
{
"content": "On te donne pour tâche d'implémenter une fonction qui lit un fichier JSON et récupère la valeur associée à une clé spécifiée. Ta fonction doit gérer les cas où le fichier n'existe pas ou le JSON est malformé en renvoyant `None`. La fonction doit être efficace et robuste.\n\n**Signature de la fonct... | ["\nassert get_value_from_json(\"test.json\", \"name\") == \"John\"\n", "\nassert get_value_from_json(\"test.json\", \"age\") == 30\n", "\nassert get_value_from_json(\"test.json\", \"address\") == None\n", "\nassert get_value_from_json(\"non_existent_file.json\", \"name\") == None\n", "\nassert get_value_from_json(\"in... |
e9479d323a677d1e43493fc880896f6e | [
{
"content": "On te donne un ensemble de données constitué de `N` tuples, où chaque tuple contient un point de données et son étiquette correspondante. Chaque point de données est représenté comme une liste de `M` valeurs numériques, et chaque étiquette est un entier. Ta tâche est de mettre en œuvre une fonctio... | ["\nassert separate_and_sort_dataset([([1, 2, 3], 0), ([4, 5, 6], 1), ([0, 0, 1], 2)]) == ([[4, 5, 6], [1, 2, 3], [0, 0, 1]], [1, 0, 2])\n", "\nassert separate_and_sort_dataset([([10], 1), ([5], 2), ([1], 3)]) == ([[10], [5], [1]], [1, 2, 3])\n", "\nassert separate_and_sort_dataset([([1, 1, 1], 1), ([2, 2, 2], 2), ([3,... |
10af00f445d7efd87887c3974b9515c4 | [
{
"content": "On te donne une liste d'entiers distincts `nums`. Ta tâche est de générer tous les sous-ensembles possibles de `nums`, y compris l'ensemble vide et l'ensemble lui-même. Les sous-ensembles peuvent être retournés dans n'importe quel ordre.\n\n**Entrée :**\n- Une liste d'entiers `nums` (1 ≤ len(nums)... | ["\nassert generate_subsets([1, 2, 3]) == [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]\n", "\nassert generate_subsets([1]) == [[], [1]]\n", "\nassert generate_subsets([]) == [[]]\n", "\nassert generate_subsets([1, 2]) == [[], [1], [1, 2], [2]]\n", "\nassert generate_subsets([1, 2, 3, 4]) == [[], [1], [1, 2], ... |
7635b27515ef8a6c12e266591bf5a8d5 | [
{
"content": "Tu développes un pipeline de prétraitement pour un modèle d'apprentissage profond qui prédit le flux de particules dans une chambre de projection temporelle à argon liquide (LArTPC). Ta tâche est d'implémenter une fonction qui prétraite les images d'entrée en les standardisant, en les normalisant ... | ["\nassert preprocess_data(np.array([[1, 2], [3, 4]])).shape == (2, 2)\n", "\nassert np.allclose(preprocess_data(np.array([[1, 1], [1, 1]])), np.array([[0., 0.], [0., 0.]]))\n", "\nassert np.allclose(preprocess_data(np.array([[0, 1], [2, 3]])), np.array([[0., 0.], [1., 1.]]))\n", "\nassert np.allclose(preprocess_data(n... |
452a173ed9c6b818bce2ebe8b0dfcaf2 | [
{
"content": "On te donne un tableau d'entiers `numbers`. Ta tâche est de trouver le produit maximal de tout sous-tableau contigu dans `numbers`. Un sous-tableau est défini comme un segment contigu non vide du tableau.\n\n**Contraintes :**\n- Le tableau `numbers` contiendra au moins un entier.\n- Le tableau peu... | ["\nassert find_max_product_subarray([2, 3, -2, 4]) == 6\n", "\nassert find_max_product_subarray([-2, 0, -1]) == 0\n", "\nassert find_max_product_subarray([-2, -3, 0, -5, -1]) == 30\n", "\nassert find_max_product_subarray([0, 2]) == 2\n", "\nassert find_max_product_subarray([-1, -2, -3, -4]) == 24\n", "\nassert find_ma... |
6a954b7346fe8cfd853410394f9d800a | [
{
"content": "On te donne une liste d'entiers positifs `nums` de longueur `n` (où `n >= 3`). Ta tâche est de construire une chaîne de caractères qui représente la division de ces nombres de gauche à droite, en maximisant le résultat en plaçant stratégiquement une seule paire de parenthèses. Les parenthèses doiv... | ["\nassert maximize_division([2, 3, 4, 5]) == \"2/(3/4/5)/5\"\n", "\nassert maximize_division([10, 2, 5]) == \"10/(2/5)/5\"\n", "\nassert maximize_division([1, 2]) == \"1/2\"\n", "\nassert maximize_division([7, 3, 2, 8, 4]) == \"7/(3/2/8/4)/4\"\n", "\nassert maximize_division([5]) == \"5\"\n", "\nassert maximize_divisi... |
a12352471be4b4f70c5b1c76594c7aae | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots anglais séparés par des espaces. Ta tâche est d'écrire une fonction `word_frequencies` qui traite ce texte et renvoie un dictionnaire avec la fréquence de chaque mot, en excluant les mots vides courants. Les mots vides à ignorer sont :... | ["\nassert word_frequencies(\"The quick brown fox jumps over the lazy dog.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert word_frequencies(\"The quick brown fox jumps over the lazy dog. The dog was not amused.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over... |
8b074449db777e3f103f74282d98f161 | [
{
"content": "On te donne une chaîne de caractères `s`, un motif `pat`, et une fonction de remplacement `repl_fn`. Ta tâche est d'implémenter la fonction `custom_replace` qui remplace toutes les occurrences du motif dans la chaîne par le résultat de la fonction de remplacement. La fonction de remplacement prend... | ["\nassert custom_replace(\"hello world\", \"world\", lambda x: \"there\") == \"hello there\"\n", "\nassert custom_replace(\"banana\", \"na\", lambda x: \"ma\") == \"bamama\"\n", "\nassert custom_replace(\"aaaa\", \"aa\", lambda x: \"bb\") == \"bbbb\"\n", "\nassert custom_replace(\"abcabcabc\", \"abc\", lambda x: \"xyz... |
edd5c0115dbb212859842830e3615dd2 | [
{
"content": "On te donne une liste d'entiers, qui peut inclure des nombres négatifs. Ta tâche est d'écrire une fonction `max_element` qui renvoie l'élément maximal de la liste. Si la liste est vide, la fonction doit lever une exception `ValueError` avec le message \"Input list cannot be empty\".\n\n**Exemple d... | ["\nassert max_element([1, 2, 3, 4, 5]) == 5\n", "\nassert max_element([-1, -2, -3, -4, -5]) == -1\n", "\nassert max_element([-10, 0, 10]) == 10\n", "\nassert max_element([0, 0, 0, 0]) == 0\n", "\nassert max_element([-100, -200, -300, -50]) == -50\n", "\nassert max_element([100, -100, 50, -50]) == 100\n", "\nassert max... |
9a432ba6c68be28f973f5c76b837f95f | [
{
"content": "On te donne une liste de polygones, où chaque polygone est représenté comme une liste de coordonnées au format `[x1, y1, x2, y2, ..., xn, yn]`. Ta tâche est d'écrire une fonction qui calcule le rectangle englobant minimal (pas nécessairement aligné sur les axes) pour chaque polygone et renvoie une... | ["\nassert min_bounding_rectangles([[0, 0, 1, 0, 1, 1, 0, 1]]) == [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0]\n", "\nassert min_bounding_rectangles([[1, 0, 2, 0, 2, 2, 1, 2]]) == [1.0, 0.0, 2.0, 0.0, 2.0, 2.0, 1.0, 2.0]\n", "\nassert min_bounding_rectangles([[0, 0, 1, 2, 2, 0]]) == [0.5, 0.0, 1.5, 1.0, 2.0, 0.0, 1.0, -1.0... |
22373d62e493af7379f4bc5c8c561b06 | [
{
"content": "On te donne deux entiers, `x` et `y`. Ta tâche est de refactoriser le code fourni pour le rendre plus lisible et maintenable. La fonction doit renvoyer la valeur absolue du plus grand des deux entiers, en conservant son signe d'origine. Si les deux entiers sont nuls, la fonction doit renvoyer 0.\n... | ["\nassert calculate_adjusted_value(5, 10) == 10\n", "\nassert calculate_adjusted_value(-5, 10) == 10\n", "\nassert calculate_adjusted_value(5, -10) == -10\n", "\nassert calculate_adjusted_value(-5, -10) == -10\n", "\nassert calculate_adjusted_value(0, 0) == 0\n", "\nassert calculate_adjusted_value(0, 5) == 5\n", "\nas... |
377f119375ea682fe34e0c8c4236204b | [
{
"content": "Tu es chargé d'implémenter une fonction `count_words_in_file(file_path)` qui compte efficacement les occurrences de chaque mot unique dans un fichier texte donné. La fonction doit gérer les fichiers volumineux en minimisant l'utilisation de la mémoire et le temps de traitement. Les mots sont défin... | ["\nassert count_words_in_file('test_file_1.txt') == {'hello': 1, 'world': 1}\n", "\nassert count_words_in_file('test_file_2.txt') == {'this': 2, 'is': 2, 'a': 2, 'test': 2}\n", "\nassert count_words_in_file('test_file_3.txt') == {'python': 1, 'programming': 1, 'language': 1}\n", "\nassert count_words_in_file('test_fil... |
6dc50f97b7b35576a3085e24ce636c52 | [
{
"content": "On te donne une séquence d'ADN constituée des bases A, C, G et T sous forme de chaîne de caractères. Ta tâche est de mettre en œuvre une fonction `gc_content(sequence)` qui calcule deux valeurs : le pourcentage de contenu GC et le nombre de paires GC dans la séquence. Le contenu GC est défini comm... | ["\nassert gc_content(\"ATCGTAGCCGCGATCG\") == (43.75, 3)\n", "\nassert gc_content(\"GCGCGCGCGCGCGCGC\") == (100.0, 13)\n", "\nassert gc_content(\"ATATATATATATATAT\") == (0.0, 0)\n", "\nassert gc_content(\"GC\") == (100.0, 0)\n", "\nassert gc_content(\"GCGC\") == (100.0, 2)\n", "\nassert gc_content(\"A\") == (0.0, 0)\n... |
2506f2a5900af0d2f93b0b53ea842cf9 | [
{
"content": "On te donne un tableau d'entiers `numbers` et un entier `target`. Implémente une fonction `quick_sort_count(numbers, target)` qui trie le tableau en utilisant l'algorithme Quick Sort sans récursion et compte le nombre d'éléments dans le tableau trié qui sont inférieurs ou égaux à `target`. Retourn... | ["\nassert quick_sort_count([3, 6, 8, 10, 1, 2, 1], 5) == 4\n", "\nassert quick_sort_count([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 5) == 5\n", "\nassert quick_sort_count([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5) == 5\n", "\nassert quick_sort_count([5, 5, 5, 5, 5], 5) == 5\n", "\nassert quick_sort_count([1, 2, 3, 4, 5], 0) == 0\n", ... |
04b9e17a865d99111f99cb59d9cf7f2f | [
{
"content": "On te donne un carré de côté 1 centré à l'origine (0,0). À l'intérieur de ce carré, il y a une ellipse centrée à l'origine avec un demi-grand axe `a` de 0,7 et un demi-petit axe `b` de 0,5. Ta tâche est d'implémenter une fonction `is_inside_ellipse` qui génère un point aléatoire à l'intérieur du c... | ["\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_inside_ellipse() in [True, False]\n", "\nassert is_... |
c5567b42e6b84d882366764415c068fd | [
{
"content": "On te donne un entier `num`. Ta tâche est de déterminer si `num` peut être exprimé comme la somme des cubes de ses chiffres. Implémente la fonction `is_sum_of_cubes(num)` pour résoudre ce problème. Tu **n'es pas** autorisé à convertir le nombre en chaîne de caractères à aucun moment.\n\n**Contrain... | ["\nassert is_sum_of_cubes(153) == True\n", "\nassert is_sum_of_cubes(370) == True\n", "\nassert is_sum_of_cubes(371) == True\n", "\nassert is_sum_of_cubes(407) == True\n", "\nassert is_sum_of_cubes(1) == False\n", "\nassert is_sum_of_cubes(100) == False\n", "\nassert is_sum_of_cubes(9474) == True\n", "\nassert is_sum_... |
9ed1061d69f298850f9755c114713252 | [
{
"content": "On te donne une chaîne de caractères `txt` et un séparateur `sep`. Ta tâche est de mettre en œuvre une fonction `extract_info_from_string(txt, sep)` qui extrait toutes les sous-chaînes encadrées par le séparateur `sep` et les renvoie dans une liste. Le séparateur `sep` peut apparaître plusieurs fo... | ["\nassert extract_info_from_string(\"This is <info1> an example string with <info2> multiple <info3> separators.\", \"<>\") == ['info1', 'info2', 'info3']\n", "\nassert extract_info_from_string(\"No separators here.\", \"<>\") == []\n", "\nassert extract_info_from_string(\"<info1><info2><info3>\", \"<>\") == ['info1',... |
79cdaf1d6e683debac62ca1bee514ac4 | [
{
"content": "On te demande d'implémenter une simulation simple de distributeur automatique en Python. Le distributeur automatique doit prendre en charge les opérations suivantes :\n\n1. **Ajouter un article** : Ajouter un nouvel article ou mettre à jour la quantité d'un article existant. Chaque article a un no... | ["\nassert isinstance(VendingMachine(), VendingMachine)\n", "\nvm = VendingMachine(); vm.add_item('Soda', 1.50, 5); assert vm.items['Soda'] == {'price': 1.50, 'quantity': 5}\n", "\nvm = VendingMachine(); vm.add_item('Soda', 1.50, 5); vm.add_item('Soda', 1.50, 3); assert vm.items['Soda'] == {'price': 1.50, 'quantity': 8... |
e9ad54ebf73d182bec083063a7a7002a | [
{
"content": "On te donne un ensemble de données représenté comme une liste de dictionnaires, où chaque dictionnaire correspond à une ligne d'un tableau. Tous les dictionnaires partagent le même ensemble de clés, mais certaines valeurs peuvent être manquantes. Ta tâche est de transformer cet ensemble de données... | ["\nassert convert_dicts_to_lists([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}], ['a', 'b']) == [[1, 2], [3, 4]]\n", "\nassert convert_dicts_to_lists([{'a': 1, 'b': 2}, {'a': 3}], ['a', 'b']) == [[1, 2], [3, None]]\n", "\nassert convert_dicts_to_lists([{'a': 1}, {'b': 2}], ['a', 'b']) == [[1, None], [None, 2]]\n", "\nassert con... |
398441c63106d04c30ac032dcaddec7b | [
{
"content": "On te demande d'implémenter une application console textuelle pour simuler un jeu de Tic Tac Toe (morpion) pour deux joueurs. Le plateau de jeu est une grille 3x3. Les joueurs marquent à tour de rôle une cellule de la grille avec leur symbole ('X' pour le premier joueur et 'O' pour le second joueu... | ["\nassert check_winner([[\"X\", \"X\", \"X\"], [\" \", \" \", \" \"], [\" \", \" \", \" \"]]) == \"X\"\n", "\nassert check_winner([[\" \", \" \", \" \"], [\"O\", \"O\", \"O\"], [\" \", \" \", \" \"]]) == \"O\"\n", "\nassert check_winner([[\" \", \" \", \" \"], [\" \", \" \", \" \"], [\"X\", \"X\", \"X\"]]) == \"X\"\n"... |
2e590a05b31c182581c27919ca004e44 | [
{
"content": "On te donne une liste de tuples, où chaque tuple contient trois entiers : `(a, b, c)`. Chaque tuple représente une fonction de la forme `f(x) = ax^2 + bx + c` si `a ≠ 0`, ou `f(x) = bx + c` si `a = 0`. Ta tâche est d'écrire une fonction qui prend cette liste de tuples en entrée et renvoie une list... | ["\nassert create_quadratic_functions([(1, -3, 2)])[0](2) == 0\n", "\nassert create_quadratic_functions([(1, -3, 2)])[0](1) == -2\n", "\nassert create_quadratic_functions([(1, -3, 2)])[0](3) == 2\n", "\nassert create_quadratic_functions([(1, -3, 2)])[0](0) == 2\n", "\nassert create_quadratic_functions([(0, 2, 3)])[0](0... |
4748dc3821849b33205e3cc6a1f3fbe4 | [
{
"content": "On te charge de gérer l'occupation des étages d'un immeuble. Chaque étage a une limite d'occupation maximale spécifique. Étant donné une liste de personnes et leurs étages souhaités, affecte chaque personne à son étage souhaité si celui-ci n'est pas complet. Si l'étage souhaité est complet, affect... | ["\nassert assign_floors({0: 0, 1: 0, 2: 0}, {0: 1, 1: 1, 2: 1}, [(1, 2)]) == {0: 0, 1: 0, 2: 1}\n", "\nassert assign_floors({0: 0, 1: 1, 2: 2}, {0: 1, 1: 1, 2: 2}, [(1, 2), (2, 2)]) == {0: 1, 1: 1, 2: 2}\n", "\nassert assign_floors({0: 0, 1: 1, 2: 2}, {0: 1, 1: 1, 2: 2}, [(1, 3)]) == {0: 1, 1: 1, 2: 2}\n", "\nassert a... |
3001942627056651951a915dd6fe5365 | [
{
"content": "On te donne une structure de données à nœuds liés représentant une séquence d'ADN. Chaque nœud contient un seul caractère représentant une nucléotide (A, T, C ou G) stocké dans l'attribut `nucleotide`. L'attribut `nextNode` pointe vers le nœud suivant dans la séquence. Le dernier nœud a un attribu... | ["\nassert get_dna_sequence(Node('A', nextNode=Node('T', nextNode=Node('C'))), ['nextNode']) == \"ATC\"\n", "\nassert get_dna_sequence(Node('G', branch=Node('A', branch=Node('T'))), ['branch']) == \"GAT\"\n", "\nassert get_dna_sequence(Node('C', link=Node('G', link=Node('A', link=Node('T')))), ['link']) == \"CGAT\"\n",... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.