id stringlengths 32 32 | prompts listlengths 1 1 | unit_tests stringlengths 242 7.91k |
|---|---|---|
45dc86f3ee07251b4c4fd14b8568ccb6 | [
{
"content": "On te donne une liste d'entiers. Ta tâche est de calculer la moyenne pondérée de ces entiers, où le poids de chaque entier est défini comme le nombre de ses facteurs premiers uniques. Un nombre premier a un poids de 1. Si la liste est vide, retourne \"Aucun nombre fourni\". Si un élément de la lis... | ["\nassert calculate_average([2, 3, 5]) == 3.3333333333333335\n", "\nassert calculate_average([4, 6, 8]) == 6.0\n", "\nassert calculate_average([0, 0, 0]) == \"Cannot divide by zero\"\n", "\nassert calculate_average([0, 2, 3, 5]) == 3.3333333333333335\n", "\nassert calculate_average([]) == \"No numbers provided\"\n", "... |
dac5325a35d941d64f1966f735216f36 | [
{
"content": "On te demande d'implémenter une classe `Circle` en Python. La classe doit avoir les fonctionnalités suivantes :\n\n- **Initialisation** : La classe doit être initialisée avec un attribut `radius`.\n- **Calcul de l'aire** : Implémente une méthode `area` qui renvoie l'aire du cercle.\n- **Calcul de ... | ["\nassert Circle(1).area() == math.pi\n", "\nassert Circle(0).area() == 0\n", "\nassert Circle(2).circumference() == 4 * math.pi\n", "\nassert Circle(5).circumference() == 10 * math.pi\n", "\nassert Circle(3).set_radius(4) is None\n", "\nassert Circle(3).set_radius(4) or Circle(3).radius == 4\n", "\nassert Circle(10).... |
055895dc747e419fac08c23bc19b1449 | [
{
"content": "On te charge de gérer un réseau distribué de serveurs répartis dans différentes régions, chacune représentée par un « centre de données ». Ton système fournit une fonction `get_regions_from_network()` qui renvoie une liste de toutes les régions. Cependant, s'il n'y a qu'une seule région, elle renv... | ["\nassert get_unique_regions() == {\"north\"} if get_regions_from_network() == \" North \" else True\n", "\nassert get_unique_regions() == {\"north\", \"south\"} if get_regions_from_network() == [\"North\", \" south \"] else True\n", "\nassert get_unique_regions() == {\"east\", \"west\"} if get_regions_from_network... |
03fc86ad23f5be2f583a3c001646c48a | [
{
"content": "On te donne un jeu de cartes représenté comme une liste doublement chaînée d'entiers, où chaque entier représente une carte unique. Le jeu est initialement trié par ordre croissant. Implémente l'algorithme de mélange Fisher-Yates pour mélanger le jeu. L'algorithme de mélange Fisher-Yates fonctionn... | ["\nassert fisher_yates_shuffle(DoublyLinkedList()).to_list() == []\n", "\nassert fisher_yates_shuffle(DoublyLinkedList([1])).to_list() == [1]\n", "\nassert len(fisher_yates_shuffle(DoublyLinkedList([1, 2, 3, 4, 5])).to_list()) == 5\n", "\nassert set(fisher_yates_shuffle(DoublyLinkedList([1, 2, 3, 4, 5])).to_list()) ==... |
b99dac6b5bf100a21cce2509be2fca0d | [
{
"content": "On te donne un entier `upperbnd`. Ta tâche est d'écrire une fonction `sum_even_fibonacci_primes(upperbnd)` qui calcule la somme de tous les nombres de Fibonacci pairs inférieurs ou égaux à `upperbnd` qui sont également des nombres premiers. La suite de Fibonacci commence par 1 et 2. Un nombre prem... | ["\nassert sum_even_fibonacci_primes(10) == 2\n", "\nassert sum_even_fibonacci_primes(34) == 2\n", "\nassert sum_even_fibonacci_primes(100) == 2\n", "\nassert sum_even_fibonacci_primes(1) == 0\n", "\nassert sum_even_fibonacci_primes(2) == 2\n", "\nassert sum_even_fibonacci_primes(0) == 0\n", "\nassert sum_even_fibonacc... |
b5ce11cae37ea05830f2bc8cb8c233e0 | [
{
"content": "On te donne une liste de chaînes de caractères `strings`. Ta tâche est d'implémenter une fonction `filter_palindromes(strings)` qui renvoie une nouvelle liste contenant uniquement les palindromes de la liste originale. Une chaîne de caractères est considérée comme un palindrome si, une fois tous l... | ["\nassert filter_palindromes([\"radar\", \"hello\", \"A man a plan a canal Panama\", \"world\", \"Madam In Eden Im Adam\"]) == [\"radar\", \"A man a plan a canal Panama\", \"Madam In Eden Im Adam\"]\n", "\nassert filter_palindromes([\"\", \" \", \"a\", \"aa\"]) == [\"\", \" \", \"a\", \"aa\"]\n", "\nassert filter_pali... |
89adfea97e974cb61d31e6cec4b5968c | [
{
"content": "On te donne une liste de chaînes de caractères. Ton objectif est de mettre en œuvre une fonction `remove_duplicates` qui traite cette liste et renvoie une nouvelle liste contenant uniquement la première occurrence de chaque chaîne, dans l'ordre où elles apparaissent. La liste d'entrée contiendra t... | ["\nassert remove_duplicates([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"kiwi\"]) == [\"apple\", \"banana\", \"orange\", \"kiwi\"]\n", "\nassert remove_duplicates([\"a\", \"b\", \"c\", \"a\", \"b\", \"c\"]) == [\"a\", \"b\", \"c\"]\n", "\nassert remove_duplicates([\"hello\", \"world\", \"hello\", \"wor... |
9f3f943425dea95aa9275f5bcc66c099 | [
{
"content": "On te donne deux matrices, `A` et `B`, de dimensions `(d, n1)` et `(d, n2)` respectivement. Ta tâche est de calculer la similarité de Jaccard généralisée entre chaque paire de vecteurs dans `A` et `B`. Pour chaque paire de vecteurs, considère les vecteurs comme des ensembles de leurs éléments non ... | ["\nassert np.array_equal(generalized_jaccard_similarity(np.array([[1, 2], [3, 4]]), np.array([[1, 0], [0, 4]])), np.array([[1.0, 0.6], [0.6, 1.0]]))\n", "\nassert np.array_equal(generalized_jaccard_similarity(np.array([[0, 0], [0, 0]]), np.array([[0, 0], [0, 0]])), np.array([[1.0, 1.0], [1.0, 1.0]]))\n", "\nassert np.... |
3e26ce8e38a15375d2b73fcac7db33dc | [
{
"content": "On te donne une liste d'entiers. Ta tâche est d'écrire une fonction `count_occurrences` qui renvoie un dictionnaire. Les clés du dictionnaire doivent être les entiers uniques de la liste, et les valeurs doivent être le nombre de fois que chaque entier apparaît dans la liste.\n\n**Entrée :**\n- Une... | ["\nassert count_occurrences([1, 2, 2, 3, 3, 3]) == {1: 1, 2: 2, 3: 3}\n", "\nassert count_occurrences([4, 4, 4, 4]) == {4: 4}\n", "\nassert count_occurrences([1, 1, 2, 2, 3, 3, 4, 4]) == {1: 2, 2: 2, 3: 2, 4: 2}\n", "\nassert count_occurrences([]) == {}\n", "\nassert count_occurrences([7]) == {7: 1}\n", "\nassert coun... |
51bfb51eccc00b32f2dcb520c744ff59 | [
{
"content": "On te donne une liste de chaînes de caractères `lines`, où chaque chaîne représente un enregistrement avec des champs séparés par des points-virgules (`;`). Implémente une fonction `sort_by_field(lines, field_index)` qui trie ces enregistrements en fonction du champ à l'index `field_index` spécifi... | ["\nassert sort_by_field([\"Alice;30;Engineer\", \"bob;25;Designer\", \"Charlie;35;Manager\", \"dave;28;Developer\"], 0) == [\"Alice;30;Engineer\", \"bob;25;Designer\", \"Charlie;35;Manager\", \"dave;28;Developer\"]\n", "\nassert sort_by_field([\"Alice;30;Engineer\", \"bob;25;Designer\", \"Charlie;35;Manager\", \"dave;... |
4a6734819a63e6d1be7c6b26ad37f056 | [
{
"content": "On te demande d'écrire un programme Python qui génère une liste d'entiers aléatoires dans la plage de 1 à 100 et de les trier par ordre croissant. Le programme doit utiliser le module `random` pour générer les entiers et la méthode `sort` pour trier la liste. L'utilisateur doit saisir le nombre d'... | ["\nassert generate_and_sort_numbers(1) == sorted([random.randint(1, 100) for _ in range(1)])\n", "\nassert generate_and_sort_numbers(5) == sorted([random.randint(1, 100) for _ in range(5)])\n", "\nassert generate_and_sort_numbers(10) == sorted([random.randint(1, 100) for _ in range(10)])\n", "\nassert generate_and_sor... |
55853a2ce67e9f7ce8088644506b39e9 | [
{
"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 ne considérant que les caractères alphanumériques et en ignorant la casse. Une chaîne est un palindrome si elle se lit de la même manière de gauche à droite et de droite à gauche.\n\n**Entrée :*... | ["\nassert is_palindrome(\"A man, a plan, a canal, Panama\") == True\n", "\nassert is_palindrome(\"race a car\") == False\n", "\nassert is_palindrome(\"No 'x' in Nixon\") == True\n", "\nassert is_palindrome(\"Was it a car or a cat I saw?\") == True\n", "\nassert is_palindrome(\"Not a palindrome\") == False\n", "\nasser... |
ba5d5785647b118e952f1f4b699d031a | [
{
"content": "On te donne un graphe orienté avec `n` nœuds et `m` arêtes, représenté sous forme de liste d'adjacence. Le graphe peut contenir plusieurs arêtes entre les nœuds, des boucles et des cycles de n'importe quelle longueur. Ta tâche est de déterminer s'il existe un chemin cyclique du nœud source `s` au ... | ["\nassert is_cyclic_path({0: [1], 1: [2], 2: [0]}, 0, 0) == True\n", "\nassert is_cyclic_path({0: [1], 1: [2]}, 0, 2) == False\n", "\nassert is_cyclic_path({0: [1], 1: [0]}, 0, 1) == True\n", "\nassert is_cyclic_path({0: [1], 1: [2], 2: [3]}, 0, 3) == False\n", "\nassert is_cyclic_path({0: [0]}, 0, 0) == True\n", "\na... |
087b4f3b2e295e41ad357d329f78db7d | [
{
"content": "On te donne une chaîne de caractères `s` représentant une séquence d'éléments séparés par un délimiteur `d`. La chaîne `s` peut contenir plusieurs occurrences du délimiteur `d`. Ta tâche est de mettre en œuvre une fonction `split_items(s, d)` qui divise la chaîne `s` à la première occurrence du dé... | ["\nassert split_items(\"item1=item2=item3\", \"=\") == [\"item1\", \"item2=item3\"]\n", "\nassert split_items(\"item1\", \"=\") == [\"item1\", \"\"]\n", "\nassert split_items(\"\", \"=\") == [\"\", \"\"]\n", "\nassert split_items(\" item1 = item2 \", \"=\") == [\"item1\", \"item2\"]\n", "\nassert split_items(\"ite... |
0ce4ee82cd3111f0f8fbc7058248a5d1 | [
{
"content": "On te donne une chaîne de caractères `text`. Ta tâche est d'écrire une fonction qui compte la fréquence de chaque mot dans la chaîne, en ignorant les mots vides courants tels que \"the\", \"and\", \"is\", \"at\", \"over\" et \"back\". La fonction doit renvoyer un dictionnaire avec les mots comme c... | ["\nassert word_frequency(\"The quick brown fox jumps over the lazy dog.\") == {'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}\n", "\nassert word_frequency(\"The dog barked back at the fox.\") == {'dog': 1, 'barked': 1, 'back': 1, 'fox': 1}\n", "\nassert word_frequency(\"The quick brown f... |
2f27dd5b9dd6b18127654d099013f627 | [
{
"content": "On te donne une liste non triée d'entiers `nums` et un entier `target`. Ta tâche est de trouver toutes les paires uniques d'entiers dans `nums` telles que la somme de chaque paire soit égale à `target`. Chaque entier dans `nums` peut être utilisé au plus une fois dans les paires, et aucun indice n... | ["\nassert find_pairs_with_target_sum([1, 2, 3, 4, 5], 5) == [(1, 4), (2, 3)]\n", "\nassert find_pairs_with_target_sum([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_pairs_with_target_sum([1, 2, 3, 4, 5], 9) == [(4, 5)]\n", "\nassert find_pairs_with_target_sum([1, 2, 3, 4, 5], 6) == [(1, 5), (2, 4)]\n", "\nassert find_p... |
26dcc84846f8e02843f1c3ba921d5e3d | [
{
"content": "On te donne une liste d'entiers représentant le nombre de pas effectués par une personne chaque jour sur une période donnée. Ta tâche est de générer un histogramme qui affiche la fréquence de chaque nombre impair de pas. Les jours avec un nombre pair de pas doivent être exclus de l'histogramme.\n\... | ["\nassert plot_odd_steps_histogram([1, 2, 3, 4, 5]) == None\n", "\nassert plot_odd_steps_histogram([2, 4, 6, 8]) == None\n", "\nassert plot_odd_steps_histogram([1, 3, 5, 7, 9]) == None\n", "\nassert plot_odd_steps_histogram([11, 22, 33, 44, 55]) == None\n", "\nassert plot_odd_steps_histogram([10, 15, 20, 25, 30]) == N... |
71ac3accac154161c98a5b55a910791b | [
{
"content": "On te donne une série de listes. Ta tâche est d'écrire une fonction `combine_lists_alternating` qui prend un nombre quelconque de listes en arguments et renvoie une nouvelle liste qui alterne les éléments de chaque liste d'entrée. Si les listes d'entrée ont des longueurs différentes, la fonction d... | ["\nassert combine_lists_alternating([1, 2, 3], ['a', 'b'], [True, False, None]) == [1, 'a', True, 2, 'b', False, 3, None]\n", "\nassert combine_lists_alternating([1, 2], [3, 4], [5, 6], [7, 8]) == [1, 3, 5, 7, 2, 4, 6, 8]\n", "\nassert combine_lists_alternating([1, 2, 3], ['a', 'b']) == [1, 'a', 2, 'b', 3]\n", "\nasse... |
ddb883b38a5f213074cb143417fcc665 | [
{
"content": "Tu es chargé d'implémenter une fonction `convert_time` qui convertit une durée donnée en secondes en un format lisible par un humain. La fonction doit accepter un nombre à virgule flottante représentant la durée et renvoyer une chaîne formatée comme `HHhMMmSS.sssZ`. Ici, `HH` représente les heures... | ["\nassert convert_time(0) == \"00h00m00.000Z\"\n", "\nassert convert_time(3600) == \"01h00m00.000Z\"\n", "\nassert convert_time(3661.1234) == \"01h01m01.123Z\"\n", "\nassert convert_time(60) == \"00h01m00.000Z\"\n", "\nassert convert_time(59.999) == \"00h00m59.999Z\"\n", "\nassert convert_time(3661.6789) == \"01h01m01... |
09c958a8af9a540dc8c6ebf9ddf5c1b6 | [
{
"content": "On te demande d'implémenter une fonction `calculate_interest` qui calcule les intérêts composés pour un montant principal donné, un taux d'intérêt annuel et une durée d'investissement. Les intérêts sont composés annuellement. Ta fonction doit accepter trois paramètres : `principal` (le montant ini... | ["\nassert calculate_interest(1000, 5, 10) == 628.894626777442\n", "\nassert calculate_interest(1500, 4.3, 6) == 438.8388589249973\n", "\nassert calculate_interest(2000, 3, 5) == 318.6391128430775\n", "\nassert calculate_interest(500, 7, 3) == 112.26152500000003\n", "\nassert calculate_interest(1000, 0, 10) == 0.0\n", ... |
8a5f6914f4a05366dc0853cbbe242c96 | [
{
"content": "On te demande d'évaluer la précision des évaluations de clients prédites pour un produit, où chaque évaluation est étiquetée comme positive (1) ou négative (0). Compte tenu de la nature du produit, les évaluations négatives sont plus importantes et se voient donc attribuer un poids plus élevé que ... | ["\nassert weighted_review_score(np.array([[1, 1], [0, 0]]), 1, 2) == 0.0\n", "\nassert weighted_review_score(np.array([[1, 0], [0, 1]]), 1, 2) == 1.0\n", "\nassert weighted_review_score(np.array([[0.5, 0.5], [0.5, 0.5]]), 1, 2) == 0.0\n", "\nassert weighted_review_score(np.array([[1, 0.9], [0, 0.1]]), 1, 2) == 0.01\n"... |
bc65eb683d99d6cdbbd70e600c0832be | [
{
"content": "On te donne une liste d'entiers. Ton objectif est d'écrire une fonction Python qui renvoie une nouvelle liste contenant les carrés des entiers de la liste d'entrée. Utilise des compréhensions de liste pour y parvenir de manière concise et lisible.\n\n**Exemple d'entrée :**\n```python\n[1, 2, 3, 4,... | ["\nassert square_numbers([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]\n", "\nassert square_numbers([-1, -2, -3, -4, -5]) == [1, 4, 9, 16, 25]\n", "\nassert square_numbers([0, 1, 2, 3, 4]) == [0, 1, 4, 9, 16]\n", "\nassert square_numbers([]) == []\n", "\nassert square_numbers([10, 20, 30]) == [100, 400, 900]\n", "\nassert squ... |
ba2c936f3fae1329faa34f1ac05004ff | [
{
"content": "On te donne une liste de lignes, où chaque ligne contient au moins deux éléments : un nom de table et un nom de champ. Ton objectif est de créer une fonction `parse_rows` qui traite cette liste et renvoie un dictionnaire avec le format suivant :\n\n- Chaque clé est un nom de table (sans tenir comp... | ["\nassert parse_rows([[\"Table1\", \"Field1\"], [\"Table1\", \"Field2\"]]) == {\"table1\": [\"field1\", \"field2\"]}\n", "\nassert parse_rows([[\"TABLE1\", \"FIELD1\"], [\"table1\", \"field2\"]]) == {\"table1\": [\"field1\", \"field2\"]}\n", "\nassert parse_rows([[\"table1\", \"field1\"], [\"table2\", \"field1\"]]) ==... |
b4b81134267cb7b543761d188d8af9aa | [
{
"content": "On te demande de développer un classificateur d'analyse des sentiments pour un texte donné. Le classificateur doit catégoriser le texte en \"positif\", \"négatif\" ou \"neutre\" en fonction de la présence de mots-clés positifs et négatifs prédéfinis. Les règles de classification sont les suivantes... | ["\nassert classify_sentiment(\"The movie was fantastic, but the ending was disappointing.\", [\"fantastic\", \"great\", \"good\", \"excellent\"], [\"disappointing\", \"bad\", \"terrible\", \"awful\"]) == \"neutral\"\n", "\nassert classify_sentiment(\"The movie was fantastic and great!\", [\"fantastic\", \"great\", \"g... |
4d9ae4db1ee77ecd3d01b2adb5ee23fb | [
{
"content": "On te donne un fichier CSV nommé `execution_times.csv` contenant une liste de temps d'exécution pour un programme. Chaque ligne du fichier représente un temps d'exécution unique en secondes. Les temps d'exécution sont listés dans l'ordre où ils ont été enregistrés, et le fichier peut contenir jusq... | ["\nassert calculate_average_difference('test1.csv') == 0.0 # File with one execution time\n", "\nassert calculate_average_difference('test2.csv') == 1.0 # File with two execution times, difference is 1.0\n", "\nassert calculate_average_difference('test3.csv') == 2.0 # File with three execution times, difference bet... |
173d0f4e00b3f6f1ac393cf38929d749 | [
{
"content": "On te demande d'écrire une fonction `convert_seconds_to_human_readable` qui traite des durées fournies en secondes et les convertit en un format lisible par l'homme `HH:MM:SS`. La fonction doit être capable de gérer les durées qui dépassent 24 heures. De plus, la fonction doit être capable d'accep... | ["\nassert convert_seconds_to_human_readable(0) == \"00:00:00\"\n", "\nassert convert_seconds_to_human_readable(1) == \"00:00:01\"\n", "\nassert convert_seconds_to_human_readable(59) == \"00:00:59\"\n", "\nassert convert_seconds_to_human_readable(60) == \"00:01:00\"\n", "\nassert convert_seconds_to_human_readable(3600)... |
517ea72805c46e32c86c1d398bcea06d | [
{
"content": "On te donne deux listes, `x` et `filter_list`. Ta tâche est d'implémenter une fonction `self_return_filtered(x, filter_list)` qui renvoie une nouvelle liste contenant uniquement les éléments de `x` qui ne sont pas présents dans `filter_list`. Tu **n'es pas** autorisé à utiliser les méthodes intégr... | ["\nassert self_return_filtered([1, 2, 3, 4, 5], [2, 4]) == [1, 3, 5]\n", "\nassert self_return_filtered(['a', 'b', 'c', 'd'], ['b', 'd']) == ['a', 'c']\n", "\nassert self_return_filtered([10, 20, 30, 40], [10, 30]) == [20, 40]\n", "\nassert self_return_filtered([], [1, 2, 3]) == []\n", "\nassert self_return_filtered([... |
187dc461ea5fbec4a556f5040da6d45d | [
{
"content": "On te donne la tâche d'implémenter une fonction `read_cfd` qui traite un fichier dans un format personnalisé, `.cfd` (Custom Format Data). Chaque ligne du fichier `.cfd` contient des métadonnées concernant un ensemble de données au format `key=value`. Les clés sont `Dimensions`, `DataTypes`, `Scal... | ["\nassert read_cfd('test1.cfd') == OrderedDict({'Dimensions': [3, 4], 'DataTypes': ['int8', 'float32'], 'ScalingFactors': [1.0, 2.0], 'Offsets': [0, 0], 'IsSigned': [True, False]})\n", "\nassert read_cfd('test2.cfd') == OrderedDict({'Dimensions': [1], 'DataTypes': ['int32'], 'ScalingFactors': [1.5], 'Offsets': [10], '... |
285a7a8dcf4349ead32012c93ae21636 | [
{
"content": "On te demande d'implémenter une classe `TemperatureConverter` en Python qui prenne en charge la conversion de températures entre Celsius, Fahrenheit et Kelvin. Ta classe doit fournir trois méthodes : `to_celsius(temp, scale)`, `to_fahrenheit(temp, scale)` et `to_kelvin(temp, scale)`. Chaque méthod... | ["\nassert TemperatureConverter().to_celsius(100, 'C') == 100.0\n", "\nassert TemperatureConverter().to_celsius(212, 'F') == 100.0\n", "\nassert TemperatureConverter().to_celsius(373.15, 'K') == 100.0\n", "\nassert TemperatureConverter().to_fahrenheit(0, 'C') == 32.0\n", "\nassert TemperatureConverter().to_fahrenheit(3... |
aa195f5cc04ae2dd9d86f02a54bf1d43 | [
{
"content": "Implémente une structure de données pile en utilisant une liste en Python. Ta pile doit prendre en charge les opérations suivantes :\n- `is_empty()` : Renvoie `True` si la pile est vide, sinon `False`.\n- `push(item)` : Ajoute un élément au sommet de la pile.\n- `pop()` : Supprime et renvoie l'élé... | ["\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 st... |
b55b5c91b1a0414dbc182af5332ed874 | [
{
"content": "On te donne une liste triée d'étudiants, chacun représenté par un tuple contenant un identifiant unique et une note. Ta tâche est de mettre en œuvre une fonction qui trouve l'étudiant avec l'identifiant immédiatement supérieur à un identifiant donné, dont la note est un nombre premier. Si un tel é... | ["\nassert next_prime_grade_student([(1, 88), (2, 97), (3, 64), (4, 83), (5, 91), (6, 79), (7, 100)], 4) == (6, 79)\n", "\nassert next_prime_grade_student([(1, 88), (2, 97), (3, 64), (4, 83), (5, 91), (6, 79), (7, 100)], 6) == (2, 97)\n", "\nassert next_prime_grade_student([(1, 88), (2, 97), (3, 64), (4, 83), (5, 91), ... |
b7f8c0744c1f66b922adfa8662595e37 | [
{
"content": "On te donne un fichier CSV nommé \"data.csv\" contenant des données numériques. Ta tâche est d'écrire un script Python qui lit ce fichier et calcule la moyenne de chaque colonne. La première ligne du fichier CSV contient les en-têtes de chaque colonne. Ton programme doit afficher la moyenne de cha... | ["\nassert calculate_column_averages('data.csv') == None\n", "\nassert calculate_column_averages('empty.csv') == None\n", "\nassert calculate_column_averages('single_row.csv') == None\n", "\nassert calculate_column_averages('single_column.csv') == None\n", "\nassert calculate_column_averages('multiple_columns.csv') == ... |
0041232706afb51594031d0f0f69e7cb | [
{
"content": "On te donne un dictionnaire Python `data` représentant un objet JSON avec une structure plate. Ta tâche est de mettre en œuvre une fonction `json_to_markdown` qui convertit cet objet JSON en un tableau Markdown. Les clés du dictionnaire doivent être utilisées comme en-têtes de colonne, et les vale... | ["\nassert json_to_markdown({\"name\": \"John Doe\", \"age\": 30, \"email\": \"john.doe@example.com\"}) == \"| name | age | email |\\n|------|-----|---------------------|\\n| John Doe | 30 | john.doe@example.com |\"\n", "\nassert json_to_markdown({\"key1\": \"value1\", \"key2\": \"value2\"}) == \"| key1 | key2 |\\n|---... |
3d8fffe498fb80e54aaf7a6810d299fb | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est de traiter cette chaîne selon les règles suivantes :\n\n1. Convertis tous les caractères en minuscules.\n2. Remplace tous les caractères de nouvelle ligne (`\\n`) par un seul tiret (`-`).\n3. Supprime tous les signes de ponctuation et les cara... | ["\nassert filter_string(\"A man, a plan, a canal, Panama!\\nWas it a car or a cat I saw?\") == \"a man a plan a canal panama -was it a car or a cat i saw\"\n", "\nassert filter_string(\"No lemon, no melon\") == \"no lemon no [[melon]]\"\n", "\nassert filter_string(\"Was it a car or a cat I saw?\") == \"was it a car or... |
e5ed70b332fa7dc812ef2c00fc33a73e | [
{
"content": "Tu es chargé de traiter un fichier texte contenant des sous-titres de films accompagnés de leurs horodatages. Chaque ligne du fichier respecte le format : `<movie_id> <subtitle_text> <start_timestamp> <end_timestamp>`. Ton objectif est de mettre en œuvre une fonction qui lit ce fichier et renvoie ... | ["\nassert read_subtitles(\"test1.txt\") == {'1': [('Hello World', 120000, 130000)]}\n", "\nassert read_subtitles(\"test2.txt\") == {'2': [('Subtitle 1', 5000, 10000), ('Subtitle 2', 15000, 20000)]}\n", "\nassert read_subtitles(\"test3.txt\") == {'3': [('Another subtitle', 0, 5000)]}\n", "\nassert read_subtitles(\"test... |
40e09a4c72b4fa663144c901c2b5c4cf | [
{
"content": "Tu es chargé de traiter une image en utilisant une technique de fenêtre glissante. L'image est divisée en blocs d'une taille spécifiée, et chaque bloc est traité indépendamment. Pour éviter la perte de détails importants aux limites de ces blocs, un chevauchement est introduit. Le chevauchement es... | ["\nassert calculate_overlap(100, 20, 5) == (95, 20)\n", "\nassert calculate_overlap(200, 10, 10) == (180, 20)\n", "\nassert calculate_overlap(50, 50, 0) == (50, 25)\n", "\nassert calculate_overlap(150, 0, 20) == (120, 0)\n", "\nassert calculate_overlap(100, 100, 0) == (100, 100)\n", "\nassert calculate_overlap(100, 0,... |
c7d131bb18b2e330f1925a26e93ade54 | [
{
"content": "On te donne un arbre de recherche binaire (BST) représenté par une classe `TreeNode` avec des attributs `value`, `left` et `right`. Implémente une fonction `find_maximum` qui renvoie la valeur maximale stockée dans le BST. Le BST est garanti d'avoir au moins un nœud.\n\n**Exemple d'entrée :**\n```... | ["\nassert find_maximum(TreeNode(5)) == 5\n", "\nassert find_maximum(TreeNode(1, None, TreeNode(2))) == 2\n", "\nassert find_maximum(TreeNode(10, TreeNode(5), TreeNode(20))) == 20\n", "\nassert find_maximum(TreeNode(3, TreeNode(1), TreeNode(4, TreeNode(2)))) == 4\n", "\nassert find_maximum(TreeNode(7, TreeNode(3, TreeN... |
80aaf33aa9694a60924b2baf150bee3a | [
{
"content": "On te donne une liste de chaînes de caractères représentant les relevés de vote des membres du parlement (députés). Chaque chaîne contient le nom de famille du député, son affiliation politique (soit 'R' pour Républicain, soit 'D' pour Démocrate), son état d'origine et une séquence de votes (0, 1 ... | ["\nassert parse_voting_records([\"Smith R CA 1 0 -1 1\"]) == {\"Smith\": [1, 0, -1, 1]}\n", "\nassert parse_voting_records([\"Johnson D NY -1 1 0 1\"]) == {\"Johnson\": [-1, 1, 0, 1]}\n", "\nassert parse_voting_records([\"Williams R FL 0 -1 1 0\"]) == {\"Williams\": [0, -1, 1, 0]}\n", "\nassert parse_voting_records([\... |
4c9bdaa478c5f5f405ca7a04c832aba9 | [
{
"content": "Tu participes à un concours de programmation où tu dois traiter un fichier CSV manuellement, sans utiliser de fonctions ou de bibliothèques d'analyse CSV intégrées. Le fichier CSV contient des informations sur diverses villes avec les colonnes suivantes : CityName, Latitude et Longitude. Ta tâche ... | ["\nassert parse_csv_to_json('test1.csv') == {\"CityName\": [\"CityA\", \"CityB\"], \"Latitude\": [\"34.05\", \"36.12\"], \"Longitude\": [\"-118.24\", \"-115.17\"]}\n", "\nassert parse_csv_to_json('test2.csv') == {\"CityName\": [\"CityC\"], \"Latitude\": [\"40.71\"], \"Longitude\": [\"-74.01\"]}\n", "\nassert parse_csv... |
e354d950b5d55e1503c88e3c7e0dbcbd | [
{
"content": "On te donne un entier non négatif `n`. Ta tâche est de déterminer si `n` est une puissance de 4 en utilisant uniquement des opérations bit à bit. Un nombre est une puissance de 4 s'il peut être exprimé comme 4 élevé à une certaine puissance entière (par exemple, 1, 4, 16, 64, ...).\n\n**Entrée :**... | ["\nassert isPowerOfFour(0) == False\n", "\nassert isPowerOfFour(1) == True\n", "\nassert isPowerOfFour(4) == True\n", "\nassert isPowerOfFour(16) == True\n", "\nassert isPowerOfFour(64) == True\n", "\nassert isPowerOfFour(2) == False\n", "\nassert isPowerOfFour(8) == False\n", "\nassert isPowerOfFour(32) == False\n", ... |
013339dce4f00da1452e983d92625fe9 | [
{
"content": "On te demande d'implémenter une classe `BankAccount` en Python. La classe doit prendre en charge les opérations suivantes :\n- **Dépôt** : Ajouter un montant spécifié au solde du compte. La méthode doit renvoyer `True` si le dépôt est réussi, sinon `False`.\n- **Retrait** : Soustraire un montant s... | ["\nassert BankAccount().get_balance() == 0\n", "\nassert BankAccount(100).get_balance() == 100\n", "\nassert BankAccount(100).deposit(50) == True\n", "\nassert BankAccount(100).deposit(-50) == False\n", "\nassert BankAccount(100).withdraw(50) == True\n", "\nassert BankAccount(100).withdraw(150) == False\n", "\nassert ... |
8103864d40f573a72e316a4516b6a19e | [
{
"content": "On te donne une liste d'entiers sur 16 bits représentant une séquence de données. Ta tâche est de convertir cette liste en une liste d'entiers sur 32 bits ou 64 bits en fonction des options fournies. La conversion consiste à combiner tous les 2 ou 4 entiers sur 16 bits consécutifs en un seul entie... | ["\nassert convert_integers([0x1234, 0x5678], True, False) == [0x12345678]\n", "\nassert convert_integers([0x1234, 0x5678], False, False) == [0x56781234]\n", "\nassert convert_integers([0x1234, 0x5678, 0x9ABC, 0xCDEF], True, True) == [0x123456789ABCDEF]\n", "\nassert convert_integers([0x1234, 0x5678, 0x9ABC, 0xCDEF], F... |
c26180cec330d394c5b22661093245ce | [
{
"content": "On te demande d'implémenter une classe `Book` et une classe `BookStore` en Python. La classe `Book` doit avoir les attributs `title`, `author` et `isbn`. La classe `BookStore` doit gérer une collection d'objets `Book` et fournir des méthodes pour ajouter, supprimer et rechercher des livres. La fon... | ["\nassert BookStore().search_by_isbn(\"1234567890\") == []\n", "\nassert BookStore().search_by_title(\"Python Programming\") == []\n", "\nassert BookStore().search_by_author(\"John Doe\") == []\n", "\nbook_store = BookStore()\nbook_store.add_book(Book(\"Python Programming\", \"John Doe\", \"1234567890\"))\nassert book... |
ba96c4d0ba3390797a275afce1862ef5 | [
{
"content": "On te donne un poème sous forme de fichier texte. Ta tâche est d'écrire une fonction `process_poem(poem: TextIO) -> List[str]` qui lit le poème ligne par ligne, traite chaque ligne en supprimant les espaces blancs en début et en fin de ligne, ainsi que toute ponctuation au début et à la fin de cha... | ["\nassert process_poem(open('test1.txt', 'r')) == [\"This\", \"is\", \"a\", \"test\"]\n", "\nassert process_poem(open('test2.txt', 'r')) == [\"Line1\", \"Line2\", \"Line3\"]\n", "\nassert process_poem(open('test3.txt', 'r')) == [\"No\", \"extra\", \"spaces\", \"here\"]\n", "\nassert process_poem(open('test4.txt', 'r')... |
e1de78688c2382b5f2cb4906e0803ba3 | [
{
"content": "On te demande d'écrire un test unitaire pour une fonction nommée `validate_email(email)`. Cette fonction est conçue pour valider le format d'une adresse e-mail et doit lever une exception `ValueError` si l'entrée est une chaîne vide. Ton objectif est de t'assurer que la fonction se comporte correc... | ["\nassert validate_email(\"test@example.com\") == True\n", "\nassert validate_email(\"user@domain.co.uk\") == True\n", "\nassert validate_email(\"user.name+tag+sorting@example.com\") == True\n", "\nassert validate_email(\"user@sub.domain.com\") == True\n", "\nassert validate_email(\"user@domain\") == True # Assuming ... |
562ced7a6b8880ce245c584e1e28e52b | [
{
"content": "On te demande d'implémenter une fonction `max_priority_task` qui traite un flux continu de tâches et identifie la tâche ayant la priorité la plus élevée à un moment donné. Chaque tâche est représentée comme un objet avec deux attributs : `name` (une chaîne de caractères) et `priority` (un entier p... | ["\nassert max_priority_task([Task(\"task1\", 1), Task(\"task2\", 2), Task(\"task3\", 3)]) == \"task3\"\n", "\nassert max_priority_task([Task(\"task1\", 3), Task(\"task2\", 2), Task(\"task3\", 1)]) == \"task1\"\n", "\nassert max_priority_task([Task(\"task1\", 1), Task(\"task2\", 1), Task(\"task3\", 1)]) == \"task1\"\n"... |
35cadb0597324421e660ac05fdce9912 | [
{
"content": "On te donne une chaîne de caractères `s` et un entier `n`. Construis une matrice `n x n` où chaque cellule est remplie avec un caractère de la chaîne `s` 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. Cependant, pour chaque ... | ["\nassert create_spiral_matrix(\"abcdefghi\", 3) == [['a', 'b', 'c'], ['f', 'h', 'd'], ['g', 'i', 'e']]\n", "\nassert create_spiral_matrix(\"abcde\", 3) == [['a', 'b', 'c'], ['e', 'd', ' '], [' ', ' ', ' ']]\n", "\nassert create_spiral_matrix(\"abcdefgh\", 4) == [['a', 'b', 'c', 'd'], ['h', 'g', 'f', 'e'], ['i', 'j', ... |
a5862865f15df43b7039e1a596baddc0 | [
{
"content": "On te donne un fichier binaire composé d'une séquence de blocs de 8 octets. Chaque bloc représente deux entiers non signés de 32 bits, N1 et N2, stockés dans l'ordre d'octets big-endian. Ta tâche est d'écrire une fonction `process_binary_file` qui lit le fichier binaire et renvoie une liste de tup... | ["\nassert process_binary_file('test1.bin') == [(0x20212223, 0x24252627)]\n", "\nassert process_binary_file('test2.bin') == [(0x20212223, 0x24252627), (0x28292A2B, 0x2C2D2E2F)]\n", "\nassert process_binary_file('test3.bin') == []\n", "\nassert process_binary_file('test4.bin') == [(0x20212223, 0x24252627)]\n", "\nassert... |
b92cbe47fd686ecba64db09fd456ca7d | [
{
"content": "On te donne une liste d'entiers représentant les hauteurs de montagnes consécutives. Un pic est défini comme une montagne qui est plus haute que ses voisins immédiats. Ta tâche est de déterminer le nombre de pics dans la liste.\n\n**Entrée :**\n- Une liste d'entiers `heights` (1 ≤ len(heights) ≤ 1... | ["\nassert count_peaks([1, 3, 1, 4, 1]) == 2\n", "\nassert count_peaks([1, 2, 3, 4, 5]) == 0\n", "\nassert count_peaks([5, 4, 3, 2, 1]) == 0\n", "\nassert count_peaks([1, 2, 3, 2, 1]) == 1\n", "\nassert count_peaks([1, 3, 2, 4, 3, 5, 4]) == 3\n", "\nassert count_peaks([1]) == 0\n", "\nassert count_peaks([]) == 0\n", "\... |
081c98b47530eed2db1e6a9515048565 | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est d'implémenter une fonction `optimize_sort(arr)` qui trie le tableau par ordre croissant en utilisant un algorithme de tri optimisé avec une complexité temporelle moyenne de O(n log n). L'algorithme doit être plus efficace que la méthode `sort()` intég... | ["\nassert optimize_sort([38, 27, 43, 3, 9, 82, 10]) == [3, 9, 10, 27, 38, 43, 82]\n", "\nassert optimize_sort([5, 2, 9, 1, 5, 6]) == [1, 2, 5, 5, 6, 9]\n", "\nassert optimize_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert optimize_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]\n", "\nassert optimize_sort([]) == []\n... |
9d3b001c7ebc025d8c3e6373e98f0e2d | [
{
"content": "On te donne un fichier texte nommé `urls.txt` contenant une liste d'URL, une par ligne. Ta tâche est d'écrire un script Python qui lit ce fichier, récupère le contenu de chaque URL et écrit le contenu dans un nouveau fichier avec l'URL comme nom de fichier. Les noms de fichiers doivent avoir les c... | ["\nassert os.path.exists('output') == True # Assuming the output directory is created if it doesn't exist\n", "\nassert os.path.isfile('output/http___example_com.txt') == True # Assuming 'http://example.com' is in the input file\n", "\nassert os.path.isfile('output/https___example_com.txt') == True # Assuming 'http... |
389dd825c7e1e088261d3a394d3a2f18 | [
{
"content": "Dans un problème de classification multi-classes, tu disposes de deux listes : l'une contenant les étiquettes prédites pour chaque instance, triées par confiance décroissante, et l'autre contenant les étiquettes réelles. Ta tâche est de calculer la précision à k, qui est le pourcentage d'instances... | ["\nassert top_k_accuracy([['dog', 'cat', 'fish', 'bird']], ['dog'], 1) == 100.0\n", "\nassert top_k_accuracy([['dog', 'cat', 'fish', 'bird']], ['cat'], 2) == 100.0\n", "\nassert top_k_accuracy([['dog', 'cat', 'fish', 'bird']], ['bird'], 4) == 100.0\n", "\nassert top_k_accuracy([['dog', 'cat', 'fish', 'bird']], ['fish'... |
89474f47ead6a0da25a18432cd492225 | [
{
"content": "On te donne une séquence d'ADN représentée comme une liste de caractères, où chaque caractère est l'un de 'A', 'T', 'C' ou 'G'. Ta tâche est de mettre en œuvre une fonction qui effectue une \"double mutation ponctuelle\" sur cette séquence. La fonction doit prendre trois paramètres : la séquence d... | ["\nassert len(double_point_mutation(['A', 'T', 'C', 'G'], 1, 3)) == 4\n", "\nassert double_point_mutation(['A', 'T', 'C', 'G'], 0, 0) != ['A', 'T', 'C', 'G']\n", "\nassert double_point_mutation(['A', 'T', 'C', 'G'], 1, 2) != ['A', 'T', 'C', 'G']\n", "\nassert double_point_mutation(['A', 'T', 'C', 'G'], 2, 3) != ['A', ... |
fb02aec4e58ff65bf07c29b24e8fa095 | [
{
"content": "On te donne quatre points dans le plan cartésien, `p1`, `p2`, `q1` et `q2`, chacun représenté comme un tuple de 2 éléments. Ces points définissent deux lignes. Avant de trouver l'intersection, applique une transformation linéaire en utilisant une matrice 2x2 inversible `M` de ton choix à tous les ... | ["\nassert find_intersection((1, 1), (2, 2), (1, 2), (2, 3)) == None\n", "\nassert find_intersection((0, 0), (1, 1), (0, 1), (1, 0)) == (1.0, 1.5)\n", "\nassert find_intersection((1, 2), (3, 4), (5, 6), (7, 8)) == None\n", "\nassert find_intersection((0, 0), (2, 3), (0, 3), (2, 0)) == (1.2, 1.8)\n", "\nassert find_inte... |
e369fff406e4babb89ac14a142140ed4 | [
{
"content": "On te demande de traiter un ensemble de données de missions spatiales afin de déterminer les périodes de suivi pour chaque mission. Chaque mission est identifiée par un identifiant de mission unique et possède une date de début et une date de fin. L'ensemble de données comprend également des enreg... | ["\nassert update_dataset({\"M1\": {\"Start_Date\": \"2020-01-01\", \"End_Date\": \"2020-01-10\"}}, [\"2020-01-02\", \"M1\", \"start\"], \"M1\", None, None) == (\"M1\", \"2020-01-02\")\n", "\nassert update_dataset({\"M1\": {\"Start_Date\": \"2020-01-01\", \"End_Date\": \"2020-01-10\"}}, [\"2020-01-10\", \"M1\", \"end\"... |
dd186ca5af6805bb09257cae4c50f829 | [
{
"content": "On te donne une chaîne `resource_uri` représentant un URI pour une ressource dans un groupe de ressources et une chaîne `resource_type` représentant le type de la ressource. Ta tâche est d'implémenter une fonction `get_resource_name(resource_uri, resource_type)` qui extrait le nom de la ressource ... | ["\nassert get_resource_name(\"/subscriptions/sub/resourceGroups/resource/providers/Microsoft.Compute/virtualMachines/vm1\", \"virtualMachines\") == \"vm1\"\n", "\nassert get_resource_name(\"/subscriptions/sub/resourceGroups/resource/providers/Microsoft.Storage/storageAccounts/storage1\", \"storageAccounts\") == \"stor... |
299681d82e6011bc6624eee5057970b3 | [
{
"content": "On te donne une chaîne de caractères `S`. Ta tâche est d'écrire une fonction qui convertit chaque caractère de la chaîne en sa valeur ASCII correspondante et renvoie une liste de tuples. Chaque tuple doit contenir un caractère de la chaîne et sa valeur ASCII. Par exemple, si la chaîne d'entrée est... | ["\nassert string_to_ascii(\"Hello\") == [('H', 72), ('e', 101), ('l', 108), ('l', 108), ('o', 111)]\n", "\nassert string_to_ascii(\"Python\") == [('P', 80), ('y', 121), ('t', 116), ('h', 104), ('o', 111), ('n', 110)]\n", "\nassert string_to_ascii(\"123\") == [('1', 49), ('2', 50), ('3', 51)]\n", "\nassert string_to_as... |
22d6f5e4094589322bdf744f95c8dd90 | [
{
"content": "On te demande de simuler le mouvement de plusieurs balles dans un espace 2D et de détecter les collisions avec des obstacles statiques. Chaque balle est représentée comme un cercle avec des propriétés pour la position du centre `(cx, cy)`, le rayon et la vitesse `(vx, vy)`. Chaque obstacle est rep... | ["\nassert simulate_balls_and_obstacles([{'cx': 10, 'cy': 10, 'radius': 5, 'vx': 2, 'vy': 2}], [{'rx': 20, 'ry': 20, 'rw': 20, 'rh': 20}], 10) == [(0, 0, 'left')]\n", "\nassert simulate_balls_and_obstacles([{'cx': 50, 'cy': 10, 'radius': 5, 'vx': -1, 'vy': -1}], [{'rx': 70, 'ry': 20, 'rw': 20, 'rh': 20}], 10) == [(0, 0... |
cc1b059f8d51b1013902fcf1e79989c3 | [
{
"content": "On te donne une chaîne de caractères `s`. Ta tâche est d'implémenter une fonction `extract_numeric_suffix(s)` qui identifie et renvoie le suffixe numérique de la chaîne. Le suffixe numérique est défini comme la plus longue séquence de chiffres située à la fin de la chaîne. Si aucun suffixe numériq... | ["\nassert extract_numeric_suffix(\"Face12\") == 12\n", "\nassert extract_numeric_suffix(\"Face\") == 0\n", "\nassert extract_numeric_suffix(\"Face123abc456\") == 456\n", "\nassert extract_numeric_suffix(\"abc123\") == 123\n", "\nassert extract_numeric_suffix(\"123456\") == 123456\n", "\nassert extract_numeric_suffix(\... |
24008d4cd722a0e028cdcb9913a2a7b3 | [
{
"content": "On te donne deux entiers, `a` et `b`. Ta tâche est de calculer la somme de tous les entiers de `a` à `b` (inclus). Si `a` est supérieur à `b`, retourne 0.\n\n**Entrée :**\n- Deux entiers `a` et `b` (où -10^9 ≤ a, b ≤ 10^9).\n\n**Sortie :**\n- Un seul entier représentant la somme de tous les entier... | ["\nassert sum_from_a_to_b(1, 5) == 15\n", "\nassert sum_from_a_to_b(5, 1) == 0\n", "\nassert sum_from_a_to_b(0, 0) == 0\n", "\nassert sum_from_a_to_b(-5, 5) == 0\n", "\nassert sum_from_a_to_b(10, 10) == 10\n", "\nassert sum_from_a_to_b(-10, -5) == -45\n", "\nassert sum_from_a_to_b(1, 100) == 5050\n", "\nassert sum_fro... |
4e94a356ef3efacbfa8bfb6921a2f1e5 | [
{
"content": "On te demande d'implémenter une classe `Rectangle` en Python. La classe doit avoir les attributs et méthodes suivants :\n\n- **Attributs :**\n - `width` : Un entier représentant la largeur du rectangle.\n - `height` : Un entier représentant la hauteur du rectangle.\n\n- **Méthodes :**\n - `area... | ["\nassert Rectangle(3, 4).area() == 12\n", "\nassert Rectangle(5, 5).area() == 25\n", "\nassert Rectangle(7, 2).perimeter() == 18\n", "\nassert Rectangle(10, 10).perimeter() == 40\n", "\nassert Rectangle(1, 1).is_square() == True\n", "\nassert Rectangle(2, 3).is_square() == False\n", "\nassert Rectangle(0, 0).area() =... |
b9e3c270e22867c3086a92a53c283f0b | [
{
"content": "On te demande d'implémenter une fonction `validate_product_code` qui détermine la validité d'un code produit. Un code produit valide doit contenir au moins un caractère alphanumérique, en ignorant les espaces blancs en début ou en fin de chaîne. Ta fonction doit renvoyer `True` si le code produit ... | ["\nassert validate_product_code(\"abc123\") == True\n", "\nassert validate_product_code(\" abc123 \") == True\n", "\nassert validate_product_code(\"!@#$%^&*()\") == False\n", "\nassert validate_product_code(\" !@#$%^&*() \") == False\n", "\nassert validate_product_code(\"abc 123\") == True\n", "\nassert valida... |
1c85f019198c67ceac69fdc3ee26de87 | [
{
"content": "On te donne une grille 2D représentant un plateau de jeu de dimensions `n x m`. Chaque cellule de la grille peut être l'une des suivantes :\n- `'X'` : occupée par une pièce de jeu.\n- `'O'` : marquée comme un obstacle temporaire.\n- `'E'` : vide.\n\nTa tâche est d'écrire une fonction `find_first_e... | ["\nassert find_first_empty_cell([['X', 'O', 'E'], ['X', 'X', 'X'], ['O', 'E', 'X']]) == (0, 2)\n", "\nassert find_first_empty_cell([['X', 'X', 'X'], ['X', 'X', 'X'], ['X', 'X', 'X']]) == None\n", "\nassert find_first_empty_cell([['E', 'X', 'O'], ['X', 'E', 'X'], ['O', 'X', 'E']]) == (0, 0)\n", "\nassert find_first_emp... |
d630a46a27a7cc21c4581909011d10e0 | [
{
"content": "On te donne un entier positif `n` supérieur à 1. Ta tâche est d'écrire une fonction `generate_prime_factors` qui renvoie une liste de ses facteurs premiers par ordre non décroissant. Par exemple, si `n` est 28, la fonction doit renvoyer `[2, 2, 7]`.\n\n**Entrée :**\n- Un seul entier `n` (2 ≤ n ≤ 1... | ["\nassert generate_prime_factors(28) == [2, 2, 7]\n", "\nassert generate_prime_factors(100) == [2, 2, 5, 5]\n", "\nassert generate_prime_factors(37) == [37]\n", "\nassert generate_prime_factors(1) == []\n", "\nassert generate_prime_factors(2) == [2]\n", "\nassert generate_prime_factors(3) == [3]\n", "\nassert generate... |
49eea973d201ef3b3749b2e217c483e1 | [
{
"content": "On te demande d'implémenter un décorateur Python nommé `time_decorator`. Ce décorateur doit mesurer et afficher le temps d'exécution de toute fonction qu'il décore, en prenant en charge les fonctions récursives et les fonctions avec des arguments variables. Ton implémentation ne doit pas modifier ... | ["\nassert time_decorator(lambda x: x)(5) == 5\n", "\nassert time_decorator(lambda x, y: x + y)(3, 4) == 7\n", "\nassert time_decorator(lambda *args: sum(args))(1, 2, 3, 4) == 10\n", "\nassert time_decorator(lambda **kwargs: sum(kwargs.values()))(a=1, b=2, c=3) == 6\n", "\nassert time_decorator(lambda x: x * x)(10) == ... |
90a3801f68fc024e371100c034adfc3f | [
{
"content": "On te demande d'implémenter une fonction récursive `find_permutations(sequence)` qui génère toutes les permutations possibles d'une séquence donnée. La fonction doit renvoyer une liste de toutes les permutations. La séquence peut consister en des entiers, des chaînes de caractères ou un mélange de... | ["\nassert find_permutations([1, 2, 3]) == [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]\n", "\nassert find_permutations(['a', 'b', 'c']) == [['a', 'b', 'c'], ['a', 'c', 'b'], ['b', 'a', 'c'], ['b', 'c', 'a'], ['c', 'a', 'b'], ['c', 'b', 'a']]\n", "\nassert find_permutations([1]) == [[1]]\n", "\nas... |
eac8c45dee460fbb197d20b90a9da9a2 | [
{
"content": "On te demande d'implémenter une fonction `is_subclass_instance(obj, a_class)` qui détermine si un objet donné `obj` est une instance d'une sous-classe (directement ou indirectement) d'une classe spécifiée `a_class`. La fonction doit renvoyer `True` si `obj` est une instance d'une sous-classe de `a... | ["\nassert is_subclass_instance(5, int) == False\n", "\nassert is_subclass_instance(\"hello\", str) == False\n", "\nassert is_subclass_instance([], list) == False\n", "\nclass A: pass\nclass B(A): def __str__(self): return \"B\"\nassert is_subclass_instance(B(), A) == True\n", "\nclass A: pass\nclass B(A): pass\nassert... |
82dcd369a8aaf5814830526d5961f7ff | [
{
"content": "Tu participes à un défi de vision par ordinateur où tu dois traiter les coordonnées des boîtes englobantes provenant d'algorithmes de détection d'objets. Les boîtes englobantes sont fournies sous forme de tableau NumPy avec des coordonnées normalisées dans la plage `[0, 1]`. Ta tâche est d'écrire ... | ["\nassert np.array_equal(denormalise_boxes(np.array([0.5, 0.5, 1.0, 1.0]), (800, 600)), np.array([400, 300, 800, 600]))\n", "\nassert np.array_equal(denormalise_boxes(np.array([[0.25, 0.25, 0.5, 0.5], [0.75, 0.75, 1.0, 1.0]]), (400, 300)), np.array([[100, 75, 200, 150], [300, 225, 400, 300]]))\n", "\nassert np.array_e... |
dd8c20b9ddcb11ae0e69fa3423060134 | [
{
"content": "On te donne une séquence d'entiers, `A = [a0, a1, a2, ..., an-1]`. Ta tâche est de déterminer la valeur maximale qui peut être obtenue en effectuant l'opération `A[i] XOR A[j]` pour toute paire d'indices `i` et `j` (où `i != j`).\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤... | ["\nassert max_xor([1, 2, 3, 4, 5]) == 7\n", "\nassert max_xor([0, 0, 0, 0]) == 0\n", "\nassert max_xor([1, 1, 1, 1]) == 0\n", "\nassert max_xor([10, 20, 30, 40, 50]) == 62\n", "\nassert max_xor([15, 25, 35, 45, 55]) == 63\n", "\nassert max_xor([1, 3, 5, 7, 9]) == 14\n", "\nassert max_xor([2, 4, 6, 8, 10]) == 14\n", "\... |
c732511c54972f2059f6789967df538e | [
{
"content": "On te donne une chaîne de caractères `text` composée de divers caractères, notamment des lettres, des chiffres, de la ponctuation et des espaces. Ta tâche est de mettre en œuvre une fonction `count_words` qui renvoie le nombre de mots dans la chaîne. Un mot est défini comme une séquence de caractè... | ["\nassert count_words(\"Hello world!\") == 2\n", "\nassert count_words(\"This is a test.\") == 4\n", "\nassert count_words(\" Leading and trailing spaces \") == 4\n", "\nassert count_words(\"\") == 0\n", "\nassert count_words(\"OneWord\") == 1\n", "\nassert count_words(\"Multiple spaces between words\") == 4\n... |
99248f0b079855bbdf8ee58c35ae38da | [
{
"content": "Tu es chargé d'implémenter une classe `DeckOfCards` en Python qui simule un jeu standard de 52 cartes à jouer. La classe doit prendre en charge les opérations suivantes :\n\n1. **Mélanger** : Réorganiser aléatoirement l'ordre des cartes dans le jeu.\n2. **Distribuer une carte** : Retirer et renvoy... | ["\nassert DeckOfCards().cards == ['2 of Hearts', '3 of Hearts', '4 of Hearts', '5 of Hearts', '6 of Hearts', '7 of Hearts', '8 of Hearts', '9 of Hearts', '10 of Hearts', 'Jack of Hearts', 'Queen of Hearts', 'King of Hearts', 'Ace of Hearts', '2 of Diamonds', '3 of Diamonds', '4 of Diamonds', '5 of Diamonds', '6 of Dia... |
d151e8760a3038f181eb4a30c24a7376 | [
{
"content": "On te demande d'implémenter une fonction `day_suffix(date_str, timezone_str)` qui traite une chaîne de date au format \"jj-mm-aaaa\" et une chaîne de fuseau horaire. La fonction doit convertir la date donnée du fuseau horaire spécifié au fuseau horaire local du serveur et renvoyer le jour du mois ... | ["\nassert day_suffix(\"01-01-2022\") == \"1st\"\n", "\nassert day_suffix(\"02-02-2022\") == \"2nd\"\n", "\nassert day_suffix(\"03-03-2023\") == \"3rd\"\n", "\nassert day_suffix(\"11-11-2022\") == \"11th\"\n", "\nassert day_suffix(\"21-12-2022\") == \"21st\"\n", "\nassert day_suffix(\"22-12-2022\") == \"22nd\"\n", "\na... |
53b71219fb7821ee30726431fa2598ac | [
{
"content": "On te donne un arbre binaire. Ta tâche est d'implémenter une fonction qui crée une copie profonde de l'arbre binaire donné. La fonction doit renvoyer la racine du nouvel arbre, qui est une copie complète de l'arbre original, incluant tous les nœuds et leur structure.\n\n**Entrée :**\n- L'entrée es... | ["\nassert deep_copy_tree(None) is None\n", "\nassert deep_copy_tree(TreeNode(1)).val == 1\n", "\nassert deep_copy_tree(TreeNode(1)).left is None\n", "\nassert deep_copy_tree(TreeNode(1)).right is None\n", "\noriginal = TreeNode(1, TreeNode(2), TreeNode(3))\ncopy = deep_copy_tree(original)\nassert copy.val == original.... |
185dc145b33f0f1496033fd28b7c6309 | [
{
"content": "On te donne une séquence d'entiers non négatifs `sequence` et un entier positif `k`. Ta tâche est de déterminer la somme maximale de `k` éléments consécutifs quelconques dans la séquence.\n\n**Entrée :**\n- La première ligne contient un entier `n` (1 ≤ n ≤ 10^5), la longueur de la séquence.\n- La ... | ["\nassert max_sum_of_k_consecutive([1, 2, 3, 4, 5], 2) == 9\n", "\nassert max_sum_of_k_consecutive([1, 2, 3, 4, 5], 3) == 12\n", "\nassert max_sum_of_k_consecutive([1, 2, 3, 4, 5], 5) == 15\n", "\nassert max_sum_of_k_consecutive([10, 20, 30, 40, 50], 2) == 90\n", "\nassert max_sum_of_k_consecutive([5, 5, 5, 5, 5, 5], ... |
a27c56af3c815c740e22772b294a2c22 | [
{
"content": "On te donne deux dictionnaires Python, `config1` et `config2`, qui représentent des paramètres de configuration. Ta tâche est de mettre en œuvre une fonction `merge_configs(config1, config2)` qui fusionne ces deux dictionnaires de manière récursive. Si une clé existe dans les deux dictionnaires, l... | ["\nassert merge_configs({}, {}) == {}\n", "\nassert merge_configs({'a': 1}, {'b': 2}) == {'a': 1, 'b': 2}\n", "\nassert merge_configs({'a': 1}, {'a': 2}) == {'a': 2}\n", "\nassert merge_configs({'a': {'b': 1}}, {'a': {'b': 2}}) == {'a': {'b': 2}}\n", "\nassert merge_configs({'a': {'b': 1}}, {'a': {'c': 2}}) == {'a': {... |
3d12fcf9fd656d6adca068cfcf010f6a | [
{
"content": "On te donne une liste d'entiers uniques compris entre 1 et 10. Ta tâche est de déterminer le score maximal que tu peux obtenir en sélectionnant des nombres dans la liste de telle sorte qu'aucun deux nombres sélectionnés ne soient adjacents. Écris une fonction `max_score(numbers)` qui prend une lis... | ["\nassert max_score([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 30\n", "\nassert max_score([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == 30\n", "\nassert max_score([1, 3, 5, 7, 9]) == 25\n", "\nassert max_score([2, 4, 6, 8, 10]) == 18\n", "\nassert max_score([1, 2]) == 2\n", "\nassert max_score([10]) == 10\n", "\nassert max_score([]) =... |
4adc008d3d68ff8aa55c39f851d9ca6e | [
{
"content": "On te donne un tableau d'entiers. Ta tâche est de trouver la plus longue sous-tableau contigu où tous les éléments sont distincts. S'il y a plusieurs sous-tableaux de longueur maximale identique, renvoie celui qui apparaît en premier dans le tableau.\n\n**Entrée :**\n- La première ligne contient u... | ["\nassert longest_distinct_subarray([1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 3]) == [4, 5, 6, 7, 8, 9, 2, 3]\n", "\nassert longest_distinct_subarray([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n", "\nassert longest_distinct_subarray([1, 2, 2, 3, 4, 5]) == [1, 2]\n", "\nassert longest_distinct_subarray([1, 2, 3, 4, 5, 1, 2, 3, ... |
a919ca5d3c601b75d91a8da4dc44d82c | [
{
"content": "On te donne une chaîne de caractères `s` composée de divers caractères, y compris des parenthèses. Ta tâche est de déterminer si les parenthèses dans la chaîne sont équilibrées. Une chaîne avec des parenthèses équilibrées signifie que chaque parenthèse ouvrante '(' a une parenthèse fermante corres... | ["\nassert is_balanced_parentheses(\"(a + b) * (c + d)\") == True\n", "\nassert is_balanced_parentheses(\"((a + b)\") == False\n", "\nassert is_balanced_parentheses(\"()\") == True\n", "\nassert is_balanced_parentheses(\")(\") == False\n", "\nassert is_balanced_parentheses(\"((()))\") == True\n", "\nassert is_balanced_... |
559836fe7c8759da73aa6c1975aaa920 | [
{
"content": "On te demande d'implémenter une fonction `fetch_user_data` qui interagit avec une API distante pour récupérer les informations d'un utilisateur. La fonction doit accepter un seul argument entier `user_id` et renvoyer un dictionnaire représentant les données de l'utilisateur. Le point de terminaiso... | ["\nassert fetch_user_data(1) == {'id': 1, 'name': 'John Doe', 'email': 'john.doe@example.com'}\n", "\nassert fetch_user_data(2) == {'id': 2, 'name': 'Jane Smith', 'email': 'jane.smith@example.com'}\n", "\nassert fetch_user_data(0) == {'id': 0, 'name': 'Admin', 'email': 'admin@example.com'}\n", "\nassert fetch_user_dat... |
30fdf9f09872345a43a16d6b4ffd8fa1 | [
{
"content": "On te donne un entier `n` et une fonction prédicat `condition`. Ta tâche est de mettre en œuvre une fonction `join_numbers_with_condition` qui renvoie une chaîne de caractères contenant les nombres de 0 à `n` (inclus) qui satisfont la `condition`. Chaque nombre doit être converti en sa représentat... | ["\nassert join_numbers_with_condition(5, lambda x: x % 2 == 0) == \"0,2,10\"\n", "\nassert join_numbers_with_condition(10, lambda x: x % 3 == 0) == \"0,10,20\"\n", "\nassert join_numbers_with_condition(0, lambda x: x == 0) == \"0\"\n", "\nassert join_numbers_with_condition(3, lambda x: x > 1) == \"10,20\"\n", "\nasser... |
b1f84fa5a6fbc4fa58efdb20a7ec064d | [
{
"content": "On te demande d'implémenter une fonction `calculate_discounted_price` pour une plateforme de commerce en ligne. La fonction doit accepter deux paramètres : `product_price` et `discount_percentage`. Elle doit renvoyer le prix final après application de la réduction. Le `discount_percentage` doit êt... | ["\nassert calculate_discounted_price(100, 0) == 100\n", "\nassert calculate_discounted_price(100, 100) == 0\n", "\nassert calculate_discounted_price(200, 50) == 100\n", "\nassert calculate_discounted_price(150, 25) == 112.5\n", "\nassert calculate_discounted_price(50, 10) == 45\n", "\nassert calculate_discounted_price... |
38cf4f9d45861d92d2ab246f831c6ed5 | [
{
"content": "On te donne un tenseur 4D `tensor` de forme `(batch_size, num_classes, num_samples, num_features)` et un tenseur 1D `index` de forme `(batch_size,)`. Ta tâche est d'implémenter une fonction `select_samples(tensor, index)` qui renvoie un nouveau tenseur de forme `(batch_size, num_classes, 1, num_fe... | ["\nassert torch.equal(select_samples(torch.tensor([[[[1, 2], [3, 4]]], [[[5, 6], [7, 8]]]]), torch.tensor([[[[3, 4]]], [[[7, 8]]]]))\n", "\nassert torch.equal(select_samples(torch.tensor([[[[1, 2], [3, 4]]], [[[5, 6], [7, 8]]]]), torch.tensor([[[[4, 3]]], [[[8, 7]]]]), torch.tensor([0, 0]))\n", "\nassert torch.equal(s... |
506ac3e155bead6ecda80aeb53c4034a | [
{
"content": "On te demande de traiter un grand fichier texte nommé \"encyclopedia.txt\" qui contient plusieurs articles séparés par des lignes vides. Ton objectif est de mettre en œuvre une fonction qui compte le nombre d'articles contenant une sous-chaîne spécifique. La fonction doit être optimisée pour l'uti... | ["\nassert count_articles_with_string(\"Python\", \"test_file.txt\") == 3\n", "\nassert count_articles_with_string(\"Java\", \"test_file.txt\") == 0\n", "\nassert count_articles_with_string(\"C++\", \"test_file.txt\") == 1\n", "\nassert count_articles_with_string(\" \", \"test_file.txt\") == 5\n", "\nassert count_artic... |
f0d21010c48b0fde544d26559d57d3ba | [
{
"content": "Tu as pour tâche de concevoir une API RESTful pour une application de blog simple. L'API doit prendre en charge les opérations suivantes :\n\n1. **Créer un nouveau billet de blog** : Accepte un objet JSON avec les champs `title` et `content` et renvoie le billet créé avec un `id` attribué.\n2. **R... | ["\nassert get_posts().json == [{'id': 1, 'title': 'First Post', 'content': 'Content of first post'}, {'id': 2, 'title': 'Second Post', 'content': 'Content of second post'}]\n", "\nassert get_post(1).json == {'id': 1, 'title': 'First Post', 'content': 'Content of first post'}\n", "\nassert get_post(3).status_code == 40... |
fe0ca0aa43bd32f0a28ad2bad03dbcde | [
{
"content": "On te demande d'implémenter une fonction `validate_date` qui vérifie la validité d'une chaîne de date donnée, formatée comme \"AAAA-MM-JJ\". La date est considérée comme valide si elle satisfait les critères suivants :\n- L'année est un nombre à quatre chiffres compris entre 1000 et 9999, inclusiv... | ["\nassert validate_date(\"2023-02-29\") == False\n", "\nassert validate_date(\"2024-02-29\") == True\n", "\nassert validate_date(\"2023-03-17\") == True\n", "\nassert validate_date(\"2023-04-02\") == False\n", "\nassert validate_date(\"2023-05-23\") == True\n", "\nassert validate_date(\"2023-06-31\") == False\n", "\na... |
ca91f2f3baa95a8c36a6a97232068f2d | [
{
"content": "On te demande d'implémenter une fonction pour calculer l'aire de la surface d'un cône. Étant donné le diamètre de la base et la hauteur oblique du cône, ta fonction doit renvoyer l'aire de la surface en utilisant la formule \\( \\pi r (r + s) \\), où \\( r \\) est le rayon et \\( s \\) est la haut... | ["\nassert calculate_surface_area_of_cone(6.0, 10.0) == 254.46900494077323\n", "\nassert calculate_surface_area_of_cone(0.0, 10.0) == 0.0\n", "\nassert calculate_surface_area_of_cone(10.0, 0.0) == 78.53981633974483\n", "\nassert calculate_surface_area_of_cone(1.0, 1.0) == 4.71238898038469\n", "\nassert calculate_surfac... |
7409c48f0d857c396c591d3838e5d9aa | [
{
"content": "On te donne la tâche d'implémenter une fonction `convert_temperature` qui effectue une transformation linéaire pour convertir une valeur de température d'une échelle à une autre. La fonction doit gérer n'importe quelle échelle de température arbitraire définie par ses valeurs minimale et maximale.... | ["\nassert convert_temperature(25, 0, 100, 32, 212) == 77.0\n", "\nassert convert_temperature(0, 0, 100, 32, 212) == 32.0\n", "\nassert convert_temperature(100, 0, 100, 32, 212) == 212.0\n", "\nassert convert_temperature(50, 0, 100, 0, 100) == 50.0\n", "\nassert convert_temperature(32, 32, 212, 0, 100) == 0.0\n", "\nas... |
294d209a1adc89fcf60ea0563294cb20 | [
{
"content": "On te donne deux ensembles de points 3D, `A` et `B`, chacun représenté comme une liste de tuples, où chaque tuple contient trois entiers représentant les coordonnées d'un point. Ta tâche est d'écrire une fonction qui calcule la distance euclidienne moyenne entre chaque point de l'ensemble `A` et s... | ["\nassert average_nearest_neighbor_distance(np.array([[0, 0, 0]]), np.array([[1, 1, 1]])) == np.sqrt(3)\n", "\nassert average_nearest_neighbor_distance(np.array([[1, 1, 1]]), np.array([[1, 1, 1]])) == 0\n", "\nassert average_nearest_neighbor_distance(np.array([[0, 0, 0], [1, 1, 1]]), np.array([[1, 1, 1], [2, 2, 2]])) ... |
53818302614dd44afbcf2e67f47b8436 | [
{
"content": "On te donne une liste de `n` produits, chacun représenté comme un dictionnaire avec les clés `\"id\"`, `\"name\"`, `\"price\"` et `\"stock\"`. Ta tâche est de calculer la valeur totale du stock pour tous les produits. La valeur totale du stock est définie comme la somme du produit du prix et du st... | ["\nassert calculate_total_stock_value([{\"id\": 1, \"name\": \"Laptop\", \"price\": 1000, \"stock\": 5}]) == 5000\n", "\nassert calculate_total_stock_value([{\"id\": 2, \"name\": \"Mouse\", \"price\": 20, \"stock\": 100}, {\"id\": 3, \"name\": \"Keyboard\", \"price\": 50, \"stock\": 50}]) == 6000\n", "\nassert calcula... |
3895ba96c6f20820faba07c1a7b4d2fa | [
{
"content": "On te donne une liste de `n` graphes et leurs retards correspondants. Chaque graphe est représenté comme un dictionnaire où les clés sont les nœuds et les valeurs sont des listes de tuples. Chaque tuple consiste en un nœud connecté et le type de connexion (par exemple, \"autoroute\", \"chemin de f... | ["\nassert merge_graphs_and_delays([{'A': [('B', 'highway')]}, {'A': [('C', 'railway')]}], [{'A': {'highway': {'B': 10}}}, {'A': {'railway': {'C': 5}}}]) == ({'A': [('B', 'highway'), ('C', 'railway')]}, {'A': {'highway': {'B': 10}, 'railway': {'C': 5}}})\n", "\nassert merge_graphs_and_delays([{'X': [('Y', 'road')]}, {'... |
c4cc959f80df041878479334dfeb3cbd | [
{
"content": "On te donne une matrice carrée \\( A \\) de taille \\( n \\times n \\). Les éléments de la matrice sont définis comme suit :\n\n- Si l'indice de ligne \\( r \\) est égal à l'indice de colonne \\( c \\), l'élément \\( A[r, c] \\) est défini sur \\( \\frac{n+1}{n} \\).\n- Si l'indice de ligne \\( r ... | ["\nassert calculate_prime_spiral_sum(1) == 0\n", "\nassert calculate_prime_spiral_sum(2) == 0\n", "\nassert calculate_prime_spiral_sum(3) == 0\n", "\nassert calculate_prime_spiral_sum(4) == 0\n", "\nassert calculate_prime_spiral_sum(5) == 0\n", "\nassert calculate_prime_spiral_sum(6) == 0\n", "\nassert calculate_prime... |
004e75accca3c045777c4fa539bfd148 | [
{
"content": "On te donne une liste d'entiers `nums` et un entier cible `target`. Ta tâche est de trouver toutes les paires uniques d'entiers dans `nums` qui s'additionnent pour donner `target`. Chaque paire doit être représentée comme un tuple avec le plus petit nombre en premier. Retourne une liste de ces tup... | ["\nassert find_pairs([1, 2, 3, 4, 5], 5) == [(1, 4), (2, 3)]\n", "\nassert find_pairs([1, 2, 3, 4, 5], 10) == []\n", "\nassert find_pairs([1, 2, 3, 4, 5], 9) == [(4, 5)]\n", "\nassert find_pairs([1, 2, 3, 4, 5, 4], 8) == [(3, 5), (4, 4)]\n", "\nassert find_pairs([1, 1, 1, 1], 2) == [(1, 1)]\n", "\nassert find_pairs([]... |
7ff10420cc3173c526ff1629883f1b4b | [
{
"content": "On te donne un dictionnaire où chaque clé est associée à une valeur entière unique. Ta tâche est d'écrire une fonction qui renvoie une liste des clés du dictionnaire triées par ordre décroissant en fonction de leurs valeurs correspondantes. Si deux clés ont la même valeur, leur ordre relatif dans ... | ["\nassert sort_keys_by_values_desc({'a': 3, 'b': 1, 'c': 2}) == ['a', 'c', 'b']\n", "\nassert sort_keys_by_values_desc({'x': 10, 'y': 20, 'z': 15}) == ['y', 'z', 'x']\n", "\nassert sort_keys_by_values_desc({'apple': 5, 'banana': 5, 'cherry': 5}) == ['apple', 'banana', 'cherry']\n", "\nassert sort_keys_by_values_desc({... |
203bb7716a7a72aad40ec3fc4c00c717 | [
{
"content": "On te donne une liste d'URL de dépôts GitHub. Ta tâche est d'écrire une fonction Python qui utilise l'API GitHub pour récupérer le nombre d'étoiles pour chaque dépôt. La fonction doit afficher les résultats au format \"Repository URL: {url}, Stars: {stars_count}\". Si la requête à l'API échoue, af... | ["\nassert get_repo_stars([\"https://github.com/user/repo1\"]) is None\n", "\nassert get_repo_stars([\"https://github.com/user/repo1\", \"https://github.com/user/repo2\"]) is None\n", "\nassert get_repo_stars([]) is None\n", "\nassert get_repo_stars([\"https://github.com/invalid/repo\"]) is None\n", "\nassert get_repo_... |
c353a727e2e47b5d11f34a87e845344b | [
{
"content": "On te donne une chaîne de caractères `s` de longueur `n` et un entier `d` (où `1 ≤ d ≤ n-1`). Ta tâche est de mettre en œuvre une fonction `rotate_string` qui effectue une rotation circulaire vers la droite de la chaîne `s` de `d` positions et renvoie la chaîne résultante.\n\n**Entrée :**\n- Une c... | ["\nassert rotate_string(\"abcdef\", 2) == \"efabcd\"\n", "\nassert rotate_string(\"abcdef\", 6) == \"abcdef\"\n", "\nassert rotate_string(\"abcdef\", 0) == \"abcdef\"\n", "\nassert rotate_string(\"abcdef\", 1) == \"fabcde\"\n", "\nassert rotate_string(\"abcdef\", 5) == \"bcdefa\"\n", "\nassert rotate_string(\"rotation... |
97acfc717103c6c7439c897ff43ec7ec | [
{
"content": "On te donne une séquence de valeurs de vitesse pour un objet en mouvement à des intervalles de temps discrets. Ta tâche est de calculer la position de l'objet à chaque intervalle de temps en utilisant la méthode d'intégration d'Euler explicite, en tenant compte des fluctuations d'accélération aléa... | ["\nassert isinstance(forward_euler_integration([1, 2, 3], 0.1), list)\n", "\nassert len(forward_euler_integration([1, 2, 3], 0.1)) == 4\n", "\nassert forward_euler_integration([0, 0, 0], 0.1)[0] == 0\n", "\nassert forward_euler_integration([1, 1, 1], 1)[1] == 1\n", "\nassert forward_euler_integration([1, 1, 1], 1)[2] ... |
968dacd9b3bc4880c3788d8003e666c8 | [
{
"content": "Tu es chargé de mettre en œuvre une fonction qui extrait des adresses e-mail uniques d'une chaîne de caractères donnée à l'aide d'expressions régulières. La fonction doit renvoyer une liste d'adresses e-mail uniques trouvées dans la chaîne d'entrée. Suppose que la chaîne d'entrée peut contenir plu... | ["\nassert extract_unique_emails(\"john.doe@example.com\") == [\"john.doe@example.com\"]\n", "\nassert extract_unique_emails(\"jane.smith@workplace.org, john.doe@example.com\") == [\"jane.smith@workplace.org\", \"john.doe@example.com\"]\n", "\nassert extract_unique_emails(\"john.doe@example.com, jane.smith@workplace.or... |
a26653669301686c91d977bbe3b504f2 | [
{
"content": "On te demande de développer une API simple en utilisant Flask qui fournit les informations météorologiques actuelles pour une ville spécifiée. L'API doit accepter le nom d'une ville en tant que paramètre de requête et renvoyer les données météorologiques dans un format JSON structuré. Suppose que ... | ["\nassert weather() == jsonify({\"error\": \"City query parameter is required\"}), 400\n", "\nassert weather() == jsonify({\"city\": \"London\", \"temperature\": \"22\u00b0C\", \"condition\": \"Sunny\", \"humidity\": \"50%\", \"wind_speed\": \"10km/h\"}), 200\n", "\nassert weather() == jsonify({\"city\": \"New York\",... |
f066a438f1f2827cacad839291ac1fb2 | [
{
"content": "On te demande d'implémenter une fonction qui calcule les hyperparamètres pour un processus de diffusion avec température dynamique et forces externes. Le processus de diffusion modélise la propagation d'une quantité (par exemple, la chaleur, les particules ou l'information) dans le temps dans un m... | ["\nassert compute_diffusion_hyperparameters(1, 0.1, 0.1, 0.5, 10, 0.2, 0.8, 0.3)['beta'].item() == 0.1\n", "\nassert compute_diffusion_hyperparameters(1, 0.1, 0.1, 0.5, 10, 0.2, 0.8, 0.3)['alpha'].item() == torch.sqrt(torch.tensor(0.9)).item()\n", "\nassert compute_diffusion_hyperparameters(1, 0.1, 0.1, 0.5, 10, 0.2, ... |
f9c6132c41ebc46e7a5413bb63cbc53b | [
{
"content": "Tu es chargé de développer une fonction pour une application web côté serveur qui construit un objet JSON. Cet objet doit contenir l'heure actuelle du serveur formatée comme 'AAAA-MM-JJ HH:MM:SS' et un identifiant unique pour la requête, qui doit être un UUID (Identifiant Universellement Unique) g... | ["\nassert isinstance(generate_request_info(), str)\n", "\nassert 'server_time' in json.loads(generate_request_info())\n", "\nassert 'request_id' in json.loads(generate_request_info())\n", "\nassert len(json.loads(generate_request_info())['request_id']) == 36\n", "\nassert json.loads(generate_request_info())['server_ti... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.