Upload code.txt

code.txt

@@ -4,8 +4,8 @@ moyenne
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, calculs, taille d'une liste (len)
 ;;;
-Écrire une fonction moyenne qui prend en paramètre un tableau non vide d'entiers tab et qui renvoie la moyenne de ces entiers.  
-Il est interdit d'utiliser la fonction Python sum  
+Écrire une fonction `moyenne` qui prend en paramètre un tableau non vide d'entiers `tab` et qui renvoie la moyenne de ces entiers.  
+Il est interdit d'utiliser la fonction Python `sum`  
 Exemple :  
 ```
 >>> moyenne([10, 15, 20])
@@ -30,8 +30,8 @@ maximum tableau
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, comparaison de deux valeurs, instruction if
 ;;;
-Écrire la fonction maximum_tableau, prenant en paramètre un tableau non vide de nombres tab (de type list) et renvoyant le plus grand élément de ce tableau.    
-Il est interdit d'utiliser la fonction Python max  
+Écrire la fonction `maximum_tableau`, prenant en paramètre un tableau non vide de nombres `tab` (de type list) et renvoyant le plus grand élément de ce tableau.    
+Il est interdit d'utiliser la fonction Python `max`  
 Exemples :  
 ```
 >>> maximum_tableau([98, 12, 104, 23, 131, 9])
@@ -60,8 +60,8 @@ recherche
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, utilisation de l'indice 
 ;;;
-Programmer la fonction recherche, prenant en paramètres un tableau non vide tab (type list) d’entiers et un entier n, et qui renvoie l’indice de la première occurrence de l’élément cherché.  
-Si l’élément n’est pas présent, la fonction renvoie None.  
+Programmer la fonction `recherche`, prenant en paramètres un tableau non vide tab (type list) d’entiers et un entier `n`, et qui renvoie l’indice de la première occurrence de l’élément cherché.  
+Si l’élément n’est pas présent, la fonction renvoie `None`.  
 Exemples :  
 ```
 >>> recherche([5, 3],1) # renvoie None
@@ -91,8 +91,8 @@ max et indice
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, indice, comparaison
 ;;;
-Écrire une fonction max_et_indice qui prend en paramètre un tableau non vide tab (type Python list) de nombres entiers et qui renvoie la valeur du plus grand élément de ce tableau ainsi que l’indice de sa première apparition dans ce tableau.  
-L’utilisation de la fonction native max n’est pas autorisée.  
+Écrire une fonction `max_et_indice` qui prend en paramètre un tableau non vide `tab` (type Python list) de nombres entiers et qui renvoie la valeur du plus grand élément de ce tableau ainsi que l’indice de sa première apparition dans ce tableau.  
+L’utilisation de la fonction native `max` n’est pas autorisée.  
 Exemples :  
 ```
 >>> max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
@@ -129,7 +129,7 @@ verifie
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, indice, instruction if, comparaison de deux valeurs
 ;;;
-Écrire une fonction verifie qui prend en paramètre un tableau de valeurs numériques et qui renvoie True si ce tableau est trié dans l’ordre croissant, False sinon.  
+Écrire une fonction `verifie` qui prend en paramètre un tableau de valeurs numériques et qui renvoie `True` si ce tableau est trié dans l’ordre croissant, `False` sinon.  
 Un tableau vide est considéré comme trié.  
 Exemples :  
 ```
@@ -173,7 +173,7 @@ premier et dernier
 ;;;
 tableau, index, longueur tableau
 ;;;
-Écrire une fonction premier_dernier qui prend en paramètre un tableau non vide tab. Cette fonction renvoie un tuple contenant le premier et le dernier éléments du tabeau tab.  
+Écrire une fonction `premier_dernier` qui prend en paramètre un tableau non vide `tab`. Cette fonction renvoie un tuple contenant le premier et le dernier éléments du tabeau `tab`.  
 Exemples :  
 ```
 >>> premier_dernier([4, 15, 34, 22])
@@ -206,7 +206,7 @@ tableau (liste Python), boucle for, parcours d'un tableau, indice, utilisation d
 ;;;
 Le codage par différence (delta encoding en anglais) permet de compresser un tableau d’entiers dont les valeurs sont proches les unes des autres. Le principe est de stocker la première donnée en indiquant pour chaque autre donnée sa différence avec la précédente plutôt que la donnée elle-même.  
 On se retrouve alors avec un tableau dont les valeurs sont plus petites, nécessitant moins de place en mémoire.  
-Programmer la fonction delta qui prend en paramètre un tableau non vide de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.  
+Programmer la fonction `delta` qui prend en paramètre un tableau non vide de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.  
 Exemples :  
 ```
 >>> delta([1000, 800, 802, 1000, 1003])
@@ -233,7 +233,7 @@ tableau (liste Python), boucle for, parcours d'un tableau, tableau de tableaux,
 ;;;
 Dans cet exercice, on cherche à calculer la moyenne pondérée d’un élève dans une matière donnée. Chaque note est associée à un coefficient qui la pondère. Par exemple, si ses notes sont : 14 avec coefficient 3, 12 avec coefficient 1 et 16 avec coefficient 2, sa moyenne pondérée sera donnée par :  
 (14 × 3 + 12 × 1 + 16 × 2) / (3 + 1 + 2) = 14, 333...  
-Écrire une fonction moyenne : qui prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (int ou float) positifs ou nuls et qui renvoie la moyenne pondérée des notes de la liste sous forme de flottant si la somme des coefficients est non nulle, None sinon.  
+Écrire une fonction `moyenne` qui prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (`int` ou `float`) positifs ou nuls et qui renvoie la moyenne pondérée des notes de la liste sous forme de flottant si la somme des coefficients est non nulle, `None` sinon.  
 Exemple :  
 ```
 >>> moyenne([(12, 2), (8, 1), (10, 1)])
@@ -258,7 +258,7 @@ tri sélection
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, algo de tri
 ;;;
-Écrire une fonction tri_selection qui prend en paramètre un tableau tab de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri sélection.  
+Écrire une fonction `tri_selection` qui prend en paramètre un tableau `tab` de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri sélection.  
 Exemple :  
 ```
 >>> tri_selection([1, 52, 6, -9, 12])
@@ -283,8 +283,8 @@ min et max
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, recherche minimum et maximum
 ;;;
-Écrire une fonction min_et_max qui prend en paramètre un tableau de nombres tab non vide, et qui renvoie la plus petite et la plus grande valeur du tableau sous la forme d’un dictionnaire à deux clés min et max.  
-L’utilisation des fonctions natives min, max et sorted, ainsi que la méthode sort n’est pas autorisée.  
+Écrire une fonction `min_et_max` qui prend en paramètre un tableau de nombres `tab` non vide, et qui renvoie la plus petite et la plus grande valeur du tableau sous la forme d’un dictionnaire à deux clés `min` et `max`.  
+L’utilisation des fonctions natives `min`, `max` et `sorted`, ainsi que la méthode `sort` n’est pas autorisée.  
 Exemples :  
 ```
 >>> min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1])
