Upload code.txt

code.txt

@@ -15,7 +15,7 @@ Exemple :
 ```
 ;;;
 c = ""
-if moyenne([10, 15, 20]) == 15:
+if moyenne([10, 15, 20]) == 15.0:
     c += "1"
 else :
     c += "0"
@@ -23,6 +23,14 @@ if moyenne([8, 11, 17, 10]) == 11.5:
     c += "1"
 else :
     c += "0"
+if moyenne([5, 15]) == 10.0:
+    c += '1'
+else:
+    c += '0'
+if moyenne([10, 20, 30, 40]) == 25.0:
+    c += "1"
+else :
+    c += "0"
 ;;;
 est voyelle
 ;;;
@@ -54,6 +62,14 @@ if est_voyelle('y') == True:
     c += "1"
 else:
     c += "0"
+if est_voyelle('u') == True:
+    c += '1'
+else:
+    c += '0'
+if est_voyelle('o') == True:
+    c += "1"
+else :
+    c += "0"
 ;;;
 maximum tableau
 ;;;
@@ -88,6 +104,14 @@ if maximum_tableau([-27, -24, -3, 15]) == 15:
     c += "1"
 else :
     c += "0"
+if maximum_tableau([10, 20, 5, 25, 15]) == 25:
+    c += '1'
+else:
+    c += '0'
+if maximum_tableau([10, 50, 20, 30]) == 50:
+    c += "1"
+else :
+    c += "0"
 ;;;
 mot de passe valide
 ;;;
@@ -119,12 +143,16 @@ if mdp_valide('MonSuperMDP12') == True:
     c += "1"
 else:
     c += "0"
+if mdp_valide('abc') == False:
+    c += '1'
+else:
+    c += '0'
 ;;;
 recherche
 ;;;
 2
 ;;;
-tableau (liste Python), boucle for, parcours d'un tableau, utilisation de l'indice 
+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`.  
@@ -150,6 +178,14 @@ if recherche([2,3,5,2,4],2) == 0:
     c += "1"
 else :
     c += "0"
+if recherche([10, 20, 30], 40) == None:
+    c += '1'
+else:
+    c += '0'
+if recherche([1, 2, 3, 4, 5], 3) == 2:
+    c += "1"
+else :
+    c += "0"
 ;;;
 est bissextile
 ;;;
@@ -182,6 +218,14 @@ if est_bissextile(2000) == True:
     c += "1"
 else:
     c += "0"
+if est_bissextile(2024) == True:
+    c += '1'
+else:
+    c += '0'
+if est_bissextile(1900) == False:
+    c += "1"
+else :
+    c += "0"
 ;;;
 dernier chiffre
 ;;;
@@ -213,6 +257,14 @@ if dernier_chiffre(1980) == 0:
     c += "1"
 else:
     c += "0"
+if dernier_chiffre(2023) == 3:
+    c += '1'
+else:
+    c += '0'
+if dernier_chiffre(99) == 9:
+    c += "1"
+else :
+    c += "0"
 ;;;
 max et indice
 ;;;
@@ -251,6 +303,14 @@ if max_et_indice([1, 1, 1, 1]) == (1, 0):
     c += "1"
 else  :
     c += "0"
+if max_et_indice([1, 9, 2, 9]) == (9, 1):
+    c += '1'
+else:
+    c += '0'
+if max_et_indice([5, 8, 2, 8]) == (8, 1):
+    c += "1"
+else :
+    c += "0"
 ;;;
 tarification
 ;;;
@@ -285,6 +345,14 @@ if tarification(25) == 'Plein tarif':
     c += "1"
 else:
     c += "0"
+if tarification(11) == 'Demi-tarif':
+    c += '1'
+else:
+    c += '0'
+if tarification(5) == 'Demi-tarif':
+    c += "1"
+else :
+    c += "0"
 ;;;
 prix TTC
 ;;;
@@ -310,6 +378,10 @@ if prix_ttc(50, 5.5) == 52.75:
     c += "1"
 else:
     c += "0"
+if prix_ttc(200, 10) == 220.0:
+    c += '1'
+else:
+    c += '0'
 ;;;
 verifie
 ;;;
