Examen écrit de structures de données

Examen écrit de structures de données
G. Falquet, C.-L. Mottaz Jiang, semestre d’été 2001
Tous les documents sont autorisés
Durée : trois heures
Note maximum : 7 (toutes les questions valent 1 pt)
Ecrivez vos réponses directement sur l'énoncé
NOM :
_________________
PRENOM : _________________
1. Nombres entiers
On considère une machine dans laquelle les entiers sont représentés sur 14 bits en complément à
deux.
Pour chacune des expressions ci-dessous, trouvez une valeur de la variable entière x qui rende
l'expression vraie.
1. x > 0 et 8100 + x < 8100
2. x > 0 et 8191 + x = -8192
3. x > 0 et 2 * x < x
4. x > 0 et x * 4096 = 0
5. x * x < 0
2. Nombres flottants
Dans une application comptable écrite en Java, on a décidé d'utiliser le type float pour représenter
des sommes d'argent en francs et centimes.
a. Lors d'un bouclement, on doit additionner 1000 sommes comprises entre 0.01 Fr. et
999'999.99 Fr. Quelle pourra être la différence maximum entre le total exact et le total obtenu
par le programme ? Justifiez votre réponse.
b. Quel type de données faudrait-il choisir et comment faudrait-il l'utiliser pour être absolument sûr
que le résultat soit toujours exact, c'est-à-dire sans aucune imprécision aussi infime soit-elle ?
1/9
NOM: ________________
3. Types abstraits algébriques
On définit un type Spile de la manière suivante:
SPECIFICATION SPile
SORTES pile, elem
OPERATIONS vide : pile;
empiler : elem, pile pile;
depiler : pile pile
sommet : pile elem;
inverser : pile pile
AXIOMES
VAR E, E1, E2 : elem; P : pile
depiler(empiler(E,P)) == P
sommet(empiler(E,P)) == E
inverser(empiler(E1, empiler(E2, P))) == empiler(E2, empiler(E1, P))
Simplifiez au maximum les expressions suivantes en vous servant des axiomes
- a, b, c, etc. sont des constantes de la sorte elem
- P est une variable de la sorte pile
1. sommet(depiler(empiler(c, empiler(a, P))))
2. sommet(inverser(empiler(a, empiler(b, P))))
3. sommet(inverser(inverser(empiler(a, empiler(b, P)))))
4. inverser(empiler(d, inverser(empiler(c, inverser(empiler(b, empiler(a, P)))))))
5. sommet(inverser(empiler(d, inverser(empiler(c, inverser(empiler(b, empiler(a, P))))))))
6. sommet(inverser(depiler(depiler(inverser(empiler(a, empiler(b, empiler(c, P))))))))
2/9
NOM: ________________
3. Types abstraits algébriques (suite)
Expliquez pourquoi toute expression correcte (où on n'essaie pas de dépiler des piles vides, etc.) ne
contenant que les opérations empiler, dépiler et inverser peut être transformée en une expression
équivalente ne contenant que des empiler.
(Facultatif, pour les mordus)
A partir de là démontrez que pour toute pile P
- inverser(inverser(P)) == P
Remarques pour les questions 4, 5, 6 et 7
•
La définition des types Ensemble, Liste, Fonction et Iterateur est donnée en annexe. Pour les
questions 4, 5 et 6, vos solutions devront utiliser uniquement les opérations de ces types.
•
Attention: écrire un algorithme en pseudo-code ne signifie pas écrire un texte vague. Vos
algorithmes doivent être écrits très précisément et être facilement transposables dans un vrai
langage de programmation (un texte en français n’est donc pas suffisant).
3/9
NOM: ________________
4. Ensembles
Intersection d'ensembles
On a au départ deux ensembles A et B. Le but est d'obtenir un nouvel ensemble qui contiendra tous
les éléments communs à A et B.
exemple:
au départ, on a
A = {a, k, o, q, b, c, e, t}
B = {q, g, b, y, u, p, i, t, e}
on devra obtenir pour résultat l'ensemble :
{q, e, t, b}
Ecrivez un algorithme sous forme d'une séquence d'instructions en pseudo-code qui réalise
l'opération ci-dessus. On suppose que les ensembles de départ se trouvent dans des variables A et B
de type Ensemble.
4/9
NOM: ________________
5. Listes
Modification d'une liste
On a au départ une liste que l'on souhaite modifier en remplaçant un ou plusieurs de ses éléments.
On utilise une deuxième liste pour indiquer la position des éléments à remplacer dans la liste de
départ.
exemple :
la variable listeCar contient la liste [a, h, o, a, v, r, k, w, y, j, l ]
la variable listePos contient la liste [2, 5, 7, 9, 10]
remplace(listeCar, listePos, 'H')
doit retourner la liste : [a, h, H, a, v, H, k, H, y, H, H]
c'est-à-dire que l'on remplace les éléments se trouvant aux positions 2, 5, 7, 9 et 10 par le
caractère H
Ecrivez la méthode Liste remplace(Liste depart, Liste Positions, Element
e) sous forme d'une séquence d'instructions en pseudo-code. La méthode reçoit comme paramètres
la liste de départ, la liste des positions des éléments à remplacer et l'élément à utiliser pour le
remplacement.
5/9
NOM: ________________
6. Fonctions
Indexation à l'aide d'une fonction
On a au départ une liste dont certains éléments peuvent apparaître plusieurs fois. Le but est d'obtenir
une fonction qui indiquera pour chaque élément la liste de ses positions dans la liste de départ.
exemple :
si on a au départ on a une liste
L = ["ours", "chat", "chien", "chat", "serpent", "ours"]
on devra obtenir la fonction :
{ ours → [0, 5], chat → [1, 3], chien → [2], serpent → [4] }
Ecrivez un algorithme sous forme d'une séquence d'instructions en pseudo-code qui réalise
l'opération ci-dessus.
6/9
NOM: ________________
7. Arbres
On a un arbre binaire (qui contient des nombres entiers) dont la structure est définie par le type
Arbre ci-dessous :
classe Arbre
// variables d’instance
int valeur ;
// valeur du nœud racine
Arbre gauche ; // sous-arbre de gauche
Arbre droite ; // sous-arbre de droite
On veut répondre à la question : combien l'arbre compte-t-il d'entiers supérieurs à X ?
Écrivez une méthode comptePlusGrand(int x) qui explore l'arbre en profondeur et retourne
le nombre d'entiers plus grands que x contenus dans l'arbre.
exemple :
Si on a l’arbre
12
70
2
140
120
24
8
90
150
70
1
3
11
10
145
comptePlusGrand(50) doit retourner 7.
7/9
Annexes: définition des types
Type Liste d’éléments de type T (un type quelconque)
résultat
opération
paramètres
effet
Liste
new Liste
Liste
insérer
int i, T elem
insère elem à la position i
Liste
remplacer
int i, T elem
remplace le ie élément par elem
Liste
supprimer
int i
supprime l’élément à la position i
T
element
int i
element se trouvant à la position i
int
longueur
longueur de la liste
boolean
estVide
la liste est-elle vide ? (longueur = 0)
crée une liste vide
Type Ensemble d’éléments de type T
résultat
opération
paramètres
description
Ensemble
new Ensemble
booléen
ajoute
Tt
ajoute l’élément t à l’ensemble;
retourne vrai si t a été ajouté et faux si t
était déjà dans l’ensemble
booléen
retire
Tt
retire l’élément t de l’ensemble;
retourne vrai si t a été retiré et faux si t
n’était pas dans l’ensemble
int
cardinalite
cardinalité de l’ensemble
boolean
estVide
l’ensemble est-il vide ?
boolean
appartient
créer un nouvel ensemble vide
Tt
t appartient-il à l’ensemble ?
8/9
Type Fonction
résultat
Fonction
opération
paramètres
new
Fonction
effet
crée une fonction vide
lier
TD d, TA a
ajoute la paire (d  a) à la fonction
TA
delier
TD d
supprime la paire dont l’élément de départ est
d, retourne l’ancienne image de d.
int
cardinalite
cardinalité de la fonction
boolean
estVide
la fonction est-elle vide ?
boolean
estLie
TD d
vrai s’il existe une paire (d =ΚΚΚΦ=(dont d est
la clé)
TA
image
TD d
retourne l’image de d
Type Itérateur sur une collection (ensemble, liste) d’éléments de type T.
résultat
Iterateur
opération
new
Iterateur
paramètres
Collection c
effet
crée un nouvel itérateur sur la collection c
avancer
passe à l’élément suivant
T
courant
fournit l’élément courant de la collection
boolean
encore
vrai s’il reste des éléments à voir
9/9