id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
116d99fe21ab3f71c5690f4289f4bb54 | [
{
"content": "On te donne une liste imbriquée contenant des entiers et des chaînes de caractères. Ta tâche est de mettre en œuvre une fonction `deep_flatten` qui renvoie une seule liste d'entiers. Les entiers doivent apparaître dans le même ordre que dans la liste imbriquée, et toutes les chaînes de caractères ... | ["\nassert deep_flatten([1, 2, 3]) == [1, 2, 3]\n", "\nassert deep_flatten([[1, 2], [3, [4, 5]], 6]) == [1, 2, 3, 4, 5, 6]\n", "\nassert deep_flatten([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert deep_flatten([1, 'a', [2, 'b', [3, 'c', [4, 'd', [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert deep_flatten(['string... |
dda2bd4b9d4ed8de6d8af75444dde24c | [
{
"content": "On te donne une liste d'entiers `numbers` où chaque entier représente les ventes d'un article unique un jour donné. L'index de chaque entier dans la liste correspond au jour de la vente, en commençant au jour 0. Ta tâche est de mettre en œuvre une fonction `moving_average_sales(numbers, window)` q... | ["\nassert moving_average_sales([3, 5, 2, 8, 0, 7, 1, 9, 4], 5) == [2.0, 3.0, 2.3333333333333335, 2.0]\n", "\nassert moving_average_sales([1, 2, 3, 4, 5, 6, 7, 8, 9], 3) == [2.0, 4.0, 6.0, 8.0]\n", "\nassert moving_average_sales([10, 20, 30, 40, 50], 2) == [None, 20.0, 30.0, 40.0]\n", "\nassert moving_average_sales([1,... |
e5603a739cc6a021b5c21837d2aee936 | [
{
"content": "On te donne deux entiers positifs, `n` et `factor`. Ta tâche est de calculer la somme de la série `factor + factor*2 + factor*3 + ... + factor*k`, où `k` est le plus grand entier tel que `factor*k` soit un nombre palindrome et `factor*k` ne dépasse pas `n`.\n\n**Entrée :**\n- La première ligne con... | ["\nassert sum_of_multiples(100, 1) == 204\n", "\nassert sum_of_multiples(50, 5) == 55\n", "\nassert sum_of_multiples(200, 11) == 11\n", "\nassert sum_of_multiples(1000, 10) == 0\n", "\nassert sum_of_multiples(999, 9) == 1782\n", "\nassert sum_of_multiples(1, 1) == 1\n", "\nassert sum_of_multiples(123, 123) == 123\n", ... |
296539b7eb6eec8f4aaf497ee0feac84 | [
{
"content": "On te donne pour tâche d'implémenter une fonction qui traite un fichier de configuration nommé `config.json` pour un projet logiciel. Le fichier est au format JSON et contient divers paramètres de configuration tels que le nom du projet, la version, les dépendances et les scripts. Ton travail cons... | ["\nassert sanitize_string(\"hello-world\") == \"hello-world\"\n", "\nassert sanitize_string(\"hello_world\") == \"hello_world\"\n", "\nassert sanitize_string(\"hello world!\") == \"helloworld\"\n", "\nassert sanitize_string(\"123abc!@#\") == \"123abc\"\n", "\nassert sanitize_string(\"no_special_chars\") == \"no_specia... |
a4f1f6fb9f40097498282c81a7a88c7b | [
{
"content": "On te demande d'implémenter une fonction pour calculer le nième nombre de Fibonacci efficacement. 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 >= 2. Ta fonction doit être capable de gérer des valeurs très grandes de `n` efficacement, en utilis... | ["\nassert fibonacci(0) == 0\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci_optimized(0) == 0\n", "\nassert fibonacci_optimized(1) == 1\n", "\nassert fibonacci_optimized(10) == ... |
0f4f6b2ae867d72ec2e425561c59ebb9 | [
{
"content": "On te donne un tableau `nums` de `n` entiers où `n >= 2`. Ta tâche est de construire un tableau `result` tel que `result[i]` soit le produit de tous les éléments dans `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division.\n\n**Entrée :**\n- Un tableau d'entiers `nums` de lo... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([2, 3, 4, 5]) == [60, 40, 30, 24]\n", "\nassert product_except_self([5, 3, 2, 4, 1]) == [24, 40, 60, 30, 60]\n", "\nassert product_except_self([1, 1, 1, 1]) == [1, 1, 1, 1]\n", "\nassert product_except_self([0, 1, 2, 3]) ==... |
07750dbd10b098ecb3ec963ede2e2560 | [
{
"content": "On te donne une structure imbriquée composée de dictionnaires, de listes, de chaînes de caractères, d'entiers et de nombres à virgule flottante. Ta tâche est d'aplanir cette structure en un seul dictionnaire. Les clés dans le dictionnaire résultant doivent représenter les chemins vers les valeurs ... | ["\nassert flatten_nested_structure({\"a\": 1}) == {\"a\": 1}\n", "\nassert flatten_nested_structure({\"a\": {\"b\": 2}}) == {\"a.b\": 2}\n", "\nassert flatten_nested_structure({\"a\": [1, 2, 3]}) == {\"a.0\": 1, \"a.1\": 2, \"a.2\": 3}\n", "\nassert flatten_nested_structure({\"a\": [{\"b\": 2}, {\"c\": 3}]}) == {\"a.0... |
efae72a83e4a169e1641100bd1b12ea5 | [
{
"content": "On te donne un tuple et un élément. Ta tâche est d'implémenter une fonction `find_element_index` qui renvoie l'index de la première occurrence de l'élément dans le tuple, en se basant sur la comparaison des valeurs de hachage. Si l'élément n'est pas trouvé, renvoie la chaîne de caractères \"Elemen... | ["\nassert find_element_index((1, 2, 3, 4), 3) == 2\n", "\nassert find_element_index(('a', 'b', 'c'), 'b') == 1\n", "\nassert find_element_index((True, False, True), False) == 1\n", "\nassert find_element_index((1.1, 2.2, 3.3), 2.2) == 1\n", "\nassert find_element_index((1, 'a', 3.3, True), 'a') == 1\n", "\nassert find... |
b724336e0840bcbb338e349badeae516 | [
{
"content": "On te demande d'implémenter une fonction pour valider les adresses IPv4. Ta fonction doit déterminer si une chaîne de caractères donnée est une adresse IPv4 valide et renvoyer `True` si elle est valide, sinon `False`. Une adresse IPv4 valide est constituée de quatre nombres décimaux, chacun allant... | ["\nassert is_valid_ipv4(\"192.168.1.1\") == True\n", "\nassert is_valid_ipv4(\"255.255.255.255\") == True\n", "\nassert is_valid_ipv4(\"0.0.0.0\") == True\n", "\nassert is_valid_ipv4(\"256.256.256.256\") == False\n", "\nassert is_valid_ipv4(\"192.168.1\") == False\n", "\nassert is_valid_ipv4(\"192.168.1.1.1\") == Fals... |
ea1d06689cca6ec6f44e6ec158b9e99a | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui renvoie le nombre de caractères uniques dans la chaîne, sans tenir compte de la casse. La fonction doit être efficace et gérer les chaînes de caractères allant jusqu'à 10^5 caractères.\n\n**Exemple d'entrée :**\n```\n... | ["\nassert count_unique_characters(\"HelloWorld\") == 7\n", "\nassert count_unique_characters(\"Python\") == 6\n", "\nassert count_unique_characters(\"AaBbCc\") == 3\n", "\nassert count_unique_characters(\"1234567890\") == 10\n", "\nassert count_unique_characters(\"!@#$%^&*()\") == 10\n", "\nassert count_unique_charact... |
58d6069858df8116040d50a18731e785 | [
{
"content": "On te donne une liste de vecteurs 2D, où chaque vecteur est représenté comme un tuple de deux nombres à virgule flottante. Ta tâche est de normaliser chaque vecteur de la liste de sorte que son amplitude devienne 1, sans en altérer la direction. Si un vecteur a une amplitude de 0, il doit rester i... | ["\nassert normalize_vectors([(1.0, 2.0)]) == [(0.4472135954999579, 0.8944271909999159)]\n", "\nassert normalize_vectors([(3.0, 4.0)]) == [(0.6, 0.8)]\n", "\nassert normalize_vectors([(0.0, 0.0)]) == [(0.0, 0.0)]\n", "\nassert normalize_vectors([(-1.0, -2.0)]) == [(0.4472135954999579, 0.8944271909999159)]\n", "\nassert... |
798aefe479b44d0719cd7a186ab893ba | [
{
"content": "On te demande d'implémenter une fonction `get_optimizer(config, model)` qui configure et renvoie un optimiseur pour un modèle PyTorch donné, en se basant sur un dictionnaire de configuration fourni. Le dictionnaire de configuration (`config`) inclut les clés suivantes :\n- `OPTIMIZER` : une chaîne... | ["\nassert isinstance(get_optimizer({'OPTIMIZER': 'adam', 'LR': 0.001, 'WEIGHT_DECAY': 0.01, 'BATCH_SIZE': 16}, torch.nn.Linear(10, 1)), torch.optim.Adam)\n", "\nassert isinstance(get_optimizer({'OPTIMIZER': 'adamw', 'LR': 0.001, 'WEIGHT_DECAY': 0.01, 'BATCH_SIZE': 16}, torch.nn.Linear(10, 1)), torch.optim.AdamW)\n", "... |
e3d642f49630eab45abd549346e7690b | [
{
"content": "On te donne un entier positif `n` supérieur à 1. Ta tâche est d'écrire une fonction `findPrimeFactors(n)` qui renvoie un dictionnaire où les clés sont les facteurs premiers de `n` et les valeurs sont leurs puissances respectives dans la factorisation première de `n`.\n\n**Entrée :**\n- Un entier `... | ["\nassert findPrimeFactors(2) == {2: 1}\n", "\nassert findPrimeFactors(3) == {3: 1}\n", "\nassert findPrimeFactors(4) == {2: 2}\n", "\nassert findPrimeFactors(5) == {5: 1}\n", "\nassert findPrimeFactors(6) == {2: 1, 3: 1}\n", "\nassert findPrimeFactors(12) == {2: 2, 3: 1}\n", "\nassert findPrimeFactors(18) == {2: 1, 3... |
e9e91d439a5d786b0f13230d0012247e | [
{
"content": "Tu développes un jeu où les personnages s'engagent au combat. Chaque personnage possède des attributs `power` et `defense`. Lorsqu'un personnage (l'attaquant) inflige des dégâts à un autre personnage (le défenseur), les dégâts sont calculés à l'aide de la formule : `damage = attacker_power * (1 - ... | ["\nassert calculate_damage({'power': 100, 'defense': 10}, {'power': 80, 'defense': 20}) == 80.0\n", "\nassert calculate_damage({'power': 50, 'defense': 0}, {'power': 30, 'defense': 0}) == 50.0\n", "\nassert calculate_damage({'power': 200, 'defense': 50}, {'power': 150, 'defense': 50}) == 100.0\n", "\nassert calculate_... |
245b521f205a96522425c970e6ae7bd5 | [
{
"content": "On te demande d'implémenter une fonction `read_file_content` qui lit le contenu d'un fichier à partir de son chemin. Ta fonction doit gérer les exceptions avec élégance et renvoyer le contenu sous forme de chaîne de caractères. Si le fichier n'existe pas ou ne peut pas être lu, renvoie un message ... | ["\nassert read_file_content(\"test.txt\") == \"This is a test file.\\n\"\n", "\nassert read_file_content(\"non_existent_file.txt\") == \"Error: The file does not exist.\"\n", "\nassert read_file_content(\"empty_file.txt\") == \"\"\n", "\nassert read_file_content(\"file_with_one_line.txt\") == \"Single line here.\\n\"\... |
7b59eebf98530ff834fc392b4cd1215c | [
{
"content": "On te donne une chaîne de caractères `code_segment` représentant un segment de code. Ta tâche est d'implémenter une fonction `extract_inline_code` qui extrait tous les extraits de code en ligne uniques, encadrés par des backticks (`` ` ``), de la chaîne. Les extraits doivent être renvoyés dans une... | ["\nassert extract_inline_code(\"Here is some `code` and `more code`\") == [\"code\", \"more code\"]\n", "\nassert extract_inline_code(\"No code here!\") == []\n", "\nassert extract_inline_code(\"`single`\") == [\"single\"]\n", "\nassert extract_inline_code(\"``double``\") == [\"double\"]\n", "\nassert extract_inline_c... |
4e76a99a0a7b9f372950fdaa7d8684db | [
{
"content": "On te donne une liste de points 3D, où chaque point est représenté comme un tuple de trois nombres à virgule flottante (x, y, z). Ta tâche est d'écrire une fonction qui calcule le centre de masse de ces points après avoir fait pivoter chaque point autour de l'axe z d'un angle θ (en radians). Suppo... | ["\nassert calculate_center_of_mass([(1, 0, 0), (0, 1, 0)], math.pi / 2) == (0.0, 0.0, 0.0)\n", "\nassert calculate_center_of_mass([(1, 0, 0), (0, 1, 0)], 0) == (0.5, 0.5, 0.0)\n", "\nassert calculate_center_of_mass([(1, 0, 0), (0, 1, 0), (0, 0, 1)], 0) == (1/3, 1/3, 1/3)\n", "\nassert calculate_center_of_mass([(1, 0, ... |
34531471e179b84dbd9c1a9884597623 | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est de mettre en œuvre une fonction `word_counter(text)` qui traite le texte pour compter les occurrences de chaque mot unique, sans tenir compte de la casse et en excluant tous les mots vides. La fonction doit renvoyer un dictionnaire où les c... | ["\nassert word_counter(\"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_counter(\"A quick brown fox jumps over the lazy dog\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nas... |
85cb7a43e24351b9b64aa221e9b8e366 | [
{
"content": "On te donne une chaîne de caractères représentant un format CSV (Comma-Separated Values). La première ligne de la chaîne contient les en-têtes de colonnes, et chaque ligne suivante représente une ligne de données. Ta tâche est d'écrire une fonction Python qui analyse cette chaîne et renvoie une li... | ["\nassert csv_to_dict_list(\"name,age\\nAlice,30\\nBob,25\") == [{'name': 'Alice', 'age': '30'}, {'name': 'Bob', 'age': '25'}]\n", "\nassert csv_to_dict_list(\"id,name\\n1,Alice\\n2,Bob\\n3,Charlie\") == [{'id': '1', 'name': 'Alice'}, {'id': '2', 'name': 'Bob'}, {'id': '3', 'name': 'Charlie'}]\n", "\nassert csv_to_dic... |
0e19f6336e716af2c15bf8f043891659 | [
{
"content": "On te demande d'implémenter une classe `Car` en Python pour simuler les attributs et les comportements d'une voiture. La classe doit avoir les spécifications suivantes :\n\n- **Attributs :**\n - `make` : une chaîne de caractères représentant le fabricant de la voiture.\n - `model` : une chaîne d... | ["\nassert Car(\"Toyota\", \"Corolla\", 2020, 15000).display_info() == \"Make: Toyota, Model: Corolla, Year: 2020, Mileage: 15000\"\n", "\nassert Car(\"Honda\", \"Civic\", 2018, 20000).display_info() == \"Make: Honda, Model: Civic, Year: 2018, Mileage: 20000\"\n", "\nassert Car(\"Ford\", \"Mustang\", 2021, 0).display_i... |
6c439b90c170ce38cae7a12f32c2b06d | [
{
"content": "On te demande d'implémenter une classe Python `Fibonacci` qui génère efficacement les nombres de Fibonacci. La classe doit prendre en charge les opérations suivantes :\n\n- `__init__` : Initialise la séquence de Fibonacci.\n- `next` : Renvoie le nombre de Fibonacci suivant dans la séquence.\n- `re... | ["\nassert Fibonacci().next() == 0\n", "\nassert Fibonacci().next() == 0\n", "\nassert Fibonacci().get_nth_fibonacci(0) == 0\n", "\nassert Fibonacci().get_nth_fibonacci(1) == 1\n", "\nassert Fibonacci().get_nth_fibonacci(2) == 1\n", "\nassert Fibonacci().get_nth_fibonacci(5) == 5\n", "\nassert Fibonacci().get_nth_fibon... |
2ac31e2fa44ccf6c77c71b7124f66bb5 | [
{
"content": "On te demande d'implémenter une classe `DatabaseManager` en Python pour gérer une base de données SQLite. La classe doit prendre en charge les opérations suivantes :\n\n1. **Initialisation** : Établir une connexion à une base de données SQLite en utilisant un chemin de base de données donné.\n2. *... | ["\nassert isinstance(DatabaseManager(\"test.db\"), DatabaseManager)\n", "\ndb = DatabaseManager(\"test.db\"); db.create_table(\"test_table\", {\"id\": \"INTEGER PRIMARY KEY\", \"name\": \"TEXT\"}); db.close()\n", "\ndb = DatabaseManager(\"test.db\"); db.create_table(\"test_table\", {\"id\": \"INTEGER PRIMARY KEY\", \"... |
c6677d213dd959f7d76245301741fe88 | [
{
"content": "On te donne une structure arborescente représentant la hiérarchie d'une entreprise. Chaque employé est identifié de manière unique par un identifiant entier, et une liste des identifiants de ses subordonnés directs est fournie. Le PDG est la racine de cet arbre et n'a pas de supérieur. On te donne... | ["\nassert count_employees(1, {1: [2, 3], 2: [4, 5], 3: [6], 4: [], 5: [7, 8], 6: [], 7: [], 8: []}) == 8\n", "\nassert count_employees(1, {1: []}) == 1\n", "\nassert count_employees(1, {1: [2], 2: [3], 3: [4], 4: [5], 5: []}) == 5\n", "\nassert count_employees(1, {1: [2, 3, 4, 5], 2: [], 3: [], 4: [], 5: []}) == 5\n",... |
cc257fc0340531811840d7bb29c055d2 | [
{
"content": "Tu es chargé d'implémenter une fonction `generate_username` qui construit un nom d'utilisateur à partir d'un nom complet donné. Le nom d'utilisateur doit consister au minimum des deux premières initiales des prénoms (sans le nom de famille) suivies du nom de famille, le tout en minuscules et sépar... | ["\nassert generate_username(\"John-Doe! Smith\") == \"j-s-smith\"\n", "\nassert generate_username(\"Alice B. Toklas\") == \"a-b-toklas\"\n", "\nassert generate_username(\"Bob_the_Builder\") == \"b-t-builder\"\n", "\nassert generate_username(\"Mary-Jane Watson\") == \"m-j-watson\"\n", "\nassert generate_username(\"Dr. ... |
3d9f4d74a8ca0c8e5fe35f2f38a42204 | [
{
"content": "Tu participes à une compétition de machine learning où l'on te fournit deux tenseurs PyTorch, `tensor_a` et `var_b`, tous deux résidant sur un GPU. Le tenseur `tensor_a` a une forme de `(batch_size, input_size)` et `var_b` a une forme de `(batch_size, output_size)`. Ta tâche est d'implémenter une ... | ["\nassert np.allclose(convert_and_multiply(torch.tensor([[1.0, 2.0], [3.0, 4.0]]).cuda(), torch.tensor([[2.0, 3.0], [4.0, 5.0]]).cuda()), np.array([[0.4472136, 0.6708204], [0.6708204, 0.8944272]]))\n", "\nassert np.allclose(convert_and_multiply(torch.tensor([[0.0, 0.0], [0.0, 0.0]]).cuda(), torch.tensor([[1.0, 2.0], [... |
29af6d31f7ba0acd703a07029d0809f0 | [
{
"content": "On te donne un objet JSON représentant le profil d'un utilisateur. Ta tâche est d'écrire une fonction `extract_email(profile)` qui recherche récursivement dans l'objet JSON et renvoie l'adresse e-mail associée à la clé \"email\". L'objet JSON peut contenir des dictionnaires et des listes imbriqués... | ["\nassert extract_email({\"email\": \"test@example.com\"}) == \"test@example.com\"\n", "\nassert extract_email({\"user\": {\"email\": \"user@example.com\"}}) == \"user@example.com\"\n", "\nassert extract_email({\"user\": {\"details\": {\"email\": \"details@example.com\"}}}) == \"details@example.com\"\n", "\nassert ext... |
836a17b6cf07eaa167313d64e9d5336e | [
{
"content": "On te donne une liste de `n` points dans le plan 2D, où chaque point est représenté par une paire d'entiers `(x, y)`. Ces points forment un polygone non auto-intersecté lorsqu'ils sont connectés dans l'ordre dans lequel ils apparaissent dans la liste. Ta tâche est d'écrire une fonction qui calcule... | ["\nassert polygon_area([(0, 0), (4, 0), (4, 3), (0, 3)]) == 11\n", "\nassert polygon_area([(0, 0), (5, 0), (5, 5), (0, 5)]) == 29\n", "\nassert polygon_area([(1, 1), (4, 1), (4, 5)]) == 11\n", "\nassert polygon_area([(0, 0), (1, 0), (1, 1), (0, 1)]) == 3\n", "\nassert polygon_area([(0, 0), (0, 1), (1, 1), (1, 0)]) == ... |
4dea52ac9564df37a351b466e492643f | [
{
"content": "Tu développes une application de remise en forme qui nécessite la génération de plans d'entraînement personnalisés pour le haut du corps. Ta tâche est d'implémenter une fonction `make_upper_workout` qui prend quatre paramètres : `name` (une chaîne de caractères représentant le nom de l'entraînemen... | ["\nassert make_upper_workout(\"Upper Body Strength\", 10, 0, False) == {\"name\": \"Upper Body Strength\", \"day\": 0, \"membership\": False, \"exercises\": {\"Push-ups\": 4, \"Dumbbell Chest Press\": 4, \"Bench Dips\": 4, \"Lateral Raises\": 4, \"Face Pulls\": 4, \"Arm Curls\": 4, \"Tricep Dips\": 4}}\n", "\nassert m... |
283a3bc3bd28701821b12509ccf75b0f | [
{
"content": "On te demande d'implémenter une fonction `format_price` qui formate un prix donné avec un type de devise spécifié en une chaîne de caractères lisible par l'homme avec l'unité monétaire localisée. La fonction doit gérer les séparateurs de milliers spécifiques à la région et jusqu'à deux décimales. ... | ["\nassert format_price(123.45, 'USD') == \"$123.45\"\n", "\nassert format_price(123.45, 'EUR') == \"\u20ac123,45\"\n", "\nassert format_price(1234567.89, 'USD') == \"$1,234,567.89\"\n", "\nassert format_price(1234567.89, 'EUR') == \"\u20ac1.234.567,89\"\n", "\nassert format_price(123.45, 'USD', autoescape=False) == \"... |
9c4fad06a7762e0f9d38c070247511b1 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_max_min` qui détermine les valeurs maximales et minimales dans la liste. La fonction doit renvoyer un tuple contenant les valeurs maximales et minimales dans cet ordre. Si la liste est vide, la fonction doit renvoyer `(... | ["\nassert find_max_min([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == (9, 1)\n", "\nassert find_max_min([10]) == (10, 10)\n", "\nassert find_max_min([]) == (None, None)\n", "\nassert find_max_min([-1, -2, -3, -4]) == (-1, -4)\n", "\nassert find_max_min([0, 0, 0, 0]) == (0, 0)\n", "\nassert find_max_min([100, 200, 300, 400, 500... |
f085aeb62d5dccdb78193d7e723bc406 | [
{
"content": "On te donne un fichier CSV contenant des données numériques avec d'éventuelles valeurs manquantes. Ta tâche est d'écrire une fonction `calculate_stats` qui lit ce fichier, calcule la moyenne et l'écart type pour chaque colonne tout en ignorant les valeurs manquantes, et renvoie les résultats dans ... | ["\nassert calculate_stats(\"test_data_1.csv\") == {'A': {'mean': 2.5, 'std': 1.5811388300841898}, 'B': {'mean': 5.5, 'std': 1.5811388300841898}}\n", "\nassert calculate_stats(\"test_data_2.csv\") == {'X': {'mean': 10.0, 'std': 0.0}, 'Y': {'mean': 20.0, 'std': 0.0}}\n", "\nassert calculate_stats(\"test_data_3.csv\") ==... |
8a1c3ac38a8c9f1ebd45ee3603248b4a | [
{
"content": "On te donne une liste d'entiers en arguments de ligne de commande. Ta tâche est d'écrire un script Python qui lit ces entiers, met chacun d'eux au carré et affiche la liste résultante. Les entiers en entrée sont fournis en tant qu'arguments de ligne de commande, en excluant le nom du script.\n\n**... | ["\nassert square_numbers(['1', '2', '3']) == [1, 4, 9]\n", "\nassert square_numbers(['-1', '-2', '-3']) == [1, 4, 9]\n", "\nassert square_numbers(['0', '0', '0']) == [0, 0, 0]\n", "\nassert square_numbers(['10', '20', '30']) == [100, 400, 900]\n", "\nassert square_numbers(['100', '200', '300']) == [10000, 40000, 90000... |
62a66f6ae23bf015ed3c55072a1933ec | [
{
"content": "On te donne un nombre `N` (qui peut être un flottant) et un entier positif `R` (base). Ta tâche est de trouver le multiple de `R` le plus proche de `N`. La comparaison doit être faite après avoir arrondi `N` à `P` décimales, où `P` est un entier non négatif représentant la précision. Si deux multi... | ["\nassert closest_multiple(18.45, radix=5, precision=1) == 18.5\n", "\nassert closest_multiple(123.7, radix=10, precision=0) == 120\n", "\nassert closest_multiple(123.7, radix=10, precision=1) == 123.7\n", "\nassert closest_multiple(123.5, radix=10, precision=0) == 120\n", "\nassert closest_multiple(123.5, radix=10, p... |
659a8c1f514741f2442f20fb3508fb08 | [
{
"content": "On te donne une liste triée d'entiers `arr` et un entier `target`. Implémente une fonction `binary_search(arr, target)` qui effectue une recherche binaire pour trouver l'index de l'élément `target` dans la liste. Si `target` n'est pas présent dans la liste, la fonction doit retourner `-1`. La fonc... | ["\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(... |
e8759ba3d2bd5dcfa2e24f97bbe88af5 | [
{
"content": "Tu participes à un concours de programmation où tu dois développer une fonction `generate_search_query(ingredients)` pour un moteur de recherche de recettes. La fonction doit prendre une liste d'ingrédients et renvoyer une chaîne de requête de recherche encodée par URL. La requête de recherche doi... | ["\nassert generate_search_query([\"flour\", \"sugar\", \"eggs\"]) == \"flour%2Csugar%2Ceggs\"\n", "\nassert generate_search_query([\"chocolate chips\", \"vanilla extract\"]) == \"chocolate%20chips%2Cvanilla%20extract\"\n", "\nassert generate_search_query([\"&\", \"?\", \"#\"]) == \"%26%2C%3F%2C%23\"\n", "\nassert gene... |
36f01236ea88a5f27a7c736d62872574 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de mettre en œuvre une fonction qui trouve la plus longue sous-chaîne palindromique dans `s`. Un palindrome est une chaîne qui se lit de la même manière à l'endroit et à l'envers. S'il existe plusieurs sous-chaînes palindromiques de longueur m... | ["\nassert longest_palindrome(\"abacdfgdcaba\") == \"abacdfgdcaba\"\n", "\nassert longest_palindrome(\"racecar\") == \"racecar\"\n", "\nassert longest_palindrome(\"banana\") == \"anana\"\n", "\nassert longest_palindrome(\"civic\") == \"civic\"\n", "\nassert longest_palindrome(\"noon\") == \"noon\"\n", "\nassert longest... |
33e94426f5d6434b60f3cad8d8703e14 | [
{
"content": "On te demande de simuler un système dynamique en utilisant diverses méthodes d'intégration numérique. Le système est représenté par une fonction `model` qui décrit son comportement. L'état initial du système est donné par `t0` (temps initial) et `k0` (vecteur d'état initial). Ton objectif est de c... | ["\nassert compute_solution_trajectories(lambda t, y: -y, 0, [1])['dopri5'].shape == (1, 143)\n", "\nassert compute_solution_trajectories(lambda t, y: -y, 0, [1])['dop853'].shape == (1, 143)\n", "\nassert compute_solution_trajectories(lambda t, y: -y, 0, [1])['vode'].shape == (1, 143)\n", "\nassert compute_solution_tra... |
f07f859309bb813f97d2eb6865f4ae1a | [
{
"content": "On te donne un arbre de recherche binaire (BST) et ta tâche est de le sérialiser en une chaîne de caractères, puis de désérialiser cette chaîne pour reconstruire le BST. La sérialisation doit suivre un format de parcours préfixé. La représentation sous forme de chaîne doit être au format \"value1,... | ["\nassert serialize_and_deserialize(None) == (\"\", None)\n", "\nassert serialize_and_deserialize(TreeNode(1)) == (\"1\", TreeNode(1))\n", "\nassert serialize_and_deserialize(TreeNode(5, TreeNode(3), TreeNode(7))) == (\"5,3,7\", TreeNode(5, TreeNode(3), TreeNode(7)))\n", "\nassert serialize_and_deserialize(TreeNode(10... |
c39f731700890c03f913724e0d27e919 | [
{
"content": "On te donne une liste d'entiers `nums` et une liste d'entiers précalculée `fact` où `fact[i]` représente la factorielle de `i`. Ta tâche est d'implémenter une fonction `digit_fact_sum(nums, fact)` qui calcule la somme de la factorielle de chaque chiffre dans les nombres de `nums`, chacun étant éle... | ["\nassert digit_fact_sum([123], [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]) == 1 + 4 + 216\n", "\nassert digit_fact_sum([456], [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]) == 24 + 1296 + 46656\n", "\nassert digit_fact_sum([0], [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]) == 1\n", "\nasse... |
9d56b7f667d3dfd4859dc7eff3a3f0dc | [
{
"content": "On te demande d'implémenter une fonction `escape_special_characters` qui traite une chaîne de caractères donnée `input_string`. La fonction doit remplacer chaque occurrence des caractères spéciaux suivants : `{`, `}`, `[`, `]`, `(`, `)`, `.`, `*`, `+`, `?`, `^`, `$`, `|`, `\\`, `/` par leurs versi... | ["\nassert escape_special_characters(\"hello world\") == \"hello world\"\n", "\nassert escape_special_characters(\"{hello} world\") == \"\\\\{hello\\\\} world\"\n", "\nassert escape_special_characters(\"[hello] world\") == \"\\\\[hello\\\\] world\"\n", "\nassert escape_special_characters(\"(hello) world\") == \"\\\\(he... |
ed29fd681c65171698b3f696f7cb7509 | [
{
"content": "Implémente une classe `LRUCache` qui supporte les opérations suivantes : `get` et `put`. La classe `LRUCache` doit être initialisée avec un entier positif `capacity` qui représente le nombre maximal de paires clé-valeur qu'elle peut contenir. Lorsque le cache atteint sa capacité, elle doit invalid... | ["\nassert LRUCache(0).get(0) == -1\n", "\nassert LRUCache(1).get(1) == -1\n", "\nlru_cache = LRUCache(2); lru_cache.put(1, 1); assert lru_cache.get(1) == 1\n", "\nlru_cache = LRUCache(2); lru_cache.put(1, 1); lru_cache.put(2, 2); lru_cache.put(3, 3); assert lru_cache.get(1) == -1\n", "\nlru_cache = LRUCache(2); lru_ca... |
df1a999aa72f30fd23ea9d0f83f1a2b9 | [
{
"content": "On te demande d'implémenter une fonction récursive `rec_product_n(numb)` qui calcule la factorielle d'un entier donné `numb`. La fonction doit renvoyer un tuple constitué de la valeur de la factorielle et du nombre total d'appels récursifs effectués pendant le calcul. Ton implémentation doit gérer... | ["\nassert rec_product_n(0) == (1, 1)\n", "\nassert rec_product_n(1) == (1, 1)\n", "\nassert rec_product_n(2) == (2, 2)\n", "\nassert rec_product_n(3) == (6, 3)\n", "\nassert rec_product_n(4) == (24, 4)\n", "\nassert rec_product_n(5) == (120, 5)\n", "\nassert rec_product_n(6) == (720, 6)\n", "\nassert rec_product_n(7) ... |
8a0c8e8f08b2c5bdb934f761e44c893f | [
{
"content": "Dans un concours de photographie, tu dois développer une fonction nommée `lens_specs` qui traite les spécifications des objectifs d'appareil photo. La fonction accepte deux paramètres : `aperture` et `focal_length`. L' `aperture` peut être fournie soit sous forme de chaîne au format 'f/X', soit so... | ["\nassert lens_specs('f/1.4', 35) == 'f/1.4 @ 35mm'\n", "\nassert lens_specs('f/2.0', 50) == 'f/2.0 @ 50mm'\n", "\nassert lens_specs(2.8, 85) == 'f/2.8 @ 85mm'\n", "\nassert lens_specs(1.8, 50) == 'f/1.8 @ 50mm'\n", "\nassert lens_specs('f/5.6', 135) == 'f/5.6 @ 135mm'\n", "\nassert lens_specs(16.0, 300) == 'f/16.0 @ ... |
7f697787194ad9413b6d1357fb7c9e13 | [
{
"content": "On te donne deux images en niveaux de gris, `image_a` et `image_b`, représentées comme des tableaux numpy 2D de forme `(rows, cols)`. Ta tâche est de mettre en œuvre une fonction `compute_SSIM` qui calcule l'indice de similarité structurelle (SSIM) entre les deux images. Le SSIM doit être calculé ... | ["\nassert compute_SSIM(np.array([[1]]), np.array([[1]])) == 1.0\n", "\nassert compute_SSIM(np.array([[0, 0], [0, 0]]), np.array([[0, 0], [0, 0]])) == 1.0\n", "\nassert compute_SSIM(np.array([[255, 255], [255, 255]]), np.array([[255, 255], [255, 255]])) == 1.0\n", "\nassert compute_SSIM(np.array([[0, 255], [255, 0]]), ... |
1e4572d712e580a23063cfce00337da7 | [
{
"content": "On te demande d'implémenter une hiérarchie de classes pour gérer des livres et des livres électroniques. Implémente une classe `Book` avec les attributs suivants :\n- `title` : une chaîne de caractères représentant le titre du livre.\n- `author` : une chaîne de caractères représentant l'auteur du ... | ["\nassert Book(\"1984\", \"George Orwell\", 1949).get_book_info() == \"Title: 1984, Author: George Orwell, Year Published: 1949\"\n", "\nassert EBook(\"To Kill a Mockingbird\", \"Harper Lee\", 1960, \"PDF\").get_ebook_info() == \"Title: To Kill a Mockingbird, Author: Harper Lee, Year Published: 1960, File Format: PDF\... |
4e32c44e6b856053fe10d756f5cf98d6 | [
{
"content": "On te donne la tâche de développer un programme qui traite un fichier de configuration formaté en JSON. Le fichier contient des structures imbriquées détaillant les configurations de base de données telles que le type, l'hôte, le port, le nom d'utilisateur et le mot de passe. Ton programme doit an... | ["\nassert read_config_file(\"non_existent_file.json\") == \"Error: The configuration file does not exist.\"\n", "\nassert read_config_file(\"invalid_json_file.json\") == \"Error: The configuration file is not in the correct JSON format.\"\n", "\nassert read_config_file(\"simple_config.json\") == {\"db_type\": \"sqlite... |
3117249f28b04b9b34270ec873eb911e | [
{
"content": "On te demande d'implémenter une fonction `generate_html_table(data)` qui construit un tableau HTML à partir d'une liste de dictionnaires donnée. Chaque dictionnaire de la liste représente une ligne du tableau, avec les clés comme en-têtes de colonnes et les valeurs comme données de la cellule corr... | ["\nassert generate_html_table([]) == \"<table></table>\"\n", "\nassert generate_html_table([{'Name': 'John', 'Age': 30}]) == \"<table><tr><th>Name</th><th>Age</th></tr><tr><td>John</td><td>30</td></tr></table>\"\n", "\nassert generate_html_table([{'Name': 'John', 'Age': 30}, {'Name': 'Anna', 'Age': 22}]) == \"<table><... |
0e33a2bb32509ce096139a1fb3879499 | [
{
"content": "On te donne une grille 2D de taille N x M, où chaque cellule est soit vide ('0') soit bloquée ('1'). On te donne également les coordonnées de départ (x1, y1) et les coordonnées d'arrivée (x2, y2) de deux cellules. Ta tâche est de déterminer s'il existe un chemin de la cellule de départ à la cellul... | ["\nassert has_path([['0', '0', '0'], ['0', '0', '0'], ['0', '0', '0']], (1, 1), (3, 3)) == True\n", "\nassert has_path([['0', '0', '0'], ['0', '1', '0'], ['0', '0', '0']], (1, 1), (3, 3)) == False\n", "\nassert has_path([['0', '0', '0', '0'], ['0', '0', '0', '0'], ['0', '0', '0', '0'], ['0', '0', '0', '0']], (1, 1), (... |
b7dd12e3e238ef90ce0074e971ce8786 | [
{
"content": "On te donne deux dictionnaires, `dict_a` et `dict_b`, représentant la présence et un attribut supplémentaire d'appareils à deux endroits différents à différents moments. Chaque clé dans les dictionnaires est un identifiant composite au format `UID-TIMESTAMP`, où `UID` est un identifiant d'appareil... | ["\nassert calculate_similarity({\"1-1\": (1, 5), \"2-1\": (0, 3)}, {\"1-1\": (1, 5), \"2-1\": (0, 3)}) == 1.0\n", "\nassert calculate_similarity({\"1-1\": (1, 5), \"2-1\": (0, 3)}, {\"1-1\": (0, 5), \"2-1\": (0, 3)}) == 0.5\n", "\nassert calculate_similarity({\"1-1\": (1, 5), \"2-1\": (0, 3)}, {\"1-1\": (1, 5), \"2-1\... |
4e9104c9c208348be419a2146ea59a13 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_max_min_difference` qui calcule la différence entre les valeurs maximale et minimale dans la liste. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Entrée :**\n- Une liste d'entiers, `numbers`.\n\n**Sortie ... | ["\nassert find_max_min_difference([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]) == 8\n", "\nassert find_max_min_difference([10, 10, 10, 10]) == 0\n", "\nassert find_max_min_difference([-5, -10, -3, -8]) == 5\n", "\nassert find_max_min_difference([100]) == 0\n", "\nassert find_max_min_difference([]) == None\n", "\nassert find_max... |
57044d62adfaf136584214a17e37ef07 | [
{
"content": "On te demande de refactoriser un script Python qui calcule la factorielle d'un entier non négatif à l'aide d'une boucle. Ton code refactorisé doit respecter les bonnes pratiques, notamment des noms de variables significatifs, des commentaires clairs et des docstrings complètes. La fonction doit le... | ["\nassert calculate_factorial(0) == 1\n", "\nassert calculate_factorial(1) == 1\n", "\nassert calculate_factorial(5) == 120\n", "\nassert calculate_factorial(7) == 5040\n", "\nassert calculate_factorial(10) == 3628800\n", "\nassert calculate_factorial(12) == 479001600\n", "\nassert calculate_factorial(15) == 130767436... |
727b00ba3c0024a5071993c768de6de9 | [
{
"content": "On te donne un dictionnaire où les clés sont des chaînes de caractères et les valeurs sont des entiers. Ta tâche est d'écrire une fonction qui trie ce dictionnaire par ses valeurs par ordre croissant et renvoie une liste de tuples contenant les paires clé-valeur dans l'ordre trié. La fonction doit... | ["\nassert sort_dict_by_values({\"apple\": 3, \"banana\": 1, \"cherry\": 2}) == [(\"banana\", 1), (\"cherry\", 2), (\"apple\", 3)]\n", "\nassert sort_dict_by_values({\"a\": 10, \"b\": 5, \"c\": 15}) == [(\"b\", 5), (\"a\", 10), (\"c\", 15)]\n", "\nassert sort_dict_by_values({\"x\": 1, \"y\": 1, \"z\": 1}) == [(\"x\", 1... |
2eb495bd196ccdc1b32118882b3a02d5 | [
{
"content": "On te demande d'implémenter une fonction `unpack_varargs` qui traite une entrée donnée `args`. L'entrée peut être soit une liste, soit un tuple. Si `args` est une liste, la fonction doit la convertir en tuple, en s'assurant que toutes les listes imbriquées dans `args` sont également converties en ... | ["\nassert unpack_varargs([1, 2, 3]) == (1, 2, 3)\n", "\nassert unpack_varargs((1, 2, 3)) == (1, 2, 3)\n", "\nassert unpack_varargs([1, (2, 3), [4, 5]]) == (1, (2, 3), (4, 5))\n", "\nassert unpack_varargs((1, [2, 3], (4, 5))) == (1, (2, 3), (4, 5))\n", "\nassert unpack_varargs([[1, 2], [3, [4, 5]]]) == ((1, 2), (3, (4,... |
f7581849766ea19bf75c832dec319cb6 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction récursive qui calcule la somme de tous les éléments de la liste. La fonction ne doit pas utiliser de boucles ou de fonctions de somme intégrées. Le cas de base doit gérer une liste vide, en renvoyant 0.\n\n**Exemple d'entrée :**\n... | ["\nassert sum_of_list([1, 2, 3, 4, 5]) == 15\n", "\nassert sum_of_list([10, 20, 30]) == 60\n", "\nassert sum_of_list([-1, -2, -3, -4]) == -10\n", "\nassert sum_of_list([0, 0, 0, 0]) == 0\n", "\nassert sum_of_list([]) == 0\n", "\nassert sum_of_list([100]) == 100\n", "\nassert sum_of_list([1, -1, 1, -1]) == 0\n", "\nass... |
4e8bdc17e9bbe2faed26736f93873b38 | [
{
"content": "On te donne un nombre à virgule flottante positif `n` et un entier positif `significant_figures`. Ta tâche est d'implémenter une fonction `round_to_significant_figures(n, significant_figures)` qui arrondit le nombre `n` au nombre de chiffres significatifs spécifié. La fonction doit gérer efficacem... | ["\nassert round_to_significant_figures(12345.6789, 3) == 12300.0\n", "\nassert round_to_significant_figures(0.0012345, 2) == 0.0012\n", "\nassert round_to_significant_figures(98765.4321, 4) == 98770.0\n", "\nassert round_to_significant_figures(0.000098765, 3) == 0.0000988\n", "\nassert round_to_significant_figures(1.2... |
7e839f533fe859deeef6de8aaff0b9e0 | [
{
"content": "On te donne la racine d'un arbre de recherche binaire (BST). Ta tâche est d'implémenter une fonction qui renvoie une liste de tous les éléments du BST dans l'ordre croissant en utilisant un parcours en ordre infixe.\n\n**Entrée :**\n- L'entrée est le nœud racine de l'arbre de recherche binaire. Ch... | ["\nassert in_order_traversal(None) == []\n", "\nassert in_order_traversal(TreeNode(1)) == [1]\n", "\nassert in_order_traversal(TreeNode(2, TreeNode(1))) == [1, 2]\n", "\nassert in_order_traversal(TreeNode(2, None, TreeNode(3))) == [2, 3]\n", "\nassert in_order_traversal(TreeNode(3, TreeNode(2, TreeNode(1)))) == [1, 2,... |
1de7b119d9c15ab50f33e3ac5830c6dc | [
{
"content": "On te demande d'implémenter une classe `Polynomial` en Python qui représente un polynôme de la forme `a_n*x^n + a_(n-1)*x^(n-1) + ... + a_1*x + a_0`. La classe doit avoir les fonctionnalités suivantes :\n\n- **Initialisation** : Le constructeur `__init__` doit accepter une liste de coefficients `c... | ["\nassert Polynomial([1, 2, 3]).evaluate(1) == 6\n", "\nassert Polynomial([1, 2, 3]).evaluate(0) == 1\n", "\nassert Polynomial([1, 2, 3]).add(Polynomial([4, 5, 6])).coefficients == [5, 7, 9]\n", "\nassert Polynomial([1, 2, 3]).add(Polynomial([0, 0, 0])).coefficients == [1, 2, 3]\n", "\nassert Polynomial([1, 2, 3]).add... |
010697ee9a0b36f5c55c74f4b6745969 | [
{
"content": "On te donne une liste d'étudiants, chacun représenté par un tuple contenant son nom et son score au test. Ta tâche est de trier ces étudiants en fonction de la valeur de hachage de leur score au test concaténé à leur nom, par ordre décroissant. Retourne un tuple de deux listes : la première liste ... | ["\nassert sort_students_by_hash([('Alice', 88), ('Bob', 95), ('Charlie', 78), ('David', 88)]) == ([95, 88, 88, 78], ['Bob', 'Alice', 'David', 'Charlie'])\n", "\nassert sort_students_by_hash([('Eve', 100), ('Frank', 100), ('Grace', 99)]) == ([100, 100, 99], ['Eve', 'Frank', 'Grace'])\n", "\nassert sort_students_by_hash... |
75f66e8d4c14fd4c2ef175bc49584123 | [
{
"content": "On te donne une séquence d'entiers. Ta tâche est de déterminer la longueur de la plus longue sous-séquence qui forme un palindrome. Une sous-séquence est une séquence dérivée d'une autre séquence en supprimant certains éléments ou aucun, sans modifier l'ordre des éléments restants.\n\n**Entrée :**... | ["\nassert longest_palindromic_subsequence([1, 3, 5, 3, 1, 2, 1]) == 5\n", "\nassert longest_palindromic_subsequence([1, 2, 3, 4, 5]) == 1\n", "\nassert longest_palindromic_subsequence([1, 2, 3, 2, 1]) == 5\n", "\nassert longest_palindromic_subsequence([1, 2, 2, 1, 3, 3, 3]) == 4\n", "\nassert longest_palindromic_subse... |
fd01c254473141bb71962225cfdb5733 | [
{
"content": "On te donne un arbre de recherche binaire (BST) représenté par son nœud racine. Ta tâche est de mettre en œuvre une fonction qui effectue un parcours en largeur (BFS) de l'arbre et renvoie une liste des valeurs des nœuds dans l'ordre dans lequel ils sont visités.\n\n**Entrée :**\n- Le nœud racine ... | ["\nassert bfs(TreeNode(1)) == [1]\n", "\nassert bfs(TreeNode(1, TreeNode(2), TreeNode(3))) == [1, 2, 3]\n", "\nassert bfs(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert bfs(TreeNode(1, None, TreeNode(2, None, TreeNode(3)))) == [1, 2, 3]... |
acab9cf38671085762e86a5bc99ca134 | [
{
"content": "On te donne une liste de points 2D représentant les sommets d'un polygone simple. Ta tâche est de déterminer si le polygone est concave. Un polygone est considéré comme concave si au moins l'un de ses angles intérieurs dépasse 180 degrés. La liste d'entrée peut contenir des points dupliqués conséc... | ["\nassert is_polygon_concave([(0, 0), (1, 0), (1, 1), (0, 1)]) == False\n", "\nassert is_polygon_concave([(0, 0), (1, 0), (2, 1), (1, 2), (0, 1)]) == True\n", "\nassert is_polygon_concave([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]) == False\n", "\nassert is_polygon_concave([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0), (0, 0)... |
83e0ca8f796d25a011019354caaec88e | [
{
"content": "On te donne deux chaînes de caractères, `str1` et `str2`. Ta tâche est de mettre en œuvre une fonction `longest_common_substring` qui trouve la plus longue sous-chaîne commune entre les deux chaînes. Une sous-chaîne valide doit contenir au moins une voyelle et une consonne. Si aucune sous-chaîne d... | ["\nassert longest_common_substring(\"abcdefg\", \"abcdxyz\") == \"bcd\"\n", "\nassert longest_common_substring(\"hello\", \"world\") == \"o\"\n", "\nassert longest_common_substring(\"abc\", \"def\") == \"\"\n", "\nassert longest_common_substring(\"a\", \"a\") == \"\"\n", "\nassert longest_common_substring(\"aeiou\", \... |
ab6d12d2f4c7f1f6ef5fbb67e4a6b0af | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si la chaîne est un palindrome, en considérant uniquement les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entré... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"hello\") == False\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindr... |
d349504c7ad65601a831f7a47c65abdf | [
{
"content": "On te donne une liste de `n` entiers, où chaque entier représente la hauteur d'un bâtiment. Ta tâche est de déterminer l'aire maximale d'un rectangle qui peut être formé par les bâtiments lorsqu'ils sont vus de côté. La largeur du rectangle est la distance entre deux bâtiments, et la hauteur est l... | ["\nassert largest_rectangle_area([2, 1, 5, 6, 2, 3]) == 10\n", "\nassert largest_rectangle_area([1, 2, 3, 4, 5]) == 9\n", "\nassert largest_rectangle_area([5, 4, 3, 2, 1]) == 9\n", "\nassert largest_rectangle_area([1, 1, 1, 1, 1]) == 5\n", "\nassert largest_rectangle_area([2, 2, 2, 2, 2]) == 10\n", "\nassert largest_r... |
70c2d327533432c0d0f3fc37281bd249 | [
{
"content": "On te donne la tâche d'écrire une fonction `get_binary_type(path)` qui détermine le type d'un fichier binaire situé au `path` spécifié. La fonction doit être capable d'identifier deux types de fichiers binaires : ELF et PE. Si le fichier n'est ni un binaire ELF valide, ni un binaire PE valide, la ... | ["\nassert get_binary_type('example_elf_file') == 'ELF'\n", "\nassert get_binary_type('example_pe_file') == 'PE'\n", "\nassert get_binary_type('example_non_binary_file') == None\n", "\nassert get_binary_type('non_existent_file') == None\n", "\nassert get_binary_type('empty_file') == None\n", "\nassert get_binary_type('... |
228d29595363d045332d76706d74a016 | [
{
"content": "On te donne deux listes de nombres, `list1` et `list2`, chacune contenant `n` rendements quotidiens de deux actions différentes sur une période donnée. Ta tâche est de mettre en œuvre la fonction `compute_correlation(list1, list2)` qui calcule le coefficient de corrélation de Pearson entre ces deu... | ["\nassert compute_correlation([1, 2, 3], [1, 2, 3]) == 1.0\n", "\nassert compute_correlation([1, 2, 3], [3, 2, 1]) == -1.0\n", "\nassert compute_correlation([1, 1, 1], [1, 1, 1]) == 0.0\n", "\nassert compute_correlation([1, 2, 3, 4], [2, 4, 6, 8]) == 1.0\n", "\nassert compute_correlation([1, 2, 3, 4], [4, 3, 2, 1]) ==... |
6b5f8374f0c66b9f78f4b89c3a6edc69 | [
{
"content": "On te donne une liste triée d'entiers `arr` et un entier `target`. Implémente une fonction `binary_search` qui renvoie l'index de `target` dans `arr` s'il existe, sinon renvoie `-1`. Ta solution doit utiliser l'algorithme de recherche binaire, en assurant une complexité temporelle de O(log n).\n\n... | ["\nassert binary_search([1, 3, 5, 7, 9], 5) == 2\n", "\nassert binary_search([1, 3, 5, 7, 9], 1) == 0\n", "\nassert binary_search([1, 3, 5, 7, 9], 9) == 4\n", "\nassert binary_search([1, 3, 5, 7, 9], 0) == -1\n", "\nassert binary_search([1, 3, 5, 7, 9], 10) == -1\n", "\nassert binary_search([], 5) == -1\n", "\nassert ... |
bd6179a5ef1ed9b155ea0472fa48f048 | [
{
"content": "On te demande d'implémenter une classe `Student` pour gérer les données des élèves dans un système scolaire. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : un élève est initialisé avec un nom (chaîne de caractères), un âge (entier) et une liste optionnel... | ["\nassert Student(\"Alice\", 20).get_average_grade() == 0\n", "\nassert Student(\"Bob\", 22, [85, 90, 78]).get_average_grade() == 84.33333333333333\n", "\nassert Student(\"Charlie\", 21, [95, 85]).add_grade(80) is None\n", "\nassert Student(\"David\", 23, [90, 80, 70]).remove_grade(80) is None\n", "\nassert str(Studen... |
53c364ba6b22d3a5e31cebbff0dd71d8 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `n`. Ta tâche est de calculer la somme de tous les multiples uniques des entiers dans `numbers` qui sont strictement inférieurs à `n`.\n\n**Entrée :**\n- Une liste d'entiers `numbers` (1 ≤ len(numbers) ≤ 100, 1 ≤ numbers[i] ≤ 100)\n- Un entier... | ["\nassert sum_of_multiples([2, 3], 10) == 39\n", "\nassert sum_of_multiples([1, 2, 3], 10) == 44\n", "\nassert sum_of_multiples([5, 10], 50) == 275\n", "\nassert sum_of_multiples([7], 20) == 28\n", "\nassert sum_of_multiples([0], 10) == 0\n", "\nassert sum_of_multiples([], 10) == 0\n", "\nassert sum_of_multiples([11, ... |
7a6c68b2b74a184d44095e1ab47ecd24 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Chaque mot est composé de caractères alphanumériques. Ta tâche est de trouver le mot le plus fréquent dans le texte. S'il y a plusieurs mots ayant la même fréquence la plus élevée, renvoie celui qui apparaît en p... | ["\nassert most_common_word(\"hello world hello\") == \"hello\"\n", "\nassert most_common_word(\"one two three two three three\") == \"three\"\n", "\nassert most_common_word(\"apple banana apple orange banana apple\") == \"apple\"\n", "\nassert most_common_word(\"a b c d e f g h i j k l m n o p q r s t u v w x y z\") =... |
82074eb60dcc118e4651e5e199fb1c58 | [
{
"content": "On te donne une liste contenant exactement trois entiers. Ta tâche est de trier ces entiers par ordre croissant sans utiliser de fonctions de tri intégrées. Après le tri, calcule la somme du nombre du milieu et la valeur absolue de la différence entre le plus grand et le plus petit des nombres.\n\... | ["\nassert sort_and_sum([3, 1, 2]) == 5\n", "\nassert sort_and_sum([10, 20, 30]) == 40\n", "\nassert sort_and_sum([5, 5, 5]) == 5\n", "\nassert sort_and_sum([7, 3, 5]) == 9\n", "\nassert sort_and_sum([1, 2, 3]) == 4\n", "\nassert sort_and_sum([9, 8, 7]) == 16\n", "\nassert sort_and_sum([0, -1, 1]) == 2\n", "\nassert so... |
e85dbc92ce4418af3edf7e6f440146e3 | [
{
"content": "Tu participes à un défi de vision par ordinateur où tu dois traiter les coordonnées des boîtes englobantes. Étant donné un tenseur `boxes` de forme `(B, N, 4)` représentant `B` lots de `N` boîtes englobantes au format centre-taille, où chaque boîte est représentée par `(cx, cy, w, h)`, ta tâche es... | ["\nassert torch.equal(convert_boxes(torch.tensor([[[1.0, 1.0, 2.0, 2.0]]])), torch.tensor([[[0.0, 0.0, 2.0, 2.0]]]))\n", "\nassert torch.equal(convert_boxes(torch.tensor([[[0.0, 0.0, 1.0, 1.0]]])), torch.tensor([[[ -0.5, -0.5, 0.5, 0.5]]]))\n", "\nassert torch.equal(convert_boxes(torch.tensor([[[2.0, 3.0, 4.0, 5.0]]... |
5e8dcfc6052b70cd3f91b19ae8264a15 | [
{
"content": "On te donne une structure de liste imbriquée composée de listes qui peuvent contenir d'autres listes, ainsi qu'un élément. Ta tâche est de modifier la liste imbriquée originale sur place en ajoutant l'élément donné à la fin de chaque sous-liste. La fonction doit gérer les références circulaires da... | ["\nassert append_to_all(0, [[]]) == None and nested_list == [[0]]\n", "\nassert append_to_all(5, [[1, 2], [3, 4]]) == None and nested_list == [[1, 2, 5], [3, 4, 5]]\n", "\nassert append_to_all('a', [[], ['b'], ['c', 'd']]) == None and nested_list == [['a'], ['b', 'a'], ['c', 'd', 'a']]\n", "\nassert append_to_all(10, ... |
ff8aa32a209616ff22404aa10df4a9a3 | [
{
"content": "On te donne un ensemble de données contenant des n-grammes pour plusieurs langues. Chaque langue possède un dictionnaire de n-grammes avec leurs nombres d'occurrences respectifs. Ta tâche est de filtrer tous les n-grammes qui apparaissent moins de 5 fois dans chaque langue. Implémente une fonction... | ["\nassert filter_rare_ngrams({\"English\": {\"hello world\": 10, \"foo bar\": 1, \"python code\": 6, \"exception error\": 4}}) == {\"English\": {\"hello world\": 10, \"python code\": 6}}\n", "\nassert filter_rare_ngrams({\"Spanish\": {\"hola mundo\": 10, \"chau hasta\": 8, \"codigo python\": 2, \"error excepciones\": ... |
0eba4d66077b0ce012ad855ec3ce160a | [
{
"content": "On te donne un arbre binaire avec `n` nœuds, chaque nœud ayant une valeur entière unique. L'arbre est représenté par une classe `TreeNode`, où chaque nœud a une valeur, un enfant gauche et un enfant droit. Ta tâche est de mettre en œuvre une fonction `find_common_ancestor(root, node1, node2)` qui ... | ["\nassert find_common_ancestor(TreeNode(3, TreeNode(5, TreeNode(6), TreeNode(2, TreeNode(7), TreeNode(4))), TreeNode(1, TreeNode(0), TreeNode(8))), TreeNode(5), TreeNode(1)) == TreeNode(3)\n", "\nassert find_common_ancestor(TreeNode(3, TreeNode(5, TreeNode(6), TreeNode(2, TreeNode(7), TreeNode(4))), TreeNode(1, TreeNo... |
6f2a8de26c5243076dc8665b2464cbdf | [
{
"content": "On te donne une liste de `n` positions dans un plan 2D, où chaque position est représentée par un tuple de deux entiers `(x, y)`. Ta tâche est d'implémenter une fonction `calculate_center` qui calcule le centre géométrique de ces positions. Le centre est défini comme le point `(center_x, center_y)... | ["\nassert calculate_center([(1, 2), (3, 4), (5, 6)]) == (3.0, 4.0)\n", "\nassert calculate_center([(0, 0), (0, 0), (0, 0)]) == (0.0, 0.0)\n", "\nassert calculate_center([(10, 10), (20, 20), (30, 30)]) == (20.0, 20.0)\n", "\nassert calculate_center([(-1, -1), (-2, -2), (-3, -3)]) == (-2.0, -2.0)\n", "\nassert calculate... |
1e96ee20135d6734c4ecb597f8966be4 | [
{
"content": "On te charge d'optimiser le placement des casernes de pompiers dans une grille urbaine afin de minimiser le temps de réponse moyen aux incendies. La ville est représentée comme une grille 2D, chaque cellule représentant un bâtiment. On te fournit les coordonnées des bâtiments et les emplacements p... | ["\nassert np.array_equal(calculate_distances(np.array([[0, 0]]), np.array([[0, 0]])), np.array([[0.0]]))\n", "\nassert np.array_equal(calculate_distances(np.array([[1, 1]]), np.array([[0, 0]])), np.array([[np.sqrt(2)]]))\n", "\nassert np.array_equal(calculate_distances(np.array([[1, 1], [2, 2]]), np.array([[0, 0]])), ... |
ed73da8c601682d0ffd20aa7930cd7a6 | [
{
"content": "On te donne une chaîne de caractères `text` contenant divers mots et URL. Ta tâche est d'écrire une fonction Python qui extrait toutes les URL de la chaîne en utilisant des expressions régulières. Une URL est définie comme une séquence de caractères commençant par `http://` ou `https://` et se ter... | ["\nassert extract_urls(\"Check out https://www.google.com for more info.\") == [\"https://www.google.com\"]\n", "\nassert extract_urls(\"Visit http://example.org or https://example.com.\") == [\"http://example.org\", \"https://example.com\"]\n", "\nassert extract_urls(\"No URLs here!\") == []\n", "\nassert extract_url... |
e85daed6a7007f9ee3d713963cdd5fbe | [
{
"content": "On te donne un tableau trié d'entiers, `arr`, et un entier cible, `target`. Ta tâche est de déterminer l'indice du plus grand élément dans `arr` tel que l'application de la fonction `key(x)` à cet élément donne une valeur inférieure ou égale à `target`. Si un tel élément n'existe pas, renvoie `Non... | ["\nassert find_index([1, 2, 4, 6, 8], 5, lambda x: x) == 2\n", "\nassert find_index([1, 2, 4, 6, 8], 8, lambda x: x) == 4\n", "\nassert find_index([1, 2, 4, 6, 8], 0, lambda x: x) == None\n", "\nassert find_index([1, 3, 5, 7, 9], 10, lambda x: x) == 4\n", "\nassert find_index([1, 3, 5, 7, 9], 1, lambda x: x) == 0\n", ... |
37c1b2c351867c3d8cfda6ceeec25de6 | [
{
"content": "On te donne un fichier contenant des données d'annotation génomique. Chaque ligne du fichier représente une interaction génomique, et la 14e colonne de chaque ligne contient une liste d'identifiants de TAD (Domaines d'Association Topologique) séparés par des points-virgules. Les identifiants de TA... | ["\nassert get_unique_tad_identifiers(\"test_data_1.txt\") == {\"tad1\", \"tad2\", \"tad3\"}\n", "\nassert get_unique_tad_identifiers(\"test_data_2.txt\") == {\"tad1\", \"tad2\", \"tad3\", \"tad4\"}\n", "\nassert get_unique_tad_identifiers(\"test_data_3.txt\") == {\"tad1\", \"tad2\", \"tad3\", \"tad4\", \"tad5\"}\n", "... |
daae4bb6098c05dc8a44a582583cf9f5 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui renvoie le nombre de mots dans la chaîne. Un mot est défini comme une séquence de caractères séparés par des espaces. Par exemple, la chaîne \"Hello world\" contient 2 mots.\n\n**Exemple d'entrée :**\n```\n\"Hello wor... | ["\nassert count_words(\"Hello world\") == 2\n", "\nassert count_words(\"This is a test\") == 4\n", "\nassert count_words(\"\") == 0\n", "\nassert count_words(\"One\") == 1\n", "\nassert count_words(\" Leading and trailing spaces \") == 4\n", "\nassert count_words(\"Multiple spaces between words\") == 4\n", "\na... |
1b20f9e951bef494ef22b79df4fe96f8 | [
{
"content": "On te donne deux séquences, `seq1` et `seq2`. Ta tâche est d'implémenter une fonction `longest_common_subsequence(seq1: list, seq2: list) -> list` qui trouve la plus longue sous-séquence commune entre les deux séquences. La fonction doit renvoyer la sous-séquence sous forme de liste. S'il existe p... | ["\nassert longest_common_subsequence([1, 2, 3, 4, 1], [3, 4, 1, 2, 1, 3]) == [3, 4, 1]\n", "\nassert longest_common_subsequence(['a', 'b', 'c', 'd'], ['a', 'c', 'b', 'd']) == ['a', 'c', 'd']\n", "\nassert longest_common_subsequence([1, 3, 5, 7], [2, 4, 6, 8]) == []\n", "\nassert longest_common_subsequence([], [1, 2, 3... |
c095307957ec3b32fae6cd8e300401c0 | [
{
"content": "On te demande d'implémenter une fonction qui génère une onde cosinusoïdale modulée en fonction de paramètres spécifiés. La fonction doit renvoyer un tuple contenant l'onde cosinusoïdale modulée et les intervalles de temps correspondants.\n\nLa fonction doit accepter les paramètres suivants :\n- `f... | ["\nassert np.allclose(generate_cosine_wave(10.0, 1.0, 0.0, 315)[0], generate_cosine_wave(10.0, 1.0, 0.0)[0])\n", "\nassert len(generate_cosine_wave(5.0, 2.0)[0]) == 315 * 2\n", "\nassert len(generate_cosine_wave(5.0, 2.0)[1]) == 315 * 2\n", "\nassert generate_cosine_wave(0.0, 1.0)[0].shape == (315,)\n", "\nassert np.a... |
0e5f2ed68540663b8ed49adbb5bd4eb9 | [
{
"content": "On te donne une matrice carrée de taille `n x n` contenant des nombres complexes. Ta tâche est de déterminer si la matrice est symétrique par rapport à la diagonale principale et à la diagonale secondaire. Une matrice est symétrique par rapport à la diagonale principale si `matrix[i][j] == matrix[... | ["\nassert isSymmetric([[1+0j]]) == True\n", "\nassert isSymmetric([[1+0j, 2+3j], [2-3j, 4+0j]]) == True\n", "\nassert isSymmetric([[1+0j, 2+3j], [3+2j, 4+0j]]) == False\n", "\nassert isSymmetric([[1+0j, 2+3j, 4-5j], [2-3j, 6+0j, 7+8j], [4+5j, 7-8j, 9+0j]]) == True\n", "\nassert isSymmetric([[1+0j, 2+3j, 4-5j], [2-3j, ... |
9536b3c3681dd186a70614e53653fb13 | [
{
"content": "On te donne une liste de tuples, où chaque tuple est composé d'un mot et de sa fréquence correspondante. Ta tâche est d'écrire une fonction Python qui identifie et renvoie le mot ayant la fréquence la plus élevée. En cas d'égalité, le mot qui apparaît en premier dans la liste doit être renvoyé.\n\... | ["\nassert word_with_highest_frequency([(\"apple\", 4), (\"banana\", 2), (\"orange\", 4), (\"grape\", 1)]) == \"apple\"\n", "\nassert word_with_highest_frequency([(\"dog\", 3), (\"cat\", 3), (\"bird\", 2)]) == \"dog\"\n", "\nassert word_with_highest_frequency([(\"hello\", 1), (\"world\", 1)]) == \"hello\"\n", "\nassert... |
dce69fc7e66eaf9575dc76b75354164b | [
{
"content": "On te demande d'implémenter une fonction `validate_username` pour déterminer si un nom d'utilisateur respecte des règles spécifiques. Un nom d'utilisateur est considéré comme valide s'il satisfait les conditions suivantes :\n\n1. Commence par une consonne (majuscule ou minuscule).\n2. Ne comprend ... | ["\nassert validate_username(\"a1b2\") == False\n", "\nassert validate_username(\"B1a-\") == False\n", "\nassert validate_username(\"C1a_\") == False\n", "\nassert validate_username(\"D1a2\") == True\n", "\nassert validate_username(\"E1a2\") == False\n", "\nassert validate_username(\"F1a2_\") == False\n", "\nassert val... |
f11c8b9781f823d1f3ace69db7be1587 | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails des employés dans la base de données d'une entreprise. La classe doit prendre en charge les fonctionnalités suivantes :\n\n- **Initialisation** : Créer un objet `Employee` avec les attributs `name`, `employee_id`, `dep... | ["\nassert str(Employee(\"Alice\", 101, \"HR\", 50000)) == \"Employee Name: Alice, Employee ID: 101, Department: HR, Salary: 50000\"\n", "\nassert str(Employee(\"Bob\", 102, \"Marketing\", 60000)) == \"Employee Name: Bob, Employee ID: 102, Department: Marketing, Salary: 60000\"\n", "\nassert str(Employee(\"Charlie\", 1... |
67001435a168731ef6f559f23589ea49 | [
{
"content": "On te donne une liste de vecteurs cartésiens 2D représentés comme des tuples d'entiers. Ta tâche est de mettre en œuvre une fonction qui renvoie une nouvelle liste de vecteurs. Chaque vecteur de la nouvelle liste doit être la somme cumulative de tous les vecteurs jusqu'à ce point dans la liste ori... | ["\nassert cumulative_vector_sum([(1, 2), (3, 4)]) == [(1, 2), (4, 6)]\n", "\nassert cumulative_vector_sum([(0, 0), (0, 0)]) == [(0, 0), (0, 0)]\n", "\nassert cumulative_vector_sum([(1, -1), (-1, 1)]) == [(1, -1), (0, 0)]\n", "\nassert cumulative_vector_sum([(5, 5), (10, 10), (15, 15)]) == [(5, 5), (15, 15), (30, 30)]\... |
ff7ec594aac77ac4d68c74e45fc8ae33 | [
{
"content": "Implémente une table de hachage simple en Python qui prend en charge l'insertion, la récupération et la suppression de paires clé-valeur. La table de hachage doit gérer les collisions en utilisant le chaînage. La fonction de hachage doit être basée sur la fonction de hachage intégrée de Python. La... | ["\nassert HashTable(5).hash_function(\"test\") == hash(\"test\") % 5\n", "\nassert HashTable(5).hash_function(\"example\") == hash(\"example\") % 5\n", "\nassert HashTable(5).hash_function(\"key\") == hash(\"key\") % 5\n", "\nhash_table = HashTable(5)\nhash_table.insert(\"apple\", 10)\nassert hash_table.get(\"apple\")... |
fd0c0661fdca36e10c63303b8609dc80 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `compress_list(l)` qui traite cette liste selon les règles suivantes :\n- Identifier les groupes de doublons consécutifs dans la liste.\n- Remplacer les groupes de doublons consécutifs qui apparaissent un nombre impair de fois par... | ["\nassert compress_list([1, 1, 2, 2, 3, 3, 3]) == [3]\n", "\nassert compress_list([1, 1, 1, 2, 2, 2, 2, 3, 3]) == [1]\n", "\nassert compress_list([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) == [3]\n", "\nassert compress_list([1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5]) == [3]\n", "\nassert compress_list([1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3,... |
7b46ff20523af93ea24f2866822b04f6 | [
{
"content": "On te demande d'implémenter une fonction qui traite un ensemble de données et écrit les résultats dans plusieurs fichiers de manière thread-safe. L'ensemble de données se compose de plusieurs listes et tableaux :\n- `elements` : Une liste de chaînes de caractères représentant différents éléments.\... | ["\nassert len(threading.enumerate()) == 1 # Ensure all threads have finished execution\n", "\nassert open(\"H_0.txt\").read() == \"XYZ: [0.0, 0.0, 0.0]\\nIterations (current/max): 1/100\\nEnergy: 10.5\\n\"\n", "\nassert open(\"O_1.txt\").read() == \"XYZ: [1.0, 1.0, 1.0]\\nIterations (current/max): 2/200\\nEnergy: 20.... |
a35820aa067f42520f2b06215ec69569 | [
{
"content": "On te donne une chaîne de caractères `s` constituée d'une séquence de mots séparés par des espaces simples. Ta tâche est d'écrire une fonction Python qui inverse l'ordre des mots dans la chaîne et renvoie la chaîne résultante. Suppose que la chaîne d'entrée ne contient pas d'espaces de début, de f... | ["\nassert reverse_words(\"hello world\") == \"world hello\"\n", "\nassert reverse_words(\"python is fun\") == \"fun is python\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\"reverse these words\") == \"words these reverse\"\n", "\nassert reverse_words(\"single\") == \"single... |
c333a2a7b959acc21ef1141755fa76fd | [
{
"content": "Implémente une classe `Stack` en Python qui supporte les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et retourne l'élément au sommet de la pile. Si la pile est vide, lève une exception `IndexError` avec le message \"pop from empty stack\".... | ["\nassert Stack().is_empty() == True\n", "\nstack = Stack()\nstack.push(1)\nassert stack.is_empty() == False\n", "\nstack = Stack()\nstack.push(1)\nstack.push(2)\nassert stack.peek() == 2\n", "\nstack = Stack()\nstack.push(1)\nstack.push(2)\nassert stack.pop() == 2\n", "\nstack = Stack()\nstack.push(1)\nstack.push(2)\... |
d16e2f55293e6ab65d45e3b2d0db34dd | [
{
"content": "On te donne une liste d'entiers représentant les prix des actions sur des jours consécutifs. Ta tâche est de déterminer le profit maximal qui peut être réalisé en achetant et en vendant l'action exactement une fois. Tu dois acheter avant de vendre, et tu ne peux détenir qu'une seule action à la fo... | ["\nassert find_max_profit([7, 1, 5, 3, 6, 4]) == 5\n", "\nassert find_max_profit([7, 6, 4, 3, 1]) == 0\n", "\nassert find_max_profit([1, 2, 3, 4, 5]) == 4\n", "\nassert find_max_profit([3, 3, 5, 0, 0, 3, 1, 4]) == 4\n", "\nassert find_max_profit([1, 2]) == 1\n", "\nassert find_max_profit([2, 1, 2, 1, 0, 1, 2]) == 2\n"... |
27e1a972a4ab108ebb4e83ea4d54e9e9 | [
{
"content": "On te donne un fichier texte. Ta tâche est d'écrire une fonction `count_words_in_file(file_path)` qui lit le fichier et renvoie le nombre total de mots qui ont plus de 4 caractères. Les mots sont définis comme des séquences de caractères alphabétiques uniquement, en ignorant la ponctuation, les no... | ["\nassert count_words_in_file(\"test1.txt\") == 0\n", "\nassert count_words_in_file(\"test2.txt\") == 3\n", "\nassert count_words_in_file(\"test3.txt\") == 2\n", "\nassert count_words_in_file(\"test4.txt\") == 5\n", "\nassert count_words_in_file(\"test5.txt\") == 1\n", "\nassert count_words_in_file(\"test6.txt\") == 0... |
9eb2b0e2a5ab20cfd596f2578f4eefae | [
{
"content": "On te donne un dictionnaire imbriqué `data` et une chaîne de caractères `path`. Le `path` est une séquence de clés séparées par des barres obliques ('/'). Ta tâche est d'implémenter la fonction `deep_get_value` qui navigue à travers le dictionnaire en utilisant le chemin et renvoie la valeur à la ... | ["\nassert deep_get_value({\"a\": {\"b\": {\"c\": 1}}}, \"a/b/c\") == 1\n", "\nassert deep_get_value({\"x\": {\"y\": {\"z\": 2}}}, \"x/y/z\") == 2\n", "\nassert deep_get_value({\"key1\": {\"key2\": {\"key3\": \"value\"}}}, \"key1/key2/key3\") == \"value\"\n", "\nassert deep_get_value({\"level1\": {\"level2\": {\"level3... |
6c50c77cac4c7c0ce99c2e00cd600309 | [
{
"content": "Tu participes à un concours d'analyse de données de vélos en libre-service à l'échelle de la ville. On te fournit un ensemble de données stocké dans un DataFrame pandas `df` qui contient des informations sur les services de partage de vélos. Le DataFrame a les colonnes suivantes : `Start Station` ... | ["\nassert bike_stats(pd.DataFrame({\n 'Start Station': ['A', 'B', 'A', 'C', 'A', 'B'],\n 'End Station': ['B', 'C', 'B', 'B', 'C', 'A'],\n 'Trip Duration': [45, 75, 60, 30, 90, 120]\n})) == None\n", "\nassert bike_stats(pd.DataFrame({\n 'Start Station': ['X', 'Y', 'X', 'Z', 'X', 'Y'],\n 'End Station': ['... |
a3165cd6af9076460b3cf7a510d675c8 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction qui supprime tous les éléments dupliqués de la liste tout en conservant l'ordre de leur première apparition. La fonction doit renvoyer la liste modifiée.\n\n**Exemple d'entrée :**\n```\n[4, 5, 6, 4, 3, 2, 5, 1]\n```\n\n**Exem... | ["\nassert remove_duplicates([4, 5, 6, 4, 3, 2, 5, 1]) == [4, 5, 6, 3, 2, 1]\n", "\nassert remove_duplicates([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [10, 9, 8... |
f70fc8c503c9062657d1349974aceb44 | [
{
"content": "On te demande d'implémenter une fonction pour extraire des attributs spécifiques d'un objet `Employee` et de les stocker dans un dictionnaire. La classe `Employee` possède des attributs tels que `name`, `age`, `position` et `salary`. On te fournit une liste d'attributs à extraire, qui peut inclure... | ["\nassert extract_attributes(Employee(\"John Doe\", 30, \"Software Engineer\", 80000), ['name', ('age', 'years_old'), 'position']) == {'name': 'John Doe', 'years_old': 30, 'position': 'Software Engineer'}\n", "\nassert extract_attributes(Employee(\"Jane Smith\", 25, \"Data Analyst\", 70000), ['name', 'age', 'salary'])... |
eb2f9e1ab3467f1deaa389ed55c93f92 | [
{
"content": "On te donne une séquence qui peut être une liste, un tuple ou une chaîne de caractères. Ta tâche est d'écrire une fonction `reverse_alternate` qui renvoie une nouvelle séquence où chaque élément à une position correspondant à un nombre de Fibonacci (à l'exclusion des deux premiers nombres de Fibon... | ["\nassert reverse_alternate((1, 2, 3, 4, 5)) == (1, 2, 3, 4, 5)\n", "\nassert reverse_alternate((1, 2, (3, 4), 5, (6, 7))) == (1, 2, (4, 3), 5, (7, 6))\n", "\nassert reverse_alternate(\"abcdef\") == \"abcfed\"\n", "\nassert reverse_alternate(\"abcdefghij\") == \"abcdejihgf\"\n", "\nassert reverse_alternate([1, 2, [3, ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.