@@ -327,7 +327,7 @@ nombre de répétitions
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau
 ;;;
-Écrire une fonction Python appelée nb_repetitions qui prend en paramètres un élément elt et un tableau tab (type list) d’éléments du même type et qui renvoie le nombre de fois où l’élément apparaît dans le tableau.  
+Écrire une fonction Python appelée `nb_repetitions` qui prend en paramètres un élément `elt` et un tableau `tab` (type list) d’éléments du même type et qui renvoie le nombre de fois où l’élément apparaît dans le tableau.  
 Exemples :  
 ```
 >>> nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5])
@@ -358,7 +358,7 @@ recherche motif
 ;;;
 chaine de caractère, parcours d'une chaine, recherche d'un motif 
 ;;;
-Écrire une fonction recherche_motif qui prend en paramètres une chaîne de caractères motif non vide et une chaîne de caractères texte et qui renvoie la liste des positions de motif dans texte. Si motif n’apparaît pas, la fonction renvoie une liste vide.  
+Écrire une fonction `recherche_motif` qui prend en paramètres une chaîne de caractères motif non vide et une chaîne de caractères texte et qui renvoie la liste des positions de motif dans texte. Si motif n’apparaît pas, la fonction renvoie une liste vide.  
 Exemples:  
 ```
 >>> recherche_motif("ab", "")
@@ -395,7 +395,7 @@ recherche indice classement
 ;;;
 tableau (liste Python), boucle for, parcourt d'un tableau, comparaison, création de tableau, ajout d'éléments dans un tableau
 ;;;
-Écrire une fonction recherche_indices_classement qui prend en paramètres un entier elt et un tableau d’entiers tab représenté par une liste Python, et qui renvoie trois listes Python d’entiers:  
+Écrire une fonction `recherche_indices_classement` qui prend en paramètres un entier `elt` et un tableau d’entiers `tab` représenté par une liste Python, et qui renvoie trois listes Python d’entiers:  
 • la première liste contient les indices des valeurs du tableau tab strictement inférieures à elt ;  
 • la deuxième liste contient les indices des valeurs du tableau tab égales à elt ;  
 • la troisième liste contient les indices des valeurs du tableau tab strictement supérieures à elt.  
@@ -435,8 +435,8 @@ parcours largeur arbre (T)
 ;;;
 arbre binaire, parcours en largeur d'un arbre
 ;;;
-Un arbre binaire est soit vide, représenté en Python par la valeur None, soit un nœud représenté par un triplet (g, x, d) où x est l’étiquette du nœud et g et d sont les sousarbres gauche et droit.  
-On souhaite écrire une fonction parcours_largeur qui prend en paramètre un arbre binaire et qui renvoie la liste des étiquettes des nœuds de l’arbre parcourus en largeur.  
+Un arbre binaire est soit vide, représenté en Python par la valeur `None`, soit un nœud représenté par un triplet (`g`, `x`, `d`) où `x` est l’étiquette du nœud et `g` et `d` sont les sousarbres gauche et droit.  
+On souhaite écrire une fonction `parcours_largeur` qui prend en paramètre un arbre binaire et qui renvoie la liste des étiquettes des nœuds de l’arbre parcourus en largeur.  
 Exemples :  
 ```
 >>> parcours_largeur(( ( (None, 1, None), 2, (None, 3, None) ),4,( (None, 5, None), 6, (None, 7, None) ) ))
@@ -455,8 +455,8 @@ recherche minimum
 ;;;
 tableau (list Python), parcours d'un tableau, recherche d'un minimum
 ;;;
-Écrire une fonction recherche_min qui prend en paramètre un tableau de nombres tab, et qui renvoie l’indice de la première occurrence du minimum de ce tableau. Les tableaux seront représentés sous forme de liste Python.  
-Il est interdit d'utiliser les fonctions min et index de Python.  
+Écrire une fonction `recherche_min` qui prend en paramètre un tableau de nombres `tab`, et qui renvoie l’indice de la première occurrence du minimum de ce tableau. Les tableaux seront représentés sous forme de liste Python.  
+Il est interdit d'utiliser les fonctions `min` et `index` de Python.  
 Exemples :  
 ```
 >>> recherche_min([5])
@@ -493,10 +493,10 @@ ajoute dictionnaire
 ;;;
 dictionnaire Python, parcours de dictionnaire selon les clés, création d'un dictionnaire
 ;;;
-Écrire une fonction ajoute_dictionnaires qui prend en paramètres deux dictionnaires d1 et d2 dont les clés et les valeurs associées sont des nombres et renvoie le dictionnaire d défini de la façon suivante :  
-• les clés de d sont celles de d1 et celles de d2 réunies ;  
-• si une clé est présente dans les deux dictionnaires d1 et d2, sa valeur associée dans le dictionnaire d est la somme de ses valeurs dans les dictionnaires d1 et d2 ;  
-• si une clé n’est présente que dans un des deux dictionnaires, sa valeur associée dans le dictionnaire d est la même que sa valeur dans le dictionnaire où elle est présente.  
+Écrire une fonction `ajoute_dictionnaires` qui prend en paramètres deux dictionnaires `d1` et `d2` dont les clés et les valeurs associées sont des nombres et renvoie le dictionnaire d défini de la façon suivante :  
+• les clés de `d` sont celles de `d1` et celles de `d2` réunies ;  
+• si une clé est présente dans les deux dictionnaires `d1` et `d2`, sa valeur associée dans le dictionnaire `d` est la somme de ses valeurs dans les dictionnaires `d1` et `d2` ;  
+• si une clé n’est présente que dans un des deux dictionnaires, sa valeur associée dans le dictionnaire `d` est la même que sa valeur dans le dictionnaire où elle est présente.  
 Exemples :  
 ```
 >>> ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11})
@@ -527,7 +527,7 @@ plus grande valeur
 ;;;
 comparaison
 ;;;
-Écrire une fonction plus_grande qui prend en paramètres deux entiers a et b. Cette fonction renvoie a si a est plus grand que b et renvoie b si b est plus grand que a.  
+Écrire une fonction `plus_grande` qui prend en paramètres deux entiers `a` et `b`. Cette fonction renvoie `a` si `a` est plus grand que `b` et renvoie `b` si `b` est plus grand que `a`.  
 Exemples :  
 ```
 >>> plus_grande(15,3)
@@ -552,7 +552,7 @@ couples consecutifs
 ;;;
 tableau (list Python), parcours d'un tableau par indice
 ;;;
