code.txt

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"
if maximum_tableau([-27, -24, -3, 15]) == 15:
    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"
;;;
(T) parcours largeur arbre
;;;
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"
;;;
(T) 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  
- g`et_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"
;;;
(T) suite fibonacci récursive
;;;
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"
;;;
(T) 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) ==  3:
    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"
;;;
(T) parcours suffixe d'un arbre binaire
;;;
3
;;;
arbre, programmation orientée objet, parcours d'un arbre
;;;
Écrire une fonction `parcours_suffixe qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours suffixe de l'arbre binaire `T`.  
La classe `Arbre` possède 3 méthodes :  
- `get_gauche()` renvoie l'arbre gauche  
- `get_droit()` renvoie l'arbre droit  
- `get_valeur()` renvoie la valeur du noeud  
;;;
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 = ""
if parcours_suffixe(racine) == ['E', 'C', 'D', 'B', 'I', 'G', 'J', 'H', 'F', 'A']:
    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"
;;;
un sur deux
;;;
2
;;;
parcours d'un tableau, indice d'un tableau, création d'un tableau, append
;;;
Écrire une fonction `un_sur_deux` qui prend en paramètre un tableau non vide `tab` contenant des entiers. Cette fonction renvoie un autre tableau contenant les entiers contenu dans `tab`, mais en gardant uniquement un entier sur deux.  
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 = ""
if un_sur_deux([3, 4, 12, 8, 43,7]) == [3, 12, 43]:
    c += "1"
else  :
    c += "0"
if un_sur_deux([54, 5, 7, 14, 26, 54, 32]) == [54, 7, 26,32]:
    c += "1"
else  :
    c += "0"
;;;
(T) 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 somme_max([-3,-2,-1,-4]) == -1 :
    c+="1"
else  :
    c+="0"
;;;
(T) taille d'un arbre binaire
;;;
2
;;;
arbre binaire, programmation orientée objet, taille d'un arbre
;;;
Écrire une fonction `taille` qui prend en paramètre une instance de la classe `arbre T` et renvoie la taille de l'arbre binaire `T`.  
La classe `Arbre` possède 3 méthodes :  
- g`et_gauche()` renvoie l'arbre gauche  
- `get_droit()` renvoie l'arbre droit  
- `get_valeur()` renvoie la valeur du noeud  
;;;
class ArbreBinaire:
    def __init__(self, valeur):
        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 = ""
if taille(racine) == 10:
    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"
;;;
(T) parcours préfixe d'un arbre binaire
;;;
3
;;;
arbre, programmation orientée objet, parcours d'un arbre
;;;
Écrire une fonction `parcours_prefixe` qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours préfixe de l'arbre binaire `T`.  
La classe `Arbre` possède 3 méthodes :  
- `get_gauche()` renvoie l'arbre gauche  
- `get_droit()` renvoie l'arbre droit  
- `get_valeur()` renvoie la valeur du noeud  
;;;
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 = ""
if parcours_prefixe(racine) == ['A', 'B', 'C', 'E', 'D', 'F', 'G', 'I', 'H', 'J']:
    c += "1"
else  :
    c += "0"
;;;
calcul du carré d'un nombre
;;;
1
;;;
calcul
;;;
Écrire une fonction `carre` qui prend en paramètre un nombre `x` et qui renvoie le carré de ce nombre.
Exemple :
```
>>> carre(5)
25
```
;;;
c = ""
if carre(5) == 25:
  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"
;;;
(T) parcours infixe d'un arbre binaire
;;;
3
;;;
arbre binaire, programmation orientée objet, parcours arbre binaire
;;;
Écrire une fonction `parcours_infixe` qui prend en paramètre une instance de la classe `arbre T` et renvoie un tableau (de type list) contenant les valeurs des noeuds de l'arbre `T` classés dans un ordre compatible avec un parcours infixe de l'arbre binaire `T`.  
La classe `Arbre` possède 3 méthodes :  
- `get_gauche()` renvoie l'arbre gauche  
- `get_droit()` renvoie l'arbre droit  
- `get_valeur()` renvoie la valeur du noeud  
;;;
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 = ""
if parcours_infixe(racine) == ['C', 'E', 'B', 'D', 'A', 'I', 'G', 'F', 'H', 'J']:
    c += "1"