@@ -390,6 +462,14 @@ if mention_bac(8.5) == 'Recalé':
     c += "1"
 else:
     c += "0"
+if mention_bac(14.5) == 'Bien':
+    c += '1'
+else:
+    c += '0'
+if mention_bac(11) == 'Passable':
+    c += "1"
+else :
+    c += "0"
 ;;;
 premier et dernier
 ;;;
@@ -421,6 +501,14 @@ if premier_dernier([42]) == (42, 42):
     c += "1"
 else  :
     c += "0"
+if premier_dernier([1, 2, 3]) == (1, 3):
+    c += '1'
+else:
+    c += '0'
+if premier_dernier(['A', 'B', 'C']) == ('A', 'C'):
+    c += "1"
+else :
+    c += "0"
 ;;;
 delta encoding
 ;;;
@@ -448,6 +536,14 @@ if delta([42]) == [42]:
     c += "1"
 else  :
     c += "0"
+if delta([10, 15, 12]) == [10, 5, -3]:
+    c += '1'
+else:
+    c += '0'
+if delta([100, 100, 100]) == [100, 0, 0]:
+    c += "1"
+else :
+    c += "0"
 ;;;
 moyenne pondérée
 ;;;
@@ -475,6 +571,10 @@ if moyenne([(3, 0), (5, 0)]) == None:
     c += "1"
 else  :
     c += "0"
+if moyenne([(5,1), (15,1)]) == 10.0:
+    c += '1'
+else:
+    c += '0'
 ;;;
 tri sélection
 ;;;
@@ -500,6 +600,14 @@ if tri_selection([6]) == [6]:
     c += "1"
 else  :
     c += "0"
+if tri_selection([3, 1, 2]) == [1, 2, 3]:
+    c += '1'
+else:
+    c += '0'
+if tri_selection([9, 7, 8]) == [7, 8, 9]:
+    c += "1"
+else :
+    c += "0"
 ;;;
 salutation
 ;;;
@@ -525,6 +633,14 @@ if salutation("Bob", 20) == 'Bonsoir Bob':
     c += "1"
 else:
     c += "0"
+if salutation('Antigravity', 9) == 'Bonjour Antigravity':
+    c += '1'
+else:
+    c += '0'
+if salutation('Bob', 19) == 'Bonsoir Bob':
+    c += "1"
+else :
+    c += "0"
 ;;;
 min et max
 ;;;
@@ -569,6 +685,14 @@ if min_et_max([-1, -1, -1, -1, -1]) == {'min': -1, 'max': -1}:
     c += "1"
 else  :
     c += "0"
+if min_et_max([5, 10, 1]) == {'min': 1, 'max': 10}:
+    c += '1'
+else:
+    c += '0'
+if min_et_max([10, 0, -10]) == {'min': -10, 'max': 10}:
+    c += "1"
+else :
+    c += "0"
 ;;;
 nombre de répétitions
 ;;;
@@ -592,7 +716,7 @@ if  nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5]) == 3:
     c += "1"
 else  :
     c += "0"
-if nb_repetitions('A', ['B', 'A', 'B', 'A', 'R']) == 2 :
+if nb_repetitions('A', ['B', 'A', 'B', 'A', 'R']) == 2:
     c += "1"
 else  :
     c += "0"
@@ -600,6 +724,14 @@ if nb_repetitions(12, [1, 3, 7, 21, 36, 44]) == 0:
     c += "1"
 else  :
     c += "0"
+if nb_repetitions(1, [1, 2, 1, 3, 1]) == 3:
+    c += '1'
+else:
+    c += '0'
+if nb_repetitions('X', ['X', 'Y', 'X', 'Z']) == 2:
+    c += "1"
+else :
+    c += "0"
 ;;;
 volume cube
 ;;;
@@ -625,12 +757,20 @@ if volume_cube(10) == 1000:
     c += "1"
 else:
     c += "0"
+if volume_cube(2) == 8:
+    c += '1'
+else:
+    c += '0'
+if volume_cube(1) == 1:
+    c += "1"
+else :
+    c += "0"
 ;;;
 recherche motif
 ;;;
 3
 ;;;
