Algorithmique & Programmation (Résumé)

Pascal

I- Les structures de données

Déclaration des constantes

En Algorithmique :
Tableau de Déclaration des Objets
Objets Type/Nature Rôle
Général Nom Constante = valeur de la constante Rôle
Annee Constante = 2018
G Constante = 9.81
Exemples Ville Constante = "Chebba"
Existe Constante = Vrai
Lettre Constante = "B"

En Pascal :
• Syntaxe : CONST <nom_constante> = <valeur_constante> ;
• Exemples : CONST annee = 2018 ;
g = 9.81 ;
ville = ‘Chebba’ ;
existe = True ;
lettre = ‘B’ ;

Déclaration des variables

En Algorithmique :
T.D.O
Objets Type/Nature Rôle
Général Nom Type de la variable Rôle
Code Octet
Heure Entier
Nb Entier Long
Exemples Moy Réel
Phrase Chaîne de caractères
Let Caractère
Test Booléen

En Pascal :
• Syntaxe : VAR <nom_variable> : type_variable ;
• Exemples : VAR Code : Byte ;
Heure : Integer ;
Nb : LongInt ;
Moy : Real ;
Phrase : String ;
Let : Char ;
Test : Boolean ;

Algorithmique & Programmation Pascal Page 1/12

 Déclaration d’un tableau à une dimension
Première formulation
EN ALGORITHMIQUE EN PASCAL

T.D.O. VAR
Objet Type/Nature Rôle Ident_tableau : ARRAY [Binf..Bsup] OF
Ident_tableau Tableau de taille et de Type_éléments ;
type_éléments
MOY Tableau de 30 Réels Exemple :
VAR Moy : array [1..30] of real ;

Deuxième formulation
EN ALGORITHMIQUE EN PASCAL

Tableau de déclarations des nouveaux types TYPE

Type Nom_type = ARRAY [Binf..Bsup] OF
Nom_type = tableau de taille et de type_éléments Type_éléments ;
Tab = tableau de 100 chaînes de caractères VAR
Ident_tableau : Nom_type ;
T.D.O.
Exemple :
Objet Type/Nature Rôle
Type Tab = Array [1..100] of string ;
Ident_tableau Nom_type
Var T : Tab ;
T Tab

Algorithmique & Programmation Pascal Page 2/12

 II- Les structures simples

L’opération d’affectation
Analyse / Algorithme Pascal
Variable Valeur Variable := Valeur ;

Exemples :

Analyse Pascal Commentaire Résultat

et Algorithme
A 5 A := 5 ; La variable A reçoit la valeur 5 A=5
B A+3 B := A + 3 ; B reçoit la valeur de l’expression A+3 B=8
A A +1 A := A +1 ; A reçoit sa valeur actuelle incrémentée de 1 A=6
C long("lycée")/2 C := length(‘lycée’)/2 ; C reçoit la valeur de l’expression arithmétique … C = 2.5
D 4<6 D := 4 < 6 ; D reçoit la valeur de l’expression logique … D = Vrai

L’opération d’entrée (lecture, saisie)

Analyse Algorithme Pascal
Variable = Donnée Lire (variable) ReadLn (variable) ;
Var1, Var2, Var3 = Données Lire (var1, var2, var3) Readln (var1, var2, var3) ;
Variable = Donnée ("Message") Ecrire ("Message"), Lire (variable) Write ('Message') ; Readln (variable) ;

L’opération de sortie (écriture, affichage)

Analyse / Algorithme Pascal
Ecrire ("Message", Nom_objet, Expression) Write ('Message', Nom_objet, Expression)

Exemples :
Analyse / Algorithme Pascal Résultat sur l'écran
A 10 A:=10 ;
Ecrire (A) Write (A) ; 10Bonjour
Ecrire ("Bonjour") Writeln ('Bonjour') ;
Ecrire (2 * 8 DIV 3) Writeln (2 * 8 DIV 3) ; 5
Ecrire (5 > 6) Write (5 > 6) ; False
Ecrire (3, "*", A, " = ", 3*A) Writeln (3, '*', A, ' = ', 3*a) ; 3*10 = 30

