code.txt

moyenne (N2)
;;;
É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 (N2)
;;;
É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 (N2)
;;;
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 (N2)
;;;
É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 (N3)
;;;
É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")
;;;
premier et dernier (N1)
;;;
Écrire une fonction premier_dernier qui prend en paramètre un tableau non vide tab. Cette fonction renvoie un tuple contenant le premièr 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 = 0
if premier_dernier([4, 15, 34, 22]) == (4, 22):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if premier_dernier(["a", "f", "g", "z"]) == ("a", "z"):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if premier_dernier([42]) == (42, 42):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
delta encoding (N3)
;;;
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 (N3)
;;;
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 = 09,50
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 (N3)
;;;
É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 = 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 (N2)
;;;
É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 (N2)
;;;
É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 (N3)
;;;
É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 (N2)
;;;
É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 = 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 (N3 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 (N2)
;;;
É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 (N3)
;;;
É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")
;;;
plus grande valeur (N1)
;;;
É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 = 0
if plus_grande(15,3) == 15:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if plus_grande(-15,-3) == -3:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
couples consecutifs (N3)
;;;
É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")
;;;
moyenne (N1)
;;;
É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.
>>> moyenne(5, 10, 15)
10
;;;
c = 0
if moyenne(5, 10, 15) == 10:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
recheche arbre binaire de recherche (N2 T)
;;;
É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 = 0
if recherche_abr(racine_r,4):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not recherche_abr(racine_r,42):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
suite fibonacci (N3)
;;;
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 (N3)
;;;
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 (N4)
;;;
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 (N3)
;;;
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")
;;;
nombre d’occurrences d’un caractère (N3)
;;;
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 = 0
if nbr_occurrences('Hello world !') == {'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
temperature minimale (N3)
;;;
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 = 0
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):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
occurrences (N2)
;;;
É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 = 0
if occurrences('e', "sciences") == 2:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if occurrences('i',"mississippi") == 4:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if occurrences('a',"mississippi") == 0:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
aire cercle (N1)
;;;
É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 = 0
import math
if round(aire_cercle(3)) == 28:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
indices maxi (N2)
;;;
É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 = 0
if indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9, [3, 8]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if indices_maxi([7]) == (7, [0]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
addition (N1)
;;;
É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 = 0
if add(3,5) == 8:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
sélection enclos (N3)
;;;
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 = 0
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}]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if selection_enclos(animaux, 2) == [{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if  selection_enclos(animaux, 7) == []:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
pair (N1)
;;;
É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.
>>> pair(8)
True
>>> pair(5)
False
;;;
c = 0
if pair(8):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not pair(5):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
doublon (N2)
;;;
É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 = 0
if not a_doublon([]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not a_doublon([1]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if a_doublon([1, 2, 4, 6, 6]):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if a_doublon([2, 5, 7, 7, 7, 9]):
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if not a_doublon([0, 2, 3]):
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
somme (N2)
;;;
É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 = 0
if somme([5, 4, 7]) == 16:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if somme([]) == 0:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
énumère (N3)
;;;
É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 = 0
if enumere([])== {}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if enumere([1, 2, 3]) == {1: [0], 2: [1], 3: [2]}:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if  enumere([1, 1, 2, 3, 2, 1]) == {1: [0, 1, 5], 2: [2, 4], 3: [3]}:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
max_dico (N3)
;;;
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 = 0
if max_dico({ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 }) == ('Ada', 201) :
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 }) == ('Alan', 222) or ('Eve', 222) :
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
correspond (N3)
;;;
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 = 0
if correspond('INFORMATIQUE', 'INFO*MA*IQUE') :
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not correspond('AUTOMATIQUE', 'INFO*MA*IQUE') :
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if not correspond('STOP', 'S*') :
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if correspond('AUTO', '*UT*') :
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
tri insertion (N3)
;;;
É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 = 0
if tri_insertion([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if tri_insertion([6]) == [6]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
insére (N3)
;;;
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 = 0
if insere([1, 2, 4, 5], 3) ==  [1, 2, 3, 4, 5]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if insere([1, 2, 7, 12, 14, 25], 30) ==  [1, 2, 7, 12, 14, 25, 30]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if insere([2, 3, 4], 1) ==  [1, 2, 3, 4]:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if insere([], 1) == [1] :
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
décimal vers binaire (N3)
;;;
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 = 0
if binaire(83) ==  '1010011':
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if binaire(6) ==  '110':
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if binaire(127) ==  '1111111':
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if binaire(0) == '0' :
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
recherche dichotomique récursive (N3 T)
;;;
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 = 0
if chercher([1, 5, 6, 9, 12], 7) == None:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if chercher([1, 5, 6, 9, 12], 9) ==  4:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if chercher([1, 5, 6, 9, 12], 6) ==  2:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
moyenne dico (N3)
;;;
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 clefs 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 = 0
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:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if  round(moyenne("Durand", resultats)) ==  9:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
parcours suffixe d'un arbre binaire (N3 T)
;;;
Écrire une fonction parcours_suffixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours suffixe de l'arbre binaire T.
La classe Arbre possède 3 méthodes :
- get_gauche() renvoie l'arbre gauche
- get_droit() renvoie l'arbre droit
- get_valeur() renvoie la valeur du noeud
;;;
class ArbreBinaire:
    def __init__(self, valeur):
        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 = ArbreBinaire('A')
racine.insert_gauche('B')
racine.insert_droit('F')

b_node = racine.get_gauche()
b_node.insert_gauche('C')
b_node.insert_droit('D')

f_node = racine.get_droit()
f_node.insert_gauche('G')
f_node.insert_droit('H')

c_node = b_node.get_gauche()
c_node.insert_droit('E')

g_node = f_node.get_gauche()
g_node.insert_gauche('I')

h_node = f_node.get_droit()
h_node.insert_droit('J')
c = 0
if parcours_suffixe(racine) == ['E', 'C', 'D', 'B', 'I', 'G', 'J', 'H', 'F', 'A']:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
 nombre de boites (N4)
;;;
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 = 0
if empaqueter([1, 2, 3, 4, 5], 10) == 2:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if empaqueter([1, 2, 3, 4, 5], 5) == 4:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if empaqueter([7, 6, 3, 4, 8, 5, 9, 2], 11) ==  5:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
un sur deux (N2)
;;;
Écrire une fonction un_sur_deux qui prend en paramètre un tableau non vide tab contenant des entiers. Cette fonction renvoie un autre tableau contenant les entiers contenu dans tab, mais en gardant uniquement un entier sur deux.
Exemples :
>>>  un_sur_deux([3, 4, 12, 8, 43,7])
[3, 12, 43]
>>>  un_sur_deux([54, 5, 7, 14, 26, 54, 32])
[54, 7, 26,32]
;;;
c = 0
if un_sur_deux([3, 4, 12, 8, 43,7]) == [3, 12, 43]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if un_sur_deux([54, 5, 7, 14, 26, 54, 32]) == [54, 7, 26,32]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
plus grande somme (N4 T)
;;;
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 = 0
if somme_max([1, 2, 3, 4, 5]) ==  15:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if somme_max([1, 2, -3, 4, 5]) ==  9:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if somme_max([1, 2, -2, 4, 5]) ==  10:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if somme_max([1, -2, 3, 10, -4, 7, 2, -5]) == 18 :
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if omme_max([-3,-2,-1,-4]) == -1 :
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
taille d'un arbre binaire (N2 T)
;;;
Écrire une fonction taille qui prend en paramètre une instance de la classe arbre T et renvoie la taille de l'arbre binaire T.
La classe Arbre possède 3 méthodes :
- get_gauche() renvoie l'arbre gauche
- get_droit() renvoie l'arbre droit
- get_valeur() renvoie la valeur du noeud
;;;
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 = ArbreBinaire('A')
racine.insert_gauche('B')
racine.insert_droit('F')

b_node = racine.get_gauche()
b_node.insert_gauche('C')
b_node.insert_droit('D')

f_node = racine.get_droit()
f_node.insert_gauche('G')
f_node.insert_droit('H')

c_node = b_node.get_gauche()
c_node.insert_droit('E')

g_node = f_node.get_gauche()
g_node.insert_gauche('I')

h_node = f_node.get_droit()
h_node.insert_droit('J')
c = 0
if taille(racine) == 10:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
sépare 0 et 1 (N3)
;;;
É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 = 0
if separe([1, 0, 1, 0, 1, 0, 1, 0]) ==  [0, 0, 0, 0, 1, 1, 1, 1]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
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]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
élève du mois (N3)
;;;
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 = 0
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']):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if eleves_du_mois([],[]) ==  (0, []):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
parcours préfixe d'un arbre binaire (N3 T)
;;;
Écrire une fonction parcours_prefixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours préfixe de l'arbre binaire T.
La classe Arbre possède 3 méthodes :
- get_gauche() renvoie l'arbre gauche
- get_droit() renvoie l'arbre droit
- get_valeur() renvoie la valeur du noeud
;;;
class ArbreBinaire:
    def __init__(self, valeur):
        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 = ArbreBinaire('A')
racine.insert_gauche('B')
racine.insert_droit('F')

b_node = racine.get_gauche()
b_node.insert_gauche('C')
b_node.insert_droit('D')

f_node = racine.get_droit()
f_node.insert_gauche('G')
f_node.insert_droit('H')

c_node = b_node.get_gauche()
c_node.insert_droit('E')

g_node = f_node.get_gauche()
g_node.insert_gauche('I')

h_node = f_node.get_droit()
h_node.insert_droit('J')
c = 0
if parcours_prefixe(racine) == ['A', 'B', 'C', 'E', 'D', 'F', 'G', 'I', 'H', 'J']:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
recherche dichotomique (N2)
;;;
É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 = 0
if dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
parcours infixe d'un arbre binaire (N3 T)
;;;
Écrire une fonction parcours_infixe qui prend en paramètre une instance de la classe arbre T et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre T classés dans un ordre compatible avec un parcours infixe de l'arbre binaire T.
La classe Arbre possède 3 méthodes :
- get_gauche() renvoie l'arbre gauche
- get_droit() renvoie l'arbre droit
- get_valeur() renvoie la valeur du noeud
;;;
class ArbreBinaire:
    def __init__(self, valeur):
        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 = ArbreBinaire('A')
racine.insert_gauche('B')
racine.insert_droit('F')

b_node = racine.get_gauche()
b_node.insert_gauche('C')
b_node.insert_droit('D')

f_node = racine.get_droit()
f_node.insert_gauche('G')
f_node.insert_droit('H')

c_node = b_node.get_gauche()
c_node.insert_droit('E')

g_node = f_node.get_gauche()
g_node.insert_gauche('I')

h_node = f_node.get_droit()
h_node.insert_droit('J')
c = 0
if parcours_infixe(racine) == ['C', 'E', 'B', 'D', 'A', 'I', 'G', 'F', 'H', 'J']:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
palindrome (N3)
;;;
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_palidrome 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 = 0
if est_palindrome('kayak'):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not est_palindrome('NSI'):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
hauteur d'un arbre binaire (N2 T)
;;;
Écrire une fonction hauteur qui prend en paramètre une instance de la classe arbre T et renvoie la hauteur de l'arbre binaire T.
La classe Arbre possède 3 méthodes :
- get_gauche() renvoie l'arbre gauche
- get_droit() renvoie l'arbre droit
- get_valeur() renvoie la valeur du noeud
;;;
class ArbreBinaire:
    def __init__(self, valeur):
        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 = ArbreBinaire('A')
racine.insert_gauche('B')
racine.insert_droit('F')

b_node = racine.get_gauche()
b_node.insert_gauche('C')
b_node.insert_droit('D')

f_node = racine.get_droit()
f_node.insert_gauche('G')
f_node.insert_droit('H')

c_node = b_node.get_gauche()
c_node.insert_droit('E')

g_node = f_node.get_gauche()
g_node.insert_gauche('I')

h_node = f_node.get_droit()
h_node.insert_droit('J')
c = 0
if hauteur(racine) == 4:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
dico vers tableau (N2)
;;;
Écrire une fonction dico_tab qui prend en paramètre un dictionnaire d. Cette fonction renvoie un tableau contenant des tuples, chaque tuple contient en première position une clé du dictionnaire d et en deuxième position la valeur associée  à cette clé.
Exemples :
>>> dico_tab({"pommes" : 3, "cerises" : 15, "fraises" : 7})
[("pommes", 3), ("cerises", 15), ("fraises", 7)]
>>> dico_tab({"pêches" : 2})
[("pêches", 2)]
>>> dico_tab({})
[]
;;;
c = 0
if dico_tab({"pommes" : 3, "cerises" : 15, "fraises" : 7}) == [("pommes", 3), ("cerises", 15), ("fraises", 7)]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if dico_tab({"pêches" : 2}) == [("pêches", 2)]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if dico_tab({}) == []:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
prix article (N2)
;;;
On considère le stock d'un magasin. Ce stock est géré à l'aide d'un tableau contenant des dictionnaires. Chaque dictionnaire est composé de 3 clés : nom, prix et quantité
Exemple :
[{"nom": "T-shirt", "prix": 15, "quantité": 10},  {"nom": "Pantalon", "prix": 30, "quantité": 5}, {"nom": "Chaussures", "prix": 60, "quantité": 2}]

Écrire une fonction prix_article qui prend en paramètres inventaire (le tableau de dictionnaires représentant l'inventaire) et nom_article (le nom de l'article recherché). La fonction doit renvoyer le prix de l'article si celui-ci est présent dans l'inventaire, et -1 sinon.
Exemples :
>>> inv = [{"nom": "T-shirt", "prix": 15, "quantité": 10},  {"nom": "Pantalon", "prix": 30, "quantité": 5}, {"nom": "Chaussures", "prix": 60, "quantité": 2}]
>>> prix_article(inv, "Pantalon")
30
>>> prix_article(inv, "Pull")
-1
;;;
c = 0
inv = [{"nom": "T-shirt", "prix": 15, "quantité": 10},  {"nom": "Pantalon", "prix": 30, "quantité": 5}, {"nom": "Chaussures", "prix": 60, "quantité": 2}]
if prix_article(inv, "Pantalon") == 30:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if prix_article(inv, "Pull") == -1 :
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
info météo (N2)
;;;
On considère un relevé météo implémenté à l'aide de dictionnaires. On  trouve dans ce relevé les informations suivantes pour chaque ville :
- la température maxi
- la température mini
- la pluviométrie

Exemple :

donnees_meteo = {
    "Paris": {"max": 25, "min": 15, "precip": 5},
    "Lyon": {"max": 28, "min": 18, "precip": 2},
    "Marseille": {"max": 30, "min": 20, "precip": 0},
    "Toulouse": {"max": 27, "min": 17, "precip": 10}
}

Écrire une fonction info_meteo qui prend en paramètre un relevé météo et renvoie un tuple contenant : 
- le nom de la ville où la plus petite température a été relevée
- le nom de la ville où la plus haute température a été relevée
-  la somme de  toutes la pluviométrie.

Exemple :

>>> donnees_meteo = {
    "Paris": {"max": 25, "min": 15, "precip": 5},
    "Lyon": {"max": 28, "min": 18, "precip": 2},
    "Marseille": {"max": 30, "min": 20, "precip": 0},
    "Toulouse": {"max": 27, "min": 17, "precip": 10}
}
>>> info_meteo(donnees_meteo)
("Paris", "Marseille", 17)
;;;
c = 0
donnees_meteo = {
    "Paris": {"max": 25, "min": 15, "precip": 5},
    "Lyon": {"max": 28, "min": 18, "precip": 2},
    "Marseille": {"max": 30, "min": 20, "precip": 0},
    "Toulouse": {"max": 27, "min": 17, "precip": 10}
}
if info_meteo(donnees_meteo) == ("Paris", "Marseille", 17):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
moyenne notes (N3)
;;;
Un professeur utilise un dictionnaire pour stocker les notes de ses élèves. Chaque clé du dictionnaire est le nom de l'élève (une chaîne de caractères), et la valeur associée est une liste de notes (des nombres décimaux).
Dans le cas où un élève est absent à une évaluation, on saisie la chaine "abs" à la place de la  note.
Exemple :
notes = {
    "Martine" : [12, 11, 8, 15],
    "Anne-Marie" : [15, 17, 12, 12],
    "Patrick" : ["abs", 12, 11, 10],
    "Pierre-Louis" : ["abs", "abs", "abs", "abs"]
}
Écrire une fonction liste_moyenne qui prend un paramètre un dictionnaire  (même structure que ci-dessus). Cette fonction renvoie un tableau contenant des tuples. Chaque tuple contient le prénom de l'élève en première position et la moyenne de l'élève en deuxième position.
Exemple :
>>> notes = {
    "Martine" : [12, 11, 8, 15],
    "Anne-Marie" : [15, 17, 12, 12],
    "Patrick" : ["abs", 12, 11, 10],
    "Pierre-Louis" : ["abs", "abs", "abs", "abs"]
}
>>> liste_moyenne(notes)
[('Martine', 11.5), ('Anne-Marie', 14.0), ('Patrick', 11.0), ('Pierre-Louis', 'abs')]
;;;
c = 0
notes = {
    "Martine" : [12, 11, 8, 15],
    "Anne-Marie" : [15, 17, 12, 12],
    "Patrick" : ["abs", 12, 11, 10],
    "Pierre-Louis" : ["abs", "abs", "abs", "abs"]
}
if liste_moyenne(notes) == [('Martine', 11.5), ('Anne-Marie', 14.0), ('Patrick', 11.0), ('Pierre-Louis', 'abs')]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
calculatrice RPN (N3)
;;;
Écrire une fonction Python rpn_calcul qui prend en paramètre une expression expr sous forme d'un tableau de chaînes de caractères représentant une expression en notation polonaise inverse. Cette fonction doit renvoiyer le résultat du calcul. L'expression contient des nombres et des opérateurs (+, -, *, /).
Utilisez une pile pour effectuer le calcul.
Parcourez la liste expression.
Si un élément est un nombre, empilez-le sur la pile.
Si un élément est un opérateur (+, -, *, /), dépilez les deux derniers éléments de la pile, effectuez l'opération correspondante, et empilez le résultat.
Exemples :
>>> rpn_calcul(["3", "4", "+"])
7
>>> rpn_calcul(["4", "2", "-"])
2
>>>  rpn_calcul(["10", "5", "+", "3", "*"])
45
>>> rpn_calcul(["15", "7", "1", "+", "-", "3", "*"])
21
;;;
c = 0
if rpn_calcul(["3", "4", "+"]) == 7:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if rpn_calcul(["4", "2", "-"]) == 2:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if rpn_calcul(["10", "5", "+", "3", "*"]) == 45:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if rpn_calcul(["15", "7", "1", "+", "-", "3", "*"]) == 21:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
supprimer doublon (N2)
;;;
Écrire une fonction supprimer_doublons qui prend en argument un tableau tab et qui renvoie un tableau contenant les mêmes éléments que la liste d'entrée, mais sans doublons.
Exemples :
>>> supprimer_doublons([1, 2, 2, 3, 4, 4, 5, 3, 1])
[1, 2, 3, 4, 5]
>>> supprimer_doublons([5, 15, 22, 5, 8, 2, 5, 2, 1])
[5, 15, 22, 8, 2, 1]
>>> supprimer_doublons([1, 1, 1, 1, 1])
[1]
>>> supprimer_doublons([])
[]
;;;
c = 0
if supprimer_doublons([1, 2, 2, 3, 4, 4, 5, 3, 1]) == [1, 2, 3, 4, 5]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if supprimer_doublons([5, 15, 22, 5, 8, 2, 5, 2, 1]) == [5, 15, 22, 8, 2, 1]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if supprimer_doublons([1, 1, 1, 1, 1]) == [1]:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if supprimer_doublons([]) == []:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;