-Écrire une fonction couples_consecutifs qui prend en paramètre un tableau de nombres entiers tab non vide (type list), et qui renvoie la liste Python (éventuellement vide) des couples d’entiers consécutifs successifs qu’il peut y avoir dans tab.  
+Écrire une fonction `couples_consecutifs` qui prend en paramètre un tableau de nombres entiers `tab` non vide (type list), et qui renvoie la liste Python (éventuellement vide) des couples d’entiers consécutifs successifs qu’il peut y avoir dans `tab`.  
 Exemples :  
 ```
 >>> couples_consecutifs([1, 4, 3, 5])
@@ -595,7 +595,7 @@ moyenne
 ;;;
 calcul d'une moyenne à partir de 3 valeurs
 ;;;
-Écrire une fonction moyenne qui prend en paramètre 3 entiers a, b et c. Cette fonction renvoie la moyenne des entiers a, b et c.  
+Écrire une fonction `moyenne` qui prend en paramètre 3 entiers `a`, `b` et `c`. Cette fonction renvoie la moyenne des entiers `a`, `b` et `c`.  
 Exemple :  
 ```
 >>> moyenne(5, 10, 15)
@@ -614,11 +614,11 @@ recheche arbre binaire de recherche
 ;;;
 programmation orientée objet, recherche dans arbre binaire de recherche
 ;;;
-Écrire une fonction recherche_abr qui prend en paramètre une instance de la classe arbre T (T étant un arbre binaire de recherche) et un entier n. Cette fonction renvoie True si n est présent dans T et False dans le cas contraire. 
+Écrire une fonction `recherche_abr` qui prend en paramètre une instance de la classe `arbre T` (`T` étant un arbre binaire de recherche) et un entier `n`. Cette fonction renvoie `True` si `n` est présent dans `T` et `False` dans le cas contraire. 
 La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+- `get_gauche()` renvoie l'arbre gauche  
+- g`et_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -688,7 +688,7 @@ On s’intéresse à la suite d’entiers définie par :
 • ensuite, chaque valeur est obtenue en faisant la somme des deux valeurs qui le précèdent.  
 La troisième valeur est donc 0+1 = 1, la quatrième est 1+2 = 3, la cinquième est 2+3 = 5, la sixième est 3 + 5 = 8, et ainsi de suite.  
 Cette suite d’entiers est connue sous le nom de suite de Fibonacci.  
-Écrire en Python une fonction fibonacci qui prend en paramètre un entier n supposé strictement positif et qui renvoie le terme d’indice n de cette suite.  
+Écrire en Python une fonction `fibonacci` qui prend en paramètre un entier `n` supposé strictement positif et qui renvoie le terme d’indice n de cette suite.  
 Exemples :  
 ```
 >>> fibonacci(0)
@@ -727,7 +727,7 @@ fusion tableaux
 ;;;
 tableaux (list Python), parcours tableau, comparaison valeurs
 ;;;
-Programmer la fonction fusion prenant en paramètres deux tableaux non vides tab1 et tab2 (type list) d’entiers, chacun dans l’ordre croissant, et renvoyant un tableau trié dans l’ordre croissant et contenant l’ensemble des valeurs de tab1 et tab2.  
+Programmer la fonction `fusion` prenant en paramètres deux tableaux non vides `tab1` et `tab2` (type list) d’entiers, chacun dans l’ordre croissant, et renvoyant un tableau trié dans l’ordre croissant et contenant l’ensemble des valeurs de `tab1` et `tab2`.  
 Exemples :  
 ```
 >>> fusion([3, 5], [2, 5])
@@ -770,7 +770,7 @@ multiplication
 ;;;
 calculs, tests
 ;;;
-Programmer la fonction multiplication qui prend en paramètres deux nombres entiers relatifs n1 et n2, et qui renvoie le produit de ces deux nombres.  
+Programmer la fonction `multiplication` qui prend en paramètres deux nombres entiers relatifs `n1` et `n2`, et qui renvoie le produit de ces deux nombres.  
 Les seules opérations arithmétiques autorisées sont l’addition et la soustraction.  
 Exemples :  
 ```
@@ -808,7 +808,7 @@ renverse chaine
 ;;;
 chaine de caractères, parcours d'une chaine, concaténation
 ;;;
-Programmer une fonction renverse qui prend en paramètre une chaîne de caractères mot et qui renvoie cette chaîne de caractères en ordre inverse.  
+Programmer une fonction `renverse` qui prend en paramètre une chaîne de caractères `mot` et qui renvoie cette chaîne de caractères en ordre inverse.  
 Exemple :  
 ```
 >>> renverse("")
@@ -851,7 +851,7 @@ Par exemple : avec la phrase 'Hello world !' le dictionnaire est le suivant :
 {'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}
 ```  
 L’ordre des clefs n’a pas d’importance.  
-Écrire une fonction nbr_occurrences prenant comme paramètre une chaîne de caractères chaine et renvoyant le dictionnaire des nombres d’occurrences des caractères de cette chaîne.  
+Écrire une fonction `nbr_occurrences` prenant comme paramètre une chaîne de caractères `chaine` et renvoyant le dictionnaire des nombres d’occurrences des caractères de cette chaîne.  
 ;;;
 c=""
 if nbr_occurrences('Hello world !') == {'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}:
@@ -870,7 +870,7 @@ On a relevé les valeurs moyennes annuelles des températures à Paris pour la p
 t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
 annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]
 ```
-Écrire la fonction annee_temperature_minimale qui prend en paramètres ces deux tableaux et qui renvoie la plus petite valeur relevée au cours de la période et l’année correspondante.  
+Écrire la fonction `annee_temperature_minimale` qui prend en paramètres ces deux tableaux et qui renvoie la plus petite valeur relevée au cours de la période et l’année correspondante.  
 On suppose que la température minimale est atteinte une seule fois.  
 Exemple :  
 ```
@@ -890,8 +890,8 @@ occurrences
 ;;;
 chaine de caractères, incrémentation d'une variable, parcours d'une chaine
 ;;;
-Écrire une fonction occurrences(caractere, chaine) qui prend en paramètres caractere, une chaîne de caractère de longueur 1, et chaine, une chaîne de caractères.  
-Cette fonction renvoie le nombre d’occurrences de caractere dans chaine, c’est-à-dire le nombre de fois où caractere apparaît dans chaine.  
+Écrire une fonction `occurrences(caractere, chaine)` qui prend en paramètres `caractere`, une chaîne de caractère de longueur 1, et `chaine`, une chaîne de caractères.  
+Cette fonction renvoie le nombre d’occurrences de `caractere` dans `chaine`, c’est-à-dire le nombre de fois où `caractere` apparaît dans `chaine`.  
 Exemples :  
 ```
 >>> occurrences('e', "sciences")
@@ -922,7 +922,7 @@ aire cercle
 ;;;
 calcul
 ;;;
-Écrire une fonction aire_cercle qui prend en paramètre le rayon d'un cercle r et qui renvoie l'aire du cercle.  
+Écrire une fonction `aire_cercle` qui prend en paramètre le rayon d'un cercle `r` et qui renvoie l'aire du cercle.  
 Exemple :  
 ```
 >>> aire_cercle(2)