Algorithmique & Programmation Pascal Page 3/12

 III- Les structures de contrôles conditionnelles

La structure de contrôle conditionnelle simple

En Algorithmique En Pascal

Si condition(s) IF condition(s)
Alors Action 1 THEN Begin
Sinon Action 2 Action 1 ;
Fin Si End
ELSE Begin
Action 2 ;
End ;

N.B. : Si traitement2 est vide, on parle de structure conditionnelle simple réduite qui a la
syntaxe suivante :
En Algorithmique En Pascal

Si condition(s) IF condition(s)
Alors Action THEN Begin
Fin Si Action ;
End ;

La structure de contrôle conditionnelle imbriquée

En Algorithmique En Pascal

Si condition1 Alors Action1 IF condition1 THEN Begin

Sinon Si condition2 Alors Action2 Action 1;
Sinon Si condition3 Alors Action3 End
Sinon Si ………………………… ELSE IF condition2 THEN Begin
Sinon Si condition n-1 Action 2;
Alors Action n-1 End
Sinon Action n ELSE IF …………………………
Fin Si ELSE IF condition n-1 THEN Begin
Action n-1;
End
ELSE Begin
Action n;
End ;

III.2) La structure de contrôle conditionnelle à choix multiples

En Algorithmique En Pascal

Cas ou Donnée Vaut CASE Donnée OF

valeur1 : Action 1 valeur1 : Action 1 ;
valeur2 : Action 2 valeur2 : Action 2 ;
valeur5, valeur8 : Action 3 valeur 5, valeur 8 : Action 3 ;
valeur10..valeur30:Action4 valeur 10..valeur 30 : Action 4 ;
... ...
valeur n-1 : Action n-1 valeur n-1 : Action n-1 ;
A u t r e Action n Else Action n ;
Fin Cas END ;

Algorithmique & Programmation Pascal Page 4/12

 IV- Les structures de contrôles itératives
La structure de contrôle itérative complète : la boucle POUR
En Algorithmique En Pascal

POUR Vc de Vi à Vf FAIRE FOR Vc:=Vi TO/DOWNTO Vf DO

Action Begin
Fin Pour Action ;
End ;
{TO lorsque Vi ≤ Vf}
{DOWNTO lorsque Vi ≥ Vf}

La structure de contrôle itérative à condition d’arrêt

[Link] boucle REPETER :

En Algorithmique En Pascal

REPETER REPEAT
Action Action ;
JUSQU'A condition(s) UNTIL condition(s) ;
{jusqu’à condition soit vraie}

[Link] boucle TANT QUE :

En Algorithmique En Pascal

TANT QUE condition(s) FAIRE WHILE condition(s) DO

Action Begin
Fin Tant que Action ;
{Tant que condition est vraie End ;
répéter le traitement}

Algorithmique & Programmation Pascal Page 5/12

V- Les sous programmes
Les procédures
• Une procédure est un sous-programme qui permet la résolution d’un sous-problème précis et
qui peut transmettre zéro, un ou plusieurs résultats au programme appelant.

• L’entête de la définition :
- En algorithmique :
0) DEF PROC Nom_procédure (pf1 :type1 ; Var pf2 :type2 ; … ; pfn :typen)

- En Pascal :
PROCEDURE Nom_procédure (pf1 :type1 ; Var pf2 :type2 ; … ; pfn :typen) ;

• L’appel :
- En analyse
Nom_objet = PROC Nom_procédure (pe1 , pe2 , … , pen )

- En algorithmique :
PROC Nom_procédure (pe1 , pe2 , … , pen )

- En Pascal :
Nom_procédure (pe1 , pe2 , … , pen ) ;

Les fonctions
• Une fonction est un sous-programme qui permet la résolution d’un sous-problème précis et doit
retourner (renvoyer) un seul résultat de type simple (entier, caractère, réel, booléen, chaîne,
énuméré) au programme appelant. Il s’agit d’un cas particulier des procédures.

