Université de Carthage Année universitaire : 2020/2021

Filière : SM/SP/ST
Institut Préparatoire aux Etudes Niveau d’étude : 2ème année
d’Ingénieurs de Nabeul Semestre : 1 / Date : 17/12/2020
Département de Mathématique Nombre de pages : 4
et de l’Informatique Date : 17/12/2020 Durée :1h30
Devoir Surveillé d’informatique

Exercice 1 (4 points) : méthodes spéciales de la classe Pile

On rappelle qu’une pile est une structure de données qui suit le principe LIFO (dernier arrivé est le premier
servi), on propose l’implémentation suivante d’une classe Pile pouvant contenir des objets quelconques

class Pile :
def __init__(self) :
self.__liste=[ ] # l’attribut __liste est privé, il est interdit d’y accéder à l’extérieur
de cette classe
def empiler(self, unObjet) :
self.__liste.append(unObjet)

def depiler(self) :
if self.est_vide( )== False:
return self.__liste.pop( )

def __len__(self) :
return ( len(self.__liste) )

def est_vide(self) :
return ( len(self) == 0 )

def copier(self) :
copie = Pile()
for objet in (self.__liste) : copie.empiler(objet)
return copie

Travail demandé :
1.1. écrire dans la classe Pile une méthode__contains__(self, unObjet) qui retourne True si
la pile contient unObjet passé en paramètre et qui retourne Fa1se sinon.
1.2. écrire dans la classe Pile une méthode __add__(self, other), qui construit une Pile contenant
tous les éléments des deux piles self et other, tels que les éléments de la pile self sont en
bas et les éléments de la pile other sont en haut de la pile construite, cette dernière
est renvoyée comme résultat de la méthode.
1.3. écrire dans la classe Pile une méthode __eq__(self, other), qui retourne True si tous les éléments
des deux piles self et other sont égaux deux-à-deux (aux mêmes positions des deux
piles). Vous devez donc commencer par vérifier que len(self)==len(other)

1
Exercice 2 : ( 7 points) Représentation de la structure d'arbre binaire
Un arbre binaire est une structure de données formée par une hiérarchie d'éléments appelés nœuds. Un
nœud est caractérisé par deux catégories d'informations:
Les informations propres au nœud ;
Les informations décrivant les liens avec ses nœuds descendants.
Un arbre binaire est toujours désigné par un nœud : son nœud initial appelé racine.
Chaque nœud possède au plus deux nœuds fils :
• Si le nœud possède exactement deux nœuds fils, ils sont appelés fils gauche et fils droit.
• Si le nœud possède un seul nœud fils, ce dernier est soit le fils gauche soit le fils droit
• Si le nœud ne possède aucun nœud fils, il est appelé feuille.
Alors, un arbre binaire est une structure recursive, puisque le fils gauche et le fils droit sont eux-
mêmes des nœuds (représentant des arbres à leur tour).
Exemple :
La figure 1 représente un arbre binaire dont le nœud A
est la racine avec B son fils gauche et C son fils droit.
Le nœud C a un seul fils F (fils droit). D, E et F sont
des nœuds feuilles.

Figure 1 : Exemple d'un arbre binaire

Dans la suite, on propose de construire la classe Node dont le squelette est donné par :
class Node :

self.right= rightNode # instance de la classe Node ou None

def isLeaf(self):
return (self.left == None and self.right == None)
def str__(self): # méthode récursive retournant la chaine représentant l'arbre
if self.isLeaf():
return "Node("+self.label+")
# traitement recursif du noeud fils droit
return "Node("+self.label+", None, " + str(self.right)+ ")"
# traitement recursif du noeud fils gauche
return "Node("+self.label+", "+ str(self.left) +", None)"
else: # traitement recursif des deux noeuds fils
return "Node("+self.label+","+str(self.left)+","+str(self.right)+")"

# à completer . . .

