Vous êtes sur la page 1sur 6

Lycée Victor Hugo MP* 2019-2020

TP : Utilisation des piles

Ouvrir le fichier TPPiles.py et valider la partie nommée "Primitives". Vous venez ainsi de définir
sous Python une nouvelle classe autonome d’objets : la classe Pile.

Rappelons le plus important : les six fonctionnalités de cette classe seront les seuls outils de base
que l’on s’autorisera sur ce TP ; ce sont les seules que l’on s’autorise a priori sur les piles (peu importe
leur implémentation réelle sous forme d’une classe ou d’une liste). Voici le fonctionnement de ces
méthodes :
1. Création d’une pile vide nommée MaPile :
MaPile = Pile ()

2. Test de la vacuité d’une pile


Mapile . estvide () # pour savoir si la pile est vide

3. Empiler une donnée sur MaPile :


Mapile . empiler ( donn é e )

4. Dépiler : (Attention : s’assurer que la pile est non vide !)


element = MaPile . depiler () # on d é pile la pile et on stocke le r é
sultat dans element

5. Consultation de l’élément en haut de la pile : (Attention : s’assurer que la pile est non vide !)
element = MaPile . sommet () # on consulte le sommet de la pile sans
la d é piler et on stocke le r é sultat dans element

6. Afficher la pile : cette dernière n’est généralement pas implantée mais elle vous permet dans ce
TP de mieux observer l’évolution de la pile si nécessaire
MaPile . affiche ()

1
Lycée Victor Hugo MP* 2019-2020

Par conséquent, seules les piles pourront être utilisées en tant que structure de données évoluée au
sein des codes des fonctions (et donc pas de recours aux listes, tableaux ou tuples).

Script 1 H
Créer dans le Shell une pile nommée pipile dont l’affichage produit :
In [] : pipile . affiche ()

2015
True
12
lvh
34
Dans les exercices suivants, les algorithmes sont rarement donnés afin de vous faire réfléchir aux
algorithmes utilisés (parfois inconsciemment) pour réaliser certaines tâches.

I Manipulations d’une pile


1 Copie
Script 2 H

Écrire une fonction copy qui prend en argument une pile P et qui renvoie une copie de P .
Attention la pile P doit être conservée !
Tester votre fonction sur pipile et vérifier que pipile n’est pas modifiée.

2 Inverse
Script 3 H

Écrire une fonction inverse qui prend en entrée une pile P et qui renvoie une pile dont les éléments
sont dans l’ordre inverse de ceux de la pile P.
Attention , la pile P doit être conservée !
Question 4 H
Complexité : Quel est le nombre d’opérations effectuées par inverse ? On notera L le nombre
d’éléments de la pile P .

3 Permutation Circulaire
Script 5 H

Écrire une fonction permcirc qui prend en entrée une pile P et un entier n et qui effectue sur la pile
n permutations circulaires successives.
Ici, la pile P est donc modifiée.
Par exemple avec n = 2 :
7 98
11 2
98 sera transformée en 103
2 7
103 11
Question 6 H
Complexité : Quel est le nombre d’opérations effectuées par permcirc ? On notera L le nombre
d’éléments de la pile P .

2
Lycée Victor Hugo MP* 2019-2020

II Mélange de piles
On souhaite mélanger deux piles (paquets cartes par
exemple) en une troisième pile de la façon suivante : tant
qu’une pile que l’on mélange au moins n’est pas vide, on
retire aléatoirement un élément au sommet d’une des deux
piles et on l’empile sur la pile résultat, sinon on retire
l’élément de la pile non vide restante. A l’issue du mélange,
les deux piles de départ sont vides, tous les éléments (cartes)
sont dans la pile résultat.

Script 7 H