• L’entête de la définition :
- En algorithmique :
0) DEF FN Nom_fonction (pf1 :type1 ; pf2 :type2 ; … ; pfn :typen) : Type_résultat

- En Pascal :
Function Nom_fonction (pf1 :type1 ; pf2 :type2 ; … ; pfn :typen) : Type_résultat ;

• L’appel :
- En analyse et algorithmique :
• Nom_objet FN Nom_fonction (pe1 , pe2 , … , pen )
• Ecrire (FN Nom_fonction (pe1 , pe2 , … , pen ))
• Si FN Nom_fonction (pe1 , pe2 , … , pen ) Alors …

- En Pascal :
• Nom_objet := Nom_fonction (pe1 , pe2 , … , pen ) ;
• Writeln (Nom_fonction (pe1 , pe2 , … , pen )) ;
• If Nom_fonction (pe1 , pe2 , … , pen ) Then …

Algorithmique & Programmation Pascal Page 6/12

 SOUS PROGRAMMES USUELS
En Algorithme En Pascal
Saisir un entier N tel que 5 ≤ N ≤ 500
0) DEF PROC Saisie (VAR N : Entier) Procedure Saisie (Var n : integer) ;
1) Répéter Begin
Ecrire ("Donner un entier "), Lire(N) Repeat
Jusqu’à (5 ≤ N) ET (N ≤ 500) Write (‘Donner un entier ’);
2) Fin Saisie Readln (n);
Until (5 <= N) AND (N <= 500) ;
End ;

Saisir une chaîne de caractère en majuscule

0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire(CH) Begin
i 1 Repeat
Tant que (ch[i] dans ["A".."Z"]) et Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
(i ≤ long(ch)) Faire i i+1 i:=1;
Jusqu’à i > long(ch) While (ch[i] in ['A'..'Z']) and (i<=length(ch)) do
2) Fin Saisie i:=i+1;
Until i > length(ch);
End ;

Saisir une chaîne de caractères distincts

0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire (ch) verif : Boolean;
i 0 Begin
Répéter Repeat
i i+1 Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
verif pos (ch[i],ch) = i i := 0 ;
Jusqu’à (verif=faux) ou (i=long(ch)) Repeat
Jusqu’à verif i := i+1 ;
2) Fin Saisie Verif := pos(ch[i],ch) = i ;
Until (verif=false) or (i = length(ch)) ;
Until verif ;
End ;

Saisir une chaîne formée exactement des quatre lettres A, I, P et F

0) DEF PROC Saisie (VAR ch : Chaîne) Procedure saisie (Var ch:string);
1) Répéter Var valid : Boolean;
Ecrire ("Ch = "), Lire (ch) Begin
valid (pos(‘'I’',ch)≠0) et (pos(‘'F’',ch)≠0) et Repeat
(pos(‘'A’',ch)≠0) et (pos(‘'P’',ch)≠0) Write ('ch = ');
et (long(ch)=4) Readln (ch);
Jusqu’à valid valid := (pos('I',ch)<>0) and (pos('F',ch)<>0) and
2) Fin Saisie (pos('A',ch)<>0) and (pos('P',ch)<>0)
and (length(ch)=4) ;
Until valid ;
End;
Remplir un tableau T par N entiers impairs
0) DEF PROC Remplir (N : Entier ; VAR T : Tab) Procedure Remplir (N : integer ; Var T : Tab) ;
1) Pour i de 1 à n Faire Var i : integer;
Répéter Begin
Ecrire ("T[", i, "] = "), Lire (T[i]) For i:=1 To n Do
Jusqu’à (T[i] mod 2) ≠ 0 Repeat
Fin Pour Write (‘T[‘,i,’]= ’) ;
2) Fin Remplir Readln (T[i]) ;
Until (T[i] mod 2) <> 0 ;
End ;

Algorithmique & Programmation Pascal Page 7/12

 Remplir un tableau par des entiers au hasard entre [a,b]
