LES ELEMENTS GENERALE D’UN PROGRAMME

III. Partie Traitement

Elle commence par le mot réservé « BEGIN » et se termine par « END. ».

Elles délimitent un bloc appelé Programme principale qui regroupe toute les instructions qui
suivent un ordre séquentiel et logique et sont terminées par « ; »
Une instruction peut être :
1- instruction simple : l'instruction vide, affectation, branchement, appel de sous
programm.
2- Instruction structurée : structure alternative, répétitive.
3- Instruction composée (bloc) : c’est une séquence d’inst simple, structurées ou
d’autres inst composées délimité par les bornes « BEGIN » et « END ; »

BEGIN
Instruction simple 1 ;
Instruction simple 2 ;
Inst composée 1 Instruction structurée1 ;
Instruction composée2 ; BEGIN
Inst structurée2 ;
Inst simple3 ;
End ;
END ;

Les opérations élémentaires du pascal

1. Instruction Simple:
Le formalisme pascal est basé sur certaines opérations élémentaires :
1.1. Instruction vide: En Pascal, il est possible d'utiliser des instructions vides pour
diverses raisons, par exemple pour créer des structures de contrôle conditionnelles ou de
boucles qui ne nécessitent pas d'action spécifique à exécuter (qui ne fait rien). Voici quelques
exemples d'instructions vides en Pascal :

 L'instruction point-virgule : L'instruction point-virgule (;) en Pascal peut être utilisée pour
créer une instruction vide dans une structure de contrôle conditionnelle ou de boucle.

 Le mot-clé "begin end" : Les instructions vides aussi sont représentées par le mot-clé
"begin end". Elles ne font rien lorsqu'elles sont exécutées, mais peuvent être utilisées comme
espace réservé pour une instruction qui sera ajoutée plus tard.

1
 LES ELEMENTS GENERALE D’UN PROGRAMME

Voici quelques exemples d'utilisation d'instructions vides en Pascal :

1. Boucle vide :
var i: integer;
begin
for i := 1 to 10 do
; // Boucle vide
end.

Cette boucle ne contient aucune instruction à l'intérieur, ce qui signifie qu'elle ne fait rien.
2. Condition vide:
var x: integer;
begin
if x > 10
then ; // Condition vide
end.

Dans cet exemple, la condition "if" est suivie d'une instruction vide.

3. Fonction vide:
function maFonction(x: integer): integer;
begin // Fonction vide
end;
begin
end.

Dans cet exemple, la fonction "maFonction" ne contient aucune instruction à l'intérieur.

4. Procédure vide:
procedure maProcedure;
begin // Procédure vide
end;
begin
maProcedure; // Appelle la procédure maProcedure
end.

Dans cet exemple, la procédure "maProcedure" ne contient aucune instruction à l'intérieur.

Elle ne fait donc rien lorsqu'elle est appelée.

En résumé, les instructions vides en Pascal sont des instructions qui ne font rien lorsqu'elles
sont exécutées. Elles peuvent être utilisées comme espace réservé pour une instruction qui
sera ajoutée plus tard.

2
 LES ELEMENTS GENERALE D’UN PROGRAMME

1.2. L’affectation : En Pascal, l'affectation est une instruction qui permet de stocker une
valeur dans une variable. Elle utilise le symbole ":=" pour assigner une valeur à une variable.

La syntaxe générale de l'affectation est la suivante

Idf_variable := expression;

 Idf_variable est le nom de la variable à laquelle la valeur sera assignée

 l'expression est la valeur qui sera stockée dans la variable.

Voici quelques exemples d'utilisation de l'affectation en Pascal :

1. Affectation d'un entier à une variable :
var x: integer;
begin x := 5; // Assigner la valeur 5 à la variable x
end.
2. Affectation d'un réel à une variable :
var y: real;
begin y := 3.14; // Assigner la valeur 3.14 à la variable y
end.
3. Affectation d'un caractère à une variable :
var c: char;
begin
c := 'B'; // Assigner le caractère 'B' à la variable c
end.
4. Affectation d'une expression à une variable :
var a, b, c: integer;
begin
a := 5; b := 3;
c := a + b; // Assigner la valeur de l'expression a + b à la variable c
end.
5. Affectation de la valeur d'une variable à une autre variable :
var x, y: integer;
begin x := 5; y := x; // Assigner la valeur de la variable x à la variable y
end.
 Il est important de noter que la variable à gauche de l'opérateur ":=" doit être une