@@ -942,9 +942,9 @@ indices maxi
 ;;;
 tableau(list Python), parcours d'un tableau, recherche d'un maxi
 ;;;
-Écrire une fonction indices_maxi qui prend en paramètre un tableau non vide de nombres entiers tab, représenté par une liste Python et qui renvoie un tuple (maxi, indices) où :  
-• maxi est le plus grand élément du tableau tab ;  
-• indices est une liste Python contenant les indices du tableau tab où apparaît ce plus grand élément.  
+Écrire une fonction `indices_maxi` qui prend en paramètre un tableau non vide de nombres entiers `tab`, représenté par une liste Python et qui renvoie un tuple `(maxi, indices)` où :  
+• `maxi` est le plus grand élément du tableau `tab` ;  
+• `indices` est une liste Python contenant les indices du tableau `tab` où apparaît ce plus grand élément.  
 Exemple :  
 ```
 >>> indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
@@ -969,7 +969,7 @@ addition
 ;;;
 calcul, valeur renvoyée par une fonction
 ;;;
-Écrire une fonction add qui prend en paramètre 2 entiers a et b. Cette fonction renvoie l'addition de a et b.  
+Écrire une fonction `add` qui prend en paramètre 2 entiers `a` et `b`. Cette fonction renvoie l'addition de `a` et `b`.  
 Exemple :  
 ```
 >>> add(3, 5)
@@ -993,9 +993,9 @@ Voici un exemple d’une telle table :
 ```
 animaux = [ {'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}, {'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5}, {'nom':'Tom', 'espece':'chat', 'age':7, 'enclos':4}, {'nom':'Belle', 'espece':'chien', 'age':6, 'enclos':3}, {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]
 ```
-Programmer une fonction selection_enclos qui :  
+Programmer une fonction `selection_enclos` qui :  
 prend en paramètres : une table animaux contenant des enregistrements relatifs à des animaux (comme dans l’exemple ci-dessus) et un numéro d’enclos num_enclos ;  
-La fonction renvoie une table contenant les enregistrements de animaux dont l’attribut 'enclos' est num_enclos.  
+La fonction renvoie une table contenant les enregistrements de animaux dont l’attribut 'enclos' est `num_enclos`.  
 Exemples avec la table animaux ci-dessus :  
 ```
 >>> selection_enclos(animaux, 5)
@@ -1028,7 +1028,7 @@ pair
 ;;;
 modulo, booléen
 ;;;
-Écrire une fonction pair qui prend en paramètre un entier n. Cette fonction renvoie True si n est pair et False si n est impair.  
+Écrire une fonction `pair` qui prend en paramètre un entier `n`. Cette fonction renvoie `True` si n est pair et `False` si `n` est impair.  
 Exemples :  
 ```
 >>> pair(8)
@@ -1053,7 +1053,7 @@ doublon
 ;;;
 tableau (list Python), parcours d'un tableau
 ;;;
-Écrire une fonction a_doublon qui prend en paramètre un tableau trié de nombres dans l’ordre croissant et renvoie True si ce tableau contient au moins deux nombres identiques, False sinon.  
+Écrire une fonction `a_doublon` qui prend en paramètre un tableau trié de nombres dans l’ordre croissant et renvoie `True` si ce tableau contient au moins deux nombres identiques, `False` sinon.  
 Exemple :  
 ```
 >>> a_doublon([])
@@ -1096,8 +1096,8 @@ somme
 ;;;
 tableau (list Python), parcours d'un tableau
 ;;;
-Écrire une fonction somme qui prend en paramètre un tableau d'entiers tab (de type list). Cette fonction renvoie la somme des éléments présents dans tab.  
-Il est interdit d'utiliser la fonction Python sum.  
+Écrire une fonction `somme` qui prend en paramètre un tableau d'entiers `tab` (de type list). Cette fonction renvoie la somme des éléments présents dans `tab`.  
+Il est interdit d'utiliser la fonction Python `sum`.  
 Exemples :  
 ```
 >>> somme([5, 4, 7])
@@ -1122,7 +1122,7 @@ else  :
 ;;;
 tableau (list Python), parcours d'un tableau, dictionnaire
 ;;;
-Écrire une fonction enumere qui prend en paramètre un tableau tab (typelist) et renvoie un dictionnaire d dont les clés sont les éléments de tab avec pour valeur associée la liste des indices de l’élément dans le tableau tab.  
+Écrire une fonction `enumere` qui prend en paramètre un tableau `tab` (typelist) et renvoie un dictionnaire `d` dont les clés sont les éléments de `tab` avec pour valeur associée la liste des indices de l’élément dans le tableau `tab`.  
 Exemple :  
 ```
 >>> enumere([])
@@ -1157,8 +1157,8 @@ Sur le réseau social TipTop, on s’intéresse au nombre de « like » des abon
 ```
 { 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 }
 ```
-Écrire une fonction max_dico qui :  
-• prend en paramètre un dictionnaire dico non vide dont les clés sont des chaînes de caractères et les valeurs associées sont des entiers ;  
+Écrire une fonction `max_dico` qui :  
+• prend en paramètre un dictionnaire `dico` non vide dont les clés sont des chaînes de caractères et les valeurs associées sont des entiers ;  
 • et qui renvoie un tuple dont :  
 – la première valeur est une clé du dictionnaire associée à la valeur maximale ;  
 – la seconde valeur est cette valeur maximale.  
@@ -1188,11 +1188,11 @@ chaîne de caractères, parcours d'une chaine, if, condition avec and et or
 ;;;
 On considère des chaînes de caractères contenant uniquement des majuscules et des caractères * appelées mots à trous.  
 Par exemple INFO*MA*IQUE, ***I***E** et *S* sont des mots à trous.  
-Programmer une fonction correspond :  
+Programmer une fonction `correspond` :  
 • qui prend en paramètres deux chaînes de caractères mot et mot_a_trous où mot_a_trous est un mot à trous comme indiqué ci-dessus ;  
 • et qui renvoie :  
-– True si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous ;  
-– False sinon.  
+– `True` si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous ;  
+– `False` sinon.  
 Exemple :  
 ```
 >>> correspond('INFORMATIQUE', 'INFO*MA*IQUE')
@@ -1229,7 +1229,7 @@ tri insertion
 ;;;
 tri d'un tableau, tri par insertion
 ;;;