# à completer ...
Exemple :
Nd est une instance de la classe Node correspondant à l'arbre de la figure 1 :
Nd= Node('A', Node('B', Node('D'), Node('E')), Node('C', None, Node('F')))

2
Travail demandé :
1. Ecrire la méthode __len__(self) qui permet de déterminer le nombre de noeuds d'un arbre.
Exemple:
>>> len(Nd)
6
2. Ecrire la méthode __contains__(self, label) qui retourne True si l’arbre contient un
nœud étiqueté par le label passé en paramètre et qui retourne Fa1se sinon.
Exemple:
>>> Nd.__contains__('E')
True
>>> 'G' in Nd
False

3. Ajouter à la classe Node, l’écriture d’une méthode copier_dans_pile(self, pile)

qui empile tous les labels des nœuds de l’arbre dans la pile passée en paramètre

4. Ajouter à la classe Node, l’écriture d’une méthode __eq__(self, other), qui retourne True si
tous les labels des noeuds des deux arbres self et other sont égaux deux-à-deux (aux
mêmes positions des deux arbres). Pour cela, il suffit de copier les deux arbres
dans deux piles, ensuite il faut exploiter une méthode écrite dans l’exercice 1.

Exercice 3 : ( 9 points)
La Société des transports de Tunis souhaite mettre en place une application en Python permettant
d’automatiser la gestion de sa clientèle ainsi que les tarifs des tickets de transport utilisés.
Chaque client est caractérisé par les attributs:
- cin : de type chaine de caractère.
- nom : de type chaine de caractère.
- age : de type entier

Un client paie un ticket dont le tarif dépend de son âge et d’un tarif de base égal à 0.900 :

Formule de calcul du tarif des tickets selon l’âge de chaque client:

Si âge <=3 alors tarif = 0,

Si 3< âge <= 7 alors tarif = 0.3 * tarif de base,

Sinon tarif = le tarif de base

Partie 1 : écrire la classe Client, possédant:
a) Un attribut de classe TARIF_BASE égal à 0.900,
b) Un constructeur,
c) Une méthode __str__ retournant une représentation textuelle du client
selon le format : Client ( 08132456, Imen, 32 ans),
d) Une méthode calculTarif permettant de calculer le tarif du ticket du client.

3
 Partie 2
On se propose maintenant de réaliser une classe Wagon désignant un wagon du métro caractérisée par :
- code : de type entier.
- pile_clients : une Pile contenant les clients qui sont à bord du wagon, ces clients seront des
instances de la classe Client écrite dans la partie 1 ci-dessus
- cpMax : de type entier représentant la capacité maximale du wagon.

Écrire la classe Wagon fournissant :

1) Un Constructeur paramétré par le code et la capacité maximale du wagon :

ce constructeur initialise la pile des clients à une pile vide : self.pile_clients = Pile( )
il faut obligatoirement utiliser la classe Pile de l’exercice 1 pour gérer l’attribut pile_clients
2) Une méthode __str__ retournant une représentation textuelle du wagon afin d’afficher le code
du wagon ainsi que la description de tous les clients qui sont à bord du wagon comme suit:
Wagon N° 12452 avec 2 Clients à bord:
Client ( 08132456, Imen, 32 ans)
Client ( 05469182, Majdi, 45 ans)
NB: Dans votre écriture de cette méthode __str__, vous devez respecter deux conditions :
- il faut obligatoirement exploiter au moins une méthode de la classe Client
- la pile_clients ne doit pas devenir vide après l’appel de la méthode __str__

3) Une méthode monterClient permettant d’ajouter un objet client passé en paramètre dans la
pile des clients à bord du wagon.
NB : prévoir le cas de dépassement de capacité du wagon

4) Une méthode recette permettant de renvoyer le total des tarifs des tickets de tous les clients
qui sont à bord du wagon, il faut obligatoirement utiliser une méthode de la classe Client
NB : la pile_clients du wagon devient vide après l’appel de la méthode recette

4
 Université de Carthage Année universitaire :
