1 exercices simples

Exercice 1 :
Ecrire un algorithme d’une action qui échange deux variables A et B

Action : Echange
Var : A, B, C : réels
Début : Ecrire (« Saisissez deu x variables »)
Lire (A, B)
C <= A
A <= B
B <= C
Ecrire (« les valeurs de », A, « et de » , B, « ont été changées »)
Fin

Exercice 2 :
Ecrire une fonction qui donne les carré d’un réel

Fonction : carré (x :réel) :réel

Var : x_au_carré
Début
x_au_carré <= x* x
retourner x_au_carré
fin

Remarques :
Dans une fonction, la seule variable qui est définie est celle du résultat, les autres sont définies dans la fonction
mère, et apparaissent ici en temps qu’entrées.
Dans une fonction, ne pas oublier de retourner le résultat.
 2 exercice en utilisant les structures
SI…ALORS…SINON et SELON…QUE

Exercice 3 :
Ecrire une action qui fournit les félicitations ou l’ajournement d’un élève suivant sa note en utilisant Si-alors-
sinon.

Action : Jury
Var : note : réel
Début : lire (note)
Si note <10 alors écrire (« ajourné »)
Sinon écrire (« reçu »)
Fin

Exercice 4 :
Ecrire un programme qui donne la valeur absolue de 2 réels :

Action : Valeur_absolue
Var : a, b : réels
Début : Ecrire (« saisissez 2 réels »)
Lire (A, B)
Ecrire « les valeurs absolues de A et de B sont : »)
Si A <0 alors écrire (-A )
Sinon écrire (A)
Ecrire (« et »)
Si B<0 alors écrire (-B)
Sinon écrire (B)
Fin

Remarque : on peut aller plus vite en créant une fonction valeur absolue et en faisant appel à cette fonction dans
une action :

Fonction : valAbs (x :réel) :réel

Var : abs x : réel
Début : si x <0 alo rs absx <= -x
Sinon absx <= x
Retourner absx
Fin

Et
Action : Valeur_absolue2
Var : A, B réels
Début : Ecrire (« saisissez 2 réels »)
Lire (A, B)
Ecrire (« les valeurs de A et B sont : », valAbs(A), « et », valAbs(B))

Ecrire 5 :
Faire un programme qui donne le volu me d’un cylindre en faisant appel à une fonction ‘aire d’un cercle’.

Fonction : aire_cercle (rayon :réel) :réel

Var : A ire : réel
Const : PI=3.14

2
Début : Aire <= PI*rayon*rayon
Retourner (Aire)
Fin

Fonction : volu me_cercle (hauteur, rayon :réels) :réel

Var : volu me : réel
Début : Vo lu me <=aire_cercle (rayon)*hauteur
Retourner volu me
Fin

Exercice 6 :
Ecrire un algorithme permettant de résoudre une équation du premier degré

Action : premierdegre
Var : a, b, x réels
Début : Ecrire (« saisissez les valeurs a et b de l’équation ax+b =0 : »)
Lire (a, b)
Si a = 0 alors écrire (« pas de solution »)
Sinon écrire (« la solution est x= », -b/a)
Fin

Exercice 7 :
Ecrire un algorithme permettant de résoudre une équation du second degré en utilisant des si alors..

Action : seconddegré
Var : a, b, c, delta
Début : Ecrire (« saisissez les valeurs a, b et c de l’équation ax²+b x+c=0 : »)
Lire (a, b, c)
Si a=0 alors écrire (« équation du premier degré »)
Sinon delta<=b² -4*a*c
Début
Si delta>0 alors écrire (« les solutions de l’équation sont », (-b-sqrt(delta))/(2*a), « et », (-
b+sqrt(delta))/(2*a))
Sinon
Début
Si d =0 alors écrire ( -b/(2a))
Sinon écrire (« pas de solutions réelles »)
Fin
Fin
Fin

Ecrire le même algorith me avec des selon-que :

Action : seconddegré
Var : a, b, c, delta
Début : Ecrire (“saisissez les valeurs de a, b et c de l’équation ax²+b x+c)
Lire (a, b, c)
Si a=0 alors écrire (« résoudre permier degré »)
Sinon début
Delta <= b²-4*a*c
Selon que
Delta > 0 : écrire ((-b-sqrt(delta))/(2*a), (-b+sqrt(delta))/ (2*a))
Delta = 0 : écrire (( -b/(2a))
Sinon écrire (« pas de solution réelle »)
Fin selon
Fin

3
Exercice 8
Ecrire un algorith me qui donne la durée de vol en heure minute connaissant l’heure de départ et l’heure
d’arrivée.
1) on considère que le départ et l’arrivée ont lieu même jour
2) idem mais sans faire les conversions en minutes
3) on suppose que la durée de vol est inférieure à 24 heures mais que l’arrivée peut avoir lieu le
lendemain.

1)
Action : DuréeVol1
Var : h 1, h 2, m1, m2, hr, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
Lire (h1, m1, h2, m2)
mr <= [h2* 60+m2] – [h1* 60+m1]
hr <= mr/60
mr <= mr%60
Ecrire (« durée de vol : » , hr, mr)
Fin

Remarque : l’opération % (modulo) permet de calcu ler le reste de la division entière.

2)
Action : DuréeVol2
Var : h 1, h 2, h r, m1, m2, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
Lire (h1, m1, h2, m2)
Si m2>m1 alors
hr <= h2-h1 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Fin

3)
Action : DuréeVol3
Var : h 1, h 2, m1, m2, hr, mr : entiers
Début : Ecrire (« entrer horaire de départ et d’arrivée »)
Lire (h1, m1, h2, m2)
Si h 2>h 1 alors
Si m2>m1 alors
hr <= h2-h1 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Sinon
Si m2>m1 alors
hr <= h2-h1+24 et mr <= m2-m1
Ecrire (hr, mr)
Sinon
hr <= h2-h1+24-1 et mr <= m2+60-m1
Ecrire (hr, mr)
Fin