variable modifiable, c'est-à-dire une variable qui a été déclarée avec le mot-clé "var" et
qui n'est pas constante ou une expression.
 L'expression à droite de l'opérateur ":=" doit être compatible avec le type de la
variable à gauche. Si l'expression n'est pas compatible avec le type de la variable, une
erreur de compilation sera générée.
 Les opérations j:=j+1 et j:=j-1 sont respectivement désignés par incrémentation et
décrémentation

3
LES ELEMENTS GENERALE D’UN PROGRAMME

Exercice de l'événement :
1. Quelles sont les valeurs successives prises par les variables X et Y suite aux
instructions suivantes : X := 6;
Y := (−4);
X := (−X + 3);
X := (Y − 5);
Y:= (X + Y).
2. Soit les déclarations suivantes
Const Pi=3.14;
Maxi=1000;
Var X,Y: Real;
A,B,I: Integer;
Ens supposant que A=3,B=4,Y=-10 indiquer parmi les expressions ci-dessous, les
expressions invalides et les valeurs des expressions valides
I:= A mod B;
Y:=A MOD (A/B);
I:=B DIV 0;
I:=A MOD Y;
X:=A DIV B;
X:=(A+B)/(Y+0.3);
I:=A/B;
X:=A/B;
I:=(990-MAXI) DIV A;
I:=A MOD (990-MAXI);
I:=A MOD 0;
I:= Pi*Y;
X:=A/B*A;
Solution:
X 6 6 -3 -9 -9
1.
Y -4 -4 -4 -13
2.
I:= A mod B; // Expression valide : I prend la valeur 3
Y:= A MOD (A/B); // Expression invalide : division sur un nombre réel
I:= B DIV 0; // Expression invalide : division par zéro
I:= A MOD Y; // Expression invalide : erreur de syntaxe, Y c'est réel
X:= A DIV B; // Expression valide : X prend la valeur 0
X:= (A+B)/(Y+0.3); // Expression valide : X prend la valeur -2.8
I:= A/B; // Expression invalide : erreur de syntaxe, I c'est un entier
X:= A/B; // Expression valide : X prend la valeur 0.75
I:= (990-MAXI) DIV A; // Expression valide : I prend la valeur -3
I:= A MOD (990-MAXI); // Expression valide : I prend la valeur 13
I:= A MOD 0; // Expression invalide : division par zéro
I:= Pi*Y; // Expression valide : I prend la valeur -31.4
X:= A/B*A; // Expression valide : X prend la valeur 2.25

4
LES ELEMENTS GENERALE D’UN PROGRAMME

1.3. L’écriture: write()

Elle permet d’afficher la valeur d’un élément sur un périphérique de sortie (écran). Un
élément peut être
Un nombre,
Une variable numérique,
Un résultat d’une opération entre plusieurs variables,
Une chaîne de caractères quelconque (qui peut contenir des lettres accentuées et des espaces) :
dans ce dernier cas, il est nécessaire de mettre la chaîne de caractères entre deux apostrophes.

Syntaxe:
Write (éléments);
Exemple1 :
1. Afficher un Nombre
write(5);
2. Afficher la valeur d'une variable
var A,B,C:integer;
begin
A:=5;
B:=2;
C:=A+B;
write(A,B,C);
end.
3. Afficher un résultat d'une opération entre plusieurs variables
var A,B:integer;
begin
A:=5;
B:=2
write(A+B);
end;
4. Afficher une chaine de caractère (message)
write('c''est la dernière instruction dans mon programme Exo2');
// Afficher le message entre côtes.

Writeln (liste d’éléments) ; écrit le résultat et revient à la ligne.

Exemple3:
Soit A une variable dont la valeur est 1000, donnez le résultat de chaque instruction :
Writeln (A) ; 1000
Writeln (‘A’) ; A
Writeln (A,’A’) ; 1000A
Writeln (A, ‘ A‘) ; 1000 A
Writeln (‘le module Pascal’) ; le module Pascal

5
LES ELEMENTS GENERALE D’UN PROGRAMME

1.4. La lecture: Read()

 Attribution d’une valeur à une variable d’entrée selon le choix de l’utilisateur à partir