-Écrire une fonction tri_insertion qui prend en paramètre un tableau tab de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri par insertion.  
+Écrire une fonction `tri_insertion` qui prend en paramètre un tableau `tab` de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri par insertion.  
 Exemple :  
 ```
 >>> tri_insertion([1, 52, 6, -9, 12])
@@ -1254,8 +1254,8 @@ insére
 ;;;
 tableau, insertion d'une valeur dans un tableau trié
 ;;;
-On considère la fonction insere ci-dessous qui prend en arguments un tableau tab d’entiers triés par ordre croissant et un entier a.  
-Cette fonction crée et renvoie un nouveau tableau à partir de celui fourni en paramètre en y insérant la valeur a de sorte que le tableau renvoyé soit encore trié par ordre croissant. Les tableaux seront représentés sous la forme de listes Python.  
+On considère la fonction `insere` ci-dessous qui prend en arguments un tableau `tab` d’entiers triés par ordre croissant et un entier `a`.  
+Cette fonction crée et renvoie un nouveau tableau à partir de celui fourni en paramètre en y insérant la valeur `a` de sorte que le tableau renvoyé soit encore trié par ordre croissant. Les tableaux seront représentés sous la forme de listes Python.  
 Écrire cette fonction insere  
 Exemples :  
 ```
@@ -1293,8 +1293,8 @@ décimal vers binaire
 ;;;
 conversion décimal vers binaire, modulo, division entière
 ;;;
-On considère la fonction binaire. Cette fonction prend en paramètre un entier positif a en écriture décimale et renvoie son écriture binaire sous la forme d’une chaine de caractères.  
-Écrire cette fonction binaire  
+On considère la fonction `binaire`. Cette fonction prend en paramètre un entier positif `a` en écriture décimale et renvoie son écriture binaire sous la forme d’une chaine de caractères.  
+Écrire cette fonction `binaire`  
 Exemples :  
 ```
 >>> binaire(83)
@@ -1331,11 +1331,11 @@ recherche dichotomique récursive
 ;;;
 récursivité, recherche dans un tableau, dichotomie
 ;;;
-Soit tab un tableau non vide d’entiers triés dans l’ordre croissant et n un entier.  
-La fonction chercher doit renvoyer l'indice de position de n dans le dernier s'il s'y trouve et None s'il est absent du tableau  
-La fonction recherche prend n en paramètre  
+Soit `tab` un tableau non vide d’entiers triés dans l’ordre croissant et `n` un entier.  
+La fonction `chercher` doit renvoyer l'indice de position de `n` dans le dernier s'il s'y trouve et `None` s'il est absent du tableau  
+La fonction recherche prend `n` en paramètre  
 L’algorithme demandé est une recherche dichotomique récursive.  
-Écrire le code de la fonction chercher.  
+Écrire le code de la fonction `chercher`.  
 ```
 Exemples :
 >>> chercher([1, 5, 6, 9, 12], 7)
@@ -1388,7 +1388,7 @@ resultats = {
 }
 ```
 L’élève dont le nom est Durand a ainsi obtenu au DS2 la note de 8 avec un coefficient 4. La professeure crée une fonction moyenne qui prend en paramètre le nom d’un de ses élèves et renvoie sa moyenne arrondie au dixième. Si l’élève n’a pas de notes, on considère que sa moyenne est nulle. Si le nom donné n’est pas dans les résultats, la fonction renvoie None.  
-Écrire le code de la fonction moyenne.  
+Écrire le code de la fonction `moyenne`.  
 Exemples :  
 ```
 >>> moyenne("Dupont", resultats)
@@ -1414,11 +1414,11 @@ parcours suffixe d'un arbre binaire (T)
 ;;;
 arbre, programmation orientée objet, parcours d'un arbre
 ;;;
-Écrire une fonction parcours_suffixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours suffixe de l'arbre binaire T.  
-La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+Écrire une fonction `parcours_suffixe qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours suffixe de l'arbre binaire `T`.  
+La classe `Arbre` possède 3 méthodes :  
+- `get_gauche()` renvoie l'arbre gauche  
+- `get_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1484,7 +1484,7 @@ Par exemple, pour ranger dans des boîtes de capacité c = 5 un ensemble de troi
 • Le deuxième objet, de masse 5, ne peut pas aller dans la même boite que le premier objet car cela dépasserait la capacité de la boite. On place donc cet objet dans une deuxième boîte.  
 • Le troisième objet, de masse 2, va dans la première boîte.  
 On a donc utilisé deux boîtes de capacité c = 5 pour ranger les 3 objets.  
-Écrire la fonction Python empaqueter qui prend en paramètre la liste des masses liste_masses et la capacité de la boite c. La fonction empaqueter doit renvoyer le nombre de boîtes de capacité c nécessaires pour empaqueter un ensemble d’objets dont les masses sont contenues dans la liste liste_masses. On supposera que toutes les masses sont inférieures ou égales à c.  
+Écrire la fonction Python `empaqueter` qui prend en paramètre la liste des masses `liste_masses` et la capacité de la boite `c`. La fonction empaqueter doit renvoyer le nombre de boîtes de capacité `c` nécessaires pour empaqueter un ensemble d’objets dont les masses sont contenues dans la liste `liste_masses`. On supposera que toutes les masses sont inférieures ou égales à `c`.  
 Exemples :  
 ```
 >>> empaqueter([1, 2, 3, 4, 5], 10)
@@ -1515,7 +1515,7 @@ un sur deux
 ;;;
 parcours d'un tableau, indice d'un tableau, création d'un tableau, append
 ;;;
-Écrire une fonction un_sur_deux qui prend en paramètre un tableau non vide tab contenant des entiers. Cette fonction renvoie un autre tableau contenant les entiers contenu dans tab, mais en gardant uniquement un entier sur deux.  
+Écrire une fonction `un_sur_deux` qui prend en paramètre un tableau non vide `tab` contenant des entiers. Cette fonction renvoie un autre tableau contenant les entiers contenu dans `tab`, mais en gardant uniquement un entier sur deux.  
 Exemples :  
 ```
 >>>  un_sur_deux([3, 4, 12, 8, 43,7])
@@ -1541,13 +1541,13 @@ plus grande somme (T)
 programmation dynamique, tableau
 ;;;
 On considère un tableau non vide de nombres entiers, positifs ou négatifs, et on souhaite déterminer la plus grande somme possible de ses éléments consécutifs.  
-Par exemple, dans le tableau [1, -2, 3, 10, -4, 7, 2, -5], la plus grande somme est 18 obtenue en additionnant les éléments 3, 10, -4, 7, 2.  
+Par exemple, dans le tableau `[1, -2, 3, 10, -4, 7, 2, -5]`, la plus grande somme est 18 obtenue en additionnant les éléments 3, 10, -4, 7, 2.  
 Pour cela, on va résoudre le problème par programmation dynamique. Si on note tab le tableau considéré et i un indice dans ce tableau, on se ramène à un problème plus simple : déterminer la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i.  
 Si on connait la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i-1, on peut déterminer la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i :  
 • soit on obtient une plus grande somme en ajoutant tab[i] à cette somme précédente ;  
 • soit on commence une nouvelle somme à partir de tab[i].  
 Remarque : les sommes considérées contiennent toujours au moins un terme.  