Exercice 9
1) Ecrire une fonction max3 qui retourne le maximu m de trois entiers

4
 2) Ecrire une fonction min 3 qui retourne le min imu m de tro is entiers
3) Ecrire une fonction max2 qui retourne le maximu m de deu x entiers
4) Ecrire une fonction max3 qui retourne le maximu m de trois entiers en faisant appel à max2

1)
Fonction : max3(a, b, c : entier) : entier :
Var : max3 : entier
Début : Si a>b alors
Si a>c alors max3 <= a
Sinon max3 <= c
Sinon
Si c>b alors max3 <= c
Sinon max3 <= b
Retourner (max3)
Fin

2)
Fonction : min3(a, b, c : entier ) : entier :
Var min 3 : entier
Début
Retourner (– max3(-a, -b, -c))
Fin

3)
Fonction : max2 (a, b : entier) : entier
Var : max2 : entier
Début : Si a<b alors max2 <= b
Sinon max2 <= a
Retourner (max2)
Fin

4)
Fonction : max3 (a, b, c : entier) : entier :
Var : max3 : entier
Début : max3 <= max2 [max2 (a, b), c)
Retourner (max3)
Fin

Exercice 10
Ecrire avec des Si A lors Sinon une action permettant la saisie d’une note n (0 n 20) et qui affiche la mention
(n 16 : TB, n 14 : B, n 12 : AB, n 10 : Passable, n 10 : Ajourné)

Action : Mention
Var Note : réel
Début : Ecrire (« saisissez une note »)
Lire (Note)
Si Note 16 alors écrire (« TB »)
Sinon
Si Note 14 alors écrire (« B »)
Sinon
Si Note 12 alors écrire (« AB »)
Sinon
Si Note 10 alors écrire (« Passable »)
Sinon écrire (« ajourné »)
Fin

Alternative : écrire le même programme avec des Selon Que :

5
Action : Note
Var : Note : réel
Selon que
Note 16 écrire (« TB »)
Note 14 écrire (« B »)
Note 12 écrire (« AB »)
Note 10 écrire (« Passable »)
Sinon écrire (« ajourné »)

Exercice 11
Soit l’algorith me suivant :
Action : Permis_voiture
Var : permis, voiture : booléen
Début : Ecrire (« avez-vous le permis ? (0/1) »)
Lire (permis)
Ecrire (« avez vous une voiture ? (0/1) »)
Lire (voiture)
Si non permis ou voiture alors
Si vo iture alors écrire (« conduisez moi à la gare »)
Sinon écrire (« j’ai une voiture pas chère »)
Sinon
Si vo iture alors écrire (« vous êtes hors la loi »)
Sinon écrire (« vive le vélo »)
fin

1) Ecrire l’arb re des conditionnelles

2) Corriger les tests pour que tous les cas soient couvert de manière cohérente
3) Faites correspondre les actions et les tests correctement
4) Si possible, écrire cet algorithme avec des selon que.

Permis et voiture Permis voiture Ni permis ni voiture

gare Vive le vélo Conduisez moi à la gare Vo iture pas chère
Conduisez moi à la gare Vo iture pas chère Hors la loi Vive le vélo

En clair, selon l’algorith me proposé : si l’on a le permis et la voiture on peut amener quelqu’un à la gare ; si l’on
a que le permis on dit vive le vélo, si l’on n’a que la voiture on conduit aussi à la gare, enfin si l’on a n i permis ni
voiture alors on achète une voiture pas chère. Le cas hors la loi n’est pas évoqué et les correspondance sont
inexactes. Il faut évidemment avoir :
- permis et voiture : conduire à la gare
- permis : j’ai une voiture pas chère
- voiture : vous êtes hors la loi
- ni voiture, n i permis : vive le vélo

Correction de l’algorithme proposé :

Action : Permis_voiture
Var : permis, voiture : booléen
Début : Ecrire (« avez-vous le permis ? (0/1) »)
Lire (permis)
Ecrire (« avez vous une voiture ? (0/1) »)
Lire (voiture)
Si permis ou voiture alors
Si vo iture alors écrire (« conduisez moi à la gare »)
Sinon écrire (« j’ai une voiture pas chère »)
Sinon
Si vo iture alors écrire (« vous êtes hors la loi »)
Sinon écrire (« vive le vélo »)

6
On peut effectivement écrire cet algorithme avec des selon-que :
Action : permis_voiture
Var : permis voiture : réel
Début : Ecrire (« avez-vous le permis ? (0/1) »)
Lire (permis)
Ecrire (« avez vous une voiture ? (0/1) »)
Lire (voiture)
Selon que :
Permis et voiture : écrire (« conduisez moi à la gare »)
Permis et non voiture : écrire (« j’ai une voiture pas chère »)
Non permis et voiture : (« vous êtes hors la loi »)
Non permis et non voiture : (« vive le vélo » )
Fin

Exercice 12
Ecrire un programme calculat rice permettant la saisie de deux entiers et une opération –booléen- ( +, - , / , x ) et
affichant le résultat. Donner avant cela les spécifications, la solution en langage naturel, les structures de
données.

Spécifications :
Données : 2 opérandes et un opérateur
Résultat : résultat de l’opération choisie

Solution en langage naturel : Saisie des données, envisager tous les cas : +, - , x, /. Attention à la division par
zéro qui est impossible

Structure de données : 2 opérandes : des entiers

Un opérateur booléen : +, -, * , /

Algorith me :

Action : calcu l
Var : a, b : réel op : booléen
Début Ecrire (« saisissez le premier entier »)
Lire (a)
Ecrire (« saisissez l’opérateur »)
Lire (op)
Ecrire (« saisissez la deu xième variable »)
Lire (b)
Selon que :
Op = ‘+’ : Ecrire (a+b)
Op = ‘*’ : Ecrire (a*b)
Op = ‘/’ : Si b = 0 alors écrire (« d ivision impossible »)
Sinon écrire (a/b)
Op = ‘-‘ : Ecrire (a-b)
Fin selon
Fin