d'un périphérique d'entrée (clavier), la valeur attribuée doit être de même type que la
variable.
 cette écriture est l'équivalente à idf_variable:= Valeur lue à partir de clavier
 l'instruction read permet d'initialiser une ou plusieurs variable à la fois.
Read (liste des variables) ;
 liste des variables: Idf_variable1, Idf_variable2,.., Idf_variablen
Exp :
Read(a) ; Read (b) Ou bien read(a,b);

Readln (liste de variables) ; lit la liste des variables et revient à la ligne

 lorsqu'un programme rencontre l'instruction read et readln il s'arrêt de s'exécuter

jusqu'à ce qu'on termine l'initialisation de toutes les valeurs à partir de clavier;
Exp:
Ecrire le programme à l'aide de la procédure read et readln et voire la différance entre les deux
var a,b:integer;
begin
readln(a);
readln(b);
writeln;
writeln(a);
writeln(b);
end.

6
LES ELEMENTS GENERALE D’UN PROGRAMME

Exercice de l'événement :

Écrivez un programme qui demande à l'utilisateur d'entrer deux nombres entiers, puis calcule
et affiche la somme, la différence, le produit et le quotient des deux nombres.

Solution:
program Calculatrice;
var
nombre1, nombre2, somme, difference, produit: integer;
quotient: real;

begin
// Demande à l'utilisateur d'entrer deux nombres entiers
write('Entrez le premier nombre entier : ');
readln(nombre1);
write('Entrez le deuxième nombre entier : ');
readln(nombre2);

// Calcule la somme, la différence, le produit et le quotient des deux nombres

somme := nombre1 + nombre2;
difference := nombre1 - nombre2;
produit := nombre1 * nombre2;
quotient := nombre1 / nombre2;

// Affiche les résultats

writeln('La somme de ', nombre1, ' et ', nombre2, ' est : ', somme);
writeln('La différence entre ', nombre1, ' et ', nombre2, ' est : ', difference);
writeln('Le produit de ', nombre1, ' et ', nombre2, ' est : ', produit);
writeln('Le quotient de ', nombre1, ' et ', nombre2, ' est : ', quotient:0:2);
end.

7
LES ELEMENTS GENERALE D’UN PROGRAMME

1.5. l'instruction saut Goto :

Le branchement est utilisé la séquence courante et brancher à une autre séquence du même
programme.
Il est nécessaire parfois d’effectuer un saut afin de se brancher à une instruction donnée du
programme.
Cette instruction doit être précédé par une étiquette suivi par « : »
Les étiquettes du programme sont déclaré par le mot réservé LABEL suivi de la liste des
identificateurs d’étiquettes séparé par des virgules « , » et se terminent par « ; »
Syntaxe:
LABEL eidf-etiq1, eidf-etiq2, eidf-etiq3,……… ;

Remq :
L’étiquette est une valeur alphanumérique

L’instruction de branchement à une étiquette se fait par :

Goto idf-etiq ;

Exp :
Program test ;
Label 10,15,fin ;
Var x,y,z :integer;
Begin
Read (x,y) ; x :=x*2 ;
Goto 10;
x :=x-1 ;
10: y :=y-2 ;
Goto 15;
y :=y*4 ;
15: x :=x*3 ;
Goto fin ;
Fin : x :=x*6 ; z :=x+y ;
End.

Remq :
L’instruction goto ne peut se faire vers une partie interne dune instruction structurée
(alternative ou répététive)

8
LES ELEMENTS GENERALE D’UN PROGRAMME

Exercice de l'événement :
Fait le déroulement du programme d l'exemple pour x=2 et Y= 5
Solution:
Pour x=2 et y=5, le déroulement du programme sera le suivant :

1. Les variables x et y sont initialisées à 2 et 5, respectivement.

2. La valeur de x est multipliée par 2, ce qui donne x=4.
3. L'instruction "goto" envoie l'exécution à l'étiquette "10".
4. La valeur de x est décrémentée de 1, ce qui donne x=3.
5. L'étiquette "10" est atteinte et la valeur de y est décrémentée de 2, ce qui donne y=3.
6. L'instruction "goto" envoie l'exécution à l'étiquette "15".
7. La valeur de y est multipliée par 4, ce qui donne y=12.
8. L'étiquette "15" est atteinte et la valeur de x est multipliée par 3, ce qui donne x=9.
9. L'instruction "goto" envoie l'exécution à l'étiquette "fin".
10. L'étiquette "fin" est atteinte et la valeur de x est multipliée par 6 (x=54) et ajoutée à la
valeur de y (y=12), ce qui donne z=66.
11. Le programme se termine.

