id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
d927dc28c59af8ddeee3b444f236262a | [
{
"content": "On te donne une liste de chaînes de caractères, où chaque chaîne est un nom de fichier formaté comme `<nom_de_l'échantillon>_<numéro_de_séquence>`. Ta tâche est de mettre en œuvre une fonction qui extrait et renvoie une liste de noms d'échantillons, en excluant les numéros de séquence. Les numéros... | ["\nassert extract_sample_names([\"sampleA_001\", \"sampleB_12\", \"sampleC_0\", \"sampleD_1001\"]) == [\"sampleA\", \"sampleB\", \"sampleC\", \"sampleD\"]\n", "\nassert extract_sample_names([\"test_1\", \"test_01\", \"test_001\"]) == [\"test\", \"test\", \"test\"]\n", "\nassert extract_sample_names([\"file_12345\", \"... |
f385b951e43b0e1fe2d0625156a3c752 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui renvoie une nouvelle liste contenant les carrés de chaque entier de la liste d'entrée. Implémente cette fonctionnalité en utilisant une compréhension de liste.\n\n**Exemple d'entrée :**\n```python\n[1, 2, 3, 4, 5]\n```\n\n... | ["\nassert squares([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]\n", "\nassert squares([-1, -2, -3, -4, -5]) == [1, 4, 9, 16, 25]\n", "\nassert squares([0, 1, 2, 3, 4]) == [0, 1, 4, 9, 16]\n", "\nassert squares([]) == []\n", "\nassert squares([10, 20, 30]) == [100, 400, 900]\n", "\nassert squares([1, 0, -1]) == [1, 0, 1]\n", "... |
c09a2fdf9e04fdc4ff1094ea7597cb8c | [
{
"content": "On te demande d'implémenter une classe `Product` pour gérer l'inventaire d'un magasin. La classe doit encapsuler les propriétés d'un produit : `name`, `price` et `quantity`. Implémente les méthodes suivantes :\n\n- `add_stock(amount)` : Augmente le stock du montant spécifié `amount`. Assure-toi qu... | ["\nassert Product(\"Laptop\", 1000, 5).get_total_value() == 5000\n", "\nassert Product(\"Mouse\", 25, 10).get_total_value() == 250\n", "\nassert Product(\"Keyboard\", 50, 0).get_total_value() == 0\n", "\nassert Product(\"Monitor\", 150, 3).add_stock(2) or Product(\"Monitor\", 150, 3).quantity == 5\n", "\nassert Produc... |
149fc8380e66dcdb80257f8ecdb7b2a2 | [
{
"content": "On te donne un fichier nommé `words.txt` contenant des mots et leurs synonymes. Chaque ligne du fichier consiste en un mot suivi de ses synonymes, séparés par un caractère de tabulation (`\\t`). Les synonymes de chaque mot sont séparés par des espaces. Ta tâche est d'écrire une fonction `create_wo... | ["\nassert create_word_map(\"test1.txt\") == {\"apple\": [\"banana\", \"cherry\"], \"dog\": [\"elephant\", \"fox\"]}\n", "\nassert create_word_map(\"test2.txt\") == {\"cat\": [\"dog\", \"elephant\"], \"fish\": [\"goat\", \"horse\"]}\n", "\nassert create_word_map(\"test3.txt\") == {\"ant\": [\"bee\", \"cow\"], \"bat\": ... |
e63232cd81f50f6000fa34ad6f71bf21 | [
{
"content": "On te donne une chaîne de caractères `text` contenant des mots séparés par des espaces. Ta tâche est de mettre en œuvre une fonction `word_frequency` qui renvoie un dictionnaire avec la fréquence de chaque mot unique dans la chaîne. La fonction doit ignorer la ponctuation et traiter les mots sans ... | ["\nassert word_frequency(\"Hello, world! Hello, universe. Universe, hello.\") == {'hello': 3, 'world': 1, 'universe': 2}\n", "\nassert word_frequency(\"Python is great. Python is fun.\") == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert word_frequency(\"A quick brown fox jumps over the lazy dog.\") == {'a'... |
5a3a17dd233a28d2e962d03a3f8baf59 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est de trouver tous les sous-tableaux du tableau `[1, 2, 3, ..., n]` tels que la somme des éléments de chaque sous-tableau soit égale à `n`. De plus, chaque sous-tableau doit contenir au moins un nombre premier. Un sous-tableau est défini comme une parti... | ["\nassert find_subarrays_with_prime(1) == []\n", "\nassert find_subarrays_with_prime(2) == [[2]]\n", "\nassert find_subarrays_with_prime(3) == [[3], [1, 2]]\n", "\nassert find_subarrays_with_prime(4) == [[3, 1]]\n", "\nassert find_subarrays_with_prime(5) == [[5], [2, 3]]\n", "\nassert find_subarrays_with_prime(6) == [... |
9c61c042d400fb7595e916c175f6fc75 | [
{
"content": "On te donne une liste d'entiers `numbers` représentant les hauteurs des bâtiments d'un paysage urbain. Ta tâche est de trier ces bâtiments par ordre décroissant en utilisant l'algorithme de tri par insertion. Le tri doit être stable, ce qui signifie que les bâtiments de même hauteur doivent conser... | ["\nassert insertion_sort_descending([5, 3, 2, 5, 4, 3, 1]) == None\n", "\nnumbers = [5, 3, 2, 5, 4, 3, 1]; insertion_sort_descending(numbers); assert numbers == [5, 5, 4, 3, 3, 2, 1]\n", "\nnumbers = [1, 2, 3, 4, 5]; insertion_sort_descending(numbers); assert numbers == [5, 4, 3, 2, 1]\n", "\nnumbers = [5, 4, 3, 2, 1]... |
c7d6d90d79800b869adde97e648e3958 | [
{
"content": "On te demande d'écrire une fonction pour déterminer si une chaîne de caractères donnée est une adresse IPv4 valide. Une adresse IPv4 valide est constituée de quatre octets, chacun allant de 0 à 255, séparés par des points. Les zéros non significatifs dans les octets sont autorisés.\n\n**Entrée :**... | ["\nassert is_valid_ipv4(\"192.168.1.1\") == True\n", "\nassert is_valid_ipv4(\"255.255.255.255\") == True\n", "\nassert is_valid_ipv4(\"256.100.50.25\") == False\n", "\nassert is_valid_ipv4(\"192.168.1\") == False\n", "\nassert is_valid_ipv4(\"192.168.01.1\") == True\n", "\nassert is_valid_ipv4(\"0.0.0.0\") == True\n"... |
a69fd78031c415d75e1ef754d394c6ae | [
{
"content": "On te demande d'implémenter une fonction récursive `sumOfSquares(n)` qui calcule la somme des carrés des `n` premiers entiers positifs. La fonction doit renvoyer un tuple contenant la somme finale et une liste des sommes intermédiaires calculées lors des appels récursifs.\n\n**Contraintes :**\n- `... | ["\nassert sumOfSquares(1) == (1, [1])\n", "\nassert sumOfSquares(2) == (5, [1, 5])\n", "\nassert sumOfSquares(3) == (14, [1, 5, 14])\n", "\nassert sumOfSquares(4) == (30, [1, 5, 14, 30])\n", "\nassert sumOfSquares(5) == (55, [1, 5, 14, 30, 55])\n", "\nassert sumOfSquares(6) == (91, [1, 5, 14, 30, 55, 91])\n", "\nasser... |
115c5e002c84dbdddddeee154cfebb1d | [
{
"content": "On te donne une classe Python `BankAccount` qui modélise un compte bancaire simple avec des méthodes pour déposer, retirer et vérifier le solde. Ta tâche est d'implémenter une méthode `transfer` qui permet de transférer un montant spécifié du compte actuel vers une autre instance de `BankAccount`.... | ["\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(50).deposit(50) or BankAccount(50).get_balance() == 100\n", "\nassert BankAccount(100).withdraw(50) or BankAccount(100).get_balance() == 50\n", "\ntry: BankAccount().withdraw(10); assert False excep... |
9bf47bb5080fea49633f4a6952f9dfea | [
{
"content": "On te demande d'écrire un script Python pour traiter un fichier CSV nommé `employees.csv`. Ce fichier contient des enregistrements d'employés avec les colonnes suivantes : `EmployeeID`, `Name`, `Department` et `Salary`. Ton objectif est de calculer le salaire moyen de tous les employés répertoriés... | ["\nassert calculate_average_salary('test_employees_1.csv') == None # Assuming test_employees_1.csv has valid data and prints the average salary\n", "\nassert calculate_average_salary('test_employees_2.csv') == None # Assuming test_employees_2.csv has no salary data and prints \"No valid salary data found.\"\n", "\na... |
8e65cbb10b80fb59f24d82446f75d423 | [
{
"content": "On te donne un tableau d'entiers `nums` et un entier cible `target`. Ta tâche est de trouver tous les triplets uniques dans le tableau qui s'additionnent à la valeur cible. Les triplets doivent être triés par ordre croissant, et le tableau `nums` peut contenir des entiers en double. Retourne une l... | ["\nassert three_sum([1, 2, 2, 3, 4, 4, 5], 9) == [[1, 3, 5], [1, 4, 4], [2, 2, 5], [2, 3, 4]]\n", "\nassert three_sum([-1, 0, 1, 2, -1, -4], 0) == [[-1, -1, 2], [-1, 0, 1]]\n", "\nassert three_sum([0, 0, 0, 0], 0) == [[0, 0, 0]]\n", "\nassert three_sum([1, 2, 3, 4, 5], 12) == [[1, 5, 6], [2, 4, 6], [3, 4, 5]]\n", "\na... |
7ec2822245b385478ab1e7b7618947bd | [
{
"content": "Tu es chargé de créer une fonction `generate_unique_alias` qui génère un alias unique pour une adresse e-mail donnée. L'alias doit être construit en prenant les 10 premiers caractères de la partie locale de l'e-mail, en ajoutant un hachage de ces caractères (en utilisant SHA-256 et en prenant les ... | ["\nassert generate_unique_alias('john.doe@example.com', {'john15e84a52123456'}) != 'john15e84a52123456'\n", "\nassert generate_unique_alias('jane.doe@example.com', {'jane2a5f7b8c234567'}) != 'jane2a5f7b8c234567'\n", "\nassert len(generate_unique_alias('test@example.com', set())) == 21\n", "\nassert generate_unique_ali... |
114461729e8843468230f1719cb5c51d | [
{
"content": "On te demande d'écrire une fonction Python efficace et lisible pour convertir les températures de Celsius en Fahrenheit. Ta fonction doit prendre un seul nombre à virgule flottante en entrée, représentant la température en Celsius, et renvoyer la température correspondante en Fahrenheit sous forme... | ["\nassert celsius_to_fahrenheit(0) == 32\n", "\nassert celsius_to_fahrenheit(100) == 212\n", "\nassert celsius_to_fahrenheit(-40) == -40\n", "\nassert celsius_to_fahrenheit(37) == 98.6\n", "\nassert celsius_to_fahrenheit(20) == 68\n", "\nassert celsius_to_fahrenheit(15.5) == 59.9\n", "\nassert celsius_to_fahrenheit(-1... |
3370b5080b527be8b56f6f294f69088c | [
{
"content": "On te charge de développer une fonction pour un système de gestion de bibliothèque qui identifie efficacement les livres en double en fonction d'attributs spécifiques. Le schéma de base de données du système comprend une table `Book` avec les champs suivants : `id` (clé primaire), `title`, `author... | ["\nassert find_duplicate_books(Book(title=\"The Great Gatsby\", author=\"F. Scott Fitzgerald\", publisher=\"Charles Scribner's Sons\", publication_year=1925)).count() == 0\n", "\nassert find_duplicate_books(Book(title=\"1984\", author=\"George Orwell\", publisher=\"Secker & Warburg\", publication_year=1949)).count() =... |
0af086887b8e79aec7dac15b0402bf99 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres minuscules de l'alphabet anglais. Ta tâche est de déterminer le nombre de sous-chaînes de `s` qui contiennent exactement deux caractères distincts. Une sous-chaîne est définie comme une séquence contiguë de caractères dans la chaîne.\n\n... | ["\nassert count_substrings_with_two_distinct(\"abacaba\") == 10\n", "\nassert count_substrings_with_two_distinct(\"aabb\") == 6\n", "\nassert count_substrings_with_two_distinct(\"abc\") == 3\n", "\nassert count_substrings_with_two_distinct(\"aaa\") == 3\n", "\nassert count_substrings_with_two_distinct(\"aabbc\") == 10... |
9f4f5f87d0bc688d5c3e744116feb597 | [
{
"content": "Étant donné un tableau `arr` de `n` entiers positifs, détermine le nombre maximal de paires distinctes `(x, y)` telles que `x^y > y^x`. Note que `(x, y)` et `(y, x)` sont considérées comme des paires différentes.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 100), le nombre ... | ["\nassert count_pairs([2, 3, 4]) == 2\n", "\nassert count_pairs([1, 2, 3, 4]) == 4\n", "\nassert count_pairs([10, 20, 30]) == 0\n", "\nassert count_pairs([5, 6, 7, 8]) == 4\n", "\nassert count_pairs([1, 1, 1, 1]) == 0\n", "\nassert count_pairs([2, 2, 2, 3]) == 2\n", "\nassert count_pairs([3, 3, 3, 3, 3]) == 0\n", "\na... |
ccb0ae40d8c0910c345dcaed45c1218f | [
{
"content": "On te charge de développer une fonction pour évaluer le potentiel d'érosion de différents échantillons de sol en fonction de leur susceptibilité à la formation de croûte, quantifiée par le Facteur de Croûtement du Sol (FCS). Le FCS est déterminé à l'aide de la formule suivante :\n\n\\[ \\text{FCS}... | ["\nassert calculate_erosion_factor([[0.1], [0.2, 0.3]], [[0.05], [0.1, 0.15]]) == [[0.9868421052631579], [0.9743589743589743, 0.9626865671641791]]\n", "\nassert calculate_erosion_factor([[0.5], [0.6, 0.7]], [[0.4], [0.5, 0.6]]) == [[0.8829268292682926], [0.8264462809917356, 0.7741935483870968]]\n", "\nassert calculate... |
ee0e9cb7ef3a219b1e3b01493ef2ae5c | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `find_maximum` qui renvoie la valeur maximale dans la liste. Si la liste est vide, la fonction doit renvoyer `None`.\n\n**Exemple d'entrée :**\n```python\nnumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\n```\n\n**Exemple de sortie :**... | ["\nassert find_maximum([1, 2, 3, 4, 5]) == 5\n", "\nassert find_maximum([-1, -2, -3, -4, -5]) == -1\n", "\nassert find_maximum([10]) == 10\n", "\nassert find_maximum([]) == None\n", "\nassert find_maximum([5, 4, 3, 2, 1]) == 5\n", "\nassert find_maximum([0, 0, 0, 0]) == 0\n", "\nassert find_maximum([100, 200, 300, 400... |
0e901c7312b7b623f4ca524478942eed | [
{
"content": "On te donne une matrice réelle définie positive \\( A \\) et un vecteur réel \\( b \\). Ta tâche est de résoudre le système linéaire \\( Ax = b \\) pour le vecteur \\( x \\) en utilisant la méthode du Gradient Conjugué (GC) avec un préconditionneur de Jacobi. La matrice \\( A \\) n'est pas fournie... | ["\nassert np.allclose(conjugate_gradient(lambda x: np.array([[4, 1], [1, 3]]) @ x, np.array([1, 2])), np.array([0.09090909, 0.63636364]), atol=1e-6)\n", "\nassert torch.allclose(conjugate_gradient(lambda x: torch.tensor([[4, 1], [1, 3]]) @ x, torch.tensor([1, 2])), torch.tensor([0.09090909, 0.63636364]), atol=1e-6)\n"... |
35fff05d8788bb807299a56c00c22ba6 | [
{
"content": "Implémente une classe Python nommée `Calculator` qui prend en charge les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit inclure des méthodes pour chaque opération. La méthode de division doit gérer la division par zéro en levant une exception ... | ["\nassert Calculator().add(2, 3) == 5\n", "\nassert Calculator().subtract(10, 4) == 6\n", "\nassert Calculator().multiply(6, 7) == 42\n", "\nassert Calculator().divide(8, 2) == 4.0\n", "\nassert Calculator().add(-1, -1) == -2\n", "\nassert Calculator().subtract(0, 0) == 0\n", "\nassert Calculator().multiply(-3, 5) == ... |
cb0d59820ed5f78368c6e63cd49f5dce | [
{
"content": "On te donne un tableau NumPy 2D `signal` représentant un signal multi-canal, où chaque colonne correspond à un canal différent. Ta tâche est d'écrire une fonction `normalize_signal` qui effectue les opérations suivantes :\n\n1. Ajuste les valeurs de la Racine Carrée Moyenne (RMS) de chaque canal p... | ["\nassert np.allclose(normalize_signal(np.array([[1, 1], [1, 1]])), np.array([[1, 1], [1, 1]]))\n", "\nassert np.allclose(normalize_signal(np.array([[0, 0], [0, 0]])), np.array([[0, 0], [0, 0]]))\n", "\nassert np.allclose(normalize_signal(np.array([[1, 2], [3, 4]])), np.array([[0.4472136, 0.4472136], [1.34164079, 1.34... |
a5a0dd025d67322f22fee1545d106eab | [
{
"content": "On te donne une liste de chaînes de caractères. Pour chaque chaîne, supprime tous les caractères dupliqués tout en préservant l'ordre de leur première apparition. Retourne une liste des chaînes modifiées.\n\n**Entrée :**\n- Une liste de chaînes de caractères, où chaque chaîne est composée de lettr... | ["\nassert remove_duplicate_characters([\"hello\", \"world\"]) == [\"helo\", \"wrd\"]\n", "\nassert remove_duplicate_characters([\"aabbcc\", \"ddeeff\"]) == [\"abc\", \"def\"]\n", "\nassert remove_duplicate_characters([\"python\", \"programming\"]) == [\"python\", \"progamin\"]\n", "\nassert remove_duplicate_characters... |
0862340c5896d33e4d62c4902f81c1a7 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_smallest_prime_factor` qui détermine le plus petit facteur premier de `n`. Si `n` est inférieur à 2, la fonction doit renvoyer `None`. Un nombre premier est défini comme un nombre naturel supérieur à 1 qui ne peut pas être... | ["\nassert find_smallest_prime_factor(1) == None\n", "\nassert find_smallest_prime_factor(2) == 2\n", "\nassert find_smallest_prime_factor(3) == 3\n", "\nassert find_smallest_prime_factor(4) == 2\n", "\nassert find_smallest_prime_factor(5) == 5\n", "\nassert find_smallest_prime_factor(6) == 2\n", "\nassert find_smalles... |
d006d4792d3dbe9bd896ee2c120799b0 | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est d'écrire une fonction `sort_by_length_and_lexicographically` qui traite cette liste et renvoie une nouvelle liste de chaînes de caractères. La liste renvoyée doit être triée principalement par la longueur des chaînes et secondairemen... | ["\nassert sort_by_length_and_lexicographically([\"apple\", \"Banana\", \"kiwi\", \"cherry\", \"berry\", \"Mango1\", \"berry2\", \"Apricot\"]) == ['kiwi', 'apple', 'berry', 'banana', 'cherry', 'apricot']\n", "\nassert sort_by_length_and_lexicographically([\"dog\", \"Cat\", \"bat\", \"rat\"]) == ['bat', 'cat', 'dog', 'r... |
221bc01d872c90eefabd5dc5794496ad | [
{
"content": "On te donne une chaîne de caractères `text` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `top_n_words(text, n)` qui renvoie une liste des `n` mots les plus fréquemment rencontrés dans le texte, en ignorant la casse et les mots vides courants tels que \"and\", \"the\", \"is\", \"i... | ["\nassert top_n_words(\"Python is a high-level, interpreted programming language.\", 2) == [('python', 2), ('programming', 1)]\n", "\nassert top_n_words(\"The quick brown fox jumps over the lazy dog.\", 3) == [('the', 2), ('quick', 1), ('brown', 1)]\n", "\nassert top_n_words(\"Hello world! Hello everyone.\", 1) == [('... |
76cc237962d45100ce53beb090daf974 | [
{
"content": "Tu développes un jeu où les points de vie (PV) d'un joueur sont enregistrés à différents intervalles de temps. Les valeurs de PV sont stockées dans une liste d'entiers. Ta mission est d'identifier les indices auxquels les PV atteignent un minimum local. Un minimum local est défini comme un indice ... | ["\nassert find_critical_points([100, 90, 80, 90, 100, 85, 90]) == [2, 5]\n", "\nassert find_critical_points([100, 100, 100, 100]) == []\n", "\nassert find_critical_points([100, 90, 100, 80, 100, 90, 100]) == [1, 3, 5]\n", "\nassert find_critical_points([100, 90, 80, 70, 60, 50, 40]) == []\n", "\nassert find_critical_p... |
cf3f6ad707875324a5f4269f4417b37b | [
{
"content": "On te donne une série d'essais, chacun consistant en une période de stimulation et une période de pause. La période de stimulation est divisée en plusieurs périodes de fixation, pendant lesquelles une action spécifique est effectuée. La durée de chaque période de fixation peut varier d'un essai à ... | ["\nassert create_trial_map([1], 10, 5, 2, [2]) == {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1, 7: 1, 8: 0, 9: 0, 10: 0}\n", "\nassert create_trial_map([2], 10, 5, 2, [2]) == {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 1, 9: 1, 10: 1, 11: 1, 12: 0, 13: 0, 14: 0}\n", "\nassert create_trial_map([2], 10, 5, 2, [3]) ... |
d657f2fa8609ff07c77342431a2ec5e4 | [
{
"content": "On te donne un tableau d'entiers `nums`. Ta tâche est de construire un tableau `result` tel que `result[i]` soit le produit de tous les éléments de `nums` sauf `nums[i]`. Tu dois résoudre ce problème sans utiliser la division.\n\n**Contraintes :**\n- `2 <= len(nums) <= 10^5`\n- `-30 <= nums[i] <= ... | ["\nassert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]\n", "\nassert product_except_self([5, 3, 2, 4, 1]) == [24, 40, 60, 30, 120]\n", "\nassert product_except_self([0, 1, 2, 3]) == [6, 0, 0, 0]\n", "\nassert product_except_self([1, 0, 3, 4]) == [0, 12, 0, 0]\n", "\nassert product_except_self([1, 2, 0, 4]) == [... |
0496bcc63a8cd2a35dd2c2f2bb01f8ab | [
{
"content": "On te donne la production initiale de déchets d'une ville et le nombre d'unités de traitement disponibles. En raison des fluctuations saisonnières, la production de déchets et le nombre d'unités de traitement sont tous deux modifiés par un facteur `S`. Ta tâche est de calculer l'efficacité du syst... | ["\nassert calculate_efficiency(1000, 100, 1.1, 5) == 50.0\n", "\nassert calculate_efficiency(500, 50, 1.0, 10) == 100.0\n", "\nassert calculate_efficiency(2000, 100, 0.9, 5) == 90.0\n", "\nassert calculate_efficiency(0, 100, 1.1, 5) == 0.0\n", "\nassert calculate_efficiency(1000, 0, 1.1, 5) == 0.0\n", "\nassert calcul... |
f7de7962bf1f7dc0d865ee22f0e6a1a3 | [
{
"content": "On te demande d'implémenter une fonction `is_valid_document` qui détermine la validité d'un document en fonction de critères spécifiques. Le document est représenté comme un dictionnaire avec les clés suivantes :\n\n- `content_type` : une chaîne de caractères indiquant le type MIME du document.\n-... | ["\nassert is_valid_document({'status': 200, 'content_type': 'application/pdf', 'version': '1.4'}) == True\n", "\nassert is_valid_document({'status': 200, 'content_type': 'application/pdf', 'version': '2.0'}) == True\n", "\nassert is_valid_document({'status': 200, 'content_type': 'application/pdf', 'version': '1.10'}) ... |
1c1cd71ace305f89c2f5716f7b428065 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de mettre en œuvre une fonction qui trie cette liste par ordre décroissant en utilisant l'algorithme de tri fusion. Ta fonction doit renvoyer la liste triée.\n\n**Entrée :**\n- Une liste d'entiers `arr` (1 ≤ len(arr) ≤ 10^4), où chaque entier `arr[i]` ... | ["\nassert merge_sort_descending([38, 27, 43, 3, 9, 82, 10]) == [82, 43, 38, 27, 10, 9, 3]\n", "\nassert merge_sort_descending([1, 2, 3, 4, 5]) == [5, 4, 3, 2, 1]\n", "\nassert merge_sort_descending([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n", "\nassert merge_sort_descending([10]) == [10]\n", "\nassert merge_sort_descending... |
f65bcee31bf8c3ebeba3df61378c6762 | [
{
"content": "On te donne un arbre binaire. Ta tâche est d'implémenter une fonction qui effectue un parcours en largeur de l'arbre et renvoie le résultat sous forme de liste de listes. Chaque liste interne doit contenir les valeurs des nœuds à ce niveau, en commençant par le niveau racine.\n\n**Entrée :**\n- Le... | ["\nassert level_order_traversal(TreeNode(1, TreeNode(2), TreeNode(3))) == [[1], [2, 3]]\n", "\nassert level_order_traversal(TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))) == [[1], [2, 3], [4, 5, 6, 7]]\n", "\nassert level_order_traversal(TreeNode(1)) == [[1]]\n", "\nassert l... |
721fbf53e891f2a97f96e8211b8b56d9 | [
{
"content": "Implémente une classe Python nommée `Book` avec les spécifications suivantes :\n\n- **Attributs :**\n - `title` : Une chaîne de caractères représentant le titre du livre.\n - `author` : Une chaîne de caractères représentant l'auteur du livre.\n - `year_published` : Un entier représentant l'anné... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, \"978-0451524935\").title == \"1984\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"978-0451524935\").author == \"George Orwell\"\n", "\nassert Book(\"1984\", \"George Orwell\", 1949, \"978-0451524935\").year_published == 1949\n", "\nassert Book(\"1984\", \"G... |
24c48226077d67b6699d960990531ea8 | [
{
"content": "On te donne une chaîne de caractères `text` composée de mots séparés par des espaces. Ta tâche est d'écrire une fonction Python `word_frequency` qui renvoie un dictionnaire contenant la fréquence de chaque mot dans le texte. La fonction doit traiter le texte de manière insensible à la casse et doi... | ["\nassert word_frequency(\"Hello, world!\") == {'hello': 1, 'world': 1}\n", "\nassert word_frequency(\"Python is great. Python is fun.\") == {'python': 2, 'is': 2, 'great': 1, 'fun': 1}\n", "\nassert word_frequency(\"It's a beautiful day.\") == {\"it's\": 1, 'a': 1, 'beautiful': 1, 'day': 1}\n", "\nassert word_frequen... |
575d939db8a184fb1ab14b51bad8662c | [
{
"content": "On te demande d'implémenter une fonction `ip_to_location(ip_addresses)` qui prend une liste d'adresses IP et renvoie une liste de dictionnaires contenant des informations géographiques pour chaque adresse IP. La fonction doit gérer efficacement plusieurs adresses IP à la fois et minimiser le nombr... | ["\nassert ip_to_location([\"8.8.8.8\"]) == [{'status': 'success', 'country': 'United States', 'countryCode': 'US', 'region': 'CA', 'regionName': 'California', 'city': 'Mountain View', 'zip': '94043', 'lat': 37.422, 'lon': -122.084, 'timezone': 'America/Los_Angeles', 'isp': 'Google LLC', 'org': 'Google LLC', 'as': 'AS1... |
409f7a6c42fa8ca67b1d0308266aad35 | [
{
"content": "On te demande d'écrire un script Python qui utilise la bibliothèque `requests` pour récupérer des informations météorologiques auprès de l'API OpenWeatherMap. Ton programme doit accepter le nom d'une ville en entrée et afficher la température actuelle en Celsius, le pourcentage d'humidité et une b... | ["\nassert get_weather_data(\"nonexistentcity\", \"fake_api_key\") is None\n", "\nassert get_weather_data(\"\", \"fake_api_key\") is None\n", "\nassert get_weather_data(\"New York\", \"fake_api_key\") is None\n", "\nassert get_weather_data(\"London\", \"fake_api_key\") is None\n", "\nassert get_weather_data(\"Paris\", ... |
c9de792024a7b40b91c46913bafb1abe | [
{
"content": "On te donne une chaîne de caractères `data`. Ta tâche est d'implémenter la fonction `transform_string(data)` qui traite la chaîne selon les règles suivantes :\n\n1. Ne conserver que les caractères alphabétiques, sans tenir compte de la casse.\n2. Convertir tous les caractères en minuscules.\n3. In... | ["\nassert transform_string(\"Hello, World! 123\") == \"dlrowolleh\"\n", "\nassert transform_string(\"Python3.8\") == \"nohtyp\"\n", "\nassert transform_string(\"1234567890\") == \"\"\n", "\nassert transform_string(\"!@#$%^&*()\") == \"\"\n", "\nassert transform_string(\"aBcDeFgHiJ\") == \"jihgfedcba\"\n", "\nassert tr... |
64116eb1746c74f2e0a6a14dc9d8078e | [
{
"content": "On te donne une liste d'entiers `nums` contenant tous les nombres de 1 à n, à l'exception d'un. Ta tâche est de trouver et de renvoyer le nombre manquant. La liste `nums` ne sera pas triée et peut contenir n'importe quelle permutation des nombres, à l'exception du nombre manquant.\n\n**Contraintes... | ["\nassert find_missing_number([1, 2, 4, 5, 6]) == 3\n", "\nassert find_missing_number([1, 3, 4, 5]) == 2\n", "\nassert find_missing_number([2, 3, 4, 5, 6, 7, 8, 9, 10]) == 1\n", "\nassert find_missing_number([1, 2, 3, 4, 5, 6, 7, 8, 10]) == 9\n", "\nassert find_missing_number([1]) == 2\n", "\nassert find_missing_numbe... |
fae50b5e67eb3e450c697f2e332154d7 | [
{
"content": "On te demande d'implémenter une fonction `detect_file_format` qui identifie le format d'un fichier en se basant sur son nombre magique. La fonction doit lire les 6 premiers octets du fichier et les comparer aux nombres magiques connus pour des formats de fichiers spécifiques. Si une correspondance... | ["\nassert detect_file_format(io.BytesIO(b'ELFIO!data')) == {\"format_name\": \"ELF Executable (ARM)\", \"format_options\": 1}\n", "\nassert detect_file_format(io.BytesIO(b'ZIP_!archive')) == {\"format_name\": \"ZIP Archive\", \"format_options\": 1}\n", "\nassert detect_file_format(io.BytesIO(b'PDF_!document')) == {\"f... |
5b95708f2b879598b41d4e7297044af1 | [
{
"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. Lève une `IndexError` si la pile est vide.\n- `peek()` : Retourne l'élément au sommet de la pi... | ["\nassert Stack().is_empty() == True\n", "\nassert Stack().size() == 0\n", "\ns = Stack(); s.push(1); assert s.peek() == 1\n", "\ns = Stack(); s.push(1); s.push(2); assert s.pop() == 2\n", "\ns = Stack(); s.push(1); s.push(2); s.pop(); assert s.size() == 1\n", "\ns = Stack(); s.push(1); s.push(2); s.push(3); assert s.... |
3f170ee52c6c2333cd9c0d829e61ff16 | [
{
"content": "Tu participes à un défi de classification multi-classes où l'on te fournit une liste de probabilités prédites pour chaque classe (`output`) et une liste d'étiquettes réelles (`labels`). Le `output` est un tableau NumPy 2D ou 3D. S'il est 2D, il a une forme de `(num_samples, num_classes)`, où chaqu... | ["\nassert compute_f1_score(np.array([[0.1, 0.9], [0.8, 0.2]]), np.array([1, 0])) == 1.0\n", "\nassert compute_f1_score(np.array([[[0.1, 0.9], [0.8, 0.2]], [[0.9, 0.1], [0.2, 0.8]]]), np.array([1, 0])) == 1.0\n", "\nassert compute_f1_score(np.array([[0.9, 0.1], [0.2, 0.8]]), np.array([0, 1])) == 1.0\n", "\nassert compu... |
0daae5836e5226b7a84527ecc84bcfe2 | [
{
"content": "On te donne une chaîne de caractères contenant plusieurs ensembles de longueurs de côtés de triangle. Chaque ensemble est séparé par un saut de ligne. Ta tâche est de déterminer le nombre de triangles valides qui peuvent être formés à partir de chaque ensemble de côtés. Un triangle est valide si l... | ["\nassert count_valid_triangles(\"3 4 5\\n6 7 8\") == [1, 1]\n", "\nassert count_valid_triangles(\"5 5 5\\n1 2 3\") == [1, 0]\n", "\nassert count_valid_triangles(\"1 2 3\\n4 5 6\\n7 8 9\") == [0, 1, 1]\n", "\nassert count_valid_triangles(\"10 20 25\\n30 40 50\") == [1, 1]\n", "\nassert count_valid_triangles(\"1 1 2\\n... |
15394f9ce76bee94127ec47bd0d3f3a1 | [
{
"content": "On te donne une liste de dictionnaires, chacun représentant un étudiant avec les clés \"name\", \"age\" et \"grades\" (une liste d'entiers). Ta tâche est de calculer la moyenne des notes pour chaque étudiant et de renvoyer un dictionnaire où les clés sont les noms des étudiants et les valeurs sont... | ["\nassert calculate_average_grades([{\"name\": \"Alice\", \"age\": 20, \"grades\": [85, 90, 78]}]) == {\"Alice\": 84.33333333333333}\n", "\nassert calculate_average_grades([{\"name\": \"Bob\", \"age\": 22, \"grades\": [70, 80, 85]}]) == {\"Bob\": 78.33333333333333}\n", "\nassert calculate_average_grades([{\"name\": \"... |
77cb3d95670cf87eca994467af9ff78a | [
{
"content": "On te donne la tâche de construire un carré magique 3x3, où la somme des nombres dans chaque ligne, colonne et diagonale est identique. De plus, la somme des nombres dans les quatre coins du carré doit être égale à la somme des nombres dans les cinq éléments centraux. Ton objectif est d'implémente... | ["\nassert sum(magic_square[0]) == sum(magic_square[1]) == sum(magic_square[2])\n", "\nassert sum(magic_square[i][0] for i in range(3)) == sum(magic_square[i][1] for i in range(3)) == sum(magic_square[i][2] for i in range(3))\n", "\nassert magic_square[0][0] + magic_square[0][2] + magic_square[2][0] + magic_square[2][2... |
cb367fa5d40a65dca84ab409151a3a3e | [
{
"content": "On te donne un entier `n`. Ta tâche est d'écrire une fonction `prime_factors(n)` qui renvoie une liste des facteurs premiers de `n`. La liste doit être triée par ordre croissant et inclure tous les facteurs premiers, y compris leurs multiplicités. Par exemple, si `n = 56`, la fonction doit renvoye... | ["\nassert prime_factors(56) == [2, 2, 2, 7]\n", "\nassert prime_factors(1) == []\n", "\nassert prime_factors(2) == [2]\n", "\nassert prime_factors(3) == [3]\n", "\nassert prime_factors(4) == [2, 2]\n", "\nassert prime_factors(9) == [3, 3]\n", "\nassert prime_factors(100) == [2, 2, 5, 5]\n", "\nassert prime_factors(101... |
1bfb675bdc432c5a96f6028c2ee74974 | [
{
"content": "Tu participes à une compétition de traitement de données où tu dois gérer les métadonnées d'un produit. Les métadonnées sont fournies sous forme de dictionnaire où les clés suivent un schéma spécifique : `file_name_band_{band_number}`. Chaque clé correspond à un nom de fichier associé au numéro de... | ["\nassert map_band_to_filename({'file_name_band_1': 'image1.jpg'}) == {1: 'image1.jpg'}\n", "\nassert map_band_to_filename({'file_name_band_2': 'image2.jpg', 'file_name_band_3': 'image3.jpg'}) == {2: 'image2.jpg', 3: 'image3.jpg'}\n", "\nassert map_band_to_filename({'file_name_band_10': 'image10.jpg', 'file_name_band_... |
3e14aebaf5dfb139eb98b607627cad4a | [
{
"content": "On te demande d'implémenter une structure de données pile en Python qui supporte les opérations suivantes en temps constant : `push`, `pop`, `top` et `get_min`. L'opération `get_min` doit renvoyer l'élément minimum de la pile. Ton implémentation doit gérer les cas limites, tels que le fait de reti... | ["\nassert MinStack().get_min() == None\n", "\nassert MinStack().top() == None\n", "\ns = MinStack(); s.push(3); assert s.get_min() == 3\n", "\ns = MinStack(); s.push(3); s.push(5); assert s.get_min() == 3\n", "\ns = MinStack(); s.push(3); s.push(5); s.push(2); assert s.get_min() == 2\n", "\ns = MinStack(); s.push(3); ... |
2ff37234a53e59bb943fd576c3b7af70 | [
{
"content": "On te donne un octet, représenté comme une liste de 8 chiffres binaires (0 et 1), ordonnés du bit de poids faible (LSB) au bit de poids fort (MSB). De plus, on te fournit une séquence binaire, également représentée comme une liste de chiffres binaires, d'une longueur maximale de 8. Ta tâche est de... | ["\nassert replace_and_add_parity([0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1]) == [0, 0, 0, 0, 0, 1, 1, 1, 1]\n", "\nassert replace_and_add_parity([1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0]) == [1, 1, 1, 1, 1, 0, 0, 0, 0]\n", "\nassert replace_and_add_parity([0, 1, 1, 1, 1, 1, 0, 1], [0, 1, 0]) == [0, 1, 1, 1, 1, 0, 1, 0, 0]\n", "\na... |
7d77602dd33faa23bbe0f80dad29b15d | [
{
"content": "On te donne un tableau d'entiers qui peut contenir des éléments dupliqués. Implémente une version modifiée de l'algorithme de tri Shell pour trier le tableau dans l'ordre croissant ou décroissant en fonction d'un paramètre de direction donné. Ton implémentation doit minimiser les échanges et les c... | ["\nassert shell_sort([3, 2, 4, 5, 1, 2, 3, 3], 'asc') == ([1, 2, 2, 3, 3, 3, 4, 5], 24, 16)\n", "\nassert shell_sort([3, 2, 4, 5, 1, 2, 3, 3], 'desc') == ([5, 4, 3, 3, 3, 2, 2, 1], 24, 16)\n", "\nassert shell_sort([1, 1, 1, 1, 1], 'asc') == ([1, 1, 1, 1, 1], 10, 0)\n", "\nassert shell_sort([1, 1, 1, 1, 1], 'desc') == ... |
e59c9da18eb76fe6378704316594433d | [
{
"content": "On te donne une séquence imbriquée d'entiers et d'autres séquences. Ta tâche est d'écrire une fonction `count_elements` qui compte tous les éléments individuels de la séquence, y compris ceux des séquences imbriquées. La fonction doit utiliser une approche de programmation dynamique et un mécanism... | ["\nassert count_elements([]) == 0\n", "\nassert count_elements([1, 2, 3]) == 3\n", "\nassert count_elements([1, [2, 3], 4]) == 4\n", "\nassert count_elements([1, [2, [3, 4]], 5]) == 5\n", "\nassert count_elements([1, (2, 3), [4, (5, 6)]]) == 6\n", "\nassert count_elements([[], [1], [[2]], [[[3]]]]) == 3\n", "\nassert ... |
57828255a429ac4aed6028b6c74df089 | [
{
"content": "On te donne un nombre à virgule flottante `num` et un entier `n`. Ta tâche est de mettre en œuvre une fonction `round_to_n_decimals(num, n)` qui renvoie la représentation sous forme de chaîne de caractères de `num` arrondie à `n` décimales. Si `n` est négatif, la fonction doit renvoyer la représen... | ["\nassert round_to_n_decimals(3.14159, 2) == \"3.14\"\n", "\nassert round_to_n_decimals(3.14159, -1) == \"3\"\n", "\nassert round_to_n_decimals(123.456, 3) == \"123.456\"\n", "\nassert round_to_n_decimals(123.456, 0) == \"123\"\n", "\nassert round_to_n_decimals(123.456, -2) == \"123\"\n", "\nassert round_to_n_decimals... |
6ca1bec0ab4fbcc652282973f73a8541 | [
{
"content": "On te donne une liste d'entiers, `numbers`. Ta tâche est d'implémenter une fonction `sorted_absolute_values` qui renvoie une nouvelle liste contenant les valeurs absolues des éléments dans `numbers`, triées par ordre croissant. Si deux éléments ont la même valeur absolue, leur ordre relatif dans l... | ["\nassert sorted_absolute_values([-5, -2, 0, 1, 3]) == [0, 1, 2, 3, 5]\n", "\nassert sorted_absolute_values([4, -1, -3, 2, -5]) == [1, 2, 3, 4, 5]\n", "\nassert sorted_absolute_values([0, 0, 0, 0]) == [0, 0, 0, 0]\n", "\nassert sorted_absolute_values([-10, 10, -20, 20]) == [10, 10, 20, 20]\n", "\nassert sorted_absolut... |
0868fabdfe5a045c53526b41827fc882 | [
{
"content": "On te donne une séquence d'ADN représentée sous forme de chaîne de caractères `sequence` composée des caractères 'A', 'T', 'C', 'G', et potentiellement d'autres caractères non standard. La séquence a une position de départ `global_start` dans le système de coordonnées global et est située sur le b... | ["\nassert calculate_dna_position(\"AXYTNGCR\", 100, 1) == {'standard_sequence': 'ATGC', 'first_standard_pos': 100, 'last_standard_pos': 103}\n", "\nassert calculate_dna_position(\"AXYTNGCR\", 100, -1) == {'standard_sequence': 'ATGC', 'first_standard_pos': 103, 'last_standard_pos': 100}\n", "\nassert calculate_dna_posi... |
7fe0727e3ea28e9daf157448c60fda59 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de trouver la paire de nombres dans la liste dont la somme est la plus proche de zéro. La liste peut contenir des nombres positifs et négatifs. Ta solution doit être suffisamment efficace pour gérer de grandes listes.\n\n**Entrée :**\n- Une liste d'ent... | ["\nassert find_closest_to_zero([1, 60, -10, 70, -80, 85]) == (-10, 10)\n", "\nassert find_closest_to_zero([1, 3, 4, 7, 10]) == (1, 3)\n", "\nassert find_closest_to_zero([-1, -3, -4, -7, -10]) == (-1, -3)\n", "\nassert find_closest_to_zero([1, 2, 3, -4, -1, 4]) == (-1, 1)\n", "\nassert find_closest_to_zero([0, 2, 3, -4... |
4e90f734dfe688480f733a2aaacbda72 | [
{
"content": "On te donne une chaîne hexadécimale représentant une séquence de caractères ASCII, où chaque caractère est encodé sous forme de deux chiffres hexadécimaux. Ta tâche est d'implémenter la fonction `decode_hex_string` qui convertit cette chaîne hexadécimale en la chaîne ASCII correspondante. Tu n'es ... | ["\nassert decode_hex_string(\"48656C6C6F\") == \"Hello\"\n", "\nassert decode_hex_string(\"576F726C64\") == \"World\"\n", "\nassert decode_hex_string(\"4142434445\") == \"ABCDE\"\n", "\nassert decode_hex_string(\"6162636465\") == \"abcde\"\n", "\nassert decode_hex_string(\"2021222324\") == \" !\\\"#$\"\n", "\nassert d... |
cf7d6f5a6cac6883913c94d0a8e11594 | [
{
"content": "On te donne une matrice de transformation 3x3 `mtx` et un vecteur tridimensionnel `src`. Ta tâche est de mettre en œuvre une fonction `transform_vector(src, mtx)` qui applique la matrice de transformation `mtx` au vecteur `src`. La matrice de transformation `mtx` représente une combinaison d'opéra... | ["\nassert transform_vector([1, 0, 0], [[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == [1, 0, 0]\n", "\nassert transform_vector([0, 1, 0], [[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == [0, 1, 0]\n", "\nassert transform_vector([0, 0, 1], [[1, 0, 0], [0, 1, 0], [0, 0, 1]]) == [0, 0, 1]\n", "\nassert transform_vector([1, 1, 1], [[2, 0, 0],... |
73157b73d4b087cd08643abbd5c23621 | [
{
"content": "On te donne une liste d'entiers `nums`. Ta tâche est d'implémenter une fonction `find_mode(nums)` qui détermine le mode de la liste, c'est-à-dire le nombre qui apparaît le plus fréquemment. Si plusieurs nombres ont la même fréquence la plus élevée, renvoie l'un d'entre eux. Si la liste est vide, r... | ["\nassert find_mode([1, 2, 2, 3, 3, 4]) in [2, 3]\n", "\nassert find_mode([4, 4, 1, 2, 2, 3, 3]) in [2, 3, 4]\n", "\nassert find_mode([7, 7, 7, 7, 7]) == 7\n", "\nassert find_mode([1, 1, 2, 3, 4, 4, 5, 5, 5]) == 5\n", "\nassert find_mode([10, 20, 20, 10, 30, 30, 30]) == 30\n", "\nassert find_mode([]) == None\n", "\nas... |
496a11ce4121b8d401794c84a825b095 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_prime_factors(n)` qui renvoie une liste des facteurs premiers distincts de `n` dans l'ordre croissant. Si `n` est inférieur ou égal à 1, renvoie une liste vide. Note que chaque facteur premier doit apparaître une seule foi... | ["\nassert find_prime_factors(56) == [2, 7]\n", "\nassert find_prime_factors(100) == [2, 5]\n", "\nassert find_prime_factors(1) == []\n", "\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(29) == [29]\n", "\nassert find_prime_factors(60) == [2, 3, 5]\n", "... |
6dd4ce200557d1fec0d20ed6a61e1a28 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'implémenter une fonction `calculate_average` qui calcule la moyenne des nombres dans la liste. Si la liste est vide, la fonction doit renvoyer 0.0. Ta solution doit être efficace et gérer les cas limites de manière appropriée.\n\n**Exemple d'entrée 1... | ["\nassert calculate_average([10, 20, 30, 40, 50]) == 30.0\n", "\nassert calculate_average([5, 15, 25, 35, 45]) == 25.0\n", "\nassert calculate_average([]) == 0\n", "\nassert calculate_average([100]) == 100.0\n", "\nassert calculate_average([1, 2, 3, 4, 5]) == 3.0\n", "\nassert calculate_average([-10, -20, -30, -40, -5... |
1c7a87c632a64f081ef84131e9077496 | [
{
"content": "On te donne deux entiers `n` et `r`. Ta tâche est de générer toutes les combinaisons possibles de `r` éléments parmi un ensemble de `n` éléments, représentés par les nombres `1` à `n`. Les combinaisons doivent être renvoyées sous forme de liste de listes, où chaque liste interne représente une com... | ["\nassert generate_combinations(4, 2) == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n", "\nassert generate_combinations(3, 2) == [[1, 2], [1, 3], [2, 3]]\n", "\nassert generate_combinations(5, 3) == [[1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5], [1, 4, 5], [2, 3, 4], [2, 3, 5], [2, 4, 5], [3, 4, 5]]\n",... |
3285def2c87b011e1222773f767216a0 | [
{
"content": "On te donne une séquence d'appels de fonctions représentée sous forme de liste de dictionnaires. Chaque dictionnaire contient les clés `\"function_name\"`, `\"unique_id\"` et `\"timestamp\"`, indiquant le nom de la fonction, son identifiant unique et l'heure à laquelle elle a été appelée, respecti... | ["\nassert _match_exit_function({'unique_id': 1}, [{'unique_id': 1}]) == True\n", "\nassert _match_exit_function({'unique_id': 2}, [{'unique_id': 1}, {'unique_id': 2}]) == True\n", "\nassert _match_exit_function({'unique_id': 3}, [{'unique_id': 1}, {'unique_id': 2}]) == False\n", "\nassert _match_exit_function({'unique... |
a9426b92dcefd114b96f4f5a817c41fd | [
{
"content": "On te demande d'implémenter une version thread-safe de la méthode de Runge-Kutta du 4ème ordre pour résoudre des équations différentielles ordinaires (EDO). Ton implémentation doit gérer plusieurs threads appelant simultanément la fonction `rungekutta4step` sans provoquer de conditions de concurre... | ["\nassert np.array_equal(RungeKutta4().rungekutta4step(lambda t, y: y, np.array([1.0]), 0.0, 0.1), np.array([1.10517092]))\n", "\nassert np.array_equal(RungeKutta4().rungekutta4step(lambda t, y: -y, np.array([1.0]), 0.0, 0.1), np.array([0.90483742]))\n", "\nassert np.array_equal(RungeKutta4().rungekutta4step(lambda t,... |
f05997af7b5126d1b6d8df2b78a9960e | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_largest_prime_factor(n)` qui renvoie le plus grand facteur premier de `n`. La fonction doit être optimisée pour gérer efficacement les grandes valeurs de `n`.\n\n**Entrée :**\n- Un seul entier `n` (2 ≤ n ≤ 10^12)\n\n**Sort... | ["\nassert find_largest_prime_factor(13195) == 29\n", "\nassert find_largest_prime_factor(2048) == 2\n", "\nassert find_largest_prime_factor(600851475143) == 6857\n", "\nassert find_largest_prime_factor(1) == -1\n", "\nassert find_largest_prime_factor(2) == 2\n", "\nassert find_largest_prime_factor(3) == 3\n", "\nasser... |
fa8bbbdedcbef72d5a3983ffa6ab085c | [
{
"content": "On te donne une chaîne de caractères `data`. Ta tâche est de déterminer si la chaîne est composée uniquement de caractères uniques de l'alphabet anglais (minuscules et majuscules), de chiffres et du caractère de soulignement. Si la chaîne répond à ces critères, retourne `True`; sinon, retourne `Fa... | ["\nassert is_special_string(\"abc123_\") == True\n", "\nassert is_special_string(\"abc123_a\") == False\n", "\nassert is_special_string(\"abc!@#\") == False\n", "\nassert is_special_string(\"AaBbCc123_\") == True\n", "\nassert is_special_string(\"1234567890\") == True\n", "\nassert is_special_string(\"AaAaAa\") == Fal... |
af537b1882792f5726985dcdfbe2663f | [
{
"content": "On te donne deux listes : `marriages` et `individuals`. Chaque élément dans `marriages` est un dictionnaire représentant un mariage avec les clés suivantes :\n- `husband_id` : L'identifiant unique du mari.\n- `wife_id` : L'identifiant unique de la femme.\n- `marriage_date` : La date du mariage.\n-... | ["\nassert validate_marriage_before_death([{'husband_id': 'H1', 'wife_id': 'W1', 'marriage_date': '1980-01-01', 'divorce_date': '1990-01-01'}], [{'id': 'H1', 'name': 'John Doe', 'death_date': '1985-01-01'}, {'id': 'W1', 'name': 'Jane Doe', 'death_date': None}]) == [\"Error: John Doe (ID: H1) married on 1980-01-01 but d... |
92ffa1e0434760fdb03180adc20adc82 | [
{
"content": "Dans un projet de voiture autonome, tu dois implémenter une fonction `stabilize_steering` qui ajuste l'angle de direction en fonction de l'angle de direction actuel, d'un nouvel angle de direction proposé, du nombre de lignes de voie détectées et du mode de conduite. La fonction doit respecter des... | ["\nassert stabilize_steering(10, 16, 2, 'Normal') == 15\n", "\nassert stabilize_steering(10, 9, 1, 'Normal') == 9\n", "\nassert stabilize_steering(10, 12, 1, 'Traffic Jam') == 10.5\n", "\nassert stabilize_steering(0, 5, 2, 'Lane Assist') == 5\n", "\nassert stabilize_steering(0, 8, 2, 'Lane Assist') == 7\n", "\nassert ... |
6cbed117ffb5e244a8e85ad2f08bcf32 | [
{
"content": "On te demande d'implémenter une fonction `fibonacci_sequence(n)` qui calcule les `n` premiers nombres de la suite de Fibonacci. La suite de Fibonacci est définie comme suit : le premier nombre est 0, le deuxième nombre est 1, et chaque nombre suivant est la somme des deux nombres précédents. Ta fo... | ["\nassert fibonacci_sequence(1) == [0]\n", "\nassert fibonacci_sequence(2) == [0, 1]\n", "\nassert fibonacci_sequence(5) == [0, 1, 1, 2, 3]\n", "\nassert fibonacci_sequence(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "\nassert fibonacci_sequence(15) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n", "\na... |
8c60ddd06109c69f16484cdc4097ad17 | [
{
"content": "On te donne une chaîne de caractères `row` représentant une ligne de valeurs séparées par des virgules (CSV). Chaque valeur dans la ligne CSV peut contenir des espaces et peut être entourée de guillemets doubles pour inclure des virgules à l'intérieur de la valeur. Ta tâche est d'analyser la chaîn... | ["\nassert comma_separated_values(\";a;b;;c;;;d;;;;e;;;;;f;;;;;;;g;;;;;;;\") == ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n", "\nassert comma_separated_values(\"a,b,c,d,e\") == ['a', 'b', 'c', 'd', 'e']\n", "\nassert comma_separated_values(\",,a,,b,,c,,\") == ['a', 'b', 'c']\n", "\nassert comma_separated_values(\"\\\"a,b\\\"... |
35a9a534046cb3bd573eeb735d687380 | [
{
"content": "On te donne deux entiers, `a` et `b` (1 ≤ a ≤ b ≤ 10^6). Ta tâche est d'écrire un programme Python qui trouve tous les nombres premiers dans l'intervalle inclusif [a, b]. Le programme doit être optimisé pour gérer efficacement les grandes plages.\n\n**Exemple d'entrée :**\n```\n10 100\n```\n\n**Ex... | ["\nassert find_primes_in_range(10, 100) == [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n", "\nassert find_primes_in_range(1, 10) == [2, 3, 5, 7]\n", "\nassert find_primes_in_range(20, 22) == []\n", "\nassert find_primes_in_range(0, 1) == []\n", "\nassert find_primes_in_range(17... |
cf84322a479a1b840d654ec2cfc74a22 | [
{
"content": "Tu développes un système pour gérer les réponses HTTP. Ta tâche est d'implémenter une fonction `handle_http_status` qui traite les codes d'état HTTP. La fonction doit gérer les cas suivants :\n- Si le code d'état est 404, renvoie la chaîne de caractères `\"Resource not found\"`.\n- Si le code d'ét... | ["\nassert handle_http_status(404) == \"Resource not found\"\n", "\nassert handle_http_status(500) == \"Server error occurred\"\n", "\nassert handle_http_status(200) == \"Status code handled\"\n", "\nassert handle_http_status(599) == \"Server error occurred\"\n", "\nassert handle_http_status(403) == \"Status code handl... |
1200bf106949eb57700a82558bf09537 | [
{
"content": "On te donne une phrase et une longueur minimale. Ta tâche est de déterminer si la phrase est un pangramme avec la contrainte supplémentaire que chaque lettre doit être utilisée dans un mot d'au moins 3 caractères, et si la phrase a une longueur minimale. Un pangramme est une phrase qui utilise cha... | ["\nassert is_pangram_with_min_length(\"The quick brown fox jumps over the lazy dog\", 40) == True\n", "\nassert is_pangram_with_min_length(\"The quick brown fox jumps over the lazy\", 39) == False\n", "\nassert is_pangram_with_min_length(\"Pack my box with five dozen liquor jugs\", 30) == True\n", "\nassert is_pangram... |
c14665f771c288ceb0526bfe2ffa7021 | [
{
"content": "On te donne un tableau multidimensionnel représenté par sa forme sous forme de liste d'entiers. Ta tâche est de déterminer la forme d'un seul bloc pour ce tableau. La forme du bloc est définie comme suit :\n\n- Pour les tableaux à 1 et 2 dimensions, chaque dimension du bloc doit être le minimum de... | ["\nassert chunk_shape([1024]) == [997]\n", "\nassert chunk_shape([500]) == [500]\n", "\nassert chunk_shape([1024, 512]) == [997, 997]\n", "\nassert chunk_shape([10, 20]) == [10, 20]\n", "\nassert chunk_shape([1024, 512, 256]) == [3, 3, 256]\n", "\nassert chunk_shape([1024, 512, 256, 128]) == [3, 3, 256, 97]\n", "\nass... |
6ad7bc2c2a35ea5e9345db3449838b4d | [
{
"content": "On te donne une chaîne de caractères `text` qui consiste en plusieurs lignes. Ta tâche est d'écrire une fonction `extract_integer_from_text(text)` qui traite la première ligne de la chaîne d'entrée et identifie le premier entier positif qui est un nombre premier. Si aucun nombre premier de ce type... | ["\nassert extract_integer_from_text(\"2 is the smallest prime number\") == 2\n", "\nassert extract_integer_from_text(\"The first prime number is 2\") == 2\n", "\nassert extract_integer_from_text(\"15 is not a prime number\") == 0\n", "\nassert extract_integer_from_text(\"The number 17 is prime\") == 17\n", "\nassert e... |
2e2327cfd5d5acad8d3fafa8e581cd53 | [
{
"content": "On te donne un échiquier standard de 8x8 et un cavalier situé sur une cellule spécifique. Le cavalier peut se déplacer vers n'importe quelle case de l'échiquier qui est soit à deux cases horizontalement et une case verticalement, soit à deux cases verticalement et une case horizontalement. De plus... | ["\nassert count_knight_moves(\"A1\") == 2\n", "\nassert count_knight_moves(\"H8\") == 2\n", "\nassert count_knight_moves(\"D4\") == 8\n", "\nassert count_knight_moves(\"E5\", [\"C6\", \"G6\"]) == 6\n", "\nassert count_knight_moves(\"B2\", [\"D3\"]) == 3\n", "\nassert count_knight_moves(\"G7\", [\"F5\", \"H6\"]) == 4\n... |
1efe9d04e065fbbb86e0fc575ae0fe60 | [
{
"content": "On te donne un mot et une liste de mots. Ta tâche est de trouver l'anagramme le plus proche du mot donné dans la liste. L'anagramme le plus proche est défini comme le mot ayant la plus petite distance de Levenshtein par rapport au mot d'entrée. S'il y a plusieurs mots avec la même distance minimal... | ["\nassert find_closest_anagram(\"listen\", [\"silent\", \"enlist\", \"tinsel\", \"banana\"]) == \"silent\"\n", "\nassert find_closest_anagram(\"triangle\", [\"integral\", \"integral\", \"integral\"]) == \"integral\"\n", "\nassert find_closest_anagram(\"apple\", [\"pale\", \"ale\", \"apples\", \"appl\"]) == \"apples\"\... |
ef7b64a77ef7dfe407d96451526e322f | [
{
"content": "On te donne un graphe non orienté avec `n` sommets et une représentation sous forme de liste d'adjacence. Ta tâche est de mettre en œuvre une fonction qui effectue un parcours en profondeur (DFS) à partir du sommet 0. La fonction doit renvoyer une liste des sommets visités dans l'ordre dans lequel... | ["\nassert dfs(4, [[1, 2], [0, 3], [0], [1]]) == [0, 1, 3, 2]\n", "\nassert dfs(3, [[1], [0, 2], [1]]) == [0, 1, 2]\n", "\nassert dfs(5, [[1, 4], [0, 2], [1, 3], [2], [0]]) == [0, 1, 2, 3, 4]\n", "\nassert dfs(6, [[1, 2], [0, 3], [0, 4], [1, 5], [2], [3]]) == [0, 1, 3, 5, 2, 4]\n", "\nassert dfs(1, [[]]) == [0]\n", "\n... |
6b64a2c80a221fc0581bd4a3cb0cacf4 | [
{
"content": "Dans une université, chaque étudiant est représenté par un tuple contenant son nom, son numéro d'étudiant et une liste de ses résultats d'examen. Ta tâche est de déterminer s'il existe au moins un étudiant qui a échoué à au moins deux examens. Un étudiant est considéré comme ayant échoué à un exam... | ["\nassert has_failed_exam([(\"Alice\", 1, [45, 40, 60])]) == True\n", "\nassert has_failed_exam([(\"Bob\", 2, [55, 60, 70])]) == False\n", "\nassert has_failed_exam([(\"Charlie\", 3, [45, 55, 65, 75])]) == False\n", "\nassert has_failed_exam([(\"David\", 4, [45, 40, 49, 60])]) == True\n", "\nassert has_failed_exam([(\... |
3008438a6fc8c1debd38307cda628d27 | [
{
"content": "On te donne une matrice de transformation géométrique 3D où un angle joue un rôle crucial. Ta tâche est d'implémenter une fonction qui calcule la proportion d'un angle donné qui se situe entre deux valeurs normalisées. Les angles doivent être considérés dans la plage \\([-π, π]\\). La fonction doi... | ["\nassert angle_proportion(0, -math.pi, math.pi) == 0.5\n", "\nassert angle_proportion(math.pi, -math.pi, math.pi) == 1.0\n", "\nassert angle_proportion(-math.pi, -math.pi, math.pi) == 0.0\n", "\nassert angle_proportion(math.pi/2, -math.pi, math.pi) == 0.75\n", "\nassert angle_proportion(-math.pi/2, -math.pi, math.pi)... |
2e04a34fc3cdc5acc5eca60c55bb13c3 | [
{
"content": "On te demande d'implémenter une fonction `find_prime_sum(n)` qui calcule la somme des `n` premiers nombres premiers. Un nombre premier est défini comme un nombre naturel supérieur à 1 qui n'a pas de diviseurs autres que 1 et lui-même. Ta fonction doit renvoyer `-1` si `n` est inférieur ou égal à 0... | ["\nassert find_prime_sum(1) == 2\n", "\nassert find_prime_sum(2) == 5\n", "\nassert find_prime_sum(3) == 10\n", "\nassert find_prime_sum(4) == 17\n", "\nassert find_prime_sum(5) == 28\n", "\nassert find_prime_sum(0) == -1\n", "\nassert find_prime_sum(-5) == -1\n", "\nassert find_prime_sum(10) == 129\n", "\nassert find... |
eee27b77ae69c90085aa9f9854685b67 | [
{
"content": "On te donne un ensemble de données sous la forme d'un DataFrame pandas `df` et une liste de fonctions de traitement `processing_functions`. Chaque fonction de traitement est une transformation qui doit être appliquée à l'ensemble de données. La liste des fonctions de traitement est fournie sous la... | ["\nassert process_dataframe(pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}), [], 'B') == (pd.DataFrame({'A': [1, 2, 3]}), pd.DataFrame({'B': [4, 5, 6]}))\n", "\nassert process_dataframe(pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}), [(lambda df: df, [], {})], 'B') == (pd.DataFrame({'A': [1, 2, 3]}), pd.DataFrame({'B':... |
76cae45faeada2d320ad15c630562030 | [
{
"content": "On te donne une liste d'entiers `lst` et un entier `n`. Ta tâche est de trouver la somme maximale de `n` éléments consécutifs quelconques dans la liste. Implémente la fonction `max_sum_sublist(lst, n)` avec une complexité temporelle meilleure que O(n^2).\n\n**Contraintes :**\n- 1 ≤ len(lst) ≤ 10^5... | ["\nassert max_sum_sublist([1, 2, 3, 4, 5], 2) == 9\n", "\nassert max_sum_sublist([1, 2, 3, 4, 5], 3) == 12\n", "\nassert max_sum_sublist([1, 2, 3, 4, 5], 5) == 15\n", "\nassert max_sum_sublist([1, 2, 3, 4, 5], 6) == 0\n", "\nassert max_sum_sublist([1, 2, 3, 4, 5], 0) == 0\n", "\nassert max_sum_sublist([-1, -2, -3, -4,... |
bf7cbe0b54dbfd7371d77d725fc8cff5 | [
{
"content": "On te demande d'implémenter une fonction pour analyser une matrice de nombres à virgule flottante à partir d'un fichier texte. Chaque ligne du fichier représente une ligne de la matrice, et chaque nombre dans une ligne représente un élément de la matrice. Ta fonction doit ignorer les lignes qui ne... | ["\nassert load_matrix_from_file(\"test1.txt\") == [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]\n", "\nassert load_matrix_from_file(\"test2.txt\") == [[0.1, 0.2], [0.3, 0.4]]\n", "\nassert load_matrix_from_file(\"test3.txt\") == [[1.0, 2.0, 3.0, 4.0]]\n", "\nassert load_matrix_from_file(\"test4.txt\") == []\n", "\nassert load_ma... |
e2aba7658dffdcb15fd4f0cf99cd1bec | [
{
"content": "On te charge de gérer les dossiers des employés d'une entreprise. Étant donné une liste de noms d'employés, ton objectif est de trier ces noms par ordre alphabétique et d'attribuer à chaque employé un identifiant unique commençant à 1. Les identifiants doivent être attribués dans l'ordre des noms ... | ["\nassert assign_employee_ids([\"Alice Johnson\", \"Bob Smith\", \"Charlie Brown\", \"David Wilson\"]) == {\"Alice Johnson\": 1, \"Bob Smith\": 2, \"Charlie Brown\": 3, \"David Wilson\": 4}\n", "\nassert assign_employee_ids([\"Zachary\", \"Adam\", \"Yvonne\"]) == {\"Adam\": 1, \"Yvonne\": 2, \"Zachary\": 3}\n", "\nass... |
ae66b82732cc081bf0333e6b95e9f55f | [
{
"content": "On te demande d'implémenter une fonction `parse_csv_line` qui simule l'analyse d'une seule ligne d'un fichier CSV. La fonction doit gérer correctement les champs séparés par des virgules, et les champs contenant des virgules ou des guillemets doivent être entourés de guillemets doubles. Ta fonctio... | ["\nassert parse_csv_line('apple,banana,cherry') == ['apple', 'banana', 'cherry']\n", "\nassert parse_csv_line('\"apple, banana\",cherry') == ['apple, banana', 'cherry']\n", "\nassert parse_csv_line('apple,\"banana, cherry\"') == ['apple', 'banana, cherry']\n", "\nassert parse_csv_line('\"apple, \"\"banana, cherry\"\"\... |
3b5b3ba894f3ee6dad7f61580e7292dd | [
{
"content": "On te donne une grille de taille `n x n` remplie d'entiers uniques de `1` à `n^2` dans un ordre en spirale en partant du coin supérieur gauche et en se déplaçant dans le sens des aiguilles d'une montre. On te fournit également quatre entiers `b`, `a`, `j` et `i` représentant les indices de ligne e... | ["\nassert get_index(0, 3, 2, 1, 4, False) == 13\n", "\nassert get_index(0, 0, 3, 3, 4, False) == 2\n", "\nassert get_index(3, 3, 0, 0, 4, False) == -1\n", "\nassert get_index(0, 0, 3, 3, 4, True) == -1\n", "\nassert get_index(0, 1, 0, 2, 4, False) == 3\n", "\nassert get_index(1, 0, 2, 0, 4, False) == 5\n", "\nassert g... |
7277b60526a7c2e17c2fa7f0168d94d4 | [
{
"content": "Tu es chargé d'implémenter une fonction pour une application web qui récupère les journaux de construction à partir d'un serveur distant via une API REST. Le point de terminaison de l'API est structuré comme suit :\n\n`https://api.example.com/logs?project_id={project_id}&build_id={build_id}`\n\nTa... | ["\nassert get_logs_url(0) == \"https://api.example.com/logs?project_id=default&build_id=0\"\n", "\nassert get_logs_url(123, 'my_project') == \"https://api.example.com/logs?project_id=my_project&build_id=123\"\n", "\nassert get_logs_url(999999999) == \"https://api.example.com/logs?project_id=default&build_id=999999999\... |
39e79cd63e7c5b345d332cc5fe63ba54 | [
{
"content": "On te demande d'implémenter une fonction `is_prime` qui détermine si un entier donné `n` est un nombre premier. Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas de diviseurs positifs autres que 1 et lui-même. Ta fonction doit gérer efficacement les grandes valeurs de `n`.\n\n**Ent... | ["\nassert is_prime(2) == True\n", "\nassert is_prime(3) == True\n", "\nassert is_prime(4) == False\n", "\nassert is_prime(5) == True\n", "\nassert is_prime(17) == True\n", "\nassert is_prime(18) == False\n", "\nassert is_prime(19) == True\n", "\nassert is_prime(1) == False\n", "\nassert is_prime(0) == False\n", "\nass... |
a34dc0a274e5d98e0ce2e3e647e119e5 | [
{
"content": "On te donne un extrait HTML sous forme de chaîne de caractères. Ta tâche est de convertir cet extrait HTML en un format Markdown équivalent. L'extrait HTML contiendra un titre (`<h1>`), un paragraphe (`<p>`) et une liste non ordonnée (`<ul>`). Le paragraphe peut contenir du texte en gras (`<strong... | ["\nassert html_to_markdown(\"<html><body><h1>Title</h1><p>This is a <strong>bold</strong> paragraph.</p><ul><li>Item 1</li><li>Item 2</li></ul></body></html>\") == \"# Title\\nThis is a **bold** paragraph.\\n- Item 1\\n- Item 2\\n\"\n", "\nassert html_to_markdown(\"<html><body><h1>Another Title</h1><p>Simple paragraph... |
e2cbda2e1e37d4a9a5ab204aebfec7de | [
{
"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 ignorant la casse et la ponctuation. Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :**\n- Une seule chaîne de caractères `s` (1... | ["\nassert is_palindrome(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Hello, World!\") == False\n", "\nassert is... |
035762068a14f07bf4ebbee9887972e4 | [
{
"content": "On te demande d'implémenter une fonction pour calculer la factorielle d'un entier non négatif donné en utilisant la récursion. Pour optimiser ta solution, assure-toi que chaque valeur de factorielle est calculée une seule fois. Ta fonction doit gérer efficacement plusieurs requêtes.\n\n**Entrée :*... | ["\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(12) == 479001600\n", "\nassert ... |
635290e39c30a60f2efb0941bd395668 | [
{
"content": "On te demande d'implémenter une fonction `generate_prime_numbers` qui génère efficacement tous les nombres premiers jusqu'à un entier spécifié `n` en utilisant l'algorithme du crible d'Ératosthène. Ta fonction doit renvoyer une liste de ces nombres premiers.\n\n**Entrée :**\n- Un entier `n` (1 ≤ n... | ["\nassert generate_prime_numbers(10) == [2, 3, 5, 7]\n", "\nassert generate_prime_numbers(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_prime_numbers(1) == []\n", "\nassert generate_prime_numbers(0) == []\n", "\nassert generate_prime_numbers(2) == [2]\n", "\nassert generate_prime_numbers(30) == [2, 3, 5, ... |
96c1fc597c0bf1af2864fef4a2bc47ee | [
{
"content": "On te demande d'implémenter une fonction `calculate_fibonacci` qui calcule le nième nombre de Fibonacci en utilisant une approche récursive. La suite de Fibonacci est définie comme suit : F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1. Ta fonction doit gérer les entrées invalides avec él... | ["\nassert calculate_fibonacci(0) == 0\n", "\nassert calculate_fibonacci(1) == 1\n", "\nassert calculate_fibonacci(2) == 1\n", "\nassert calculate_fibonacci(3) == 2\n", "\nassert calculate_fibonacci(4) == 3\n", "\nassert calculate_fibonacci(5) == 5\n", "\nassert calculate_fibonacci(10) == 55\n", "\nassert calculate_fib... |
44705777a6ef482733cd978dd534720f | [
{
"content": "On te donne un entier `n`. Ta tâche est d'implémenter une fonction `sum_of_digits` qui calcule la somme des chiffres de `n`, en traitant `n` comme un entier positif quel que soit son signe. Si la somme des chiffres est un nombre premier, retourne la somme des carrés des chiffres à la place. Sinon,... | ["\nassert sum_of_digits(123) == 6\n", "\nassert sum_of_digits(-456) == 77\n", "\nassert sum_of_digits(0) == 0\n", "\nassert sum_of_digits(11) == 2\n", "\nassert sum_of_digits(23) == 11\n", "\nassert sum_of_digits(-23) == 11\n", "\nassert sum_of_digits(113) == 11\n", "\nassert sum_of_digits(29) == 86\n", "\nassert sum_... |
5a1646467f69b7ad81a043f200622968 | [
{
"content": "On te donne une chaîne de caractères au format camel case. Ta tâche est d'écrire une fonction `convert_camel_case(text)` qui convertit cette chaîne au format snake case. La fonction doit gérer correctement les lettres majuscules consécutives. Par exemple, la chaîne `camelCaseString` doit être conv... | ["\nassert convert_camel_case(\"camelCaseString\") == \"camel_case_string\"\n", "\nassert convert_camel_case(\"HTTPRequest\") == \"http_request\"\n", "\nassert convert_camel_case(\"convertCamelCase\") == \"convert_camel_case\"\n", "\nassert convert_camel_case(\"thisIsATest\") == \"this_is_a_test\"\n", "\nassert convert... |
c3f5d8407d0090360f70d3e8ff627445 | [
{
"content": "On te donne un DataFrame `df` avec les colonnes `model_name`, `metric` et `value`. La colonne `metric` contient le nom de la métrique, et la colonne `value` contient la valeur correspondante pour cette métrique pour le modèle donné. Ta tâche est de mettre en œuvre une fonction `filter_metrics(df, ... | ["\nassert filter_metrics(pd.DataFrame({'model_name': ['model1'], 'metric': ['accuracy'], 'value': [0.9]}), 'standard').equals(pd.DataFrame({'model_name': ['model1'], 'metric': ['accuracy'], 'value': [0.9]}))\n", "\nassert filter_metrics(pd.DataFrame({'model_name': ['model1'], 'metric': ['max_error'], 'value': [1.5]}),... |
55a524aa7fca20134905fb892d2e4f06 | [
{
"content": "Dans le jeu de Yahtzee, un joueur lance cinq dés à six faces et peut choisir de relancer n'importe lequel ou tous les dés jusqu'à deux fois de plus. Pour ce problème, tu dois simuler les lancers de dés en fonction du nombre de lancers spécifié par le joueur. La fonction doit renvoyer un tuple cont... | ["\nassert simulate_yahtzee_roll(1) == ([[1, 1, 1, 1, 1]], 1) or simulate_yahtzee_roll(1) == ([[6, 6, 6, 6, 6]], 6)\n", "\nassert simulate_yahtzee_roll(2) == ([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1]], 1) or simulate_yahtzee_roll(2) == ([[6, 6, 6, 6, 6], [6, 6, 6, 6, 6]], 6)\n", "\nassert simulate_yahtzee_roll(3) == ([[1, 1, ... |
5491fa1ee6fb60d3bb790ee3a1e8759b | [
{
"content": "On te demande d'implémenter une fonction pour analyser un fichier contenant une séquence de chaînes hexadécimales. Chaque chaîne hexadécimale est exactement longue de 8 caractères et représente un code secret. Les codes sont regroupés par paires dans le fichier. Ta fonction doit gérer manuellement... | ["\nassert read_secret_codes('test1.txt') == ['1a2b3c4d', '5e6f7a8b']\n", "\nassert read_secret_codes('test2.txt') == ['abcdef12', '34567890']\n", "\nassert read_secret_codes('test3.txt') == ['12345678', '9abcdef0']\n", "\nassert read_secret_codes('test4.txt') == []\n", "\nassert read_secret_codes('test5.txt') == ['a1b... |
c75ba59d9ebe266724fee3e75143e185 | [
{
"content": "On te donne une liste d'entiers `nums`. Ton objectif est d'implémenter une fonction `remove_duplicates(nums)` qui renvoie une nouvelle liste contenant uniquement les éléments uniques de `nums`, en préservant l'ordre de leur première apparition. Par exemple, si `nums` est `[4, 5, 6, 4, 7, 5, 8]`, l... | ["\nassert remove_duplicates([1, 2, 2, 3, 4, 4, 5, 6, 6, 7]) == [1, 2, 3, 4, 5, 6, 7]\n", "\nassert remove_duplicates([10, 20, 20, 10, 30]) == [10, 20, 30]\n", "\nassert remove_duplicates([1, 1, 1, 1, 1]) == [1]\n", "\nassert remove_duplicates([]) == []\n", "\nassert remove_duplicates([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1... |
8e5bb7e156e6257d82c95a7066e7b6e8 | [
{
"content": "On te donne une liste de points 2D, où chaque point est représenté par une paire d'entiers (x, y). Ta tâche est de trouver le point qui est le plus proche de la ligne définie par l'équation `y = -2x + 12`. La distance entre un point et la ligne est calculée en utilisant la formule :\n\n`distance =... | ["\nassert find_closest_point([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]) == (3, 4)\n", "\nassert find_closest_point([(0, 12), (1, 10), (2, 8), (3, 6), (4, 4)]) == (0, 12)\n", "\nassert find_closest_point([(5, 2), (5, 3), (5, 4), (5, 5), (5, 6)]) == (5, 4)\n", "\nassert find_closest_point([(1, 1), (2, 2), (3, 3), (4, 4)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.