-chaine de caractère, parcours d'une chaine, recherche d'un 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.  
 Exemples:  
@@ -662,6 +802,14 @@ if recherche_motif("ab", "abracadabraab") == [0, 7, 11]:
     c+="1"
 else  :
     c+="0"
+if recherche_motif('aa', 'aaa') == [0, 1]:
+    c += '1'
+else:
+    c += '0'
+if recherche_motif('ab', 'abracadabra') == [0, 7]:
+    c += "1"
+else :
+    c += "0"
 ;;;
 recherche indice classement
 ;;;
@@ -702,6 +850,10 @@ if recherche_indices_classement(3, []) == ([], [], []):
     c+="1"
 else  :
     c+="0"
+if recherche_indices_classement(10, [5, 10, 15]) == ([0], [1], [2]):
+    c += '1'
+else:
+    c += '0'
 ;;;
 signe
 ;;;
@@ -736,6 +888,10 @@ if signe(0) == 'nul':
     c += "1"
 else:
     c += "0"
+if signe(-10) == 'strictement négatif':
+    c += '1'
+else:
+    c += '0'
 ;;;
 (T) parcours largeur arbre
 ;;;
@@ -794,6 +950,14 @@ if recherche_min([-1, -2, -3, -3]) == 2:
     c+="1"
 else  :
     c+="0"
+if recherche_min([1, 2, 3]) == 0:
+    c += '1'
+else:
+    c += '0'
+if recherche_min([10, 20, 30]) == 0:
+    c += "1"
+else :
+    c += "0"
 ;;;
 ajoute dictionnaire
 ;;;
@@ -915,10 +1079,15 @@ if moyenne(5, 10, 15) == 10:
     c+="1"
 else  :
     c+="0"
+if moyenne(5, 5, 5) == 5:
+    c += '1'
+else:
+    c += '0'
+
 ;;;
 (T) recheche arbre binaire de recherche
 ;;;
-2
+3
 ;;;
 programmation orientée objet, recherche dans arbre binaire de recherche
 ;;;
@@ -926,7 +1095,7 @@ programmation orientée objet, recherche dans arbre binaire de recherche
 La classe Arbre possède 3 méthodes :  
 - `get_gauche()` renvoie l'arbre gauche  
 - g`et_droit()` renvoie l'arbre droit  
-- `get_valeur()` renvoie la valeur du noeud  
+- `get_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1071,6 +1240,10 @@ if fusion([1, 2, 3], []) == [1, 2, 3]:
     c+="1"
 else  :
     c+="0"
+if fusion([1], [2]) == [1, 2]:
+    c+="1"
+else :
+    c+="0"
 ;;;
 multiplication
 ;;;
@@ -1159,7 +1332,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}:
@@ -1270,6 +1443,14 @@ if indices_maxi([7]) == (7, [0]):
     c+="1"
 else  :
     c+="0"
+if indices_maxi([1, 2,10,10,3]) == (10,[2,3]):
+    c += '1'
+else:
+    c += '0'
+if indices_maxi([42, 17, 99]) == (99,[2]):
+    c += "1"
+else :
+    c += "0"
 ;;;
 addition
 ;;;
@@ -1423,6 +1604,11 @@ if somme([]) == 0:
     c+="1"
 else  :
     c+="0"
+
+if somme([1, 2, 3, 4]) == 10:
+    c += "1"
+else :
+    c += "0"
 ;;;
 énumère
 ;;;
@@ -1483,7 +1669,7 @@ if max_dico({ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 }) == ('Ada', 201)
     c+="1"
 else  :
     c+="0"
-if max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 }) == ('Alan', 222) or ('Eve', 222) :
+if max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 }) in [('Alan', 222),('Eve', 222)] :
     c+="1"
 else  :
     c+="0"
@@ -1492,7 +1678,7 @@ correspond
 ;;;
 3
 ;;;
-chaîne de caractères, parcours d'une chaine, if, condition avec and et or 
+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.  
@@ -1648,7 +1834,7 @@ L’algorithme demandé est une recherche dichotomique récursive.
 Exemples :
 >>> chercher([1, 5, 6, 9, 12], 7)
 >>> chercher([1, 5, 6, 9, 12], 9)
-4
+3
 >>> chercher([1, 5, 6, 9, 12], 6)
 2
 ```