else  :
    c += "0"
;;;
conversion Celsius fahrenheit
;;;
1
;;;
calcul, conversion
;;;
Écrire une fonction `convert_celsius_fahrenheit` qui prend en paramètre une température en degrés Celsius `temp_celsius` et qui renvoie la température équivalente en degrés Fahrenheit.
La formule de conversion est : `Fahrenheit = (Celsius * 9/5) + 32`
Exemple :
```
>>> convert_celsius_fahrenheit(0)
32.0
>>> convert_celsius_fahrenheit(100)
212.0
```
;;;
c = ""
if convert_celsius_fahrenheit(0) == 32.0:
 c += "1"
else:
 c += "0"
if convert_celsius_fahrenheit(100) == 212.0:
 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"
;;;
(T) hauteur d'un arbre binaire
;;;
2
;;;
arbre binaire, programmation orientée objet, hauteur d'un arbre
;;;
Écrire une fonction `hauteur` qui prend en paramètre une instance de la classe `arbre T` et renvoie la hauteur de l'arbre binaire `T`.  
La classe `Arbre` possède 3 méthodes :  
- `get_gauche()` renvoie l'arbre gauche  
- `get_droit()` renvoie l'arbre droit  
- `get_valeur()` renvoie la valeur du noeud  
;;;
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 = ""
if hauteur(racine) == 4:
    c += "1"
else  :
    c += "0"
;;;
dico vers tableau
;;;
2
;;;
dictionnaire, tableau
;;;
Écrire une fonction `dico_tab` qui prend en paramètre un dictionnaire `d`. Cette fonction renvoie un tableau contenant des tuples, chaque tuple contient en première position une clé du dictionnaire `d` et en deuxième position la valeur associée à cette clé.  
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 = ""
if dico_tab({"pommes" : 3, "cerises" : 15, "fraises" : 7}) == [("pommes", 3), ("cerises", 15), ("fraises", 7)]:
    c += "1"
else  :
    c += "0"
if dico_tab({"pêches" : 2}) == [("pêches", 2)]:
    c += "1"
else  :
    c += "0"
if dico_tab({}) == []:
    c += "1"
else  :
    c += "0"
;;;
prix article
;;;
2
;;;
dictionnaire, calculs, tableau, tableau de dictionnaires
;;;
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 = ""
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:
    c += "1"
else  :
    c += "0"
if prix_article(inv, "Pull") == -1 :
    c += "1"
else  :
    c += "0"
;;;
info météo
;;;
2
;;;
dictionnaire, dictionnaire de dictionnaires, tuple, recherche maxi, recherche mini
;;;
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 = ""
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):
    c += "1"
else  :
    c += "0"
;;;
moyenne notes
;;;
3
;;;
dictionnaire, calcul moyenne, tableau, tableau dans un dictionnaire
;;;
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 = ""
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')]:
    c += "1"
else  :
    c += "0"
;;;
(T) calculatrice RPN
;;;
3
;;;
tableau, parcours d'un tableau, pile
;;;
Écrire une fonction Python `rpn_calcul` qui prend en paramètre une expression `expr` sous forme d'un tableau de chaînes de caractères représentant une expression en notation polonaise inverse. Cette fonction doit renvoiyer le résultat du calcul. L'expression contient des nombres et des opérateurs (+, -, *, /).  
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 = ""
if rpn_calcul(["3", "4", "+"]) == 7:
    c += "1"
else  :
    c += "0"
if rpn_calcul(["4", "2", "-"]) == 2:
    c += "1"
else  :
    c += "0"
if rpn_calcul(["10", "5", "+", "3", "*"]) == 45:
    c += "1"
else  :
    c += "0"
if rpn_calcul(["15", "7", "1", "+", "-", "3", "*"]) == 21:
    c += "1"
else  :
    c += "0"