-Écrire la fonction somme_max qui prend en paramètre un tableau (de type list) et qui renvoie la plus grande somme possible des éléments consécutifs.  
+Écrire la fonction `somme_max` qui prend en paramètre un tableau (de type list) et qui renvoie la plus grande somme possible des éléments consécutifs.  
 Exemples :  
 ```
 >>> somme_max([1, 2, 3, 4, 5])
@@ -1590,11 +1590,11 @@ taille d'un arbre binaire (T)
 ;;;
 arbre binaire, programmation orientée objet, taille d'un arbre
 ;;;
-Écrire une fonction taille qui prend en paramètre une instance de la classe arbre T et renvoie la taille de l'arbre binaire T.  
-La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+Écrire une fonction `taille` qui prend en paramètre une instance de la classe `arbre T` et renvoie la taille de l'arbre binaire `T`.  
+La classe `Arbre` possède 3 méthodes :  
+- g`et_gauche()` renvoie l'arbre gauche  
+- `get_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1653,7 +1653,7 @@ sépare 0 et 1
 ;;;
 tableau, changer la position de valeurs dans un tableau
 ;;;
-Écrire la fonction separe qui prend en paramètre un tableau tab dont les éléments sont des 0 et des 1. Cette fonction renvoie un tableau qui contient autant de 0 et de 1 qu'il y en a dans tab mais où tous les 0 sont placés en début de tableau et tous les 1 sont placés en fin de tableau.  
+Écrire la fonction `separe` qui prend en paramètre un tableau `tab` dont les éléments sont des 0 et des 1. Cette fonction renvoie un tableau qui contient autant de 0 et de 1 qu'il y en a dans `tab` mais où tous les 0 sont placés en début de tableau et tous les 1 sont placés en fin de tableau.  
 Exemples :  
 ```
 >>> separe([1, 0, 1, 0, 1, 0, 1, 0])
@@ -1678,9 +1678,9 @@ else  :
 ;;;
 tableau, parcours simultané de 2 tableaux, indice de position
 ;;;
-On considère la fonction eleves_du_mois prenant en paramètres eleves et notes deux tableaux de même longueur, le premier contenant le nom des élèves et le second, des entiers positifs désignant leur note à un contrôle de sorte que eleves[i] a obtenu la note notes[i].  
+On considère la fonction `eleves_du_mois` prenant en paramètres eleves et notes deux tableaux de même longueur, le premier contenant le nom des élèves et le second, des entiers positifs désignant leur note à un contrôle de sorte que eleves[i] a obtenu la note notes[i].  
 Cette fonction renvoie le couple constitué de la note maximale attribuée et des noms des élèves ayant obtenu cette note regroupés dans un tableau.  
-Écrire la fonction eleves_du_mois.  
+Écrire la fonction `eleves_du_mois`.  
 Exemples :  
 ```
 >>> eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
@@ -1709,11 +1709,11 @@ parcours préfixe d'un arbre binaire (T)
 ;;;
 arbre, programmation orientée objet, parcours d'un arbre
 ;;;
-Écrire une fonction parcours_prefixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours préfixe de l'arbre binaire T.  
-La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+Écrire une fonction `parcours_prefixe` qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours préfixe de l'arbre binaire `T`.  
+La classe `Arbre` possède 3 méthodes :  
+- `get_gauche()` renvoie l'arbre gauche  
+- `get_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1791,7 +1791,7 @@ recherche dichotomique
 ;;;
 recherche dans un tableau, dichotomie
 ;;;
-Écrire une fonction dichotomie qui prend en paramètre un tableau tab d'entiers triés et un entier n. Cette fonction renvoie True si n est présent dans le tableau et False dans le cas contraire.  
+Écrire une fonction `dichotomie` qui prend en paramètre un tableau `tab` d'entiers triés et un entier `n`. Cette fonction renvoie `True` si `n` est présent dans le tableau et `False` dans le cas contraire.  
 Attention : vous devez utiliser l'algorithme de la recherche dichotomique  
 Exemples :  
 ```
@@ -1817,11 +1817,11 @@ parcours infixe d'un arbre binaire (T)
 ;;;
 arbre binaire, programmation orientée objet, parcours arbre binaire
 ;;;
-Écrire une fonction parcours_infixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours infixe de l'arbre binaire T.  
-La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+Écrire une fonction `parcours_infixe` qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours infixe de l'arbre binaire `T`.  
+La classe `Arbre` possède 3 méthodes :  
+- `get_gauche()` renvoie l'arbre gauche  
+- `get_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1880,8 +1880,8 @@ conversion Celsius fahrenheit
 ;;;
 calcul, conversion
 ;;;
-Écrire une fonction convert_celsius_fahrenheit qui prend en paramètre une température en degrés Celsius temp_celsius et qui renvoie la température équivalente en degrés Fahrenheit.
-La formule de conversion est : Fahrenheit = (Celsius * 9/5) + 32
+Écrire une fonction `convert_celsius_fahrenheit` qui prend en paramètre une température en degrés Celsius `temp_celsius` et qui renvoie la température équivalente en degrés Fahrenheit.
+La formule de conversion est : `Fahrenheit = (Celsius * 9/5) + 32`
 Exemple :
 ```
 >>> convert_celsius_fahrenheit(0)
@@ -1907,7 +1907,7 @@ palindrome
 chaine de caractères, concaténation, parcours d'une chaine de caractère
 ;;;
 Un mot palindrome peut se lire de la même façon de gauche à droite ou de droite à gauche : kayak, radar, et non sont des mots palindromes.  
