id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
eb5bb1b349663888b72339b92e5dc898 | [
{
"content": "Conçois une fonction génératrice Python nommée `fibonacci_generator` qui génère une séquence infinie de nombres de Fibonacci. La séquence de Fibonacci commence par 0 et 1, et chaque nombre suivant est la somme des deux nombres précédents. Ta fonction doit être capable de générer des nombres de Fib... | ["\nassert next(fibonacci_generator()) == 0\n", "\ngen = fibonacci_generator()\nnext(gen)\nassert next(gen) == 1\n", "\ngen = fibonacci_generator()\nnext(gen)\nnext(gen)\nassert next(gen) == 1\n", "\ngen = fibonacci_generator()\nnext(gen)\nnext(gen)\nnext(gen)\nassert next(gen) == 2\n", "\ngen = fibonacci_generator()\n... |
61441b53b1c7227c71b0068e4ca63b7a | [
{
"content": "On te donne une chaîne de caractères au format camel case. Ta tâche est d'écrire une fonction `convert_to_snake_case` qui convertit cette chaîne au format snake case. En camel case, chaque mot commence par une majuscule et il n'y a pas d'espaces entre les mots. En snake case, les mots sont séparés... | ["\nassert convert_to_snake_case(\"convertToSnakeCaseExample\") == \"convert_to_snake_case_example\"\n", "\nassert convert_to_snake_case(\"already_snake_case\") == \"already_snake_case\"\n", "\nassert convert_to_snake_case(\"HTTPRequest\") == \"http_request\"\n", "\nassert convert_to_snake_case(\"ThisIsATest\") == \"th... |
b1ed15656e5065de48ba313a27680bd1 | [
{
"content": "On te demande d'implémenter une fonction qui vérifie la validité d'une chaîne JSON par rapport à un schéma JSON fourni. Ta fonction doit renvoyer `True` si la chaîne JSON est conforme au schéma, et `False` sinon.\n\n**Entrée :**\n- La fonction recevra deux chaînes : `json_string` et `schema`.\n- `... | ["\nassert validate_json('{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}', '{\"type\": \"object\", \"properties\": {\"name\": {\"type\": \"string\"}, \"age\": {\"type\": \"integer\"}, \"city\": {\"type\": \"string\"}}}') == True\n", "\nassert validate_json('{\"name\": \"John\", \"age\": \"thirty\", \"city\":... |
87fbc5d3fd7ceb7d9bc32bfea7bd9465 | [
{
"content": "Tu es chargé d'implémenter une classe `SimpleCalculator` en Python qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. Ta classe doit inclure des méthodes pour chaque opération et gérer les erreurs de manière appropriée, comme la division ... | ["\nassert SimpleCalculator().add(2, 3) == 5\n", "\nassert SimpleCalculator().subtract(5, 3) == 2\n", "\nassert SimpleCalculator().multiply(4, 7) == 28\n", "\nassert SimpleCalculator().divide(10, 2) == 5.0\n", "\nassert SimpleCalculator().add(-1, 1) == 0\n", "\nassert SimpleCalculator().subtract(0, 0) == 0\n", "\nasser... |
7f5b336cc95e3f0bc563a1159583544c | [
{
"content": "On te donne une liste de chaînes de caractères. Ta tâche est de trouver la sous-chaîne de longueur 3 (trigramme) la plus courante parmi toutes les chaînes. En cas d'égalité, renvoie le premier trigramme ayant la fréquence la plus élevée. Si la liste est vide ou si toutes les chaînes ont moins de 3... | ["\nassert most_common_trigram([\"abcabcabc\", \"abcde\", \"abcfgh\", \"abc\"]) == \"abc\"\n", "\nassert most_common_trigram([\"xyz\", \"zyx\", \"xyz\", \"zyx\", \"xyz\"]) == \"xyz\"\n", "\nassert most_common_trigram([\"aaa\", \"bbb\", \"aaa\", \"ccc\", \"aaa\"]) == \"aaa\"\n", "\nassert most_common_trigram([\"abc\", \... |
1c21fecf35a0f3df75d18348ce3574db | [
{
"content": "On te confie la tâche de développer une fonction pour estimer la distance d'un appareil par rapport à un point d'accès Wi-Fi en fonction de la puissance du signal reçu (RSSI) en dBm. Les relevés de puissance du signal sont bruyants et peuvent varier de ±3 dBm. Ta fonction doit calculer et renvoyer... | ["\nassert distance_from_rssi(-65) == (1.93, 3.98)\n", "\nassert distance_from_rssi(-70) == (3.98, 7.94)\n", "\nassert distance_from_rssi(-80) == (7.94, 15.85)\n", "\nassert distance_from_rssi(-90) == (15.85, 31.62)\n", "\nassert distance_from_rssi(-100) == (31.62, 63.09)\n", "\nassert distance_from_rssi(-50) == (0.97,... |
dd480479db8cef66d0a59b5fb71c786a | [
{
"content": "On te donne un modèle de langage pré-entraîné qui génère du texte à partir d'une entrée donnée. Le modèle utilise un tokenizer pour convertir le texte en tokens, qui sont ensuite introduits dans le modèle pour générer le token suivant. Le modèle renvoie une distribution de probabilité sur l'ensemb... | ["\nassert torch.allclose(discourage_frequent_tokens(model, tokenizer, context, [\"H\", \"e\", \"l\", \"l\", \"o\", \"o\"], penalty=0.8), torch.tensor([0.1, 0.2, 0.3, 0.4, 0.0]))\n", "\nassert torch.allclose(discourage_frequent_tokens(model, tokenizer, context, [\"H\", \"e\", \"l\", \"l\", \"o\"], penalty=0.9), torch.t... |
09d22f015ca6922b291d10665a802255 | [
{
"content": "On te donne un système d'amortissement qui fonctionne linéairement dans une plage spécifiée de valeurs d'entrée. L'amortisseur a un niveau d'amortissement minimum `d1` et un niveau d'amortissement maximum `d2`. Le système fonctionne comme suit :\n- Si la valeur d'entrée `i` est inférieure à `i1`, ... | ["\nassert damper_system(5, 0, 10, 1, 5) == 3.0\n", "\nassert damper_system(0, 0, 10, 1, 5) == 1\n", "\nassert damper_system(10, 0, 10, 1, 5) == 5\n", "\nassert damper_system(-5, 0, 10, 1, 5) == 1\n", "\nassert damper_system(15, 0, 10, 1, 5) == 5\n", "\nassert damper_system([0, 5, 10, 15], 0, 10, 1, 5) == [1, 3.0, 5, 5... |
1afe9626d131d1d5459c0fb4f0424639 | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est de mettre en œuvre une fonction `get_common_elements` qui renvoie une nouvelle liste contenant les éléments communs aux deux listes d'entrée. La liste renvoyée ne doit contenir aucun doublon et doit être triée par ordre croissant.... | ["\nassert get_common_elements([1, 2, 3], [2, 3, 4]) == [2, 3]\n", "\nassert get_common_elements([5, 6, 7], [8, 9, 10]) == []\n", "\nassert get_common_elements([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert get_common_elements([], [1, 2, 3]) == []\n", "\nassert get_common_elements([1, 2, 3], []) == []\n", "\nassert g... |
d999f56ab5f59df3f7354f3137848346 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphanumériques et d'espaces. Ta tâche est de classer la chaîne dans l'une des catégories suivantes :\n\n1. La chaîne contient uniquement des caractères alphabétiques (en ignorant les espaces).\n2. La chaîne contient uniquement des ca... | ["\nassert classify_string(\"Hello World\") == 1\n", "\nassert classify_string(\"1234567890\") == 2\n", "\nassert classify_string(\"Hello123\") == 3\n", "\nassert classify_string(\" \") == 4\n", "\nassert classify_string(\"\") == 4\n", "\nassert classify_string(\"Hello World 123\") == 3\n", "\nassert classify_string(\"... |
355551430c5a26e2085b930304e67235 | [
{
"content": "On te donne deux listes d'entiers, `data` et `weights`, toutes deux de la même longueur. Chaque élément de `data` a un poids correspondant dans `weights`. Ta tâche est de calculer la moyenne pondérée des éléments de `data`. Cependant, si un élément de `data` est un nombre premier, son poids doit ê... | ["\nassert weighted_avg([1, 2, 3, 4, 5], [1, 1, 1, 1, 1]) == 33 / 7\n", "\nassert weighted_avg([2, 4, 6, 8], [1, 1, 1, 1]) == 5\n", "\nassert weighted_avg([7, 11, 13], [1, 1, 1]) == 37 / 3\n", "\nassert weighted_avg([10, 15, 20], [2, 3, 4]) == 15.5\n", "\nassert weighted_avg([17, 19, 23], [1, 1, 1]) == 72 / 3\n", "\nas... |
9ab65f97e42e3b2f24d3403b41971301 | [
{
"content": "On te donne la tâche d'écrire une fonction qui détermine le nombre de façons distinctes de rendre la monnaie pour un montant spécifié en utilisant un ensemble limité de pièces. Les pièces disponibles sont les quarters (25 cents), les dimes (10 cents), les nickels (5 cents) et les pennies (1 cent).... | ["\nassert count_ways_to_make_change(0) == 1\n", "\nassert count_ways_to_make_change(1) == 1\n", "\nassert count_ways_to_make_change(5) == 2\n", "\nassert count_ways_to_make_change(10) == 4\n", "\nassert count_ways_to_make_change(15) == 6\n", "\nassert count_ways_to_make_change(25) == 4\n", "\nassert count_ways_to_make... |
e3235462c2008024e83d6e58f1739db9 | [
{
"content": "Tu développes un système qui nécessite la génération d'un identifiant unique pour les utilisateurs, basé sur leur nom d'utilisateur et une clé secrète. Cet identifiant sera utilisé pour créer des liens personnalisés. Ta tâche est d'implémenter une fonction `generate_user_link_hash` qui prend deux ... | ["\nassert generate_user_link_hash(\"user1\", \"key1\") == \"d41d8cd98f00\"\n", "\nassert generate_user_link_hash(\"admin\", \"secret\") == \"8d969eef6ecad3c29a3a629280e686cf\"\n", "\nassert generate_user_link_hash(\"\", \"secret\") == None\n", "\nassert generate_user_link_hash(\"user\", \"\") == None\n", "\nassert gen... |
af67d1468e85d41178e053f5cb14475a | [
{
"content": "Tu es chargé d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author`, `year` et `ISBN`. De plus, la classe doit inclure une méthode `get_details()` qui renvoie une chaîne formatée avec les détails du livre. Le format de la chaîne doit être : \"Tit... | ["\nassert Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925, \"9780743273565\").get_details() == \"Title: The Great Gatsby, Author: F. Scott Fitzgerald, Year: 1925, ISBN: 9780743273565\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"9780451524935\").get_details() == \"Title: 1984, Author: George Orwel... |
b67e27eb7969e4707645c7b97ec95e0e | [
{
"content": "Implémente l'algorithme QuickSort pour trier un tableau d'entiers par ordre croissant. Ta fonction doit prendre un tableau en entrée et renvoyer le tableau trié. Le tableau d'entrée peut contenir des éléments en double.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^3), le... | ["\nassert quicksort([3, 6, 8, 10, 1, 2, 1]) == [1, 1, 2, 3, 6, 8, 10]\n", "\nassert quicksort([5, 3, 8, 4, 2]) == [2, 3, 4, 5, 8]\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", "... |
4d13103126098ab128711eba5acc2e27 | [
{
"content": "Tu participes à un défi de prédiction de mots. Tu as deux fichiers texte, `predicted.txt` et `actual.txt`. Chaque fichier contient une liste de mots, chaque ligne représentant un seul mot. Le fichier `predicted.txt` contient les mots suivants prédits générés par un modèle de langage, tandis que le... | ["\nassert evaluate_predictions(\"predicted1.txt\", \"actual1.txt\") == (3, 3)\n", "\nassert evaluate_predictions(\"predicted2.txt\", \"actual2.txt\") == (0, 2)\n", "\nassert evaluate_predictions(\"predicted3.txt\", \"actual3.txt\") == (2, 4)\n", "\nassert evaluate_predictions(\"predicted4.txt\", \"actual4.txt\") == (5... |
dd6c8eaca6c160d762c86536adf55136 | [
{
"content": "On te demande d'implémenter une fonction `validate_ports` qui traite une chaîne de ports TCP. La chaîne d'entrée `ports_str` contient une liste de ports séparés par des virgules. Chaque port peut être un nombre unique ou une plage spécifiée par deux nombres séparés par un tiret (par exemple, \"80-... | ["\nassert validate_ports(\"80, 8080, 9000, 65536, abc, 123\") == [80, 123, 8080, 9000]\n", "\nassert validate_ports(\"80-100\") == list(range(80, 101))\n", "\nassert validate_ports(\"100-80\") == []\n", "\nassert validate_ports(\"100-200, 150-160\") == list(range(100, 201))\n", "\nassert validate_ports(\"0, 65535\") =... |
8b107bb7f5bff5b7dcb1dc5021e84807 | [
{
"content": "On te demande d'implémenter une fonction `calculate_discount` qui calcule le prix réduit d'un produit. La fonction accepte deux paramètres : `original_price` et `discount_rate`. Le `original_price` est fourni sous forme de chaîne de caractères formatée avec des virgules pour les milliers et un sig... | ["\nassert calculate_discount('$1,234.56', '20') == '$987.65'\n", "\nassert calculate_discount('$100.00', '50') == '$50.00'\n", "\nassert calculate_discount('$1,000,000.00', '10') == '$900,000.00'\n", "\nassert calculate_discount('$0.99', '100') == '$0.00'\n", "\nassert calculate_discount('$500.00', '0') == '$500.00'\n... |
634b241a96e4d69dd6cec36af6c5a16c | [
{
"content": "On te donne une ligne de code provenant d'un langage de programmation qui utilise des points-virgules (`;`), des dièses (`#`) et des doubles points d'exclamation (`!!`) comme indicateurs de commentaires. Ta tâche est d'écrire une fonction `process_code_line` qui traite cette ligne selon les règles... | ["\nassert process_code_line(\"int a = 5; // comment\") == \"5 ta ni\"\n", "\nassert process_code_line(\"print('hello world')!!\") == \"dlrow olleh tnirp\"\n", "\nassert process_code_line(\"var x = 10 # another comment\") == \"01 x rav\"\n", "\nassert process_code_line(\"function call(param1, param2)\") == \"1mnap epac... |
8b401b8fbc4d39e291c2f06781009fd7 | [
{
"content": "On te donne une chaîne de caractères `s` contenant une série de nombres séparés par des virgules. Ta tâche est d'écrire une fonction `find_product_of_numbers_in_string(s)` qui extrait ces nombres, les convertit en nombres à virgule flottante, calcule leur produit et renvoie le résultat arrondi à l... | ["\nassert find_product_of_numbers_in_string(\"1,2,3,4,5\") == 120\n", "\nassert find_product_of_numbers_in_string(\"1.5,2.5,3.5\") == 14\n", "\nassert find_product_of_numbers_in_string(\"2,4,6,8,10\") == 3840\n", "\nassert find_product_of_numbers_in_string(\"1.1,1.1,1.1,1.1\") == 1\n", "\nassert find_product_of_number... |
e94f8f8237279e6458a3d790c91211fc | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est de mettre en œuvre une fonction `count_words` qui traite cette chaîne et renvoie un dictionnaire. Le dictionnaire doit associer chaque mot unique (sans tenir compte de la casse) au nombre de fois où il apparaît dans le texte. Les mots sont ... | ["\nassert count_words(\"Hello world\") == {'hello': 1, 'world': 1}\n", "\nassert count_words(\"Hello hello world\") == {'hello': 2, 'world': 1}\n", "\nassert count_words(\"Python is great, python is fun!\") == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert count_words(\"A quick brown fox jumps over the laz... |
cf97255bdd81e846c085cd4d21709329 | [
{
"content": "On te donne un tableau trié d'entiers `nums` et un entier `target`. Ta tâche est de mettre en œuvre une fonction qui effectue une recherche binaire pour trouver l'index de `target` dans le tableau. Si `target` n'est pas présent dans le tableau, retourne -1.\n\n**Entrée :**\n- La première ligne con... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([2, 4, 6, 8, 10, 12, 14, 16, 18, 20], 14) == 6\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([1], 1) == 0\n", "\nassert binary_search([1, 3, 5, 7, 9], 1) == 0\n", "\... |
330a9f4391d8d864b44410c6df0eea5b | [
{
"content": "On te demande de traiter des données provenant d'une plateforme de réseaux sociaux. Les données consistent en une liste d'utilisateurs, où chaque utilisateur est représenté comme un tuple contenant un identifiant utilisateur unique et une liste de ses publications. Chaque publication est un tuple ... | ["\nassert calculate_totals([[\"user1\", [[1, 2], [3, 4]]]]) == {\"user1\": [4, 6]}\n", "\nassert calculate_totals([[\"user2\", [[0, 0], [0, 0]]]]) == {\"user2\": [0, 0]}\n", "\nassert calculate_totals([[\"user3\", [[5, 5], [5, 5]]]]) == {\"user3\": [10, 10]}\n", "\nassert calculate_totals([[\"user4\", [[10, 20], [30, ... |
0a2dd1b0226abd46f83077f6b1117759 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule la somme de tous les entiers positifs dans la liste. La fonction doit être optimisée à la fois pour la lisibilité et la performance.\n\n**Exemple d'entrée :**\n```python\n[1, -2, 3, 4, -5, 6]\n```\n\n**Exemple de s... | ["\nassert sum_of_positive_numbers([1, 2, 3, 4, 5]) == 15\n", "\nassert sum_of_positive_numbers([-1, -2, -3, -4, -5]) == 0\n", "\nassert sum_of_positive_numbers([0, 0, 0, 0, 0]) == 0\n", "\nassert sum_of_positive_numbers([-1, 2, -3, 4, -5]) == 6\n", "\nassert sum_of_positive_numbers([10, -10, 20, -20, 30]) == 60\n", "\... |
3c4e2c23e98d45c2e6468ef7d5b5fcdb | [
{
"content": "On te donne une structure de liste imbriquée où chaque sous-liste contient des tuples. Ta tâche est d'aplatir cette liste imbriquée en une seule liste d'éléments. Tu dois implémenter la fonction `flatten_nested_list(nested_list)` sans utiliser de fonctions intégrées qui gèrent directement l'aplati... | ["\nassert flatten_nested_list([[(1, 2)], [(3, 4)], [(5, 6)]]) == [1, 2, 3, 4, 5, 6]\n", "\nassert flatten_nested_list([[(1, 2, 3)], [4, (5, 6)], [7, 8, (9, 10)]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert flatten_nested_list([[], [(1, 2)], [], [(3, 4)], []]) == [1, 2, 3, 4]\n", "\nassert flatten_nested_list([[(... |
dc920eaa9f3faa83ec7ae3eecf17f891 | [
{
"content": "Tu es chargé de créer un script Python qui traite un ensemble de données de transactions d'achats en ligne afin de générer un rapport récapitulatif pour chaque client. Le rapport doit inclure les dépenses totales, le nombre de transactions et la valeur moyenne des transactions pour chaque client. ... | ["\nassert generate_customer_summary_report(pd.DataFrame({\n 'customer_id': [101, 102, 101],\n 'transaction_id': [10001, 10002, 10003],\n 'transaction_date': ['2022-01-11', '2022-01-12', '2022-01-13'],\n 'amount': [150.50, 200.75, 99.99]\n})).equals(pd.DataFrame({\n 'customer_id': [101, 102],\n 'total... |
3a748fadbcb9a83f4b182c7e72f05cd2 | [
{
"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 croissante dans cette séquence. Une sous-séquence croissante est définie comme une séquence où chaque élément est supérieur au précédent. Tu dois implémenter une solution en utilisant la prog... | ["\nassert length_of_lis([10, 9, 2, 5, 3, 7, 101, 18]) == 4\n", "\nassert length_of_lis([0, 1, 0, 3, 2, 3]) == 4\n", "\nassert length_of_lis([7, 7, 7, 7, 7, 7, 7]) == 1\n", "\nassert length_of_lis([1, 2, 3, 4, 5]) == 5\n", "\nassert length_of_lis([5, 4, 3, 2, 1]) == 1\n", "\nassert length_of_lis([1]) == 1\n", "\nassert... |
f392549c0d4674aff1deac5249b9afe3 | [
{
"content": "On te demande d'implémenter une fonction qui traite plusieurs fichiers texte simultanément et renvoie un dictionnaire associant chaque nom de fichier au nombre total de mots qu'il contient. Ta fonction doit gérer les erreurs de lecture de fichier avec élégance en affichant un message d'erreur et e... | ["\nassert count_words_in_files([\"test1.txt\", \"test2.txt\"]) == {\"test1.txt\": 10, \"test2.txt\": 20}\n", "\nassert count_words_in_files([\"nonexistentfile.txt\"]) == {\"nonexistentfile.txt\": 0}\n", "\nassert count_words_in_files([]) == {}\n", "\nassert count_words_in_files([\"emptyfile.txt\"]) == {\"emptyfile.txt... |
c1b28daebb9fb4f35163d02233df33b0 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `split_even_odd` qui sépare les entiers en deux listes distinctes : une pour les nombres pairs et une autre pour les nombres impairs. La fonction doit renvoyer un tuple contenant ces deux listes.\n\n**Entrée :**\n- Une liste d'ent... | ["\nassert split_even_odd([1, 2, 3, 4, 5, 6]) == ([2, 4, 6], [1, 3, 5])\n", "\nassert split_even_odd([10, 15, 20, 25, 30]) == ([10, 20, 30], [15, 25])\n", "\nassert split_even_odd([]) == ([], [])\n", "\nassert split_even_odd([0, 1, 2, 3, 4, 5]) == ([0, 2, 4], [1, 3, 5])\n", "\nassert split_even_odd([-2, -3, -4, -5]) ==... |
126687b3aed9f767497e4f896ec025f5 | [
{
"content": "On te donne une liste d'entiers et un entier `n`. Ta tâche est d'implémenter une fonction `rotate_list` qui fait pivoter les éléments de la liste vers la droite de `n` positions et renvoie la liste résultante. Si la liste est vide, renvoie une liste vide. La fonction doit gérer les cas où `n` est ... | ["\nassert rotate_list([1, 2, 3, 4, 5], 2) == [4, 5, 1, 2, 3]\n", "\nassert rotate_list([1, 2, 3, 4, 5], 5) == [1, 2, 3, 4, 5]\n", "\nassert rotate_list([1, 2, 3, 4, 5], 0) == [1, 2, 3, 4, 5]\n", "\nassert rotate_list([1, 2, 3, 4, 5], 7) == [4, 5, 1, 2, 3]\n", "\nassert rotate_list([], 3) == []\n", "\nassert rotate_lis... |
b66516356beeb89316dabb911ed45755 | [
{
"content": "On te demande d'implémenter une fonction nommée `validate_input` qui lit les entrées de l'utilisateur indéfiniment jusqu'à ce qu'un entier pair valide supérieur à 10 soit saisi. La fonction doit gérer les entrées invalides avec élégance en affichant le message \"Invalid input. Please enter an even... | ["\nassert validate_input() == 12 # Simulate input of \"12\"\n", "\nassert validate_input() == 20 # Simulate input of \"20\"\n", "\nassert validate_input() == 14 # Simulate input of \"14\"\n", "\nassert validate_input() == 18 # Simulate input of \"18\"\n", "\nassert validate_input() == 100 # Simulate input of \"10... |
b48806a70860f6e527627259b56f1b00 | [
{
"content": "Implémente une fonction pour approximer l'intégrale d'une fonction donnée \\( f(x) \\) de \\( a \\) à \\( b \\) en utilisant la règle du point milieu avec \\( n \\) sous-intervalles. Ton implémentation doit utiliser exclusivement des nombres rationnels pour éviter les problèmes de précision des no... | ["\nassert midpoint_rule_rational(lambda x: Fraction(1), Fraction(0), Fraction(1), 1) == Fraction(1)\n", "\nassert midpoint_rule_rational(lambda x: x, Fraction(0), Fraction(1), 1) == Fraction(1, 2)\n", "\nassert midpoint_rule_rational(lambda x: x**2, Fraction(0), Fraction(1), 1) == Fraction(1, 4)\n", "\nassert midpoint... |
e3ca6608c0e6fe274bb46a8500bab709 | [
{
"content": "On te donne un fichier binaire représentant une image disque et une configuration pour une partition dans cette image disque. La configuration de la partition inclut l'octet de début de la partition. Dans la partition, il y a un indicateur spécifique situé à un décalage fixe par rapport au début d... | ["\nassert is_file_system_read_write(\"test_disk.img\", 0x1BE, 0x10) == True\n", "\nassert is_file_system_read_write(\"test_disk.img\", 0x1BE, 0x10) == False\n", "\nassert is_file_system_read_write(\"test_disk.img\", 0x0, 0x0) == True\n", "\nassert is_file_system_read_write(\"test_disk.img\", 0x0, 0x0) == False\n", "\n... |
9454b39934364c6af5010ef20da28dd8 | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `count_primes(n)` qui renvoie un tuple contenant deux entiers : le premier entier est le nombre de nombres premiers inférieurs ou égaux à `n`, et le second entier est le nombre maximal de nombres non premiers consécutifs entre deux nomb... | ["\nassert count_primes(10) == (4, 2)\n", "\nassert count_primes(1) == (0, 0)\n", "\nassert count_primes(0) == (0, 0)\n", "\nassert count_primes(2) == (1, 0)\n", "\nassert count_primes(30) == (10, 4)\n", "\nassert count_primes(100) == (25, 8)\n", "\nassert count_primes(101) == (26, 8)\n", "\nassert count_primes(200) ==... |
dc6bf2b385589db2f39cce160f5b63d9 | [
{
"content": "On te donne une liste d'entiers `prices` où `prices[i]` représente le prix d'une action au `i-ème` jour. Tu es autorisé à effectuer au plus une transaction : acheter une action et la vendre un autre jour dans le futur. Cependant, chaque fois que tu vends l'action, tu dois payer des frais de transa... | ["\nassert max_profit_with_fee([7, 1, 5, 3, 6, 4], 2) == 3\n", "\nassert max_profit_with_fee([1, 3, 2, 8, 4, 9], 2) == 5.88\n", "\nassert max_profit_with_fee([10, 7, 5, 8, 11, 9], 2) == 3.6\n", "\nassert max_profit_with_fee([1, 2, 3, 4, 5], 10) == 0\n", "\nassert max_profit_with_fee([5, 4, 3, 2, 1], 2) == 0\n", "\nasse... |
6768651b0a7ae405930f977135cab153 | [
{
"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 `sort_dict_by_value` qui trie ce dictionnaire par ses valeurs par ordre décroissant. Si deux valeurs sont identiques, les clés correspondantes doivent être tri... | ["\nassert sort_dict_by_value({'apple': 3, 'banana': 2, 'cherry': 2, 'date': 5}) == {'date': 5, 'apple': 3, 'banana': 2, 'cherry': 2}\n", "\nassert sort_dict_by_value({'a': 1, 'b': 2, 'c': 3}) == {'c': 3, 'b': 2, 'a': 1}\n", "\nassert sort_dict_by_value({'x': 10, 'y': 10, 'z': 5}) == {'x': 10, 'y': 10, 'z': 5}\n", "\na... |
7739b4f9f24bbf97ec86a2480778c779 | [
{
"content": "On te demande d'implémenter une fonction `count_elements` qui respecte les spécifications suivantes. La fonction ne doit pas utiliser de boucles explicites (par exemple, `for`, `while`).\n\n**Signature de la fonction :**\n```python\ndef count_elements(condition: Callable[[Any, int], bool]) -> Call... | ["\nassert count_elements(lambda x, n: x > n)([1, 2, 3, 4, 5], 3) == 2\n", "\nassert count_elements(lambda x, n: x < n)([1, 2, 3, 4, 5], 3) == 2\n", "\nassert count_elements(lambda x, n: x == n)([1, 2, 3, 4, 5], 3) == 1\n", "\nassert count_elements(lambda x, n: x != n)([1, 2, 3, 4, 5], 3) == 4\n", "\nassert count_eleme... |
fca31252f8702dd799abf99bad5ea9f1 | [
{
"content": "On te donne la tâche de construire un graphe non orienté complet avec un nombre spécifié de nœuds. Dans ce graphe, chaque nœud doit être identifié de manière unique par les plus petits nombres premiers possibles. Le graphe doit être représenté comme un dictionnaire où chaque clé est un nœud (nombr... | ["\nassert generate_complete_graph(1) == {2: set()}\n", "\nassert generate_complete_graph(2) == {2: {3}, 3: {2}}\n", "\nassert generate_complete_graph(3) == {2: {3, 5}, 3: {2, 5}, 5: {2, 3}}\n", "\nassert generate_complete_graph(4) == {2: {3, 5, 7}, 3: {2, 5, 7}, 5: {2, 3, 7}, 7: {2, 3, 5}}\n", "\nassert generate_compl... |
926989dd6e44c5e142d0ad9666f6dd04 | [
{
"content": "On te donne un dictionnaire `students` où chaque clé est le nom d'un étudiant (une chaîne de caractères) et chaque valeur est la note de l'étudiant (un nombre à virgule flottante). Implémente une fonction `filter_top_students(students, threshold)` qui filtre les étudiants dont les notes ne dépasse... | ["\nassert filter_top_students({\"Alice\": 85, \"Bob\": 92, \"Charlie\": 78, \"David\": 95}, 90) == {\"Bob\": 92, \"David\": 95}\n", "\nassert filter_top_students({\"Alice\": 85, \"Bob\": 92, \"Charlie\": 78, \"David\": 95}, 85) == {\"Bob\": 92, \"David\": 95}\n", "\nassert filter_top_students({\"Alice\": 85, \"Bob\": ... |
354cad7fa73a5091f2a26afc25e178cc | [
{
"content": "On te donne une chaîne de caractères `expression` composée de chiffres uniques, de parenthèses, d'opérateurs d'addition, de soustraction et de multiplication. Évalue l'expression selon les règles suivantes :\n- L'addition et la soustraction ont une priorité plus élevée que la multiplication.\n- Le... | ["\nassert calculate_expression(\"3+5\") == 8\n", "\nassert calculate_expression(\"3*5\") == 15\n", "\nassert calculate_expression(\"3*(5+2)\") == 21\n", "\nassert calculate_expression(\"(3+5)*2\") == 16\n", "\nassert calculate_expression(\"3*(5+2)*2\") == 42\n", "\nassert calculate_expression(\"3+5*2\") == 13\n", "\na... |
4429a53ff5640ed91a470a6d156b54a6 | [
{
"content": "On te donne un graphe où chaque nœud représente une variable avec un attribut `shape`, une liste d'entiers représentant ses dimensions. Le graphe peut avoir un dictionnaire `shape_feature` qui optimise les formes des variables. De plus, le graphe a un dictionnaire `constraints` qui mappe les noms ... | ["\nassert optimized_shape(var1, 0, graph) == 3\n", "\nassert optimized_shape(var2, 1, graph) == 6\n", "\nassert optimized_shape(var1, 1, graph) == 4\n", "\nassert optimized_shape(var2, 0, graph) == 5\n", "\nassert optimized_shape(var1, 0, Graph()) == 2\n", "\nassert optimized_shape(var2, 1, Graph()) == 5\n", "\nassert... |
c0589ac9177fb2c3fb924f468d3a93d2 | [
{
"content": "On te demande d'implémenter un éditeur de texte simple en Python. Ton éditeur de texte doit prendre en charge les opérations suivantes :\n\n1. **Ouvrir un Fichier** : Charger le contenu d'un fichier dans l'éditeur.\n2. **Sauvegarder un Fichier** : Écrire le contenu actuel de l'éditeur dans un fich... | ["\nassert SimpleTextEditor().content == ''\n", "\neditor = SimpleTextEditor(); editor.insert_text(0, 'Hello'); assert editor.content == 'Hello'\n", "\neditor = SimpleTextEditor(); editor.insert_text(0, 'Hello'); editor.insert_text(5, ' World'); assert editor.content == 'Hello World'\n", "\neditor = SimpleTextEditor();... |
8fb74f16c65dc63f6fc84653ce3571ae | [
{
"content": "Implémente une classe Python `Stack` qui prend en charge les opérations suivantes :\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élément du sommet de la pile. Si la pile est vide, lève une exception `IndexError`.\n- `peek()` : Renvoie l'élément au so... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().peek() == None\n", "\ns = Stack(); s.push(5); assert s.peek() == 5\n", "\ns = Stack(); s.push(5); s.push(10); assert s.pop() == 10\n", "\ns = Stack(); s.push(5); s.push(10); s.pop(); assert s.peek() == 5\n", "\ns = Stack(); s.push(5); s.push(10); s.pop(); s.po... |
80d386d898e9b3d1951da12fe87a61ad | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `find_median(data)` qui calcule la médiane de la liste. La médiane est la valeur du milieu dans une liste de nombres triés par ordre croissant. Si la liste a un nombre pair d'éléments, la médiane est la moyenne des deux valeu... | ["\nassert find_median([3, 1, 2, 4, 5]) == 3\n", "\nassert find_median([-10, 4, 6, 1000, 10, 20]) == 15.0\n", "\nassert find_median([]) == None\n", "\nassert find_median([1]) == 1\n", "\nassert find_median([1, 2]) == 1.5\n", "\nassert find_median([7, 3, 5, 9]) == 6.0\n", "\nassert find_median([1.5, 3.5, 2.5]) == 2.5\n"... |
ed5183bcf613b2c84dcbf3e144efa78c | [
{
"content": "On te donne un modèle d'apprentissage automatique sérialisé, entraîné sur un ensemble de données de fruits avec des points de données bruités et manquants. Ta tâche est d'implémenter une fonction `load_and_predict_fruit` qui charge le modèle et prédit le nom du fruit en fonction de ses caractérist... | ["\nassert load_and_predict_fruit('fruit_classifier.pkl', [2.2, 3.3, 4.4]) in ['apple', 'banana', 'orange', 'grape']\n", "\nassert load_and_predict_fruit('fruit_classifier.pkl', [None, None, None]) in ['apple', 'banana', 'orange', 'grape']\n", "\nassert load_and_predict_fruit('fruit_classifier.pkl', [1.1, 2.2, None]) i... |
da7ef6a5b6bf4fa960605ccc7779db17 | [
{
"content": "On te demande d'implémenter une fonction `calculate_score` qui calcule un score en fonction des valeurs de trois entiers `a`, `b` et `c`. La fonction doit également accepter deux paramètres optionnels `x` et `y` avec des valeurs par défaut de 1 et 2, respectivement. Les règles de calcul du score s... | ["\nassert calculate_score(2, 4, 6) == 11\n", "\nassert calculate_score(1, 3, 5) == -4\n", "\nassert calculate_score(0, 0, 0) == 5\n", "\nassert calculate_score(-1, 2, 3) == -1\n", "\nassert calculate_score(1, -2, 3) == -2\n", "\nassert calculate_score(1, 2, -3) == -3\n", "\nassert calculate_score(10, 20, 30, 123, 456)... |
c74cbf68cae9be0daa0309a5f4f5ae2e | [
{
"content": "On te donne une chaîne de caractères `input_string` et une chaîne de format `format_string`. La chaîne de format contient des espaces réservés pour différents types de données (`%s` pour chaîne de caractères, `%d` pour entier, `%i` pour entier signé, `%f` pour nombre à virgule flottante) et peut i... | ["\nassert parse_input('Hello 42 3.14 test', 'Hello %d %f test') == {'42': '42', '3.14': '3.14'}\n", "\nassert parse_input('Name: Alice Age: 30', 'Name: %s Age: %d') == {'Alice': 'Alice', '30': '30'}\n", "\nassert parse_input('Price: 19.99', 'Price: %f') == {'19.99': '19.99'}\n", "\nassert parse_input('Count: -5', 'Cou... |
87bb265a2fa4507454ce27a77afd2d26 | [
{
"content": "On te donne une image représentée comme une liste 2D d'entiers, où chaque entier représente l'intensité de la couleur d'un pixel. Ta tâche est d'implémenter la fonction `scale_image_to_fit` qui redimensionne l'image pour qu'elle s'adapte à une taille cible spécifiée tout en conservant le rapport h... | ["\nassert scale_image_to_fit([[255]], (1, 1)) == [[255]]\n", "\nassert scale_image_to_fit([[255, 0], [0, 255]], (2, 2)) == [[255, 0], [0, 255]]\n", "\nassert scale_image_to_fit([[255, 0], [0, 255]], (1, 1)) == [[127]]\n", "\nassert scale_image_to_fit([[255, 0], [0, 255]], (4, 4)) == [[255, 127, 127, 0], [127, 63, 63, ... |
7c7bc06e4d2c696e306022c758377718 | [
{
"content": "On te donne un fichier texte nommé `input.txt`. Ta tâche est d'écrire un programme qui lit ce fichier et calcule la fréquence de chaque mot, en ignorant la ponctuation et la casse. La sortie doit être un dictionnaire où les clés sont les mots et les valeurs sont leurs fréquences respectives.\n\n**... | ["\nassert count_word_frequencies('test1.txt') == {'hello': 1, 'world': 1}\n", "\nassert count_word_frequencies('test2.txt') == {'this': 2, 'is': 2, 'a': 2, 'test': 2}\n", "\nassert count_word_frequencies('test3.txt') == {'python': 1, 'programming': 1, 'language': 1}\n", "\nassert count_word_frequencies('test4.txt') ==... |
624f85ac04ab7533e56a67c50cc1c73f | [
{
"content": "On te donne un DataFrame pandas `df` représentant un catalogue de fruits. Le DataFrame se compose de trois colonnes : `fruit_name`, `fruit_type` et `binary_fruit_type`. La colonne `fruit_type` spécifie le type de fruit (par exemple, \"apple\", \"banana\", \"orange\"), et la colonne `binary_fruit_t... | ["\nassert get_fruit_dicts(pd.DataFrame({'fruit_name': ['apple', 'banana'], 'fruit_type': ['sweet', 'sour'], 'binary_fruit_type': ['sweet', 'sour']})) == ({'sweet': 0, 'sour': 1}, {0: 'sweet', 1: 'sour'}, {'sweet': 0, 'sour': 1}, {0: 'sweet', 1: 'sour'})\n", "\nassert get_fruit_dicts(pd.DataFrame({'fruit_name': ['apple... |
c182daca665e5378a5b37f54b6e8b90c | [
{
"content": "On te demande d'implémenter une fonction `convert_units` qui effectue des conversions de température entre Celsius et Fahrenheit. La fonction doit accepter deux paramètres : une valeur de température (`temperature`) et l'unité de la température d'entrée (`unit`). Le paramètre `unit` sera une chaîn... | ["\nassert convert_units(0, 'C') == 32.0\n", "\nassert convert_units(100, 'C') == 212.0\n", "\nassert convert_units(32, 'F') == 0.0\n", "\nassert convert_units(212, 'F') == 100.0\n", "\nassert convert_units(-40, 'C') == -40.0\n", "\nassert convert_units(-40, 'F') == -40.0\n", "\nassert convert_units(37, 'C') == 98.6\n"... |
47d3b500b0bb50c7f83b608a9949ff0b | [
{
"content": "On te demande de créer un carré magique de taille `n x n` où chaque cellule contient un entier distinct de `1` à `n^2`. Un carré magique est défini comme une grille carrée où la somme des entiers de chaque ligne, colonne et des deux diagonales est égale à une constante connue sous le nom de « cons... | ["\nassert calculate_magic_constant(3) == 15\n", "\nassert calculate_magic_constant(5) == 65\n", "\nassert calculate_magic_constant(7) == 175\n", "\nassert magic_square_sum(3) == [[8, 1, 6], [3, 5, 7], [4, 9, 2]]\n", "\nassert magic_square_sum(3)[0][0] == 8\n", "\nassert magic_square_sum(3)[1][1] == 5\n", "\nassert mag... |
8b69356125c2598a5f20010dc56f6a8f | [
{
"content": "On te demande d'implémenter une fonction `validate_email` qui détermine si une chaîne de caractères donnée est une adresse e-mail valide. La fonction doit utiliser des expressions régulières pour effectuer la validation. Prends en compte les cas limites tels que les adresses e-mail internationalis... | ["\nassert validate_email(\"test.email+alex@leetcode.com\") == True\n", "\nassert validate_email(\"user@domain.co\") == True\n", "\nassert validate_email(\"user.name@domain.com\") == True\n", "\nassert validate_email(\"user@sub.domain.com\") == True\n", "\nassert validate_email(\"user@domain\") == False\n", "\nassert v... |
c2cc4ef33d43f715e79240fa3ec57235 | [
{
"content": "On te donne une liste d'entiers `digits` représentant un entier positif dans l'ordre inverse en utilisant un système numérique modifié en base 5. Chaque chiffre de la liste peut être l'un des éléments {0, 1, 2, 3, 4}. Par exemple, la liste `[1, 0, 3]` correspond à l'entier `301` en base 5, qui est... | ["\nassert add_one_to_base5([0]) == [1]\n", "\nassert add_one_to_base5([4]) == [1, 0]\n", "\nassert add_one_to_base5([2, 3]) == [3, 3]\n", "\nassert add_one_to_base5([4, 4]) == [1, 0, 0]\n", "\nassert add_one_to_base5([1, 0, 3]) == [2, 0, 3]\n", "\nassert add_one_to_base5([3, 0, 4]) == [4, 0, 4]\n", "\nassert add_one_t... |
fd1d3d310e13998189663e6d545b3e53 | [
{
"content": "On te donne une liste de dictionnaires, `employees`, où chaque dictionnaire représente un employé avec les clés suivantes : `'id'`, `'name'`, et `'department'`. Ta tâche est d'implémenter une fonction `get_employee_by_id(employees, employee_id)` qui prend en paramètres la liste des employés et un ... | ["\nassert get_employee_by_id([{'id': 1, 'name': 'Alice', 'department': 'HR'}, {'id': 2, 'name': 'Bob', 'department': 'IT'}], 1) == {'id': 1, 'name': 'Alice', 'department': 'HR'}\n", "\nassert get_employee_by_id([{'id': 1, 'name': 'Alice', 'department': 'HR'}, {'id': 2, 'name': 'Bob', 'department': 'IT'}], 3) == None\n... |
5106a0a13c2cc4df8afb5825106059e7 | [
{
"content": "On te donne un tableau `arr` composé de `n` entiers. Ta tâche est de mettre en œuvre une fonction `find_min_max` qui renvoie un tuple `(min_value, max_value)`. La fonction doit considérer uniquement les entiers uniques du tableau pour déterminer les valeurs minimale et maximale.\n\n**Entrée :**\n-... | ["\nassert find_min_max([1, 2, 2, 3, 4]) == (1, 4)\n", "\nassert find_min_max([5, 5, 5, 5]) == (5, 5)\n", "\nassert find_min_max([10, 20, 30, 40, 50]) == (10, 50)\n", "\nassert find_min_max([-1, -2, -3, -4, -5]) == (-5, -1)\n", "\nassert find_min_max([100]) == (100, 100)\n", "\nassert find_min_max([0, 0, 0, 0, 0]) == (... |
fa9aa7627534f399427805cf87d411b3 | [
{
"content": "On te donne une chaîne de caractères `text` et une liste de `stop_words`. Ta tâche est d'implémenter une fonction `filter_words` qui supprime toutes les occurrences des mots vides du texte, sans tenir compte de la casse. La fonction doit renvoyer la chaîne de caractères résultante avec les mots re... | ["\nassert filter_words(\"The quick brown fox jumps over the lazy dog\", [\"the\", \"over\"]) == \"quick brown fox jumps lazy dog\"\n", "\nassert filter_words(\"Hello world\", [\"hello\"]) == \"world\"\n", "\nassert filter_words(\"Python is great\", [\"is\"]) == \"python great\"\n", "\nassert filter_words(\"Stop words ... |
14916ebc8f005ff6ae48f6e82a4be169 | [
{
"content": "On te donne une chaîne de caractères `text` contenant une séquence de mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `analyze_text` qui traite ce texte et renvoie un dictionnaire avec la fréquence de chaque mot, en excluant les mots vides courants. La fonction doit trai... | ["\nassert analyze_text(\"This is a sample text, and this text is for testing the analyze_text function.\") == {'sample': 1, 'text': 2, 'testing': 1, 'analyze_text': 1, 'function': 1}\n", "\nassert analyze_text(\"Hello, world! Hello, Universe.\") == {'hello': 2, 'world': 1, 'universe': 1}\n", "\nassert analyze_text(\"P... |
f398496cfc366a82f296fecc45105e89 | [
{
"content": "On te donne deux matrices carrées, `matrix1` et `matrix2`, chacune de taille `n x n`. Ta tâche est de mettre en œuvre une fonction `matrix_addition` qui calcule la somme élément par élément de ces deux matrices et renvoie la matrice résultante. Les matrices sont représentées sous forme de listes i... | ["\nassert matrix_addition([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == [[6, 8], [10, 12]]\n", "\nassert matrix_addition([[0, 0], [0, 0]], [[0, 0], [0, 0]]) == [[0, 0], [0, 0]]\n", "\nassert matrix_addition([[1, -1], [-1, 1]], [[-1, 1], [1, -1]]) == [[0, 0], [0, 0]]\n", "\nassert matrix_addition([[10, 20], [30, 40]], [[50, 6... |
5e78e509796c684a56e25c4f3c5e04fb | [
{
"content": "On te donne une liste d'événements, où chaque événement est représenté comme un dictionnaire avec les clés suivantes : 'event_id', 'timestamp' et 'data'. Le 'timestamp' est un objet datetime, et 'data' est un dictionnaire contenant diverses métriques pour cet événement. De plus, on te fournit un d... | ["\nassert get_event_metrics([{'event_id': 1, 'timestamp': datetime(2023, 1, 1, 12, 0, 0), 'data': {}}], {'2023-01-01': 10}, 1) == 10\n", "\nassert get_event_metrics([{'event_id': 2, 'timestamp': datetime(2023, 1, 2, 12, 0, 0), 'data': {}}], {'2023-01-01': 10}, 2) == 10\n", "\nassert get_event_metrics([{'event_id': 3, ... |
a1d583cc21b1a6d1facb472863eb308c | [
{
"content": "On te demande d'implémenter une calculatrice simple qui prend en charge les opérations arithmétiques de base : l'addition, la soustraction, la multiplication et la division. Ton programme doit lire deux nombres et un opérateur à partir de l'entrée, effectuer l'opération correspondante et afficher ... | ["\nassert simple_calculator(10, 5, '+') == 15\n", "\nassert simple_calculator(10, 5, '-') == 5\n", "\nassert simple_calculator(10, 5, '*') == 50\n", "\nassert simple_calculator(10, 5, '/') == 2.0\n", "\nassert simple_calculator(10, 0, '/') == \"Error: Division by zero is not allowed.\"\n", "\nassert simple_calculator(... |
c8797dd249bc08ff19bc09f619f2b7ae | [
{
"content": "On te demande d'analyser une base de données de ventes pour identifier les produits les plus vendus dans une catégorie spécifique. La base de données se compose de deux tables : `products` et `orders`. La table `products` comprend les colonnes `product_id`, `product_name` et `category`. La table `... | ["\nassert get_top_selling_products(dbc, 'Electronics') == [('ProductA', 150), ('ProductB', 100), ('ProductC', 50)]\n", "\nassert get_top_selling_products(dbc, 'Clothing') == [('ProductX', 200), ('ProductY', 150), ('ProductZ', 100)]\n", "\nassert get_top_selling_products(dbc, 'Books') == [('Book1', 300), ('Book2', 250)... |
26275ef407f302997b690833dd009e8c | [
{
"content": "Tu participes à un défi de vérification de l'intégrité des données. Ta tâche est d'écrire un programme qui calcule le hachage SHA-256 de deux fichiers et de vérifier s'ils sont identiques. Le programme doit être suffisamment efficace pour gérer des fichiers jusqu'à 10 Go sans charger l'intégralité... | ["\nassert sha256_checksum(\"test_files/empty_file.txt\") == \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"\n", "\nassert sha256_checksum(\"test_files/single_char_file.txt\") == \"9e107d9d372bb6826bd81d3542a419d6e277d4d731479577a1e63c1f27b8e47e\"\n", "\nassert sha256_checksum(\"test_files/small_fi... |
1515230be3dc81e25fa409f1b905e9cd | [
{
"content": "On te donne une liste d'adresses e-mail. Ta tâche est d'implémenter une fonction `remove_duplicates(emails)` qui traite cette liste pour éliminer toute entrée en double, en traitant les adresses e-mail de manière insensible à la casse. La fonction doit renvoyer une liste d'adresses e-mail uniques.... | ["\nassert remove_duplicates([\"example@example.com\", \"Example@Example.com\"]) == [\"example@example.com\"]\n", "\nassert remove_duplicates([\"test1@test.com\", \"test2@test.com\", \"test1@test.com\"]) == [\"test1@test.com\", \"test2@test.com\"]\n", "\nassert remove_duplicates([\"a@b.com\", \"B@a.com\", \"c@d.com\"])... |
67a02576b4728b1646340d8977b2fa4a | [
{
"content": "On te donne une liste de valeurs d'indice de végétation normalisé (NDVI) représentant différentes régions. Ta tâche est de catégoriser ces régions en fonction de la santé de leur végétation en utilisant les critères suivants :\n\n- \"Pas de végétation\" pour les valeurs de NDVI inférieures à 0.1.\... | ["\nassert categorize_vegetation([0.05]) == [\"No Vegetation\", 0.05]\n", "\nassert categorize_vegetation([0.15]) == [\"Sparse Vegetation\", 0.15]\n", "\nassert categorize_vegetation([0.3]) == [\"Moderate Vegetation\", 0.3]\n", "\nassert categorize_vegetation([0.5]) == [\"Dense Vegetation\", 0.5]\n", "\nassert categori... |
b2664be0de94793ebb623f12d1685f8b | [
{
"content": "On te donne une fonction quadratique définie par l'équation \\( f(x) = ax^2 + bx + c \\). Ta tâche est de calculer l'aire sous cette courbe entre deux points \\( x = l \\) et \\( x = r \\). L'aire doit être calculée en utilisant l'intégrale définie de la fonction de \\( l \\) à \\( r \\).\n\n**Ent... | ["\nassert area_under_curve(1, 0, 0, 0, 1) == 1/3\n", "\nassert area_under_curve(1, 2, 1, 0, 1) == 4/3\n", "\nassert area_under_curve(0, 0, 0, 0, 1) == 0\n", "\nassert area_under_curve(0, 1, 0, 0, 1) == 1/2\n", "\nassert area_under_curve(0, 0, 1, 0, 1) == 1\n", "\nassert area_under_curve(1, -3, 2, 0, 2) == 0\n", "\nass... |
67c9f5aeb645134de001031dae399a3e | [
{
"content": "Tu mènes une expérience scientifique et as collecté une série de mesures, chacune représentée comme un flottant dans l'unité keV/um (kiloelectronvolts par micromètre). Ces mesures sont stockées dans une liste. On te fournit également une fonction `measurement_func` qui prend une liste de flottants... | ["\nassert calculate_representative_value([1.0, 2.0, 3.0], lambda x: sum(x)) == 6.0\n", "\nassert calculate_representative_value([1.0, 2.0, 3.0], lambda x: sum(x), [0, 2]) == 4.0\n", "\nassert calculate_representative_value([1.0, 2.0, 3.0], lambda x: max(x)) == 3.0\n", "\nassert calculate_representative_value([1.0, 2.0... |
1b52759a6a7f0d6d5b3c7f7a3c6dc684 | [
{
"content": "Tu développes une simulation pour une animation de pluie sur un écran d'une hauteur de `screen_h` pixels. Chaque goutte de pluie est représentée comme une ligne verticale d'une hauteur de `rain_height` pixels. Les gouttes de pluie tombent du haut de l'écran vers le bas. Ton objectif est de détermi... | ["\nassert calculate_raindrop_rows(1000, 100, 5) == 1\n", "\nassert calculate_raindrop_rows(500, 50, 3) == 2\n", "\nassert calculate_raindrop_rows(300, 100, 2) == 1\n", "\nassert calculate_raindrop_rows(200, 100, 1) == 1\n", "\nassert calculate_raindrop_rows(200, 100, 2) == 0\n", "\nassert calculate_raindrop_rows(100, ... |
0e04e1504504000e81f999531804ae1d | [
{
"content": "On te demande d'implémenter une fonction `convert_temperature` qui gère jusqu'à 100 000 requêtes de conversion de température simultanées. Chaque requête est un tuple constitué d'une température entière `temperature` en Fahrenheit et d'un entier optionnel `mode`. Le paramètre `mode` spécifie le fo... | ["\nassert convert_temperature([(32, 1)]) == [0.0]\n", "\nassert convert_temperature([(212, 2)]) == [373.15]\n", "\nassert convert_temperature([(100, None)]) == (37.77777777777778, 310.92777777777775)\n", "\nassert convert_temperature([(0, 3)]) == (37.77777777777778, 310.92777777777775)\n", "\nassert convert_temperatur... |
545158fbd426fccb4071b3b0fc423d23 | [
{
"content": "On te donne une liste de relevés de puissance pour un cycliste pendant une course. Chaque relevé est un nombre à virgule flottante représentant la puissance de sortie à un moment précis. Ta tâche est de calculer l'Indice de Rythme (Pacing Index), qui mesure la constance de la puissance de sortie d... | ["\nassert pacing_index([100.0, 100.0, 100.0, 100.0, 100.0]) == 1.0\n", "\nassert pacing_index([120.0, 150.0, 130.0, 160.0, 110.0]) == 1.07\n", "\nassert pacing_index([200.0, 200.0, 200.0, 200.0, 200.0, 200.0]) == 1.0\n", "\nassert pacing_index([150.0, 150.0, 150.0, 150.0, 150.0, 150.0, 150.0]) == 1.0\n", "\nassert pac... |
3f161c8bc83aa4080b2be4268941baba | [
{
"content": "On te demande d'implémenter une fonction `is_valid_url` qui détermine la validité d'une URL donnée en fonction de critères spécifiques. Une URL est considérée comme valide si elle respecte les règles suivantes :\n- Elle commence par le protocole `http` ou `https`.\n- Elle inclut un nom de domaine ... | ["\nassert is_valid_url(\"http://www.example.com\") == True\n", "\nassert is_valid_url(\"https://subdomain.example.co.uk/path/to/resource?query=string#fragment\") == True\n", "\nassert is_valid_url(\"http://example\") == False\n", "\nassert is_valid_url(\"ftp://example.com\") == False\n", "\nassert is_valid_url(\"www.e... |
c36e653a476023711907ccc97e24420d | [
{
"content": "On te donne un tableau d'entiers, `nums`. Ta tâche est de créer un nouveau tableau, `squares`, où chaque élément est le carré de l'élément correspondant dans `nums`. Cependant, si l'élément est un nombre premier, il doit être remplacé par son cube à la place. Les éléments dans `squares` doivent êt... | ["\nassert zigzag_sorted_squares([-4, -2, 0, 2, 4]) == [0, 4, 4, 16, 16]\n", "\nassert zigzag_sorted_squares([-3, -2, -1, 0, 1, 2, 3]) == [0, 1, 1, 4, 4, 9, 9]\n", "\nassert zigzag_sorted_squares([-5, -3, -1, 2, 4, 6]) == [1, 4, 4, 16, 16, 36]\n", "\nassert zigzag_sorted_squares([1, 2, 3, 5, 7, 11]) == [1, 8, 9, 125, 4... |
cf60ffb21df9f8f37fd266d9b037b031 | [
{
"content": "On te donne une liste de mots, où chaque mot est représenté comme un tuple contenant la forme brute du mot et son lakshana associé (un attribut spécial). Implémente une fonction `word_merging` qui effectue une \"fusion de mots\" sur cette liste de mots.\n\nLa fusion de mots combine deux mots consé... | ["\nassert word_merging([(\"word1\", \"lakshana1\"), (\"word2\", \"lakshana2\"), (\"word3\", \"lakshana3\")], 1) == [(\"word1\", \"lakshana1\"), (\"word2\", \"lakshana2_word3\")]\n", "\nassert word_merging([(\"word1\", \"lakshana1\"), (\"word2\", \"lakshana2\"), (\"longword\", \"lakshana3\")], 1) == [(\"word1\", \"laks... |
57227f941770daf6b100e023f570ffaa | [
{
"content": "On te demande d'implémenter une fonction `get_n_colors(n=None)` qui renvoie un dictionnaire de `n` couleurs parmi un ensemble prédéfini de couleurs. Les clés du dictionnaire doivent être les noms des couleurs et les valeurs leurs codes de couleur hexadécimaux correspondants. Si `n` n'est pas fourn... | ["\nassert get_n_colors() == {'emerald': '#008000', 'navy': '#000080', 'teal': '#008080', 'maroon': '#800000', 'purple': '#800080', 'olive': '#808000', 'silver': '#C0C0C0', 'fuchsia': '#FF00FF', 'lime': '#00FF00', 'aqua': '#00FFFF'}\n", "\nassert get_n_colors(1) == {'silver': '#C0C0C0'}\n", "\nassert get_n_colors(2) ==... |
da5072f45f61fba58bc3fa09070db1b1 | [
{
"content": "On te demande d'implémenter une classe `Book` (Livre) et une classe `Library` (Bibliothèque) en Python. La classe `Book` doit avoir les attributs suivants : `title` (titre), `author` (auteur), `isbn`, `publication_year` (année de publication) et `availability` (disponibilité) (valeur par défaut : ... | ["\nassert book1.title == \"1984\"\n", "\nassert book2.author == \"Harper Lee\"\n", "\nassert book1.isbn == \"9780451524935\"\n", "\nassert book2.publication_year == 1960\n", "\nassert book1.availability == True\n", "\nassert len(library.books) == 2\n", "\nbook1.borrow_book(); assert book1.availability == False\n", "\n... |
85c1d6323d6ecc02e452a2b6c4a807f8 | [
{
"content": "On te demande de gérer un système d'inventaire d'entrepôt. Étant donné un dictionnaire `products_dict` où chaque clé est le nom d'un produit et chaque valeur est la quantité correspondante de ce produit en stock, ton objectif est d'identifier le ou les produits ayant la quantité la plus faible. Si... | ["\nassert find_min_quantity_products({'apple': 30, 'banana': 10, 'orange': 20, 'grape': 10}) == ['banana', 'grape']\n", "\nassert find_min_quantity_products({'apple': 5, 'banana': 5, 'orange': 5}) == ['apple', 'banana', 'orange']\n", "\nassert find_min_quantity_products({'apple': 100}) == ['apple']\n", "\nassert find_... |
052982ece8cfdbc18b7deb12ad836d7b | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'écrire une fonction Python qui identifie et renvoie les éléments communs entre ces deux listes sous forme d'un ensemble. La fonction doit être optimisée pour la performance, en particulier lorsqu'il s'agit de grandes listes.\n\n... | ["\nassert find_common_elements([1, 2, 3], [2, 3, 4]) == {2, 3}\n", "\nassert find_common_elements(['a', 'b', 'c'], ['b', 'c', 'd']) == {'b', 'c'}\n", "\nassert find_common_elements([10, 20, 30], [40, 50, 60]) == set()\n", "\nassert find_common_elements([], [1, 2, 3]) == set()\n", "\nassert find_common_elements([1, 2, ... |
5b352a539cc244f57d3aeed05b418361 | [
{
"content": "On te donne une chaîne de caractères constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui compte le nombre de mots palindromes dans la chaîne. Un mot est considéré comme un palindrome s'il se lit de la même manière à l'endroit et à l'envers. On suppose que la chaîne d... | ["\nassert count_palindromes(\"madam racecar apple level\") == 4\n", "\nassert count_palindromes(\"hello world\") == 0\n", "\nassert count_palindromes(\"level deed civic rotor\") == 4\n", "\nassert count_palindromes(\"a man a plan a canal panama\") == 0\n", "\nassert count_palindromes(\"radar deed\") == 2\n", "\nassert... |
3bcc2b95dbd6f71c494b3e94ff27b0ea | [
{
"content": "On te donne une grille de taille `rows x cols`. Ta tâche est de trouver le nombre de chemins uniques du coin supérieur gauche (0, 0) au coin inférieur droit (rows-1, cols-1). Tu ne peux te déplacer que vers la droite ou vers le bas à tout moment. Cependant, certaines cellules de la grille sont blo... | ["\nassert count_unique_paths_with_obstacles(3, 3, [(1, 1)]) == 2\n", "\nassert count_unique_paths_with_obstacles(3, 3, [(0, 1), (1, 0)]) == 0\n", "\nassert count_unique_paths_with_obstacles(3, 3, [(2, 2)]) == 2\n", "\nassert count_unique_paths_with_obstacles(3, 3, [(0, 0)]) == 0\n", "\nassert count_unique_paths_with_o... |
0526bf519c8e3789ae89ef55cb86c9a5 | [
{
"content": "On te demande d'implémenter une fonction pour calculer la factorielle d'un entier non négatif `n` en utilisant une approche itérative. La factorielle d'un nombre `n`, notée `n!`, est le produit de tous les entiers positifs de 1 à `n`. Ta fonction doit s'appeler `factorial_iterative(n)` et doit lev... | ["\nassert factorial_iterative(0) == 1\n", "\nassert factorial_iterative(1) == 1\n", "\nassert factorial_iterative(5) == 120\n", "\nassert factorial_iterative(6) == 720\n", "\nassert factorial_iterative(10) == 3628800\n", "\nassert factorial_iterative(3) == 6\n", "\nassert factorial_iterative(7) == 5040\n", "\nassert f... |
3ca610227da0a1b6e74fb657ee212e55 | [
{
"content": "On te donne un fichier CSV nommé `users.csv` qui contient des informations sur les utilisateurs dans le format suivant : `name,age,email`. Ta tâche est d'écrire une fonction Python `read_user_info(filename)` qui lit ce fichier et renvoie un dictionnaire. Les clés du dictionnaire doivent être les a... | ["\nassert read_user_info(\"test.csv\") == {'test1@example.com': ('John Doe', 30), 'test2@example.com': ('Jane Smith', 25)}\n", "\nassert read_user_info(\"empty.csv\") == {}\n", "\nassert read_user_info(\"single_entry.csv\") == {'single@example.com': ('Alice Johnson', 45)}\n", "\nassert read_user_info(\"multiple_entrie... |
0c317c3b645e103de08d329394f3bf33 | [
{
"content": "Implémente une classe `Rectangle` en Python avec les spécifications suivantes :\n\n- **Attributs :**\n - `width` : Un entier représentant la largeur du rectangle.\n - `height` : Un entier représentant la hauteur du rectangle.\n\n- **Méthodes :**\n - `__init__(self, width, height)` : Initialise ... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).perimeter() == 20\n", "\nassert Rectangle(0, 0).area() == 0\n", "\nassert Rectangle(10, 2).perimeter() == 24\n", "\nassert Rectangle(7, 3).area() == 21\n", "\nassert Rectangle(1, 1).perimeter() == 4\n", "\nassert Rectangle(15, 10).area() == 150\n", "... |
3202c39126f8ac87f1f8ad6cd45245f7 | [
{
"content": "On te demande d'implémenter un algorithme efficace pour calculer la factorielle d'un entier non négatif 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 \\). Par définition, la factorielle ... | ["\nassert factorial(0) == 1\n", "\nassert factorial(1) == 1\n", "\nassert factorial(2) == 2\n", "\nassert factorial(3) == 6\n", "\nassert factorial(4) == 24\n", "\nassert factorial(5) == 120\n", "\nassert factorial(6) == 720\n", "\nassert factorial(10) == 3628800\n", "\nassert factorial(15) == 1307674368000\n", "\nass... |
9ea59a5f752c7209b7e3c73d4fe7edc1 | [
{
"content": "On te donne une liste de termes académiques au format \"Semestre Année\", où Semestre est l'un de \"Spring\", \"Summer\" ou \"Fall\", et Année est un entier à quatre chiffres représentant l'année. Ta tâche est d'écrire une fonction qui attribue une valeur numérique unique à chaque terme, de sorte ... | ["\nassert assign_term_values([\"Spring 2022\"]) == [(\"Spring 2022\", 6066)]\n", "\nassert assign_term_values([\"Summer 2022\"]) == [(\"Summer 2022\", 6067)]\n", "\nassert assign_term_values([\"Fall 2022\"]) == [(\"Fall 2022\", 6068)]\n", "\nassert assign_term_values([\"Spring 2023\"]) == [(\"Spring 2023\", 6069)]\n",... |
7a68d2ca7959aa88efad93b7caea37d8 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver le plus grand produit qui peut être obtenu en multipliant trois entiers quelconques de la liste. Tu n'es pas autorisé à trier la liste ou à utiliser des fonctions intégrées qui trient la liste.\n\n**Entrée :**\n- Une liste d'entiers `nums` o... | ["\nassert largest_product_of_three([1, 10, 2, 6, 5, 3]) == 300\n", "\nassert largest_product_of_three([-10, -10, 5, 2]) == 500\n", "\nassert largest_product_of_three([1, 2, 3]) == 6\n", "\nassert largest_product_of_three([-1, -2, -3, -4]) == -6\n", "\nassert largest_product_of_three([0, 2, 3, 5]) == 30\n", "\nassert l... |
1d6e6d5987f3cb5ea7697530a7dfa38e | [
{
"content": "On te donne une chaîne de caractères `metadataLine` représentant les métadonnées d'un morceau de musique. La chaîne est formatée comme \"Metadata for track: <track_title>\", où `<track_title>` est le titre du morceau qui peut inclure des caractères spéciaux et peut être entouré de guillemets doubl... | ["\nassert get_track_title_from_metadata_line(\"Metadata for track: Bohemian Rhapsody\") == \"Bohemian Rhapsody\"\n", "\nassert get_track_title_from_metadata_line(\"Metadata for track: Stairway to Heaven\") == \"Stairway to Heaven\"\n", "\nassert get_track_title_from_metadata_line(\"Metadata for track: &My@Song#\") == ... |
1822a7fb360d04478ce8982a004ae88e | [
{
"content": "On te donne une liste de listes, où chaque liste interne contient des entiers. Ta tâche est d'écrire une fonction Python nommée `list_product` qui calcule le produit des éléments de chaque liste interne et renvoie une nouvelle liste contenant ces produits.\n\n**Entrée :**\n- Une liste de listes, o... | ["\nassert list_product([[1, 2, 3], [4, 5, 6], [7, 8]]) == [6, 120, 56]\n", "\nassert list_product([[1], [2], [3]]) == [1, 2, 3]\n", "\nassert list_product([[0, 1, 2], [3, 4, 5]]) == [0, 60]\n", "\nassert list_product([[10, 20], [30, 40], [50]]) == [200, 1200, 50]\n", "\nassert list_product([[-1, -2, -3], [4, 5, 6]]) =... |
e97b740f75886f9ed567e4d38106d692 | [
{
"content": "On te donne une liste de mots et une longueur minimale. Ta tâche est de mettre en œuvre une fonction `filter_by_length` qui filtre les mots plus courts que la longueur minimale spécifiée. La fonction doit renvoyer une nouvelle liste contenant uniquement les mots qui respectent ou dépassent l'exige... | ["\nassert filter_by_length([\"apple\", \"banana\", \"cherry\", \"date\"], 5) == [\"apple\", \"banana\", \"cherry\"]\n", "\nassert filter_by_length([\"dog\", \"cat\", \"elephant\", \"fox\"], 3) == [\"dog\", \"cat\", \"elephant\", \"fox\"]\n", "\nassert filter_by_length([\"hello\", \"world\", \"hi\", \"bye\"], 2) == [\"... |
1b3e7390ea89cafa49d51a7ef8c4269b | [
{
"content": "On te demande d'implémenter une classe `EmailManager` qui prend en charge les fonctionnalités de base de gestion des e-mails. La classe doit avoir les méthodes suivantes :\n\n- `add_email(self, recipient, subject, body)` : Cette méthode doit ajouter un e-mail à la boîte de réception du gestionnair... | ["\nassert EmailManager().list_emails() == []\n", "\nassert EmailManager().add_email(\"test@example.com\", \"Hello\", \"This is a test email.\") is None\n", "\nassert EmailManager().list_emails() == []\n", "\nmanager = EmailManager()\nmanager.add_email(\"test@example.com\", \"Hello\", \"This is a test email.\")\nassert... |
a7179c988a3f986cb8824d4529664d59 | [
{
"content": "On te donne une chaîne de caractères `s` constituée d'entiers séparés par des virgules. Ta tâche est d'écrire une fonction qui convertit cette chaîne en une liste d'entiers. Si la chaîne est vide ou ne contient que des espaces, la fonction doit renvoyer une liste vide.\n\n**Entrée :**\n- Une seule... | ["\nassert string_to_int_list(\"1,2,3,4,5\") == [1, 2, 3, 4, 5]\n", "\nassert string_to_int_list(\" 10, 20, 30, 40, 50 \") == [10, 20, 30, 40, 50]\n", "\nassert string_to_int_list(\"100, 200, 300\") == [100, 200, 300]\n", "\nassert string_to_int_list(\" \") == []\n", "\nassert string_to_int_list(\"\") == []\n", "\n... |
c08605968ea4b6d7bb597c776483564b | [
{
"content": "On te demande d'implémenter une classe `SocialMediaPost` en Python. La classe doit prendre en charge les opérations suivantes :\n- Initialiser un message avec un auteur et un contenu.\n- Ajouter un commentaire au message.\n- Incrémenter le nombre de \"j'aime\" pour le message.\n- Afficher les déta... | ["\nassert SocialMediaPost(\"Alice\", \"Hello\").author == \"Alice\"\n", "\nassert SocialMediaPost(\"Bob\", \"Hi\").content == \"Hi\"\n", "\nassert SocialMediaPost(\"Charlie\", \"Test\").likes == 0\n", "\nassert SocialMediaPost(\"David\", \"Post\").comments == []\n", "\npost = SocialMediaPost(\"Eve\", \"Greetings\")\np... |
c43ad238da3cc00d372cb66bf82b1256 | [
{
"content": "On te donne une liste d'entiers positifs. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste où chaque entier est remplacé par ses chiffres dans l'ordre inverse. Par exemple, si la liste d'entrée est `[123, 456, 789]`, la sortie doit être `[321, 654, 987]`.\n\n**Exemple d'entrée... | ["\nassert reverse_digits([123, 456, 789]) == [321, 654, 987]\n", "\nassert reverse_digits([100, 200, 300]) == [1, 2, 3]\n", "\nassert reverse_digits([0, 0, 0]) == [0, 0, 0]\n", "\nassert reverse_digits([1, 2, 3]) == [1, 2, 3]\n", "\nassert reverse_digits([111, 222, 333]) == [111, 222, 333]\n", "\nassert reverse_digits... |
52cfeddd1a44b8bbf006dcf87a663afd | [
{
"content": "On te donne un ensemble de données représentant diverses villes, chacune avec un identifiant unique et des attributs incluant la population totale qui ne s'identifie pas comme blanche (`pop_not_white`), la population totale (`total_pop`) et un dictionnaire de quartiers (`neighborhoods`). Chaque qu... | ["\nassert calculate_segregation_index([{\"city\": \"A\", \"pop_not_white\": 100, \"total_pop\": 200, \"neighborhoods\": {\"N1\": {\"pop_not_white\": 50, \"total_pop\": 100}, \"N2\": {\"pop_not_white\": 50, \"total_pop\": 100}}}]) == [0.5]\n", "\nassert calculate_segregation_index([{\"city\": \"B\", \"pop_not_white\": ... |
0f89bb0be45453e01b108d0413401d53 | [
{
"content": "On te donne un tableau d'entiers `arr` et une somme cible `target`. Ta tâche est de trouver le plus long sous-tableau contigu dans `arr` dont la somme est égale à `target`. S'il existe plusieurs sous-tableaux de longueur maximale, retourne l'un d'entre eux. S'il n'existe pas de tel sous-tableau, r... | ["\nassert longest_subarray_with_sum([1, 4, 20, 3, 10, 5], 33) == [1, 4, 20]\n", "\nassert longest_subarray_with_sum([1, 4, 20, 3, 10, 5], 50) == []\n", "\nassert longest_subarray_with_sum([10, 2, -2, -20, 10], -10) == [10, 2, -2, -20]\n", "\nassert longest_subarray_with_sum([1, 4, 20, 3, 10, 5], 3) == [1, 4, 20, 3, 10... |
b7091f72e794caf8dbb3fb6497fe5a9a | [
{
"content": "On te donne une liste d'horodatages au format \"AAAA-MM-JJ HH:MM:SS\". Ta tâche est d'écrire une fonction qui convertit ces horodatages en nombres de jours juliens (JDN) sous forme de nombres à virgule flottante, avec une précision à la seconde. La fonction doit gérer les horodatages sans informat... | ["\nassert timestamp_to_julian_day_number([\"2023-01-01 00:00:00\"]) == [2459859.5]\n", "\nassert timestamp_to_julian_day_number([\"2000-01-01 00:00:00\"]) == [2451544.5]\n", "\nassert timestamp_to_julian_day_number([\"1970-01-01 00:00:00\"]) == [2440587.5]\n", "\nassert timestamp_to_julian_day_number([\"2023-12-31 23:... |
4a1e36090ff0eec32f00b5d98fab8156 | [
{
"content": "On te demande d'implémenter une fonction `compute_double_factorial` qui calcule le double factoriel d'un entier non négatif `n`. Le double factoriel d'un nombre `n` est défini comme le produit de tous les entiers de `n` à 1 qui ont la même parité (impaire ou paire) que `n`. Par exemple, le double ... | ["\nassert compute_double_factorial(0) == 1\n", "\nassert compute_double_factorial(1) == 1\n", "\nassert compute_double_factorial(2) == 2\n", "\nassert compute_double_factorial(3) == 3\n", "\nassert compute_double_factorial(4) == 8\n", "\nassert compute_double_factorial(5) == 15\n", "\nassert compute_double_factorial(6... |
de2fd3072ad4e8dd582ba39ad76f57de | [
{
"content": "On te donne une chaîne de caractères `S` et un dictionnaire `R` où chaque paire clé-valeur représente un caractère dans `S` et son caractère de remplacement correspondant. Ta tâche est de construire une nouvelle chaîne en remplaçant chaque caractère dans `S` par sa valeur mappée dans `R`. Si un ca... | ["\nassert replace_characters(\"hello world\", {\"h\": \"j\", \"o\": \"a\"}) == \"jella warld\"\n", "\nassert replace_characters(\"abc\", {\"a\": \"x\", \"b\": \"y\", \"c\": \"z\"}) == \"xyz\"\n", "\nassert replace_characters(\"python\", {\"p\": \"q\", \"y\": \"z\"}) == \"qthon\"\n", "\nassert replace_characters(\"123\... |
ec40841d29feb6de5eb8d5b82f7aaa2f | [
{
"content": "On te donne une liste de `n` villes dans un plan 2D, chacune représentée par ses coordonnées `(x, y)`. Ta tâche est de trouver toutes les paires uniques de villes qui sont exactement à `d` unités l'une de l'autre en distance euclidienne, en excluant les paires qui se trouvent sur une ligne horizon... | ["\nassert find_city_pairs([(0, 0), (3, 4), (-3, 4), (3, -4), (0, 5), (5, 0)], 5.0) == [((0, 0), (3, 4)), ((0, 0), (-3, 4)), ((0, 0), (3, -4)), ((3, 4), (-3, 4)), ((3, 4), (3, -4)), ((-3, 4), (3, -4))]\n", "\nassert find_city_pairs([(0, 0), (1, 1), (2, 2), (3, 3)], 1.41421356237) == []\n", "\nassert find_city_pairs([(0... |
8ed2824e94411821287ca8a0446d7b1b | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author` et `year`. Implémente des méthodes setter et getter pour chaque attribut. De plus, écris une fonction `sort_books` qui accepte une liste d'objets `Book` et renvoie une nouvelle ... | ["\nassert [book.get_year() for book in sort_books([Book(\"Book1\", \"Author1\", 2001), Book(\"Book2\", \"Author2\", 1999)])] == [1999, 2001]\n", "\nassert [book.get_title() for book in sort_books([Book(\"Book1\", \"Author1\", 2001), Book(\"Book2\", \"Author2\", 1999)])] == [\"Book2\", \"Book1\"]\n", "\nassert [book.ge... |
3a2e35a4c47164cf2ed316f739999f69 | [
{
"content": "On te donne une liste d'intervalles, où chaque intervalle est représenté comme une liste de deux entiers `[début, fin]`. Ta tâche est de fusionner tous les intervalles qui se chevauchent et de renvoyer une liste des intervalles fusionnés. Deux intervalles sont considérés comme se chevauchant s'ils... | ["\nassert merge_intervals([[1, 3], [2, 4], [6, 8], [5, 7]]) == [[1, 4], [5, 8]]\n", "\nassert merge_intervals([[1, 2], [3, 4], [5, 6]]) == [[1, 2], [3, 4], [5, 6]]\n", "\nassert merge_intervals([[1, 4], [4, 5]]) == [[1, 5]]\n", "\nassert merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]) == [[1, 6], [8, 10], [15, 18... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.