7
 3 exercices en utilisant les structures répétitives
TANT QUE et REPETER…JUSQU'A et POUR

Exercice 13
Ecrire le programme qui affiche la so mme d’une suite d’entiers saisie par l’utilisateur se terminant par zéro.
Exemple : l’utilisateur entre 1, puis 5, puis 2, puis 0 : affiche : 8
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorith me

Spécifications :
- données : suite de nombre entiers se terminant par zéro
- résultat : la somme de ces entiers

Solution en langage naturel : tant que l’entier saisi n’est pas zéro, l’ajouter à la somme part ielle et saisir l’entier
suivant.

Structure de données :
- entier : entier courant (saisi)
- entier : somme partielle

Algorith me :
Action : So mme Su ite
Var : a, s : entiers
Début s<=0 Attention : dans une structure tant que ne pas oublier d’init ialiser!!!
Lire (a)
Tant que a 0 faire
Début
s<=s+a
Lire (a)
Fin
Ecrire (s)
Fin

Exercice 14
Ecrire un algorithme qui affiche la moyenne d’une suite d’entiers se terminant par zéro (le zéro n’entrant pas en
compte dans la moyenne : il est juste la pour indiquer la fin de saisie)
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorith me

Spécification :
- données : suite d’entier se terminant par zéro
- résultat : la moyenne de ces entiers (zéro exclu)

Solution en langage naturel :

Tant que l’entier saisi différent de 0 alors ajouter l’entier au x entiers précédents et faire la moyenne (c’est à dire
diviser par le no mbre d’entiers

Structures de données :
- entier : entier saisi

8
 - entier : résultat moyenne

Algorith me :
Action : Moyenne
Var : n, moy, s : entiers
Début : moy<=0
s<=0
Lire (n)
Tant que n 0 faire
Début
Moy <= moy*s+n)/(s+1)
s<=s+1
lire (n)
fin
Ecrire (moy )
Fin

Exercice 15
Ecrire un algorith me permettant la saisie d’une suite d’entiers se terminant par zéro et vérifier si cette suite
contient deux entiers consécutifs égaux en utilisant les structures tant que.
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorith me

Spécifications :
- données : suite d’entier se terminant par zéro
- résultat : vrai si deu x entiers consécutifs, faux sinon.

Solution en langage naturel : co mparer l’entier courant et le précédent. Et tant que ils sont différents, on continu
la lecture et tant que l’entier courant est différent de zéro.

Structures de données :
- entier : nomb re courant
- entier : nomb re précédent

Algorith me :
Action : Entiers consécutifs
Var : nc, np : entier
{on désignera par nc le nomb re courant et np le no mbre précédent}
Début Lire (nc)
np<=nc-1
{pour être sur que le no mbre courant ne sera pas le même que le nombre précédent dès le départ on affec te la
valeur nc-1 au nombre précédent. On aurait tout aussi bien pu lui donner la valeur zéro)
Tant que nc 0 et np nc faire
Début
np<=nc
lire (nc)
fin
Si nc 0 alors écrire (« oui »)
Sinon écrire (« non »)
Fin

Refaire le même algorithme en utilisant une structure répéter jusqu'à

Action : Entiers consécutifs

Var : nc, np : entiers
Début

9
Lire (nc)
Si nc 0 alors Répéter
Début
np <= nc
lire (nc)
jusqu'à (nc=np ou nc=0)
Si nc=0 alors écrire (« oui »)
Sinon écrire (« non »)
Fin

Exercice 16
Ecrire un algorithme qui affiche le maximu m d’une suite se terminant par zéro
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorith me

Spécifications :
- données : une suite d’entiers se terminant par zéro
- résultat : un entier : le maximu m de cette suite

Solution en langage naturel : co mparer l’entier courant avec le maximu m et tant que nc<max on continue, sinon
on affiche la résultat et on continue, et tant que nc 0

Structures de données
- n : entier courant (saisi)
- max : entier max de la suite

Algorith me :
Action : max suite
Var : n, max : entiers
Début Lire (n)
Max<=n
Tant que n 0 faire
Début
Lire (n)
Si max<n alors max<=n
Fin
Ecrire (max)
Fin

Exercice 17
Ecrire un programme mettant en œuvre le jeu suivant :
Le premier utilisateur saisi un entier que le second doit deviner. Pour cela, il a le dro it à autant de tentatives qu’il
souhaite. A chaque échec, le programme lui indique si l’entier cherché est plus grand ou plus petit que sa
proposition.
Un score indiquant le no mbre de coups joués est mis à jour et affiché lorsque l’entier est trouvé.
1) donner les spécifications
2) donner la solution en langage naturel
3) indiquer les structures de données
4) faites l’algorith me

Spécifications :
- données : nombre entier
- résultat : nombre de tentatives

10
Solution en langage naturel : saisir un nombre entier par le premier joueur. Tant que le joueur 2 n saisie, dire si
n est > ou < à nombre cherché, incrémenter de 1 et continuer. Quand le résulta t est trouvé, afficher le nombre de
tentatives.

Structures de données :
- a : no mbre saisi par l’utilisateur 1
- n : no mbre saisi par l’utilisateur 2
- t : tentatives

Algorith me :
Action : devinette
Var : a, n, t : entiers
Début : Lire (a)
Lire (n)
t=0
Tant que a n faire
Début
Si n >a alors écrire (« no mbre cherché p lus petit « )
Sinon écrire (« nombre cherché plus grand »)
t<=t+1
lire (n)
fin
écrire (t+1)
fin

Exercice 18
Ecrire un algorith me permettant de calculer le PGCD de deux no mbres en utilisant l’astuce suivante : soustraite
le plus petit des deux entiers du plus grand jusqu'à ce qu’ils soient égaux
Ecrire le même programme en utilisant l’algorith me d’Euclide : d’une part en utilisant uniquement les structures
TANT QUE, d’autre part en utilisant uniquement les structures REPETER JUSQU'A.