@@ -1666,6 +1852,14 @@ if chercher([1, 5, 6, 9, 12], 6) ==  2:
     c+="1"
 else  :
     c+="0"
+if chercher([1, 2, 3], 2) == 1:
+    c += '1'
+else:
+    c += '0'
+if chercher([10, 20, 30], 20) == 1:
+    c += "1"
+else :
+    c += "0"
 ;;;
 moyenne dico
 ;;;
@@ -1726,7 +1920,7 @@ arbre, programmation orientée objet, parcours d'un arbre
 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_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -1891,10 +2085,18 @@ if somme_max([-3,-2,-1,-4]) == -1 :
     c+="1"
 else  :
     c+="0"
+if somme_max([1, 2, 10, 3]) == 16:
+    c+='1'
+else:
+    c+='0'
+if somme_max([1, 2, 3, 4]) == 10:
+    c+="1"
+else :
+    c+="0"
 ;;;
 (T) taille d'un arbre binaire
 ;;;
-2
+3
 ;;;
 arbre binaire, programmation orientée objet, taille d'un arbre
 ;;;
@@ -1902,7 +2104,7 @@ arbre binaire, programmation orientée objet, taille d'un arbre
 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  
+- `get_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -2021,7 +2223,7 @@ arbre, programmation orientée objet, parcours d'un arbre
 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_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -2118,6 +2320,14 @@ if not dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27):
     c+="1"
 else  :
     c+="0"
+if dichotomie([1, 2, 3], 2):
+    c += '1'
+else:
+    c += '0'
+if not dichotomie([10, 20, 30], 40):
+    c += "1"
+else :
+    c += "0"
 ;;;
 (T) parcours infixe d'un arbre binaire
 ;;;
@@ -2129,7 +2339,7 @@ arbre binaire, programmation orientée objet, parcours arbre binaire
 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_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -2236,7 +2446,7 @@ else  :
 ;;;
 (T) hauteur d'un arbre binaire
 ;;;
-2
+3
 ;;;
 arbre binaire, programmation orientée objet, hauteur d'un arbre
 ;;;
@@ -2244,7 +2454,7 @@ arbre binaire, programmation orientée objet, hauteur d'un arbre
 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_valeur()` renvoie la valeur du noeud
 ;;;
 class ArbreBinaire:
     def __init__(self, valeur):
@@ -2613,7 +2823,7 @@ if est_anagramme("chien", "niche"):
  c += "1"
 else:
  c += "0"
-if est_anagramme("marie ", "aimer"):
+if est_anagramme("marie", "aimer"):
  c += "1"
 else:
  c += "0"
@@ -2801,6 +3011,10 @@ if plus_petit_moyenne([1, 1, 1, 1, 1]) == []:
     c += "1"
 else:
     c += "0"
+if plus_petit_moyenne([5, 15]) == [5]:
+    c += '1'
+else:
+    c += '0'
 ;;;
 somme des chiffres
 ;;;
@@ -2868,7 +3082,7 @@ else:
 ;;;
 (T) somme des éléments d'un tableau
 ;;;
-4
+3
 ;;;
 tableau (liste Python), récursivité, somme
 ;;;
@@ -2896,6 +3110,11 @@ if somme_recursive([10]) == 10:
  c += "1"
 else:
  c += "0"
+
+if somme_recursive([1, 2, 3, 4]) == 10:
+    c += "1"
+else :
+    c += "0"
 ;;;
 calcul surface rectangle
 ;;;
@@ -3068,7 +3287,7 @@ else:
 ;;;
 somme des nombres pairs d'un tableau
 ;;;
-2 
+2
 ;;;
 tableau (liste Python), boucle for, condition (if), modulo, somme
 ;;;
@@ -3084,27 +3303,31 @@ Exemples :
 20  
 >>> somme_pairs([])  
 0  
-```  
+```
 ;;;
 c = ""  
