32
TD I3 v1.4.1 avec solution N. Delestre Table des mati` eres 1 Affectation et sch´ ema conditionnel 3 1.1 Affectation ..................................... 3 1.1.1 ´ Echanger .................................. 3 1.1.2 Permutation circulaire ........................... 3 1.1.3 ecomposition d’une somme d’argent ................... 3 1.1.4 Parit´ e .................................... 4 1.1.5 Date valide ................................. 4 1.2 Sch´ ema conditionnel ................................ 5 1.2.1 Tri de trois entiers ............................. 5 1.2.2 Nombre de jours de cong´ es ......................... 6 2 Sch´ ema it´ eratif 6 2.1 La multiplication .................................. 6 2.2 Calcul de factorielle n ................................ 7 2.3 Partie enti` ere inf´ erieure de la racine carr´ ee d’un nombre .............. 7 2.4 Multiplication ´ egyptienne .............................. 7 2.5 Int´ egration par la m´ ethode des trap` ezes ....................... 8 3 Sch´ ema it´ eratif (suite) 9 3.1 eveloppement limit´ e ................................ 9 3.2 Nombres premiers .................................. 10 3.3 Recherche du z´ ero d’une fonction par dichotomie ................. 10 4 Analyse descendante 11 4.1 Nombre de chiffres pairs dans un nombre ..................... 11 4.2 Majuscule ...................................... 12 4.2.1 Analyse ................................... 12 4.2.2 Conception pr´ eliminaire .......................... 13 4.2.3 Conception d´ etaill´ ee ............................ 13 5 TP Pascal : des multiplications 14 6 Tableaux 15 6.1 Plus petit ´ el´ ement d’un tableau d’entiers ...................... 16 6.2 Indice du plus petit ´ el´ ement d’un tableau d’entiers ................. 16 6.3 Nombre d’occurrences d’un ´ el´ ement ........................ 16 1

TD algorithme avec Corrections

  • Upload
    micipsa

  • View
    140

  • Download
    14

Embed Size (px)

DESCRIPTION

TD algorithme avec Corrections

Citation preview

Page 1: TD algorithme avec Corrections

TD I3v1.4.1

avec solution

N. Delestre

Table des matieres

1 Affectation et schema conditionnel 31.1 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.1.1 Echanger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.1.2 Permutation circulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.1.3 Decomposition d’une somme d’argent . . . . . . . . . . . . . . . . . . . 31.1.4 Parite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.1.5 Date valide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Schema conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2.1 Tri de trois entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2.2 Nombre de jours de conges . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Schema iteratif 62.1 La multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2 Calcul de factorielle n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3 Partie entiere inferieure de la racine carree d’un nombre . . . . . . . . . . . . . . 72.4 Multiplication egyptienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.5 Integration par la methode des trapezes . . . . . . . . . . . . . . . . . . . . . . . 8

3 Schema iteratif (suite) 93.1 Developpement limite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.2 Nombres premiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.3 Recherche du zero d’une fonction par dichotomie . . . . . . . . . . . . . . . . . 10

4 Analyse descendante 114.1 Nombre de chiffres pairs dans un nombre . . . . . . . . . . . . . . . . . . . . . 114.2 Majuscule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.2.1 Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124.2.2 Conception preliminaire . . . . . . . . . . . . . . . . . . . . . . . . . . 134.2.3 Conception detaillee . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

5 TP Pascal : des multiplications 14

6 Tableaux 156.1 Plus petit element d’un tableau d’entiers . . . . . . . . . . . . . . . . . . . . . . 166.2 Indice du plus petit element d’un tableau d’entiers . . . . . . . . . . . . . . . . . 166.3 Nombre d’occurrences d’un element . . . . . . . . . . . . . . . . . . . . . . . . 16

1

Page 2: TD algorithme avec Corrections

6.4 Element le plus frequent d’un tableau . . . . . . . . . . . . . . . . . . . . . . . 176.5 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186.6 Tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

6.6.1 Tri par insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186.6.2 Tri shaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

7 TP Pascal : Matrice 20

8 Recursivite 238.1 Calcul de C(n,p) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238.2 Multiplication egyptienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238.3 Des cercles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

8.3.1 Comprehension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248.3.2 Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

8.4 Recherche d’un element dans un tableau . . . . . . . . . . . . . . . . . . . . . . 26

9 TP Pascal : Benchmark de tri 279.1 Resultats attendus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

9.1.1 testTri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279.1.2 benchmark . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

9.2 Travail a realiser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

10 TP Pascal : Benchmark de tri (suite) 2810.1 Resultats attendus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

10.1.1 testTri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2810.1.2 benchmark . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

10.2 Travail a realiser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

11 Liste chaınee 29

12 TP Pascal : Liste chaınee 3112.1 Resultats attendus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3112.2 Travail a realiser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

13 TP Pascal : Fichiers 3113.1 Resultats attendus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3213.2 Travail a realiser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2

Page 3: TD algorithme avec Corrections

1 Affectation et schema conditionnel

1.1 Affectation

1.1.1 Echanger

Ecrire une procedure, echangerDeuxEntiers, qui permet d’echanger les valeurs de deux entiers.

Solution proposee :procedure echangerDeuxEntiers (E/S a,b : Entier)

Declaration temp : Entierdebut

temp← aa← bb← temp

fin

1.1.2 Permutation circulaire

Ecrire une procedure qui permet d’affectuer une permutation circulaire des valeurs entieres detrois variables x, y, z (c’est-a-dire la valeur de y dans x, la valeur de z dans y et la valeur de x dansz.

Solution proposee :procedure permutationDeTroisEntiers (E/S x,y,z : Entier)

Declaration temp : Entierdebut

temp← xx← yy← zz← temp

fin

1.1.3 Decomposition d’une somme d’argent

Ecrire une procedure, decomposerSomme, qui a partir d’une somme ronde d’argent donnee,donne le nombre minimal de billets de 5 et 10¤ et le nombre de pieces de 2 et 1¤ qui la compose.

Solution proposee :procedure decomposerSomme (E somme : Naturel ;S nbBilletDe10, nbBilletDe5, nbPieceDe2,nbPieceDe1 : Naturel)

Declaration sommeRestante : Natureldebut

sommeRestante← sommenbBilletDe10← sommeRestante div 10sommeRestante← sommeRestante mod 10nbBilletDe5← sommeRestante div 5sommeRestante← sommeRestante mod 5nbPieceDe2← sommeRestante div 2

3

Page 4: TD algorithme avec Corrections

nbPieceDe1← sommeRestante mod 2fin

A titre d’exemple de raisonnement a mener pour la validation structurelle de votre algorithme,voici la demarche a effectuer.

– Coherence des types : Ici, il n’apparait pas explicitement de contrainte sur le type des pa-rametres. Cette contrainte est induite par la semantique (ce qui est le cas le plus frequent).Compte tenu de la semantique des parametres, ici le type a utiliser est ”Naturel” et non pas”Entier”. En effet ”Entier” autoriserait la definition de donnees negatives (ce qui n’est paspossible pour une somme d’argent a decomposer).

– Les parametres de sortie sont tous au moins presents une fois en partie gauche d’une affec-tation.

– Le parametre d’entree n’est jamais present en partie gauche d’une affectation.– Le type utilise pour la variable temporaire est compatible avec le type des parametres.Une fois ces controles effectues, cela ne signifie pas que votre algorithme est juste mais seule-

ment qu’il a une chance d’etre juste car il sera structurellement correct. Son adequation semantiqueelle ne peut pas etre verifiee formellement a ce stade de vos connaissances.

Il vous appartient maintenant d’appliquer ce raisonnement aux alogrithmes que vous ecrivez.

1.1.4 Parite

Ecrire une fonction booleenne, estPair, qui a partir d’un nombre entier strictement positif re-tourne VRAI si ce nombre est pair et FAUX sinon.

Solution proposee :fonction estPair (a : NaturelNonNul) : Booleendebut

retourner a mod 2 = 0fin

Ici, une contrainte apparait sur le parametre qui doit etre un entier strictement positif. Le typeassocie est alors NaturelNonNul.

1.1.5 Date valide

Ecrire une fonction qui pour un numero de jour, de mois et d’annee donnes, determine s’ils’agit ou non d’une date, apres JC, valide (d’apres le calendrier gregorien).Rappel 1 :

“Depuis l’instauration du calendrier gregorien, sont bissextiles :

1. les annees divisibles par 4 mais non divisibles par 100

2. les annees divisibles par 400

Ainsi, l’an 2004 etait bissextile suivant la premiere regle. L’an 1900 n’etait pas bissex-tile, car divisible par 100, ce qui va a l’encontre de la premiere regle, et non divisiblepar 400, ce qui va a l’encontre de la seconde. L’an 2000 etait bissextile car divisiblepar 400.”

Solution proposee :Une date j/m/a est valide si et seulement si a > 0 et :– lorsque m ∈ {1, 3, 5, 7, 8, 10, 12} alors j ∈ [1..31]

1. D’apres Wikipedia

4

Page 5: TD algorithme avec Corrections

– lorsque m ∈ {4, 6, 9, 11} alors j ∈ [1..30]– lorsque m = 2, alors j ∈ [1..28] pour les annee non bissextile et j ∈ [1..29] sinon.

fonction dataValide (j : 1..31, m : 1..12, a : NaturelNonNul) : BooleenDeclaration validePourMoisEn31Jours, validePourMoisEn30Jours, validePourMoisFevrier :

Booleendebut

validePourMoisEn31Jours ← (m=1 ou m=3 ou m=5 ou m=7 ou m=8 ou m=10 ou m=12) etj≤31validePourMoisEn30Jours← (m=4 ou m=6 ou m=9 ou m=11) et j≤30validePourMoisFevrier← m=2 et ((((a mod 4 = 0 et a mod 100 6= 0) ou (a mod 400 = 0)) etj≤29) ou j≤28)retourner a>0 et j>0 (validePourMoisEn31Jours ou validePourMoisEn30Jours ou valide-PourMoisFevrier)

fin

1.2 Schema conditionnel

1.2.1 Tri de trois entiers

Ecrire une procedure, trierTroisEntiers, qui prend en entree trois parametres a, b et c contenantchacun un entier et qui les retourne tries par ordre croissant : a contient la valeur minimum, et ccontient la valeur maximum.

Solution proposee :procedure echanger (E/S a,b : Entier)

Declaration temp : Entierdebut

temp← aa← bb← temp

fin

procedure trierDeuxEntiers (E/S a,b : Entier)debut

si a>b alorsechanger(a,b)

finsifin

procedure trierTroisEntiers (E/S a,b,c : Entier)debut

trierDeuxEntiers(a,b)trierDeuxEntiers(b,c)trierDeuxEntiers(a,b)

fin

5

Page 6: TD algorithme avec Corrections

1.2.2 Nombre de jours de conges

Dans une entreprise, le calcul des jours de conges payes s’effectue de la maniere suivante : siune personne est entree dans l’entreprise depuis moins d’un an, elle a droit a deux jours de congespar mois de presence (au minimum 1 mois), sinon a 28 jours au moins. Si cette personne est uncadre et si elle est agee d’au moins 35 ans et si son anciennete est superieure a 3 ans, il lui estaccorde 2 jours supplementaires. Si elle est cadre et si elle est agee d’au moins 45 ans et si sonanciennete est superieure a 5 ans, il lui est accorde 4 jours supplementaires, en plus des 2 accordespour plus de 35 ans.

Ecrire une fonction, nbJoursDeConges, qui calcule le nombre de jours de conges a partir del’age exprime en annee, l’anciennete exprimee en mois et l’appartenance (booleenne) au collegecadre d’une personne.

Solution proposee :fonction nbJoursDeConges (age : 16..65 ; anciennete : NaturelNonNul ; cadre : Booleen) : Natu-rel

Declaration nbJours : Natureldebut

si anciennete<12 alorsnbJours← anciennete*2

sinonnbJours← 28

finsisi cadre alors

si age ≥ 35 et anciennete ≥ 3*12 alorsnbJours← nbJours + 2

finsisi age ≥ 45 et anciennete ≥ 5*12 alors

nbJours← nbJours + 4finsi

finsiretourner nbJours

fin

2 Schema iteratif

2.1 La multiplication

Ecrire une fonction, multiplication, qui effectue la multiplication de deux entiers positifs (notesx et y) donnes en utilisant uniquement l’addition entiere.

Solution proposee :fonction multiplication (x,y : Naturel) : Naturel

Declaration i, produit : Natureldebut

produit← 0pour i←1 a x faire

produit← produit + y

6

Page 7: TD algorithme avec Corrections

finpourretourner produit

fin

2.2 Calcul de factorielle n

Ecrire une fonction, factorielle, qui calcule pour un entier positif donne n la valeur de n !.

Solution proposee :fonction factorielle (n : Naturel) : Naturel

Declaration i, valeur : Natureldebut

valeur← 1pour i←1 a n faire

valeur← valeur * ifinpourretourner valeur

fin

2.3 Partie entiere inferieure de la racine carree d’un nombre

Ecrire une fonction, racineEntiere, qui retourne la partie entiere de la racine carree d’un entierpositif donne n (sans utiliser racineCarree).

Solution proposee :fonction racineEntiere (n : Naturel) : Naturel

Declaration racine : Natureldebut

racine← 1tant que racine * racine ≤ n faire

racine← racine + 1fintantqueretourner racine - 1

fin

2.4 Multiplication egyptienne

Les egyptiens de l’antiquite savaient :– additionner deux entiers strictement positifs,– soustraire 1 a un entier strictement positif,– multiplier par 1 et 2 tout entier strictement positif,– diviser par 2 un entier strictement positif pair.Voici un exemple qui multiplie 14 par 13 en utilisant uniquement ces operations :

14 × 13 = 14 + 14 × (13 - 1) = 14 + 14 × 12= 14 + (14 × 2) × (12 / 2) = 14 + 28 × 6= 14 + (28 × 2) × (6 / 2) = 14 + 56 × 3= 14 + 56 + 56 × (3 - 1) = 70 + 56 × 2= 70 + (56 × 2) × (2 / 2) = 70 + 112 × 1= 70 + 112 = 182

7

Page 8: TD algorithme avec Corrections

Donner le corps de la fonction suivante :

fonction multiplicationEgyptienne (a,b : Naturel) : Naturel

Solution proposee :fonction multiplicationEgyptienne (a,b : Naturel) : Naturel

Declaration resultat : Natureldebut

resultat← 0tant que b>0 faire

si b mod 2=0 alorsa← 2*ab← b div 2

sinonresultat← resultat+ab← b-1

finsifintantqueretourner a

fin

2.5 Integration par la methode des trapezes

Ecrire une fonction, integrale, qui retourne la valeur de l’integrale d’une fonction f(x) reellecontinue sur l’intervalle reel [a, b]. L’integration consiste a decouper cet intervalle, en n sous-intervalles de longueur ∆. L’integrale d’un sous-intervalle [x, x + ∆] est approximee au trapezede base ∆ et de cotes f(x) et f(x + ∆). a, b et n vous sont donnes.

Remarque : la communication de f entre l’appelant et la fonction appelee, est realisee demaniere implicite (operation transparente pour vous). Cette remarque est valide pour tous lesexercices numeriques de ce type.

Solution proposee :fonction integrale (a,b : Reel ; n : NaturelNonNul) : Reelbprecondition(s) a ≤ b

Declaration x1, x2, ∆, somme : Reel

debutsomme← 0x1← a∆← (b - a)/npour i←1 a n faire

x2← x1 + ∆somme← somme + (f(x1) + f(x2))x1← x2

finpoursomme← somme * ∆ / 2retourner somme

fin

8

Page 9: TD algorithme avec Corrections

Soit vous introduisez une pre-condition sur (a, b) soit vous devez tenir compte dans l’algo-rithme pour le calcul de ∆ et utiliser valeurAbsolue(b-a).

Version un peu optimisee :fonction integrale (a,b : Reel ; n : NaturelNonNul) : Reelbprecondition(s) a ≤ b

Declaration x1, x2, ∆, somme : Reel

debutsomme← 0x← a∆← (b - a)/npour i←2 a n-1 faire

x← x + ∆somme← somme + f(x)

finpoursomme←∆*(somme+((f(a)+f(b)) / 2))retourner somme

fin

3 Schema iteratif (suite)

3.1 Developpement limite

Lorsque x est proche de 0, sinh(x) peut etre approxime a l’aide de la formule suivante :

n∑i=0

x2i+1

(2i + 1)!

Ecrire la fonction sinh en n’utilisant aucune autre fonction (pas d’analyse descendante) :

fonction sinh (x : Reel, n : Naturel) : ReelDeclaration i : Naturel

numerateur,denominateur : Reelresultat : Reel

debut. . .

fin

Solution proposee :fonction sinh (x : Reel, n : Naturel) : Reel

Declaration i : Naturelnumerateur,denominateur : Reelresultat : Reel

debutnumerateur← xdenominateur← 1

9

Page 10: TD algorithme avec Corrections

resultat← resultat+numerateur/denominateurpour i←1 a n faire

numerateur← numerateur*x*xdenominateur← (2*i+1)*(2*i)*denominateurresultat← resultat+numerateur/denominateur

finpourretourner resultat

fin

3.2 Nombres premiers

Ecrire une fonction booleenne, estPremier, qui a partir d’un entier strictement positif donne,retourne le resultat VRAI ou FAUX selon que le nombre est premier ou non. Pour memoire, voicila liste des nombres premiers inferieurs a 100 : 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97.

Solution proposee :fonction estPremier (n : NaturelNonNul) : Booleen

Declaration i : NaturelNonNul,premier : Booleen

debutpremier← VRAIi← 2tant que premier et i ≤ racineCarree(n) faire

si n mod i = 0 alorspremier← FAUX

finsii← i + 1

fintantqueretourner premier

fin

3.3 Recherche du zero d’une fonction par dichotomie

Ecrire une fonction, zeroFonction, qui calcule le zero d’une fonction reelle f(x) sur l’intervallereel [a, b], avec une precision epsilon. La fonction f ne s’annule qu’une seule et unique fois sur[a, b]. Pour trouver ce zero, la recherche procede par dichotomie, c’est-a-dire divise l’intervalle derecherche par deux a chaque etape. Soit m le milieu de [a, b]. Si f(m) et f(a) sont de meme signe,le zero recherche est dans l’intervalle [m, b], sinon il est dans l’intervalle [a, m]. a, b et epsilonvous sont donnes.

Solution proposee :fonction estMemeSigne (a,b : Reel) : Booleendebut

retourner a * b ≥ 0fin

fonction zeroFonction (a,b, epsilon : Reel) : Reelbprecondition(s) a ≤ b

10

Page 11: TD algorithme avec Corrections

Declaration borneMin, milieu, borneMax : Reel

debutborneMin← aborneMax← btant que (borneMax - borneMin) > epsilon faire

milieu← (borneMin + borneMax) / 2si estMemeSigne(f(borneMin), f(milieu)) alors

borneMin← milieusinon

borneMax← milieufinsi

fintantqueretourner borneMin

fin

4 Analyse descendante

4.1 Nombre de chiffres pairs dans un nombre

On se propose de calculer le nombre de chiffres pairs d’un nombre donne. On suit pour celal’analyse descendante presentee par la figure 1, tel que :

nbChiffresPairs resoud le probleme demande. Par exemple pour le nombre 821, on obtient 2.

nbChiffres permet d’obtenir le nombre de chiffres d’un nombre. Par exemple pour le nombre821, on obtient 3.

iemeChiffre permet d’obtenir le ieme chiffre d’un nombre. Par exemple pour 821, le premierchiffre est 1, le second 2 et le troisieme est 8 (on ne traite pas les erreurs).

estPair permet de savoir si un nombre est pair.

nbChiffresPairs

nbChiffres

iemeChiffre

estPair

FIGURE 1 – Analyse descendante

1. Reprenez le schema donne et completez le (tel que nous l’avons vu en cours).

2. Donnez la signature des fonctions ou procedures des operations donnees par l’analyse des-cendante.

3. Donnez le corps de la fonction ou procedure nbChiffresPairs.

Solution proposee :

11

Page 12: TD algorithme avec Corrections

1.

nbChiffresPairs

nbChiffres

iemeChiffre

estPair

Naturel Naturel

Naturel NaturelNonNul

NaturelNonNulNaturel

Naturel

Naturel Booléen

2.– fonction nbChiffresPairs (nb : Naturel) : Naturel– fonction nbChiffres (nb : Naturel) : Naturel– fonction iemeChiffre (nb : Naturel,) : Naturel– fonction estPair (nb : Naturel,) : Booleen

3.fonction nbChiffresPairs (nb : Naturel) : Naturel

Declaration i : Naturelresultat : Naturel

debutresultat← 0pour i←1 a nbChiffres(nb) faire

si estPair(iemeChiffre(nb,i)) alorsresultat← resultat+1

finsifinpourretourner resultat

fin

4.2 Majuscule

La fonction majuscule permet de calculer a partir d’une chaıne de caracteres ch une chaıne decaracteres ch′ tel que tous les caracteres minuscules, et uniquement eux, de ch soient transformesen majuscule dans ch′. La signature de cette est fonction est :

– fonction majuscule (uneChaine : Chaine de caracteres) : Chaine de caracteresAinsi majuscule(”abc, ?ABC”) donne la valeur ”ABC, ?ABC”.

L’objectif de cet exercice est de donner l’algorithme de cette fonction en considerant que nousavons les trois fonctions suivantes :

– fonction longueur (uneChaine : Chaine de caracteres) : Naturel– fonction iemeCaractere (uneChaine : Chaine de caracteres, position : Naturel) : Carac-

tere– fonction caractereEnChaine (unCaractere : Caractere) : Chaine de caracteres

4.2.1 Analyse

Pour calculer la version majuscule d’une chaıne de caracteres ch, on a besoin de savoir calculerla majuscule d’un caractere c de ch lorsque c represente une lettre minuscule. Nous n’avons aucuna priori concernant la table de codage de ces caracteres, si ce n’est que :

– le caractere ’a’ precede le caractere ’b’, qui precede le caractere ’c’, etc.– le caractere ’A’ precede le caractere ’B’, qui precede le caractere ’C’, etc.Proposez une analyse descendante de ce probleme a l’aide du formalisme vu en cours.

Solution proposee :

12

Page 13: TD algorithme avec Corrections

majusculeChaine Chaine

lettreMajusculeCaractère Caractère

estUneLettreMinusculeCaractère Booléen

4.2.2 Conception preliminaire

Determinez la signature des fonctions ou procedures correspondant aux operations de votreanalyse descendante.

Solution proposee :– fonction majuscule (ch : Chaine de caracteres) : Chaine de caracteres– fonction estUneLettreMinuscule (c : Caractere) : Booleen– fonction lettreMajuscule (c : Caractere) : Caractere

4.2.3 Conception detaillee

Donnez le corps de chacune de ces fonctions ou procedures.Solution proposee :fonction majuscule (ch : Chaine de caracteres) : Chaine de caracteres

Declaration i : Naturelc : Caractereresultat : Chaine de caracteres

debutresultat← ””pour i←1 a longueur(ch) faire

c← iemeCaractere(ch,i)si estUneLettreMinuscule(c) alors

resultat← resultat+ caractereEnChaine(lettreMajuscule(c))sinon

resultat← resultat+ caractereEnChaine(c)finsi

finpourretourner resultat

finfonction estUneLettreMinuscule (c : Caractere) : Booleendebut

retourner c≥’a’ et c≤’z’finfonction lettreMajuscule (c : Caractere) : Caracteredebut

retourner chr(ord(’A’)+ord(c)-ord(’a’))

13

Page 14: TD algorithme avec Corrections

finou

fonction lettreMajuscule (c : Caractere) : CaractereDeclaration i : Caractere

resultat : Caracteredebut

resultat← ’A’pour i←’b’ a c faire

resultat← succ(resultat)finpour

fin

5 TP Pascal : des multiplications

L’objectif de ce TP est de comparer les algorithmes vu dans les exercices 2.1 et 2.4.Le resultat attendu est du type :

./multiplicationCalcul de a*b :

a = 100b = 100

Multiplication classique, a*b = 10000 en 0 msMultiplication egyptienne, a*b = 10000 en 0 ms

Afin de tester la multiplication avec des grands nombres, vous utiliserez le type de donneesQWord pour un ordinateur 64 bits et LongWord pour un ordinateur 32 bits. De plus, les ordina-teurs d’aujourd’hui sont si rapides, que vous vous arrangerez pour que les deux algorithmes iterentsur le plus grand des deux nombres a multiplier.

Vous pouvez calculer le temps mis par une procedure ou une fonction en encadrant son executionpar les appels aux fonctions DateTimeToTimeStamp(Time()) (disponible dans l’unite sysutils).Le type de la valeur retournee est TTimeStamp, qui est un enregistrement dont le champ timepossede l’heure correspondante en ms. La soustraction de ces deux valeurs de champ vous per-mettra d’avoir une idee quant au temps mis par cette fonction ou procedure.

Vous comparerez le temps mis par ces deux algorithmes en augmentant regulierement la tailledes arguments (vous pouvez aller jusqu’a des valeurs de plusieurs milliards).

Solution proposee :1 program multiplication;23 uses sysutils;45 type6 Entier = QWord;78 f u n c t i o n min(a,b : Entier) : Entier;9 begin

10 i f a<b then11 min:=a12 e l s e13 min:=b14 end;15

14

Page 15: TD algorithme avec Corrections

16 f u n c t i o n max(a,b : Entier) : Entier;17 begin18 i f a>b then19 max:=a20 e l s e21 max:=b22 end;2324 f u n c t i o n multiplicationClassique(a,b : Entier) : Entier;25 var26 i,a1,b1 : Entier;27 begin28 a1:=max(a,b);29 b1:=min(a,b);30 multiplicationClassique:=0;31 f o r i:=1 to a1 do32 multiplicationClassique:=multiplicationClassique+b1;33 end; { multiplicationClassique }3435 f u n c t i o n multiplicationEgyptienne(a,b : Entier) : Entier;36 var37 a1,b1 : Entier;38 begin39 a1:=min(a,b);40 b1:=max(a,b);41 multiplicationEgyptienne:=0;42 whi le (b1>0) do43 i f (b1 mod 2)=0 then44 begin45 a1:=2*a1;46 b1:=b1 div 2;47 end48 e l s e49 begin50 multiplicationEgyptienne:=multiplicationEgyptienne+a1;51 b1:=b1-1;52 end;53 end; { multiplicationEgyptienne }5455 var56 a,b,res : Entier;57 t1,t2 : TTimeStamp;5859 begin60 w r i t e l n(’Calcul de a*b :’);61 w r i t e(’ a = ’);readln(a);62 w r i t e(’ b = ’);readln(b);63 t1:=DateTimeToTimeStamp(Time());64 res:=multiplicationClassique(a,b);65 t2:=DateTimeToTimeStamp(Time());66 w r i t e l n(’ Multiplication classique, a*b = ’,res,’ en ’, t2.time-t1.time,’ ms’);67 t1:=DateTimeToTimeStamp(Time());68 res:=multiplicationEgyptienne(a,b);69 t2:=DateTimeToTimeStamp(Time());70 w r i t e l n(’ Multiplication egyptienne, a*b = ’,res,’ en ’, t2.time-t1.time,’ ms’);71 end.

6 Tableaux

Dans tous les exercices qui vont suivre, le tableau d’entiers t est defini comme etant de typeTableau[1..MAX] d’Entier.

15

Page 16: TD algorithme avec Corrections

6.1 Plus petit element d’un tableau d’entiers

Ecrire une fonction, minTableau, qui a partir d’un tableau d’entiers t non trie de n elementssignificatifs retourne le plus petit element du tableau.

Solution proposee :fonction minTableau (t : Tableau[1..MAX] d’Entier ; n : Naturel) : Entierbprecondition(s) n ≥ 1 et n≤MAX

Declaration i : Naturel,min : Entier

debutmin← t[1]pour i←2 a n faire

si t[i]<min alorsmin← t[i]

finsifinpourretourner min

fin

6.2 Indice du plus petit element d’un tableau d’entiers

Ecrire une fonction, indiceMin, qui retourne l’indice du plus petit element d’un tableau d’en-tiers t non trie de n elements significatifs.

Solution proposee :fonction indiceMin (t : Tableau[1..MAX] d’Entier ; n : Naturel) : Naturelbprecondition(s) n ≥ 1 et n≤MAX

Declaration i, indiceDuMin : Naturel

debutindiceDuMin← 1pour i←2 a n faire

si t[i]<t[indiceDuMin] alorsindiceDuMin← i

finsifinpourretourner indiceDuMin

fin

6.3 Nombre d’occurrences d’un element

Ecrire une fonction, nbOccurences, qui indique le nombre de fois ou un element apparaıt dansun tableau d’entiers t non trie de n elements.

Solution proposee :fonction nbOccurences (t : Tableau[1..MAX] d’Entier ; n : Naturel ; element : Entier) : Natu-rel

16

Page 17: TD algorithme avec Corrections

Declaration i, nb : Natureldebut

nb← 0pour i←1 a n faire

si t[i] = element alorsnb← nb + 1

finsifinpourretourner nb

finIci, il n’est pas necessaire d’introduire des preconditions sur la valeur de n. La semantique de lafonction s’accorde tres bien d’un tableau vide. La boucle sur n ne sera pas effectuee si le tableauest vide et le retour sera coherent puisqu’egal a 0.

6.4 Element le plus frequent d’un tableau

Soit un tableau d’entiers t non trie de n elements significatifs. Ecrire une procedure, determi-nerElementPlusFrequent, qui calcule l’element qui apparaıt le plus souvent dans le tableau t, ainsique son nombre d’occurrences. Si plusieurs elements differents repondent au probleme, votre al-gorithme doit en fournir un, quel qu’il soit. Vous ne devez utiliser aucun autre tableau que celuisur lequel vous travaillez.

Solution proposee :procedure determinerElementPlusFrequent (E t : Tableau[1..MAX] d’Entier ; n : Naturel ;S ele-ment : Entier ; nombre : Naturel)bprecondition(s) n ≥ 1 et n≤MAX

Declaration i, compteur : Naturel

debutnombre← 0pour i←1 a n faire

compteur← nbOccurences(t,n,t[i])si compteur > nombre alors

nombre← compteurelement← t[i]

finsifinpour

finEn etudiant cet algorithme, l’initialisation du parametre de sortie ”element” n’est faite que dansune alternative. Il faut donc garantir qu’effectivement cette branche de l’alternative sera parcourueau moins une fois. La precondition (n≥ 1) garantit que l’iterative sera effectuee au moins une fois.L’initialisation a 0 de nombre garantit que le test compteur (qui vaut par definition au minimum 1la premiere fois) sera forcement superieur a nombre. La branche ”alors” sera donc parcourue aumoins une fois dans cet algorithme. Le parametre ”element” sera donc initialise au moins une fois.

Cet algorithme peut etre ameliorer en partant de la fin du tableau, en faisant une boucleindeterministe et en jouant sur le parametre n de la fonction nbOccurrences.

17

Page 18: TD algorithme avec Corrections

6.5 Recherche dichotomique

Ecrire une fonction, rechercheDichotomique, qui determine par dichotomie le plus petit indiced’un element, (dont on est sur de l’existence) dans un tableau d’entiers t trie dans l’ordre croissantde n elements significatifs. Il peut y avoir des doubles (ou plus) dans le tableau.

Solution proposee :fonction rechercheDichotomique (t : Tableau[1..MAX] d’Entier ; n : Naturel ; element : Entier): Naturelbprecondition(s) estPresent(t,n,element)

Declaration g,d,m : Naturel

debutg← 1d← ntant que g 6= d faire

m← (g + d) div 2si t[m] > element alors

d← m-1sinon

si t[m] = element alorsd← m

sinong← m + 1

finsifinsi

fintantqueretourner g

fin

6.6 Tris

6.6.1 Tri par insertion

Nous avons vu en cours que l’algorithme du tri par insertion est :procedure triParInsertion (E/S t :Tableau[1..MAX] d’Entier,E nb :Naturel)

Declaration i,j : Natureltemp : Entier

debutpour i←2 a nb faire

j← obtenirIndiceDInsertion(t,i,t[i])temp← t[i]decaler(t,j,i)t[j]← temp

finpourfinDonnez l’algorithme de la fonction obtenirIndiceDInsertion tout d’abord de maniere sequentielle,puis de maniere dichotomique. Demontrez que la complexite de ce dernier est-il en O(log2(n)).

Solution proposee :

18

Page 19: TD algorithme avec Corrections

– Version sequentiellefonction obtenirIndiceDInsertion (t : Tableau[1..MAX] d’Entier ; rang : Naturel ; entie-rAInserer : Entier) : Naturelbprecondition(s) rang > 1 et rang≤MAX

Declaration i : Naturel

debuti← 1tant que t[i]≤entierAInserer et i<rang faire

i← i+1fintantqueretourner i

fin– Version dichotomique

fonction obtenirIndiceDInsertion (t : Tableau[1..MAX] d’Entier ; rang : Naturel ; entie-rAInserer : Entier) : Naturelbprecondition(s) rang > 1 et rang≤MAX

Declaration g, d, m : Naturel

debutg← 1d← rangtant que g 6= d faire

m← (g+d) div 2si t[m] > entierAInserer alors

d← m // l’intervalle g..m contient alors l’indice recherchesinon

g← m+1finsi

fintantqueretourner g

fin

6.6.2 Tri shaker

La tri shaker est une amelioration du tri a bulles ou les iterations permettant de savoir si letableau et trie (et qui inverse deux elements successifs t[i] et t[i+ 1] lorsque t[i] > t[i+ 1]) se fontsuccessivement de gauche a droite puis de droite a gauche.

Donnez l’algorithme du tri shaker.

Solution proposee :procedure triShaker (E/S t :Tableau[1..MAX] d’Entier,E nb :Naturel)

Declaration estTrie : Booleeni,j : Naturelsens : Entier

debutsens← 1j← 1repeter

19

Page 20: TD algorithme avec Corrections

estTrie← VRAIpour i←1 a n-1 faire

si t[j]>t[j+1] alorsechanger(t[j],t[j+1])estTrie← FAUX

finsij← j+sens

finpoursens← -sensj← j+sens

jusqu’a ce que estTriefin

7 TP Pascal : Matrice

Soit l’unite Matrice qui propose un type TMatrice et cinq sous-programmes qui permettentde manipuler des variables de type TMatrice :

function matriceZero(hauteur,largeur : Integer) : TMatrice permet d’obtenir une matrice com-posee de 0

function largeur(m : TMatrice) : Integer permet d’obtenir la largeur d’une matrice

function hauteur(m : TMatrice) : Integer permet d’obtenir la hauteur d’une matrice

function obtenir(m : TMatrice ; jHauteur, iLargeur : Integer) : Real ; permet d’obtenir un elementd’une matrice

procedure fixer(var m : TMatrice ; jHauteur, iLargeur : Integer ; val : Real) ; qui permet defixer la valeur d’un des elements de la matrice

L’objectif de ce TP est developper une unite libMatrice, qui permettra :– de transformer une matrice en chaıne de caracteres (fonction matriceEnChaine) ;– d’additionner deux matrices (fonction additionnerDeuxMatrices) ;– de multiplier deux matrices (fonction multiplierDeuxMatrices) ;– de calculer la transposer d’une matrice (fonction transposer).Pour les fonctions d’addition et de multiplication, les erreurs sont gerees via une variable

globale erreur de type TErreur. Cette variable possedera la valeur pas d erreur lorsquetout va bien et la valeur erreur taille lorsque la taille des matrices utilisees pour ces deuxfonctions sont incompatibles. Dans ce dernier ces fonctions retourneront la valeur (0).

Le fichier TP-Matrices-Sources.zip disponible sur moodle, contient :– l’unite Matrice.pas,– l’unite libMatrice.pas,– l’executable test.pas.Completez l’unite libMatrice.pas et utilisez le programme test.pas pour tester votre

code. Voici un exemple d’execution du programme test.

$ ./testm1=1.00 4.002.00 5.003.00 6.00

m2=2.00 5.003.00 6.00

20

Page 21: TD algorithme avec Corrections

4.00 7.00

m3=3.00 5.00 7.004.00 6.00 8.00

m1 + m2 =3.00 9.005.00 11.007.00 13.00

m1 * m3 =19.00 29.00 39.0026.00 40.00 54.0033.00 51.00 69.00

transpose de m1 =1.00 2.00 3.004.00 5.00 6.00

Solution proposee :1 u n i t libMatrice;23 i n t e r f a c e45 uses Matrice;67 type TErreur = (pas_d_erreur, erreur_taille);89 var erreur : TErreur;

1011 f u n c t i o n matriceEnChaine(m : TMatrice) : String;12 f u n c t i o n additionnerDeuxMatrices(m1,m2 : TMatrice) : TMatrice;13 f u n c t i o n multiplierDeuxMatrices(m1,m2 : TMatrice) : TMatrice;14 f u n c t i o n transposer(m : TMatrice) : TMatrice;1516 implementat ion1718 f u n c t i o n plusGdChaine(m : TMatrice) : I n t e g e r;19 var20 i,j : I n t e g e r;21 s : String;22 begin23 plusGdChaine:=0;24 f o r j:=1 to hauteur(m) do25 begin26 f o r i:=1 to largeur(m) do27 begin28 str(obtenir(m,j,i):0:2,s);29 i f length(s)>plusGdChaine then30 plusGdChaine:=length(s);31 end;32 end33 end; { plusGdChaine }343536 f u n c t i o n matriceEnChaine(m : TMatrice) : String;37 var38 i,j : I n t e g e r;39 s : String;40 nbChiffres : I n t e g e r;41 begin42 erreur := pas_d_erreur;43 matriceEnChaine:=’’;44 nbChiffres:=plusGdChaine(m);

21

Page 22: TD algorithme avec Corrections

45 f o r j:=1 to hauteur(m) do46 begin47 f o r i:=1 to largeur(m) do48 begin49 str(obtenir(m,j,i):nbChiffres:2,s);50 matriceEnChaine:=matriceEnChaine+s+’ ’;51 end;52 matriceEnChaine:=matriceEnChaine+#10;53 end54 end;5556 f u n c t i o n additionnerDeuxMatrices(m1,m2 : TMatrice) : TMatrice;57 var58 i,j : I n t e g e r;59 begin60 i f (largeur(m1)<>largeur(m2)) or (hauteur(m1)<>hauteur(m2)) then61 begin62 erreur := erreur_taille;63 additionnerDeuxMatrices:=matriceZero(1,1);64 end65 e l s e66 begin67 erreur := pas_d_erreur;68 additionnerDeuxMatrices:=matriceZero(largeur(m1),hauteur(m1));69 f o r i:=1 to largeur(m1) do70 f o r j:=1 to hauteur(m1) do71 fixer(additionnerDeuxMatrices,j,i,obtenir(m1,j,i)+obtenir(m2,j,i));72 end73 end;7475 f u n c t i o n multiplierDeuxMatrices(m1,m2 : TMatrice) : TMatrice;76 var77 i,j,k : I n t e g e r;78 begin79 i f (largeur(m1)<>hauteur(m2)) or (hauteur(m1)<>largeur(m2)) then80 begin81 erreur := erreur_taille;82 multiplierDeuxMatrices:=matriceZero(1,1);83 end84 e l s e85 begin86 erreur := pas_d_erreur;87 multiplierDeuxMatrices:=matriceZero(hauteur(m1),largeur(m2));88 f o r j:=1 to hauteur(m1) do89 f o r i:=1 to largeur(m2) do90 f o r k:=1 to largeur(m1) do91 fixer(multiplierDeuxMatrices,j,i,obtenir(multiplierDeuxMatrices,j,i)+92 obtenir(m1,j,k)*obtenir(m2,k,i));93 end94 end;9596 f u n c t i o n transposer(m : TMatrice) : TMatrice;97 var i,j : I n t e g e r;98 begin99 transposer := matriceZero(hauteur(m),largeur(m));

100 f o r i:=1 to largeur(m) do101 f o r j:=1 to hauteur(m) do102 fixer(transposer,i,j,obtenir(m,j,i))103 end;104105 begin106 erreur := pas_d_erreur;107 end.

22

Page 23: TD algorithme avec Corrections

8 Recursivite

8.1 Calcul de C(n,p)

Ecrire une fonction cnp, qui en fonction des entiers positifs n et p, retourne le nombre decombinaisons de p elements parmi n.

Solution proposee :Pour rappel :

Cnp =

{1 si p = 0 ou n = p

Cn−1p + Cn−1

p−1

fonction cnp (n,p : naturel) : Natureldebut

si p=0 ou n=p alorsretourner 1

sinonretourner cnp(n-1,p)+cnp(n-1,p-1)

finsifin

8.2 Multiplication egyptienne

Soit la multiplication egyptienne definie dans l’exercice 2.4. On se propose cette fois d’ecrirecet algorithme de maniere recursive.

1. Determiner le ou les cas terminaux. Determiner le ou les cas generaux.

2. Donner le corps de la fonction suivante en utilisant un algorithme recursif :

fonction multiplicationEgyptienne (a,b : Naturel) : Naturel

Solution proposee :– Cas terminal :

– Si b = 1 alors a ∗ b = a– Cas general, Si b > 1

– Si b est paire alors a ∗ b = 2a ∗ b/2– Si b est impaire alors a ∗ b = a + a ∗ (b− 1)

fonction multiplicationEgyptienne (a,b :Naturel) : Natureldebut

si b=1 alorsretourner a

sinonsi b mod 2=0 alors

retourner multiplicationEgyptienne(2*a,b div 2)sinon

retourner a+multiplicationEgyptienne(a,b-1)finsi

finsifin

23

Page 24: TD algorithme avec Corrections

8.3 Des cercles

Supposons que la procedure suivante permette de dessiner un cercle sur un graphique (variablede type Graphique) :

– procedure cercle (E/S g : Graphique,E xCentre,yCentre,rayon : Reel)

8.3.1 Comprehension

Soit l’algorithme suivant :procedure cercles (E/S g : Graphique,E x,y,r : Reel, n : Naturel)

Declaration rTemp : Reeldebut

si n>0 alorsrTemp← r/(1+racineCarree(2))cercles(g,x,y+rTemp*racineCarree(2),rTemp,n-1)cercles(g,x,y-rTemp*racineCarree(2),rTemp,n-1)cercle(g,x,y,r)cercles(g,x+rTemp*racineCarree(2),y,rTemp,n-1)cercles(g,x-rTemp*racineCarree(2),y,rTemp,n-1)

finsifin

L’instruction cercles(g,1.0,1.0,1.0,3) permet d’obtenir le graphique de la figure 2.Numerotez les cercles (numero a mettre au centre du cercle) suivant leur ordre d’apparition

sur le graphique.

FIGURE 2 – Resultat d’un autre algorithme pour cercles

Solution proposee :

24

Page 25: TD algorithme avec Corrections

8.3.2 Construction

Proposez un autre algorithme de la procedure cercles qui, pour la meme instruction cercles(g,1.0,1.0,1.0,3), affiche les cercles dans l’ordre propose par la figure 3.

FIGURE 3 – Resultat d’un autre algorithme pour cercles

Solution proposee :procedure cercles (E/S g : Graphique,E x,y,r : Reel, n : Naturel)

25

Page 26: TD algorithme avec Corrections

Declaration rTemp : Reeldebut

si n>0 alorsrTemp← r/(1+racineCarree(2))cercles(g,x+rTemp*racineCarree(2),y,rTemp,n-1)cercle(g,x,y,r)cercles(g,x-rTemp*racineCarree(2),y,rTemp,n-1)cercles(g,x,y-rTemp*racineCarree(2),rTemp,n-1)cercles(g,x,y+rTemp*racineCarree(2),rTemp,n-1)

finsifin

8.4 Recherche d’un element dans un tableau

Ecrire une fonction recursive, estPresent, qui retourne VRAI si un element donne est un deselements d’un tableau d’entiers t et FAUX sinon. Etudier les cas ou t n’est pas un tableau trie etou t est un tableau trie.

Solution proposee :– Si le tableau n’est pas trie :

fonction estPresent (t : Tableau[1..MAX] d’Entier ; element : Entier ; debut, fin : NbEle-mentTableau) : Booleendebut

si debut > fin alorsretourner FAUX

sinonsi element = t[fin] alors

retourner VRAIsinon

retourner estPresent(t, element, debut, fin-1)finsi

finsifin

– Si le tableau est trie :fonction estPresent (t : Tableau[1..MAX] d’Entier ; element : Entier ; debut,fin : NbEle-mentTableau) : Booleen

Declaration m : NbElementTableau

debutsi debut > fin alors

retourner FAUXsinon

m← (debut + fin) div 2si element = t[m] alors

retourner VRAIsinon

si t[m] > element alorsretourner estPresent(t, element, debut, m - 1)

sinonretourner estPresent(t, element, m + 1, fin)

26

Page 27: TD algorithme avec Corrections

finsifinsi

finsifin

Appel initial : estPresent (t, 10, 1, MAX) pour tout le tableau et recherche de l’element 10.

9 TP Pascal : Benchmark de tri

L’objectif de ce TP est d’implanter et de comparer les performances des tris suivants :– tri par selection ;– tri par insertions avec recherche d’insertion sequentielle ;– tri par insertions avec recherche d’insertion dichotomique ;

9.1 Resultats attendus

Deux programmes sont utilises dans ce TP : testTri et benchmark.

9.1.1 testTri

Le programme testTri a pour objectif de verifier le bon fonctionnement des tris. Voici unexemple de resultats attendus a son execution :

Verification des tris :Nb elements :10

Tableau a trier : 5 5 7 8 6 8 5 8 4 6Resultat Tri par selection : 4 5 5 5 6 6 7 8 8 8Resultat Tri par insertion (recherche d’insertion sequentielle) : 4 5 5 5 6 6 7 8 8 8Resultat Tri par insertion (recherche d’insertion dichotomique) : 4 5 5 5 6 6 7 8 8 8

9.1.2 benchmark

Le programme benchmark a pour objectif de comparer les performances des tris. Voici unexemple de resultats attendus a son execution (les XX representent des temps) :

Nb elements :10000Tri par selection : XX msTri par insertion (recherche d’insertion sequentielle) : XX msTri par insertion (recherche d’insertion dichotomique) : XX ms

9.2 Travail a realiser

Comme les tris sont utilises par deux programmes, nous les avons repartis dans des unitespascal (une unite par tri).

De meme le type TEntiers representant un tableau d’entiers (avec des sous-programmespermettant d’en remplir aleatoirement un, d’en afficher un, ou encore de demander a l’utilisateurcombien d’entiers il faut utiliser) est utilise dans toutes les unites et les deux programmes, il estdonc declare dans une unite.

Les programmes donnes compilent et s’executent, mais ne donnent pas les bons resultats. Pourrealiser ce TP, suivez les etapes suivantes :

1. Telechargez et decompressez l’archive TP-Tris1-Sources.zip disponible sur moo-dle.

2. Completez l’unite triselection et compilez les deux programmes.

3. Completez l’unite triinsertionsequentiel et compilez les deux programmes.

27

Page 28: TD algorithme avec Corrections

4. Completez l’unite triinsertiondichotomoqie et compilez les deux programmes.

Comparez les valeurs obtenues avec 1000, 10000, 20000 et 30000 elements a trier.

10 TP Pascal : Benchmark de tri (suite)

L’objectif de ce TP est de completer le TP precedent, en implantant et comparant les perfor-mances des tris suivants :

– tri a bulles– tri par selection ;– tri par insertions avec recherche d’insertion sequentielle ;– tri par insertions avec recherche d’insertion dichotomique ;– tri rapide– tri par fusion

10.1 Resultats attendus

Deux programmes sont utilises dans ce TP : testTri et benchmark.

10.1.1 testTri

Le programme testTri a pour objectif de verifier le bon fonctionnement des tris. Voici unexemple de resultats attendus a son execution :

Verification des tris :Nb elements :10

Tableau a trier : 5 5 7 8 6 8 5 8 4 6Resultat Tri rapide : 4 5 5 5 6 6 7 8 8 8Resultat Tri par fusion : 4 5 5 5 6 6 7 8 8 8Resultat Tri par selection : 4 5 5 5 6 6 7 8 8 8Resultat Tri par insertion (recherche d’insertion sequentielle) : 4 5 5 5 6 6 7 8 8 8Resultat Tri par insertion (recherche d’insertion dichotomique) : 4 5 5 5 6 6 7 8 8 8Resultat Tri a bulles : 4 5 5 5 6 6 7 8 8 8

10.1.2 benchmark

Le programme benchmark a pour objectif de comparer les performances des tris. Voici unexemple de resultats attendus a son execution (les XX representent des temps) :

Nb elements :10000Tri rapide : XX msTri par fusion : XX msTri par selection : XX msTri par insertion (recherche d’insertion sequentielle) : XX msTri par insertion (recherche d’insertion dichotomique) : XX msTri a bulles : XX ms

10.2 Travail a realiser

Les programmes donnes compilent et s’executent, mais ne donnent pas les bons resultats. Pourrealiser ce TP, suivez les etapes suivantes :

1. Telechargez et decompressez l’archive TP-Tris2-Sources.zip disponible sur moo-dle.

2. Remplacez les unites triselection, triinsertionsequentiel ettriinsertiondichotomoqie par celles que vous avez developpees au dernier TP.

28

Page 29: TD algorithme avec Corrections

3. Completez l’unite trirapide et compilez les deux programmes.

4. Completez l’unite trifusion et compilez les deux programmes.

Comparez les valeurs obtenues avec 1000, 10000, 20000 et 30000 elements a trier.

11 Liste chaınee

Pour rappel, le type ListeChaineeDEntiers est defini de la facon suivante :Type ListeChaineeDEntiers = ˆ NoeudDEntierType NoeudDEntier = Structure

entier : EntierlisteSuivante : ListeChaineeDEntiers

finstructureEt nous l’utilisons a l’aide des fonctions et procedures suivantes :– fonction listeVide () : ListeChaineeDEntiers– fonction estVide (uneListe : ListeChaineeDEntiers) : Booleen– procedure ajouter (E/S uneListe : ListeChaineeDEntiers,E element : Entier)– fonction obtenirEntier (uneListe : ListeChaineeDEntiers) : Entier

bprecondition(s) non(estVide(uneListe))

– fonction obtenirListeSuivante (uneListe : ListeChaineeDEntiers) : ListeChaineeDEntiers

bprecondition(s) non(estVide(uneListe))

– procedure fixerListeSuivante (E/S uneListe : ListeChaineeDEntiers,E nelleSuite : Liste-ChaineeDEntiers)bprecondition(s) non(estVide(uneListe))

– procedure supprimerTete (E/S l :ListeChaineeDEntiers)bprecondition(s) non estVide(l)

– procedure supprimer (E/S uneListe : ListeChaineeDEntiers)

1. Ecrire une procedure iterative, afficher, qui permet d’afficher les elements d’une liste chaınee.

2. Ecrire une procedure recursive, afficher, qui permet d’afficher les elements d’une liste chaınee.

3. Ecrire une fonction booleenne recursive, estPresent, qui permet de savoir si un entier estpresent dans une liste chaınee.

4. Ecrire une procedure recursive, concatener, qui concatene deux listes chaınees.

5. Ecrire une procedure recursive, inverser, qui permet d’inverser une liste chaınee.

Solution proposee :

1. Afficher iteratifprocedure afficher (E l :ListeChaineeDEntiers)debut

tant que non est Vide(l) faireecrire(obtenirEntier(l))l← obtenirListeSuivante(l)

fintantquefin

2. Afficher recursif

29

Page 30: TD algorithme avec Corrections

procedure afficher (E l :ListeChaineeDEntiers)debut

si non est Vide(l) alorsecrire(obtenirEntier(l))afficher(obtenirListeSuivante(l))

finsifin

3. est present recursiffonction estPresent (liste : LIsteChaineeDEntiers ; cherche : Entier) : Booleendebut

si estVide(liste) alorsretourner FAUX

sinonsi obtenirEntier(liste) = cherche alors

retourner VRAIsinon

retourner estPresent(obtenirListeSuivante(liste),cherche)finsi

finsifin

4. concatenationprocedure concatener (E/S l1 : LIsteChaineeDEntiers,E l2 : LIsteChaineeDEntiers)

Declaration temp : LIsteChaineeDEntiers

debutsi estVide(l1) alors

l1← l2sinon

si non estVide(l2) alorstemp← obtenirListeSuivante(l1)concatener(temp,l2)fixerListeSuivante(l1, temp)

finsifinsi

fin5. inverser

procedure inverser (E/S l : LIsteChaineeDEntiers)Declaration temp : LIsteChaineeDEntiers

debutsi non estVide(l) alors

temp← obtenirListeSuivante(l)inverser(temp)fixerListeSuivante(l,listeChainee())concatener(temp,l)

finsifin

30

Page 31: TD algorithme avec Corrections

12 TP Pascal : Liste chaınee

L’objectif de ce TP est de developper une librairie (unite LibListeChaineeDEntiers)sur une liste chaınee d’entiers (unite ListeChaineeDEntiers). Cette librairie permettra de :

– savoir si deux listes chaınees sont egales ;– copier une liste chaınee d’entiers ;– savoir si un entier est present dans une liste chaınee d’entiers ;– savoir les entiers d’une liste sont presents en ordre croissant ;– concatener deux liste chaınees d’entiers.Afin de verifier que la librairie fonctionne, un programme de tests unitaires est propose (pro-

gramme testLibListeChaineeDEntiers).

12.1 Resultats attendusL’execution du programme de tests unitaires devra valider tous les tests :

$ ./testLibListeChaineDEntiersTests unitaires de la librairie LibListeChaineeDEntiers

sontEgales(l,l) : OKsontEgales(l1,l2) (avec l1 et l2 qui possedent les meme elements) : OKsontEgales(l1,l2) (avec l1 et l2 qui ne possedent pas les meme elements) : OKcopier(l) : OKestPresent(l,e) (avec e qui est reellement present au debut): OKestPresent(l,e) (avec e qui est reellement present a la fin): OKestPresent(l,e) (avec e qui est reellement present, cas general): OKestPresent(l,e) (avec e qui n’est pas present): OKestEnOrdreCroissant(l) (avec la liste (1 2 3)): OKestEnOrdreCroissant(l) (avec la liste (1 2 3 2 1)): OKconcatener(l1,l2) : OK

12.2 Travail a realiser

1. Telechargez et decompressez l’archive TP-Liste-Sources.zip disponible sur moo-dle.

2. Completez l’unite LibListeChaineeDEntiers. A chaque fois que vous avez code unefonction et que la compilation de l’unite reussie, recompilez et lancez le programme de testsunitaires.

13 TP Pascal : Fichiers

L’objectif de ce TP est de completer le mini gestionnaire de contatcs vu en cours afin qu’enplus de l’ajout et de l’affichage d’un contact, le programme puisse :

– supprimer un contact ;– n’afficher que les contacts correspondant a un nom ;– que l’affichage des contacts se fasse en ordre croissant sur les noms.Comme vu en cours le programme devra separer l’interface homme machine et la logique

metier. L’interface homme machine sera toujours en mode texte et les actions de l’utilisateur seronttoujours specifier dans la ligne de commande. Voici un exemple d’aide qui sera afficher lorsque lenombre d’arguments ne sera pas valide :

$ ./contactsTxtcontacts nom_fichier : permet d’afficher l’ensemble des contactscontacts nom_fichier nom : permet d’afficher un contactcontacts nom_fichier nom prenom : permet de supprimer un contactcontacts nom_fichier nom prenom telephone : permet d’ajouter un contact

31

Page 32: TD algorithme avec Corrections

13.1 Resultats attendusVoici un exemple d’utilisation du programme une fois qu’il sera termine :

$ ./contactsTxt insa.fic$ ./contactsTxt insa.fic "Delestre" "Nicolas" "02 32 95 98 76"$ ./contactsTxt insa.ficNom : DelestrePrenom : NicolasTelephone : 02 32 95 98 76$ ./contactsTxt insa.fic "Malandain" "Nicolas" "02 32 95 98 83"$ ./contactsTxt insa.ficNom : DelestrePrenom : NicolasTelephone : 02 32 95 98 76Nom : MalandainPrenom : NicolasTelephone : 02 32 95 98 83$ ./contactsTxt insa.fic "Delporte" "Julien" ""$ ./contactsTxt insa.ficNom : DelestrePrenom : NicolasTelephone : 02 32 95 98 76Nom : DelportePrenom : JulienTelephone :Nom : MalandainPrenom : NicolasTelephone : 02 32 95 98 83$ ./contactsTxt insa.fic "Malandain"Nom : MalandainPrenom : NicolasTelephone : 02 32 95 98 83$ ./contactsTxt insa.fic "Delestre" "Nicolas"$ ./contactsTxt insa.ficNom : DelportePrenom : JulienTelephone :Nom : MalandainPrenom : NicolasTelephone : 02 32 95 98 83

13.2 Travail a realiser

1. Telechargez et decompressez l’archive TP-Contact-Sources.zip disponible sur moo-dle.

2. Compilez et executez le programme de facon a verifier que l’affichage des contacts et l’ajoutd’un contact fonctionne bien.

3. Completez la procedure supprimerContact qui permet de supprimer un contact a partirde son nom et de son prenom. Compilez et testez votre programme pour la suppression d’uncontact.

4. Completez la procedure parcourirContactsAvecComparaison qui permet de trai-ter tous les contacts c tels que la fonction comparer retourne 0 si elle est executee aveccomme argument reference et c. Compilez et testez votre programme pour l’affichage descontacts d’un certain nom.

5. Modifiez la procedure ajouterContact de facon a ce que l’ajout se fasse dans l’ordrecroissant des noms des contacts. Compilez et testez votre programme avec un nouveau carnetde contacts.

32