Upload 4 files

code.txt

@@ -0,0 +1,724 @@
+moyenne
+;;;
+É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 = 0
+if moyenne([10, 15, 20]) == 15:
+    print("Test n°1 : OK")
+    c += 1
+else :
+    print("Test n°1 : échec")
+if moyenne([8, 11, 17, 10]) == 11.5:
+    print("Test n°2 : OK")
+    c += 1
+else :
+    print("Test n°2 : échec")
+if c == 2 :
+    print('OK')
+else :
+    print('KO')
+;;;
+maximum_tableau
+;;;
+É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 = 0
+if maximum_tableau([98, 12, 104, 23, 131, 9]) == 131:
+    print("Test n°1 : OK")
+    c += 1
+else :
+    print("Test n°1 : échec")
+if maximum_tableau([-27, 24, -3, 15]) == 24:
+    print("Test n°2 : OK")
+    c += 1
+else :
+    print("Test n°2 : échec")
+if maximum_tableau([-27, -24, -3, -15]) == -3:
+    print("Test n°3 : OK")
+    c += 1
+else :
+    print("Test n°3 : échec")
+if c == 3 :
+    print('OK')
+else :
+    print('KO')
+;;;
+recherche
+;;;
+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 = 0
+if recherche([5, 3],1) == None:
+    print("Test n°1 : OK")
+    c += 1
+else :
+    print("Test n°1 : échec")
+if recherche([2,4],2) == 0:
+    print("Test n°2 : OK")
+    c += 1
+else :
+    print("Test n°2 : échec")
+if recherche([2,3,5,2,4],2) == 0:
+    print("Test n°3 : OK")
+    c += 1
+else :
+    print("Test n°3 : échec")
+if c == 3 :
+    print('OK')
+else :
+    print('KO')
+;;;
+max_et_indice
+;;;
+É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 = 0
+if max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9,3):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if max_et_indice([-2]) == (-2, 0):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if max_et_indice([-1, -1, 3, 3, 3]) == (3, 2):
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if max_et_indice([1, 1, 1, 1]) == (1, 0):
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+verifie
+;;;
+É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 = 0
+if verifie([0, 5, 8, 8, 9]):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if not verifie([8, 12, 4]):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if verifie([-1, 4]):
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if verifie([]):
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if verifie([5]):
+    print("Test 5 : OK")
+    c += 1
+else  :
+    print("Test 5 : échec")
+if c == 5 :
+    print("OK")
+else :
+    print("KO")
+;;;
+delta encoding
+;;;
+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 = 0
+if delta([1000, 800, 802, 1000, 1003]) == [1000, -200, 2, 198, 3]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if delta([42]) == [42]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+moyenne pondérée
+;;;
+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 = 0
+if moyenne([(12, 2), (8, 1), (10, 1)]) == 10.5:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if moyenne([(3, 0), (5, 0)]) == None:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+tri sélection
+;;;
+Écrire une fonction tri_selection qui prend en paramètre un tableau tab de nombres entiers (type list) et qui le modifie afin qu’il soit trié par ordre croissant.
+Exemple :
+>>> tri_selection([1, 52, 6, -9, 12])
+[-9, 1, 6, 12, 52]
+>>> tri_selection([6])
+[6]
+;;;
+c = 0
+if tri_selection([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if tri_selection([6]) == [6]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+min et max
+;;;
+É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 = 0
+if min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1]) == {'min': -2, 'max': 9}:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if min_et_max([0, 1, 2, 3]) == {'min': 0, 'max': 3}:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if min_et_max([3]) == {'min': 3, 'max': 3}:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if min_et_max([1, 3, 2, 1, 3]) == {'min': 1, 'max': 3}:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if min_et_max([-1, -1, -1, -1, -1]) == {'min': -1, 'max': -1}:
+    print("Test 5 : OK")
+    c += 1
+else  :
+    print("Test 5 : échec")
+if c == 5 :
+    print("OK")
+else :
+    print("KO")
+;;;
+nombre de répétitions
+;;;
+É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 = 0
+if  nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5]) == 3:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if nb_repetitions('A', ['B', 'A', 'B', 'A', 'R']) == 2 :
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if nb_repetitions(12, [1, 3, 7, 21, 36, 44]) == 0:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if c == 3 :
+    print("OK")
+else :
+    print("KO")
+;;;
+recherche 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 = 0
+if recherche_motif("ab", "") == []:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if recherche_motif("ab", "cdcdcdcd") == []:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if recherche_motif("ab", "abracadabra") == [0, 7]:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if recherche_motif("ab", "abracadabraab") == [0, 7, 11]:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+recherche indice classement
+;;;
+É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 tableautabstrictement 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 = 0
+if recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0]) == ([0, 3, 7], [1, 6], [2, 4, 5]):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if recherche_indices_classement(3, [1, 4, 2, 4, 6, 0]) == ([0, 2, 5], [], [1, 3, 4]):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if recherche_indices_classement(3, [1, 1, 1, 1]) == ([0, 1, 2, 3], [], []):
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if recherche_indices_classement(3, []) == ([], [], []):
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+parcours largeur arbre (T)
+;;;
+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 = 0
+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]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if c == 1 :
+    print("OK")
+else :
+    print("KO")
+;;;
+recherche 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 = 0
+if recherche_min([5]) == 0:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if recherche_min([2, 4, 1]) == 2:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if recherche_min([5, 3, 2, 2, 4]) == 2:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if recherche_min([-1, -2, -3, -3]) == 2:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+ajoute 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 = 0
+if ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11}) == {1: 5, 2: 16, 3: 11}:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if ajoute_dictionnaires({}, {2: 9, 3: 11}) == {2: 9, 3: 11}:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if ajoute_dictionnaires({1: 5, 2: 7}, {}) == {1: 5, 2: 7}:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if c == 3 :
+    print("OK")
+else :
+    print("KO")
+;;;
+couples consecutifs
+;;;
+É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 = 0
+if couples_consecutifs([1, 4, 3, 5]) == []:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if couples_consecutifs([1, 4, 5, 3]) == [(4, 5)]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if couples_consecutifs([1, 1, 2, 4]) == [(1, 2)]:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if couples_consecutifs([7, 1, 2, 5, 3, 4]) == [(1, 2), (3, 4)]:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if couples_consecutifs([5, 1, 2, 3, 8, -5, -4, 7]) == [(1, 2), (2, 3), (-5, -4)]:
+    print("Test 5 : OK")
+    c += 1
+else  :
+    print("Test 5 : échec")
+if c == 5 :
+    print("OK")
+else :
+    print("KO")
+;;;
+suite fibonacci
+;;;
+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 = 0
+if fibonacci(0) == 0:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if fibonacci(1) == 1:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if fibonacci(10) == 55:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if fibonacci(13) == 233:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+fusion tableaux
+;;;
+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 = 0
+if fusion([3, 5], [2, 5]) == [2, 3, 5, 5]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if fusion([-2, 4], [-3, 5, 10]) == [-3, -2, 4, 5, 10]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if fusion([4], [2, 6]) == [2, 4, 6]:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if fusion([], []) == []:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if fusion([1, 2, 3], []) == [1, 2, 3]:
+    print("Test 5 : OK")
+    c += 1
+else  :
+    print("Test 5 : échec")
+if c == 5 :
+    print("OK")
+else :
+    print("KO")
+;;;
+multiplication
+;;;
+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 = 0
+if multiplication(3, 5) == 15:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if multiplication(-4, -8) == 32:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if multiplication(-2, 6) == -12:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if multiplication(-2, 0) == 0:
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+renverse chaine
+;;;
+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 = 0
+if renverse("") == "":
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if renverse("abc") == "cba":
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if renverse("informatique") == "euqitamrofni":
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if c == 3 :
+    print("OK")
+else :
+    print("KO")
+;;;
+
+
+
+