-Écrire une fonction est_palindrome qui prend en paramètre une chaine de caractère mot. Cette fonction renvoie True si mot est un palindrome et False dans le cas contraire.  
+Écrire une fonction `est_palindrome` qui prend en paramètre une chaine de caractère `mot`. Cette fonction renvoie `True` si mot est un palindrome et `False` dans le cas contraire.  
 Exemples :  
 ```
 >>> est_palindrome('kayak')
@@ -1932,11 +1932,11 @@ hauteur d'un arbre binaire (T)
 ;;;
 arbre binaire, programmation orientée objet, hauteur d'un arbre
 ;;;
-Écrire une fonction hauteur qui prend en paramètre une instance de la classe arbre T et renvoie la hauteur de l'arbre binaire T.  
-La classe Arbre possède 3 méthodes :  
-- get_gauche() renvoie l'arbre gauche  
-- get_droit() renvoie l'arbre droit  
-- get_valeur() renvoie la valeur du noeud  
+Écrire une fonction `hauteur` qui prend en paramètre une instance de la classe `arbre T` et renvoie la hauteur de l'arbre binaire `T`.  
+La classe `Arbre` possède 3 méthodes :  
+- `get_gauche()` renvoie l'arbre gauche  
+- `get_droit()` renvoie l'arbre droit  
+- `get_valeur()` renvoie la valeur du noeud  
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1995,7 +1995,7 @@ dico vers tableau
 ;;;
 dictionnaire, tableau
 ;;;
-Écrire une fonction dico_tab qui prend en paramètre un dictionnaire d. Cette fonction renvoie un tableau contenant des tuples, chaque tuple contient en première position une clé du dictionnaire d et en deuxième position la valeur associée  à cette clé.  
+Écrire une fonction `dico_tab` qui prend en paramètre un dictionnaire `d`. Cette fonction renvoie un tableau contenant des tuples, chaque tuple contient en première position une clé du dictionnaire `d` et en deuxième position la valeur associée à cette clé.  
 Exemples :  
 ```
 >>> dico_tab({"pommes" : 3, "cerises" : 15, "fraises" : 7})
@@ -2031,7 +2031,7 @@ Exemple :
 ```
 [{"nom": "T-shirt", "prix": 15, "quantité": 10},  {"nom": "Pantalon", "prix": 30, "quantité": 5}, {"nom": "Chaussures", "prix": 60, "quantité": 2}]
 ```
-Écrire une fonction prix_article qui prend en paramètres inventaire (le tableau de dictionnaires représentant l'inventaire) et nom_article (le nom de l'article recherché). La fonction doit renvoyer le prix de l'article si celui-ci est présent dans l'inventaire, et -1 sinon.  
+Écrire une fonction `prix_article` qui prend en paramètres `inventaire` (le tableau de dictionnaires représentant l'inventaire) et `nom_article` (le nom de l'article recherché). La fonction doit renvoyer le prix de l'article si celui-ci est présent dans l'inventaire, et `-1` sinon.  
 Exemples :  
 ```
 >>> inv = [{"nom": "T-shirt", "prix": 15, "quantité": 10},  {"nom": "Pantalon", "prix": 30, "quantité": 5}, {"nom": "Chaussures", "prix": 60, "quantité": 2}]
@@ -2072,7 +2072,7 @@ donnees_meteo = {
     "Toulouse": {"max": 27, "min": 17, "precip": 10}
 }
 ```
-Écrire une fonction info_meteo qui prend en paramètre un relevé météo et renvoie un tuple contenant :  
+Écrire une fonction `info_meteo` qui prend en paramètre un relevé météo et renvoie un tuple contenant :  
 - le nom de la ville où la plus petite température a été relevée  
 - le nom de la ville où la plus haute température a été relevée  
 -  la somme de  toutes la pluviométrie.  
@@ -2118,7 +2118,7 @@ notes = {
     "Pierre-Louis" : ["abs", "abs", "abs", "abs"]
 }
 ``
-Écrire une fonction liste_moyenne qui prend un paramètre un dictionnaire  (même structure que ci-dessus). Cette fonction renvoie un tableau contenant des tuples. Chaque tuple contient le prénom de l'élève en première position et la moyenne de l'élève en deuxième position.  
+Écrire une fonction `liste_moyenne` qui prend un paramètre un dictionnaire (même structure que ci-dessus). Cette fonction renvoie un tableau contenant des tuples. Chaque tuple contient le prénom de l'élève en première position et la moyenne de l'élève en deuxième position.  
 Exemple :  
 ```
 >>> notes = {
@@ -2149,7 +2149,7 @@ calculatrice RPN (T)
 ;;;
 tableau, parcours d'un tableau, pile
 ;;;
-Écrire une fonction Python rpn_calcul qui prend en paramètre une expression expr sous forme d'un tableau de chaînes de caractères représentant une expression en notation polonaise inverse. Cette fonction doit renvoiyer le résultat du calcul. L'expression contient des nombres et des opérateurs (+, -, *, /).  
+Écrire une fonction Python `rpn_calcul` qui prend en paramètre une expression `expr` sous forme d'un tableau de chaînes de caractères représentant une expression en notation polonaise inverse. Cette fonction doit renvoiyer le résultat du calcul. L'expression contient des nombres et des opérateurs (+, -, *, /).  
 Utilisez une pile pour effectuer le calcul.  
 Parcourez la liste expression.  
 Si un élément est un nombre, empilez-le sur la pile.  
@@ -2190,7 +2190,7 @@ supprimer doublon
 ;;;
 tableau, parcours tableau par indice, création tableau, append
 ;;;
-Écrire une fonction supprimer_doublons qui prend en argument un tableau tab et qui renvoie un tableau contenant les mêmes éléments que la liste d'entrée, mais sans doublons.  
+Écrire une fonction `supprimer_doublons` qui prend en argument un tableau `tab` et qui renvoie un tableau contenant les mêmes éléments que la liste d'entrée, mais sans doublons.  
 Exemples :  
 ```
 >>> supprimer_doublons([1, 2, 2, 3, 4, 4, 5, 3, 1])
@@ -2227,7 +2227,7 @@ plus grand écart
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, valeur absolue, écart
 ;;;
-Écrire une fonction `plus_grand_ecart` qui prend en paramètre un tableau de nombres tab (type list) non vide et qui renvoie le plus grand écart entre deux nombres consécutifs de ce tableau. L'écart entre deux nombres est la valeur absolue de leur différence.  
+Écrire une fonction `plus_grand_ecart` qui prend en paramètre un tableau de nombres `tab` (type list) non vide et qui renvoie le plus grand écart entre deux nombres consécutifs de ce tableau. L'écart entre deux nombres est la valeur absolue de leur différence.  
 Exemples :  
 ```
 >>> plus_grand_ecart([1, 5, 2, 8, 2])
@@ -2258,7 +2258,7 @@ est divisible
 ;;;
 modulo, operateur %
 ;;;
-Écrire une fonction `est_divisible` qui prend en paramètre deux entiers a et b. Cette fonction renvoie True si a est divisible par b et False dans le cas contraire.  
+Écrire une fonction `est_divisible` qui prend en paramètre deux entiers `a` et `b`. Cette fonction renvoie `True` si `a` est divisible par `b` et `False` dans le cas contraire.  
 Exemples :  
 ```
 >>> est_divisible(10, 2)
@@ -2410,7 +2410,7 @@ trouve doublon
 ;;;
 tableau (list Python), boucle for, test d'égalité
 ;;;