0) DEF PROC Remplir (VAR T : Tab ; N : Entier) Procedure Remplir (Var T : Tab ; N : integer) ;
1) Lire(a, b) Var a, b, i : integer;
2) Pour i de 1 à n Faire Begin
T[i] a + Aléa (b-a+1) Readln (a,b);
Fin Pour Randomize ;
3) Fin Remplir For i:=1 To n Do
T[i] := a + Random (b-a+1);
End ;

• Un réel au hasard entre [a,b[ • Un réel au hasard entre [a,b[

T[i] a+ (b-a) * Aléa T[i] := a+ (b-a) * Random

• Une lettre majuscule au hazard • Une lettre majuscule au hazard

T[i] chr (65 + Aléa(26)) T[i] := chr (65 + Random(26))

Remplir un tableau T par N éléments en ordre croissant

0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : integer ; var t : tab) ;
1) Ecrire ("T[1] : "), Lire(T[1]) Var i : integer;
2) Pour i de 2 à n Faire Begin
Répéter Write ('T[1] : ') ; Readln (T[1]) ;
Ecrire ("T[", i, "] : "), Lire (T[i]) For i:=2 To n Do
Jusqu’à T[i] > T[i-1] Repeat
Fin Pour Write ('T[',i,'] : ') ;
3) Fin Saisie Readln (T[i]) ;
Until T[i] > T[i-1];
End ;

Remplir un tableau T par N éléments distincts

0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T: Tab);
1) Pour i de 1 à n Faire Var i, j : Integer;
Répéter Begin
Ecrire (''Saisir la case '', i), Lire (T[i]) For i:=1 To n Do
j 1 Repeat
Tant que T[i] ≠ T[j] Faire Writeln ('Saisir la case ', i); Readln (T[i]);
j j+1 j:=1;
Fin Tant que While T[i] <> T[j] Do j:=j+1 ;
Jusqu’à (j = i) Until (j = i) ;
Fin Pour End;
2) Fin Saisie
Remplir un tableau T par N entiers formés des chiffres non nuls
0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T : TAB) ;
1) Pour i de 1 à n Faire Var i : Integer ;
Répéter ch : String ;
Ecrire ("T[", i, "]= "), Lire (T[i]) Begin
Conch (T[i], ch) For i:=1 To n Do
Jusqu’à pos("0",ch)= 0 Repeat
Fin Pour Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;
2) Fin Saisie Str (T[i], ch);
Until pos('0',ch) = 0 ;
End;

Affichage d’un tableau T de N éléments

0) DEF PROC Affiche (N : Entier ; T : Tab) Procedure Affiche (n : Integer ; T : TAB) ;
1) Pour i de 1 à n Faire Var i : Integer ;
Ecrire (T[i], " ") Begin
Fin Pour FOR i :=1 TO n DO Write (T[i], ‘ ‘) ;
2) Fin Affiche End ;

Algorithmique & Programmation Pascal Page 8/12

 Affichage d’un tableau, 10 valeurs par ligne
0) DEF PROC Affiche (T:tab ; n:entier) Procedure Affiche (T:tab ; n:integer);
1) Pour i de 1 à n Faire Var i : integer;
Ecrire (T[i], " ") Begin
Si (i mod 10) = 0 For i:=1 To n Do
Alors Retour_à_la_ligne begin
Fin Si write(T[i], " ");
Fin Pour If (i mod 10) = 0 then writeln ;
2) Fin Affiche end;
End ;

Permutation de deux variables réelles

0) DEF PROC Permut (VAR x, y : Réel) Procedure Permut (VAR x, y : Real) ;
1) AUX Y Var aux : Real ;
2) Y X Begin
3) X AUX Aux := Y ;
4) Fin Permut Y := X ;
X := Aux ;
End ;

Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2
0) DEF PROC Transfert (T : tab ; n : entier ; var Procedure Transfert (T : tab ; n : integer ; var t1,t2 :
t1,t2 : tab ; var c1,c2 : entier) tab ; var c1,c2 : integer) ;
1) c1 0 ; c2 0 Var i :integer ;
Pour i de 1 à n Faire Begin
Si t[i] mod 2 = 0 c1 := 0 ;
Alors c1 c1 +1 c2 := 0 ;
T1[c1] T[i] For i :=1 To n Do
Sinon c2 c2 +1 If t[i] mod 2 = 0
T2[c2] T[i] Then begin
Fin Si c1 := c1 +1 ;
Fin Pour T1[c1] := T[i] ;
2) Fin Transfert end
Else begin
c2 := c2 +1 ;
T2[c2] := T[i] ;
end ;
End ;