2020/2021
Institut Préparatoire aux
Filière :SM/SP/ST
Etudes d’Ingénieurs de
Nabeul Niveau d’étude : 2ème année
Semestre : 1
Département Mathématique- Nombre de pages : 4
Informatique Date : 17/12/2020
Durée : 1h30

Alternative de correction DS 1 Informatique

Exercice 1 :(4 points)

def __contains__(self, unObjet) : 1pt

return ( unObjet in (self.__liste) )
#ou bien return (self.__liste).__contains__(unObjet)

def __add__(self, other) : # il existe de nombreuses solutions 1,5pt

pile = Pile()
for objet in (self.__liste) : pile.empiler(objet)
for objet in (other.__liste) : pile.empiler(objet)
return pile

#ou bien utiliser la concaténation des listes (list.__add_...) ou l’opérateur + sur les listes …

def __eq__(self, other) : return ( (self.__liste) == (other.__liste)) 1,5pt

#ou bien parcours en parallèle des deux listes

def __eq__(self, other) :

if(not len(self)==len(other)) : return False
for i in range(len(self.__liste)) :
if( not (self.__liste[i])==(other.__liste[i])): return False
return True

Exercice 2: (7 points)
def __len__(self): 1.5
if(self.isLeaf()) pt
return 1
elif self.left == None:
return 1 + len(self.right)
elif self.right == None:
return 1 + len(self.left)
else:
return 1 + len(self.left) + len(self.right)

1
def contains__(self, label): 2 pt
if (self.label == label):
return True
elif self.isLeaf():
return (self.label == label)
elif self.left == None:
return label in (self.right)
#ou bien return (self.right).__contains__(label)
elif self.right == None:
return label in (self.left)
#ou bien return (self.left).__contains__(label)
else: return (label in (self.left)) or (label in (self.right))
#ou bien return (self.right).__contains__(label)or (self.left).__contains__(label)

def copier_dans_pile(self, pile) :

pile.empiler(self.label) 2 pt

if self.left != None:
(self.left).copier_dans_pile(pile)

if self.right != None:
(self.right).copier_dans_pile(pile)
def __eq__(self, other) : 1,5
pt
pileSelf = Pile()

self.copier_dans_pile(pileSelf)

pileOther = Pile()

other.copier_dans_pile(pileOther)

return (pileSelf == pileOther)

#ou bien return (pileSelf).__eq__(pileOther)

2
Exercice 3 (9 points)
Partie1 : La classe Client
class Client: 1pt
TARIF_BASE = 0.9
def __init__(self,cin,nom,age):
self.cin=cin
self.nom=nom
self.age=age

def __str__ (self): 1pt

return "Client ("+ self.cin + "," + self.nom + "," +str(self.age) + "ans)"

def calculTarif(self): 1pt

if self.age <=3 : return 0
elif self.age <= 7 :
return 0.3 * Client.TARIF_BASE
else: return Client.TARIF_BASE

Partie2 : La classe Wagon

class Wagon 1pt
def__init__(self,code,cpMax):
self.code=code
self.pile_clients = Pile()
self.cpMax=cpMax

2pt
def __str__(self) :
ch="Wagon N°" + str(self.code) + "avec" +
str(len(self.pile_clients)) + "Clients à bord:" + "\n"

copie_clients = self.pile_clients.copier()
while not copie_clients.est_vide():
client = copie_clients.depiler()
ch = ch + str(client)+'\n' #ou bien ch=ch+client.__str__()+’\n’

return ch
def monterClient(self, client): 1pt
if len(self.pile_clients) < self.cpMax:
#ou bien if self.pile_clients.__len__() < self.cpMax:
self.pile_clients.empiler(client)
else:
print("impossible : capacité maximale atteinte")

3
def recette(self) : 2pt
somme = 0
while not self.pile_clients.est_vide():
client = self.pile_clients.depiler()
somme = somme + client.calculTarif()

return somme