-if somme_pairs([1, 2, 3, 4, 5, 6]) == 12:  
- c += "1"  
-else:  
- c += "0"  
-if somme_pairs([1, 3, 5, 7]) == 0:  
- c += "1"  
-else:  
- c += "0"  
-if somme_pairs([2, 4, 6, 8]) == 20:  
- c += "1"  
-else:  
- c += "0"  
-if somme_pairs([]) == 0:  
- c += "1"  
-else:  
- c += "0"
+if somme_pairs([1, 2, 3, 4, 5, 6]) == 12:
+    c+="1"  
+else:
+    c+="0"  
+if somme_pairs([1, 3, 5, 7]) == 0:
+    c+="1"  
+else:
+    c+="0"  
+if somme_pairs([2, 4, 6, 8]) == 20:
+    c+="1"  
+else:
+    c+="0"  
+if somme_pairs([]) == 0:
+    c+="1"  
+else:
+    c+="0"
+if somme_pairs([1, 2, 3, 4]) == 6:
+    c+="1"
+else :
+    c+="0"
 ;;;
-(T) est un palindrome bis 
+(T) est un palindrome bis
 ;;;
 3
 ;;;
@@ -3154,7 +3377,7 @@ Exemples :
 >>> nombre_voyelles("Bonjour")
 3
 >>> nombre_voyelles("Python")
-1
+2
 >>> nombre_voyelles("AEIOUY")
 6
 >>> nombre_voyelles("")
@@ -3178,6 +3401,10 @@ if nombre_voyelles("") == 0:
     c += "1"
 else:
     c += "0"
+if nombre_voyelles('z') == 0:
+    c += '1'
+else:
+    c += '0'
 ;;;
 est un triangle rectangle ?
 ;;;
@@ -3210,3 +3437,488 @@ if not est_rectangle(6, 8, 11):
 else:
  c += "0"
 ;;;