;;;
supprimer doublon
;;;
2
;;;
tableau, parcours tableau par indice, création tableau, append
;;;
Écrire une fonction `supprimer_doublons` qui prend en argument un tableau `tab` et qui renvoie un tableau contenant les mêmes éléments que la liste d'entrée, mais sans doublons.  
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 = ""
if supprimer_doublons([1, 2, 2, 3, 4, 4, 5, 3, 1]) == [1, 2, 3, 4, 5]:
    c += "1"
else  :
    c += "0"
if supprimer_doublons([5, 15, 22, 5, 8, 2, 5, 2, 1]) == [5, 15, 22, 8, 2, 1]:
    c += "1"
else  :
    c += "0"
if supprimer_doublons([1, 1, 1, 1, 1]) == [1]:
    c += "1"
else  :
    c += "0"
if supprimer_doublons([]) == []:
    c += "1"
else  :
    c += "0"
;;;
plus grand écart
;;;
2
;;;
tableau (liste Python), boucle for, parcours d'un tableau, valeur absolue, écart
;;;
Écrire une fonction `plus_grand_ecart` qui prend en paramètre un tableau de nombres `tab` (type list) non vide et qui renvoie le plus grand écart entre deux nombres consécutifs de ce tableau. L'écart entre deux nombres est la valeur absolue de leur différence.  
Exemples :  
```
>>> plus_grand_ecart([1, 5, 2, 8, 2])
6
>>> plus_grand_ecart([1, 2, 3, 4, 5])
1
>>> plus_grand_ecart([5, 4, 3, 2, 1])
1
```
;;;
c = ""
if plus_grand_ecart([1, 5, 2, 8, 2]) == 6:
    c += "1"
else:
    c += "0"
if plus_grand_ecart([1, 2, 3, 4, 5]) == 1:
    c += "1"
else:
    c += "0"
if plus_grand_ecart([5, 4, 3, 2, 1]) == 1:
    c += "1"
else:
    c += "0"
;;;
est divisible
;;;
1
;;;
modulo, operateur %
;;;
Écrire une fonction `est_divisible` qui prend en paramètre deux entiers `a` et `b`. Cette fonction renvoie `True` si `a` est divisible par `b` et `False` dans le cas contraire.  
Exemples :  
```
>>> est_divisible(10, 2)
True
>>> est_divisible(7, 3)
False
```
;;;
c = ""
if est_divisible(10, 2):
 c += "1"
else:
 c += "0"
if not est_divisible(7, 3):
 c += "1"
else:
 c += "0"
;;;
est un anagramme
;;;
3
;;;
chaine de caractères, parcours d'une chaine, dictionnaire, comptage
;;;
Écrire une fonction `est_anagramme` qui prend deux chaînes de caractères en paramètre, `mot1` et `mot2`, et qui renvoie `True` si `mot1` est un anagramme de `mot2`, et `False` sinon.  
Deux mots sont des anagrammes si on peut obtenir l'un à partir de l'autre en permutant les lettres.   
Par exemple, "chien" est un anagramme de "niche", et " marie " est un anagramme de "aimer".  
Exemples :  
```
>>> est_anagramme("chien", "niche")
True
>>> est_anagramme("marie", "aimer")
True
>>> est_anagramme("bonjour", "bonsoir")
False
```
;;;
c = ""
if est_anagramme("chien", "niche"):
 c += "1"
else:
 c += "0"
if est_anagramme("marie ", "aimer"):
 c += "1"
else:
 c += "0"
if not est_anagramme("bonjour", "bonsoir"):
 c += "1"
else:
 c += "0"
;;;
Distance entre deux points
;;;
2
;;;
calcul, math, fonction
;;;
Écrire une fonction `distance` qui prend en paramètre les coordonnées de deux points A et B. La fonction doit renvoyer la distance euclidienne entre ces deux points.  
Exemples :  
```
>>> distance((1, 2), (4, 6))
5.0
>>> distance((0, 0), (1, 1))
1.414
```
;;;
import math
c = ""
if round(distance((1, 2), (4, 6)), 3) == 5.0:
  c += "1"
else:
  c += "0"
if round(distance((0, 0), (1, 1)), 3) == 1.414:
  c += "1"
else:
  c += "0"