Ainsi, pour x=2 et y=5, la valeur de z est égale à 66 après l'exécution du programme.

9
LES ELEMENTS GENERALE D’UN PROGRAMME

2. Les instructions conditionnelle

2.1.L’instruction alternative simple (If . . . Then . . . )
Ce type d’instruction présente une seule possibilité; elle ne s’exécute que dans le cas
où la condition est vérifiée. Le cas contraire entraîne une sortie immédiate de
l’instruction en ignorant le reste des actions qui viennent.

Syntaxe:
If <Cond> THEN < bloc d’instructions > ;

Où Cond est une expression booléenne.

Fonctionnement:
1- Évaluer la condition Cond.
2- Si Cond est True, le bloc d’instructions sera exécuté.
3- Si Cond est False, le bloc d’instructions ne sera pas exécuté.
Organigramme:
True
Cond Bloc d'instruction

False

Exemple:

If (y<0)
THEN write(' y est négatif ');

2.2.L’instruction Multiples IF…THEN…ELSE:

Cette instruction offre un choix entre deux possibilités, selon le résultat du test de la
condi- tion.

Syntaxe :

Nous avons vu dans la partie algorithmique qu’une instruction conditionnelle

standard, et composé des mots clés suivants :
SI <Conditions> ALORS <Traitement1> SINON <Traitement2> FSI ;
En Turbo PASCAL on obtient la traduction suivante :
IF <Conditions> THEN <Traitement1> ELSE <Traitement2 > ;

Une Instruction conditionnelle est programmée sous la forme d'une seule instruction.

10
LES ELEMENTS GENERALE D’UN PROGRAMME

Fonctionnement:
1- Évaluer la condition Cond.
2- Si Cond est True, le bloc d’instructions1 sera exécuté.
3- Si Cond est False, le bloc d’instructions2 sera pas exécuté.

Organigramme:
False True
Cond Bloc d'instruction1

Bloc d'instruction2

Exemple1 :

IF N1 > N2
THEN writeln (‘le premier nombre est le plus grand’)
ELSE writeln (‘le second nombre est le plus grand’) ;

Dans ce premier exemple, chacune des 2 parties du choix se limite à une seule instruction
pascal, il est possible d’en placer plusieurs à condition de les regrouper en ce l’on nomme un
‘bloc’.

Un bloc est le regroupement d’une série d’instructions délimitée par les mots clés
BEGIN et END
Ces deux mots du langage PASCAL n’étant pas des instructions, ou déclarations, mais des
délimiteurs de blocs, ils ne nécessitent pas de ponctuation spécifique.

Exemple2 :
IF N1 > N2
THEN
begin
Min : =n1;
writeln (‘le premier nombre est le plus grand’)
end
ELSE
begin
Min := n2 ;
writeln (‘le second nombre est le plus grand’) ;
end ;
writeln (min) ;

Traitement1 ou traitement2 peut être composé d’instructions simple ou structures

(alternative ou répétitives).

11
LES ELEMENTS GENERALE D’UN PROGRAMME

2.3. L’instruction alternative imbriquée Le traitement de certains problèmes qui

présentent plusieurs possibilités (choix multiples) implique l’ouverture de plusieurs voies,
correspondant à des tests imbriqués les uns dans les autres.

Syntaxe:
If < Cond 1 > Then < instructions 1 >
Else If < Cond 2 > Then < instructions 2 >
Else If < Cond 3 > Then< instructions 3 >
Else < instructions 4
Fonctionnement:
1- Evaluer la condition Cond1
2- Si Cond 1 est True, le bloc d’instructions 1 sera exécuté.
3- Si Cond 1 est False, on évalue Cond 2.
4- Si Cond 2 est True, le bloc d’instructions 2 sera exécuté.
5- Si Cond 2 est false on évalue Cond 3.
6- Si Cond 3 est True, le bloc d’instructions 3 sera exécuté.
7- Si Cond 3 est False, le bloc d’instructions 4 sera exécuté.

Exemple :

IF N1 > N2
THEN writeln (‘le premier nombre est le plus grand’)
ELSE IF N1 < N2
THEN writeln (‘le second nombre est le plus grand’)
ELSE writeln (‘les deux nombres sont égaux’);