Action : PGCD
Var : a, b entiers
Lire (a, b)
Début
a = ValAbs (a)
b = ValAbs (b)
Répéter
Selon que
a>b a<=a -b
a<b b<=b-a
jusqu’a a=b
écrire (a)
Fin

Même programme avec Euclide et des TANT QUE :

Action : PGCD
Var : a, b, r entiers
Lire (a, b)
r<=a%b
tant que r 0 faire
début
a<=b
b<=r
r<=a%b
fin
écrire (b)
fin

11
Même programme avec Euclide et des REPETER JUSQU'A :
Action : PGCD
Var : a, b, r entiers
Lire (a, b)
Répéter r<=a%b
a<=b
b<=r
jusqu'à r=0
écrire (b)
fin

Exercice 19
Ecrire avec la co mmande POUR un algorith me qui permet de faire la somme d’une suite de nombre entrée par
l’utilisateur. Faire la même chose en comptant par pas de –1.

Action :somme_nombre
Var : k, nb, n, somme : entier
Début :
Somme <= 0
Ecrire (« co mb ien voulez-vous entrer de nombres ? »)
Lire (nb)
Pour k de 1 à nb faire
Début
Lire (n)
Somme<=somme + n
Fin
Ecrire (so mme)
Fin

Même p rogramme par pas de –1 :