;;;
compte mots
;;;
3
;;;
chaine de caractères, dictionnaire, comptage
;;;
Écrire une fonction `compte_mots` qui prend en paramètre une chaîne de caractères texte et renvoie un dictionnaire dont les clés sont les mots présents dans le texte et les valeurs associées sont le nombre d'occurrences de chaque mot. On considérera que les mots sont séparés par des espaces et que la ponctuation est ignorée. La casse ne doit pas être prise en compte (les majuscules et minuscules sont considérées comme identiques).  
Exemples :  
```
>>> compte_mots("Le chat est sur le tapis")
{'le': 2, 'chat': 1, 'est': 1, 'sur': 1, 'tapis': 1}
>>> compte_mots("Un deux trois, un deux")
{'un': 2, 'deux': 2, 'trois': 1}
>>> compte_mots("")
{}
```
;;;
c = ""
if compte_mots("Le chat est sur le tapis") == {'le': 2, 'chat': 1, 'est': 1, 'sur': 1, 'tapis': 1}:
  c += "1"
else:
  c += "0"
if compte_mots("Un deux trois un deux") == {'un': 2, 'deux': 2, 'trois': 1}:
  c += "1"
else:
  c += "0"
if compte_mots("") == {}:
  c += "1"
else:
  c += "0"
;;;
conversion binaire vers décimal
;;;
2
;;;
chaine de caractères, conversion binaire vers décimal, boucle for, puissance
;;;
Écrire une fonction `binaire_decimal` qui prend en paramètre une chaîne de caractères représentant un nombre binaire et qui renvoie sa valeur en base 10 (en décimal).  
Exemples :  
```
>>> binaire_decimal("101")
5
>>> binaire_decimal("1111")
15
>>> binaire_decimal("0")
0
```
;;;
c = ""
if binaire_decimal("101") == 5:
 c += "1"
else:
 c += "0"
if binaire_decimal("1111") == 15:
 c += "1"
else:
 c += "0"
if binaire_decimal("0") == 0:
 c += "1"
else:
 c += "0"
;;;
trouve doublon
;;;
3
;;;
tableau (list Python), boucle for, test d'égalité
;;;
Écrire une fonction `trouve_doublon` qui prend en paramètre un tableau `tab` (type list) et qui renvoie `True` si le tableau contient au moins un doublon et `False` sinon.  
Exemples :  
```
>>> trouve_doublon([1, 2, 3, 4, 5])
False
>>> trouve_doublon([1, 2, 3, 4, 1])
True
>>> trouve_doublon([])
False
```
;;;
c = ""
if not trouve_doublon([1, 2, 3, 4, 5]):
 c += "1"
else:
 c += "0"
if trouve_doublon([1, 2, 3, 4, 1]):
 c += "1"
else:
 c += "0"
if not trouve_doublon([]):
 c += "1"
else:
 c += "0"
;;;
trouve element majoritaire
;;;
3
;;;
tableau (liste Python), boucle for, dictionnaire, comptage, seuil
;;;
Écrire une fonction `element_majoritaire` qui prend en paramètre un tableau `tab` (type list) et qui renvoie l'élément majoritaire de ce tableau, c'est-à-dire l'élément qui apparaît plus de `n/2` fois dans le tableau, où `n` est la longueur du tableau. Si aucun élément n'est majoritaire, la fonction doit renvoyer `None`.  
Exemples :  
```
>>> element_majoritaire([1, 2, 2, 2, 1])
2
>>> element_majoritaire([1, 2, 3, 4, 5])
>>> element_majoritaire([1, 1, 1, 2, 2])
1
```
;;;
c = ""
if element_majoritaire([1, 2, 2, 2, 1]) == 2:
 c += "1"
else:
 c += "0"
if element_majoritaire([1, 2, 3, 4, 5]) == None:
 c += "1"
else:
 c += "0"
if element_majoritaire([1, 1, 1, 2, 2]) == 1:
 c += "1"
else:
 c += "0"