-Écrire une fonction `trouve_doublon` qui prend en paramètre un tableau tab (type list) et qui renvoie True si le tableau contient au moins un doublon et False sinon.  
+Écrire une fonction `trouve_doublon` qui prend en paramètre un tableau `tab` (type list) et qui renvoie `True` si le tableau contient au moins un doublon et `False` sinon.  
 Exemples :  
 ```
 >>> trouve_doublon([1, 2, 3, 4, 5])
@@ -2441,7 +2441,7 @@ trouve element majoritaire
 ;;;
 tableau (liste Python), boucle for, dictionnaire, comptage, seuil
 ;;;
-Écrire une fonction `element_majoritaire` qui prend en paramètre un tableau tab (type list) et qui renvoie l'élément majoritaire de ce tableau, c'est-à-dire l'élément qui apparaît plus de n/2 fois dans le tableau, où n est la longueur du tableau. Si aucun élément n'est majoritaire, la fonction doit renvoyer None.  
+Écrire une fonction `element_majoritaire` qui prend en paramètre un tableau `tab` (type list) et qui renvoie l'élément majoritaire de ce tableau, c'est-à-dire l'élément qui apparaît plus de `n/2` fois dans le tableau, où `n` est la longueur du tableau. Si aucun élément n'est majoritaire, la fonction doit renvoyer `None`.  
 Exemples :  
 ```
 >>> element_majoritaire([1, 2, 2, 2, 1])
@@ -2471,7 +2471,7 @@ plus petit que la moyenne
 ;;;
 tableau (liste Python), boucle for, parcours d'un tableau, calculs, taille d'une liste (len), comparaison
 ;;;
-Écrire une fonction `plus_petit_moyenne` qui prend en paramètre un tableau non vide de nombres tab (de type list) et qui renvoie un tableau contenant les nombres de tab strictement inférieurs à la moyenne des nombres contenus dans tab.  
+Écrire une fonction `plus_petit_moyenne` qui prend en paramètre un tableau non vide de nombres `tab` (de type list) et qui renvoie un tableau contenant les nombres de tab strictement inférieurs à la moyenne des nombres contenus dans `tab`.  
 Exemples :  
 ```
 >>> plus_petit_moyenne([1, 2, 3, 4, 5])
@@ -2533,7 +2533,7 @@ est un nombre premier
 ;;;
 nombre premier, boucle for, test de primalité
 ;;;
-Écrire une fonction `est_premier` qui prend en paramètre un entier positif n. La fonction doit renvoyer True si n est un nombre premier et False sinon.  
+Écrire une fonction `est_premier` qui prend en paramètre un entier positif `n`. La fonction doit renvoyer `True` si `n` est un nombre premier et `False` sinon.  
 Un nombre premier est un nombre qui a exactement deux diviseurs distincts : 1 et lui-même.  
 Par convention, 0 et 1 ne sont pas premiers.  
 Exemples :  
@@ -2566,7 +2566,7 @@ somme des éléments d'un tableau (version récursive)
 ;;;
 tableau (liste Python), récursivité, somme
 ;;;
-Écrire une fonction récursive `somme_recursive` qui prend en paramètre un tableau de nombres tab (type list) et qui renvoie la somme de tous les éléments du tableau.  
+Écrire une fonction récursive `somme_recursive` qui prend en paramètre un tableau de nombres `tab` (type list) et qui renvoie la somme de tous les éléments du tableau.  
 Exemples :  
 ```
 >>> somme_recursive([1, 2, 3, 4, 5])
@@ -2597,7 +2597,7 @@ calcul surface rectangle
 ;;;
 calcul
 ;;;
-Écrire une fonction surface_rectangle qui prend en paramètre la longueur L et la largeur l d'un rectangle et qui renvoie la surface de ce rectangle.  
+Écrire une fonction `surface_rectangle` qui prend en paramètre la longueur `L` et la largeur `l` d'un rectangle et qui renvoie la surface de ce rectangle.  
 Exemple :  
 ```
 >>> surface_rectangle(5, 3)
@@ -2616,7 +2616,7 @@ trouve le plus long mot
 ;;;
 chaine de caractères, parcours d'un tableau, recherche du maximum
 ;;;
-Écrire une fonction `trouve_plus_long_mot` qui prend en paramètre un tableau de chaines de caractères mots (type list) non vide et qui renvoie le mot le plus long de ce tableau. S'il y a plusieurs mots de même longueur maximale, la fonction renvoie le premier mot rencontré dans le tableau.
+Écrire une fonction `trouve_plus_long_mot` qui prend en paramètre un tableau de chaines de caractères `mots` (type list) non vide et qui renvoie le mot le plus long de ce tableau. S'il y a plusieurs mots de même longueur maximale, la fonction renvoie le premier mot rencontré dans le tableau.
 Exemples :
 ```
 >>> trouve_plus_long_mot(["chat", "chien", "oiseau"])
@@ -2679,7 +2679,7 @@ calcul du périmètre d'un rectangle
 ;;;
 calcul périmètre
 ;;;
-Écrire une fonction `perimetre_rectangle` qui prend en paramètre la longueur L et la largeur l d'un rectangle et qui renvoie le périmètre de ce rectangle.  
+Écrire une fonction `perimetre_rectangle` qui prend en paramètre la longueur `L` et la largeur `l` d'un rectangle et qui renvoie le périmètre de ce rectangle.  
 Exemple :  
 ```
 >>> perimetre_rectangle(5, 3)
@@ -2698,7 +2698,7 @@ est divisible par tous
 ;;;
 tableaux (list Python), boucle for, modulo
 ;;;
-Écrire une fonction `est_divisible_par_tous` qui prend en paramètre un entier `n` et un tableau d'entiers diviseurs (type list). La fonction doit renvoyer `True` si n est divisible par tous les éléments du tableau diviseurs, et `False sinon`. Si le tableau diviseurs est vide, la fonction doit renvoyer `True`.  
+Écrire une fonction `est_divisible_par_tous` qui prend en paramètre un entier `n` et un tableau d'entiers diviseurs (type list). La fonction doit renvoyer `True` si n est divisible par tous les éléments du tableau diviseurs, et `False` sinon. Si le tableau diviseurs est vide, la fonction doit renvoyer `True`.  
 Exemples :  
 ```
 >>> est_divisible_par_tous(10, [2, 5])
@@ -2766,8 +2766,8 @@ somme des nombres pairs d'un tableau
 ;;;
 tableau (liste Python), boucle for, condition (if), modulo, somme
 ;;;
-Écrire une fonction `somme_pairs` qui prend en paramètre un tableau d'entiers tab (type list) et qui renvoie la somme des nombres pairs contenus dans ce tableau.  
-Si le tableau est vide, la fonction doit retourner 0.  
+Écrire une fonction `somme_pairs` qui prend en paramètre un tableau d'entiers `tab` (type list) et qui renvoie la somme des nombres pairs contenus dans ce tableau.  
+Si le tableau est vide, la fonction doit retourner `0`.  
 Exemples :  
 ```  
 >>> somme_pairs([1, 2, 3, 4, 5, 6])