Action : somme_entier
Var : k, nb, n, somme : entiers
Début :
Somme<=0
Ecrire (« co mb ien voulez-vous entrer de nombres ? »
Lire (nb)
Pour k de nb à 1 par pas de –1 faire
Début
Lire (n)
Somme<=somme + n
Fin
Ecrire (so mme)
Fin

Exercice 20
Traduire le POUR de l’algorith me suivant en REPETER JUSQU'A :
Action : bidon
Var : k, nb : entiers
Début
Lire (nb)
Pour k de 1 à nb faire
Ecrire (k)
Fin

Action : Bidon
Var : k, nb : entier
Début

12
 Lire (nb)
K<=1
Si nb>0 alors
Répéter écrire (k)
K<=k+1
Jusqu’à k>nb
Fin

Exercice 21
Ecrire une fonction qui fait la somme des entiers compris dans un intervalle.

Fonction : intervalle (a, b ; entiers) : entier

Var : k, somme : entier
Début
Somme <= 0
Pour k de a à b faire
Somme<=somme + k
Retourner (somme)
Fin

Exercice 22
Ecrire une fonction multip lication de a et b par addition successives.

Fonction : mu ltiplication (a, b : entiers) : entier

Var : k, produit : entiers
Début
produit<=0
Pour k de 1 à a faire
Produit<=produit + b
Retourner (produit)
Fin

13
 4 exercices sur les Tableaux

Exercice 23
Ecrire une action qui permette la saisie d’un tableau croissant : si T[k]<T[k+1] on enregistre, si T[k]>T[k+1] on
redemande la saisie d’un nombre plus grand

Const : MAX=100
Ttype : Ttab=tableau [max]d’entier

Action : saisie_tableau_croissant
Var : tab : Ttab, i : entier
Début
Lire (Tab[0])
Pour i de 1 à MAX-1 faire
Répéter lire (tab[i])
jusqu'à tab[i] tab[i-1]
Fin

Exercice 24
Ecrire une fonction retournant le maximu m d’un tableau de taille n.
Faire le même algorith me mais qui ne retourne que l’indice de la case du tableau contenant le maximu m du
tableau.

Fonction : maximu m (tab : Tableau d’entier n :entier) : entier

Var : max, i : entiers
Début
Max <= tab[0]
Pour i de 1 à n-1 faire
Si tab[i]>max alors max<=tab[i]
Retourner (max)
Fin

Fonction : maximu m (tab : Tableau d’entier n :entier) : entier

Var : indice, i, max : entiers
Début
Max<=tab[0]
Indice <=0
Pour i de 1 à n-1 faire
Si tab[i]>max alors
max<=tab[i]
indice<=i
Retourner (indice)
Fin

14
 5 Exercices généraux sur les actions paramétrées

Exercice 25
Ecrire une fonction Afficher qui affiche a l’écran le contenu d’un tableau. Ecrire aussi l’action principale qui
permettra de co mprendre co mment fonctionne cette fonction afficher.

{Ne pas oublier d’indiquer les paramètres du tableau !}

Const : MAX : entier=100
Type : Ttab : Tableau [MAX] d’entier

Fonction Afficher (tab : tableau d’entiers, n entiers)

Var : i entier
Début :
Pour i de 0 à n-1
Ecrire (tab[i], « »)
Fin

Action principale
Var t 1 t2 : Ttab
Début
T1[0]<=1
T1[1]<=3
T2[0]<=4
T2[1]<=5
T2[2]<=7
Afficher (T1, 2)
Afficher (T2, 3)
Fin

Résultat à l’écran :
13
457

Exercice 26
Ecrire une fonction qui permet la saisie d’un tableau. Faite aussi l’action principale qui permettra d’accéder a
cette fonction saisie mais aussi d’afficher dans un second temps le résultat

Fonction : saisie (Stab : tableau d’entiers, N :entier)

Var : i entier
Début :
Pour i de 0 à n-1 faire
Lire (tab[i])
Fin

Action principale
Var : tabl : Ttab
Début
Saisie (toto, 10)
Afficher (toto, 10)
Fin

15
Ou afficher est la fonction de l’exercice 1.

Exercice 27
Ecrire une fonction qui calcule le no mbre d’inversion d’un tableau de taille n (c’est à dire i<j et tab[i]>tab[j]
pour tout i et j.)

Fonction inversion (tab : tableau d’entiers, N entier)

Var : j, C, i entiers
Début
C<=0
Pour i de 0 à n-2 faire
Début
Pour j de i+1 à n-1 faire
Si tab[i]>tab[j] alors C<=C+1
Fin
Retourner ( C )
Fin

Exercice 28
Ecrire une action qui affiche les n premiers éléments de la suite définie par u 0 =1 et un+1 =somme de k=0 jusqu'à n
de (u k *un-k )
Aide : stocker les éléments dans un tableau toto avec toto[0]=1. Puis on utilise une boucle imbriquée pour
calculer toto[n+1]=somme k=0 à k=n de toto[k]*toto[n-k].

Action Suite (E : d :entier)

Var : toto : Ttab, i, k : entiers
Début :
Toto[0]<=1
Pour I de 1 à d -1 faire
Toto[i]<=0
Pour k de 0 à n-1 faire
Toto[i]<=toto[i]+toto[k]+toto[i-1-k]
Afficher (toto, d)
Fin

Exercice 29
Voyons maintenant quelques exercices rudimentaires de changements dans un tableau
Ecrire une action permettant de remp lacer toutes les occurrences de x par y dans un tableau de taille n.
Ecrire un algorithme qui échange les valeurs des cases i et j dans un tableau.
Ecrire un programme qui inverse un tableau. (exemple : 1 5 6 7 3 devient 3 7 6 5 1)

Action : Remplacer (E : x : entier, E : y : entier, ES tab : tableau d’entiers, E : n : entier)

Var : i :entier
Début
Pour i de 0 à n-1 faire
Si tab[i]=x alors tab[i]<=y
Fin

Action : Echanger (E : i : entier, E : j : entier, ES : tab : tableau d’entier, E : n :entier)

Var : temp
Début
Si i<n ET j<n alors
Temp <=tab[i]
Tab[I]<=tab[j]
Tab[j]<=temp
Fin

16
Action : inverser (ES : tab : tableau d’entiers, E : n : entier)
Var : i :entier
Début
Pour i de 0 à n/2 – 1 faire
Echanger (i, n-1-in tab, n )
{ou Echanger est la deu xième action de cet exercice}

Fin

17
 6 Entités : types structurés

Explicati ons 1 :
Les types structurés sont :
- les tableaux (voir les exercices précédents)
- les entités (ou l’on regroupe plusieurs types sous un même objet)

Exemple :
Etudiant (no m, groupe, note)
Type : Etd : entité (
No m : chaîne de caractère ;
Groupe : caractère ;
Note : entier ;
);

Pour faire appel à ce type d’entité on fera dans la fonction :

Var : Tetd toto ;
[Link]=alex
[Link]=A
[Link]=15
Ecrire (« l’étudiant », [Link], « du groupe », [Link], « a eu », [Link])

Exercice 30
Proposer une entité de données pour stocker un point dans le plan

Type : Tpoint=Entité (
abs : entier ;
ord : entier ;
)

Exercice 31
Ecrire les en-têtes des fonctions/actions suivantes :
- saisie d’un point
- affichage d’un point
- calcul de la distance entre deux points
- projection d’un point sur l’axe des abscisses
Ecrire ensuite les algorith mes de ces fonctions.
Faire une action principale qui demande la saisie de deu x points, calcule la d istance entre ces deux points et
affiche les résultats.

Action SaisieTpoint (S : P : Tpoint) {Tpoint a été défini à l’exercice 30}

Début
Lire ([Link])
Lire ([Link])
Fin

Action AfficherTpoint (E : P : Tpoint)

Début
Ecrire (« ( », [Link], « ; », [Link], « ) »)
Fin

Fonction distance (P : Tpoint ; Q : Tpoint) : réel

Var : d ist : réel

18
Début
Dist<=sqrt[([Link])² + ([Link])²]
Retourner (dist)
Fin

Action ProjectionX (ES : P : Tpoint)

Début
[Link]<=0
Fin

Action Principale
Var : P, Q : Tpoint
Dist : réel
Début
SaisieTpoint(P)
SaisieTpoint(Q)
Dist<=d istance(P, Q)
Ecrire (« la d istance entre »,AfficherTpoint(P), « et », AfficherTpoint(Q), « est », dist)
Fin

Explicati ons 2:
Nous ne rentrerons pas ici le tableau comme nous l’avons fait précédemment :
Nous utiliserons les entités. Ainsi la déclaration se fera de la manière suivante :
Const MAX=100
Type : Ttab Var=entité (
Tab : tab[MAX] d’entier
Taille : entier
)

Ainsi, dans une fonction, on aura :

TtabVar : toto
[Link][15]<=1 {pour entrer une valeur de tableau}
[Link]++ {On augmente la taille du tableau au fur et a mesure
Avantage de cette nouvelle man ière d ’entrer un tableau : on peu avoir un tableau de taille variable.

Exercice 32
Ecrire un algorithme qui permet de rentrer les données d’un tableau de type TtabVar et dont on connaît la taille.
Ecrire ensuite un algorith me qui permet de rentrer les données d’un tableau de type TtabVar et ou l’on ne connaît
pas la taille.

Action saisieTtabVar (S : tabvar : Ttab Var, E : n : entier)

Var : i : entier
Début
Pour i de 0 à n-1 faire
Lire ([Link][i])
[Link]<=n
Fin

Action saisieTtabVar (S tabvar : Ttab Var)

Var : réponse : chaîne de caractère
Début
[Link]<=0
Répéter
Ecrire (« voulez-vous entrer un entier ? »)
Lire (réponse)
Si réponse « non » alors
Lire ([Link][[Link]])
[Link]++

19
 Jusqu’à (réponse= « non » ou [Link]=MAX)
Fin

Exercice 33
Ecrire un algorithme qui permet de rentrer un tableau de taille variab le de Tpoint (vo ir exercice 30 et 31). Pour
cela, il faudra au préalable créer un nouveau type d’entité.

Const MAX=100
Type TtabVarPt=entité (tab : tableau[MAX] de Tpoint, taille : entier)

Action : SaisieTtab VarTpoint (S : tabvarPt : Ttab VarTpoint)

Var : réponse : chaîne de caractère
Début
[Link]<=0
Répéter
Ecrire (« voulez-vous entrer un entier ? »)
Lire (réponse)
Si réponse « non » alors
Lire ([Link][[Link]].abs)
Lire ([Link][[Link]].ord)
Tabvarpt++
Jusqu’à (réponse= « non » ou [Link]=MAX)

Exercice 34
Ecrire un algorithme qui détermine le point ( ( !) c’est à dire son indice)le plus au nord et le point le plus a
l’ouest dans un tableau de Tpoint.
Faire ensuite une action principale qui demande la saisie d’un tableau de Tpoint à l’utilisateur (voir exercice 33)
et affiche l’élément le plus au nord et l’élément le plus à l’ouest.

Action NordOuest (E : tvp : Ttab VarPt, S : nord : entier, S : ouest : entier)

Var : i : entier
Début
Nord<=0
Ouest<=0
Pour i de 0 [Link]-1 faire
Si [Link][i].abs<[Link][ouest].abs) alors ouest<=i
Si [Link][i].o rd<[Link][ouest].ord) alors nord<=i
Fin