;;;
plus petit que la moyenne
;;;
2
;;;
tableau (liste Python), boucle for, parcours d'un tableau, calculs, taille d'une liste (len), comparaison
;;;
Écrire une fonction `plus_petit_moyenne` qui prend en paramètre un tableau non vide de nombres `tab` (de type list) et qui renvoie un tableau contenant les nombres de tab strictement inférieurs à la moyenne des nombres contenus dans `tab`.  
Exemples :  
```
>>> plus_petit_moyenne([1, 2, 3, 4, 5])
[1, 2]
>>> plus_petit_moyenne([10, 20, 30, 40, 50])
[10, 20]
>>> plus_petit_moyenne([1, 1, 1, 1, 1])
[]
```
;;;
c = ""
if plus_petit_moyenne([1, 2, 3, 4, 5]) == [1, 2]:
    c += "1"
else:
    c += "0"
if plus_petit_moyenne([10, 20, 30, 40, 50]) == [10, 20]:
    c += "1"
else:
    c += "0"
if plus_petit_moyenne([1, 1, 1, 1, 1]) == []:
    c += "1"
else:
    c += "0"
;;;
somme des chiffres
;;;
2
;;;
chaine de caractères, boucle for, conversion type, somme
;;;
Écrire une fonction `somme_chiffres` qui prend en paramètre une chaîne de caractères nombre représentant un entier positif. La fonction doit renvoyer la somme des chiffres composant ce nombre.  
Exemples :  
```
>>> somme_chiffres("123")
6
>>> somme_chiffres("4567")
22
>>> somme_chiffres("0")
0
```
;;;
c = ""
if somme_chiffres("123") == 6:
 c += "1"
else:
 c += "0"
if somme_chiffres("4567") == 22:
 c += "1"
else:
 c += "0"
if somme_chiffres("0") == 0:
 c += "1"
else:
 c += "0"
;;;
est un nombre premier
;;;
3
;;;
nombre premier, boucle for, test de primalité
;;;
Écrire une fonction `est_premier` qui prend en paramètre un entier positif `n`. La fonction doit renvoyer `True` si `n` est un nombre premier et `False` sinon.  
Un nombre premier est un nombre qui a exactement deux diviseurs distincts : 1 et lui-même.  
Par convention, 0 et 1 ne sont pas premiers.  
Exemples :  
```
>>> est_premier(2)
True
>>> est_premier(10)
False
>>> est_premier(11)
True
```
;;;
c = ""
if est_premier(2):
 c += "1"
else:
 c += "0"
if not est_premier(10):
 c += "1"
else:
 c += "0"
if est_premier(11):
 c += "1"
else:
 c += "0"
;;;
(T) somme des éléments d'un tableau
;;;
4
;;;
tableau (liste Python), récursivité, somme
;;;
Écrire une fonction récursive `somme_recursive` qui prend en paramètre un tableau de nombres `tab` (type list) et qui renvoie la somme de tous les éléments du tableau.  
Exemples :  
```
>>> somme_recursive([1, 2, 3, 4, 5])
15
>>> somme_recursive([])
0
>>> somme_recursive([10])
10
```
;;;
c = ""
if somme_recursive([1, 2, 3, 4, 5]) == 15:
 c += "1"
else:
 c += "0"
if somme_recursive([]) == 0:
 c += "1"
else:
 c += "0"
if somme_recursive([10]) == 10:
 c += "1"
else:
 c += "0"
;;;
calcul surface rectangle
;;;
1
;;;
calcul
;;;
Écrire une fonction `surface_rectangle` qui prend en paramètre la longueur `L` et la largeur `l` d'un rectangle et qui renvoie la surface de ce rectangle.  
Exemple :  
```
>>> surface_rectangle(5, 3)
15
```
;;;
c = ""
if surface_rectangle(5, 3) == 15:
 c += "1"
else:
 c += "0"
;;;
trouve le plus long mot
;;;
3
;;;
chaine de caractères, parcours d'un tableau, recherche du maximum
;;;
Écrire une fonction `trouve_plus_long_mot` qui prend en paramètre un tableau de chaines de caractères `mots` (type list) non vide et qui renvoie le mot le plus long de ce tableau. S'il y a plusieurs mots de même longueur maximale, la fonction renvoie le premier mot rencontré dans le tableau.
Exemples :
```
>>> trouve_plus_long_mot(["chat", "chien", "oiseau"])
'oiseau'
>>> trouve_plus_long_mot(["pomme", "banane", "kiwi", "fraise"])
'banane'
>>> trouve_plus_long_mot(["a", "bb", "ccc"])
'ccc'
```
;;;
c = ""
if trouve_plus_long_mot(["chat", "chien", "oiseau"]) == 'oiseau':
    c += "1"
