Vous êtes sur la page 1sur 169

Questions d'examens de Structures de données ainsi que leurs corrigés

Questions d'examens de Structures de

données

ainsi que leurs corrigés

Contrôle continu du 7 mai 2001 (notes)

Arbre lexicographique

Arbre de tri

Examen écrit du 4 octobre 2000 (notes)

Arbres + chaînes

Les listes

Les B-arbres

Examen écrit du 3 juillet 2000 (notes)

Conversion arbre-chaîne

Arbres multiples

Listes

Graphes orientés

Contrôle continu du 22 juin 2000 (notes)

Fermeture transitive

Graphe orienté

parcours d'un B-arbre

Contrôle continu du 11 mai 2000 (notes)

Chaînes

Chaînes

Arbre de tri

Questions d'examens de Structures de données ainsi que leurs corrigés

Examen écrit du 28 février 2000

Structures statiques

Anneaux bidirectionnels

Arbres dépliables

B-arbres

Examen écrit du 11 octobre 1999

Anneaux bidirectionnels

Arbres

Listes

Chemin le plus court dans un graphe

Examen écrit du 30 juin 1999 (notes)

Anneaux bidirectionnels

Arbres dépliables

Le chemin le plus court

Hash-Coding

Contrôle continu du 14 juin 1999 (notes)

Graphes orientés

B-Arbres

Adressage associatif par transformation de clés (Hash-code)

Contrôle continu du 29 avril 1999 (notes)

Chaînes bidirectionelles

Arbre lexicographique

Examen écrit de février 1999

Questions d'examens de Structures de données ainsi que leurs corrigés

Examen écrit du 7 octobre 1998

Arbre binaire

Structures de graphes orientés (tri topologique inverse)

comparaison de B-arbres et B*-arbres

Hash-coding

Examen écrit du 25 juin 1998

Arbres dépliables

Recherche dichotomique

Hash-coding

Tables de décision

Contrôle continu du 15 juin 1998

Fichiers séquentiels indexés

Recherche dans un B-arbre

Le chemin du moindre coût

Contrôle continu du 4 mai 1998

Chaînes bidirectionnelles

Chaînes mono-directionnelles

Anneaux bidirectionnels

Arbre syntaxique

Examen écrit de février 1998

arbre dépliable de tri

Fichiers séquentiels indexés

Examen écrit du 13 octobre 1997

Structures de graphes

un réseau de transport

Questions d'examens de Structures de données ainsi que leurs corrigés

Examen écrit de juillet 1997

Arbres binaires

Graphe orienté

B-arbre

Contrôle continu du 16 juin 1997

Arbre lexicographique

Hash-code

Tables de décision

Contrôle continu du 28 avril 1997

Chaînes bidirectionnelles

Chaînes bidirectionnelles

Arbre généalogique

Examen écrit du 5 mars 1997

Tri dans une chaîne

Arbres syntaxiques et chaînes

B-arbre

Examen écrit du 15 octobre 1996

Chaînes bidirectionnelles

Fichiers séquentiels indexés et B-arbres

Examen écrit du 9 juillet 1996

Chaînes mono-directionnelles

Réseau autoroutier

Questions d'examens de Structures de données ainsi que leurs corrigés

Contrôle continu du 17 juin 1996

Anneaux bidirectionnels

Arbre de tri

Tri topologique inverse

B-arbre

Contrôle continu de mars 1996

Structure de chaîne

Contrôle continu du 20 juin 1995

Chaînes bidirectionnelles

Arbre lexicographique

Plus courts chemins dans un graphe

Description du cours "Structures de donnees"

TITRE: STRUCTURES DE DONNEES Enseignant: Bertrand Ibrahim (MER) No: 1803 Heures totales: 84 Par semaine:
TITRE: STRUCTURES DE DONNEES
Enseignant: Bertrand Ibrahim (MER)
No: 1803
Heures totales: 84
Par semaine:
Cours: 4 Exercices: 2
Pratique:
Destinataire
licence informatique
diplôme informatique
certificat . info et stat.
dipl. math.info.
Semestre
Oblig.
Facult.
Option
Crédits
2
10
2
10
2
10
4

Objectifs

Ce cours a pour but d'introduire un panorama des structures de données complexes en suivant l'approche de la programmation procédurale.

Contenu

Note: un calendrier d'avancement dans le cours est disponible pour vous permettre de déterminer ce qui a été abordé à chaque leçon.

structures de données statiques, types abstraits, notion de pointeur,

structures dynamiques fondamentales:

chaînes (monodirectionnelles, bidirectionnelles), anneaux (monodirectionnels, bidirectionnels), piles, files d'attentes,

listes généralisées,

arbres ,

graphes

algorithmes de construction, de parcours et de manipulation; représentations internes, opérations de base,

transformation de clés et «hash-coding»,

structures complexes: séquentiel indexé et B-arbres,

tables et arbres de décision.

Forme de l'enseignement:

Cours ex-cathedra, exercices, travaux pratiques

Description du cours "Structures de donnees"

Evaluation:

Contrôles continus :

lundi 7 mai 2001 de 14h00 à 16h00, auditoire U600 (Uni Dufour, 1er sous-sol) - notes

jeudi 21 juin de 14h00 à 16h00, salle 259

Examen écrit, juillet

