|
Exercice n°1: Tableaux "simples"
a) On considère l'existence d'un tableau de réels. Ecrire un algorithme permettant de parcourir ce tableau
pour afficher les valeurs qu'il contient qui sont comprises entre une borne minimale et une borne maximale
(bornes incluses).
|
AffichageTableauSeuils.lda
constante entier N <- ...
{ Methode de creation d'un tableau de reels }
{ initialise avec des nombres aleatoires }
{ compris entre 0.0 et 1.0 }
Tableau [N] de réel fonction initRand()
Locales
i : entier
tab : Tableau [N] de réel
pour i de 0 à N-1 faire
tab[i] <- random()
fait
retourner tab
fin fonction
{ Affichage d'un tableau de reels }
{ pour les valeurs comprises }
{ entre des bornes minimale et maximale }
action principale()
Locales
min : réel
max : réel
t : Tableau [N] de réel
i : entier
Ecran.afficher("SVP, valeur minimale? ")
min <- Clavier.saisirReel()
Ecran.afficher("SVP, valeur maximale? ")
max <- Clavier.saisirReel()
t <- initRand()
pour i de 0 à N-1 faire
si ( t[i] >= min ) et ( t[i] <= max ) alors
Ecran.afficherln(t[i])
fsi
fait
fin action
Clavier.class - Ecran.class
- Exemple d'exécution
|
b) On considère l'existence d'un tableau de réels. Ecrire un algorithme permettant de calculer et d'afficher
la moyenne des valeurs contenues dans ce tableau.
|
MoyenneTableau.lda
constante entier N <- ...
{ Action de creation d'un tableau de reels }
{ initialise avec des nombres aleatoires }
{ compris entre 0.0 et 10.0 }
Tableau [N] de réel fonction initRand()
Locales
i : entier
tab : Tableau [N] de réel
pour i de 0 à N-1 faire
tab[i] <- random()*10.0
fait
retourner tab
fin fonction
{ Calcul de la moyenne des valeurs contenues }
{ dans un tableau de reels }
action principale()
Locales
i : entier
moyenne : reel
t : Tableau [N] de réel
t <- initRand()
moyenne <- 0.0
pour i de 0 à N-1 faire
moyenne <- moyenne+t[i]
fait
moyenne <- moyenne/N
Ecran.afficherln("La moyenne est ",moyenne)
fin action
Clavier.class - Ecran.class
- Exemple d'exécution
|
c) On considère l'existence d'un tableau de réels. Ecrire un algorithme permettant de déterminer et d'afficher
le nombre de valeurs présentes dans ce tableau qui sont inférieures ou égales à une valeur limite.
|
NombreValeursInferieuresLimite.lda
constante entier N <- ...
{ Methode de creation d'un tableau de reels }
{ initialise avec des nombres aleatoires }
{ compris entre 0.0 et 20.0 }
Tableau [N] de reel fonction initRand()
Locales
i : entier
tab : Tableau [N] de reel
pour i de 0 à N-1 faire
tab[i] <- random()*20.0
fait
retourner tab
fin fonction
{ Calcul du nombre de valeurs inferieures }
{ ou egales a une valeur limite trouvees }
{ dans un tableau de reels }
action principale()
Locales
limite : reel
t : Tableau [N] de reel
i : entier
cpt : entier
t <- initRand()
Ecran.afficher("SVP, valeur limite? ")
limite <- Clavier.saisirReel()
cpt <- 0
pour i de 0 à N-1 faire
si t[i] <= limite alors
cpt <- cpt+1
fsi
fait
Ecran.afficherln("Nombre valeurs < a ",limite," : ",cpt)
fin action
Clavier.class - Ecran.class
- Exemple d'exécution
|
d) On considère l'existence d'un tableau de réels. Les valeurs qu'il contient sont comprises dans
l'intervalle [0.0, 20.0[. Ecrire un algorithme permettant de calculer et d'afficher les nombres de valeurs
de ce tableau comprises dans les intervalles [0.0,1.0[, [1.0, 2.0[, [2.0, 3.0[, ..., [19.0, 20.0[ (classification).
|
ClassificationTableau.lda
constante entier N <- ...
{ Methode de creation d'un tableau de reels }
{ initialise avec des nombres aleatoires }
{ compris entre 0.0 et 20.0 }
Tableau [N] de reel fonction initRand()
Locales
i : entier
tab : Tableau [N] de reel
pour i de 0 à N-1 faire
tab[i] <- random()*20.0
fait
retourner tab
fin fonction
{ Calcul des nombres de de valeurs }
{ par intervalle de largeur 1.0 }
{ pour un tableau de reels compris }
{ entre 0.0 et 20.0 }
action principale()
Locales
t : Tableau [N] de reel
classification : Tableau [20] de entier
i : entier
cl : entier
t <- initRand()
pour i de 0 à 19 faire
classification[i] <- 0
fait
pour i de 0 à N-1 faire
cl <- t[i]
classification[cl] <- classification[cl]+1
fait
Ecran.afficherln("Nombres valeurs:")
pour i de 0 à 19 faire
Ecran.afficherln(i," ",classification[i])
fait
fin action
Clavier.class - Ecran.class
- Exemple d'exécution
|
Exercice n°2: Tableaux en sous-algorithmes
a) Reprendre les questions (c) et (d) de l'exercice n°1 en les implantant avec utilisation de sous-algorithmes.
|
FonctionNombreValeursInferieuresLimite.lda
constante entier N <- ...
{ Action de calcul du nombre de valeurs }
{ inferieures ou egales a une valeur limite }
{ trouvees dans un tableau de double }
entier fonction nbValeursInferieuresLimite(t,limite)
Données
t : Tableau [N] de reel
limite : reel
Locales
cpt : entier
i : entier
cpt <- 0
pour i de 0 à N-1 faire
si t[i] <= limite alors
cpt <- cpt+1
fsi
fait
retourner cpt
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
|
FonctionClassificationTableau.lda
constante entier N <- ...
{ Action de calcul des nombres de de valeurs }
{ par intervalle de largeur 1.0 }
{ pour un tableau de reels compris }
{ entre 0.0 et 20.0 }
Tableau [20] de entier fonction classification(t)
Donnees
t : Tableau [N] de reel
Locales
i : entier
cl : entier
classification : Tableau [20] de entier
pour i de 0 à 19 faire
classification[i] <- 0
fait
pour i de 0 à N-1 faire
cl <- t[i]
classification[cl] <- classification[cl]+1
fait
retourner classification
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
b) Ecrire un sous-algorithme de recherche de l'indice de la valeur minimale contenue dans un tableau d'entiers.
|
IndiceDuMinimum.lda
constante entier N <- ...
{ Action de calcul de l'indice de la valeur }
{ minimale d'un tableau d'entiers }
entier fonction indiceDuMinimum(t)
Donnees
t : Tableau [N] de reel
Locales
i : entier
indice : entier
indice <- 0
pour i de 1 à N-1 faire
si t[i] < t[indice] alors
indice <- i
fsi
fait
retourner indice
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
c) Ecrire un sous-algorithme de fusion de deux tableaux d'entiers triés en un seul nouveau tableau d'entiers
trié.
|
FusionTableaux.lda
constante entier N1 <- ...
constante entier N2 <- ...
constante entier M <- N1+N2
{ Action de fusion de 2 tableau d'entiers }
{ tries t1 et T2 en un nouveau tableau }
{ d'entiers trie }
Tableau [M] de entier fonction fusion(t1,t2)
Donnees
t1 : Tableau [N1] de entier
t2 : Tableau [N2] de entier
Locales
t : Tableau [M] de entier
i : entier
i1 : entier
i2 : entier
i1 <- 0
i2 <- 0
pour i de 0 à M-1 faire
si i1 = N1 alors
t[i] <- t2[i2]
i2 <- i2+1
sinon
si i2 = N2 alors
t[i] <- t1[i1]
i1 <- i1+1
sinon
si t1[i1] < t2[i2] alors
t[i] <- t1[i1]
i1 <- i1+1
sinon
t[i] <- t2[i2]
i2 <- i2+1
fsi
fsi
fsi
fait
retourner t
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
Exercice n°3: Tableaux de variables de type agrégé
a) On considère le type agrégé sommet3D constitué des 3 champs x, y et z réels représentant une position dans
un espace 3D. On considère un tableau de n sommet3D.
Développer un sous-algorithme de calcul du barycentre d'un nuage de points stocké dans un tel tableau.
|
BarycentreNuageSommets3D.lda
constante entier N <- ...
/* Type agrege de stockage d'un sommet 3D */
structure sommet3D
x : reel <- 0.0
y : reel <- 0.0
z : reel <- 0.0
fin structure
/* Methode de calcul du barycentre d'un nuage */
/* de points stocke dans un tableau */
/* de sommet3D */
sommet3D fonction barycentre(tp)
Données
tp : Tableau [N] de sommet3D
Locales
p : sommet3D
i : entier
pour i de 0 à N-1 faire
p.x <- p.x+tp[i].x
p.y <- p.y+tp[i].y
p.z <- p.z+tp[i].z
fait
p.x <- p.x/N
p.y <- p.y/N
p.z <- p.z/N
retourner p
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
b) On considère le type agrégé sommet2D constitué des 2 champs x et y réels représentant l'abscisse et l'ordonnée
d'une position du plan. On considère un tableau de n sommet2D.
1) Développer un sous-algorithme de création d'un tableau de sommet2D initialisé avec les positions
des n sommets d'un polygone régulier de rayon r.
2) Développer un sous-algorithme de calcul de la longueur d'une ligne polygonale non fermée stockée
dans un tel tableau.
3) Développer un sous-algorithme de calcul de la longueur d'une boucle polygonale (fermée) stockée
dans un tel tableau.
|
TableauSommets2D.lda
constante entier N <- ...
constante reel PI <- 3.14159
{ Type agrege de stockage d'un sommet 2D }
structure sommet2D
x : reel <- 0.0
y : reel <- 0.0
fin structure
{ Methode de creation d'un tableau }
{ de sommet2D initialise avec les positions }
{ des sommets d'un polygone regulier }
{ centre sur l'origine et de rayon r }
Tableau [N] de sommet2D fonction polygoneRegulier(double r)
Données
r : reel
Locales
i : entier
angle : reel
t : Tableau [N] de sommet2D
pour i de 0 à N-1 faire
angle <- i*2.0*PI/N
t[i].x <- r*cos(angle)
t[i].y <- r*sin(angle)
fait
retourner t
fin fonction
{ Methode de calcul de la distance }
{ entre deux sommet2D }
reel fonction distance(p1,p2)
Données
p1 : sommet2D
p2 : sommet2D
Locales
l : réel
dx : réel
dy : réel
dx <- p2.x-p1.x
dy <- p2.y-p1.y
l <- sqrt(dx*dx+dy*dy)
retourner l
fin fonction
{ Methode de calcul de la longueur }
{ d'une ligne polygonale ouverte stockee }
{ dans un tableau de sommet2D }
reel fonction longueurLigne(t)
Données
t : Tableau [N] de sommet2D
Locales
l : reel
i : entier
l <- 0.0
pour i de 0 à N-2 faire
l <- l+distance(t[i],t[i+1])
fait
retourner l
fin fonction
{ Methode de calcul de la longueur }
{ d'une boucle polygonale stockee }
{ dans un tableau de sommet2D }
reel fonction longueurBoucle(t)
Données
t : Tableau [N] de sommet2D
Locales
l : réel
l <- longueurLigne(t) + distance(t[0],t[N-1])
retourner l
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
Exercice n°4: Type agrégé avec tableau
a) On souhaite calculer le coefficient de corrélation linéaire défini entre deux séries de 15 données réelles.
1) Définir un type agrégé permettant de stocker ces deux séries de données en une seule variable.
2) Implanter un sous-algorithme permettant de calculer le coefficient de corrélation linéaire existant
entre les deux séries de données stockées au sein d'une variable du type agrégé de la question (1). On utilisera
la formule de calcul suivante (wikipedia):
|
CoefficientCorrelationLineaire.lda
constante entier N <- 15
{ Type agrege de stockage de deux tableaux }
{ de 15 double }
structure DeuxSeries
x : Tableau [N] de reel
y : Tableau [N] de reel
fin structure
{ Methode de calcul de la moyenne des valeurs }
{ contenues dans un tableau de double }
réel fonction moyenne(t)
Données
t : Tableau [N] de réel
Locales
moyenne : reel
i : entier
moyenne <- 0.0
pour i de 0 à N-1 faire
moyenne <- moyenne+t[i]
fait
moyenne <- moyenne/N
retourner moyenne
fin fonction
{ Methode de calcul de l'ecart quadratique }
{ des valeurs contenues }
{ dans un tableau de double }
réel fonction ecartQuadratique(t,m)
Données
t : Tableau [N] de réel
m : réel
Locales
v : réel
i : entier
v <- 0.0
pour i de 0 à N-1 faire
v <- v + (t[i]-m)*(t[i]-m)
fait
v <- sqrt(v)
retourner v
fin fonction
{ Methode de calcul du coefficient }
{ de correlation lineaire existant }
{ entre deux series de valeurs reelles }
réel fonction coefficientCorrelation(ds)
Données
ds : deuxSeries
locales
cc : réel
i : entier
mx : réel
my : réel
eqmx : réel
eqmy : réel
mx <- moyenne(ds.x)
my <- moyenne(ds.y)
cc <- 0.0
pour i de 0 à N-1 faire
cc <- cc + (ds.x[i]-mx)*(ds.y[i]-my)
fait
eqmx <- ecartQuadratique(ds.x,mx)
eqmy <- ecartQuadratique(ds.y,my)
cc <- cc/(eqmx*eqmy)
retourner cc
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
b) On souhaite implanter une "structure de données" permettant de stocker un ensemble de chaînes de
caractères pour un maximum de 20 chaînes de caractères.
1) Définir un type agrégé permettant de stocker un tel ensemble (initialisé à l'ensemble vide).
2) Implanter un sous-algorithme permettant d'afficher les chaînes de caractères présentes dans un ensemble
de chaînes de caractères.
3) Implanter un sous-algorithme permettant d'ajouter une chaîne de caractères à un ensemble de chaînes
de caractères (l'ajout d'une chaîne existant déjà est autorisé).
4) Implanter un sous-algorithme permettant de tester si une chaîne de caractères appartient à un ensemble
de chaînes de caractères.
5) Implanter un sous-algorithme permettant de fusionner 2 ensembles de chaînes de caractères en un nouvel
ensemble de chaînes de caractères.
6) Implanter un sous-algorithme permettant de retirer une chaîne de caractères d'un ensemble de chaînes
de caractères.
7) Implanter un sous-algorithme permettant de tester si un ensemble de chaînes de caractères est vide.
|
EnsembleDeChainesDeCaracteres.lda
constante entier N <- 20
{ Type agrege de stockage d'un ensemble }
{ d'au maximum 20 chaines de caracteres }
structure ensembleDeChaines
n : entier <- 0
s : Tableau [N] de chaine
fin structure
{ Affichage des chaines de caracteres }
{ contenues dans un ensemble de chaines }
{ de caracteres }
action affichage(edc)
Données
edc : ensembleDeChaines
Locales
i : entier
pour i de 0 à edc.n faire
Ecran.afficherln(edc.s[i])
fait
fin action
{ Ajout d'une chaine de caracteres }
{ a un ensemble de chaines de caracteres }
{ Retourne vrai si l'ajout a abouti }
{ Retourne faux si plus de place }
booleen fonction ajout(e,s)
Données / Résultats
e : ensembleDeChaines
Données
s : chaine
Locales
res : booleen
si e.n < N alors
e.s[e.n] <- s
e.n <- e.n+1
res <- vrai
sinon
res <- faux
fsi
retourner res
fin fonction
{ Test de l'appartenance d'une chaine }
{ de caracteres a un ensemble de chaines }
{ de caracteres }
{ Retourne vrai si present, faux sinon }
booleen fonction appartient(e,s)
Données
e : ensembleDeChaines
s : chaine
Locales
booleen res
i : entier
res <- faux
i <- 0
tantque ( res = faux ) et ( i < e.n ) faire
res <- (e.s[i] = s)
i <- i+1
fait
retourner res
fin fonction
{ Fusion de deux ensembles de chaines }
{ de caracteres en un nouvel ensemble }
{ de chaines de caracteres }
{ Retourne null si fusion impossible }
{ car pas assez de place }
ensembleDeChaines fonction fusion(e1,e2)
Données
e1 : ensembleDeChaines
e2 : ensembleDeChaines
Locales
e : ensembleDeChaines
i : entier
si e1.n+e2.n <= N alors
pour i de 0 à e1.n-1 faire
ajout(e,e1.s[i])
fait
pour i de 0 à e2.n-1 faire
ajout(e,e2.s[i])
fait
sinon
e <- null
fsi
retourner e
fin fonction
{ Retrait d'une chaine de caracteres }
{ a un ensemble de chaines de caracteres }
{ Retourne vrai si le retrait a abouti }
{ Retourne faux sinon }
booleen fonction retrait(e,s)
Données / Résultats
e : ensembleDeChaines
Données
s : chaine
Locales
res : booleen
i : entier
res <- faux
i <- 0
tantque ( res = faux ) et ( i < e.n ) faire
res <- (e.s[i] = s)
i <- i+1
fait
si res alors
pour i de i à e.n-1 faire
e.s[i-1] <- e.s[i]
fait
e.n <- e.n-1
fsi
retourner res
fin fonction
{ Test si un ensemble de chaines }
{ de caracteres est vide }
booleen fonction estVide(EnsembleDeChaines e)
retourner (e.n = 0)
fin fonction
Clavier.class - Ecran.class
- Exemple d'exécution
|
|