else:
    c += "0"
if trouve_plus_long_mot(["pomme", "banane", "kiwi", "fraise"]) == 'banane':
    c += "1"
else:
    c += "0"
if trouve_plus_long_mot(["a", "bb", "ccc"]) == 'ccc':
    c += "1"
else:
    c += "0"
;;;
conversion chaine en entier
;;;
3
;;;
chaine de caractères, conversion type
;;;
Écrire une fonction `convertit_en_entier` qui prend en paramètre une chaîne de caractères chaine représentant un nombre entier positif. La fonction doit renvoyer la valeur entière correspondante.  
Il est interdit d'utiliser la fonction native `int`.  
Exemples :
```
>>> convertit_en_entier("123")
123
>>> convertit_en_entier("4567")
4567
>>> convertit_en_entier("0")
0
```
;;;
c = ""
if convertit_en_entier("123") == 123:
 c += "1"
else:
 c += "0"
if convertit_en_entier("4567") == 4567:
 c += "1"
else:
 c += "0"
if convertit_en_entier("0") == 0:
 c += "1"
else:
 c += "0"
;;;
calcul du périmètre d'un rectangle
;;;
1
;;;
calcul périmètre
;;;
Écrire une fonction `perimetre_rectangle` qui prend en paramètre la longueur `L` et la largeur `l` d'un rectangle et qui renvoie le périmètre de ce rectangle.  
Exemple :  
```
>>> perimetre_rectangle(5, 3)
16
```
;;;
c = ""
if perimetre_rectangle(5, 3) == 16:
  c += "1"
else:
  c += "0"
;;;
est divisible par tous
;;;
2
;;;
tableaux (list Python), boucle for, modulo
;;;
Écrire une fonction `est_divisible_par_tous` qui prend en paramètre un entier `n` et un tableau d'entiers diviseurs (type list). La fonction doit renvoyer `True` si n est divisible par tous les éléments du tableau diviseurs, et `False` sinon. Si le tableau diviseurs est vide, la fonction doit renvoyer `True`.  
Exemples :  
```
>>> est_divisible_par_tous(10, [2, 5])
True
>>> est_divisible_par_tous(12, [2, 3, 4])
True
>>> est_divisible_par_tous(15, [2, 5])
False
>>> est_divisible_par_tous(7, [])
True
```
;;;
c = ""
if est_divisible_par_tous(10, [2, 5]):
 c += "1"
else:
 c += "0"
if est_divisible_par_tous(12, [2, 3, 4]):
 c += "1"
else:
 c += "0"
if not est_divisible_par_tous(15, [2, 5]):
 c += "1"
else:
 c += "0"
if est_divisible_par_tous(7, []):
 c += "1"
else:
 c += "0"
;;;
trouve les mots
;;;
2
;;;
chaine de caractères, tableau, parcours d'un tableau, recherche
;;;
Écrire une fonction `trouve_mots` qui prend en paramètre une chaîne de caractères texte et un tableau de chaines de caractères mots (type list). La fonction doit renvoyer un tableau contenant les mots du tableau mots qui sont présents dans le texte.  
Exemples :  
```
>>> trouve_mots("Le chat est sur le tapis", ["chat", "chien", "tapis"])
["chat", "tapis"]
>>> trouve_mots("Un deux trois", ["un", "quatre", "trois"])
["un", "trois"]
>>> trouve_mots("Bonjour", ["bonsoir"])
[]
```
;;;
c = ""
if trouve_mots("Le chat est sur le tapis", ["chat", "chien", "tapis"]) == ["chat", "tapis"]:
    c += "1"
else:
    c += "0"
if trouve_mots("Un deux trois", ["un", "quatre", "trois"]) == ["un", "trois"]:
    c += "1"
else:
    c += "0"
if trouve_mots("Bonjour", ["bonsoir"]) == []:
    c += "1"