Action Principale
Var toto : Ttab VarPt ; n, o : entiers
Début
Saisie Ttab VarTpoint (toto)
NordOuest (toto, n, o)
Ecrire (« l’élément le plus au nord est », AfficherTpoint([Link][n])
{ou AfficherTpoint est la fonction de l’exercice 31}
Ecrire(« l’élément le plus à l’ouest est », AfficherTpoint([Link][o])
Fin

Exercice 35
Ecrire un algorithme qui détermine la distance maximale entre deu x points d’un tableau de Tpoint

Action DistMax (E : tvp : Ttab VarPt)

Var : i, j : entiers ; Dmax, dist : reels
Début
Dmax<=0
Pour i de 0 à [Link]-2 faire

20
 Pour j de i+1 à [Link]-1 faire
Dist<=d istance([Link][i] ; [Link][j])
Si d ist>Dmax alors Dmax<=dist
Ecrire (« la d istance maximale entre deu x points du tableau est », Dmax)
Fin

21
 7 Tableaux triés et découpages fonctionnels

Exercice 36
Le but de l’exercice est de créer une action de saisie de tableau, qui trie, au fu r et à mesure des entrées, les
valeurs par ordre croissant dans le tableau.
Exemple :
Soit le tableau suivant :
0 1 2 3

2 5 7 9
Co mment insérer 6 dans le tableau trié (en supposant qu’il n’y a pas de doublon dans le tableau) ?
- je cherche la bonne position (ici : la case d’indice 2)
- décalage à droite si nécessaire :
0 1 2 3 4

2 5 7 7 9
- Insertion de l’élément
0 1 2 3 4

2 5 6 7 9

On a donc ici le découpage fonctionnel :

On va donc créer une fonction IndiceElt Sup qui cherche la bonne position, une act ion Insérer qui inclue le
nombre entré dans la bonne case du tableau, et une action DécalageDroite qui décale co mme dans l’exemp le
toutes les cases d’un rang vers la droite si nécessaire.

Const MAX=100
Type TtabVar = entité (tab : tableau[MA X] d’entiers, taille : entier)

Fonction IndiceEltSup (tvt : Ttab Var, entier, n : entier) : entier

Var : i : entier
Début
Tant que (i [Link] ET [Link][i]<n)
i<=i+1
retourner (i)
Fin

Action DécalageDro ite (ES : tvt : Ttab Var, E : i : entier)

Var : j : entier
Début
Pour j de [Link] – 1 à i par pas de –1 faire
[Link][j+1]<=[Link][j]
[Link]++
Fin

Action Insérer (ES : tvt : Ttab Var, E : i : entier, E : i : entier)

Début
DécalageDroite (tvt, i)
[Link][i]<=i
Fin

Action SaisieTrié (S : tvt : Ttab Var)

Var : rep : chaîne, nb : entier, i : entier
Début
[Link]<=0
Répéter
Ecrire (Rentrer encore un entier ?)
Lire (rep)

22
 Si rep « non » alo rs
Lire (nb)
I<=IndiceEltSup(tvt, nb)
Si non(i<[Link] ET [Link][i]=nb)
Insérer (tvt, i, nb)
Jusqu’à rep= « non » ou [Link]=MAX
Fin

Exercice 37
Faire un algorithme qui fait une recherche dichotomique dans un tableau trié. On pourra utiliser les fonctions de
l’exercice précédent.

Nous allons créer une action qui défin ie la zone de recherche, puis l’action RechercheDicho qui opérera la
recherche dichotomique dans l’intervalle défin ie par la zone de recherche.

Action ZoneRecherche (E : tvt : Ttab Var, E : n : entier, ES : Binf : entier, ES : Bsup : entier)
Var : milieu : entier
Début
Milieu <= (Binf + Bsup)/2
Si [Link][milieu]=n alors
Début
Binf<=milieu
Bsup<=milieu
Fin
Sinon
Si [Link][milieu]>n alors Bsup<=milieu –1
Sinon Binf<=milieu+1
Fin

Fonction RechercheDicho (E : tvt : TtabVar, E : n : entier)

Var : Binf, Bsup : entiers
Début
Binf<=0
Bsup<=[Link] –1
Tant que Bsup>Binf faire
ZoneRecherche (tvt, n, Binf, Bsup)
Si Bsup=Binf alors
Retourner (Binf)
Sinon retourner ( -1)

Exercice 38
Faire un algorithme qui supprime une valeur dans un tableau trié. On pourra uti liser des fonctions des deux
exercices précédents.

Le but est d’utiliser la recherche dichotomique de l’exercice précédent pour trouver dans le tableau l’indice de la
valeur que l’on veut supprimer puis faire un décalage à gauche pour remettre en place le s valeurs (sans qu’il y ait
de vide dans une case du tableau)

Action Supprimer (ES : tvt : Ttab Var, E : n : entier)

Var : i : entier
Début
i<=RechercheDicho(tvt, n)
Si i -1 alors
DecalageGauche (tvt, i)
Fin

Action DecalageGauche (Es : tvt : Ttab Var, E : i : entier)

Var : j: entier

23
Début
Pour j de i+1 à [Link] – 1 faire
[Link][j –1] <= [Link][j]
[Link] <= [Link] –1
Fin

24
 8 Les Chaînes

On va maintenant faire des exercices sur les chaînes de caractères.

En prat ique on pourra définir une chaîne de caractères de deux manières :

Const MAX entier = 100

Type Tchaine = entité ( tab : tableau[MAX] de caractères
Longueur : entier)

Ou bien :

Const MAX entier = 100

Type Tchaine = tableau [MAX] de caractères
{Avec la sentinelle END}

Exercice 39
Faire un algorithme qui détermine la longueur d’une chaîne de caractères.
Faire ensuite de deux man ières différentes, une fonction qui permet de copier la chaîne d’une source dans une
chaîne destination.

Fonction Longueur (chaine : Tchaine) : entier

Var i : entier
Début
i0
Tant que chaine[ i ] != END faire i i+1
Retourner (i)
Fin

Fonction de copie : première méthode :

Fonction Copier (E : src : Tchaine, S : dest : Tchaine)
Var i, Lsrc : entier
Début
LsrcLongueur(src)
Pour i de 0 à Lsrc faire dest[ i ]src [ i ]
Fin

Fonction de copie : deuxième méthode : plus optimisée :

Fonction CopieOptimisée (E : src : Tchaine, S : dest : Tchaine)
Var i : entier
Début
i0
tant que src[ i ] != END faire
dest [ i ]  src [ i ]
i  i+1
dest [ i ]  src [ i] {pour copier en fin de fichier la sentinelle}
Fin

Exercice 40
Faire une fonction de concaténation (ajoute à la fin de la première chaîne de caractères le contenu de la deuxième
chaîne de caractères.)
Faire une fonction de Co mparaison qui compare deu x cha înes de caractères suivant l’ordre lexicographique.

25
Faire une fonction qui efface une partie de la chaîne en spécifiant une longueur d’effacement et un indice à partir
duquel il faut effacer.

Action Concaténation (ES : src1 : Tchaine, E : src2 : Tchaine)

Var i, Lsrc1 : entiers
Début
i0
LsrcLongueur (src1)
Tant que src2 [ i ] != END
Src1[ Lsrc1+i] src2[ i ]
ii+1
src1[Lsrc1+i]src2[ i ]
Fin

Pour faire la fonction comparer, il faut d’abord créer une fonction qui compare les caractères :
Fonction Co mparerChar (char a, char b)
Début
Si a<b retourner (-1)
Si a=b retourner (0)
Si a>b retourner (1)
Fin

On peut maintenant faire la fonction de comparaison de chaînes de caractères qui utilisera la fonction
ComparerChar :
Fonction Co mparer (E : src1 : Tchaine, E : src2 : Tchaine)
Var i, L1, L2, cmp : entiers
Début
L1Longueur (src1)
L2Longueur (src2)
I0
Tant que (i<L1 ET i<L2 ET Co mparerChar (src1[ i ], src2[ i ])=0) faire i i+1
Si i=L1 ou i=L2 alors
Si i<L1 alo rs cmp1
Sinon
Si i<L2 alo rs cmp -1
Sinon cmp0
Sinon cmpCo mparerChar(src1[ i ], src2 [ i ])
Retourner (cmp )
Fin

Fonction Effacer (ES : src : Tchaine, E : indice : entier, E : lg : entier)

Var i, Lsrc : entiers
Début
LsrcLongueur (src)
Pour i de indice+lg à Lsrc faire
Src[i-lg]src[ i ]
Fin

Exercice 41
Ecrire l’en-tête d’une action multi décalage à dro ite qui décale à droite les éléments d’une chaîne à partir d’un
certain indice et insère des cases vides à la place. (des actions de mult i décalage ont déjà été vue avec le s
tableaux, on ne demande pas d’en refaire une ici, ce référer au x exercices sur les tableaux)
Faire une action d’insertion. On pourra pour cela utiliser au paravent la fonction mult i décalage à dro ite
précédente.
Faire une action de remplacement d’une partie d ’une chaîne de caractères par une autre chaîne de caractères dont
la longueur n’est pas forcément la même. On pourra utiliser des fonctions des exercices 39 et 40.

26
Faire une fonction Extraire qui prend une partie de chaîne de caractères à partir d’un certain indice et la met dans
une chaîne destination.
Faire une fonction de recherche qui recherche une chaîne dans une chaîne de caractère et retourne un indice si à
partir de cette case on a la chaîne cherchée. Sinon, elle retourne –1.
Faire une action qui changent toutes les occurrences d’une chaîne dans une chaîne de caractères par une autre
chaîne tampon.

Action MultidécalageDroite (ES : src : Tchaine, E : indice : entier, E : lg : entier)

Action Insérer (ES : src : Tchaine, E : indice : entier, E : motif : Tchaine)

Var i, Lsrc, Lmot if : entier
Début
Lmot ifLongueur(motif)
MultidécalageDro ite (src, indice, Lmotif)
Pour i de 0 à Lmotif-1 faire
src[indice+i]motif[ i ]
Fin

Action Remplacer (ES : src : Tchaine, E indice : entier, E lg : entier, E : motif : Tchaine)
Début
Effacer (src, indice, lg)
Insérer (src, indice, mot if)
Fin

Fonction Recherche (src : Tchaine, mot if : Tchaine, Binf : entier)

Var : i, Lsrc, Lmotif : entiers
Tampon : Tchaine
Début
LsrcLongueur (src)
Lmot ifLongueur(motif)
iBinf
Extraire (src, i, Lmotif, tampon)
Tant que (i<Lsrc – Lmot if ET Co mparer (tampon, motif) 0) faire
ii+1
Extraire (src, i, Lmotif, tampon)
Si non(i=Lsrc – Lmot if) alors retourner (i)
Sinon retourner (–1)
Fin

Action RemplacarToutesChaines (ES : src : Tchaine, E : ancien : Tchaine, E : nouveau : Tchaine)

Var i , Lancien, Lnouveau, indice :entiers
Début
i0
LancienLongueur (ancien)
LnouveauLongueur (nouveau)
Indice Recherche(src, ancien, i)
Tant que indice -1 faire
Remp lacer (src, ind ice, Lancien, nouveau)
iindice+Lnouveau
indiceRecherche(src, ancien, i)
Fin

27
 9 Les fichiers

Rappelons tout d’abord comment on manipule les fich iers en ASD.

On ne manipule que les identificateurs de fichiers. On ne se soucie donc pas des fichiers sources.

Pour ouvrir un fichier :

OuvrirFichier (IdFic, ModeOuverture)
Avec ModeOuverture = lecture ou écriture ou rajout.

Pour fermer un fichier

FermerFichier (IdFic)

Pour lire un fichier

LireFich ier (IdFic, élément) cela correspond à Lire(n)  cin>>n

Pour écrire un fichier

EcrireFichier (IdFic, élément) cela correspond à Ecrire(n)  cout<<n

Exercice 42
Faire l’algorith me d’une action qui lit un fich ier d’entiers et affiche tous les entiers de ce fichiers qui sont pairs.
Ecrire une action qui lit un fichier d’entiers et met dans un autre fichier d’entiers les valeurs paires.
Faire une fonction qui recherche un entier x dans un fichier d’entiers et retourne vrai si x est dans le fichier.

Action EntierPairs (E : Fic : fichier d’entiers)

Var n : entier
Début
OuvrirFichier (Fic, lecture)
Si EtatFichier (Fic) = succès alors
LireFich ier (Fic, n )
Tant que (EtatFich ier (Fic) FdF) faire {ou FdF signifie Fin de Fich ier}
Si n%2=0 alors Ecrire(n)
LireFich ier(n )
FermerFichier (Fic)
Sinon Ecrire (« Erreur, impossible d’ouvrir le fichier en lecture » )
Fin

Action EntiersPairsFich ier (E : f1 : fichier d’entiers, ES : f2 : fichier d’entiers)

Var n : entier
Début
OuvrirFichier (f1, lecture)
Si EtatFichier (f1) = succès alors
OuvrirFichier (f2, écriture)
Si EtatFichier (f2) = succès alors
LireFich ier (f1, n)
Tant que EtatFichier(f1) FdF faire
Si n%2=0 alors EcrireFich ier(f2, n)
LireFich ier (f1, n)
FermerFichier(f2)
Sinon écrire (« Erreur en écriture »)
FermerFichier (f1)
Sinon écrire (« Erreur en lecture »)
Fin

28
Fonction Recherche (x : entier, f : fichier d’entiers) : booléen
Var bool rep false
Début
OuvrirFichier (f, lecture)
Si EtatFichier(f)=succès alors
LireFich ier(f, n)
Tant que (EtatFich ier(f) FdF ET n x) faire
LireFich ier(f, n)
Si n =x alors rep true
FermerFichier (f)
Sinon Ecrire (« Erreur en lecture »)
Fin

Exercice 43
Faire une action de fusion de deux fich iers d’entiers. Le fich ier de sortie doit être trié.

Action Fusion ( E : f1 : fich ier d’entiers, E : f2 : fichier d’entiers, S : f3 : fichier d’entiers)

Var : f3 : fichier d’entiers
Début
OuvrirFichier (f1, lecture)
Si EtatFichier (f1)=succès alors
OuvrirFichier (f2, lecture)
Si EtatFichier (f2)=succès alors
OuvrirFichier (f3, écriture)
Si EtatFichier (f3)=succès alors
LireFich ier (f1, n1)
LireFich ier (f2, n2)
Tant que (EtatFich ier(f1) FdF ET EtatFichier(f2) FdF) faire
Si n 1<n 2 alors
EcrireFichier (f3, n1)
LireFich ier (f1, n1)
Sinon
EcrireFichier (f3, n2)
LireFich ier (f2, n2)
Si EtatFichier (f1) Fd F alors
Répéter
EcrireFichier (f3, n1)
LireFich ier(f1, n 1)
Jusqu'à EtatFichier(f1)=FdF
Si EtatFichier (f2) Fd F alors
Répéter
EcrireFichier (f3, n2)
LireFich ier (f2, n2)
Jusqu'à EtatFichier (f2) = FdF
FermerFichier (f3)
Sinon écrire (« Erreur en écriture sur le fichier destination »)
FermerFichier (f2)
Sinon écrire (« Erreur de lecture sur le fich ier f2 »)
FermerFichier (f1)
Sinon écrire (« Erreur en lecture sur le fich ier f1 »)
Fin

Exercice 44
Soit le type suivant :
Type : Tetd = entité ( No m : chaîne
Nu méro : étudiant
Notes : tableau [5] d’entiers
Moyenne : entier)

29
On suppose que la fonction de saisie
Fonction SaisieEtd () : Tetd
Permettant de saisir un tableau de Tetd existe. On pourra donc s’en servir

Ecrire une fonction qui permet de saisir un groupe d’étudiant dans un fichier.
Ecrire une fonction qui permet de calculer la moyenne générale d’un groupe d’étudiant.

Action SaisieGroupe (E : nb : entier, S : Fic : fichier de Tetd)

Var : etd : Tetd i : entier
Début
OuvrirFichier (fic, écriture)
Si EtatFichier (fic)=succès alors
Pour i de 1 à nb faire
EtdSaisieEtd( )
EcrireFichier (fic, etd)
FermerFichier (fic)
Sinon écrire (« Erreur »)
Fin

Fonction Moyenne (fic : fichier de Tetd ) : réel

Var : So m : réel
Début
Som0
nb 0
OuvrirFichier (fic, lecture)
Si EtatFichier (fic)=succès alors
LireFich ier (fic, etd)
Tant que EtatFichier (fic) FdF) faire
nbnb+1
SomSo m + [Link]
LireFich ier(fic, etd)
Retourner (So m/nb)
FermerFichier (fic)
Sinon écrire (« Erreur »)
Fin

30