ou encore à l’aide des blocs

IF N1 > N2
THEN begin
writeln (‘le premier nombre est le plus grand’);
end
ELSE begin
IF N1 < N2
THEN begin
writeln (‘le second nombre est le plus grand’);
end
ELSE begin
writeln (‘les deux nombres sont égaux’);
end;
end;

Remarques
 Un point virgule (séparateur) n’est pas obligatoire devant un END
 Si une action (traitement) comprend plus d’une instruction alors cette action sera
obligatoirement traduite à l’intérieur d’un bloc (délimité par BEGIN et END).

12
LES ELEMENTS GENERALE D’UN PROGRAMME

2.4. LES CONDITIONS MULTIPLES, COMPOSEES, COMPLEXES

Les conditions multiples, composées, ou complexes respectent les règles logiques de

priorités (algèbre de BOOLE) soit : d’abord le NOT (non) puis le AND (et) et enfin OR(ou)
et XOR.
Toutefois c’est le développeur de l’application, lors de la conception qui va définir les
parenthèses correctes, en fonction du problème à résoudre.

Règle de syntaxe :
Lors de la programmation d'une condition composée, chaque condition simple composant la
condition composée doit être mise entre parenthèses ceci indépendamment du parenthésage
logique défini lors de la conception.

Exemple 1 :
Si A = B ou A = 2
alors écrire (A)
sinon écrire (B)
FSi ;

En Pascal:

If (A = B) or (A = 2)
then writeln (A)
else writeln(B);

Exemple 2 :
Si N1 > N2 et (N1 ≠ 0 ou N2 ≠ 0)
alors écrire (N1) ;
N1  N2 + 2
sinon écrire (N2) ;
N2 N1 + 3
FSi ;

En Pascal:

If (N1 > N2) and ((N1 <> 0) or (N2 <> 0))

then begin
writeln (N1);
N1 := N2 + 2;
end
else begin
writeln (N2);
N2 := N1 + 3;
end;

13
LES ELEMENTS GENERALE D’UN PROGRAMME

Cas particulier :

Essayons de traduire la formulation algorithmique suivante.

Si A = 1
alors Si B > 1
alors A  4
Finsi
sinon A  5
FSi ;

Cette instruction PASCAL est correcte d’un point de vue syntaxe

Mais elle correspond en fait à l’algorithme suivant; ce qui est faux !
Si A = 1
alors Si B > 1
alors A  4
sinon A  5
Fsi ;
FSi ;
Réécrivons la formulation algorithmique :
Si A = 1
alors Si B > 1
alors A  4
sinon Vide
Fsi ;
sinon A  5
FSi ;

La traduction PASCAL devient :

If A = 1
Then If B > 1
Then A := 4
Else
Else A := 5 ;
Ou If A = 1
Then begin If B > 1
Then A := 4;end
Else A := 5 ;

 Cette traduction correspond effectivement à l’algorithme de base.

14
LES ELEMENTS GENERALE D’UN PROGRAMME

2.5. L’INSTRUCTION CASE :

L’instruction case permet de faire un choix parmi plusieurs possibilités suivant la valeur d’une
expression de choix appelé sélecteur, cette expression doit être de type Scalaire(entier,
char,booleen).

Syntaxe :
ou encore
CASE <Sélecteur> OF
V1 : begin A1 end;
V2 : begin A2 end;
:
Vn-1 : begin An-1 end;
ELSE begin An end;
END; (* fin CASE *)

Exemple 1 :
Algorithme
CAS OPER de (OPER est de type caractère (type scalaire PASCAL))
‘+’ :RESUL  NOMBR1 + NOMBR2
‘-’ :RESUL  NOMBR1 - NOMBR2
‘*’ :RESUL  NOMBR1 * NOMBR2
‘/’ :RESUL  NOMBR1 / NOMBR2
fin
Programmation PASCAL de cette conditionnelle
CASE OPER OF
‘+’ : RESUL := NOMBR1 + NOMBR2 ;
‘-’ : RESUL := NOMBR1 - NOMBR2 ;
‘*’ : RESUL := NOMBR1 * NOMBR2 ;
‘/’ : RESUL := NOMBR1 / NOMBR2 ;
END;