else:
    c += "0"
;;;
somme des nombres pairs d'un tableau
;;;
2 
;;;
tableau (liste Python), boucle for, condition (if), modulo, somme
;;;
Écrire une fonction `somme_pairs` qui prend en paramètre un tableau d'entiers `tab` (type list) et qui renvoie la somme des nombres pairs contenus dans ce tableau.  
Si le tableau est vide, la fonction doit retourner `0`.  
Exemples :  
```  
>>> somme_pairs([1, 2, 3, 4, 5, 6])  
12  
>>> somme_pairs([1, 3, 5, 7])  
0  
>>> somme_pairs([2, 4, 6, 8])  
20  
>>> somme_pairs([])  
0  
```  
;;;
c = ""  
if somme_pairs([1, 2, 3, 4, 5, 6]) == 12:  
 c += "1"  
else:  
 c += "0"  
if somme_pairs([1, 3, 5, 7]) == 0:  
 c += "1"  
else:  
 c += "0"  
if somme_pairs([2, 4, 6, 8]) == 20:  
 c += "1"  
else:  
 c += "0"  
if somme_pairs([]) == 0:  
 c += "1"  
else:  
 c += "0"
;;;
(T) est un palindrome bis 
;;;
3
;;;
chaine de caractères, parcours d'une chaine, récursivité
;;;
Écrire une fonction récursive `est_palindrome_recursive` qui prend en paramètre une chaîne de caractères `mot` et qui renvoie `True` si `mot` est un palindrome, et `False` sinon.  
Un mot est un palindrome s'il se lit de la même manière de gauche à droite et de droite à gauche.  
Exemples :  
```
>>> est_palindrome_recursive("radar")
True
>>> est_palindrome_recursive("python")
False
>>> est_palindrome_recursive("")
True
>>> est_palindrome_recursive("a")
True
```
;;;
c = ""
if est_palindrome_recursive("radar"):
  c += "1"
else:
  c += "0"
if not est_palindrome_recursive("python"):
  c += "1"
else:
  c += "0"
if est_palindrome_recursive(""):
  c += "1"
else:
  c += "0"
if est_palindrome_recursive("a"):
  c += "1"
else:
  c += "0"
;;;
trouve le nombre de voyelles dans une chaine de caractères
;;;
2
;;;
chaine de caractères, boucle for, test d'appartenance
;;;
Écrire une fonction `nombre_voyelles` qui prend en paramètre une chaîne de caractères `chaine` et qui renvoie le nombre de voyelles (a, e, i, o, u, y) présentes dans la chaîne. La casse (majuscules/minuscules) ne doit pas être prise en compte.  
Exemples :  
```
>>> nombre_voyelles("Bonjour")
3
>>> nombre_voyelles("Python")
1
>>> nombre_voyelles("AEIOUY")
6
>>> nombre_voyelles("")
0
```
;;;
c = ""
if nombre_voyelles("Bonjour") == 3:
    c += "1"
else:
    c += "0"
if nombre_voyelles("Python") == 2:
    c += "1"
else:
    c += "0"
if nombre_voyelles("AEIOUY") == 6:
    c += "1"
else:
    c += "0"
if nombre_voyelles("") == 0:
    c += "1"
else:
    c += "0"
;;;
est un triangle rectangle ?
;;;
2
;;;
test d'égalité, théorème de pythagore, calcul
;;;
Écrire une fonction `est_rectangle` qui prend en paramètre trois entiers `a`, `b` et `c`, représentant les longueurs des côtés d'un triangle. La fonction doit renvoyer `True` si le triangle est rectangle et `False sinon`. On suppose que `c` est la longueur du côté le plus grand.  
Exemples :  
```
>>> est_rectangle(3, 4, 5)
True
>>> est_rectangle(5, 12, 13)
True
>>> est_rectangle(6, 8, 11)
False
```
;;;
c = ""
if est_rectangle(3, 4, 5):
 c += "1"
else:
 c += "0"
if est_rectangle(5, 12, 13):
 c += "1"
else:
 c += "0"
if not est_rectangle(6, 8, 11):
 c += "1"
else:
 c += "0"
;;;