Ranger les éléments négatifs d’un tableau T à gauche et les positifs à droite
0) DEF PROC Ranger (Var T : tab ; n : entier) Procedure Ranger (Var T : tab ; n : integer) ;
1) K 0 Var i, k, aux : integer ;
Pour i de 1 à n Faire Begin
Si t[i] < 0 k := 0 ;
Alors k k +1 For i :=1 To n Do
Aux t[i] If t[i] < 0
t[i] t[k] Then begin
t[k] aux k := k +1 ;
Aux := t[i] ;
Fin Si
Fin Pour t[i] := t[k] ;
2) Fin Transfert t[k] := aux ;
end ;
End ;

Insertion d’un élément X dans un tableau T à une position p

0) DEF PROC Insertion (Var T : tab ; n, x, p : Procedure Insertion ( Var T : tab ; n, x, p : integer) ;
entier) Var i :integer ;
1) Pour i de (n+1) à (p+1) Faire Begin
T[i] T[i-1] {décalage des éléments vers droite} For i := (n+1) DownTo (p+1) Do T[i] := T[i-1] ;
Fin Pour T[p] := X ;
2) T[p] X {insertion de X à la position p} End;
3) Fin Insertion

Algorithmique & Programmation Pascal Page 9/12

 La somme de n réels dans un tableau
0) DEF FN Somme (T : tab ; n : entier) : réel Function Somme (T : tab ; n : integer) : real ;
1) S 0 Var i : integer ;
Pour i de 1 à n Faire s : real;
S S + T[i] Begin
Fin Pour s:=0 ;
2) Somme S For i:=1 To n Do s:=s + T[i] ;
3) Fin Somme Somme := s ;
End ;

Factorielle de N ( n ! )
0) DEF FN Fact (n : entier) : entier long Function Fact (n : integer) : Longint ;
1) F 1 Var i : integer ;
2) Pour i de 2 à n Faire f : longint ;
F F*i Begin
Fin Pour f:=1 ;
3) Fact F For i:=2 To n Do f := f * i ;
4) Fin Fact Fact := f ;
End ;

n
Calcul de X (n ≥ 0)
0) DEF FN Puissance (x, n : entier) : entier Function Puissance (x, n : integer) : integer ;
1) p 1 Var i , p : integer ;
Pour i de 1 à n Faire Begin
p p*x p:=1 ;
Fin Pour For i:=1 To n Do p := p * x ;
2) puissance p puissance := p ;
3) Fin Puissance End ;
Vérifier si un nombre est premier
0) DEF FN Premier (n : entier) : booléen Function Premier (N:integer) : boolean ;
1) nbdiv 1 Var i ,nbdiv : integer;
2) Pour i de 1 à (n div 2) Faire Begin
Si (n mod i = 0) nbdiv:=1;
Alors nbdiv nbdiv+1 For i:=1 To (n div 2) Do
Fin Si If (n mod i = 0)
Fin Pour Then nbdiv := nbdiv + 1 ;
3) premier (nbdiv = 2) premier := nbdiv = 2 ;
4) Fin Premier End ;

PPCM (a,b)
0) DEF FN PPCM ( a, b : entier) : entier Function PPCM (a ,b :integer) : integer ;
1) i 1 Var i : integer;
2) Tant que ((a*i) mod b) ≠ 0 Faire Begin
i i+1 i := 1 ;
Fin Tant que While (a*i) mod b <> 0 Do i:=i+1 ;
3) ppcm a*i
4) Fin PPCM ppcm := a*i ;
End;
PGCD_Euclide (a,b)
0) DEF FN PGCD_Euclide ( a, b : entier) : entier Function PGCD_Euclide (a ,b :integer) : integer ;
1) Tant que b ≠ 0 Faire Var r : integer;
r a mod b Begin
a b While b<>0 Do
b r Begin
Fin Tant que r := a mod b;
2) Pgcd_euclide a a := b;
3) Fin PGCD_Euclide b := r;
End;
PGCD_Euclide := a;
End;