Écrire une fonction melange qui prend en arguments deux piles et qui mélange leurs éléments dans
une troisième pile (qui sera la valeur renvoyée par la fonction) de la manière décrite précédemment
Pour simuler le hasard, on pourra utiliser la fonction randint de la bibliothèque numpy.random (impor-
tée sous le nom rd) : l’expression rd.randint(a,b) retourne alors un entier au hasard dans l’intervalle
[[a : b[[.

III Un peu de galanterie

On considère une pile de dossiers sur un bureau.

Un dossier est en fait un enregistrement sur un assuré


social et chaque enregistrement est constitué d’informations
concernant le nom, le sexe, la date de naissance d’une per-
sonne.
On désire réarranger les enregistrements de telles ma-
nière que les enregistrements de personnes de sexe féminin
précèdent ceux de sexe masculin.

L’ensemble des enregistrements sera donné sous la forme d’une liste de tuples (nom,sexe,date)
où nom est une chaîne de caractères, sexe est un entier (1 pour homme, 2 pour femme), et date
est une chaîne de caractères "JJMMAAAA" codant la date de naissance. Les tuples ne sont pas au
programme, mais leur utilisation est simple : on récupère le premier élément du tuple MonTuple par
MonTuple[0], le second élément par MonTuple[1] etc.

Un tri a déjà été effectué sur la pile d’enregistrements puisqu’ils ont été empilés par ordre décrois-
sant de date de naissance (le plus âgé est au sommet et le plus jeune en bas de la pile).
Valider la suite d’instructions présentes dans le fichier TPPiles.py permettant de construire la pile
nommée virtuoses. Afficher cette pile !

Script 8 H

Écrire la fonction galanterie qui, lorsque virtuoses sera placé en argument, retourne une pile des
enregistrements de virtuoses dans laquelle les femmes précèdent les hommes.
On conservera le tri suivant la date de naissance pour les femmes d’une part et pour les hommes
de l’autre, et enfin, on utilisera une seule pile comme intermédiaire(pour ne pas encombrer le
bureau ! ! ! !).
Ne pas oublier de tester votre fonction !

3
Lycée Victor Hugo MP* 2019-2020

IV Analyseur syntaxique : expressions bien parenthésées


L’analyse syntaxique est une phase indispensable de la compilation des programmes. Les piles sont
particulièrement bien adaptées à ce genre de traitements. On va se limiter à la reconnaissance des
mots bien parenthésés.
Nous devons écrire un programme qui :
— accepte les expressions comme (a), (a b)((c d e)) ou (((a)(b c d))(e)) où a, b, etc. sont
des expressions quelconques sans parenthèse ;
— rejette les expressions comme a )(, (a b)((c) ou (((a b)(c d e f)))) ;

Comme les expressions a, b qui apparaissent n’ont aucune importance pour savoir si l’expression
est bien parenthésée, on donnera l’expression à tester sous forme d’une chaîne de caractères dont on
rappelle qu’on peut la parcourir comme une liste. Par exemple
expression = " ((( a ) ( b c d ) ) ( e ) ) "

Question 9 H

Élaborer un algorithme utilisant une pile pour déterminer si une expression est bien parenthésée.

Script 10 H

Écrire la fonction balanced qui rend True ou False suivant que l’expression expr donnée en
argument est bien parenthésée ou non.
Tester votre fonction sur de petits exemples.

Question 11 H
Ci dessous se trouvent écrits en LISP deux programmes. Tester votre fonction balanced sur les deux
expressions imposantes correspondantes déjà écrites dans le fichier TPPiles.py .
Sont-elles bien parenthésées ?

Tout d’abord, un programme dit de "tri rapide" :


( defun qsort - list ( l & key ( test # ’ <) ( key # ’ identity ) )
( if ( null l )
’ ()
( macrolet (( k ( x ) ‘( funcall key ,x ) )
( less ( x y ) ‘( funcall test ,x ,y ) ) )
( loop with pivot = ( k ( elt l ( floor ( length l ) 2) ) )
with smaller = ’ ()
with equal = ’ ()
with larger = ’ ()
for rest = ( cdr l ) then ( cdr l )
while l
do ( cond (( less ( k ( car l ) ) pivot )
( setf ( cdr l ) smaller
smaller l ) )
(( less pivot ( k ( car l ) ) )
( setf ( cdr l ) larger
larger l ) )
(t
( setf ( cdr l ) equal
equal l ) ) )

4
Lycée Victor Hugo MP* 2019-2020

( setf l rest )
finally ( return ( nconc ( qsort - list smaller )
equal
( qsort - list larger ) ) ) ) ) ) )

Ensuite un programme dit de "tri par paquets" :


( defun bucketsort ( vector & key ( key # ’ identity ) )
( macrolet (( k ( x ) ‘( funcall key ,x ) )
( s ( x ) ‘( aref start ,x ) )
( e ( x ) ‘( aref end ,x ) )
( v ( x ) ‘( aref vector ,x ) ) )
( let * (( min ( v 0) )
( max min ) )
;; compute min and max elements
( loop for i from 1 below ( length vector )
do ( setf min ( min min ( k ( v i ) ) )
max ( max max ( k ( v i ) ) ) ) )
( let (( start ( make - array ( list (1+ ( - max min ) ) )
: initial - element 0) )
( end ( make - array ( list (1+ ( - max min ) ) )
: initial - element 0) ) )
;; count the number of elements of each key
( loop for elem across vector
do ( incf ( e ( - ( k elem ) min ) ) ) )
;; compute end positions
( loop for i from 1 below ( length end )
do ( incf ( e i ) ( e (1 - i ) ) ) )
;; compute start positions
( loop for i from 1 below ( length start )
do ( setf ( s i ) ( e (1 - i ) ) ) )
;; sort the elements
( loop for i from 0 below ( length start )
do ( loop while ( < ( s i ) ( e i ) )
do ( let (( pos ( - ( k ( v ( s i ) ) )
min ) ) )
( rotatef ( v ( s i ) )
( v ( s pos ) ) )
( incf ( s pos ) ) ) ) ) ) ) )
vector )

5
Lycée Victor Hugo MP* 2019-2020

V Calculatrice en Notation Polonaise Inversée


On souhaite écrire un simulateur de calculatrice utilisant la notation polonaise inversée selon le
principe décrit en cours. Le programme demandera la saisie par la fonction input des opérateurs et
des opérandes. À chaque saisie le programme affichera l’état de la pile : après la saisie d’un nombre
on affiche la pile avec simplement ce nouveau nombre au sommet, après la saisie d’un opérateur on
affiche l’état de la pile après application de l’opération sur les opérandes.
On se limitera aux quatres opérations +,-,*,/. On précise que a b - calcule a-b et que a b /
calcule a/b.
On tapera & pour indiquer la fin du calcul au simulateur qui affichera alors le sommet de la pile.
Petit Rappel : la fonction input renvoie une chaîne de caractères.

Script 12 H
Coder la fonction calculatriceNPI() que l’on doit appeler pour lancer le simulateur.

Vous aimerez peut-être aussi