Upload 4 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+code.db filter=lfs diff=lfs merge=lfs -text

code.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff386aa059c06242d2b0f7b104a916a4eee21e43cb39ef5114f08c26f118b712
+size 126976

code.txt

@@ -0,0 +1,1601 @@
+moyenne
+;;;
+2
+;;;
+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  
+Exemple :  
+```
+>>> moyenne([10, 15, 20])
+15.0
+>>> moyenne([8, 11, 17, 10])
+11.5
+```
+;;;
+c = ""
+if moyenne([10, 15, 20]) == 15:
+    c += "1"
+else :
+    c += "0"
+if moyenne([8, 11, 17, 10]) == 11.5:
+    c += "1"
+else :
+    c += "0"
+;;;
+maximum tableau
+;;;
+2
+;;;
+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  
+Exemples :  
+```
+>>> maximum_tableau([98, 12, 104, 23, 131, 9])
+131
+>>> maximum_tableau([-27, 24, -3, 15])
+24
+```
+;;;
+c = ""
+if maximum_tableau([98, 12, 104, 23, 131, 9]) == 131:
+    c += "1"
+else :
+    c += "0"
+if maximum_tableau([-27, 24, -3, 15]) == 24:
+    c += "1"
+else :
+    c += "0"
+if maximum_tableau([-27, -24, -3, -15]) == -3:
+    c += "1"
+else :
+    c += "0"
+;;;
+recherche
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> recherche([5, 3],1) # renvoie None
+>>> recherche([2,4],2)
+0
+>>> recherche([2,3,5,2,4],2)
+0
+```
+;;;
+c = ""
+if recherche([5, 3],1) == None:
+    c += "1"
+else :
+    c += "0"
+if recherche([2,4],2) == 0:
+    c += "1"
+else :
+    c += "0"
+if recherche([2,3,5,2,4],2) == 0:
+    c += "1"
+else :
+    c += "0"
+;;;
+max et indice
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
+(9, 3)
+>>> max_et_indice([-2])
+(-2, 0)
+>>> max_et_indice([-1, -1, 3, 3, 3])
+(3, 2)
+>>> max_et_indice([1, 1, 1, 1])
+(1, 0)
+```
+;;;
+c = ""
+if max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9,3):
+    c += "1"
+else  :
+    c += "0"
+if max_et_indice([-2]) == (-2, 0):
+    c += "1"
+else  :
+    c += "0"
+if max_et_indice([-1, -1, 3, 3, 3]) == (3, 2):
+    c += "1"
+else  :
+    c += "0"
+if max_et_indice([1, 1, 1, 1]) == (1, 0):
+    c += "1"
+else  :
+    c += "0"
+;;;
+verifie
+;;;
+3
+;;;
+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.  
+Un tableau vide est considéré comme trié.  
+Exemples :  
+```
+>>> verifie([0, 5, 8, 8, 9])
+True
+>>> verifie([8, 12, 4])
+False
+>>> verifie([-1, 4])
+True
+>>> verifie([])
+True
+>>> verifie([5])
+True
+```
+;;;
+c = ""
+if verifie([0, 5, 8, 8, 9]):
+    c += "1"
+else  :
+    c += "0"
+if not verifie([8, 12, 4]):
+    c += "1"
+else  :
+    c += "0"
+if verifie([-1, 4]):
+    c += "1"
+else  :
+    c += "0"
+if verifie([]):
+    c += "1"
+else  :
+    c += "0"
+if verifie([5]):
+    c += "1"
+else  :
+    c += "0"
+;;;
+premier et dernier
+;;;
+2
+;;;
+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.
+Exemples :
+>>> premier_dernier([4, 15, 34, 22])
+(4, 22)
+>>> premier_dernier(["a", "f", "g", "z"])
+("a", "z")
+>>> premier_dernier([42])
+(42, 42)
+;;;
+c = ""
+if premier_dernier([4, 15, 34, 22]) == (4, 22):
+    c += "1"
+else  :
+    c += "0"
+if premier_dernier(["a", "f", "g", "z"]) == ("a", "z"):
+    c += "1"
+else  :
+    c += "0"
+if premier_dernier([42]) == (42, 42):
+    c += "1"
+else  :
+    c += "0"
+;;;
+delta encoding
+;;;
+3
+;;;
+tableau (liste Python), boucle for, parcours d'un tableau, indice, utilisation de append
+;;;
+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.  
+Exemples :  
+```
+>>> delta([1000, 800, 802, 1000, 1003])
+[1000, -200, 2, 198, 3]
+>>> delta([42])
+[42]
+```
+;;;
+c = ""
+if delta([1000, 800, 802, 1000, 1003]) == [1000, -200, 2, 198, 3]:
+    c += "1"
+else  :
+    c += "0"
+if delta([42]) == [42]:
+    c += "1"
+else  :
+    c += "0"
+;;;
+moyenne pondérée
+;;;
+3
+;;;
+tableau (liste Python), boucle for, parcours d'un tableau, tableau de tableaux, tuple, calculs, indice
+;;;
+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.  
+Exemple :  
+```
+>>> moyenne([(12, 2), (8, 1), (10, 1)])
+10.5
+>>> moyenne([(3, 0), (5, 0)])
+None
+```
+;;;
+c = ""
+if moyenne([(12, 2), (8, 1), (10, 1)]) == 10.5:
+    c += "1"
+else  :
+    c += "0"
+if moyenne([(3, 0), (5, 0)]) == None:
+    c += "1"
+else  :
+    c += "0"
+;;;
+tri sélection
+;;;
+3
+;;;
+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.  
+Exemple :  
+```
+>>> tri_selection([1, 52, 6, -9, 12])
+[-9, 1, 6, 12, 52]
+>>> tri_selection([6])
+[6]
+```
+;;;
+c = ""
+if tri_selection([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
+    c += "1"
+else  :
+    c += "0"
+if tri_selection([6]) == [6]:
+    c += "1"
+else  :
+    c += "0"
+;;;
+min et max
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1])
+{'min': -2, 'max': 9}
+>>> min_et_max([0, 1, 2, 3])
+{'min': 0, 'max': 3}
+>>> min_et_max([3])
+{'min': 3, 'max': 3}
+>>> min_et_max([1, 3, 2, 1, 3])
+{'min': 1, 'max': 3}
+>>> min_et_max([-1, -1, -1, -1, -1])
+{'min': -1, 'max': -1}
+```
+;;;
+c = ""
+if min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1]) == {'min': -2, 'max': 9}:
+    c += "1"
+else  :
+    c += "0"
+if min_et_max([0, 1, 2, 3]) == {'min': 0, 'max': 3}:
+    c += "1"
+else  :
+    c += "0"
+if min_et_max([3]) == {'min': 3, 'max': 3}:
+    c += "1"
+else  :
+    c += "0"
+if min_et_max([1, 3, 2, 1, 3]) == {'min': 1, 'max': 3}:
+    c += "1"
+else  :
+    c += "0"
+if min_et_max([-1, -1, -1, -1, -1]) == {'min': -1, 'max': -1}:
+    c += "1"
+else  :
+    c += "0"
+;;;
+nombre de répétitions
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5])
+3
+>>> nb_repetitions('A', ['B', 'A', 'B', 'A', 'R'])
+2
+>>> nb_repetitions(12, [1, 3, 7, 21, 36, 44])
+0
+```
+;;;
+c = ""
+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 :
+    c += "1"
+else  :
+    c += "0"
+if nb_repetitions(12, [1, 3, 7, 21, 36, 44]) == 0:
+    c += "1"
+else  :
+    c += "0"
+;;;
+recherche motif
+;;;
+3
+;;;
+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:  
+```
+>>> recherche_motif("ab", "")
+[]
+>>> recherche_motif("ab", "cdcdcdcd")
+[]
+>>> recherche_motif("ab", "abracadabra")
+[0, 7]
+>>> recherche_motif("ab", "abracadabraab")
+[0, 7, 11]
+```
+;;;
+c=""
+if recherche_motif("ab", "") == []:
+    c+="1"
+else  :
+    c+="0"
+if recherche_motif("ab", "cdcdcdcd") == []:
+    c+="1"
+else  :
+    c+="0"
+if recherche_motif("ab", "abracadabra") == [0, 7]:
+    c+="1"
+else  :
+    c+="0"
+if recherche_motif("ab", "abracadabraab") == [0, 7, 11]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+recherche indice classement
+;;;
+3
+;;;
+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:  
+• 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.  
+Exemples :  
+```
+>>> recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0])
+([0, 3, 7], [1, 6], [2, 4, 5])
+>>> recherche_indices_classement(3, [1, 4, 2, 4, 6, 0])
+([0, 2, 5], [], [1, 3, 4])
+>>>recherche_indices_classement(3, [1, 1, 1, 1])
+([0, 1, 2, 3], [], [])
+>>> recherche_indices_classement(3, [])
+([], [], [])
+```
+;;;
+c=""
+if recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0]) == ([0, 3, 7], [1, 6], [2, 4, 5]):
+    c+="1"
+else  :
+    c+="0"
+if recherche_indices_classement(3, [1, 4, 2, 4, 6, 0]) == ([0, 2, 5], [], [1, 3, 4]):
+    c+="1"
+else  :
+    c+="0"
+if recherche_indices_classement(3, [1, 1, 1, 1]) == ([0, 1, 2, 3], [], []):
+    c+="1"
+else  :
+    c+="0"
+if recherche_indices_classement(3, []) == ([], [], []):
+    c+="1"
+else  :
+    c+="0"
+;;;
+parcours largeur arbre (T)
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> parcours_largeur(( ( (None, 1, None), 2, (None, 3, None) ),4,( (None, 5, None), 6, (None, 7, None) ) ))
+[4, 2, 6, 1, 3, 5, 7]
+```
+;;;
+c=""
+if parcours_largeur(( ( (None, 1, None), 2, (None, 3, None) ),4,( (None, 5, None), 6, (None, 7, None) ) )) == [4, 2, 6, 1, 3, 5, 7]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+recherche minimum
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> recherche_min([5])
+0
+>>> recherche_min([2, 4, 1])
+2
+>>> recherche_min([5, 3, 2, 2, 4])
+2
+>>> recherche_min([-1, -2, -3, -3])
+2
+```
+;;;
+c=""
+if recherche_min([5]) == 0:
+    c+="1"
+else  :
+    c+="0"
+if recherche_min([2, 4, 1]) == 2:
+    c+="1"
+else  :
+    c+="0"
+if recherche_min([5, 3, 2, 2, 4]) == 2:
+    c+="1"
+else  :
+    c+="0"
+if recherche_min([-1, -2, -3, -3]) == 2:
+    c+="1"
+else  :
+    c+="0"
+;;;
+ajoute dictionnaire
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11})
+{1: 5, 2: 16, 3: 11}
+>>> ajoute_dictionnaires({}, {2: 9, 3: 11})
+{2: 9, 3: 11}
+>>> ajoute_dictionnaires({1: 5, 2: 7}, {})
+{1: 5, 2: 7}
+```
+;;;
+c=""
+if ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11}) == {1: 5, 2: 16, 3: 11}:
+    c+="1"
+else  :
+    c+="0"
+if ajoute_dictionnaires({}, {2: 9, 3: 11}) == {2: 9, 3: 11}:
+    c+="1"
+else  :
+    c+="0"
+if ajoute_dictionnaires({1: 5, 2: 7}, {}) == {1: 5, 2: 7}:
+    c+="1"
+else  :
+    c+="0"
+;;;
+plus grande valeur
+;;;
+1
+;;;
+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.
+Exemples :
+>>> plus_grande(15,3)
+15
+>>> plus_grande(-15,-3)
+-3
+;;;
+c = ""
+if plus_grande(15,3) == 15:
+    c += "1"
+else  :
+    c += "0"
+if plus_grande(-15,-3) == -3:
+    c += "1"
+else  :
+    c += "0"
+;;;
+couples consecutifs
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> couples_consecutifs([1, 4, 3, 5])
+[]
+>>> couples_consecutifs([1, 4, 5, 3])
+[(4, 5)]
+>>> couples_consecutifs([1, 1, 2, 4])
+[(1, 2)]
+>>> couples_consecutifs([7, 1, 2, 5, 3, 4])
+[(1, 2), (3, 4)]
+>>> couples_consecutifs([5, 1, 2, 3, 8, -5, -4, 7])
+[(1, 2), (2, 3), (-5, -4)]
+```
+;;;
+c=""
+if couples_consecutifs([1, 4, 3, 5]) == []:
+    c+="1"
+else  :
+    c+="0"
+if couples_consecutifs([1, 4, 5, 3]) == [(4, 5)]:
+    c+="1"
+else  :
+    c+="0"
+if couples_consecutifs([1, 1, 2, 4]) == [(1, 2)]:
+    c+="1"
+else  :
+    c+="0"
+if couples_consecutifs([7, 1, 2, 5, 3, 4]) == [(1, 2), (3, 4)]:
+    c+="1"
+else  :
+    c+="0"
+if couples_consecutifs([5, 1, 2, 3, 8, -5, -4, 7]) == [(1, 2), (2, 3), (-5, -4)]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+moyenne
+;;;
+1
+;;;
+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.  
+Exemple :  
+```
+>>> moyenne(5, 10, 15)
+10
+```
+;;;
+c=""
+if moyenne(5, 10, 15) == 10:
+    c+="1"
+else  :
+    c+="0"
+;;;
+recheche arbre binaire de recherche
+;;;
+2
+;;;
+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. 
+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):
+        self.valeur = valeur
+        self.enfant_gauche = None
+        self.enfant_droit = None   
+    def insert_gauche(self, valeur):
+        if self.enfant_gauche == None:
+            self.enfant_gauche = ArbreBinaire(valeur)
+        else:
+            new_node = ArbreBinaire(valeur)
+            new_node.enfant_gauche = self.enfant_gauche
+            self.enfant_gauche = new_node
+    def insert_droit(self, valeur):
+        if self.enfant_droit == None:
+            self.enfant_droit = ArbreBinaire(valeur)
+        else:
+            new_node = ArbreBinaire(valeur)
+            new_node.enfant_droit = self.enfant_droit
+            self.enfant_droit = new_node
+    def get_valeur(self):
+        return self.valeur    
+    def get_gauche(self):
+        return self.enfant_gauche
+    def get_droit(self):
+        return self.enfant_droit
+racine_r = ArbreBinaire(15)
+racine_r.insert_gauche(6)
+racine_r.insert_droit(18)
+
+r_6 = racine_r.get_gauche()
+r_6.insert_gauche(3)
+r_6.insert_droit(7)
+
+r_18 = racine_r.get_droit()
+r_18.insert_gauche(17)
+r_18.insert_droit(20)
+
+r_3 = r_6.get_gauche()
+r_3.insert_gauche(2)
+r_3.insert_droit(4)
+
+r_7 = r_6.get_droit()
+r_7.insert_droit(13)
+
+r_13 = r_7.get_droit()
+r_13.insert_gauche(9)
+c = ""
+if recherche_abr(racine_r,4):
+    c += "1"
+else  :
+    c += "0"
+if not recherche_abr(racine_r,42):
+    c += "1"
+else  :
+    c += "0"
+;;;
+suite fibonacci récursive (T)
+;;;
+3
+;;;
+fonction récursive
+;;;
+On s’intéresse à la suite d’entiers définie par :  
+• la première valeur est égale à 0 ;  
+• la deuxième valeur est égale à 1 ;  
+• 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.  
+Exemples :  
+```
+>>> fibonacci(0)
+0
+>>> fibonacci(1)
+1
+>>> fibonacci(2)
+1
+>>> fibonacci(10)
+55
+>>> fibonacci(13)
+233
+```
+;;;
+c=""
+if fibonacci(0) == 0:
+    c+="1"
+else  :
+    c+="0"
+if fibonacci(1) == 1:
+    c+="1"
+else  :
+    c+="0"
+if fibonacci(10) == 55:
+    c+="1"
+else  :
+    c+="0"
+if fibonacci(13) == 233:
+    c+="1"
+else  :
+    c+="0"
+;;;
+fusion tableaux
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> fusion([3, 5], [2, 5])
+[2, 3, 5, 5]
+>>> fusion([-2, 4], [-3, 5, 10])
+[-3, -2, 4, 5, 10]
+>>> fusion([4], [2, 6])
+[2, 4, 6]
+>>> fusion([], [])
+[]
+>>> fusion([1, 2, 3], [])
+[1, 2, 3]
+```
+;;;
+c=""
+if fusion([3, 5], [2, 5]) == [2, 3, 5, 5]:
+    c+="1"
+else  :
+    c+="0"
+if fusion([-2, 4], [-3, 5, 10]) == [-3, -2, 4, 5, 10]:
+    c+="1"
+else  :
+    c+="0"
+if fusion([4], [2, 6]) == [2, 4, 6]:
+    c+="1"
+else  :
+    c+="0"
+if fusion([], []) == []:
+    c+="1"
+else  :
+    c+="0"
+if fusion([1, 2, 3], []) == [1, 2, 3]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+multiplication
+;;;
+4
+;;;
+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.  
+Les seules opérations arithmétiques autorisées sont l’addition et la soustraction.  
+Exemples :  
+```
+>>> multiplication(3, 5)
+15
+>>> multiplication(-4, -8)
+32
+>>> multiplication(-2, 6)
+-12
+>>> multiplication(-2, 0)
+0
+```
+;;;
+c=""
+if multiplication(3, 5) == 15:
+    c+="1"
+else  :
+    c+="0"
+if multiplication(-4, -8) == 32:
+    c+="1"
+else  :
+    c+="0"
+if multiplication(-2, 6) == -12:
+    c+="1"
+else  :
+    c+="0"
+if multiplication(-2, 0) == 0:
+    c+="1"
+else  :
+    c+="0"
+;;;
+renverse chaine
+;;;
+3
+;;;
+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.  
+Exemple :  
+```
+>>> renverse("")
+""
+>>> renverse("abc")
+"cba"
+>>> renverse("informatique")
+"euqitamrofni"
+```
+;;;
+c=""
+if renverse("") == "":
+    c+="1"
+else  :
+    c+="0"
+if renverse("abc") == "cba":
+    c+="1"
+else  :
+    c+="0"
+if renverse("informatique") == "euqitamrofni":
+    c+="1"
+else  :
+    c+="0"
+;;;
+nombre d’occurrences d’un caractère
+;;;
+3
+;;;
+chaine de caractères, parcours d'une chaine, dictionnaire
+;;;
+Le nombre d’occurrences d’un caractère dans une chaîne de caractères est le nombre d’apparitions de ce caractère dans la chaîne.  
+Exemples :  
+• le nombre d’occurrences du caractère 'o' dans 'bonjour' est 2 ;  
+• le nombre d’occurrences du caractère 'b' dans 'Bébé' est 1 ;  
+• le nombre d’occurrences du caractère 'B' dans 'Bébé' est 1 ;  
+• le nombre d’occurrences du caractère ' ' dans 'Hello world !' est 2.  
+On cherche les occurrences des caractères dans une phrase. On souhaite stocker ces occurrences dans un dictionnaire dont les clefs seraient les caractères de la phrase et les valeurs le nombre d’occurrences de ces caractères.  
+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.  
+;;;
+c=""
+if nbr_occurrences('Hello world !') == {'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}:
+    c+="1"
+else  :
+    c+="0"
+;;;
+temperature minimale
+;;;
+3
+;;;
+tableau (list Python), parcours tableau par indice, recherche d'un minimum
+;;;
+On a relevé les valeurs moyennes annuelles des températures à Paris pour la période allant de 2013 à 2019. Les résultats ont été récupérés sous la forme de deux tableaux (de type list) : l’un pour les températures, l’autre pour les années :
+
+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.
+On suppose que la température minimale est atteinte une seule fois.
+Exemple :
+>>> annee_temperature_minimale(t_moy, annees)
+(12.5, 2016)
+;;;
+c=""
+if annee_temperature_minimale([14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7], [2013, 2014, 2015, 2016, 2017, 2018, 2019]) == (12.5, 2016):
+    c+="1"
+else  :
+    c+="0"
+;;;
+occurrences
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> occurrences('e', "sciences")
+2
+>>> occurrences('i',"mississippi")
+4
+>>> occurrences('a',"mississippi")
+0
+```
+;;;
+c=""
+if occurrences('e', "sciences") == 2:
+    c+="1"
+else  :
+    c+="0"
+if occurrences('i',"mississippi") == 4:
+    c+="1"
+else  :
+    c+="0"
+if occurrences('a',"mississippi") == 0:
+    c+="1"
+else  :
+    c+="0"
+;;;
+aire cercle
+;;;
+1
+;;;
+calcul
+;;;
+É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)
+28.274
+```
+;;;
+c=""
+import math
+if round(aire_cercle(3)) == 28:
+    c+="1"
+else  :
+    c+="0"
+;;;
+indices maxi
+;;;
+2
+;;;
+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.  
+Exemple :  
+```
+>>> indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
+(9, [3, 8])
+>>> indices_maxi([7])
+(7, [0])
+```
+;;;
+c=""
+if indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9, [3, 8]):
+    c+="1"
+else  :
+    c+="0"
+if indices_maxi([7]) == (7, [0]):
+    c+="1"
+else  :
+    c+="0"
+;;;
+addition
+;;;
+1
+;;;
+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.  
+Exemple :  
+```
+>>> add(3, 5)
+8
+```
+;;;
+c=""
+if add(3,5) == 8:
+    c+="1"
+else  :
+    c+="0"
+;;;
+sélection enclos
+;;;
+3
+;;;
+tableau(list Python), dictionnaire, parcours d'un tableau, recherche d'une clé dans un dico
+;;;
+On considère des tables, c’est-à-dire des tableaux de dictionnaires ayant tous les mêmes clés, qui contiennent des enregistrements relatifs à des animaux hébergés dans un refuge. Les attributs des enregistrements sont 'nom', 'espece', 'age', 'enclos'.  
+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 :  
+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.  
+Exemples avec la table animaux ci-dessus :  
+```
+>>> selection_enclos(animaux, 5)
+[{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
+{'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]
+>>> selection_enclos(animaux, 2)
+[{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]
+>>> selection_enclos(animaux, 7)
+[]
+```
+;;;
+c=""
+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}]
+if selection_enclos(animaux, 5)== [{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5}, {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]:
+    c+="1"
+else  :
+    c+="0"
+if selection_enclos(animaux, 2) == [{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]:
+    c+="1"
+else  :
+    c+="0"
+if  selection_enclos(animaux, 7) == []:
+    c+="1"
+else  :
+    c+="0"
+;;;
+pair
+;;;
+1
+;;;
+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.  
+Exemples :  
+```
+>>> pair(8)
+True
+>>> pair(5)
+False
+```
+;;;
+c=""
+if pair(8):
+    c+="1"
+else  :
+    c+="0"
+if not pair(5):
+    c+="1"
+else  :
+    c+="0"
+;;;
+doublon
+;;;
+2
+;;;
+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.  
+Exemple :  
+```
+>>> a_doublon([])
+False
+>>> a_doublon([1])
+False
+>>> a_doublon([1, 2, 4, 6, 6])
+True
+>>> a_doublon([2, 5, 7, 7, 7, 9])
+True
+>>> a_doublon([0, 2, 3])
+False
+```
+;;;
+c=""
+if not a_doublon([]):
+    c+="1"
+else  :
+    c+="0"
+if not a_doublon([1]):
+    c+="1"
+else  :
+    c+="0"
+if a_doublon([1, 2, 4, 6, 6]):
+    c+="1"
+else  :
+    c+="0"
+if a_doublon([2, 5, 7, 7, 7, 9]):
+    c+="1"
+else  :
+    c+="0"
+if not a_doublon([0, 2, 3]):
+    c+="1"
+else  :
+    c+="0"
+;;;
+somme
+;;;
+2
+;;;
+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.  
+Exemples :  
+```
+>>> somme([5, 4, 7])
+16
+>>> somme([])
+0
+```
+;;;
+c=""
+if somme([5, 4, 7]) == 16:
+    c+="1"
+else  :
+    c+="0"
+if somme([]) == 0:
+    c+="1"
+else  :
+    c+="0"
+;;;
+énumère
+;;;
+3
+;;;
+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.  
+Exemple :  
+```
+>>> enumere([])
+{}
+>>> enumere([1, 2, 3])
+{1: [0], 2: [1], 3: [2]}
+>>> enumere([1, 1, 2, 3, 2, 1])
+{1: [0, 1, 5], 2: [2, 4], 3: [3]}
+```
+;;;
+c=""
+if enumere([])== {}:
+    c+="1"
+else  :
+    c+="0"
+if enumere([1, 2, 3]) == {1: [0], 2: [1], 3: [2]}:
+    c+="1"
+else  :
+    c+="0"
+if  enumere([1, 1, 2, 3, 2, 1]) == {1: [0, 1, 5], 2: [2, 4], 3: [3]}:
+    c+="1"
+else  :
+    c+="0"
+;;;
+max dico
+;;;
+3
+;;;
+dictionnaire, parcours d'un dictionnaire, tuple, clé
+;;;
+Sur le réseau social TipTop, on s’intéresse au nombre de « like » des abonnés. Les données sont stockées dans des dictionnaires où les clés sont les pseudos et les valeurs correspondantes sont les nombres de « like » comme ci-dessous :  
+```
+{ '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 ;  
+• 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.  
+Exemples :  
+```
+>>> max_dico({ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 })
+('Ada', 201)
+>>> max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 })
+('Alan', 222) # ou ('Eve', 222) également possible
+```
+;;;
+c=""
+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) :
+    c+="1"
+else  :
+    c+="0"
+;;;
+correspond
+;;;
+3
+;;;
+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 :  
+• 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.  
+Exemple :  
+```
+>>> correspond('INFORMATIQUE', 'INFO*MA*IQUE')
+True
+>>> correspond('AUTOMATIQUE', 'INFO*MA*IQUE')
+False
+>>> correspond('STOP', 'S*')
+False
+>>> correspond('AUTO', '*UT*')
+True
+```
+;;;
+c=""
+if correspond('INFORMATIQUE', 'INFO*MA*IQUE') :
+    c+="1"
+else  :
+    c+="0"
+if not correspond('AUTOMATIQUE', 'INFO*MA*IQUE') :
+    c+="1"
+else  :
+    c+="0"
+if not correspond('STOP', 'S*') :
+    c+="1"
+else  :
+    c+="0"
+if correspond('AUTO', '*UT*') :
+    c+="1"
+else  :
+    c+="0"
+;;;
+tri insertion
+;;;
+3
+;;;
+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.  
+Exemple :  
+```
+>>> tri_insertion([1, 52, 6, -9, 12])
+[-9, 1, 6, 12, 52]
+>>> tri_insertion([6])
+[6]
+```
+;;;
+c=""
+if tri_insertion([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
+    c+="1"
+else  :
+    c+="0"
+if tri_insertion([6]) == [6]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+insére
+;;;
+3
+;;;
+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.  
+Écrire cette fonction insere  
+Exemples :  
+```
+>>> insere([1, 2, 4, 5], 3)
+[1, 2, 3, 4, 5]
+>>> insere([1, 2, 7, 12, 14, 25], 30)
+[1, 2, 7, 12, 14, 25, 30]
+>>> insere([2, 3, 4], 1)
+[1, 2, 3, 4]
+>>> insere([], 1)
+[1]
+```
+;;;
+c=""
+if insere([1, 2, 4, 5], 3) ==  [1, 2, 3, 4, 5]:
+    c+="1"
+else  :
+    c+="0"
+if insere([1, 2, 7, 12, 14, 25], 30) ==  [1, 2, 7, 12, 14, 25, 30]:
+    c+="1"
+else  :
+    c+="0"
+if insere([2, 3, 4], 1) ==  [1, 2, 3, 4]:
+    c+="1"
+else  :
+    c+="0"
+if insere([], 1) == [1] :
+    c+="1"
+else  :
+    c+="0"
+;;;
+décimal vers binaire
+;;;
+3
+;;;
+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  
+Exemples :  
+```
+>>> binaire(83)
+'1010011'
+>>> binaire(6)
+'110'
+>>> binaire(127)
+'1111111'
+>>> binaire(0)
+'0'
+```
+;;;
+c=""
+if binaire(83) ==  '1010011':
+    c+="1"
+else  :
+    c+="0"
+if binaire(6) ==  '110':
+    c+="1"
+else  :
+    c+="0"
+if binaire(127) ==  '1111111':
+    c+="1"
+else  :
+    c+="0"
+if binaire(0) == '0' :
+    c+="1"
+else  :
+    c+="0"
+;;;
+recherche dichotomique récursive
+;;;
+3
+;;;
+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  
+L’algorithme demandé est une recherche dichotomique récursive.  
+Écrire le code de la fonction chercher.  
+```
+Exemples :
+>>> chercher([1, 5, 6, 9, 12], 7)
+>>> chercher([1, 5, 6, 9, 12], 9)
+4
+>>> chercher([1, 5, 6, 9, 12], 6)
+2
+```
+;;;
+c=""
+if chercher([1, 5, 6, 9, 12], 7) == None:
+    c+="1"
+else  :
+    c+="0"
+if chercher([1, 5, 6, 9, 12], 9) ==  4:
+    c+="1"
+else  :
+    c+="0"
+if chercher([1, 5, 6, 9, 12], 6) ==  2:
+    c+="1"
+else  :
+    c+="0"
+;;;
+moyenne dico
+;;;
+3
+;;;
+dictionnaire, parcours d'un dictionnaire, calcul d'une moyenne
+;;;
+Une professeure de NSI décide de gérer les résultats de sa classe sous la forme d’un dictionnaire :  
+• les clefs sont les noms des élèves ;  
+• les valeurs sont des dictionnaires dont les clés sont les types d’épreuves sous forme de chaîne de caractères et les valeurs sont les notes obtenues associées à leurs coefficients dans une liste.  
+Avec :  
+```
+resultats = {
+    Dupont': {
+        'DS1': [15.5, 4],
+        'DM1': [14.5, 1],
+        'DS2': [13, 4],
+        'PROJET1': [16, 3],
+        'DS3': [14, 4]
+    },
+    'Durand': {
+        'DS1': [6 , 4],
+        'DS2': [8, 4],
+        'PROJET1': [9, 3],
+        'IE1': [7, 2],
+        'DS3': [12, 4]
+    }
+}
+```
+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.  
+Exemples :  
+```
+>>> moyenne("Dupont", resultats)
+14.5
+>>> moyenne("Durand", resultats)
+8.5
+```
+;;;
+c=""
+resultats = {'Dupont': {'DS1': [15.5, 4],'DM1': [14.5, 1],'DS2': [13, 4],'PROJET1': [16, 3],'DS3': [14, 4]},'Durand': {'DS1': [6 , 4],'DS2': [8, 4],'PROJET1': [9, 3],'IE1': [7, 2],'DS3': [12, 4]}}
+if  round(moyenne("Dupont", resultats)) == 15:
+    c+="1"
+else  :
+    c+="0"
+if  round(moyenne("Durand", resultats)) ==  9:
+    c+="1"
+else  :
+    c+="0"
+;;;
+ nombre de boites
+;;;
+4
+;;;
+algo glouton, tableau
+;;;
+On dispose d’un ensemble d’objets dont on connaît, pour chacun, la masse. On souhaite ranger l’ensemble de ces objets dans des boites identiques de telle manière que la somme des masses des objets contenus dans une boîte ne dépasse pas la capacité c de la boîte. On souhaite utiliser le moins de boîtes possibles pour ranger cet ensemble d’objets.  
+Pour résoudre ce problème, on utilisera un algorithme glouton consistant à placer chacun des objets dans la première boîte où cela est possible.  
+Par exemple, pour ranger dans des boîtes de capacité c = 5 un ensemble de trois objets dont les masses sont représentées en Python par la liste [1, 5, 2], on procède de la façon suivante :  
+• Le premier objet, de masse 1, va dans une première boite.  
+• 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.  
+Exemples :  
+```
+>>> empaqueter([1, 2, 3, 4, 5], 10)
+2
+>>> empaqueter([1, 2, 3, 4, 5], 5)
+4
+>>> empaqueter([7, 6, 3, 4, 8, 5, 9, 2], 11)
+5
+```
+;;;
+c=""
+if empaqueter([1, 2, 3, 4, 5], 10) == 2:
+    c+="1"
+else  :
+    c+="0"
+if empaqueter([1, 2, 3, 4, 5], 5) == 4:
+    c+="1"
+else  :
+    c+="0"
+if empaqueter([7, 6, 3, 4, 8, 5, 9, 2], 11) ==  5:
+    c+="1"
+else  :
+    c+="0"
+;;;
+plus grande somme
+;;;
+4
+;;;
+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.  
+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.  
+Exemples :  
+```
+>>> somme_max([1, 2, 3, 4, 5])
+15
+>>> somme_max([1, 2, -3, 4, 5])
+9
+>>> somme_max([1, 2, -2, 4, 5])
+10
+>>> somme_max([1, -2, 3, 10, -4, 7, 2, -5])
+18
+>>> somme_max([-3,-2,-1,-4])
+-1
+```
+;;;
+c=""
+if somme_max([1, 2, 3, 4, 5]) ==  15:
+    c+="1"
+else  :
+    c+="0"
+if somme_max([1, 2, -3, 4, 5]) ==  9:
+    c+="1"
+else  :
+    c+="0"
+if somme_max([1, 2, -2, 4, 5]) ==  10:
+    c+="1"
+else  :
+    c+="0"
+if somme_max([1, -2, 3, 10, -4, 7, 2, -5]) == 18 :
+    c+="1"
+else  :
+    c+="0"
+if omme_max([-3,-2,-1,-4]) == -1 :
+    c+="1"
+else  :
+    c+="0"
+;;;
+sépare 0 et 1
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> separe([1, 0, 1, 0, 1, 0, 1, 0])
+[0, 0, 0, 0, 1, 1, 1, 1]
+>>> separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])
+[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+```
+;;;
+c=""
+if separe([1, 0, 1, 0, 1, 0, 1, 0])) ==  [0, 0, 0, 0, 1, 1, 1, 1]:
+    c+="1"
+else  :
+    c+="0"
+if separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0]) ==  [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]:
+    c+="1"
+else  :
+    c+="0"
+;;;
+élève du mois
+;;;
+3
+;;;
+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].  
+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.  
+Exemples :  
+```
+>>> eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
+>>> notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
+>>> eleves_du_mois(eleves_nsi, notes_nsi)
+(80, ['c', 'f', 'h'])
+>>> eleves_du_mois([],[])
+(0, [])
+```
+;;;
+c=""
+eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
+notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
+if eleves_du_mois(eleves_nsi, notes_nsi) ==  (80, ['c', 'f', 'h']):
+    c+="1"
+else  :
+    c+="0"
+if eleves_du_mois([],[]) ==  (0, []):
+    c+="1"
+else  :
+    c+="0"
+
+;;;
+recherche dichotomique
+;;;
+2
+;;;
+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.  
+Attention : vous devez utiliser l'algorithme de la recherche dichotomique  
+Exemples :  
+```
+>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28)
+True
+>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27)
+False
+```
+;;;
+c=""
+if dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28):
+    c+="1"
+else  :
+    c+="0"
+if not dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27):
+    c+="1"
+else  :
+    c+="0"
+;;;
+palindrome
+;;;
+3
+;;;
+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.  
+Exemples :  
+```
+>>> est_palindrome('kayak')
+True
+>>> est_palindrome('NSI')
+False
+```
+;;;
+c=""
+if est_palindrome('kayak'):
+    c+="1"
+else  :
+    c+="0"
+if not est_palindrome('NSI'):
+    c+="1"
+else  :
+    c+="0"
+;;;

database.py

@@ -0,0 +1,54 @@
+import sqlite3
+
+def create_table():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM code;")
+    with open('code.txt', 'r') as f:
+        c = 0
+        txt = ""
+        id = 1
+        for l in f :
+            txt += l
+            if l == ";;;\n":
+                c += 1
+            if c == 5 :
+                tab = txt.split(";;;\n")
+                txt = ""
+                c = 0
+                cursor.execute("INSERT INTO code (id, titre, niveau, mots_cle, enonce, test) VALUES (?, ?, ?, ?, ?, ?)", (id, tab[0], tab[1], tab[2], tab[3], tab[4]))
+                id += 1
+        conn.commit()
+        conn.close()
+
+def return_title():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, titre, niveau FROM code")
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"id" : v[0], "title" : v[1].replace("\n",""), "niveau":v[2]} for v in rows]
+
+def return_exercise(id):
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM code WHERE id = ?", (id,))
+    rows = cursor.fetchall()
+    conn.close()
+    return rows[0]
+
+def return_mot_cle():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, mots_cle FROM code")
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"id" : v[0], "mot_cle" : v[1].replace("\n","")} for v in rows]
+
+def return_niveau():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, niveau FROM code")
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"id" : v[0], "niveau" : v[1]} for v in rows]

main.py

@@ -0,0 +1,159 @@
+import os
+from dotenv import load_dotenv
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langgraph.checkpoint.memory import MemorySaver
+from typing import List
+from typing_extensions import TypedDict
+from typing import Annotated
+from langgraph.graph.message import AnyMessage, add_messages
+from langchain_core.messages import HumanMessage, AIMessage
+from langgraph.graph import END, StateGraph, START
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from database import create_table, return_title, return_exercise, return_mot_cle, return_niveau
+import logging
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+create_table()
+
+GOOGLE_API_KEY = 'AIzaSyDN9544WCs85ekrRK0ZeIdS6j7VPsGSrlo'
+
+llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0.7, api_key = GOOGLE_API_KEY)
+
+
+prompt_aide = PromptTemplate.from_template(
+"""
+Tu es un expert en pédagogie de l'apprentissage de la programmation
+Le langage utilisé pour l'apprentissage de la programmation est Python.
+Tu dois aider un élève à résoudre un exercice de programmation Python.
+Tu ne dois jamais donner la solution de l'exercice (même partiellement) à l'élève, juste lui donner des inddications lui permettant de résoudre lui même l'exercice
+Tu dois t'adresser directement à l'élève.
+L'élève ne peut pas te poser des questions, il peut juste te proposer son code.
+Tu ne dois pas proposer à l'élève de te poser des questions
+Il est inutile de proposer à l'élève de tester son code avec les exemples proposés.
+Tu ne dois pas proposer aux élèves des modifications du programme qui sorte du cadre de l'exercice. Par exemple, pour l'exercice qui demande d'écrire une fonction moyenne, si dans l'énoncé il est précisé que l'on a un tableau non vide d'entier en paramètre, il est inutile de dire à l'élève que son programme doit gérer les tableaux vides.
+Tu dois t'exprimer en français
+Voici l'énoncé de l'exercice :
+{enonce}
+Voici le programme proposé par l'élève pour résoudre l'exercice :
+{code}
+Pour améliorer ta réponse, tu as aussi à ta disposition l'historique des différents programme proposés par l'élève et les différents conseils que tu lui a déjà donné :
+{historique} 
+""")
+
+prompt_bilan = PromptTemplate.from_template(
+"""
+Tu es un expert en pédagogie de l'apprentissage de la programmation
+Le langage utilisé pour l'apprentissage de la programmation est Python.
+Ton rôle est de proposer un bilan sur la résolution d'un exercice réaliser par un élève.
+Tu dois t'adresser directement à l'élève.
+Cet élève vient de réussir l'exercice suivant :
+{enonce}
+Voici l'historique de la résolution de cet exercice (code de l'élève et conseil donnés par un expert)
+{historique}
+Tu dois faire un bilan sur les points forts de l'élève et les points à travailler
+Tu dois proposer à l'élève un autre  exercice à résoudre parmi les exercices ci-dessous (pour chaque exercice tu as le titre de l'exercice, une liste de mots clé et un niveau allant de 1 à 4 (le niveau 1 étant le plus facile et le niveau 4 le plus difficile)) :
+Tu ne dois UNIQUEMENT proposer un exercice appartenant à la liste ci-dessous.
+Tu dois donner uniquement le titre et le numéro de l'exercice que tu proposes à l'élèves (inutile d'indiquer les mots clé liés à l'exercice)
+### LISTE DES EXERCICES
+{mot_cle}
+""")
+
+
+descr_exo = ""
+lst_titre = return_title()
+lst_niveau = return_niveau()
+lst_mot_cle = return_mot_cle()
+for i in range(len(lst_niveau)):
+    descr_exo += f"Exercie n° {lst_mot_cle[i]['id']} => titre : {lst_titre[i]['title']} ; mots clé : {lst_mot_cle[i]['mot_cle']} ; niveau : {lst_niveau[i]['niveau']}\n"
+
+def history(hist):
+    historical = ""
+    for i in range(len(hist)):
+        if i%2 == 0:
+            historical += "code de l'éléve : \n"+hist[i].content+"\n"
+        else :
+            historical += "aide de l'expert : \n"+hist[i].content+"\n"
+    return historical
+
+memory = MemorySaver()
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class Request(BaseModel):
+    id : str
+    enonce : str
+    code : str
+    res_test : str
+
+class AgentState(TypedDict):
+    enonce : str
+    messages: Annotated[list[AnyMessage], add_messages]
+    res_test : str
+
+def routeur(state : AgentState):
+    if state['res_test'] == "1" or state['res_test'] == "0":
+        return "aide"
+    else :
+        return "bilan"
+
+def aide(state : AgentState):
+    llm_aide = prompt_aide | llm | StrOutputParser()
+    response = llm_aide.invoke({'enonce': state['enonce'], 'code' : state['messages'][-1].content, 'historique' : history(state['messages'])})
+    return {"messages": [AIMessage(content=response)]}
+
+def bilan(state : AgentState):
+    llm_bilan = prompt_bilan | llm | StrOutputParser()
+    response = llm_bilan.invoke({'enonce': state['enonce'], 'historique' : history(state['messages']), 'mot_cle': descr_exo})
+    return {"messages": [AIMessage(content=response)]}
+
+workflow = StateGraph(AgentState)
+
+workflow.add_node("aide", aide)
+workflow.add_node("bilan", bilan)
+
+workflow.add_conditional_edges(
+    START,
+    routeur,
+    {
+        "aide": "aide",
+        "bilan": "bilan"
+    })
+workflow.add_edge( "aide",END)
+workflow.add_edge( "bilan",END)
+graph = workflow.compile(checkpointer=memory)
+
+@app.post('/request')
+def request(req: Request):
+    config = {"configurable": {"thread_id": req.id}}
+    rep = graph.invoke({"enonce" : req.enonce,"messages": req.code, "res_test" : req.res_test},config , stream_mode="values")
+    return {"response":rep['messages'][-1].content}
+
+
+@app.get('/title')
+def get_title():
+    tab_title = return_title()
+    return {"title":tab_title}
+
+@app.get('/exercise/{id}')
+def get_exercise(id : int):
+    ex = return_exercise(id)
+    return {"title" : ex[1].replace("\n",""), "enonce" : ex[4], "test": ex[5]}
+
+
+
+
+
+
+
+
+