Algorithmique & Programmation Pascal Page 10/12

 La somme de chiffres d’un entier
0) DEF FN Som_chif (n : entier) : entier Function Som_Chif ( N : integer ) : integer ;
1) som 0 Var som, r : integer ;
2) Répéter Begin
R n mod 10 som:=0 ;
Som som + r Repeat
N n div 10 r := n mod 10 ;
Jusqu’à (n = 0) Som := som + r ;
3) som_chif som N := n div 10 ;
4) Fin Som_chif Until n=0 ;
Som_chif := som ;
End;

Vérifier si une chaîne est palindrome

0) DEF FN Palindrome (ch : chaîne) : Booléen Function palindrome (ch:string):boolean;
1) i 0 Var i:integer;
2) Répéter verif:boolean;
i i+1 Begin
verif ch[i] = ch[long(ch) – i + 1] i:=0;
Jusqu’à (verif=faux) ou (i = long(ch) div 2) repeat
3) palindrome verif i:=i+1;
4) Fin Palindrome verif := ch[i] = ch[length(ch)-i+1] ;
until (verif=false) or (i=length(ch) div 2) ;
Palindrome := verif;
End;

Recherche de la première valeur minimum dans un tableau de n réels

0) DEF FN Minimum (n : Entier ; T : Tab) : Réel Function Minimum (n : Integer ; T : Tab) : Real ;
1) min T[1] Var i : Integer ;
Pour i de 2 à n Faire Min : Real ;
Si (T[i] < min) Begin
Alors min T[i] Min := T[1] ;
Fin Si For i :=2 To n Do
Fin Pour If (T[i] < min) Then min := T[i] ;
2) Minimum min Minimum := min ;
3) Fin Minimum End ;

Recherche de la dernière position d’un élément X dans un tableau de n réels

0) DEF FN Recherche (X : réel ; n : Entier ; T : Function Recherche (X:Real ; N:Integer ; T:Tab) :
Tab) : Entier Integer ;
1) p 0 ; i n+1 Var i, p : Integer ;
Répéter Begin
i i-1 p := 0 ;
Si T[i]=X Alors p i Fin Si i := n+1;
Jusqu’à (p≠0) OU (i=1) Repeat
2) Recherche p i := i - 1;
3) Fin Recherche If T[i]=X Then p := i ;
Until (p<>0) OR (i=1) ;
Recherche := p ;
End ;

Fréquence d’un élément X dans un tableau de N entiers

0) DEF FN Frequence (x,n :entier ;T:Tab) : entier Function Frequence (x, n :integer ; T:Tab):integer;
1) f 0 Var i, f : Integer ;
2) Pour i de 1 à n Faire Begin
Si (T[i] = X) f := 0 ;
Alors f f+1 For i :=1 To n Do
Fin Si If (T[i] = X) Then f := f+1 ;
Fin Pour Frequence := f ;
3) frequence f End ;
4) Fin Frequence

Algorithmique & Programmation Pascal Page 11/12

 STRUCTURE GENERALE D’UN PROGRAMME TURBO PASCAL