Exemple 2 :
Algorithme
CAS NUM de ( NUM est de type entier (type scalaire PASCAL))
1 faire RESUL NOMBR1 + NUM
écrire (RESUL)
2 à 5 faire RESUL NOMBR1 - NUM
écrire (RESUL)
6,8 faire RESUL NOMBR1 * NUM
écrire (RESUL)
7,9 faire RESUL NOMBR1 / NUM
écrire (RESUL)
sinon RESUL 0
écrire (‘Erreur de valeur ‘, NUM)
fin ;

15
LES ELEMENTS GENERALE D’UN PROGRAMME

Programmation PASCAL de cette conditionnelle

CASE NUM OF
1 : begin
RESUL := NOMBR1 + NUM ;
writeln(RESUL:8:3) ;
end ;
2..5 : begin
RESUL := NOMBR1 - NUM ;
writeln(RESUL:8:3) ;
end ;
6,8 : begin
RESUL := NOMBR1 * NUM ;
writeln(RESUL:8:3) ;
end ;
7,9 : begin
RESUL := NOMBR1 / NUM ;
writeln(RESUL:8:3) ;
end ;
ELSE begin (* facultatif dans la partie ELSE d’un CASE*)
RESUL := 0 ;
writeln(‘Erreur de valeur ‘, NUM);
end; (* facultatif dans la partie ELSE d’un CASE *)
END;
Remarques

 Le fin de cas se traduit obligatoirement par un END ;

 Si une action (traitement) comprend plus d’une instruction alors cette action sera
obligatoirement traduite à l’intérieur d’un bloc (délimité par BEGIN et END).
 Dans le cas de la traduction de la partie sinon (ELSE) la délimitation d’un bloc n’est
pas obligatoire, on a en effet une délimitation physique claire ELSE <Action> END;
(*fin CASE*)
 Si un cas couvre une série consécutive de valeurs de V1 à Vp ; on traduira par V1 ..
Vp.
 Si un cas couvre une série de valeurs Vp , Vr , Vz ; on traduira par Vp , Vr , Vz.
 on peut avoir une mixité des deux précédentes remarques.
exemple : de ‘a’ à ‘z’ , de ‘A’ à ‘Z’ se traduira par ‘a’ .. ‘z’ , ‘A’ .. ‘Z’

16
LES ELEMENTS GENERALE D’UN PROGRAMME

3. Les instructions répétitives:

Le langage de programmation Pascal offre plusieurs types de boucles pour répéter des
instructions plusieurs fois. Les boucles permettent d'économiser du temps et de l'espace en
évitant de répéter les mêmes instructions à plusieurs reprises.

Il y a principalement trois types de boucles en Pascal : la boucle "while", la boucle "repeat

until" et la boucle "for".

Cas où le nombre de répétitions est inconnu:

3.1."while":
La boucle "while" permet de répéter un bloc d'instructions tant qu'une condition est vraie.

La syntaxe de cette boucle est la suivante :

while condition do Instructions

Ex:

While I < 10 do
I := I + 2;

Si le traitement de l’itération WHILE comporte plus d’une instruction il faut traduire ce

traitement à l’intérieur d’un bloc BEGIN END

Par exemple, si nous voulons répéter un bloc d'instructions tant que le nombre est inférieur à
10, nous pouvons utiliser la boucle "while" comme suit :

Ex:
var nombre : integer;
begin
nombre := 0;
while nombre < 10 do
begin
writeln('Nombre : ', nombre);
nombre := nombre + 1;
end;
end.
Dans cet exemple, le programme répète l'affichage du nombre tant que le nombre est inférieur
à 10.

17
LES ELEMENTS GENERALE D’UN PROGRAMME

3.2.Boucle "repeat until" :

La boucle "repeat until" permet de répéter un bloc d'instructions jusqu'à ce qu'une condition
soit vraie.

La syntaxe de cette boucle est la suivante :

repeat
// Instructions à répéter
until condition;

Par exemple, si nous voulons répéter un bloc d'instructions jusqu'à ce que le nombre soit
supérieur à 10, nous pouvons utiliser la boucle "repeat until" comme suit :

Exemple:
var nombre : integer;
begin
nombre := 0;
repeat
writeln('Nombre : ', nombre);
nombre := nombre + 1;
until nombre > 10; end.

Dans cet exemple, le programme répète l'affichage du nombre jusqu'à ce que le nombre soit
supérieur à 10.

Exemple 2:

1+1/2+1/3+1/4+…………………….+1/n >A
On recherche le nombre n pour le quelle la somme soit supérieure à une valeur donnée A.
Program serie ;
Var a,s :real ;
I: integer;
Begin
Writeln (‘donnez la valeur à dépasser : ‘);
readln(a);
S :=0,i :=1
Repeat
S:=s+1/I;
I:=i+1;
until s>a ;
Writeln (‘pour dépasser ‘a, ‘il faut : ‘ ,i-1 , ‘terme’);
end.

2. La différence entre la boucle Tant que et Répéter :

– Les instructions de la boucle Répéter sont exécutées au moins une fois, car

18
LES ELEMENTS GENERALE D’UN PROGRAMME

l’évaluation de la condition vient après le passage dans la boucle. Cependant, les

instructions de la boucle Tant que peuvent ne jamais être exécutées si la condition
n’est pas vérifiée, lors de la première évaluation.
– La boucle Répéter s’exécute jusqu’à ce que la condition soit vérifiée. Donc la
condition permet la sortie de la boucle Répéter. La boucle Tant que s’exécute tant que
la condition est vérifiée. Donc la condition permet le passage dans la boucle Tant que.
– Une séquence d’instructions nécessite une délimitation par Debut . . . Fin
dans le cas d’une boucle Tant que; ce qui n’est pas le cas de la boucle répéter.

19
LES ELEMENTS GENERALE D’UN PROGRAMME

Cas où le nombre de répétitions est connu:

3.3.Boucle "for":
La boucle "for" permet de répéter un bloc d'instructions un nombre spécifié de fois.

La syntaxe de cette boucle est la suivante :

For variable := début to fin do
begin
// Instructions à répéter
end;

Par exemple, si nous voulons répéter un bloc d'instructions 10 fois, nous pouvons utiliser la
boucle "for" comme suit :

var i : integer;
begin
for i := 1 to 10 do
writeln('Nombre : ', i);
end.
Dans cet exemple, le programme répète l'affichage du nombre de 1 à 10.

Si le traitement de l’itération bornée comporte plus d’une instruction il faut traduire ce

traitement à l’intérieur d’un bloc BEGIN END

Exemple:
For i := 1 to 10 do
begin {début du bloc des instructions de l’itération}
gotoxy(1,i);
write(i);
end; {fin du bloc des instructions de l’itération}

 si la borne de départ est supérieure à la borne d’arrivée

For <Indice d’itération>:=<Borne de départ>DOWNTO<Borne d’arrivée> DO

< Instructions à répéter> ;

Exemple :
For i := ‘Z’ downto ‘A’ do
writeln(i);
ou
For i := ‘Z’ downto ‘A’ do
begin {début du bloc des instructions de l’itération}
gotoxy(1,i);
write(i);
end; {fin du bloc des instructions de l’itération}

20
 LES ELEMENTS GENERALE D’UN PROGRAMME

Si une itération bornée possède un pas différent de 1.

on la traduira par une itération TANT QUE ou REPETER

Exemple de tp
Program modif;
Var I : integer ;
begin
For i := 1 to 5 do
Begin
writeln(compteur = ‘,i);
i:=i+1;
end;
writeln (compteur en fin de boucle : ‘, I );
end ;

3.4. La boucle imbriquée

Les instructions d’une boucle peuvent être des instructions itératives. Dans ce cas, on
aboutit à des boucles imbriquées.

For i:=1 to 4 do
For j:=1 to i do
write (’S’)
write (’M 2013 ')

Résultat final: pour i=4, le résultat est SSSSSSSSSSM 2013.

Exemple 1 : Afficher une table de multiplication de 1 à 10.

Exemple 2 : Afficher une pyramide de nombres de 1 à 5.

Exemple 3 : Calculer la somme des carrés des nombres de 1 à 5.

Remarque : Comment choisir le type de boucle à utiliser ?

– Si on peut déterminer le nombre d’itérations avant l’exécution de la boucle, il est plus
judicieux d’utiliser la boucle Pour.
– S’il n’est pas possible de connaître le nombre d’itérations avant l’exécution de la boucle, on
fera appel à l’une des boucles Tant Que ou Répéter.
– Pour le choix entre Tant Que et Répéter : Si on doit tester la condition de contrôle avant de
commencer les instructions de la boucle, on utilisera Tant Que.
– La valeur de la condition de contrôle dépend d’une première exécution des instructions.

21