database.py

@@ -0,0 +1,42 @@
+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 == 3 :
+                tab = txt.split(";;;\n")
+                txt = ""
+                c = 0
+                cursor.execute("INSERT INTO code (id, titre, enonce, test)VALUES (?, ?, ?, ?)", (id, tab[0], tab[1], tab[2]))
+                id += 1
+        conn.commit()
+        conn.close()
+
+def return_title():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, titre FROM code")
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"id" : v[0], "title" : v[1].replace("\n","")} 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()
+    return rows[0]
+
+
+create_table()

main.py

@@ -0,0 +1,92 @@
+import os
+from dotenv import load_dotenv
+from langchain_core.output_parsers import StrOutputParser
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+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
+
+create_table()
+
+class Request(BaseModel):
+    enonce : str
+    code : str
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv('GROQ_API_KEY')
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+llm = ChatGroq(model="llama-3.1-70b-versatile", temperature=0.5)
+#llm = ChatGroq(model="mixtral-8x7b-32768", temperature=0.5)
+exercise = ""
+system = """
+Tu es un expert Python.
+Tu dois aider un élève à résoudre un exercice de programmation Python.
+Tu ne dois jamais donner la correction 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
+"""
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", system),
+        ("human", "Voici l'exercice proposé à l'élève: \n {enonce} \n\n Voici le programme proposé par l'élève : {code}"),
+    ]
+)
+
+chain = prompt | llm | StrOutputParser()
+
+class GraphState(TypedDict):
+    enonce : str
+    messages: Annotated[list[AnyMessage], add_messages]
+    
+
+def chatbot(state : GraphState):
+    response = chain.invoke({'enonce': state['enonce'].content, 'code' : state['messages'][-1].content})
+    return {"messages": [AIMessage(content=response)]}
+
+workflow = StateGraph(GraphState)
+workflow.add_node('chatbot', chatbot)
+
+workflow.add_edge(START, 'chatbot')
+workflow.add_edge('chatbot', END)
+
+app_chatbot = workflow.compile()
+
+@app.post('/request')
+def request(req: Request):
+    rep = app_chatbot.invoke({"enonce" : HumanMessage(content=req.enonce),"messages": [HumanMessage(content=req.code)]}, 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[2], "test": ex[3]}