+somme pairs
+;;;
+2
+;;;
+tableau, boucle for, parcours d'un tableau, conditions, modulo
+;;;
+Écrire une fonction `somme_pairs` qui prend en paramètre un tableau d'entiers `tab` et qui renvoie la somme de tous les nombres pairs présents dans le tableau. Si le tableau ne contient aucun nombre pair ou est vide, la fonction renvoie 0.  
+Exemples :  
+```
+>>> somme_pairs([1, 2, 3, 4])
+6
+>>> somme_pairs([1, 3, 5])
+0
+>>> somme_pairs([])
+0
+```
+;;;
+c = ""
+if somme_pairs([1, 2, 3, 4]) == 6:
+    c += "1"
+else:
+    c += "0"
+if somme_pairs([1, 3, 5]) == 0:
+    c += "1"
+else:
+    c += "0"
+if somme_pairs([]) == 0:
+    c += "1"
+else:
+    c += "0"
+;;;
+tous positifs
+;;;
+2
+;;;
+tableau, boucle for, booléen, conditions
+;;;
+Écrire une fonction `tous_positifs` qui prend en paramètre un tableau de nombres entiers `tab` et qui renvoie `True` si tous les éléments du tableau sont strictement positifs et `False` sinon. Un tableau vide doit renvoyer `True`.  
+Exemples :  
+```
+>>> tous_positifs([1, 5, 2, 9])
+True
+>>> tous_positifs([1, -3, 5])
+False
+>>> tous_positifs([])
+True
+```
+;;;
+c = ""
+if tous_positifs([1, 5, 2, 9]) == True:
+    c += "1"
+else:
+    c += "0"
+if tous_positifs([1, -3, 5]) == False:
+    c += "1"
+else:
+    c += "0"
+if tous_positifs([]) == True:
+    c += "1"
+else:
+    c += "0"
+;;;
+recherche arriere
+;;;
+2
+;;;
+tableau, parcours à l'envers, boucle for, indice
+;;;
+Écrire une fonction `recherche_arriere` qui prend en paramètres un tableau d'entiers `tab` et un entier `n`. La fonction renvoie l'indice de la dernière occurrence de `n` dans `tab`. Si `n` n'est pas présent, la fonction renvoie `None`.  
+Exemples :  
+```
+>>> recherche_arriere([1, 2, 3, 2, 4], 2)
+3
+>>> recherche_arriere([5, 5, 5], 5)
+2
+>>> recherche_arriere([1, 2], 3)
+None
+```
+;;;
+c = ""
+if recherche_arriere([1, 2, 3, 2, 4], 2) == 3:
+    c += "1"
+else:
+    c += "0"
+if recherche_arriere([5, 5, 5], 5) == 2:
+    c += "1"
+else:
+    c += "0"
+if recherche_arriere([1, 2], 3) == None:
+    c += "1"
+else:
+    c += "0"
+if recherche_arriere([1, 2, 3], 2) == 1:
+    c += '1'
+else:
+    c += '0'
+if recherche_arriere([10, 20, 30], 20) == 1:
+    c += "1"
+else :
+    c += "0"
+;;;
+produit tableau
+;;;
+2
+;;;
+tableau, boucle for, multiplication, accumulateur
+;;;
+Écrire une fonction `produit_tableau` qui prend en paramètre un tableau non vide de nombres entiers `tab` et renvoie le produit de tous ses éléments.  
+Exemples :  
+```
+>>> produit_tableau([2, 3, 4])
+24
+>>> produit_tableau([-1, 50])
+-50
+>>> produit_tableau([100, 0, 5])
+0
+```
+;;;
+c = ""
+if produit_tableau([2, 3, 4]) == 24:
+    c += "1"
+else:
+    c += "0"
+if produit_tableau([-1, 50]) == -50:
+    c += "1"
+else:
+    c += "0"
+if produit_tableau([100, 0, 5]) == 0:
+    c += "1"
+else:
+    c += "0"
+;;;
+compte voyelles
+;;;
+2
+;;;
+chaine de caractères, boucle for, test d'appartenance
+;;;
+Écrire une fonction `compte_voyelles` qui prend en paramètre une chaîne de caractères `mot` (contenant uniquement des lettres en minuscules) et renvoie le nombre de voyelles (a, e, i, o, u, y) qu'elle contient.  
+Exemples :  
+```
+>>> compte_voyelles("bonjour")
+3
+>>> compte_voyelles("rythme")
+1
+>>> compte_voyelles("bcdfg")
+0
+```
+;;;
+c = ""
+if compte_voyelles("bonjour") == 3:
+    c += "1"
+else:
+    c += "0"
+if compte_voyelles("rythme") == 1:
+    c += "1"
+else:
+    c += "0"
+if compte_voyelles("bcdfg") == 0:
+    c += "1"
+else:
+    c += "0"
+if compte_voyelles('z') == 0:
+    c += '1'
+else:
+    c += '0'
+;;;
+renverse tableau
+;;;
+2
+;;;
+tableau, parcours, création de tableau
+;;;
+Écrire une fonction `renverse_tableau` qui prend en paramètre un tableau `tab` et renvoie un NOUVEAU tableau contenant les mêmes éléments mais dans l'ordre inverse. Il est interdit d'utiliser la méthode `reverse` de Python ou les slices comme `[::-1]`.  
+Exemples :  
+```
+>>> renverse_tableau([1, 2, 3])
+[3, 2, 1]
+>>> renverse_tableau(["a", "b"])
+['b', 'a']
+>>> renverse_tableau([])
+[]
+```
+;;;
+c = ""
+if renverse_tableau([1, 2, 3]) == [3, 2, 1]:
+    c += "1"
+else:
+    c += "0"
+if renverse_tableau(["a", "b"]) == ["b", "a"]:
+    c += "1"
+else:
+    c += "0"
+if renverse_tableau([]) == []:
+    c += "1"
+else:
+    c += "0"
+;;;
+deuxieme plus grand
+;;;
+2
+;;;
+tableau, boucle for, comparaisons
+;;;
+Écrire une fonction `deuxieme_plus_grand` qui prend en paramètre un tableau non vide d'entiers distincts `tab` (contenant au moins deux éléments) et qui renvoie la valeur du deuxième plus grand élément. Il est interdit d'utiliser la méthode `sort` ou les fonctions `sorted` et `max`.  
+Exemples :  
+```
+>>> deuxieme_plus_grand([5, 20, 10, 15])
+15
+>>> deuxieme_plus_grand([-5, -10, -2])
+-5
+>>> deuxieme_plus_grand([1, 2])
+1
+```
+;;;
+c = ""
+if deuxieme_plus_grand([5, 20, 10, 15]) == 15:
+    c += "1"
+else:
+    c += "0"
+if deuxieme_plus_grand([-5, -10, -2]) == -5:
+    c += "1"
+else:
+    c += "0"
+if deuxieme_plus_grand([1, 2]) == 1:
+    c += "1"
+else:
+    c += "0"
+;;;
+filtre pairs
+;;;
+2
+;;;
+tableau, boucle for, conditions, création de tableau
+;;;
+Écrire une fonction `filtre_pairs` qui prend en paramètre un tableau d'entiers `tab` et renvoie un nouveau tableau contenant uniquement les nombres pairs de `tab` dans leur ordre d'apparition.  
+Exemples :  
+```
+>>> filtre_pairs([1, 2, 3, 4, 5])
+[2, 4]
+>>> filtre_pairs([1, 3, 5])
+[]
+>>> filtre_pairs([2, -4, 6])
+[2, -4, 6]
+```
+;;;
+c = ""
+if filtre_pairs([1, 2, 3, 4, 5]) == [2, 4]:
+    c += "1"
+else:
+    c += "0"
+if filtre_pairs([1, 3, 5]) == []:
+    c += "1"
+else:
+    c += "0"
+if filtre_pairs([2, -4, 6]) == [2, -4, 6]:
+    c += "1"
+else:
+    c += "0"
+;;;
+est parfait
+;;;
+2
+;;;
+mathématiques, boucle for, accumulateur, division
+;;;
+Écrire une fonction `est_parfait` qui prend en paramètre un entier strictement positif `n` et renvoie `True` si cet entier est un nombre parfait (c'est-à-dire égal à la somme de ses diviseurs propres strictements inférieurs à `n`), et `False` sinon.  
+Exemples :  
+```
+>>> est_parfait(6)
+True
+>>> est_parfait(28)
+True
+>>> est_parfait(10)
+False
+```
+;;;
+c = ""
+if est_parfait(6) == True:
+    c += "1"
+else:
+    c += "0"
+if est_parfait(28) == True:
+    c += "1"
+else:
+    c += "0"
+if est_parfait(10) == False:
+    c += "1"
+else:
+    c += "0"
+;;;
+alternance
+;;;
+2
+;;;
+tableau, boucle for, modulo, indice
+;;;
+Écrire une fonction `alternance` qui prend en paramètre un tableau non vide d'entiers `tab` et renvoie `True` si les éléments du tableau alternent strictement entre pair et impair (ou impair et pair), et `False` sinon. (Un tableau à 1 élément renvoie `True`).  
+Exemples :  
+```
+>>> alternance([1, 2, 3, 4])
+True
+>>> alternance([2, 5, 8, 11])
+True
+>>> alternance([1, 3, 2])
+False
+```
+;;;
+c = ""
+if alternance([1, 2, 3, 4]) == True:
+    c += "1"
+else:
+    c += "0"
+if alternance([2, 5, 8, 11]) == True:
+    c += "1"
+else:
+    c += "0"
+if alternance([1, 3, 2]) == False:
+    c += "1"
+else:
+    c += "0"
+;;;
+remplace
+;;;
+2
+;;;
+chaine de caractères, boucle for, concaténation
+;;;
+Écrire une fonction `remplace` qui prend en paramètres une chaîne de caractères `texte`, un caractère `c1` et un caractère `c2`. La fonction renvoie une nouvelle chaîne où toutes les occurrences de `c1` dans `texte` ont été remplacées par `c2`. L'utilisation de la méthode native `replace` est interdite.  
+Exemples :  
+```
+>>> remplace("bonjour", "o", "a")
+'banjaur'
+>>> remplace("test", "z", "e")
+'test'
+>>> remplace("", "a", "b")
+''
+```
+;;;
+c = ""
+if remplace("bonjour", "o", "a") == "banjaur":
+    c += "1"
+else:
+    c += "0"
+if remplace("test", "z", "e") == "test":
+    c += "1"
+else:
+    c += "0"
+if remplace("", "a", "b") == "":
+    c += "1"
+else:
+    c += "0"
+;;;
+est trie decroissant
+;;;
+2
+;;;
+tableau, boucle for, comparaisons
+;;;
+Écrire une fonction `est_trie_decroissant` qui prend en paramètre un tableau de nombres `tab` et renvoie `True` si le tableau est trié dans l'ordre décroissant, et `False` sinon. Un tableau vide ou ne contenant qu'un élément est considéré comme trié.  
+Exemples :  
+```
+>>> est_trie_decroissant([9, 5, 2, 1])
+True
+>>> est_trie_decroissant([5, 5, 3])
+True
+>>> est_trie_decroissant([10, 8, 12])
+False
+```
+;;;
+c = ""
+if est_trie_decroissant([9, 5, 2, 1]) == True:
+    c += "1"
+else:
+    c += "0"
+if est_trie_decroissant([5, 5, 3]) == True:
+    c += "1"
+else:
+    c += "0"
+if est_trie_decroissant([10, 8, 12]) == False:
+    c += "1"
+else:
+    c += "0"
+;;;
+ecart max
+;;;
+2
+;;;
+tableau, recherche minimum et maximum, soustraction
+;;;
+Écrire une fonction `ecart_max` qui prend en paramètre un tableau non vide de nombres `tab` et renvoie l'écart maximum entre deux valeurs du tableau (c'est-à-dire la différence entre la plus grande et la plus petite valeur). L'utilisation des fonctions natives `min` et `max` est interdite.  
+Exemples :  
+```
+>>> ecart_max([1, 5, 10, 2])
+9
+>>> ecart_max([-5, 0, 5])
+10
+>>> ecart_max([3, 3, 3])
+0
+```
+;;;
+c = ""
+if ecart_max([1, 5, 10, 2]) == 9:
+    c += "1"
+else:
+    c += "0"
+if ecart_max([-5, 0, 5]) == 10:
+    c += "1"
+else:
+    c += "0"
+if ecart_max([3, 3, 3]) == 0:
+    c += "1"
+else:
+    c += "0"
+if ecart_max([1, 2, 10, 3]) == 9:
+    c += '1'
+else:
+    c += '0'
+if ecart_max([42, 17, 99]) == 82:
+    c += "1"
+else :
+    c += "0"
+;;;
+intersection tableaux
+;;;
+2
+;;;
+tableau, boucle for, test d'appartenance
+;;;
+Écrire une fonction `intersection` qui prend en paramètres deux tableaux d'entiers `tab1` et `tab2` sans doublons et qui renvoie un nouveau tableau contenant les éléments présents à la fois dans `tab1` et `tab2`, dans leur ordre d'apparition dans `tab1`.  
+Exemples :  
+```
+>>> intersection([1, 2, 3], [2, 3, 4])
+[2, 3]
+>>> intersection([1, 5, 9, 2], [5, 2, 8])
+[5, 2]
+>>> intersection([1, 2], [3, 4])
+[]
+```
+;;;
+c = ""
+if intersection([1, 2, 3], [2, 3, 4]) == [2, 3]:
+    c += "1"
+else:
+    c += "0"
+if intersection([1, 5, 9, 2], [5, 2, 8]) == [5, 2]:
+    c += "1"
+else:
+    c += "0"
+if intersection([1, 2], [3, 4]) == []:
+    c += "1"
+else:
+    c += "0"
+;;;
+prefixes
+;;;
+2
+;;;
+chaine de caractères, boucle for, concaténation, tableau
+;;;
+Écrire une fonction `prefixes` qui prend en paramètre une chaîne de caractères `mot` et renvoie un tableau contenant tous les préfixes non vides de ce mot, du plus court au plus long.  
+Exemples :  
+```
+>>> prefixes("chat")
+['c', 'ch', 'cha', 'chat']
+>>> prefixes("a")
+['a']
+>>> prefixes("")
+[]
+```
+;;;
+c = ""
+if prefixes("chat") == ['c', 'ch', 'cha', 'chat']:
+    c += "1"
+else:
+    c += "0"
+if prefixes("a") == ['a']:
+    c += "1"
+else:
+    c += "0"
+if prefixes("") == []:
+    c += "1"
+else:
+    c += "0"
+;;;