Note: dans les deux formes d'évaluation des étudiants (contrôle continu ou examen écrit), la note sera laissée en suspend jusqu'à avoir satisfait aux exigences des travaux pratiques (avoir 75% des TPs acceptés par l'assistant).

Encadrement:

Bertrand Ibrahim (bur. 350), Wolfgang Müller (bur. 336), Yvan Petroff (bur. 306).

Documentation:

livre support de cours et liste d'ouvrages de référence. Liste des questions d'examens avec leurs corrigés. Enregistrements sonores

Liaison avec d'autres cours:

Préalable requis: Algorithmique ou Introduction à l'informatique.

Préparation pour: informatique théorique, initiation à la recherche opérationnelle et langages informatiques.

19.04.01

Notes du contrôle continu du 7 mai 2001

Notes du contrôle continu du 7 mai 2001

Nom Q1 Q2 Note ALBUQUERQUE Michel 5 19 2,3 BAERTSCHIGER Didier 30 35 6,0 BELKABIR
Nom
Q1
Q2
Note
ALBUQUERQUE Michel
5
19
2,3
BAERTSCHIGER Didier
30
35
6,0
BELKABIR M??
3
0
0,3
BOUDJNANE Yassin
13
26
3,9
BRUNSCHWIG Guillaume
4
2
0,6
CABY Gerda
1
14
1,5
CHARPILLOZ Christophe
25
16
4,1
COSTANITA Rodrigue
9
23
3,2
DUCIMETIERE Jérôme
1
29
3,0
EL HASNAOUI Hassan
4
10
1,4
EMIYAN Stéphane
15
29
4,4
ETIENNE Julien
20
27
4,7
FERROUKHI Sid-Ahmed
0
13
1,3
FIRST Jean
22
33
5,5
FONTIGNIE Jacques
30
29
5,9
GULATI Asheesh
22
35
5,7
JAMES Mélanie
30
35
6,0
JOSS Olivier
30
27
5,7
LAGROUNI Kamal
25
24
4,9
MAGPANTAY Tristan
19
29
4,8
MARQUIS Samuel
22
29
5,1
NGUYEN Duy
22
29
5,1
Répartition des notes [5,5-6,0] xxxxx xxxx [5,0-5,5[ xxxxx x [4,5-5,0[ xxxxx xx [4,0-4,5[ xxxx [3,5-4,0[
Répartition des notes
[5,5-6,0] xxxxx xxxx
[5,0-5,5[ xxxxx x
[4,5-5,0[ xxxxx xx
[4,0-4,5[ xxxx
[3,5-4,0[ xxx
[3,0-3,5[ xxxxx
[2,5-3,0[
[2,0-2,5[ x

Notes du contrôle continu du 7 mai 2001

NGUYEN Thi Anh Thu 25 12 3,7 PINEIRO Elvis 25 22 4,7 PORTA Jonathan 9
NGUYEN Thi Anh Thu
25
12
3,7
PINEIRO Elvis
25
22
4,7
PORTA Jonathan
9
29
3,8
PRAPLAN Christophe
22
30
5,2
QUANG Anh
15
26
4,1
REVERDON Ludovic
4
26
3,0
RIVERA CAMACHO Ernesto A.
25
35
6,0
ROSSET Giles
27
35
6,0
SARTORETTI Fabien
25
26
5,1
SAYAH Saïd
15
26
4,1
SCHALLER Cynthia
25
28
5,3
STURB Ronald
1
14
1,5
SUHNER Thierry
12
35
4,7
STRUMIELLO Olivier
24
24
4,8
TUVERI Jairo
25
24
4,9
UMER Ali
4
26
3,0
VILLALBA Alfredo
30
35
6,0
VILLASUSO Pablo
22
29
5,1
WANG ia Ying
12
18
3,0

Dernière modification: 15.06.01

[1,5-2,0[ xx [1,0-1,5[ xx [0,5-1.0[ x [0-0,5[ x
[1,5-2,0[ xx
[1,0-1,5[ xx
[0,5-1.0[ x
[0-0,5[
x

Structuration des Données Informatiques - 8.2, exercice 5

Arbre lexicographique

Question posée au contrôle continu du 7 mai 2001

On a construit un arbre multiple d'ordre 26 permettant de stocker des mots d'un dictionnaire de façon que les chemins partant de la racine représentent des mots du dictionnaire, de la façon suivante

des mots du dictionnaire, de la façon suivante Les arcs sont étiquettés avec les lettres de

Les arcs sont étiquettés avec les lettres de l'alphabet (on suppose ici que l'on ne tient pas compte des accents sur les lettres) et les noeuds contiennent un booléen indiquant si le chemin de la racine à ce noeud représente un mot complet ou pas (sur le dessin - = faux et * = vrai).

Sur la base des déclarations suivantes, écrivez une fonction Trouve indiquant si un mot se trouve dans le dictionnaire. type VersNoeud= ^Noeud; Noeud= record

Desc: array['a' Complet: boolean; end; { Noeud } var Dico: VersNoeud;

'z']

of VersNoeud;

function Trouve(Mot: string; Dico: VersNoeud):boolean;

Solution

Structuration des Données Informatiques - 8.1, exercice 8

Arbre de tri

Question posée au contrôle continu du 7 mai 2001

Complétez le code des procédures ajouteElement, sommeArbre et produitArbre. La procédure accumulerArbre est facultative et vaut un bonus de 5 points.

{

Ajoutez le code necessaire

}

program completer;

type pElement = ^TElement; TElement = record mContenu

: integer;

mDroite,mGauche : pTElement; end; { TElement } {un type de FONCTION} TFonction = function(x, y:integer):integer;

var

gRacine: pElement; i,gSomme,gProduit, gNouveau : integer;

{

multiplier:

Cette fonction multiplie deux nombres entiers

parametres:

inX, inY: les deux nombres a multiplier

resultat:

inX*inY

}

function multiplier(inX,inY:integer):integer; begin multiplier:=inX*inY;

end; { multiplier }

{

ajouter:

Cette fonction ajoute inX a inY

parametres:

inX, inY: les deux nombres a additionner

resultat:

Structuration des Données Informatiques - 8.1, exercice 8

inX+inY

}

function ajouter(inX,inY:integer):integer; begin ajouter:=inX+inY; end; { ajouter }

{----------------------------------------

gestion d'arbres ----------------------------------------}

{

creeElement_Contenu

Cette fonction cree un nouveau element d'un arbre avec un contenu donné.

Les pointeurs de l'element a creer vont etre mis a NIL.

parametres:

inNouveauContenu : le contenu de l'element a creer

var outElement:

}

le pointeur sur l'element cree

procedure creeElement_Contenu(inNouveauContenu : integer;

var outElement

: pElement);

begin new(outElement); outElement^.mDroite:=nil; outElement^.mGauche:=nil; outElement^.mContenu:=inNouveauContenu; end; { creeElement_Contenu }

{

Ajoute un element a l'arbre pour que l'arbre soit un arbre de tri, les elements les plus petits a gauche.

parametres:

inNouveauContenu: le contenu de l'element a ajouter

inoutRacine:

la racine de l'arbre a qui un element va etre ajoute

}

procedure ajouteElement(inNouveauContenu:integer; var inoutRacine: pElement);

begin

{QUESTION:

Structuration des Données Informatiques - 8.1, exercice 8

AJOUTEZ LE CODE NECESSAIRE POUR QUE ajouteElement FASSE CE QUI EST DIT DANS LE COMMENTAIRE.

Vous n'avez pas besoin de variables supplementaires. Toutefois, on autorise l'ajout de variables LOCALES.

}

end; { ajouteElement }

{

Cette procedure calcule la somme de tous les elements dans l'arbre et l'ajoute a inoutSomme

parametres:

var inoutSomme: le parametre d'entree et le resultat

var inRacine:

la racine de l'arbre a traiter

}

procedure sommeArbre(var inoutSomme:integer; var inRacine: pElement);

begin

{QUESTION:

AJOUTEZ LE CODE NECESSAIRE POUR QUE sommeArbre FASSE CE QUI EST DIT DANS LE COMMENTAIRE.

Vous n'avez pas besoin de variables supplementaires. Toutefois, on autorise l'ajout de variables LOCALES.

}

end; { sommeArbre }

{

La procedure qui suit calcule le produit de tout les elements dans l'arbre et le multiplie avec inoutProduit

parametres:

var inoutProduit: le parametre d'entree et le resultat

var inRacine:

la racine de l'arbre a traiter

}

procedure produitArbre(var inoutProduit:integer; var inRacine: pElement);

begin

{QUESTION:

AJOUTEZ LE CODE NECESSAIRE POUR QUE produitArbre FASSE CE QUI EST DIT DANS LE COMMENTAIRE.

}

Structuration des Données Informatiques - 8.1, exercice 8

end; { produitArbre }

{

La procedure qui suit traverse l'arbre en-ordre et applique inFonction au contenu de la racine et inoutAccumulateur dans la maniere suivante:

parametres:

inoutAccumulateur: contient un nombre entier apres l'appel il contient le resultat de l'appel inFonction: contient une fonction de type TFonction; inRacine: contient la racine d'un arbre de tri genere par ajouteElement

Car inRacine contient un arbre de tri, les elements de l'arbre sont trie du plus petit au plus grand si on fait un parcours en-ordre:

n_1 < n_2 <

< n_m

sont les numeros de visite, donc n_1 est visite avant n_2, n_3 etc.

1

m

Apres un apel d'accumulerArbre avec

inoutAccumulateur=i,

inFonction=f,

et un arbre comme parametre,

inoutAccumulateur va contenir:

inoutAccumulateur=f(n_m,f(

}

,f(n_2,f(n_1,i))))

procedure accumulerArbre(var inoutAccumulateur : integer; inFonction : TFonction; var inRacine: pElement);

begin {QUESTION FACULTATIVE:

AJOUTEZ LE CODE NECESSAIRE POUR QUE accumulerArbre FASSE CE QUI EST DIT DANS LE COMMENTAIRE.

Vous n'avez pas besoin de variables supplementaires. Toutefois, on autorise l'ajout des variables LOCALES.

Structuration des Données Informatiques - 8.1, exercice 8

}

end; { accumulerArbre }

{

SI TOUS LES QUESTIONS SONT BIEN RESOLUES, LE PROGRAMME DOIT AFFICHER TROIS FOIS

LES MEMES gSomme ET gProduit RESPECTIVEMENT

}

begin gRacine:=nil;

gSomme:=0;

gProduit:=1;

{

cree arbre aleatoire de 4 elements

}

for i:=1 to 4 do begin

gNouveau:=random(10)+1;

ajouteElement(gNouveau, gRacine);

+ gNouveau;

gProduit:= gProduit * gNouveau; end; { for }

gSomme:= gSomme

write('gSomme:');

write('gProduit:'); writeln(gProduit);

gSomme:=

gProduit:= 1; sommeArbre(gSomme, gRacine);

produitArbre(gProduit, gRacine);

write('gSomme:');

write('gProduit:'); writeln(gProduit);

writeln(gSomme);

0;

writeln(gSomme);

gSomme:= 0; gProduit:= 1; accumulerArbre(gSomme, ajouter, gRacine); accumulerArbre(gProduit, multiplier, gRacine); write('gSomme:'); writeln(gSomme); write('gProduit:'); writeln(gProduit); end.

Solution

Notes du contrôle continu du 22 juin 2000

Notes de l'examen du 4 octobre 2000

Nom Q1 Q2 Q3 Note Albuquerque Paul absent Bajrami Gent 5 12 11 3,0 Ben
Nom
Q1
Q2
Q3
Note
Albuquerque Paul
absent
Bajrami Gent
5
12
11
3,0
Ben Hadj Noureddine
absent
Benkacem Omar
5
20
13
en attente des TPs
Benouataf Khalil
0
0
9
1,0
Coron Olivier
10
30
13
5,5
Londo Ilia
5
18
5
en attente des TPs
Maddi Brahim
3
6
3
1,0
Nguyen Thi Amh Thu
4
8
7
2,0
Schaller Cynthia
8
1
11
2,0

Dernière modification: 27.10.00

Répartition des notes [5,5-6,0] x [5,0-5,5[ [4,5-5,0[ [4,0-4,5[ x [3,5-4,0[ [3,0-3,5[ xx [2,5-3,0[ [2,0-2,5[
Répartition des notes
[5,5-6,0]
x
[5,0-5,5[
[4,5-5,0[
[4,0-4,5[
x
[3,5-4,0[
[3,0-3,5[
xx
[2,5-3,0[
[2,0-2,5[
xx
[1,5-2,0[
[1,0-1,5[
xx
[0,0-1,0[

Structuration des Données Informatiques - 8.1, exercice 7

Exercice suivant

Arbres + chaînes

Question posée à l'examen écrit du 4 octobre 2000

Soit une structure d'arbre de tri et une structure de chaîne bidirectionnelle représentées par les déclarations suivantes:

type pNoeudArbre = ^NoeudArbre; NoeudArbre = record nombre: integer; gauche, droite: pNoeudArbre; end; { NoeudArbre }

PtrNoeudCh = ^NoeudCh; NoeudCh = record Element: pNoeudArbre; Precedent, Suivant: PtrNoeudCh; end; { NoeudCh }

Ecrivez une fonction "Chemin" qui prend en paramètre un arbre et une valeur et retourne en résultat une chaîne pointant sur les éléments successifs de l'arbre qui auront été examinés pour trouver la valeur dans l'arbre de tri:

function Chemin(MonArbre: pNoeudArbre; MaValeur: integer): PtrNoeudCh;

Il faut bien entendu traiter tous les cas particuliers, p.ex. si l'arbre est vide la chaîne sera vide, si la valeur fournie n'existe pas dans l'arbre, il faudra retourner le chemin parcouru jusqu'à trouver que la valeur ne se trouve pas dans l'arbre.

Solution

Exercice suivant

Structuration des Données Informatiques - 9.1, exercice 3

Listes

Question posée à l'examen du 4 octobre 2000

{

Voici un programme qui gère les listes à la façon de Scheme

}

program liste_scheme;

type PPaireOuValeur = ^TPaireOuValeur; TPaireOuValeur = record mEstValeur : boolean;

mValeur

: integer;

mPremier

: PPaireOuValeur;

mDeuxieme : PPaireOuValeur; end;

var i

: integer;

gChaine : PPaireOuValeur;

function cons_paire_paire(inPremier, inSecond: PPaireOuValeur) : PPaireOuValeur; var lResultat: PPaireOuValeur; begin new(lResultat); lResultat^.mEstValeur:=false; lResultat^.mPremier:= inPremier; lResultat^.mDeuxieme := inSecond; cons_paire_paire:=lResultat; end; { cons_paire_paire }

function cons_integer_paire(inPremier: integer; inSecond: PPaireOuValeur): PPaireOuValeur; var lInteger: PPaireOuValeur; begin new(lInteger);

lInteger^.mEstValeur:=true;

lInteger^.mValeur:=inPremier;

cons_integer_paire:=cons_paire_paire(lInteger,inSecond);

end; { cons_integer_paire }

function cons_integer_integer(inPremier : integer; inSecond: integer): PPaireOuValeur;

Structuration des Données Informatiques - 9.1, exercice 3

var lInteger : PPaireOuValeur;

: PPaireOuValeur;

begin

lPaire

new(lInteger);

lInteger^.mEstValeur:=true;

lInteger^.mValeur:=inSecond;

cons_integer_integer:=cons_integer_paire(inPremier,lInteger); end; { cons_integer_integer }

{

QUESTION:

Ecrivez une fonction qui crée une liste à la façon de Scheme avec les entiers dans l'intervalle de inBegin à inEnd.

cree_chaine(5,8) devrait retourner l'equivalent de (list 5 6 7 8). cree_chaine(5,5) devrait retourner l'equivalent de (list 5), cree_chaine(5,4) devrait donner nil comme resultat.

}

function cree_chaine(inBegin,inEnd : integer ):PPaireOuValeur; var lLastCreated: PPaireOuValeur; var i: integer; begin

{

 

<VOTRE SOLUTION ICI>

}

end;

{

QUESTION:

Créez une procedure qui parcourt et affiche des chaînes simples à la Scheme de façon à donner p.ex. pour affiche_chaine(cree_chaine(5,7))

la procédure affiche "(5 6 7)" à l'écran

La procedure peut être limitée aux chaines simples

(pas de listes imbriquées, donc p.ex. "(list 1 2 3 4)" mais pas "(cons (list 1 2) (list 3 4))")

}

procedure affiche(inPaireOuValeur: PPaireOuValeur);

var lCourant: PPaireOuValeur; begin

{

Structuration des Données Informatiques - 9.1, exercice 3

<VOTRE SOLUTION ICI>

}

end; { affiche }

begin

gChaine:=cree_chaine(1,10);

writeln('Chaine cree'); affiche(gChaine);

affiche(cree_chaine(5,8));

affiche(cons_paire_paire(cree_chaine(1,2),

end.

cons_integer_integer(3,4)));

Structuration des Données Informatiques - 14.3, exercice 8

Les B-Arbres

Question posée à l'examen du 4 octobre 2000 . Soit le B-arbre d'ordre 2 suivant, dessinez le B-arbre résultant de l'insertion de la valeur 25:

le B-arbre résultant de l'insertion de la valeur 25: b. Avec le même B-arbre de départ

b. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de l'insertion de la valeur

20

c. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de l'insertion de la valeur

14

d. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de l'insertion de la valeur 6

e. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de la suppression de la valeur 60

f. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de la suppression de la valeur 63

g. Avec le même B-arbre de départ qu'en (a), dessinez le B-arbre résultant de la suppression de la valeur 80

Solution

Notes du contrôle continu du 22 juin 2000

Notes de l'examen du 3 juillet 2000

Nom Q1 Q2 Q3 Q4 Note Bajrami Gent 6 15 2 0 2,5 Ben Hadj
Nom
Q1
Q2
Q3
Q4
Note
Bajrami Gent
6
15
2
0
2,5
Ben Hadj Noureddine
2
8
0
0
1,0
Benkacem Omar
5
6
5
0
1,5
Benouataf Khalil
0
11
0
0
1,0
Bobo Ngawouo Aimé Patrick
0
1
2
0
0,5
Braik Ahcene
10
15
0
4
3,0
Buhler Stéphane
10
13
10
7
4,0
Coron Olivier
8
13
5
2
3,0
Etienne Julien
12
13
11
9
4,5
Habachi Arash
6
4
15
13
4,0
Maddi Brahim
3
6
2
0
1,0
Nguyen Thi Amh Thu
1
12
0
0
2,5
Petrini Geo
12
0
13
0
2,5
Schaller Cynthia
6
12
0
0
2,0

Dernière modification: 21.07.00

Répartition des notes [5,5-6,0] [5,0-5,5[ [4,5-5,0[ x [4,0-4,5[ xx [3,5-4,0[ [3,0-3,5[ xx [2,5-3,0[ xxx
Répartition des notes
[5,5-6,0]
[5,0-5,5[
[4,5-5,0[
x
[4,0-4,5[
xx
[3,5-4,0[
[3,0-3,5[
xx
[2,5-3,0[
xxx
[2,0-2,5[
x
[1,5-2,0[
x
[1,0-1,5[
xxx
[0,0-1,0[
x

Structuration des Données Informatiques - 8.1, exercice 6

Exercice suivant

Conversion arbre-chaîne

Question posée à l'examen écrit du 3 juillet 2000

Soit une structure d'arbre de tri et une structure de chaîne bidirectionnelle représentées par les déclarations suivantes:

type pNoeudArbre = ^NoeudArbre; NoeudArbre = record nombre: integer; gauche, droite: pNoeudArbre; end; { tNoeudArbre }

PtrNoeudCh = ^NoeudCh; NoeudCh = record Donnee: integer; Precedent, Suivant: PtrNoeudCh; end;

Ecrivez une fonction "Conversion" qui prend en paramêtre un arbre et retourne en résultat une chaîne contenant les valeurs de l'arbre dans l'ordre croissant.

Solution

Exercice suivant

Structuration des Données Informatiques - 8.2, exercice 4

Exercice suivant

Arbre multiple

Question posée à l'examen écrit du 3 juillet 2000

Le langage XML est un langage de balises destiné à succéder au langage HTML. En simplifiant, on peut dire qu'un document XML contient un élément racine. Cet élément racine est un élément complexe, c'est-à-dire qu'il contient un ou plusieurs autres éléments. Chaque élément est soit du texte simple, soit un élément vide composé uniquement d'une balise de la forme "<NomBalise />", soit un élément complexe délimité, à son début, par une balise d'ouverture de la forme "<NomBalise>", à sa fin, par une balise de fermeture de la forme "</NomBalise>" et contenant, entre deux, une succession d'éléments.

Un document XML peut être vu comme une structure arborescente du type arbre multiple. En supposant que <X>Y</X> est représenté par

supposant que <X>Y</X> est représenté par en appliquant cette représentation récursivement et et en

en appliquant cette représentation récursivement et et en tenant compte des différentes possibilités de représenter des arbres multiples, dessinez deux représentations arborescentes différentes pour le document suivant:

<article> <titre>Un journaliste <souligne>accuse</souligne>, un policier <souligne>dément</souligne></titre> <auteur>Alain Connu</auteur> <date>14 juin 1972</date> <lieu>banquise</lieu> <texte> <grand>Un journaliste de la place accuse</grand> les autorités </texte> </article>

Solution

Exercice suivant

Structuration des Données Informatiques - 9.1, exercice 2

Exercice suivant

Listes

Question posée à l'examen du 3 juillet 2000 program SchemeList;

{

une structure qui peut contenir soit une valeur, soit une paire

}

type PSchemePaireOuValeur = ^TSchemePaireOuValeur; TSchemePaireOuValeur = record

{ le record contient-il une valeur } mEstValeur:boolean;

{si ce record est une valeur} mValeur : integer;

{si ce record est une paire}

{ car de la paire}

mCar : PSchemePaireOuValeur;

{ cdr de la paire }

mCdr : PSchemePaireOuValeur; end; { TSchemePaireOuValeur }

var gSchemePaire: PSchemePaireOuValeur;

{

Une fonction qui cree une valeur

}

function creeValeur(inValeur : integer): PSchemePaireOuValeur;

var lResultat : PSchemePaireOuValeur; begin new(lResultat); lResultat^.mEstValeur:=true; lResultat^.mValeur:=inValeur; lResultat^.mCar:=nil; lResultat^.mCdr:=nil; creeValeur:=lResultat; end; { creeValeur }

{

Une fonction qui cree une paire

}

function creePaire(inCar,inCdr: PSchemePaireOuValeur):PSchemePaireOuValeur; var lResultat : PSchemePaireOuValeur; begin new(lResultat); lResultat^.mEstValeur:=false;

Structuration des Données Informatiques - 9.1, exercice 2

lResultat^.mValeur:=0;

lResultat^.mCar:=inCar; lResultat^.mCdr:=inCdr; creePaire:=lResultat; end; { creePaire }

{

Une procedure pour afficher

}

procedure display(inPaire : PSchemePaireOuValeur); {vous etes autorise(es) de mettre des variables ici} begin {Mettez votre code ici. Les commentaires du programme principal vous indiquent ce que la procedure Display est censee imprimer} end;

begin

gSchemePaire:=creePaire(creeValeur(1),

creePaire(creeValeur(2),

creePaire(creeValeur(3),nil)));

display(nil)

writeln; display(gSchemePaire); {donne "(1 . (2 . (3 . ())))"}

{donne "()"};

gSchemePaire:=creePaire(creePaire(creeValeur(1),

creeValeur(2)),

creePaire(creeValeur(3),

creeValeur(4)));

writeln; display(gSchemePaire); {donne "((1.2).(3.4))"} end.

Solution

Exercice suivant

Structuration des Données Informatiques - 11. exercice 4

Graphe orienté

Question posée à l'examen écrit du 3 juillet 2000

L'on modélise un planning à l'aide des structures suivantes :

var

Debut: array [1

NbTaches]

of Integer;

{ pour chaque tâche, le jour auquel elle est censée débuter }

Duree: array [1

NbTaches]

of Integer;

{ la durée de chaque tâche, en nombre de jours }

Avant: array [1

NbTaches,1

NbTaches]

of Boolean;

{ Avant[X,Y] vrai si la tâche X doit être achevée avant

le début de Y }

Écrire une procédure/fonction étudiant la cohérence de ces données, c.-à-d. :

1. vérifier que chaque tâche peut bien commencer au jour prévu, en tenant compte de la durée de ses antécédentes;

2. si cela n'est pas vérifié, imprimer où se situe l'erreur, et quel est l'enchaînement des tâches précédentes (depuis l'origine) à prendre en compte pour déterminer la date de début correcte ;

3. le cas échéant, proposer des améliorations locales du planning (quand une tâche pourrait commencer plus tôt que prévu).

Il n'est pas demandé de modifier les données initiales, ni de réaliser plusieurs passes, chacune tenant compte des corrections ( avancée ou retardement d'une tâche) de la précédente. Toutefois, s'il vous reste du temps, cela pourra constituer un bonus

Attention : il n'est pas spécifié que les tâches doivent s'effectuer l'une après l'autre, certaines peuvent s'accomplir en parallèle. De même, la racine du processus n'est pas nécessairement unique (ni le graphe connexe).

NB: Les variables Debut, Duree et Avant sont globales, et peuvent être utilisées comme telles dans votre code.

Notes du contrôle continu du 22 juin 2000

Notes du contrôle continu du 22 juin

2000

Nom Q1 Q2 Q3 Note ARRIS Latifa 5 7 5 1,7 BLANC Jérémy 17 18
Nom
Q1
Q2
Q3
Note
ARRIS Latifa
5
7
5
1,7
BLANC Jérémy
17
18
20
5,5
BOUGET M.
20
20
20
6,0
COLA Stéphane
17
11
17
4,5
GEROME-BAUQUIS Isis
16
6
8
3,0
HAENGGELI Christophe
17
18
20
5,5
HEUBERGER Joris
17
20
19
5,6
HYSI Hilda
17
10
10
3,7
JABRI Abdelmajid
15
2
8
2,5
LOGEAY Camille
17
15
13
4,5
POSKRIAKOV Sergei
17
20
16
5,3
RAY Nicolas
17
17
11
4,5
RENQUIN Johan
18
18
20
5,6
SARAZIN Benoît
17
7
8
3,2
YAPY Luis
20
18
14
5,2

Dernière modification: 19.07.00

Répartition des notes [5,5-6,0] xxxxxx [5,0-5,5[ x [4,5-5,0[ xxx [4,0-4,5[ [3,5-4,0[ x [3,0-3,5[ xx [2,5-3,0[
Répartition des notes
[5,5-6,0]
xxxxxx
[5,0-5,5[
x
[4,5-5,0[
xxx
[4,0-4,5[
[3,5-4,0[
x
[3,0-3,5[
xx
[2,5-3,0[
x
[2,0-2,5[
[1,5-2,0[
x
[1,0-1,5[

Structuration des Données Informatiques - 11.3, exercice 4

Graphes orientés

Question posée au contrôle continu du 22 juin 2000 Dessinez la fermeture transitive de chacun de ces quatre graphes:

la fermeture transitive de chacun de ces quatre graphes: Solution http://cuisung.unige.ch/std/ex/11/3d.html

Solution

Structuration des Données Informatiques - 11. exercice 3

Exercice suivant

Graphe orienté

Question posée au contrôle continu du 22 juin 2000

Il est aisément démontrable que lorsque l'on élève un nombre N au carré, les deux derniers chiffres du résultat ne dépendent que des deux derniers chiffres de N. Ainsi, un nombre se terminant par 05 aura toujours son carré se terminant par 25 ( 105->11025, 1905->3629025 ).

L'on peut donc définir une application reliant chacun des nombres de 00 à 99 à un autre de ces nombres, correspondant à la valeur de son carré modulo 100. Ceci compose bien entendu un graphe orienté

1. Considérant que chacun des noeuds est l'origine d'un et un seul arc, déterminez la structure de données la plus simple adaptée à la représentation des arcs de ce graphe.

La propriété précédente amène logiquement ceci :

puisqu'un noeud a au plus un successeur (en fait, exactement un), l'on peut définir en suivant les arcs (c'est-à-dire en réitérant le calcul) un chemin unique qui en est issu;

puisque tous les noeuds ont au moins un successeur, ce chemin aboutit obligatoirement à un cycle (le nombre de noeuds étant limité).

L'on aimerait donc associer à chaque noeud la "séquence terminale" (cycle) qui lui correspond.

2. Écrivez une fonction imprimant, pour un noeud passé en paramètre, les noeuds composant le cycle terminal qui lui est associé.

Pensez que chaque composante du graphe ne comporte qu'un seul cycle; rappelez-vous qu'un cycle est un cas particulier de composante fortement connexe

Exercice suivant

Structuration des Données Informatiques - 14.3, exercice 6

Exercice suivant

B-Arbres

Question posée au contrôle continu du 22 juin 2000

Complétez les procédures pour parcourir des B-arbres.

NB: Ces procédures sont sensées marcher avec tous les B-arbres possibles! Une solutions qui marche juste avec l'arbre donné dans ce programme n'est pas considérée comme réponse à cette question (0 points). Sont marquées en caractères gras les parties du code qui sont essentielles à l'élaboration de la solution. program b_arbre; const cTaillePage=

;

type PPage = ^TPage;

{ un element d'une page de b-arbre}

TPageElement

= record : integer; { Cle }

mCle

mEnfant : PPage; { Pointeur } end;

{ une page du b-arbre = un noeud du b-arbre TPage = record

}

mPremierEnfant : PPage;{ Le premier Enfant } mNombreElements : integer;

mElements

: array[1

cTaillePage]

of TPageElement;

end;

var gArbre

: PPage;

gAuxiliaire : PPage;

gTest

: boolean;

{

Initialiser un element de page

}

procedure initialisePageElement(var outInitialise : TPageElement); begin

outInitialise.mCle:=0;

outInitialise.mEnfant:=nil;

end;

{

Creer une page vide

Structuration des Données Informatiques - 14.3, exercice 6

parameter: outNouveauNoeud, la variable qui va contenir la nouvelle page

}

procedure creePage(var outNouveauNoeud : PPage); var i : integer; begin { creePage } new(outNouveauNoeud);

outNouveauNoeud^.mPremierEnfant:=nil;

outNouveauNoeud^.mNombreElements:=0;

for i:=1 to cTaillePage do initialisePageElement(outNouveauNoeud^.mElements[i]); end; { creePage }

{

Ajoute une cle a une page existante parametres:

inCle

inoutPage : la page a modifier

: la nouvelle Cle

valeur de resultat:

true, si la page n'etait pas encore pleine false, si la page etait pleine

}

function ajouteCleAPage(var inoutPage: TPage; inCle:integer) :boolean;

begin if (inoutPage.mNombreElements<cTaillePage) then begin inoutPage.mNombreElements:=inoutPage.mNombreElements + 1; inoutPage.mElements[inoutPage.mNombreElements].mCle:=inCle; ajouteCleAPage:=true; end else ajouteCleAPage:=false; end; { ajouteCleAPage }

{

Ajoute une pair de cle et pointeur a une page existante

}

function ajouteCleEtPointeurAPage(var inoutPage : TPage;

inCle :integer; inNouveauEnfant: PPage) :boolean;

begin if (inoutPage.mNombreElements<cTaillePage)then begin inoutPage.mNombreElements:=inoutPage.mNombreElements + 1; inoutPage.mElements[inoutPage.mNombreElements].mCle:= inCle; inoutPage.mElements[inoutPage.mNombreElements].mEnfant :=

Structuration des Données Informatiques - 14.3, exercice 6

inNouveauEnfant; ajouteCleEtPointeurAPage := true; end else ajouteCleEtPointeurAPage := false; end; { ajouteCleEtPointeurAPage }

{

Ajoute le premier pointeur a la page

}

function ajoutePremierPointeurAPage(var inoutPage: TPage; inNouveauEnfant: PPage) :boolean;

begin inoutPage.mPremierEnfant:=inNouveauEnfant; ajoutePremierPointeurAPage:=true; end; { ajoutePremierPointeurAPage }

{

Parcourir et afficher a l'ecran

}

procedure parcourirBArbreEnOrdre(inArbre: PPage );

{

ICI VOUS AVEZ LE DROIT DE METTRE DES VARIABLES

}

var i : integer; begin { parcourirBArbreEnOrdre } {METTEZ VOTRE SOLUTION ICI!} end; { parcourirBArbreEnOrdre }

{

Parcourir EN ORDRE INVERSE et afficher a l'ecran

}

procedure parcourirBArbreEnOrdreInverse(inArbre: PPage );

{

ICI VOUS AVEZ LE DROIT DE METTRE DES VARIABLES

}

var i : integer; begin { parcourirBArbreEnOrdreInverse } {METTEZ VOTRE SOLUTION ICI!} end; { parcourirBArbreEnOrdreInverse }

begin

creePage(gArbre);

creePage(gAuxiliaire); gTest:= ajouteCleAPage(gAuxiliaire^,1); gTest:= ajouteCleAPage(gAuxiliaire^,2);

Structuration des Données Informatiques - 14.3, exercice 6

gTest:= ajouteCleAPage(gAuxiliaire^,3); gTest:= ajoutePremierPointeurAPage(gArbre^,gAuxiliaire);

creePage(gAuxiliaire); gTest:= ajouteCleAPage(gAuxiliaire^,5); gTest:= ajouteCleAPage(gAuxiliaire^,6); gTest:= ajouteCleAPage(gAuxiliaire^,7);

gTest:= ajouteCleEtPointeurAPage(gArbre^, 4, gAuxiliaire);

parcourirBArbreEnOrdre(gArbre); { donne 1 2 3 4 5 6 7 } writeln; writeln; parcourirBArbreEnOrdreInverse(gArbre); { donne 7 6 5 4 3 2 1 } writeln; end.

Solution

Exercice suivant

Notes du contrôle continu du 11 mai 2000

Notes du contrôle continu du 11 mai

2000

Nom Q1 Q2 Q3 Note ARRIS Latifa 20 16 16 5,2 BEURET Séverine 18 8
Nom
Q1
Q2
Q3
Note
ARRIS Latifa
20
16
16
5,2
BEURET Séverine
18
8
9
3,5
BLANC Jérémy
20
19
18
5,7
BOUGET M.
19
15
16
5,0
BRAIK Ahcène
15
4
12
3,1
BUHLER Stéphane
13
13
2
2,8
COLA Stéphane
18
17
15
5,0
CORON Olivier
16
12
13
4,1
GEROME-BAUQUIS Isis
17
18
18
5,3
HABACHI Arash
15
15
16
4,6
HAENGGELI Ch.
18
18
10
4,6
HEUBERGER Joris
20
19
16
5,5
HYSI Hilda
18
17
13
4,8
JABRI Abdelmajid
18
13
10
4,1
JULIEN Etienne
18
14
0
3,2
LOGEAY Camille
18
13
14
4,5
LUONG Fayou
20
15
11
4,6
MADDI Brahim
0
2
8
1,0
PELLEGRINI David
18
10
0
2,8
PETRINI Geo
20
16
15
5,1
POSKRIAKOV Sergei
20
20
19
5,9
Répartition des notes [5,5-6,0] xxxxx [5,0-5,5[ xxxxx [4,5-5,0[ xxxxxxx [4,0-4,5[ xx [3,5-4,0[ x [3,0-3,5[ xx
Répartition des notes
[5,5-6,0]
xxxxx
[5,0-5,5[
xxxxx
[4,5-5,0[
xxxxxxx
[4,0-4,5[
xx
[3,5-4,0[
x
[3,0-3,5[
xx
[2,5-3,0[
xx
[2,0-2,5[
[1,5-2,0[
[1,0-1,5[
x

Notes du contrôle continu du 11 mai 2000

RAY Nicolas 16 16 14 4,6 RENQUIN Johan 20 20 15 5,5 SARAZIN Benoît YAPY
RAY Nicolas
16
16
14
4,6
RENQUIN Johan
20
20
15
5,5
SARAZIN Benoît
YAPY Luis
17
10
18
4,5
20
19
18
5,7

Dernière modification: 20.07.00

Structuration des Données Informatiques - 7.1, exercice 2

Exercice suivant

Chaînes

Question posée au contrôle continu du 11 mai 2000

Complétez ce programme pour que toutes les fonctions fassent ce qui est dit dans les commentaires:

program chaines; type

{

un pointeur sur des elements d'une chaine.

}

PElement = ^TElement;

{

un element d'une chaine:

}

TElement = record {chaque element de la chaine contient un entier} mContenu :

integer;

{

mSuivant: pointeur sur l'element suivant de la chaine, nil pour le dernier element

}

mSuivant : PElement; end;

var

gChaineDOrigine : PElement; gChaineResultat : PElement;

{

VOUS ETES AUTORISES A AJOUTER QUELQUES FONCTIONS ICI (Si vous voulez. Ce n'est pas forcement necessaire, mais ca peut ameliorer la lisibilite de votre solution).

DES VARIABLES SUPPLEMENTAIRES NE SONT PAS AUTORISEES.

}

{ La fonction suivante prend la chaine inChaine et retourne une

nouvelle chaine, qui contient les memes valeurs que inChaine, mais en ordre inverse: Si inChaine est (1 2 3) le resultat va etre la chaine (3 2 1).

AUCUNE VALEUR QUI APPARTIENT A INCHAINE NE DOIT ETRE MODIFIEE } function creeChaineInversee(inChaine:PElement):PElement;

{

VOUS ETES AUTORISES A METTRE DES VARIABLES ICI.

Structuration des Données Informatiques - 7.1, exercice 2

LES TABLEAUX SONT INTERDITS!!!!

}

begin { VOTRE SOLUTION ICI

Mon conseil:

Copier la liste d'entree, en ajoutant les nouveaux elements AU DEBUT de la nouvelle liste

}

end; { creeChaineInversee }

begin

{

VOUS N'ETES PAS AUTORISE A AJOUTER QUOI QUE CE SOIT ICI

}

new(gChaineDOrigine);

gChaineDOrigine^.mContenu:=2;

new(gChaineDOrigine^.mSuivant);

gChaineDOrigine^.mSuivant^.mContenu:=4;

new(gChaineDOrigine^.mSuivant^.mSuivant);

gChaineDOrigine^.mSuivant^.mSuivant^.mContenu:=6;

gChaineDOrigine^.mSuivant^.mSuivant^.mSuivant:=nil;

gChaineResultat:=creeChaineInversee(gChaineDOrigine);

writeln('Si toutes ces expressions sont correctes, il est', 'probable que le programme est lui aussi correct'); write('6 = ');writeln(gChaineResultat^.mContenu); write('4 = ');writeln(gChaineResultat^.mSuivant^.mContenu); write('2 = '); writeln(gChaineResultat^.mSuivant^.mSuivant^.mContenu); end.

Solution

Exercice suivant

Structuration des Données Informatiques - 7.1, exercice 3

Chaînes

Question posée au contrôle continu du 11 mai 2000

Étant données deux listes chaînées, comportant des entiers rangés selon l'ordre croissant, et définies comme suit:

type pElement = ^tElement; tElement = record nombre : integer; suivant : pElement; end; var debut1, debut2 : pElement;

Écrivez une fonction qui opèrera une fusion de ces deux chaînes dans une troisième, respectant également l'ordre croissant de ses éléments, en enlevant les doublons.

Ainsi, à partir de:

liste 1 :

1 3

5 7

9

liste 2 :

1 2

4 7 11 16

l'on doit obtenir:

liste 3 :

1 2

3 4

5 7 9 11 16

Structuration des Données Informatiques - 8.1, exercice 5

Exercice suivant

Arbre de tri

Question posée au controle continu du 11 mai 2000

Soit un arbre de tri représenté par la structure suivante:

type pNoeud = ^tNoeud; tNoeud = record nombre : integer; gauche, droite : pNoeud; end; var racine : pNoeud;

On suppose que la racine est instanciée à un arbre existant. Proposez alors une fonction permettant de vérifier que cet arbre est bien construit, c'est-à-dire que tous les nombres présents dans le sous-arbre gauche (resp. droit) sont inférieurs (resp. supérieurs) au nombre correspondant au noeud courant, et cela à chaque niveau de l'arbre.

Solution

Exercice suivant

Structuration des Données Informatiques - 3.1, exercice 1

Tableaux

Question posée au contrôle continu du 28 février 2000 program question1;

var gHeap : array [1

7]

of integer;

procedure affiche(inValeurCourant, inValeurFin : integer); begin if (inValeurCourant<=inValeurFin) then begin writeln('a: ',gHeap[inValeurCourant]);

affiche(inValeurCourant*2,inValeurFin);

writeln('b: ',gHeap[inValeurCourant]);

affiche(inValeurCourant*2+1,inValeurFin);

writeln('c: ',gHeap[inValeurCourant]); end (* then *) else begin writeln('d: ',inValeurCourant); end; (* if *) end; { affiche } procedure remplir; var i : integer; begin

gHeap[1]:=4;

gHeap[2]:=2;

gHeap[3]:=5;

gHeap[4]:=1;

gHeap[5]:=3;

gHeap[6]:=6;

gHeap[7]:=7;

gHeap[7]:=8;

end; { remplir }

begin remplir writeln('----------premiere partie');

affiche(1,1);

writeln('----------deuxieme partie');

affiche(1,3);

writeln('----------troisieme partie');

affiche(1,5);

writeln('----------fin')

end.

Qu'est-ce que ce programme affiche à l'écran?

Structuration des Données Informatiques - 7.4, exercice 8

Anneaux bidirectionnels

Question posée à l'examen écrit du 28 février 2000

Sur la base des déclarations suivantes:

type VersAnneau = ^ElementAnneau;

ElementAnneau = RECORD Donnee: integer; Preced, Suivant: VersAnneau; END;

Ecrivez une procédure Tri(var Anneau: VersAnneau)qui trie par permutation les données d'un anneau bidirectionnel. On supposera que les données sont tellement volumineuses que la permutation se fera en manipulant les pointeurs et non pas en changeant le champ Info.

Solution

Structuration des Données Informatiques - 8.3, exercice 2

Arbres dépliables

Question posée aux examens écrits du 30 juin 1999 et du 28 février 2000

.

Dessiner un arbre dépliable de tri, qui sera construit à partir des mots de la phrase suivante, en traitant les mots en séquence de gauche à droite:

John also reviews the use of increasingly important industry specifications and standards in platform or system issues.

b.

Solution

Détruire l'élément qui contient le mot "increasingly" et dessiner l'arbre dépliable résultant.

Structuration des Donn es Informatiques - 14.3, exercice 5

Exercice suivant

B-Arbres

Question posée à l'examen du 28 février 2000

Soit un B-arbre construit à partir des déclarations suivantes:

const NodeSize = 4;

type PNode = ^TNode; TNode = record UsedSize : integer;

Content

: array [1

NodeSize]

of integer;

Children : array [0 end; (* TNode *)

NodeSize]

of PNode;

var gRoot : PNode;

Ecrivez une procédure "afficher(Root : PNode)" qui écrit le contenu du B-arbre en ordre croissant.

Exercice suivant

Structuration des Données Informatiques - 7.4, exercice 8

Exercice suivant

Anneaux bidirectionnels

Question posée à l'examen écrit du 11 octobre 1999

Etant donné les déclarations suivantes pour un anneau bidirectionnel:

type PtrNoeud = ^Noeud;

Noeud = RECORD Donnee: integer; Preced, Suivant: PtrNoeud; END;

var TeteAnneau: PtrNoeud; (* pointeur vers premier element *)

1. Ecrire une procédure InsereFin(Anneau, Donnee) pour insérer une donnée à la fin de l'anneau

2. Ecrire une fonction NbElem(Anneau), qui retourne un entier, pour compter le nombre d'éléments de l'anneau

3. Ecrire une procédure Split(Ring, Data, LowerRing, HigherRing), qui prend les données contenues dans le premier paramètre (anneau) pour les recopier dans le troisième ou le quatrième paramètre (eux aussi des anneaux) suivant que ces données sont respectivement soit inférieures, soit supérieures ou égales à la donnée passée en second paramètre.

N.B.: à chaque fois, vous devez envisager tous les cas possibles

Solution

Exercice suivant

Structuration des Données Informatiques - 8.1, exercice 4

Exercice suivant

Arbre syntaxique

Question posée à l'examen du 11 octobre 1999

En supposantque l'on dispose des fonctions suivantes pour contruire une structure d'arbre:

type PtrNoeud: ^Noeud;

function Feuille(Contenu: char): PtrNoeud;

{ crée par allocation dynamique un noeud sans descendant et contenant un caractère }

function Arbre(ContenuRacine:char; Gauche, Droit: PtrNoeud): PtrNoeud;

{

crée, par allocation dynamique, un nouveau noeud racine auquel seront rattachés les sous-arbres gauche et droit fournis en paramêtre, de façon à former un nouvel arbre }

1. Quelle sera l'expression, composée d'appels imbriqués aux fonctions Arbre et Feuille, qui permettra de construire, en une seule instruction Pascal, l'arbre suivant:

en une seule instruction Pascal, l'arbre suivant: 2. Si, au lieu de créer une structure dynamique

2.

Si, au lieu de créer une structure dynamique en mémoire, on voulait directement évaluer l'expression arithmétique représentée par l'expression Pascal de la première partie de cette question, quel devrait être l'entête et le code des fonctions Feuille et Arbre, en supposant qu'elles retournent des valeurs entières

N.B.: on suppose que les opérateurs + et - peuvent être utilisés comme opérateurs monadiques, c'est-à-dire ne portant que sur un seul argument (opérateurs de signe).

Solution

Exercice suivant

Structuration des Données Informatiques - 9.1, exercice 1

Exercice suivant

Listes

Question posée à l'examen du 11 octobre 1999

Indiquez ligne après ligne ce qu'imprime le programme suivant:

program listes; var gDe,gA:integer;

procedure compter1(inDe,inA : integer); begin if(inDe<inA) then begin writeln(inDe);

compter1(inDe+1,inA);

end; (* if *)

end;

procedure compter2(inDe,inA : integer); begin if(inDe<inA) then begin

compter2(inDe+1,inA);

writeln(inDe); end; (* if *)

end;

procedure compter3(inDe,inA : integer); begin if(inDe<inA) then begin writeln(inDe);

compter3(inDe+1,inA);

writeln(inDe); end; (* if *)

end;

procedure compter4(var inDe,inA : integer); begin if(inDe<inA) then begin writeln(inDe);

inDe:=inDe+1;

compter4(inDe,inA);

writeln(inDe); end; (* if *)

end;

begin

Structuration des Données Informatiques - 9.1, exercice 1

gDe:=1;

gA:=4;

writeln('Avant compter1');

compter1(gDe,gA);

gDe:=1;

gA:=4;

writeln('Avant compter2');

compter2(gDe,gA);

gDe:=1;

gA:=4;

writeln('Avant compter3');

compter3(gDe,gA);

gDe:=1;

gA:=4;

writeln('Avant compter4');

compter4(gDe,gA);

end.

Exercice suivant

Structuration des Données Informatiques - 11. exercice 2

Exercice suivant

Le chemin le plus court

Question posée à l'examen écrit du 11 octobre 1999

Soit un graphe avec 4 noeuds (1,2,3,4), avec des arcs pondérés: Les arcs sont:

Départ Arrivée Distance 1 2 1 2 3 1 3 4 1 1 3 10
Départ Arrivée Distance
1
2
1
2
3
1
3
4
1
1
3
10
2
4
100
4
3
1000

Pour trouver les "distances" correspondant aux chemins les plus courts entre le noeud 1 et tous les autres noeuds, exécutez l'algorithme suivant:

1. Soit une liste L et une liste A, toutes deux initialement vides.

2. Ajoutez à la liste L la paire (1;0) pour le noeud 1 et la "distance" 0. Ajoutez pour chaque arc qui lie les noeuds x et y avec une "distance" z le triplet (x;y;z) à la liste A.

3. Retirez la paire (x;y) avec le deuxième élément (y) le plus petit de la liste L.

4. Pour chaque paire (x;y) avec le deuxième élément (y) le plus petit de la liste L, retiré à l'étape 3, faites ce qui suit:

Pour chaque arc (x,a,b) qui lie le noeud x à a avec une distance b ajoutez la paire (a;y+b) à la liste L.

Retirez (x,a,b) de A

5. Pour chaque paire (x;y) dans L: S'il existe une paire (x;z) dans L avec z plus petit ou égal à y effacez (x;y) de L.

6. Continuez en 3 tant qu'il y a encore des éléments dans A

Donnez le contenu de A et de L après chaque pas.

Exercice suivant

Notes de l'examen du 30 juin 1999

Structures de données

Notes de l'examen du 30 juin 1999

Nom Tiana Andriaharifara Patrick Arbus José Barba Ahcene Braik Denis Bucher Hechmi Chnina Baba Diao
Nom
Tiana Andriaharifara
Patrick Arbus
José Barba
Ahcene Braik
Denis Bucher
Hechmi Chnina
Baba Diao
Yves Fomekong
Mouhamed Gningue
Nicolas Hurzeler
Sylvan Laurence
Thomas Pfund
Bruno Rosa Martins
Cengiz Ulkü
Note
Remarque
0,0
absente
0,5
3,0
2,0
4,5
note en attente des TPs
0,5
0,0
absent
3,5
3,0
1,0
1,0
4,0
note en attente des TPs
5,0
0,5

N.B.: les notes du contrôle continu sont aussi disponibles

Structuration des Données Informatiques - 7.4, exercice 7

Exercice suivant

Anneaux bidirectionnels

Question posée à l'examen écrit du 30 juin 1999

Sur la base des déclarations suivantes:

type VersAnneau = ^ElementAnneau; ElementAnneau = record Info:

;

Precedent, Suivant: VersAnneau; end; { ElementAnneau }

1. écrivez une fonction Pascal Inverse qui prend en paramètre un anneau bidirectionnel et retourne comme résultat un pointeur vers un autre anneau qui a les mêmes éléments que le paramètre, mais dans l'ordre inverse:

function Inverse(Ring: VersAnneau): VersAnneau;

2. écrivez une fonction Pascal EstInverse qui prend en paramètres deux anneaux bidirectionnels et qui indique s'ils sont l'inverse l'un de l'autre:

function estInverse(Ring1, Ring2: VersAnneau): boolean;

Solution

Exercice suivant

Structuration des Données Informatiques - 11. exercice 1

Exercice suivant

Le chemin le plus court

Question posée l'examen écrit du 30 juin 1999

Imaginez un graphe orienté qui est donné par sa matrice de connectivité:

sommets d'arrivée 1 2 3 4 5 6 7 1 x x 2 x sommets
sommets d'arrivée
1
2
3
4
5
6
7
1
x
x
2
x
sommets
3
x
de
4
x
départ
5
x
6
x
7

.

Dessinez ce graphe

b.

Trouvez maintenant le chemin le plus court entre les noeuds 1 et 6. Pour ça vous avez besoin d'une

file d'attente FIFO permettant de stocker des chaînes Li. Chaque Li=(Vi,1,

séquence de sommets. L'algorithme à utiliser pour trouver le chemin le plus court entre deux

noeuds Vs et Vf est le suivant:

,Vi,n_i) contient une

1. Videz la FIFO

2. Insérez la liste (Vs) dans la FIFO.

3. Tirez la première liste de la FIFO. Appelez cet élément L1

4. Si le premier noeud V1,1 contenu dans L1 est égal à Vf, affichez L1 de la fin au début: La séquence dans L1 est un chemin de longueur minimale entre Vs et Vf (il peut y en avoir plusieurs). L'algorithme est terminé.

5. Sinon (le premier noeud V1,1 contenu en L1 n'est pas égal à Vf): visitez V1,1 de la façon suivante: Ajoutez pour chaque voisin v de V1,1 la liste résultant de (cons v L1) .

6. Continuez avec le pas 3, tant que la FIFO n'est pas vide et le chemin le plus court n'a pas été trouvé au pas 4.

Les limitations de cet algorithme sont claires. Il doit être possible d'atteindre Vf a partir de Vs. La solution doit donner le contenu de la FIFO à chaque étape de l'algorithme!

Solution

Exercice suivant

Structuration des Donn es Informatiques - 13.4, exercice 3

Adressage associatif par transformation de clés (Hash-code)

Question posée à l'examen écrit du 30 juin 1999

. Etant donné le programme en Pascal suivant:

program fabrique_fonction_de_H_code_parfaite;

const TailleMax MaxIndice NbMots MaxCoeff LongueurMax =

=

; { taille maximale de la table }

= TailleMax-1; { indice maximal dans la table }

; { nombre de mots a stocker }

; { valeur max pour les coefficients }

; { longueur max. des mots du vocabulaire}

=

=

type StringMax = string[LongueurMax];

var Taille : integer; {Nombre d'éléments utilisables dans la table}

T : array[0

Coeff : array[1 LongueurMax]

MaxIndice]

of StringMax;

of 1

MaxCoeff;

{ coefficients de la fonction H }

Vocabulaire : array[1

NbMots]

of StringMax;

function H( Mot : StringMax ) : integer; begin

H := 0;

for i := 1 to Length(Mot) do

H := H + Coeff[i] * ord( Mot[i] );

H := H mod Taille

end; { H }

procedure ChercheCoefficients; begin { ChercheCoefficients } { ajustement des coefficients Coeff[i] et Taille }

end; { ChercheCoefficients } begin { fabrique_fonction_de_H_code_parfaite } ChercheCoefficients; end. { fabrique_fonction_de_H_code_parfaite }

Ecrire la procédure 'ChercheCoefficients', permettant de fixer les coefficients ( Coeff[i] et 'Taille' ) de la fonction de H-code, afin qu'elle soit parfaite pour le remplissage du tableau avec les mots du 'Vocabulaire'.

La solution doit impérativement minimiser le paramètre 'Taille'. Idéalement, la taille du tableau serait égale au nombre de mots.

Il est conseillé d'utiliser la force brute pour résoudre ce problème. Il s'agira donc de tester toutes les valeurs possibles pour les coefficients, jusqu'à tomber sur une fonction de H-code parfaite, ou que l'espace des possibilités soit épuisé.

Structuration des Donn es Informatiques - 13.4, exercice 3

b. Le but de cette question est d'essayer de minimiser le nombre de collisions dans une structure de données remplie à l'aide de l'algorithme de H-code. Nous avons:

un tableau de strings appelé T, dont les éléments T[i] sont initialisés à '' (string vide)

une fonction H(X) retournant l'indice dans le tableau T où l'élément X devrait être stocké.

une fonction P(X) retournant la probabilité d'apparition de l'élément X sur l'ensemble des données traitées.

L'optimisation proposée est la suivante :

Lors de l'insertion d'un mot X, si l'emplacement T[H(X)] est déjà occupé, le nouveau mot X aura la priorité si sa probabilité est plus élevée que celle du mot dans l'emplacement occupé.

Pour sa réalisation, il suffira de compléter la procédure ci-dessous, déjà vue au cours. function Insert( X : string ) : integer; var H0, hi : integer; begin H0 := H(X); hi := H0;

while ( T[hi]

<> '' ) and ( T[hi] <> X ) do begin

{ Ajouter ici le code de l'optimisation }

hi := (hi+1) mod MaxElements; if hi = H0 then begin writeln('tableau plein'); exit(program); end; { if } end; { while } if T[Hi] = '' then T[Hi] := X; Insert := hi; end; { Insert }

Solution

Notes du contrôle continu du 14 juin 1999

Notes du contrôle continu du 14 juin

1999

Nom Roberto Campelo Frederic Ehrler Christiane James Dimitri Kalas Julie Lutz Alexandre Nevski Q1 Q2
Nom
Roberto Campelo
Frederic Ehrler
Christiane James
Dimitri Kalas
Julie Lutz
Alexandre Nevski
Q1
Q2
Q3
Note
8
5
0
1,3
14
20
10
4,4
12
12
20
4,4
17
18
16
5,1
17
12
16
4,5
9
10
16
3,5

Structuration des Donn es Informatiques - 11.3, exercice 3

exercice suivant

Graphes orientés

Question posée au contrôle continu du 14 juin 1999

Soit un graphe défini sur la base des relations de dépendances suivantes concernant les ages respectifs d'un groupe de personnes:

Jean est plus jeune que Paul et Pierre, mais plus agé que Jeanne.

Jacques est plus jeune que Jeanne et Pierre, mais plus vieux que Marie

Pierre est plus jeune que Paul, mais plus vieux qu'André et Alice

Yves est plus jeune que Paul, mais plus vieux que Claude et Alice

Claude est plus jeune que Pierre et plus vieux qu'André

.

dessinez le graphe en question

b.

donnez la matrice de connectivité de ce graphe

c.

donnez la matrice de connectivité de la fermeture transitive de ce graphe indiquez à quel type de question la fermeture transitive permet de répondre plus facilement

d.

donnez une séquence de sommets correspondant à un tri topologique, indiquez s'il existe une autre solution possible (si oui, proposez en une).

Solution

exercice suivant

Structuration des Donn es Informatiques - 14.3, exercice 4

Exercice suivant

B-Arbres

Question posée au contrôle continu du 14 juin 1999

Soit un B-Arbre d'ordre 1, c'est-à-dire que chaque page peut avoir soit 1 soit 2 données.

.

Insertion: Insérez dans l'ordre indiqué les nombres: 1,2,3,6,7,4,5,8,9 dans le B-arbre et dessinez après chaque insertion le B-arbre résultant.

b.

Complexité d'espace: En supposant que chaque page occupe 512 octets (2 octets pour le nombre de données dans la page, 4 octets par "pointeur" vers une autre page et 249 octets par donnée), indiquez l'espace minimum et maximum nécessaires pour stocker 10'000 données dans ce B-arbre d'ordre 1.

c.

Profondeur: Quelle profondeur minimum et maximum aura le B-arbre avec 10'000 données.

Solution

Exercice suivant

Structuration des Donn es Informatiques - 13.4, exercice 2

exercice suivant

Adressage associatif par transformation de clés (Hash-code)

Question posée au contrôle continu du 14 juin 1999

Soit une fonction H qui retourne les valeurs numériques suivantes pour les mots suivants:

mot: du esprit etait forte illumination jour la lumiere qu si son soudaine traversa une

H(mot): 6

13

3

12

9

10

7

15

5

6

5

8

10

2

On décide de placer ces mots dans un tableau de 15 positions (indices 1 ouvert, en utilisant l'expression suivante pour traiter les collisions:

H i (K) = [(H(K) + i*length(K)) mod 15] + 1, où i représente le nombre de collisions déjà subies lors de l'insertion de K (i = 0 au début) et length(K) est la fonction qui retourne le nombre de caractères d'un mot.

N.B.: Au cas où on essaye de placer un nouveau mot dans une position occupée par un mot ayant lui-même été déplacé, on donnera la priorité au nouveau mot.

Dessinez le tableau résultant de l'insertion des mots énumérés ci-dessus en les prenant dans l'ordre où ils sont écrits.

Solution

exercice suivant

15)

par la méthode de l'adresse

Contrôle Continu de Structures de Données du 29 avril 1999

29 avril 1999

Structures de Données

Contrôle Continu - Première épreuve

Rappel:

Ce contrôle continu est un examen. Vous n'êtes donc pas autorisés à communiquer avec d'autres personnes par quelque moyen que ce soit (communication verbale, par support papier ou électronique, courrier électronique, Web, espace disque), à l'exception des assistants chargé de la surveillance de cet examen. Une vérifications des "logs" des serveurs Web, proxy et courrier électronique peut être effectuée pour déterminer si quelqu'un a contrevenu à cette interdiction. Toute tricherie sera sanctionnée par une note de 0 à l'examen final pour tous les contrevenants.

Vous êtes par contre autorisés à consulter toute la documentation que vous désirez, que ce soit le livre du cours ou d'autres livres, vos notes personnelles, le site Web du cours (y compris les anciennes questions d'examens et leurs corrigés), ou même des fichiers vous appartenant.

Comment rendre vos réponses aux questions:

Les questions portent sur des exercices de programmation. Vos réponses vont donc consister en du code Pascal complétant des programmes qui vous seront fournis. Vous devez rendre vos réponses sur une disquette portant une étiquette sur laquelle votre nom est clairement inscrit. Ces disquettes vous seront rendues par la suite.

Si pour une raison quelconque, vous vous trouviez dans l'impossibilité de rendre une disquette, vous devez laisser une copie des fichiers contenant vos réponses dans votre espace disque personnel, en indiquant à au moins un assistant le problème que vous avez rencontré et en lui expliquant où se trouvent vos réponses.

Recommandation:

Si vous n'arrivez pas à faire correctement fonctionner votre code pour une des deux questions, ne restez pas bloqués dessus plus de deux heures pour avoir le temps de traiter l'autre question.

Contrôle Continu de Structures de Données du 29 avril 1999

Questions

Question 1 Description

Ici vous trouvez le fichier qui contient un programme en Pascal.

Ce programme traite des chaînes bidirectionelles qui ont deux bouts facilement accessibles. Pour l'acces, c'est a dire l'ajout et la suppression des elements et pour la construction et destruction des listes tout les fonctions necessaires sont fournies avec les commentaires. Lisez et comprenez ces procedures. C'est nécessaire pour le reste de cette question.

Question:

Completez maintenant les fonctions et procedures suivantes:

estPalindrome_Chaine

newReverse_Chaine

ajouteApresChaine_Chaine

Cette fonction verifie si une chaine est un palindrome, c'est a dire si le n-ième element est egale au (n-1)-avant-dernier-element Cette fonction genère une nouvelle chaîne qui est exactement la chaîne d'entrène lu a'l envers. Cette fonction ajoute une chaine (deuxième paramètre) a la fin d'une autre (premier paramètre). La chaîne qui était donée comme premier paramètre est entierement vide apres exécution de cette fonction.

Conseil:

Lisez et comprenez vraiment les procédures données. Sinon la question devient beaucoup plus difficile.

Question 2: arbre lexicographique

On a construit un arbre multiple d'ordre 26 permettant de stocker des mots d'un dictionnaire de façon que les chemins partant de la racine représentent des mots du dictionnaire, de la façon suivante:

Contrôle Continu de Structures de Données du 29 avril 1999

Contrôle Continu de Structures de Données du 29 avril 1999 Les arcs sont étiquettés avec les

Les arcs sont étiquettés avec les lettres de l'alphabet (on suppose ici que l'on ne tient pas compte des accents sur les lettres) et les noeuds contiennent un booléen indiquant si le chemin de la racine à ce noeud représente un mot complet ou pas (sur le dessin - = faux et * = vrai).

Sur la base des déclarations suivantes, écrivez une fonction Lecture qui construira la structure de dictionnaire à partir d'un fichier Text où les mots sont fournis, un par ligne, et une fonction NbMots comptant les mots du dictionnaire ayant une longueur donnée. Si la longueur est 0, il faut retourner le nombre total de mots, quelle que soit leur longueur. type VersNoeud= ^Noeud; Noeud= record

Desc: array['a' Complet: boolean; end; { Noeud } var Dico: VersNoeud;

'z']

of VersNoeud;

function Lecture(NomFichier: string): VersNoeud; (* cette fonction doit lire les mots du dictionnaire dans un fichier et construire la structure d'arbre au fur et a mesure de la lecture des mots *)

function NbMots(Longueur: integer; Dico: VersNoeud):integer; (* cette fonction doit retourner le nombre de mots contenus dans le dictionnaire, dont le nombre de lettres=Longueur *)

Fournis:

Indication: Nous vous recommandons de commencer par la fonction NbMots, en invoquant la fonction "PseudoLecture" fournie, à la place de la fonction Lecture qui vous est demandée. Lorsque la fonction NbMots sera au point et si vous en avez encore le temps, vous pourrez essayer de remplacer l'appel à la fonction PseudoLecture par un appel à la fonction Lecture que vous aurez écrite.

Solution

Contrôle Continu de Structures de Données du 29 avril 1999

ou plutôt oralement Quelques photos sont disponibles, ainsi que le résultat de l'évaluation

Notes du contrôle continu du 29 avril 1999

Notes du contrôle continu du 29 avril

1999

Nom Q1 Q2 Note Tiana Andriharifara 18 1 1,9 Patrick Arbus 10 0 1,0 Jose
Nom
Q1
Q2
Note
Tiana Andriharifara
18
1
1,9
Patrick Arbus
10
0
1,0
Jose Barba
8
0
0,8
Roberto Campelo
27
5
3,2
Frederic Ehrler
24
3
2,7
Yves Fomekong
17
0
1,7
Chnina Hechmi
0
0
0
Nicolas Hurzeler
0
0
0
Christiane James
17
0
1,7
Dimitri Kalas
27
20
4,7
Sylvain Laurence
24
3
2,7
Julie Lutz
21
20
4,1
Bruno Martins
Alexandre Nevski
22
5
2,7
29
20
4,9

Structuration des Données Informatiques - 11.5, exercice 2

Tri topologique inverse

Question posée à l'examen du 7 octobre 1998

En s'inspirant de la description de graphes orientés en termes de type abstrait vue au cours, nous allons supposer que les types "Graphe" et "SerieDeSommets" ont été définis, sans que vous ne connaissiez les détails de ces structures. Nous allons aussi supposer que les primitives suivantes sont à votre disposition:

function Index(NomSommet: string; LeGraphe: Graphe): integer;

{ retourne un numero compris entre 1 et MaxNbSommets }

function NomSommet(IndexSommet: integer; LeGraphe: Graphe) :string;

{ retourne le nom du sommet dont l'index est fourni }

function NombreDeSommets(LeGraphe: Graphe): integer; {retourne le nombre de sommets effectifs composant le graphe}

function SommetsVoisins(IndexSommet: integer; LeGraphe: Graphe): SerieDeSommets;

{ retourne une structure permettant de retrouver l'index des voisins immédiats }

function ExtraitSommet(var UneSerie: SerieDeSommets): integer;

{ extrait un sommets de la série et retourne son index }

function FinDeSerie(UneSerie: SerieDeSommets): boolean;

{ vrai s'il n'y a plus de sommet suivant dans la serie }

En utilisant ces primitives, tout en ignorant de quelle façon la structure de graphe est implantée, écrivez une procédure de tri topologique inverse qui imprime les sommets du graphe fourni en paramêtre:

TriTopologiqueInverse(LeGraphe: Graphe)

Solution

Structuration des Données Informatiques - 14.3, exercice 2

Exercice suivant

Comparaison de B-arbres et B*-arbres

Question posée à l'écrit du 7 octobre 1998

Rappel: un B*-arbre est une variante de B-arbre dans laquelle les pages (à l'exception de la racine) sont maintenues au moins au deux tiers pleines

Soit un ensemble d'un million de données occupant chacune 47 octets. En supposant que l'on utilise des pages de 1024 octets et des références occupant 4 octets, effectuez les calculs suivants pour le cas où on construit un B-arbre et le cas où on construit un B*-arbre. Expliquez à chaque fois votre raisonnement pour arriver aux résultats que vous fournissez.

.

ordre du B-arbre et du B*-arbre

b.

taille minimale et maximale de l'espace disque occupé

c.

profondeur minimale et maximale de la structure

Solution

Exercice suivant

Structuration des Données Informatiques - 8.3, exercice 1

Exercice suivant

Arbres dépliables

Question posée à l'examen écrit du 25 juin 1998

.

Dessiner un arbre dépliable de tri, qui sera construit à partir des mots suivants, en prenant la séquence de gauche à droite :

la, lumiere, du, jour, etait, si, forte, qu, une, illumination, soudaine, traversa, son, esprit.

b.

Solution

Exercice suivant

Détruire l'élément qui se trouve à la racine et dessiner l'arbre dépliable résultant.

solution de l'exercice 2, sectionn 15.1

Tables de décision

question posée à l'examen écrit du 25 juin 1998

Avec les déclarations suivantes définissant une table de décision ainsi qu'un arbre binaire ordonné, écrivez une fonction «ConstruitArbre» qui convertisse une table de décision condensée (paramètre d'entrée) en arbre binairee (paramètre de sortie) où les feuilles contiennent les indicateurs d'actions d'une règle et les noeuds intermédiaires contiennent le texte des conditions de façon que l'arborescence permette de sélectionner la règle qui s'appliquera à un cas donné.

Indication: il faut s'inspirer de l'algorithme de conversion d'une table de décision en cascade de tests, mais construire une structure d'arbre au lieu de produire du code Pascal.

const MaxNbCond = MaxNbRegles = MaxNbActions =

;

;

;

type Conditions =(Vrai, Faux, Indetermine);

TableDecision = record

NbConditions: 1 MaxNbCond; NbRegles: 1 MaxNbRegles;

ValCond: array[1

NbActions: 1 MaxNbActions;

MaxNbRegles,

Agir: array[1

TxtConditions:array[1

TxtActions:array[1

end; { TableDecision }

MaxNbRegles,

1

1

MaxNbCond]

of Conditions;

of boolean;

MaxNbActions]

MaxNbCond]

of string[30]; of string[30];

MaxNbActions]

PtrNoeud: ^Noeud;

Noeud = record

case Feuille: boolean of false: (TxtCond: string[30]; Vrai, Faux: PtrNoeud);

true: (Actions: array[1 end; { Noeud }

MaxNbActions]

of boolean);

function ConstruitArbre(Table: TableDecision): PtrNoeud;

solution

Structuration des Données Informatiques - 14.2, exercice 2

Fichiers séquentiels indexés

Question posée au contrôle continu du 15 juin 1998

Soit une structure de fichier séquentiel indexé contenant des données occupant chacune 80 octets, dont 8 octets contiennent la clé d'accès.

1.a)

Quelle taille minimale de bloc de données permet d'éviter d'avoir de l'espace disque inutilisé dans le fichier? (en supposant des pages qui sont des multiples de 512 octets)

1.b)

Combien de données par bloc cela représente-t-il?

Si l'on prend la taille que vous avez trouvé en 1.a) aussi bien pour les blocs de données que pour les blocs d'index et si l'on suppose qu'une référence d'un bloc d'index vers un autre bloc (d'index ou de données) occupe 4 octets,

1.c)

 

Combien de données par bloc faudrait-il mettre pour atteindre un taux de remplissage d'environ

80%?

1.d)

 

Quelle place disque occupera le fichier lorsqu'il contiendra 100'000 éléments si on remplit les blocs de données à ~80%?

1.e)

 

Indiquez aussi la profondeur de l'arborescence d'index,

1.f)

 

le nombre de blocs d'index à chaque niveau de l'arborescence ainsi que

1.g)

le nombre total de blocs de données.

Solution

Structuration des Données Informatiques - 14.3, exercice 7

Exercice suivant

Recherche B-Arbre

Question posée au contrôle continu du 15 juin 1998 Soit le B-Arbre d'ordre 1 suivant.

du 15 juin 1998 Soit le B-Arbre d'ordre 1 suivant. 2.a)   Dessinez le B-arbre résultant

2.a)

 

Dessinez le B-arbre résultant de l'insertion de la valeur L dans le B-arbre ci-dessus.

2.b)

 

Dessinez le B-arbre résultant de la suppression de la valeur C dans le B-arbre ci-dessus.

2.c)

 

Dessinez le B-arbre résultant de l'insertion de la valeur Z dans le B-arbre ci-dessus.

2.d)

 

Dessinez le B-arbre résultant de la suppression de la valeur S dans le B-arbre ci-dessus.

2.e)

Dessinez le B-arbre résultant de la suppression de la valeur P dans le B-arbre ci-dessus. Solution

Exercice suivant

Structuration des Données Informatiques - 10.3, exercice 2

Le chemin du moindre coût

Question posée au contrôle continu du 15 juin 1998 1997

Un concurrent d'un cross-country doit traverser un terrain difficile du point A au point B. Avant la course, il veut choisir le chemin à suivre. Il a une carte du terrain:

veut choisir le chemin à suivre. Il a une carte du terrain: La légende montre les

La légende montre les types de terrains, et un nombre associé à chaque type qui indique la difficulté de sa traversée. D'une case de la carte on ne peut accéder qu'à ses quatre voisines au nord, au sud, à l'est et à l'ouest (le déplacement en diagonale est interdit).

Le concurrent est équipé d'un ordinateur, dans lequel la carte peut être stockée. On vous a demandé de participer à l'écriture d'un programme qui lui permette de trouver le meilleur chemin dans cette situation, c'est-à-dire le chemin du moindre coût.

3.a)

 

Comment représenteriez-vous l'ensemble des données fournies par la carte en utilisant un graphe? (Donnez juste une courte explication - ne dessinez pas le graphe entier.)

3.b)

 

Quelle(s) structure(s) de données serait la(les) plus efficace(s) pour stocker les noeuds et arcs d'un tel graphe? Ecrivez les déclarations Pascal qui définissent la(les) structure(s) que vous proposez.

3.c)

 

Quel algorithme de recherche utiliseriez-vous pour trouver le chemin le moins coûteux entre les points A et B? Justifier votre réponse, en considérant d'autres algorithmes possibles.

3.d)

Ecrivez une description précise, en pseudo-code, de l'algorithme de recherche choisi.

Structuration des Données Informatiques - 10.3, exercice 2

Solution

Structuration des Données Informatiques - 7.4, exercice 6

Exercice suivant

Chaînes bidirectionnelles

Question posée au contrôle continu du 4 mai 1998

Supposons qu'un programme d'édition de texte utilise la structure de chaîne de strings suivante pour représenter le texte en cours d'édition:

type VersLigne = ^UneLigne; UneLigne = record

Texte: string; LignePrecedente, LigneSuivante: VersLigne; end; { UneLigne }

var LeTexte: VersLigne; Ecrivez une procédure "Paragraphes", selon les déclarations suivantes, qui parcourt la structure de donnée pour détermine où se trouvent les paragraphes du texte (les paragraphes sont composés de une ou plusieurs lignes non vides séparées par une ou plusieurs lignes vides). Le résultat sera fourni comme une chaîne bidirectionnelle de descripteurs de paragraphes (type Para). Prenez bien soin à traiter tous les cas particuliers qui peuvent survenir

type PtrPara: ^Para; Para = record Debut, Fin: integer; Preced, Suivant: PtrPara; end; { Para }

procedure Paragraphes(UnTexte: VersLigne; var ChainePara: PtrPara);

Solution

Exercice suivant

Structuration des Données Informatiques - 7.1, exercice 1

Exercice suivant

Chaînes mono-directionnelles

Question posée au contrôle continu du 4 mai 1998

Compléter le programme suivant en donnant le corps des procédures Insertion et Afficher, étant donnée la structure de données citée par la suite

N.B. On conserve dans un tableau TabElement des chaînes avec leur taille respective. Program Chaines; {Programme qui permet d'affecter des valeurs aux chaînes qui se trouvent dans un tableau et d'afficher le contenu de ce tableau} CONST MaxNbSommets = MaxNumChaine =

TYPE

;

;

PtrNoeud = ^Noeud;

Noeud = RECORD Donnee: integer; Suivant: PtrNoeud; END;

EltNoeud = RECORD Taillechaine: Integer; Chaine: PtrNoeud;

END;

VAR TabElement: ARRAY[1

MaxNumChaine]

OF EltNoeud;

Procedure Insertion(Valeur, NumChaine : integer); {Procédure permettant d'insérer une valeur à la fin de la NumChaine-ème chaîne}

Procedure Afficher; {Procédure permettant d'afficher le contenu du champs "Donnee" pour toutes les chaînes du tableau}

Solution

Exercice suivant

Structuration des Données Informatiques - 7.4, exercice 6

Exercice suivant

Anneaux bidirectionnels

Question posée au contrôle continu du 4 mai 1998

Avec les déclarations suivantes définissant un anneau bidirectionnel, on aimerait ranger une valeur dans l'anneau où les données sont triées dans l'ordre croissant. Pour ce faire, écrire d'abord la procédure d'insertion ChercherInsertion, qui permet de déterminer le noeud d'insertion pour une valeur donnée. Puis écrire la procédure RangerValeur, qui fait appel à ChercherInsertion pour trouver où insérer la nouvelle valeur et fait l'insertion proprement dite à l'aide de la procédure InsererNoeud que nous supposerons déjà exister.

N.B. On suppose que le code de la procédure InsererNoeud est déjà fourni. TYPE

VAR

PtrNoeud = ^Noeud;

Noeud

Donnee : integer; Precedent, Suivant: PtrNoeud; END;

= RECORD

Entete : PtrNoeud; AnneauVide : boolean;

{Entête pour l'anneau} {Indicateur d'anneau vide}

Procedure InsererNoeud(var NPtr,TPtr : PtrNoeud); {Insère le Noeud NPtr après TPtr Vous n'avez pas besoin d'écrire le code de cette procédure}

Procedure ChercherInsertion(Valeur: Integer; VAR NoeudInsertion: PtrNoeud); {Permet de déterminer le noeud d'insertion pour la valeur donnée. ChercherInsertion retourne, dans NoeudInsertion, un pointeur vers le plus grand élément encore inférieur à la valeur passée en paramètre, ou NIL, si Valeur existe déjà dans l'anneau. }

Procedure RangerValeur(Valeur: Integer); {Permet de ranger une valeur donnée dans l'anneau trié }

Solution

Exercice suivant

Structuration des Données Informatiques - 8.1, exercice 3

Exercice suivant

Arbre syntaxique

Question posée au contrôle continu du 4 mai 1998

En supposantque l'on dispose des fonctions suivantes pour contruire une structure d'arbre:

type PtrNoeud: ^Noeud;

function Feuille(Contenu: char): PtrNoeud;

{ crée par allocation dynamique un noeud sans descendant et contenant un caractère }

function Arbre(ContenuRacine:char; Gauche, Droit: PtrNoeud): PtrNoeud;

{

crée, par allocation dynamique, un nouveau noeud racine auquel seront rattachés les sous-arbres gauche et droit fournis en paramêtre, de façon à former un nouvel arbre }

.

Quelle sera l'expression qui permettra de construire, en une seule instruction Pascal, l'arbre suivant:

en une seule instruction Pascal, l'arbre suivant: b. Donnez une déclaration possible pour le type Noeud

b.

Donnez une déclaration possible pour le type Noeud ainsi que le code des deux fonctions Feuille et Arbre.

Solution

Exercice suivant

Structuration des Données Informatiques - 10.3, exercice 1

exercice suivant

Structures de graphes

Question posée à l'examen écrit du 13 octobre 1997

En s'inspirant de la description de graphes non-orientés en termes de type abstrait vue au cours, nous allons supposer que les types "Graphe" et "SerieDeSommets" ont été définis, sans que vous ne connaissiez les détails de ces structures. Nous allons aussi supposer que les primitives suivantes sont à votre disposition:

function Index(NomSommet: string; LeGraphe: Graphe): integer;

{ retourne un numero compris entre 1 et MaxNbSommets }

function NomSommet(IndexSommet: integer; LeGraphe: Graphe) :string;

{ retourne le nom du sommet dont l'index est fourni }

function NombreDeSommets(LeGraphe: Graphe): integer; {retourne le nombre de sommets effectifs composant le graphe} function SommetsVoisins(IndexSommet: integer; LeGraphe: Graphe): SerieDeSommets;

{ retourne une structure permettant de retrouver l'index des voisins immédiats }

function PremierSommet(var UneSerie: SerieDeSommets): integer;

{ extrait le premier des sommets de la série et retourne son index }

function SommetSuivant(var UneSerie: SerieDeSommets): integer;

{ extrait le prochain sommet de la serie & retourne son index} function FinDeSerie(UneSerie: SerieDeSommets): boolean;

{ vrai s'il n'y a plus de sommet suivant dans la serie }

En utilisant ces primitives, tout en ignorant de quelle façon la structure de graphe est implantée, écrivez une procédure de parcours en profondeur qui imprime les noms des sommets du graphe fourni en paramêtre:

procedure DFS(LeGraphe: Graphe);

Solution

exercice suivant

Structuration des Données Informatiques - 10.4, exercice 1

Arbre lexicographique

Question posée au contrôle continu du 16 juin 1997

On veut construire un arbre multiple d'ordre 26 permettant de stocker des mots d'un dictionnaire de sorte que les chemins partant de la racine représentent des mots du dictionnaire, de la façon suivante

des mots du dictionnaire, de la façon suivante Les arcs sont étiquettés avec les lettres de

Les arcs sont étiquettés avec les lettres de l'alphabet (on suppose ici que l'on ne tient pas compte des accents sur les lettres) et les noeuds contiennent un booléen indiquant si le chemin de la racine à ce noeud représente un mot complet ou pas (sur le dessin - = faux et * = vrai).

Sur la base des déclarations suivantes, écrivez une procédure imprimant touts les mots du dictionnaire dans l'ordre croissant de longueur de mot et, pour des mots d'une même longueur, par ordre alphabétique:

type VersNoeud= ^Noeud; Noeud= record Desc: array['a' Complet: boolean; end; { Noeud }

'z']

var Dico: VersNoeud;

of VersNoeud;

procedure Imprime(LeDico: VersNoeud);

Note: vous avez intérêt à considérer cet arbre lexicographique comme un graphe orienté et appliquer une des méthodes de parcours de graphe. Vous pouvez aussi considérer, si vous en avez besoin, que vous disposez d'un type "Pile" ou "FileDAttente" avec leurs procédures de manipulation. Vous pouvez aussi utiliser des strings pour réconstituer une séquence de lettres formant un mot.

Solution

Structuration des Données Informatiques - 13.4, exercice 1

exercice suivant

Hash-code

Question posée au contrôle continu du 16 juin 1997

Soient deux fonctions de hash-code H 1 et H 2 retournant les valeurs numériques suivantes:

mot:

les examens du premier cycle pour lesquels il n y

aurait qu

H 1 (mot): 15

6

11 1

3

6

2

5

7 15 2

9

H 2 (mot): 8

5

12 14

2

10

17

7

5 13 8

22

mot:

un examen oral a

subir sont admis si chaque note atteint quatre

H 1 (mot): 13 18

16

11 10

23

8

8

9

20

15

22

H 2 (mot): 9

6

1

4

3

7

13

6 17

2

12

16

On suppose que l'on utilise la méthode du chaînage externe à partir d'un tableau de 11 positions, en utilisant H 1 pour déterminer quelle chaîne utiliser et H 2 pour trier les éléments d'une même chaîne (c'est-à-dire qu'au sein d'une même chaîne, un mot m i sera placé avant un autre mot m j si H 2 (m i )<H 2 (m j )). Dessinez le tableau des chaînes que l'on obtient, en mettant un mot et le résultat de H 2 pour ce mot dans chaque élément de chaîne. Indiquez quelle expression basée sur H 1 vous avez utilisée pour le choix de la chaîne.

Solution

exercice suivant

Structuration des Données Informatiques - 15.1, exercice 1

exercice suivant

Tables de décision

Question posée au contrôle continu du 16 juin 1997

Avec les déclarations suivantes définissant des tables de décision, écrivez une procédure "Extension" qui convertisse une table de décision condensée (paramètre d'entrée) en table étendue (paramètre de sortie):

const MaxNbCond = MaxNbRegles = MaxNbActions =

;

;

;

type Conditions =(Vrai, Faux, Indetermine);

TableDecision = record NbConditions: 1 MaxNbCond; NbRegles: 1 MaxNbRegles; ValCond: array[1 MaxNbRegles, 1 MaxNbCond] of Conditions; NbActions: 1 MaxNbActions; Agir: array[1 MaxNbRegles, 1 MaxNbActions] of boolean; TxtConditions:array[1 MaxNbCond] of string[30]; TxtActions:array[1 MaxNbActions] of string[30]; end; { TableDecision }

procedure Extension(Entree: TableDecision; var Sortie: TableDecision);

Note: Pour simplifier l'écriture, vous pourrez supposer que l'affectation d'enregistrements ou de tableaux est autorisée en Pascal.

Solution

exercice suivant

Structuration des Données Informatiques - 7.4, exercice 4

Exercice suivant

Chaînes bidirectionnelles

Question posée au contrôle continu du 28 avril 1997

Supposons qu'un programme d'édition de texte utilise la structure de chaîne de strings suivante pour représenter le texte en cours d'édition:

type VersLigne = ^UneLigne; UneLigne = record

Texte: string; LignePrecedente, LigneSuivante: VersLigne; end; { UneLigne }

var LeTexte: VersLigne;

a)

 

Ecrivez une procédure "EchangeLignes", selon la déclaration suivante, qui échange deux éléments de la structure (on ne veut pas juste échanger le contenu du champs Texte):

procedure EchangeLignes(var UnTexte: VersLigne; NoLigne1, NoLigne2: integer);

b)

Ecrivez une procédure "InverserLignes", selon la déclaration suivante, qui inverse complètement l'ordre des lignes dans la structure de donnée:

procedure InverserLignes(var UnTexte: VersLigne); Dans les deux cas, il faudra prendre soin de vérifier tous les cas particuliers et diagnostiquer toutes les erreurs éventuelles.

Solution

Exercice suivant

Structuration des Données Informatiques - 7.4, exercice 5

Exercice suivant

Chaînes bidirectionnelles

Question posée au contrôle continu du 28 avril 1997

Dans le programme suivant, vous disposez d'une chaine bidirectionnelle qui a un pointeur supplémentaire (appelé ici S2):

program test(input, output); type Ptr = ^Noeud; Noeud = record info : integer; Preced, Suiv, S2 : Ptr;

end;

var LaChaine, P : Ptr;

procedure CreeS2(Depart:Ptr); var Deplacement, i:integer;

Courant, Etape

: Ptr;

FinEtape : boolean; begin Etape := Depart; while Etape <> nil do begin Deplacement := Etape^.info; i := 1; Courant := Etape; FinEtape := false; if Deplacement > 0 then begin

while (i <= Deplacement) and (not FinEtape) do if Courant^.Suiv <> nil then begin

i := i+1;

Courant := Courant^.Suiv; end {then} else begin Courant := nil; FinEtape := true; end; {if} Etape^.s2 := Courant; end {then} else begin Deplacement := -Deplacement;

while (i <= Deplacement) and (not FinEtape) do if Courant^.Preced <> nil then begin

i := i+1;

Courant := Courant^.Preced;

Structuration des Données Informatiques - 7.4, exercice 5

end {then} else begin Courant := nil; FinEtape := true; end; {if} Etape^.s2 := Courant; end; {else} Etape := Etape^.Suiv; end; {while} end; {CreeS2} begin initialise(LaChaine);

CreeS2(LaChaine);

P := LaChaine; if P <> nil then repeat

write(P^.info:1,'->');

P := P^.s2; until P = nil; else writeln('nil'); end. où la procédure initialise(var Depart:Ptr); est utilisée pour faire les initialisations: créer la chaine et initialiser le pointeur S2 à nil. Quel résultat sera affiché quand LaChaine pointe sur:

1.

2

->

0 -> 1

->

1 -> -3

2.

3

->

-1 ->

2 ->

-1 -> -3

Solution

Exercice suivant

Structuration des Données Informatiques - 8.2, exercice 2

Arbre généalogique

Question posée au contrôle continu du 28 avril 1997

program arbre_genealogique;

const MaxLongueurNom = 30;

type

Genre = (Masculin, Feminin);

Noms = array[1

ChaineFreresSoeurs = ^NoeudFrereSoeur; PersonnePtr = ^Personne;

MaxLongueurNom]

of char;

NoeudFrereSoeur = record FrereOuSoeur: PersonnePtr; FrereSoeurSuivant: ChaineFreresSoeurs; end; {NoeudFrereSoeur}

Personne = record Nom: Noms; Prenom: Noms; Sexe: Genre; Epoux: PersonnePtr; FreresEtSoeurs: ChaineFreresSoeurs; Enfants: ChaineFreresSoeurs; end; {Personne}

function NouvellePersonne(SonNom, SonPrenom: Noms; SonSexe: Genre):

PersonnePtr; var laPersonne: PersonnePtr; begin new(laPersonne); with laPersonne^ do begin Nom := SonNom; Prenom := SonPrenom; Sexe := SonSexe; Epoux := nil; FreresEtSoeurs := nil; end; {with} NouvellePersonne := laPersonne; end; {NouvellePersonne}

Structuration des Données Informatiques - 8.2, exercice 2

procedure Epouse(epoux1, epoux2: PersonnePtr); begin epoux1^.Epoux := epoux2; epoux2^.Epoux := epoux1; end; {Epoux}

procedure AjouteEnfant(Parent, Enfant: PersonnePtr); var NouveauNoeud, EnfantCourant, EnfantPrecedent: ChaineFreresSoeurs; begin new(NouveauNoeud); with NouveauNoeud^ do begin FrereOuSoeur := Enfant; FrereSoeurSuivant := nil; end; {with} EnfantCourant := Parent^.Enfants; if EnfantCourant = nil then begin {Ce nouvel Enfant est leur premier Enfant} Parent^.Enfants := NouveauNoeud; if Parent^.Epoux <> nil then Parent^.Epoux^.Enfants := NouveauNoeud; Enfant^.FreresEtSoeurs := NouveauNoeud; end {if} else begin Enfant^.FreresEtSoeurs := EnfantCourant; {cherche le dernier Enfant} while EnfantCourant <> nil do begin EnfantPrecedent := EnfantCourant; EnfantCourant := EnfantCourant^.FrereSoeurSuivant; end; {while} EnfantPrecedent^.FrereSoeurSuivant := NouveauNoeud; end; {else} end; {AjouteEnfant}

Sur la base des déclarations et procédures ci-dessus, qui permettent de construire un arbre généalogique:

1. dessinez un diagramme qui montre l'utilisation de cette structure pour une famille contennant au moins deux generations;

2. écrivez une procédure qui trouvera tous les petits-enfants d'une personne et imprimera leurs noms et prénoms:

procedure ImprimePetitsEnfants(LaPersonne: PersonnePtr);

Solution

Structuration des Données Informatiques - 8.1, exercice 2

Exercice suivant

Arbre syntaxique et chaîne

Question posée à l'écrit du 5 mars 1997

Soit un arbre syntaxique contenant une expression arithmétique, basé sur les déclarations suivantes:

type Contenus = (Operande, Operateur); Operations=(Addition, Soustraction, Multiplication, Division); VersNoeud = ^Noeud; Noeud = record case Contenu: Contenus of Operande: (Valeur: integer); Operateur:(Operation: Operations; Gauche,Droite: VersNoeud); end; (* Noeud *) Ecrivez une procédure qui convertira un tel arbre syntaxique en une chaîne contenant la même expression arithmétique en notation polonaise postfixée. Vous utiliserez à cet effet les déclarations suivantes:

type VersMaillon = ^Maillon; Maillon = record Suivant: VersMaillon; case Contenu: Contenus of Operande: (Valeur: integer); Operateur:(Operation: Operations); end; (* Maillon *) Pour rappel, la notation polonaise postfixée consiste à noter une expression arithmétique avec l'opérateur à la suite des opérandes sur lesquels il porte. Cette notation ne nécessite donc pas de parenthèses. Par exemple, l'expression (85 - 9) * ((78 + 45) / (6 - 2)) est notée, en notation polonaise postfixée, de la façon suivante: 85 9 - 78 45 + 6 2 - / *. Pour vous aider, sachez que cette conversion correspond à une des méthodes classiques de parcours d'arbre.

Exercice suivant

Structuration des Données Informatiques - 14.3, exercice 2

Exercice suivant

B-arbre

Question posée à l'écrit du 5 mars 1997

a) Soit le B-arbre d'ordre 2 suivant, dessinez le B-arbre résultant de l'insertion de la valeur 10

le B-arbre résultant de l'insertion de la valeur 10 b) Soit le B-arbre d'ordre 2 suivant,

b) Soit le B-arbre d'ordre 2 suivant, dessinez le B-arbre résultant de l'insertion de la valeur 21

le B-arbre résultant de l'insertion de la valeur 21 c) Avec le même B-arbre de départ

c) Avec le même B-arbre de départ qu'au point b, dessinez le B-arbre résultant de la suppression de la

valeur 55.

d)

Soit le B-arbre d'ordre 2 suivant, dessinez le B-arbre résultant de l'insertion de la valeur 23

le B-arbre résultant de l'insertion de la valeur 23 e) 4. f) valeur 15. Solution Exercice

e)

4.

f)

valeur 15.

Solution

Exercice suivant

Avec le même B-arbre de départ qu'au point d, dessinez le B-arbre résultant de l'insertion de la valeur

Avec le même B-arbre de départ qu'au point d, dessinez le B-arbre résultant de la suppression de la

Structuration des Données Informatiques - 7.4, exercice 3

Exercice suivant

Chaînes bidirectionnelles

Question posée à l'examen écrit du 15 octobre 1996

Supposons qu'un programme d'édition de texte utilise la structure de chaîne de strings suivante pour représenter le texte en cours d'édition:

type VersLigne = ^UneLigne; UneLigne = record

Texte: string; LignePrecedente, LigneSuivante: VersLigne; end; { UneLigne }

var LeTexte: VersLigne;

a)

 

Ecrivez une procédure "EffaceLigne", selon la déclaration suivante, qui change la structure de donnée pour refléter la suppression d'une ligne du texte:

procedure EffaceLigne(var UnTexte: VersLigne; NumeroLigne: integer);

b)

Ecrivez une procédure "JoindreLignes", selon la déclaration suivante, qui change la structure de donnée pour combiner la ligne courante et la ligne suivante en une seule ligne (le contenu de la ligne suivante est inséré à la fin de la ligne courante et la ligne suivante est alors supprimée):

procedure JoindreLignes(var UnTexte: VersLigne; LigneCourante: integer); Dans les deux cas, il faudra prendre soin de vérifier tous les cas particuliers et diagnostiquer toutes les erreurs éventuelles.

Solution

Exercice suivant

Structuration des Données Informatiques - 14.2, exercice 1

Exercice suivant

Fichiers séquentiels indexés et B-arbres

Question posée à l'examen du 15 octobre 1996

a)

Quelle est la taille de l'espace disque nécessaire pour être sûr de pouvoir créer un fichier séquentiel indexé qui doit contenir 1'000'000 éléments, sachant qu'un élément nécessite une place de 76 octets, dont une clé de 8 octets, que les blocs de données ont une taille de 1536 octets et les blocs d'index 1024 octets et que les pages de données sont initialement remplies à 80%? On supposera que les références, dans un bloc d'index, à un autre bloc d'index ou à un bloc de donnée, tiennent sur 4 octets. Justifiez votre réponse et donnez le détail des calculs. En plus de la taille de l'espace disque, vous indiquerez, entre autres, le nombre de blocs de données, la profondeur de l'arborescence des blocs d'index et le nombre de blocs d'index à chaque niveau.

b)

Pour les mêmes données (même nombre et même taille d'élément), quelle sera la taille de l'espace disque nécessaire et le nombre de niveaux si l'on utilise une structure de B-arbre avec des pages de 1024 octets (donnez les valeurs minimales et maximales possibles, dans l'hypothèse de pages à moitié pleines ou entièrement pleines)? Là aussi, justifiez votre réponse et donnez le détail des calculs: ordre du B-arbre, nombre de pages minimum et maximum, N.B. Comme pour le séquentiel indexé, les références à une page occupent 4 octets.

Solution

Exercice suivant

Structuration des Données Informatiques - 7.2, exercice 1

Chaînes mono-directionnelles

Question posée à l'examen écrit du 9 juillet 1996

Soit une d`une chaîne monodirectionnelle avec des éléments entiers. Ecrivez une procédure Pascal qui supprime à la fois le premier et le dernier élément de la chaîne, et ceci de manière répétitive, jusqu`a ce qu'il ne reste qu'un seul élément, ou jusqu'a ce que la chaîne soit vide. La procédure donnera comme résultat soit le dernier élément restant, soit le pointeur "nil".

Exemples:

1.

1.

Dans ce cas, on supprime les éléments contenant les valeurs entièlres 2 et -1, et le résultat de la procédure sera alors 3.

2.

2.

Dans ce cas, on supprimera d'abord 2 et 5, ensuite 3 et -1, et le résultat sera alors "nil".

Solution

Structuration des Données Informatiques - 11.3, exercice 2

Exercice suivant

Réseau autoroutier

Soit un réseau autoroutier tel que celui-ci:

autoroutier Soit un réseau autoroutier tel que celui-ci: 1. Quelle structure(s) de donnée(s) utiliseriez-vous pour

1. Quelle structure(s) de donnée(s) utiliseriez-vous pour le représenter; dessinez-la.

2. Donnez le détail des déclarations que vous feriez, en Pascal.

3. Ecrivez une fonction qui déterminera la distance minimale à parcourir entre deux villes données en paramètre.

Solution

Exercice suivant

Structuration des Données Informatiques - 7.4, exercice 1

Exercice suivant

Anneaux bidirectionnels

Question posée au conctrôle continu du 17 juin 1996

On vous fournit un entier ainsi qu'un anneau bidirectionnel ayant comme éléments des entiers, pouvant être négatifs. On vous demande de vous déplacer dans l'anneau à la position absolue donnée par l'entier qui vous est donné. Là, vous prenez l'entier qui se trouve dans l'élément courant, vous supprimez l'élément courant, et vous vous déplacez dans l'anneau, cette fois-ci de façon relative à la position courante en fonction du nombre qui s'y trouvait. Vous devez répéter ces pas (prendre l'entier, supprimer l'élément, se déplacer) jusqu'à ce que il n'y ait plus d'élément dans l'anneau, jusqu'à ce que vous sortiez de l'anneau, ou bien jusqu'à ce que vous rencontriez la valeur 0 (zéro) dans l'anneau. (Attention, si vous arrivez à la fin de l'anneau, il ne faut pas repartir depuis le début; de même, si on arrive au début, il ne faut pas continuer à la fin).

On vous demande de fournir, dans un paramètre de sortie, le type d'arrêt et d'imprimer, dans la procédure, les valeurs se trouvant dans les éléments visités. Utilisez les déclarations suivantes:

type TypeArret = (SortieAnneau, ElementNul, AnneauVide); Anneau = ^Element; Element = record Entier : Integer; Predecesseur, Succeseur : Anneau; end; { Element }

procedure DeplacerDansAnneau(var UnAnneau : Anneau; Deplacement: integer; var Arret : TypeArret);

Exemple:

Deplacement: integer; var Arret : TypeArret); Exemple: Dans le cas ci-dessus, si l'entier donné initialement

Dans le cas ci-dessus, si l'entier donné initialement est 1, on va à la première position, on prend 2, on l'imprime et on supprime la première position de l'anneau. On se déplace en avant de 2 positions (correspondant à la position 3 dans l'anneau initial), on prend -2, on l'imprime et on supprime l'é lément. Ensuite il faut signaler la fin du programme, parce qu'avant l'élément que l'on vient de suprimer il n'y a qu'un seul élément (contenant 4) et l'on ne peut donc pas se déplacer de 2 éléments en arrière.

Solution

Exercice suivant

Structuration des Données Informatiques - 8.1, exercice 1

Exercice suivant

Arbre de tri

Question posée au conctrôle continu du 17 juin 1996

a) Etant donné l'arbre de tri suivant, donnez une séquence possible des données fournies en entrée qui

aurait permis d'aboutir à l'arbre de tri en question:

permis d'aboutir à l'arbre de tri en question: b) idem pour l'arbre suivant: Solution Exercice suivant

b) idem pour l'arbre suivant:

de tri en question: b) idem pour l'arbre suivant: Solution Exercice suivant

Solution

Exercice suivant

Structuration des Données Informatiques - 11.5, exercice 1

Exercice suivant

Tri topologique inverse

Question posée au conctrôle continu du 17 juin 1996

En s'inspirant de la description de graphes non-orientés en termes de type abstrait vue au cours, nous allons supposer que les types "Graphe" et "SerieDeSommets" ont été définis, sans que vous ne connaissiez les détails de ces structures. Nous allons aussi supposer que les primitives suivantes sont à votre disposition:

function Index(NomSommet: string; LeGraphe: Graphe): integer;

{ retourne un numero compris entre 1 et MaxNbSommets }

function NomSommet(IndexSommet: integer; LeGraphe: Graphe) :string;

{ retourne le nom du sommet dont l'index est fourni }

function Nom