id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
e2ee8cf26fbea12a136477359ce41b48 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `find_prime_factors(n)` qui renvoie une liste de ses facteurs premiers. Un facteur premier est un facteur qui est un nombre premier. Implémente cette fonction en utilisant une approche de force brute. Commence à partir de 2 et v... | ["\nassert find_prime_factors(2) == [2]\n", "\nassert find_prime_factors(3) == [3]\n", "\nassert find_prime_factors(4) == [2, 2]\n", "\nassert find_prime_factors(5) == [5]\n", "\nassert find_prime_factors(6) == [2, 3]\n", "\nassert find_prime_factors(8) == [2, 2, 2]\n", "\nassert find_prime_factors(12) == [2, 2, 3]\n",... |
592a056ecbd66b76574b1886f1a1cfa9 | [
{
"content": "On te donne une chaîne de caractères `s`. Ton objectif est d'écrire une fonction qui trouve et renvoie la plus longue sous-chaîne palindromique dans `s` qui a une longueur d'au moins 3 caractères. S'il existe plusieurs sous-chaînes de longueur maximale identique, renvoie celle qui apparaît en prem... | ["\nassert longest_palindromic_substring(\"abracecarsadams\") == \"racecar\"\n", "\nassert longest_palindromic_substring(\"banana\") == \"anana\"\n", "\nassert longest_palindromic_substring(\"noonnoon\") == \"noonnoon\"\n", "\nassert longest_palindromic_substring(\"abc\") == \"\"\n", "\nassert longest_palindromic_subst... |
b49e8d5342f66fc3a2ff204aeb7ee223 | [
{
"content": "On te demande d'implémenter une fonction `prompt_user` qui simule un scénario d'interaction utilisateur. La fonction doit accepter deux paramètres : une chaîne de caractères `message` à afficher à l'utilisateur et une chaîne de caractères `default_value` à renvoyer si l'utilisateur ne fournit pas ... | ["\nassert prompt_user(\"Enter your name: \", \"Guest\") == \"Alice\" if input(\"Enter your name: \") == \"Alice\" else \"Guest\"\n", "\nassert prompt_user(\"Choose a number: \", \"42\") == \"42\" if input(\"Choose a number: \") == \"\" else \"42\"\n", "\nassert prompt_user(\"Enter your address: \", \"No address provid... |
1d186607db8e7cc3edbc3270e5424a11 | [
{
"content": "On te donne un tableau trié `arr` de `n` entiers distincts et un entier cible `target`. Ta tâche est de mettre en œuvre une fonction qui utilise la recherche binaire pour trouver l'indice de `target` dans le tableau. Si `target` n'est pas présent dans le tableau, retourne `-1`.\n\n**Entrée :**\n- ... | ["\nassert binary_search([1, 2, 3, 4, 5], 3) == 2\n", "\nassert binary_search([1, 2, 3, 4, 5], 1) == 0\n", "\nassert binary_search([1, 2, 3, 4, 5], 5) == 4\n", "\nassert binary_search([1, 2, 3, 4, 5], 6) == -1\n", "\nassert binary_search([], 1) == -1\n", "\nassert binary_search([10, 20, 30, 40, 50], 25) == -1\n", "\nas... |
671061cfde2f24d3acb1f478c00a2307 | [
{
"content": "On te donne une liste d'entiers et une valeur cible. Ta tâche est de trouver toutes les paires uniques d'entiers de la liste qui s'additionnent pour donner la valeur cible. Chaque paire doit être listée une seule fois, quel que soit l'ordre des entiers dans la paire.\n\n**Entrée :**\n- La première... | ["\nassert find_pairs([1, 2, 3, 4, 5], 7) == [(3, 4), (2, 5)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_pairs([1, 2, 3, 4, 5], 5) == [(1, 4), (2, 3)]\n", "\nassert find_pairs([1, 1, 2, 45, 46, 46], 47) == [(1, 46)]\n", "\nassert find_pairs([0, 0, 0, 0], 0) == [(0, 0)]\n", "\nassert find_pai... |
1ae4d89daa837ad86935a038d1aa4feb | [
{
"content": "Tu es chargé d'implémenter un jeu de devinettes de nombres. Le programme doit générer un entier aléatoire entre 1 et 100 (inclus) et demander à l'utilisateur de deviner ce nombre. Après chaque tentative, le programme doit fournir un retour d'information indiquant si la tentative est trop basse, tr... | ["\nassert number_guessing_game([50, 75, 88, 92, 95, 97, 99, 100]) == 8\n", "\nassert number_guessing_game([50, 25, 38, 49, 51, 55, 57, 58, 59, 60]) == 10\n", "\nassert number_guessing_game([100]) == 1 if random.randint(1, 100) == 100 else -1\n", "\nassert number_guessing_game([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 10 if ... |
c4cd87377dd3d2b4a1fcc4de24fc941b | [
{
"content": "On te donne un tableau d'entiers `numbers` et un entier `target`. Ta tâche est de trouver deux indices distincts `i` et `j` tels que `numbers[i] + numbers[j] = target`. Retourne les indices sous la forme d'un tuple `(i, j)`. Si aucune paire de ce type n'existe, retourne `None`. Il est garanti qu'i... | ["\nassert two_sum([2, 7, 11, 15], 9) == (0, 1)\n", "\nassert two_sum([3, 2, 4], 6) == (1, 2)\n", "\nassert two_sum([3, 3], 6) == (0, 1)\n", "\nassert two_sum([1, 2, 3, 4, 5], 10) == (3, 4)\n", "\nassert two_sum([1, 2, 3, 4, 5], 8) == (2, 4)\n", "\nassert two_sum([1, 2, 3, 4, 5], 11) == None\n", "\nassert two_sum([10, ... |
028c961dcd6aab6410dd0dd49ccb94c2 | [
{
"content": "Tu es chargé d'implémenter une fonction `create_serial_number(base_number, width, prefix)` qui génère un numéro de série unique pour un produit. La fonction accepte trois paramètres :\n\n- `base_number` : un entier représentant le nombre de base pour le numéro de série.\n- `width` : un entier repr... | ["\nassert create_serial_number(42, 5, 'PROD-') == 'PROD-0002A'\n", "\nassert create_serial_number(255, 4, 'DEV-') == 'DEV-00FF'\n", "\nassert create_serial_number(0, 3, 'TEST-') == 'TEST-000'\n", "\nassert create_serial_number(16, 2, 'ALPHA-') == 'ALPHA-10'\n", "\nassert create_serial_number(1, 1, 'BETA-') == 'BETA-1'... |
428a1fd74a2b76da4704d7d2b2b98851 | [
{
"content": "On te donne une liste de températures en Fahrenheit. Ta tâche est d'écrire une fonction `convert_to_celsius(fahrenheit_list)` qui convertit chaque température de la liste en Celsius en utilisant la formule `C = (F - 32) * 5/9`. La fonction doit renvoyer une nouvelle liste contenant les température... | ["\nassert convert_to_celsius([32]) == [0.0]\n", "\nassert convert_to_celsius([212]) == [100.0]\n", "\nassert convert_to_celsius([0]) == [-17.77777777777778]\n", "\nassert convert_to_celsius([-40]) == [-40.0]\n", "\nassert convert_to_celsius([98.6]) == [37.0]\n", "\nassert convert_to_celsius([68, 77, 86]) == [20.0, 25.... |
630187eba7ef60d0dc4efc0ffb16527d | [
{
"content": "On te charge de concevoir une API REST utilisant Flask qui prend en charge deux opérations principales : la création d'un nouvel utilisateur et la récupération d'un utilisateur existant par son identifiant unique. L'API doit gérer les requêtes suivantes :\n\n1. **Créer un utilisateur** : Une requê... | ["\nassert create_user().status_code == 400\n", "\nassert create_user().json == {\"error\": \"User ID is required\"}\n", "\nassert create_user(json={\"id\": \"1\", \"name\": \"John Doe\"}).status_code == 201\n", "\nassert create_user(json={\"id\": \"1\", \"name\": \"John Doe\"}).json == {\"error\": \"User already exist... |
cd12af00299f194cd4a666ec15415750 | [
{
"content": "On te donne la tâche de développer un programme pour analyser plusieurs processus de fermentation. Pour chaque processus, on te fournit les valeurs Brix (°Bx) initiales et finales d'un mélange de jus de fruits. La teneur en sucre en grammes par litre (g/L) peut être calculée à l'aide de la formule... | ["\nassert calculate_sugar_content([12.5, 14.0], [9.0, 10.0]) == [500.0, 400.0]\n", "\nassert calculate_sugar_content([10.0, 10.0], [10.0, 10.0]) == [0.0, 0.0]\n", "\nassert calculate_sugar_content([15.0, 12.0, 10.0], [10.0, 8.0, 5.0]) == [500.0, 400.0, 500.0]\n", "\nassert calculate_sugar_content([20.0], [15.0]) == [5... |
8fa20c0b9edf25e04fe8d9bbc1eca525 | [
{
"content": "On te demande d'implémenter une fonction nommée `cylinder_calculate` qui calcule le volume d'un cylindre en fonction de son rayon et de sa hauteur. La fonction doit renvoyer le volume arrondi à quatre décimales. Assure-toi que le rayon et la hauteur sont tous deux des nombres positifs. Si l'une de... | ["\nassert cylinder_calculate(3, 5) == 141.3717\n", "\nassert cylinder_calculate(1, 1) == 3.1416\n", "\nassert cylinder_calculate(0.5, 2) == 1.5708\n", "\nassert cylinder_calculate(7, 10) == 1539.3804\n", "\nassert cylinder_calculate(2.5, 4.5) == 88.3573\n", "\nassert cylinder_calculate(10, 0.1) == 31.4159\n", "\nasser... |
45dc948fbc9e7b8aa9912df646c6a7f0 | [
{
"content": "On te donne une liste de matrices 3D B, où chaque matrice a une taille de LxLxT. Chaque élément de la matrice est une liste d'entiers. Ta tâche est de regrouper ces matrices dans un tenseur 4D unique de taille BxLxLxT_, où T_ est la longueur maximale de toute liste dans les matrices d'entrée. Si u... | ["\nassert (pack_matrices_into_tensor([[[[1, 2], [3]], [[4, 5, 6], [7, 8]]]])[0] == np.array([[[[1, 2, 0], [3, 0, 0]], [[4, 5, 6], [7, 8, 0]]]]).all()).all()\n", "\nassert pack_matrices_into_tensor([[[[1, 2], [3]], [[4, 5, 6], [7, 8]]]])[1] == [2, 1, 3, 2]\n", "\nassert pack_matrices_into_tensor([[[[1, 2], [3]], [[4, 5... |
7e8c6703ca102ab1c926448a625266c5 | [
{
"content": "On te donne une liste d'entiers `numbers` et un entier `target_sum`. Ta tâche est de trouver toutes les paires uniques d'entiers dans la liste qui s'additionnent à `target_sum`. Chaque entier de la liste ne peut être utilisé qu'une seule fois dans une paire. Retourne une liste de tuples, où chaque... | ["\nassert find_pairs_with_sum([1, 2, 3, 4, 5], 5) == [(1, 4), (2, 3)]\n", "\nassert find_pairs_with_sum([10, 15, 3, 7], 17) == [(10, 7)]\n", "\nassert find_pairs_with_sum([1, 2, 3, 9], 8) == []\n", "\nassert find_pairs_with_sum([5, 5, 5, 5], 10) == [(5, 5), (5, 5)]\n", "\nassert find_pairs_with_sum([1, 6, 3, 8, 2, 9],... |
53e78e5d36298981b979eaf90be5caed | [
{
"content": "Conçois et implémente un point de terminaison d'API RESTful `/activate_user` pour un système d'activation de compte utilisateur. Chaque jeton d'activation ne peut être utilisé qu'une seule fois et a une période de validité de 24 heures. Le système doit gérer les éléments suivants :\n\n- **POST /ac... | ["\nassert is_valid_token(generate_token()) == False\n", "\nassert is_valid_token(test_token) == True\n", "\nassert is_valid_token(test_token) == False # Token can only be used once\n", "\nassert activate_user().status_code == 400 # No token provided\n", "\nassert activate_user().json['message'] == \"No token provide... |
c8f6b3e4f12a475be52af86cd9673e92 | [
{
"content": "On te donne un entier positif `n`. Ta tâche est d'écrire une fonction `generate_primes(n: int) -> Sequence[int]` qui renvoie une liste de tous les nombres premiers jusqu'à et y compris `n`. Pour optimiser la fonction, considère uniquement les nombres impairs jusqu'à la racine carrée de `n` et évit... | ["\nassert generate_primes(10) == [2, 3, 5, 7]\n", "\nassert generate_primes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_primes(1) == []\n", "\nassert generate_primes(2) == [2]\n", "\nassert generate_primes(0) == []\n", "\nassert generate_primes(30) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert g... |
5050f9944b3329a922574ca39e19b823 | [
{
"content": "On te donne un fichier image contenant du texte qui peut être orienté selon différents angles. Ta tâche est de développer un programme qui extrait le texte de l'image en utilisant un moteur OCR, avec la contrainte que le moteur OCR ne puisse être invoqué qu'un maximum de 3 fois. Le programme doit ... | ["\nassert ocr_with_probabilities('path/to/straight_text.png')[0] == 'straighttext'\n", "\nassert ocr_with_probabilities('path/to/rotated_90_text.png')[0] == 'rotatedtext'\n", "\nassert ocr_with_probabilities('path/to/rotated_180_text.png')[0] == 'rotatedtext'\n", "\nassert ocr_with_probabilities('path/to/rotated_270_t... |
f2bc6114d59e9830f03e45a8eedf998d | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'écrire une fonction qui supprime tous les caractères spéciaux de la chaîne et renvoie la chaîne résultante. Les caractères spéciaux sont définis comme tout caractère qui n'est pas alphanumérique (lettres et chiffres).\n\n**Entrée :**\n- Une ... | ["\nassert remove_special_characters(\"Hello, World! 123\") == \"HelloWorld123\"\n", "\nassert remove_special_characters(\"Python@3.9#\") == \"Python39\"\n", "\nassert remove_special_characters(\"NoSpecialCharsHere\") == \"NoSpecialCharsHere\"\n", "\nassert remove_special_characters(\"1234567890\") == \"1234567890\"\n"... |
529e7f6eee553baf73175434cd90758d | [
{
"content": "Implémente un arbre de recherche binaire (ARB) avec les fonctionnalités suivantes :\n- Insérer une nouvelle clé dans l'ARB.\n- Supprimer une clé de l'ARB.\n- Rechercher une clé dans l'ARB et renvoyer le nœud si trouvé, sinon renvoyer `None`.\n\nTon implémentation doit inclure une classe `TreeNode`... | ["\nassert BinarySearchTree().search(10) is None\n", "\nassert BinarySearchTree().delete(10) is None\n", "\nbst = BinarySearchTree()\nbst.insert(10)\nassert bst.search(10).val == 10\n", "\nbst = BinarySearchTree()\nbst.insert(10)\nbst.insert(5)\nassert bst.search(5).val == 5\n", "\nbst = BinarySearchTree()\nbst.insert(... |
b204e65b45aee77e040e69a1b18e0d9b | [
{
"content": "On te donne un fichier CSV nommé `emails.csv` avec une seule colonne intitulée \"email\". Ta tâche est d'écrire un script Python qui lit ce fichier, valide chaque adresse e-mail selon les règles de validation d'e-mail courantes, et affiche uniquement les adresses e-mail valides. Les adresses e-mai... | ["\nassert is_valid_email(\"test@example.com\") == True\n", "\nassert is_valid_email(\"user.name+tag+sorting@example.com\") == True\n", "\nassert is_valid_email(\"user@sub.example.com\") == True\n", "\nassert is_valid_email(\"user@123.123.123.123\") == True\n", "\nassert is_valid_email(\"user@[IPv6:2001:db8::1]\") == T... |
c0d8cc176b9302913d1e59aed38cf72f | [
{
"content": "On te donne deux listes d'entiers, `list1` et `list2`. Ta tâche est d'implémenter une fonction `find_common_elements(list1, list2)` qui renvoie une liste d'entiers représentant les éléments communs aux deux listes. La liste renvoyée ne doit contenir aucun doublon et l'ordre des éléments doit être ... | ["\nassert find_common_elements([1, 2, 3, 4, 5], [4, 5, 6, 7, 8]) == [4, 5]\n", "\nassert find_common_elements([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_common_elements([], [1, 2, 3]) == []\n", "\nassert find_common_elements([1, 2, 3], []) == []\n", "\nassert find_common_elements([1, 1, 2, 2, 3, 3], [2, 3, 4, 5]) ... |
491f6068f808326b7899509c8b965b60 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de déterminer si elle est un palindrome, en ne considérant que les caractères alphanumériques et en ignorant la casse. Un palindrome est une chaîne de caractères qui se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entr... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"racecar\") == True\n", "\nassert is_palindrome(\"No lemon, no melon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nassert... |
5dfcb03a93f007946d8ff8a5dd32fd1c | [
{
"content": "On te donne une heure `t` au format `HH:MM` sous forme de chaîne de caractères. Ta tâche est d'écrire une fonction `time_slot(t)` qui renvoie l'heure ajustée pour un début avancé de 15 minutes. L'heure doit être renvoyée dans le même format `HH:MM`. Suppose que les heures d'entrée sont valides au ... | ["\nassert time_slot(\"00:10\") == \"23:55\"\n", "\nassert time_slot(\"12:45\") == \"12:30\"\n", "\nassert time_slot(\"00:00\") == \"23:45\"\n", "\nassert time_slot(\"23:59\") == \"23:44\"\n", "\nassert time_slot(\"15:15\") == \"15:00\"\n", "\nassert time_slot(\"09:05\") == \"08:50\"\n", "\nassert time_slot(\"11:11\") ... |
090b9b00d870bda95ec915fb2bc6f7e2 | [
{
"content": "On te donne une chaîne de caractères `st` qui peut contenir des mots séparés par des espaces et qui peut inclure des signes de ponctuation. Ta tâche est d'écrire une fonction `snake_case` qui convertit la chaîne en sa représentation snake case. En snake case, tous les mots sont en minuscules et sé... | ["\nassert snake_case(\"Hello, World!\") == \"hello_world\"\n", "\nassert snake_case(\"This is an Example-String!\") == \"this_is_an_example_string\"\n", "\nassert snake_case(\"Python's Syntax\") == \"pythons_syntax\"\n", "\nassert snake_case(\"Multiple Spaces\") == \"multiple_spaces\"\n", "\nassert snake_case(\"Tra... |
ced85336177e744d9cce2783a76c9501 | [
{
"content": "On te donne une image en niveaux de gris représentée comme une liste 2D d'entiers, où chaque entier est une valeur de pixel allant de 0 (noir) à 255 (blanc). Ta tâche est de mettre en œuvre une fonction appelée `grayscale_thresholding` qui prend l'image et une liste de valeurs de seuil en entrée e... | ["\nassert grayscale_thresholding([[100, 150, 200], [50, 200, 250]], [100]) == [[[255, 255, 255], [0, 255, 255]]]\n", "\nassert grayscale_thresholding([[100, 150, 200], [50, 200, 250]], [150]) == [[[0, 255, 255], [0, 255, 255]]]\n", "\nassert grayscale_thresholding([[100, 150, 200], [50, 200, 250]], [200]) == [[[0, 0, ... |
0f137642d67b083312f288e9cd4183f3 | [
{
"content": "Dans une compétition de programmation, on te donne la tâche d'optimiser une fonction récursive pour calculer le nième nombre de Fibonacci. La fonction doit être optimisée pour la performance sans en altérer le résultat. Implémente une version optimisée de la fonction.\n\n**Entrée :**\n- Un entier ... | ["\nassert fibonacci(0) == 1\n", "\nassert fibonacci(1) == 1\n", "\nassert fibonacci(2) == 1\n", "\nassert fibonacci(3) == 2\n", "\nassert fibonacci(4) == 3\n", "\nassert fibonacci(5) == 5\n", "\nassert fibonacci(10) == 55\n", "\nassert fibonacci(20) == 6765\n", "\nassert fibonacci(30) == 832040\n", "\nassert fibonacci... |
ccb8e2d3aafa0f0e971756a5c9d81b5e | [
{
"content": "On te demande d'implémenter une fonction `season_identifier` qui traite une liste d'années à 4 chiffres et renvoie un dictionnaire associant chaque année à l'identifiant de la saison sportive correspondante. L'identifiant de saison pour une année donnée doit être au format \"AAAA-AAAA\", représent... | ["\nassert season_identifier([2022]) == {2022: \"2022-2023\"}\n", "\nassert season_identifier([1999, 2000]) == {1999: \"1999-2000\", 2000: \"2000-2001\"}\n", "\nassert season_identifier([2020, 2021, 2022]) == {2020: \"2020-2021\", 2021: \"2021-2022\", 2022: \"2022-2023\"}\n", "\nassert season_identifier([1000, 9999]) =... |
57673d4c428a1024ce76a1eb799edcba | [
{
"content": "On te donne un itérable et un nombre réel `alpha`. Ta tâche est d'implémenter une fonction `calculate_renyi_entropy` qui calcule l'entropie de Rényi d'ordre `alpha` pour l'itérable donné. La fonction doit gérer les cas suivants :\n- Si un élément de l'itérable n'est pas hachable, ou si `alpha` n'e... | ["\nassert calculate_renyi_entropy([1, 2, 2, 3, 3, 3], 2) == 1.4591479170272448\n", "\nassert calculate_renyi_entropy([1, 1, 1, 1], 1.5) == 0.0\n", "\nassert calculate_renyi_entropy(['a', 'b', 'b', 'c', 'c', 'c'], 2) == 1.4591479170272448\n", "\nassert calculate_renyi_entropy((1, 2, 3, 4, 5), 1) == 1.6094379124341003\n... |
a598cd3cf817ada0d53cd9cd136f5836 | [
{
"content": "On te donne une liste de particules, chacune caractérisée par sa masse et la force d'un champ externe qui l'affecte. La masse perçue d'une particule est calculée comme `perceived_mass = mass * (1 + external_field_strength)`. Ta tâche est de filtrer les particules dont la masse perçue est inférieur... | ["\nassert filter_particles(11, [Particle(10, 0.1), Particle(5, 0.2), Particle(8, 0.05)]) == [Particle(10, 0.1)]\n", "\nassert filter_particles(6, [Particle(10, 0.1), Particle(5, 0.2), Particle(8, 0.05)]) == [Particle(10, 0.1), Particle(5, 0.2), Particle(8, 0.05)]\n", "\nassert filter_particles(12, [Particle(10, 0.1), ... |
a1a09839de1971c0fc9390727347ed74 | [
{
"content": "On te demande d'implémenter une classe Python nommée `PrimeChecker` qui inclut une méthode pour déterminer si un entier donné est un nombre premier. La méthode doit renvoyer `True` si le nombre est premier et `False` sinon. Ton implémentation doit être efficace et gérer correctement les cas limite... | ["\nassert PrimeChecker(2).is_prime() == True\n", "\nassert PrimeChecker(3).is_prime() == True\n", "\nassert PrimeChecker(4).is_prime() == False\n", "\nassert PrimeChecker(17).is_prime() == True\n", "\nassert PrimeChecker(18).is_prime() == False\n", "\nassert PrimeChecker(1).is_prime() == False\n", "\nassert PrimeCheck... |
2896a20de6249799174072151a494533 | [
{
"content": "On te donne une chaîne de caractères `s` composée de lettres majuscules en anglais. Ta tâche est de déterminer la longueur de la plus longue sous-séquence contiguë de caractères telle que chaque caractère de la sous-séquence apparaisse au moins `k` fois.\n\n**Entrée :**\n- Une chaîne de caractères... | ["\nassert longest_subsequence(\"ABABCB\", 2) == 4\n", "\nassert longest_subsequence(\"AABBBCCC\", 3) == 6\n", "\nassert longest_subsequence(\"AAABBBCCC\", 2) == 9\n", "\nassert longest_subsequence(\"AABBCC\", 1) == 6\n", "\nassert longest_subsequence(\"AABBCC\", 3) == 0\n", "\nassert longest_subsequence(\"ABCABCABC\",... |
e15e18160245f82b66854e68d38bfc76 | [
{
"content": "On te donne une structure d'entreprise composée d'équipes et d'individus. Chaque individu a un nom et un âge. Ta tâche est de calculer l'âge moyen de tous les individus de l'entreprise. L'entreprise est représentée par une classe `Company` qui contient plusieurs objets `Team`, et chaque objet `Tea... | ["\nassert get_average_age(Company()) == 0\n", "\nassert get_average_age(Company([Team([Person(\"Alice\", 30)])])) == 30\n", "\nassert get_average_age(Company([Team([Person(\"Bob\", 25), Person(\"Charlie\", 35)])])) == 30\n", "\nassert get_average_age(Company([Team([Person(\"David\", 40)]), Team([Person(\"Eve\", 20)])]... |
c16a5a08facdf29a536bdd48059887ef | [
{
"content": "On te donne un ensemble de données de trajectoires prédites pour plusieurs scènes. Chaque scène a un nombre variable de prédictions valides, et tu dois calculer l'erreur de déplacement moyen (ADE) minimale pour chaque scène. L'ADE d'une prédiction est la moyenne des distances euclidiennes entre le... | ["\nassert np.array_equal(min_ade_k_loss(np.array([[[[1, 1], [2, 2]]]]), np.array([[[1, 1], [2, 2]]]), [1]), np.array([0.0]))\n", "\nassert np.array_equal(min_ade_k_loss(np.array([[[[1, 1], [2, 2]], [[3, 3], [4, 4]]]]), np.array([[[1, 1], [2, 2]]]), [2]), np.array([0.0]))\n", "\nassert np.array_equal(min_ade_k_loss(np.... |
b71895fa7cd871a5f17f5505bc2496d2 | [
{
"content": "On te donne deux listes d'entiers. Ta tâche est d'écrire une fonction Python qui renvoie une liste contenant l'intersection de ces deux listes, c'est-à-dire les éléments qui sont communs aux deux listes. L'ordre des éléments dans la liste résultante n'a pas d'importance.\n\n**Exemple d'entrée :**\... | ["\nassert find_intersection([1, 2, 3, 4], [3, 4, 5, 6]) == [3, 4]\n", "\nassert find_intersection([1, 2, 3], [4, 5, 6]) == []\n", "\nassert find_intersection([], [1, 2, 3]) == []\n", "\nassert find_intersection([1, 2, 3], []) == []\n", "\nassert find_intersection([1, 1, 2, 2], [2, 2, 3, 3]) == [2]\n", "\nassert find_i... |
6b07d724222392b851afc3113ef3ba76 | [
{
"content": "On te donne un tableau d'entiers, `arr`. Ta tâche est de déterminer le nombre d'inversions dans le tableau. Une inversion est définie comme une paire d'indices `(i, j)` telle que `i < j` et `arr[i] > arr[j]`. Implémente un algorithme de type diviser pour régner qui divise le tableau en deux moitié... | ["\nassert count_inversions_with_stability([1, 20, 6, 4, 5]) == 5\n", "\nassert count_inversions_with_stability([1, 3, 5, 2, 4, 6]) == 3\n", "\nassert count_inversions_with_stability([10, 20, 30, 40, 50]) == 0\n", "\nassert count_inversions_with_stability([50, 40, 30, 20, 10]) == 10\n", "\nassert count_inversions_with_... |
7ae534499c1ba54aa3c1039f8d3415a7 | [
{
"content": "Conçois une API REST pour un système de bibliothèque simple qui prend en charge les opérations suivantes :\n- **Ajouter un Livre** : Accepte un objet JSON avec les champs `title` et `author` et ajoute le livre à la bibliothèque.\n- **Récupérer Tous les Livres** : Retourne une liste de tous les liv... | ["\nassert add_book().status_code == 400\n", "\nassert add_book(json={'title': '1984'}).status_code == 400\n", "\nassert add_book(json={'title': '1984', 'author': 'George Orwell'}).json['message'] == 'Book added successfully'\n", "\nassert get_books().json == [{'title': '1984', 'author': 'George Orwell'}]\n", "\nassert... |
6df8534ff647a286b4498ec543ee55e4 | [
{
"content": "On te donne une chaîne de caractères `file_path` représentant un chemin de fichier au format `/apfs<volume_index>`. Le `volume_index` est un entier positif qui est un carré parfait et qui ne dépasse pas 99. Ta tâche est d'implémenter une fonction `extract_volume_index` qui extrait et renvoie le `v... | ["\nassert extract_volume_index(\"/apfs16\") == 16\n", "\nassert extract_volume_index(\"/apfs10\") == None\n", "\nassert extract_volume_index(\"/apfs101\") == None\n", "\nassert extract_volume_index(\"/apfsabcd\") == None\n", "\nassert extract_volume_index(\"/apfs4\") == 4\n", "\nassert extract_volume_index(\"/apfs1\")... |
dc2a3d5d011d2593eeab00f6500bdcf0 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de trouver la plus longue sous-chaîne palindromique dans `s`. S'il existe plusieurs sous-chaînes palindromiques de longueur maximale identique, renvoie l'une d'entre elles. La solution doit être efficace en termes de complexité temporelle.\n\n... | ["\nassert longest_palindrome(\"babad\") == \"bab\" or longest_palindrome(\"babad\") == \"aba\"\n", "\nassert longest_palindrome(\"cbbd\") == \"bb\"\n", "\nassert longest_palindrome(\"a\") == \"a\"\n", "\nassert longest_palindrome(\"ac\") == \"a\" or longest_palindrome(\"ac\") == \"c\"\n", "\nassert longest_palindrome(... |
e3d92f1a21a84db2f60812dc3a83348a | [
{
"content": "On te donne une grille 2D et deux entiers `n` et `k`. Tu dois trouver le nombre de chemins distincts du point (0,0) au point (n,0). Tu peux te déplacer soit vers la droite (en augmentant la coordonnée x de 1), soit en diagonale vers le haut-droite (en augmentant les coordonnées x et y de la même v... | ["\nassert count_paths(0, 1, set()) == 1\n", "\nassert count_paths(1, 1, set()) == 1\n", "\nassert count_paths(2, 1, set()) == 1\n", "\nassert count_paths(3, 1, set()) == 1\n", "\nassert count_paths(3, 2, set()) == 3\n", "\nassert count_paths(3, 3, set()) == 5\n", "\nassert count_paths(3, 3, {(1, 1)}) == 4\n", "\nasser... |
405f90352bf50b2d64d39482c9b767d1 | [
{
"content": "On te donne un ensemble de points de données. Ta tâche est de concevoir une fonction `generate_identifier` qui traite ces points de données pour produire un identifiant unique et cohérent. La fonction doit effectuer les étapes suivantes :\n1. Convertir chaque point de données en chaîne de caractèr... | ["\nassert generate_identifier(\"Hello\", \"World\") == \"fc3ff98e8c6a0d3087d515c0473f8677\"\n", "\nassert generate_identifier(\"Python\", None, \"Programming\") == \"d0b650487437c725269598d6d9d2954f\"\n", "\nassert generate_identifier(\"OpenAI\", \"ChatGPT\") == \"b1b1a1a1a1a1a1a1a1a1a1a1a1a1a1a1\"\n", "\nassert gener... |
0543faa9c898d22b3911d31f6f3eef5c | [
{
"content": "On te donne un dictionnaire `d` et une liste de clés `keys`. Ta tâche est de mettre en œuvre une fonction `filter_keys(d, keys)` qui construit et renvoie un nouveau dictionnaire contenant uniquement les paires clé-valeur de `d` où la clé est présente dans la liste `keys`.\n\n**Entrée :**\n- Un dic... | ["\nassert filter_keys({'a': 1, 'b': 2, 'c': 3}, ['a', 'b']) == {'a': 1, 'b': 2}\n", "\nassert filter_keys({'x': 10, 'y': 20, 'z': 30}, ['x', 'z']) == {'x': 10, 'z': 30}\n", "\nassert filter_keys({'p': 100, 'q': 200, 'r': 300}, ['s', 't']) == {}\n", "\nassert filter_keys({}, ['a', 'b']) == {}\n", "\nassert filter_keys(... |
49648457baca60c684449a3ab4fe1c19 | [
{
"content": "On te donne une liste d'entiers `numbers`. Ta tâche est de trouver la somme maximale d'un sous-tableau qui respecte les critères suivants :\n- Le sous-tableau doit être composé d'au moins deux éléments.\n- Le sous-tableau ne doit pas contenir plus de trois éléments consécutifs ayant la même valeur... | ["\nassert max_sum_of_valid_subarray([1, 1, 1, 2, 2, 3, 3, 3, 3]) == 6\n", "\nassert max_sum_of_valid_subarray([1, 2, 3, 4, 5]) == 14\n", "\nassert max_sum_of_valid_subarray([1, 1, 1, 1]) == 2\n", "\nassert max_sum_of_valid_subarray([1, 1, 2, 2, 3, 3, 4, 4]) == 12\n", "\nassert max_sum_of_valid_subarray([1, 1, 1, 2, 2,... |
0ab747f012491f1e1c81bcae77ddaeac | [
{
"content": "On te donne une liste de chaînes de caractères `lines`, où chaque chaîne représente une ligne de texte. Ta tâche est de mettre en œuvre une fonction `find_next_valid_line` qui renvoie l'index de la prochaine ligne contenant des données réelles. Les lignes vides, qui ne contiennent que des espaces,... | ["\nassert find_next_valid_line([\"\", \"# comment\", \" \\t \", \"data1\", \"data2\", \"! ignore\"]) == 3\n", "\nassert find_next_valid_line([\"# comment\", \"! ignore\", \"data1\", \"data2\"]) == 2\n", "\nassert find_next_valid_line([\"\", \" \", \" # comment\", \" ! ignore\"]) == 4\n", "\nassert find_next_vali... |
9ab747373520e9ec4340a81316292596 | [
{
"content": "On te donne un tableau booléen unidimensionnel `bool_arr` de longueur `n` et un tableau `xs` de longueur `n+1`. Les éléments de `bool_arr` sont positionnés entre les éléments correspondants de `xs`. Plus précisément, `bool_arr[i]` est situé entre `xs[i]` et `xs[i+1]`.\n\nTa tâche est d'identifier ... | ["\nassert find_isolated_true_run([False, True, True, False, True, False, True, True, True, False], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == (3, 6, 8, 6, 9)\n", "\nassert find_isolated_true_run([False, True, False, True, False], [0, 1, 2, 3, 4, 5]) == (1, 1, 1, 1, 2)\n", "\nassert find_isolated_true_run([True, False, Tru... |
4cb24c88acf527283e7ab8a77872b96a | [
{
"content": "Dans un calendrier hypothétique, chaque mois compte 28 jours, à l'exception du dernier mois de l'année qui en compte 31. Les années bissextiles surviennent tous les quatre ans, à l'exception des années de fin de siècle qui doivent être divisibles par 500. Étant donné une date au format (année, moi... | ["\nassert next_date(2000, 12, 31) == (2001, 1, 1)\n", "\nassert next_date(2000, 2, 28) == (2000, 3, 1)\n", "\nassert next_date(1500, 12, 31) == (1501, 1, 1)\n", "\nassert next_date(2004, 2, 28) == (2004, 3, 1)\n", "\nassert next_date(2004, 12, 31) == (2005, 1, 1)\n", "\nassert next_date(1999, 12, 31) == (2000, 1, 1)\n... |
fb1a4b3debced8fe49ec5d9605e6ddc9 | [
{
"content": "On te demande d'implémenter une fonction `weighted_mean(data, weights)` qui calcule la moyenne arithmétique pondérée d'un ensemble de données avec une particularité. Pour ce problème, les poids négatifs indiquent une proportion inverse aux points de données. Plus précisément, si un poids est négat... | ["\nassert weighted_mean([1, 2, 3], [1, 1, 1]) == 2\n", "\nassert weighted_mean([1, 2, 3], [2, 1, 1]) == 1.5\n", "\nassert weighted_mean([1, 2, 3], [-1, -1, -1]) == 2\n", "\nassert weighted_mean([1, 2, 3], [1, -1, 1]) == 2\n", "\nassert weighted_mean([10, 20, 30], [1, 2, 3]) == 23.333333333333332\n", "\nassert weighted... |
16a1ee704e19920e6035b402f5cc461b | [
{
"content": "On te donne une liste de `n` entiers uniques et un entier positif `d`. Ta tâche est de trouver tous les sous-ensembles de la liste, y compris l'ensemble vide, tels que la somme des éléments de chaque sous-ensemble soit divisible par `d`. De plus, la taille de chaque sous-ensemble ne doit pas dépas... | ["\nassert find_valid_subsets([1, 2, 3, 4, 5], 3) == [(), (3,), (1, 2), (4,), (1, 5), (2, 4)]\n", "\nassert find_valid_subsets([1, 2, 3], 2) == [(), (2,), (1, 3)]\n", "\nassert find_valid_subsets([1, 2, 3, 6], 3) == [(), (3,), (6,), (1, 2), (1, 5), (2, 4)]\n", "\nassert find_valid_subsets([10, 20, 30, 40], 10) == [(), ... |
63d75165c6c4b495450b5ee8c5c314d0 | [
{
"content": "On te donne une liste imbriquée d'entiers. Ta tâche est d'écrire une fonction Python qui aplatit cette liste en une seule liste contenant tous les entiers de la liste d'origine, en préservant leur ordre. La fonction doit gérer des niveaux de nidification arbitraires.\n\n**Exemple d'entrée :**\n```... | ["\nassert flatten([[1, 2, [3, 4]], [5, 6], 7, [8, [9, 10]]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\nassert flatten([1, [2, [3, [4, [5]]]]]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert flatten([]) == []\n", "\nassert flatten([[], [], []]) == []\n", "\nassert flatten([[[... |
f00b9e643ff2ea74886562bfe5d553b1 | [
{
"content": "On te donne une liste d'éléments XML, chacun représenté comme un dictionnaire avec un identifiant unique sous la clé `'id'`. Certains identifiants peuvent apparaître plus d'une fois dans la liste. Ta tâche est de modifier la liste de sorte que tous les identifiants soient uniques en ajoutant un su... | ["\nassert make_identifiers_unique([{'id': 'a', 'name': 'A'}, {'id': 'b', 'name': 'B'}, {'id': 'a', 'name': 'A2'}]) == [{'id': 'a_1', 'name': 'A'}, {'id': 'b', 'name': 'B'}, {'id': 'a_2', 'name': 'A2'}]\n", "\nassert make_identifiers_unique([{'id': 'x', 'name': 'X'}, {'id': 'y', 'name': 'Y'}, {'id': 'z', 'name': 'Z'}])... |
fba709bb7b9d4ed40c9690d8c62bfd2e | [
{
"content": "On te donne une chaîne d'URL formatée comme `<base_url>|<branch>|<tag>`. Ta tâche est d'écrire une fonction `parse_url_info` qui analyse cette chaîne et renvoie un dictionnaire avec les clés `\"base_url\"`, `\"branch\"` et `\"tag\"`. Si l'un de ces composants est manquant, la valeur correspondante... | ["\nassert parse_url_info(\"http://example.com/repo.git|main|v1.0\") == {\"base_url\": \"http://example.com/repo.git\", \"branch\": \"main\", \"tag\": \"v1.0\"}\n", "\nassert parse_url_info(\"https://example.com/repo|develop\") == {\"base_url\": \"https://example.com/repo\", \"branch\": \"develop\", \"tag\": \"\"}\n", ... |
e31d7f5308d97f493664bcd65f5da1d5 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction qui renvoie un dictionnaire où chaque clé est un entier de la liste et la valeur correspondante est une liste de ses facteurs premiers. La fonction doit être optimisée pour gérer efficacement les grandes listes.\n\n**Entrée :**\n-... | ["\nassert number_to_prime_factors_map([28, 30, 60, 13]) == {28: [2, 2, 7], 30: [2, 3, 5], 60: [2, 2, 3, 5], 13: [13]}\n", "\nassert number_to_prime_factors_map([1, 2, 3, 4]) == {1: [], 2: [2], 3: [3], 4: [2, 2]}\n", "\nassert number_to_prime_factors_map([17, 19, 23]) == {17: [17], 19: [19], 23: [23]}\n", "\nassert num... |
d1c9997571b5304c54d425624d683d3b | [
{
"content": "On te demande d'implémenter une classe `Book` en Python. La classe doit avoir les attributs suivants : `title`, `author`, `published_year` et `isbn`. Implémente des méthodes pour mettre à jour chaque attribut, une méthode pour afficher les informations du livre au format \"Title: [title], Author: ... | ["\nassert Book(\"1984\", \"George Orwell\", 1949, \"9780451524935\").display_info() == \"Title: 1984, Author: George Orwell, Published Year: 1949, ISBN: 9780451524935\"\n", "\nassert Book(\"Animal Farm\", \"George Orwell\", 1945, \"9780451526342\").display_info() == \"Title: Animal Farm, Author: George Orwell, Publish... |
e2f2ef84f934bc75d371abdc74075d49 | [
{
"content": "On te donne une chaîne de caractères `expressions` contenant une séquence d'expressions mathématiques valides séparées par des points-virgules. Chaque expression est composée d'entiers et des opérateurs `+`, `-`, `*` et `/`. Ta tâche est d'évaluer chaque expression et de renvoyer les résultats dan... | ["\nassert evaluate_expressions(\"3 + 5\") == [8]\n", "\nassert evaluate_expressions(\"8 - 2; 4 * 6\") == [6, 24]\n", "\nassert evaluate_expressions(\"10 / 2; 7 + 3\") == [5.0, 10]\n", "\nassert evaluate_expressions(\"1 * 1; 2 * 2; 3 * 3\") == [1, 4, 9]\n", "\nassert evaluate_expressions(\"100 - 50; 200 + 300\") == [50... |
b6459fd1f9657924f24458f6db88ab97 | [
{
"content": "On te donne un nombre arbitraire de séquences d'ADN. Ta tâche est d'écrire une fonction `calculateSequenceSimilarity` qui calcule le pourcentage de nucléotides identiques pour toutes les combinaisons possibles de séquences. Seule la région qui se chevauche de chaque paire doit être prise en compte... | ["\nassert calculateSequenceSimilarity(\"ATCGTACG\", \"ATCGTAGC\") == {(0, 1): 75.0}\n", "\nassert calculateSequenceSimilarity(\"ATCGTACG\", \"ATCGTACG\") == {(0, 1): 100.0}\n", "\nassert calculateSequenceSimilarity(\"ATCGTACG\", \"GCTAGCTA\") == {(0, 1): 0.0}\n", "\nassert calculateSequenceSimilarity(\"ATCG\", \"ATCGT... |
61bde1b2096643ea0aaf6e391fbc9c82 | [
{
"content": "On te donne une liste d'entiers `A`. Ta tâche est d'implémenter la fonction `max_steps(A)` qui renvoie la longueur de la plus longue sous-séquence croissante dans `A`. La liste `A` peut être modifiée simultanément par un autre thread ou processus pendant l'exécution de ta fonction. Ton implémentat... | ["\nassert max_steps([1, 2, 3, 4, 5]) == 5\n", "\nassert max_steps([5, 4, 3, 2, 1]) == 1\n", "\nassert max_steps([10, 9, 2, 5, 3, 7, 101, 18]) == 4\n", "\nassert max_steps([1, 3, 5, 4, 7]) == 4\n", "\nassert max_steps([2, 2, 2, 2, 2]) == 1\n", "\nassert max_steps([]) == 0\n", "\nassert max_steps([1]) == 1\n", "\nassert... |
9f95612b0821379501a93b8b014818f5 | [
{
"content": "Implémente une classe Python `BinarySearchTree` qui représente un arbre de recherche binaire simple. La classe doit inclure des méthodes pour l'insertion, la suppression et le parcours en ordre. L'arbre doit être capable de gérer les valeurs dupliquées en les insérant dans le sous-arbre droit.\n\n... | ["\nassert BinarySearchTree().inorder_traversal(BinarySearchTree().root) == []\n", "\nbst = BinarySearchTree(); bst.insert(10); assert bst.inorder_traversal(bst.root) == [10]\n", "\nbst = BinarySearchTree(); bst.insert(10); bst.insert(5); bst.insert(15); assert bst.inorder_traversal(bst.root) == [5, 10, 15]\n", "\nbst ... |
987d5377886a2afa70c83ffa50960576 | [
{
"content": "On te donne une chaîne d'ID de pool qui suit la convention de nommage `copr_<hv_type>_<architecture>_<number>`. Le `<hv_type>` peut être soit `hv` soit `p09`, l'`<architecture>` peut être soit `x86_64` soit `ppc64le`, et le `<number>` est un nombre à deux chiffres. Ta tâche est d'implémenter une f... | ["\nassert map_pool_id_to_hypervisor(\"copr_hv_x86_64_12\")[2] == \"x86_64\"\n", "\nassert map_pool_id_to_hypervisor(\"copr_p09_ppc64le_34\")[3] == ['qcow2', 'raw', 'vmdk']\n", "\nassert map_pool_id_to_hypervisor(\"copr_hv_ppc64le_56\")[3] == ['raw', 'vmdk']\n", "\nassert map_pool_id_to_hypervisor(\"copr_p09_x86_64_78\... |
08bfadbfeae90fe082d2a0f7eb2de591 | [
{
"content": "On te donne un document texte. Ta tâche est d'écrire un script Python qui lit le document, compte la fréquence de chaque mot et affiche les 10 mots les plus courants ainsi que leurs fréquences. Le script doit ignorer les mots vides courants de la langue anglaise (par exemple, \"the\", \"and\", \"i... | ["\nassert read_and_count_words('test1.txt') == None # Assuming the function prints and does not return anything\n", "\nassert read_and_count_words('test2.txt') == None # Assuming the function prints and does not return anything\n", "\nassert read_and_count_words('test3.txt') == None # Assuming the function prints a... |
f6c3f0b0d6f7143a35f66b7c83eaa40a | [
{
"content": "On te donne une liste d'entiers `numbers`. Ta tâche est de classer ces entiers en deux catégories : pairs et impairs. Implémente une fonction `classify_numbers(numbers)` qui prend une liste d'entiers en entrée et renvoie un tuple de deux listes. La première liste doit contenir tous les nombres pai... | ["\nassert classify_numbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == ([2, 4, 6, 8, 10], [1, 3, 5, 7, 9])\n", "\nassert classify_numbers([0, -1, -2, -3, -4]) == ([-2, -4, 0], [-1, -3])\n", "\nassert classify_numbers([]) == ([], [])\n", "\nassert classify_numbers([11, 13, 17, 19]) == ([], [11, 13, 17, 19])\n", "\nassert class... |
efa299eb37880a88388ce14711474122 | [
{
"content": "On te donne un arbre de recherche binaire (BST) et une série d'opérations à effectuer sur celui-ci. Chaque opération est soit une insertion, une recherche, soit une suppression. Implémente la méthode de suppression pour la classe BST. Le BST doit prendre en charge les opérations suivantes :\n\n- `... | ["\nassert bst.search(50).val == 50\n", "\nassert bst.search(20).val == 20\n", "\nassert bst.search(100) is None\n", "\nbst.delete(20); assert bst.search(20) is None\n", "\nbst.delete(30); assert bst.search(30) is None\n", "\nbst.delete(50); assert bst.search(50) is None\n", "\nbst.insert(50); bst.insert(30); bst.inser... |
834c0069a0c2d9519df15aa14520b8c1 | [
{
"content": "On te donne une chaîne de caractères représentant une date et un indicateur booléen indiquant le format de cette chaîne. Ta tâche est d'analyser la chaîne de caractères de la date en un objet `datetime`. La chaîne de caractères de la date peut être dans l'un des deux formats en fonction de l'indic... | ["\nassert parse_date_string(\" 12/31/21 23:59 \", True) == datetime.strptime(\"12/31/21 23:59\", '%m/%d/%y %H:%M')\n", "\nassert parse_date_string(\"01/01/22\", False) == datetime.strptime(\"01/01/22\", '%m/%d/%y')\n", "\nassert parse_date_string(\" 07/04/20 12:00 \", True) == datetime.strptime(\"07/04/20 12:00\",... |
6f3ba5de9733212ea781132b1cd6b80c | [
{
"content": "On te demande d'implémenter une fonction `get_coordinate_system_info(epsg_code)` qui accepte un code EPSG en entrée et renvoie un dictionnaire avec les détails suivants sur le système de coordonnées :\n\n- **Name** : Le nom du système de coordonnées.\n- **Description** : Une brève description du s... | ["\nassert get_coordinate_system_info(4326)[\"Name\"] == \"WGS 84\"\n", "\nassert get_coordinate_system_info(3857)[\"Name\"] == \"WGS 84 / Pseudo-Mercator\"\n", "\nassert get_coordinate_system_info(27700)[\"Name\"] == \"OSGB 1936 / British National Grid\"\n", "\nassert get_coordinate_system_info(32633)[\"Name\"] == \"W... |
64a645190e66684c107f4ce282e58237 | [
{
"content": "On te donne une liste de nombres. Ta tâche est d'implémenter une fonction `doublesies` qui traite cette liste et renvoie une nouvelle liste où chaque nombre est doublé, à l'exception de ceux qui sont des nombres de Fibonacci. La fonction doit correctement gérer les nombres positifs, négatifs et dé... | ["\nassert doublesies([0, 1, 2, 3, 4, 5]) == [8, 12]\n", "\nassert doublesies([8, 13, 21, 34]) == [16, 68]\n", "\nassert doublesies([-1, -2, -3, -4, -5]) == [-8, -12]\n", "\nassert doublesies([1.5, 2.5, 3.5, 4.5]) == [3.0, 5.0, 7.0, 9.0]\n", "\nassert doublesies([0.5, 1.5, 2.5, 3.5, 4.5, 5.5]) == [1.0, 3.0, 5.0, 7.0, 9... |
68bb423022bbb9b1f8d19c71771b95c8 | [
{
"content": "Tu es chargé de développer une fonction Python nommée `classify_sentiment` qui détermine le sentiment d'un texte donné comme étant \"Positif\", \"Négatif\" ou \"Neutre\". Utilise la bibliothèque NLTK et son outil d'analyse de sentiment VADER à cette fin. Ta fonction doit renvoyer \"Positif\" si le... | ["\nassert classify_sentiment(\"I love this product!\") == 'Positive'\n", "\nassert classify_sentiment(\"This is the worst experience ever.\") == 'Negative'\n", "\nassert classify_sentiment(\"It's okay, not great but not bad.\") == 'Neutral'\n", "\nassert classify_sentiment(\"Absolutely fantastic!\") == 'Positive'\n", ... |
1ca75f3a9bc8e911478ee02fcc9b69b9 | [
{
"content": "On te donne un entier `N` tel que `2 ≤ N ≤ 79`. Ta tâche est de trouver toutes les paires de nombres à 5 chiffres `(abcde, fghij)` telles que `abcde / fghij == N`. La somme des chiffres de chaque nombre doit être un nombre premier. Le premier chiffre de l'un ou l'autre nombre peut être zéro. Affic... | ["\nassert find_pairs(2) == [(20002, 10001), (20020, 10010), (20200, 10100), (22000, 11000)]\n", "\nassert find_pairs(3) == [(30003, 10001), (30030, 10010), (30300, 10100), (33000, 11000)]\n", "\nassert find_pairs(4) == [(40004, 10001), (40040, 10010), (40400, 10100), (44000, 11000)]\n", "\nassert find_pairs(5) == [(50... |
bdf51d3a7f6d56cd7deada09ffe4fa75 | [
{
"content": "On te demande d'implémenter une fonction `extract_word_features` qui analyse une chaîne de caractères donnée `word` et renvoie un dictionnaire avec des caractéristiques spécifiques du mot. Les caractéristiques doivent inclure la longueur du mot, le nombre de voyelles, de consonnes, de lettres maju... | ["\nassert extract_word_features(\"ExampleWord123!\") == {'length': 15, 'num_vowels': 4, 'num_consonants': 7, 'num_uppercase': 2, 'num_lowercase': 8, 'num_digits': 3, 'num_special': 1}\n", "\nassert extract_word_features(\"HELLO\") == {'length': 5, 'num_vowels': 2, 'num_consonants': 3, 'num_uppercase': 5, 'num_lowercas... |
f6a472e9b81879e0311d19f44921901b | [
{
"content": "On te donne une phrase sous forme de chaîne de caractères. Ta tâche est d'implémenter une fonction `extract_ngrams` qui renvoie une liste de tous les n-grammes (unigrammes, bigrammes et trigrammes) de la phrase. Un n-gramme est une séquence contiguë de n éléments du texte. Utilise des expressions ... | ["\nassert extract_ngrams(\"The quick brown fox\") == [\"The\", \"quick\", \"brown\", \"fox\", \"The quick\", \"quick brown\", \"brown fox\", \"The quick brown\", \"quick brown fox\"]\n", "\nassert extract_ngrams(\"hello world\") == [\"hello\", \"world\", \"hello world\"]\n", "\nassert extract_ngrams(\"a\") == [\"a\"]\... |
c44f5f9b0c8dfd3c1a511d0425da6464 | [
{
"content": "On te demande d'écrire un programme pour générer tous les nombres premiers jusqu'à un entier donné \\( n \\). Ta solution doit être efficace et facile à comprendre. Implémente une fonction `generate_primes(n)` qui renvoie une liste de tous les nombres premiers de 2 à \\( n \\) inclusivement.\n\n**... | ["\nassert generate_primes(10) == [2, 3, 5, 7]\n", "\nassert generate_primes(1) == []\n", "\nassert generate_primes(2) == [2]\n", "\nassert generate_primes(20) == [2, 3, 5, 7, 11, 13, 17, 19]\n", "\nassert generate_primes(0) == []\n", "\nassert generate_primes(30) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n", "\nassert g... |
ed1b4f39a1ec550ee675c3801fc2e7ff | [
{
"content": "On te demande de créer une fonction `sparse_matrix(n, p, k)` qui construit une matrice de dimension `n` x `p` avec exactement `k` éléments non nuls. Chaque élément non nul doit être placé dans une position unique dans la matrice, et sa valeur doit être un entier aléatoire compris entre 1 et 100 (i... | ["\nassert sparse_matrix(3, 3, 0) == [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n", "\nassert len(sparse_matrix(4, 5, 3)) == 4\n", "\nassert all(len(row) == 5 for row in sparse_matrix(4, 5, 3))\n", "\nassert sum(row.count(0) for row in sparse_matrix(4, 5, 3)) == 17\n", "\nassert all(0 < val <= 100 for row in sparse_matrix(4, 5,... |
83521c23016fe22f1288bf8255c93ed0 | [
{
"content": "On te donne un répertoire contenant plusieurs fichiers texte. Ta tâche est d'écrire une fonction Python qui identifie et renvoie le nom du fichier avec le plus grand nombre de lignes. Si plusieurs fichiers ont le même nombre de lignes, renvoie le nom du premier fichier rencontré. Suppose que le ch... | ["\nassert find_file_with_max_lines(\"test_dir\") == \"file1.txt\"\n", "\nassert find_file_with_max_lines(\"test_dir\") == \"file2.txt\"\n", "\nassert find_file_with_max_lines(\"test_dir\") == \"file3.txt\"\n", "\nassert find_file_with_max_lines(\"test_dir\") == \"\"\n", "\nassert find_file_with_max_lines(\"non_existen... |
87ffb317a646a1199df4d6c9c17827de | [
{
"content": "Tu participes à un concours de programmation où tu dois implémenter une fonction pour interagir avec une API distante. Ta tâche est de créer une fonction Python nommée `post_with_retries` qui envoie une requête POST à une URL donnée avec des données et des en-têtes spécifiés. La fonction doit gére... | ["\nassert post_with_retries(\"https://httpbin.org/post\", {\"key\": \"value\"}).status_code == 200\n", "\nassert post_with_retries(\"https://httpbin.org/status/500\", {\"key\": \"value\"}).status_code == 500\n", "\nassert post_with_retries(\"https://httpbin.org/status/404\", {\"key\": \"value\"}).status_code == 404\n"... |
c5c69cb8352bcaf87f19a2dfe687d61a | [
{
"content": "On te donne un ensemble de données composé de plusieurs lignes de données. Chaque ligne contient plusieurs valeurs séparées par des tabulations. La première valeur de chaque ligne est une étiquette ou un identifiant et doit être ignorée. Ta tâche est de traiter cet ensemble de données et de renvoy... | ["\nassert process_and_sort_data([\"label\\t1.5\\t-2.5\\t3.0\"]) == [3.0, -2.5, 1.5]\n", "\nassert process_and_sort_data([\"id\\t100\\t200\\t300\"]) == [300.0, 200.0, 100.0]\n", "\nassert process_and_sort_data([\"ignore\\t-1\\t-2\\t-3\"]) == [-3.0, -2.0, -1.0]\n", "\nassert process_and_sort_data([\"skip\\t0.1\\t0.2\\t0... |
09cfc4a2d1e573c4cbd3ea0f6f9127e9 | [
{
"content": "On te charge de valider une liste de numéros d'immatriculation de véhicules dans l'État de Rio de Janeiro. Chaque numéro d'immatriculation est une chaîne de 8 chiffres qui suit un schéma spécifique. Les 7 premiers chiffres sont multipliés par un ensemble de poids [2, 7, 6, 5, 4, 3, 2] respectiveme... | ["\nassert validate_registration_number([\"12345670\"]) == [True]\n", "\nassert validate_registration_number([\"12345678\"]) == [False]\n", "\nassert validate_registration_number([\"00000000\"]) == [True]\n", "\nassert validate_registration_number([\"11111111\"]) == [False]\n", "\nassert validate_registration_number([\... |
c6934ec0d7d9e4a3db61dbb6bb84f1c2 | [
{
"content": "On te demande d'implémenter la fonction `adjust_frames` qui traite les images vidéo en fonction d'un profil spécifié. La fonction doit ajuster le nombre d'images selon les règles décrites ci-dessous, sans utiliser d'instructions if-else.\n\n**Signature de la fonction :**\n```python\ndef adjust_fra... | ["\nassert adjust_frames(1, '0 to scale to 0') == 2\n", "\nassert adjust_frames(2, '0 to scale to 0') == 2\n", "\nassert adjust_frames(1, '-scale to scale to -scale') == 2\n", "\nassert adjust_frames(4, '-scale to scale to -scale') == 4\n", "\nassert adjust_frames(5, 'sinusoidal: scale to -scale to scale') == 6\n", "\n... |
085fe4eef0af17a31cc1beea1d65ae2b | [
{
"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 `first_n_words` qui renvoie les `n` premiers mots de la chaîne `text`. Un mot est défini comme une séquence de caractères séparés par des espaces. Si `n` dépasse le nombre de mots dans `text`... | ["\nassert first_n_words(\"Hello world this is a test\", 3) == \"Hello world this\"\n", "\nassert first_n_words(\"One two three\", 5) == \"One two three\"\n", "\nassert first_n_words(\"Python is fun\", 1) == \"Python\"\n", "\nassert first_n_words(\"A quick brown fox jumps over the lazy dog\", 0) == \"\"\n", "\nassert f... |
33a93d614876b96b19de4e38c3d55123 | [
{
"content": "On te demande d'implémenter une classe Python `Employee` pour gérer les détails des employés et leurs projets assignés. La classe doit avoir les attributs suivants :\n- `name` : une chaîne de caractères représentant le nom de l'employé.\n- `id` : un entier représentant l'identifiant unique de l'em... | ["\nassert Employee(\"John Doe\", 1, \"Developer\").name == \"John Doe\"\n", "\nassert Employee(\"Jane Smith\", 2, \"Manager\").id == 2\n", "\nassert Employee(\"Alice Johnson\", 3, \"Designer\").position == \"Designer\"\n", "\nassert Employee(\"Bob Brown\", 4, \"Analyst\").get_projects() == []\n", "\nemp = Employee(\"C... |
bcc683a209e103c95abd69faddf28def | [
{
"content": "On te demande d'implémenter une classe `Calculator` en Python qui supporte les opérations arithmétiques de base : addition, soustraction, multiplication et division. La classe doit être initialisée avec une `initial_value`. Chaque opération arithmétique doit mettre à jour l'état interne de la calc... | ["\nassert Calculator(5).add(3) == 8\n", "\nassert Calculator(10).subtract(4) == 6\n", "\nassert Calculator(2).multiply(5) == 10\n", "\nassert Calculator(8).divide(2) == 4.0\n", "\nassert Calculator(10).divide(0) is None\n", "\nassert Calculator(7).reset() == 0\n", "\nassert Calculator(0).add(0) == 0\n", "\nassert Calc... |
25a9551bf452128e0994a9bafd4675ff | [
{
"content": "On te donne une chaîne de caractères `s` constituée de mots séparés par des espaces. Ta tâche est d'écrire une fonction qui inverse l'ordre des mots dans la chaîne tout en préservant la casse de chaque lettre. La chaîne d'entrée ne contiendra pas d'espaces de début ou de fin, et les mots seront ga... | ["\nassert reverse_words(\"The quick brown fox\") == \"fox brown quick The\"\n", "\nassert reverse_words(\"Hello World\") == \"World Hello\"\n", "\nassert reverse_words(\"Python is fun\") == \"fun is Python\"\n", "\nassert reverse_words(\"a b c d e\") == \"e d c b a\"\n", "\nassert reverse_words(\"single\") == \"single... |
1a923397db655f197771ecc30859eae9 | [
{
"content": "Tu es chargé d'implémenter une fonction `process_file(path)` qui traite un fichier texte situé au `path` spécifié. La fonction doit lire le contenu du fichier et remplacer tous les caractères de nouvelle ligne (`\\n`, `\\r\\n`, ou `\\r`) par un seul espace, à l'exception des séquences de caractère... | ["\nassert process_file(\"test1.txt\") == \"This is a test file.\"\n", "\nassert process_file(\"test2.txt\") == 'Line1 Line2 Line3'\n", "\nassert process_file(\"test3.txt\") == 'Line1\\nLine2 Line3'\n", "\nassert process_file(\"test4.txt\") == 'Line1\\rLine2 Line3'\n", "\nassert process_file(\"test5.txt\") == 'Line1\\r... |
90665a22fc65532d3e419705d1970221 | [
{
"content": "On te donne un entier `num`. Ta tâche est de déterminer si le nombre est invariant par symétrie, c'est-à-dire s'il se lit de la même manière de gauche à droite et de droite à gauche. Pour les besoins de ce problème, les nombres négatifs ne sont pas considérés comme invariants par symétrie. Impléme... | ["\nassert is_mirror_invariant(121) == True\n", "\nassert is_mirror_invariant(12321) == True\n", "\nassert is_mirror_invariant(123) == False\n", "\nassert is_mirror_invariant(1) == True\n", "\nassert is_mirror_invariant(0) == True\n", "\nassert is_mirror_invariant(-121) == False\n", "\nassert is_mirror_invariant(-12321... |
defb0f8c547411e54332c409a5b066a9 | [
{
"content": "On te demande de maintenir une liste dynamique des chiffres de vente quotidiens d'un magasin et de calculer efficacement la médiane de ces chiffres de vente à mesure que de nouvelles données sont ajoutées. Implémente une classe `MedianMaintainer` avec les méthodes suivantes :\n\n- `__init__(self, ... | ["\nassert MedianMaintainer([1, 2, 3, 4, 5]).calculate_median() == 3\n", "\nassert MedianMaintainer([1, 2, 3, 4]).calculate_median() == 2.5\n", "\nassert MedianMaintainer([7]).calculate_median() == 7\n", "\nassert MedianMaintainer([10, 20, 30, 40, 50, 60]).calculate_median() == 35.0\n", "\nassert MedianMaintainer([5, 3... |
954f08791cd2c9d7bd0bfcc1d9e22c7b | [
{
"content": "On te demande de concevoir un modèle Django nommé `Book` pour gérer la collection de livres d'une bibliothèque. Le modèle doit inclure les champs suivants :\n- `title` : une chaîne de caractères représentant le titre du livre, d'une longueur maximale de 255 caractères et ne peut pas être vide.\n- ... | ["\nassert Book.objects.create(title=\"Book One\", author=\"Author A\", publication_date=datetime.date(2020, 1, 1), genre=\"Fiction\", isbn=\"1234567890123\").isbn == \"1234567890123\"\n", "\nassert Book.objects.create(title=\"Book Two\", author=\"Author B\", publication_date=datetime.date(2021, 5, 15), genre=\"Non-Fic... |
2603710b327dd83486a0de12ee0b4679 | [
{
"content": "On te demande de trouver les deux stations spatiales les plus proches d'un point donné dans un plan 2D en utilisant la métrique L∞ (distance de Chebyshev). Écris une fonction `closest_two_stations` qui prend une liste de coordonnées de stations spatiales et les coordonnées d'un point en entrée et ... | ["\nassert closest_two_stations([(1, 1), (4, 4), (2, 2), (6, 6)], (3, 3)) == [(2, 2), (4, 4)]\n", "\nassert closest_two_stations([(0, 0)], (1, 1)) == [(0, 0), (0, 0)]\n", "\nassert closest_two_stations([], (1, 1)) == []\n", "\nassert closest_two_stations([(1, 1), (2, 2), (3, 3)], (0, 0)) == [(1, 1), (2, 2)]\n", "\nasse... |
cef935184e0cc2085fb122efde4e0d0e | [
{
"content": "On te donne une chaîne de caractères `target` et une liste de chaînes de caractères `word_bank`. Ta tâche est de déterminer si la chaîne `target` peut être construite en concaténant des éléments de `word_bank`. Chaque élément de `word_bank` peut être utilisé plusieurs fois. Implémente la fonction ... | ["\nassert can_construct_alternate(\"abcdef\", [\"ab\", \"abc\", \"cd\", \"def\", \"abcd\"]) == True\n", "\nassert can_construct_alternate(\"skateboard\", [\"bo\", \"rd\", \"ate\", \"t\", \"ska\", \"sk\", \"boar\"]) == False\n", "\nassert can_construct_alternate(\"enterapotentpot\", [\"a\", \"p\", \"ent\", \"enter\", \... |
0d1003dbd1365d31ab9b2197fea6400d | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction qui calcule la somme de tous les entiers de la liste. La fonction doit être optimisée pour la lisibilité, la maintenabilité et l'efficacité.\n\n**Exemple d'entrée :**\n```python\n[1, 2, 3, 4, 5]\n```\n\n**Exemple de sortie :**... | ["\nassert calculate_sum([1, 2, 3, 4, 5]) == 15\n", "\nassert calculate_sum([-1, -2, -3, -4, -5]) == -15\n", "\nassert calculate_sum([0, 0, 0, 0, 0]) == 0\n", "\nassert calculate_sum([100, 200, 300]) == 600\n", "\nassert calculate_sum([]) == 0\n", "\nassert calculate_sum([1.5, 2.5, 3.5]) == 7.5\n", "\nassert calculate_... |
afb68cb8c94845fa6dbaa06976be9c4d | [
{
"content": "On te donne une chaîne de caractères `text`. Ton objectif est d'implémenter une fonction `count_unique_chars(text: str) -> Dict[str, int]` qui renvoie un dictionnaire contenant le nombre de chaque caractère unique dans la chaîne, en ignorant la casse et en excluant les espaces et la ponctuation. L... | ["\nassert count_unique_chars(\"Hello, World!\") == {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}\n", "\nassert count_unique_chars(\"A quick brown fox jumps over the lazy dog.\") == {'a': 1, 'q': 1, 'u': 2, 'i': 1, 'c': 1, 'k': 1, 'b': 1, 'r': 2, 'o': 4, 'w': 1, 'n': 1, 'f': 1, 'x': 1, 'j': 1, 'm': 1, 'p': 1... |
afb06d7cbce8a5020eb332ec4c533256 | [
{
"content": "On te donne une liste de chaînes de caractères. Pour chaque chaîne, trie les caractères par ordre croissant en fonction de leur fréquence. Si deux caractères ont la même fréquence, trie-les par ordre alphabétique. Retourne la liste des chaînes transformées.\n\n**Entrée :**\n- Une liste de chaînes ... | ["\nassert sort_strings_by_char_frequency([\"apple\"]) == [\"aelpp\"]\n", "\nassert sort_strings_by_char_frequency([\"banana\"]) == [\"aaabnn\"]\n", "\nassert sort_strings_by_char_frequency([\"cherry\"]) == [\"cehrry\"]\n", "\nassert sort_strings_by_char_frequency([\"aabbcc\"]) == [\"aabbcc\"]\n", "\nassert sort_string... |
21e456c2b10921537d59895caa00be1f | [
{
"content": "On te donne une liste chaînée simple où chaque nœud contient une seule valeur entière. Implémente une fonction qui calcule la somme de toutes les valeurs des nœuds dans la liste, en excluant tous les nœuds dont la valeur est supérieure à 10. La fonction doit prendre l'en-tête de la liste chaînée e... | ["\nassert sum_values_excluding_greater_than_ten(ListNode(5, ListNode(15, ListNode(10, ListNode(3))))) == 18\n", "\nassert sum_values_excluding_greater_than_ten(ListNode(11, ListNode(12, ListNode(13)))) == 0\n", "\nassert sum_values_excluding_greater_than_ten(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))... |
b3663f918784c1cb0fb457a7d8773deb | [
{
"content": "On te donne une chaîne de caractères `S` de longueur `N`. Ta tâche est de déterminer la longueur de la plus longue sous-chaîne de `S` qui est un palindrome. Un palindrome est une chaîne de caractères qui se lit de la même manière de gauche à droite et de droite à gauche. Si `S` est une chaîne vide... | ["\nassert longest_palindrome_substring(\"babad\") == 3\n", "\nassert longest_palindrome_substring(\"cbbd\") == 2\n", "\nassert longest_palindrome_substring(\"a\") == 1\n", "\nassert longest_palindrome_substring(\"ac\") == 1\n", "\nassert longest_palindrome_substring(\"racecar\") == 7\n", "\nassert longest_palindrome_s... |
d5bed0c23698af57684e04e43b39ed23 | [
{
"content": "On te donne une structure de données trie contenant un ensemble de mots. Ta tâche est de déterminer si un mot donné peut être segmenté en une séquence de mots séparés par des espaces, où chaque mot est présent dans le trie et a un nombre impair de caractères.\n\n**Entrée :**\n- Une chaîne de carac... | ["\nassert can_segment_word(\"kiwiapplepie\", root) == False\n", "\nassert can_segment_word(\"kiwiapple\", root) == True\n", "\nassert can_segment_word(\"applepie\", root) == True\n", "\nassert can_segment_word(\"applespies\", root) == False\n", "\nassert can_segment_word(\"kiwi\", root) == True\n", "\nassert can_segme... |
5ca8e17169a6fe74aa47573053568601 | [
{
"content": "On te donne une chaîne de caractères `sentence`. Ta tâche est de déterminer si la phrase est un palindrome. Une phrase est considérée comme un palindrome si, après l'avoir transformée en une séquence de nombres où chaque lettre est remplacée par sa position dans l'alphabet anglais (en ignorant les... | ["\nassert is_mirrored_sentence(\"A man, a plan, a canal: Panama\") == True\n", "\nassert is_mirrored_sentence(\"Was it a car or a cat I saw?\") == False\n", "\nassert is_mirrored_sentence(\"No lemon, no melon\") == True\n", "\nassert is_mirrored_sentence(\"12321\") == True\n", "\nassert is_mirrored_sentence(\"12345\")... |
4881f9eb8d0d70c3b5c1341ffa4ee679 | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'implémenter une fonction `find_largest_prime` qui identifie et renvoie le plus grand nombre premier présent dans la liste. Si la liste ne contient aucun nombre premier, la fonction doit renvoyer -1. Utilise l'algorithme du crible d'Ératosthène po... | ["\nassert find_largest_prime([10, 15, 3, 7, 11, 20, 17]) == 17\n", "\nassert find_largest_prime([4, 6, 8, 10]) == -1\n", "\nassert find_largest_prime([2, 3, 5, 7, 11, 13, 17, 19]) == 19\n", "\nassert find_largest_prime([]) == -1\n", "\nassert find_largest_prime([1, 4, 6, 8, 9, 10]) == -1\n", "\nassert find_largest_pri... |
8e450266b4bed30fb23657d05d8b850f | [
{
"content": "On te donne une chaîne de caractères `s` contenant des mots séparés par des espaces. Ta tâche est d'écrire une fonction qui traite cette chaîne et renvoie une liste de mots triés par ordre alphabétique. La fonction doit ignorer la ponctuation et considérer les lettres majuscules et minuscules comm... | ["\nassert sort_words_alphabetically(\"The quick brown fox jumps over the lazy dog!\") == ['brown', 'dog', 'fox', 'jumps', 'lazy', 'over', 'quick', 'the', 'the']\n", "\nassert sort_words_alphabetically(\"Hello, World!\") == ['hello', 'world']\n", "\nassert sort_words_alphabetically(\"Python is fun, isn't it?\") == ['fu... |
e663e4cbb97d519ce3bd2640bf9df1f5 | [
{
"content": "On te charge de surveiller les relevés de température d'un réacteur chimique, qui sont enregistrés chaque minute. Cependant, certains relevés peuvent être manquants en raison de dysfonctionnements des capteurs et sont représentés par des valeurs NaN. Ces valeurs NaN doivent être ignorées lors de l... | ["\nassert check_temperature(pd.Series([75, 80, 85, 90, 95])) == None\n", "\nassert check_temperature(pd.Series([75, 80, 69, 90, 95])) == 2\n", "\nassert check_temperature(pd.Series([75, 80, 101, 90, 95])) == 2\n", "\nassert check_temperature(pd.Series([np.nan, 75, 80, 85, 90])) == None\n", "\nassert check_temperature(... |
7c0333a4785081a93b6db52f8d119cea | [
{
"content": "On te donne un entier positif `n`. Définis une séquence `a(n)` où chaque terme est le n-ième nombre triangulaire, calculé comme `a(n) = n * (n + 1) / 2`. Ta tâche est de calculer le produit des `n` premiers termes de cette séquence, puis de déterminer la somme des chiffres de ce produit. Retourne ... | ["\nassert triangle_product(1) == 1\n", "\nassert triangle_product(2) == 3\n", "\nassert triangle_product(3) == 9\n", "\nassert triangle_product(4) == 18\n", "\nassert triangle_product(5) == 45\n", "\nassert triangle_product(6) == 108\n", "\nassert triangle_product(7) == 252\n", "\nassert triangle_product(8) == 576\n",... |
91bb4e2efab0e001342b8326d50ae7f7 | [
{
"content": "On te donne une chaîne de caractères `s` composée de caractères alphanumériques, d'espaces et de caractères spéciaux. Ta tâche est de mettre en œuvre une fonction `compress_string` qui compresse la chaîne en supprimant tous les caractères dupliqués consécutifs tout en préservant l'ordre de la prem... | ["\nassert compress_string(\"aaabbbccc\") == \"abc\"\n", "\nassert compress_string(\"aabbcc!!@@##\") == \"abc\"\n", "\nassert compress_string(\"aAaAaA\") == \"aAaAaA\"\n", "\nassert compress_string(\" a a a \") == \"a\"\n", "\nassert compress_string(\"a!b@c#d$\") == \"abcd\"\n", "\nassert compress_string(\"hello ... |
7db1071e6bccfe278ecd65b20409cabf | [
{
"content": "On te donne une image en niveaux de gris représentée comme une liste 2D d'entiers, où chaque entier est une valeur de pixel comprise entre 0 et 255. Ta tâche est de mettre en œuvre une fonction qui ajoute du bruit aléatoire à l'image, simulant un effet de type ISO élevé. Le bruit doit être ajouté ... | ["\nassert add_noise([[0, 0], [0, 0]], 0) == [[0, 0], [0, 0]]\n", "\nassert add_noise([[128, 128], [128, 128]], 0) == [[128, 128], [128, 128]]\n", "\nassert add_noise([[255, 255], [255, 255]], 0) == [[255, 255], [255, 255]]\n", "\nassert add_noise([[0, 0], [0, 0]], 10) != [[0, 0], [0, 0]]\n", "\nassert all(0 <= pixel <... |
8b7798b729ef32e4b73f15e6ec022889 | [
{
"content": "On te donne une liste chaînée simple et un entier `k`. Ta tâche est d'inverser chaque groupe de `k` nœuds dans la liste chaînée. Si le nombre de nœuds n'est pas un multiple de `k`, les nœuds restants à la fin doivent rester tels quels. Tu n'es pas autorisé à modifier les valeurs dans les nœuds, se... | ["\nassert reverseKGroup(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))), 3).val == 3\n", "\nassert reverseKGroup(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))), 3).next.val == 2\n", "\nassert reverseKGroup(ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))), 3).next.next.va... |
9f44d02a980f026da0c13cc199d33ad8 | [
{
"content": "Dans le jeu du pendu, tu dois implémenter une fonction `display_word_progress` qui aide le joueur à deviner un mot secret. La fonction prend deux paramètres : `secret_word` (une chaîne de caractères représentant le mot à deviner) et `guessed_letters` (une liste de caractères représentant les lettr... | ["\nassert display_word_progress(\"hello\", ['h', 'l']) == \"h ? l l ?\"\n", "\nassert display_word_progress(\"hello\", ['h', 'e']) == \"h e l _ e\"\n", "\nassert display_word_progress(\"world\", ['w', 'r', 'l', 'd']) == \"w o r l d\"\n", "\nassert display_word_progress(\"python\", ['p', 'y', 't', 'h', 'o', 'n']) == \"... |
4d9ffa63e7faf4ca2a56602b029282c0 | [
{
"content": "On te donne un fichier CSV nommé `data.csv` avec `N` lignes et `M` colonnes. La première ligne contient les en-têtes de colonnes, et les lignes restantes contiennent des valeurs numériques. Ta tâche est d'écrire un script Python qui lit ce fichier CSV et calcule la moyenne de chaque colonne. Le sc... | ["\nassert calculate_column_averages('data.csv') == None # Assuming the function prints to console and does not return anything\n", "\nassert calculate_column_averages('empty.csv') == None # Test with an empty CSV file\n", "\nassert calculate_column_averages('single_row.csv') == None # Test with a CSV file containin... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.