PROGRAM Nom_programme ; {En-tête du programme}
Uses WinCrt, WinDos, … ; {Utilisation des unités / bibliothèques}
Const {Déclaration des constantes ; Exemples}
Annee = 2018 ; Pi = 3.14 ; Message = 'Bonjour' ;
…;
Type {Déclaration des types ; Exemples}
Tab = Array [1..100] of Real ;
Jours_semaine = (lun, mar, mer, jeu, ven, sam, dim) ;
Let_Majus = 'A'..'Z' ;
Nom = String [25] ; D
é
…;
c
Var {Déclaration des variables ; Exemples} l
X, Y, Z : Real ; I, J : Integer ; Let : Char ; Test : Boolean ; Ch : String ; a
Ville : Array [1..10] of String ; r
T1, T2 : Tab ; a
t
Jour : Jours_semaine ;
i
Couleurs : (Rouge, Vert, Bleu, Jaune) ; o
Mois : 1..12 ; n
…; s
{================= Définition des procédures ==========================}
g
Procedure Nom_procédure (pf1 : type1 ; VAR pf2 : type2 ; … ; VAR pfn : typen) ; l
{Déclarations locales : Const, Type, Var, Function, Procedure, ...} o
Begin b
Instructions de la procédure ; a
l
End ;
e
{================== Définition des fonctions ==========================} s
Function Nom_fonction (pf1 : type1 ; pf2 : type2 ; … ; pfn : typen) : Type_résultat ;
{Déclarations locales : Const, Type, Var, Function, Procedure, ...}
Begin
Instructions de la fonction ;
Nom_fonction := résultat ;
End ;
{========================= P. P. ==================================}
BEGIN {Début du programme principal}

{Bloc principal du programme avec appel des procédures et des fonctions}

Instructions ;
Nom_procédure (pe1, pe2, … pen) ;
……………..……… Nom_fonction (pe1, pe2, … pen) …………….……
Instructions ;

END. {Fin du programme}

Algorithmique & Programmation Pascal Page 12/12

 ANNEXE I

Nom Algorithmique Code en Pascal Type de x Type du résultat Rôle Exemples en Pascal
Abs (x) ABS (x) entier/réel type de x valeur absolue de x ABS (-4) = 4 ; ABS (-5.7) = 5.7
Carré (x) SQR (x) entier/réel type de x carré de x SQR (2) = 4 ; SQR (2.5) = 6.25
Racine Carré (x) SQRT (x) entier/réel réel racine carrée de x SQRT (25) = 5.00 ; SQRT (6.25) = 2.5
Cos (x) COS (x) entier/réel réel cosinus de x (x en radians) COS (PI/2) = 0.00
Sin (x) SIN (x) entier/réel réel sinus de x (x en radians) SIN (PI/2) = 1.00
Tang (x) TAN (x) entier/réel réel tangente de x (x en radians) TAN (PI) = 0.00
Ln (x) LN (x) entier/réel réel logarithme népérien de x LN (1) = 0.00
Exp (x) EXP (x) entier/réel réel exponentiel de x EXP (0) = 1.00
TRUNC (3.15) = 3
Tronc (x) TRUNC (x) réel entier partie entière de x
TRUNC (-3.15) = -3
Ent (x) INT (x) réel réel partie entière de x INT (3.15) = 3.00
ROUND (9.49) = 9
Arrondi (x) ROUND (x) réel entier entier le plus proche de x
ROUND (9.5) = 10
Frac (x) FRAC (x) réel réel partie décimale de x FRAC (2.45) = 0.45
Aléa RANDOM - réel renvoie un réel aléatoire dans [0, 1[ 0.36 ; 0.075 ; 0.98 ; 0.02 ; …
Aléa (x) RANDOM (x) entier (mot) entier (mot) renvoie un entier aléatoire dans [0, x-1] Random (7) renvoie un entier dans [0, 6]
VRAI si x est impair ODD (3) = True
Odd (x) ODD (x) entier long booléen
FAUX si x est pair ODD (8) = False
INC (x) ; l’équivalent de x x +1
Inc (x) INC (x) ; scalaire type de x Procédure, qui incrémente x
INC(x, n) ; l’équivalent de x x + n
DEC (x) ; l’équivalent de x x - 1
Dec (x) DEC (x) ; scalaire type de x Procédure, qui décrémente x
DEC(x, n) ; l’équivalent de x x - n
PRED (5) = 4 ; PRED (‘C’) = ‘B’
Pred (x) PRED (x) scalaire type de x prédécesseur de x, s’il existe
PRED (True) = False
SUCC (5) = 6 ; SUCC (‘C’) = ‘D’
Succ (x) SUCC (x) scalaire type de x successeur de x, s’il existe
SUCC (False) = True
Chr (x) CHR (x) octet caractère caractère dont le code ASCII est x CHR (65) = ‘A’ ; CHR (97) = ‘a’
Ord (x) ORD (x) scalaire entier long rang de la valeur x ORD(‘A’)=65 ; ORD(18)=18 ; ORD(true)=1
UPCASE (‘b’) = ‘B’ ; UPCASE (‘R’) = ‘R’
Majus (x) UPCASE (x) caractère caractère majuscule de x, s’il est possible
UPCASE (‘4’) = ‘4’ ; UPCASE (‘?’) = ‘?’
* Un type scalaire est un ensemble fini et ordonné de valeurs (Entier, Caractère, Booléen, Enuméré, intervalle).

LES STRUCTURES DE DONNEES

ANNEXE II
Les fonctions standard relatives aux chaînes de caractères
Syntaxe Type
Rôle Exemples en Pascal
En Algorithmique En Pascal Paramètres d’entrée Résultat
Retourne un entier représentant la Chaîne/Caractère Entier Lg := Length ('L''école'); lg = 7
Long (ch) Length (ch) longueur de ch. Lg := Length ('') ; lg = 0
Long (ch) = ord (ch[0]) Lg := Length (' ') ; lg = 1
Chaîne/Caractère Entier P := Pos ('T', 'ATTENTION') ; P=2
Retourne la première position de la
Pos (ch1, ch2) Pos (ch1, ch2) P := Pos ('gra', 'Program') ; P=4
chaîne ch1 dans la chaîne ch2.
P := Pos ('R', 'Professeur') ; P=0
Chaîne/Caractère, Chaîne CH 1:= Copy ('Langage', 4, 3) ;
Retourne une sous chaîne de n
Entier, Entier CH1 = 'gag'
Sous_Chaîne (ch, p, n) Copy (ch, p, n) caractères à partir de la position p de
CH 2:= Copy ('Bonjour', 4, 10) ;
la chaîne ch.
CH2 = 'jour'
Retourne la concaténation de plusieurs Chaîne/Caractère Chaîne CH2 := ' Janvier' ; CH1 :='14' ;
Concat (ch1, ch2, …) Concat (ch1, ch2, …) chaînes en une seule. C'est l'équivalent CH3 := Concat (ch1, ch2, '2011') ;
de ch1+ch2+… CH3 = '14 Janvier2011'

Les procédures standard relatives aux chaînes de caractères

Syntaxe Type
Rôle Exemples en Pascal
En Algorithmique En Pascal Paramètres d’entrée Résultat
Supprime N caractères de CH à partir Chaîne, Entier, Entier Chaîne CH := 'Merci' ;
Efface (ch, p, n) Delete (ch, p, n) ;
de la position P. Delete (CH, 4, 2) ; CH = 'Mer'
Chaîne/Caractère, Chaîne CH1 := 'DA' ;
Insère une chaîne CH1 dans une
Insère (ch1, ch2, p) Insert (ch1, ch2, p) ; Chaîne, Entier CH2 := 'DIC' ;
autre CH2 à la position P.
Insert (CH1, CH2, 3) ; CH2 = 'DIDAC'
Numérique, Chaîne Chaîne STR (2018, CH) ; CH = '2018'
Convertit une valeur numérique N en
ConvCh (n, ch) Str (n, ch) ; STR (14.52, CH) ; CH = '1.4520000000E+01'
une chaîne CH.
STR (14.[Link], CH) ; CH = 'ּּ14.520'
Chaîne/Caractère, Numérique, VAL ('2010', N, Err) ; N = 2010 et Err = 0
Convertit une chaîne de caractères
Numérique, Entier Entier VAL ('0045', N, Err) ; N = 45 et Err = 0
CH en une valeur numérique N. De
VAL ('5E+3', N, Err) ;
Valeur (ch, n, err) Val (ch, n, err) ; plus, elle fournit un code d'erreur
• Si N est de type entier : N = 0 et Err = 2
ERR qui indique si l'opération s'est
déroulée correctement. • Si N est de type réel : N = 5000 et Err = 0

LES STRUCTURES DE DONNEES