I- Les structures de données

I.1) 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 = 2015
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 = 2015 ;
g = 9.81 ;
ville = ‘Chebba’ ;
existe = True ;
lettre = ‘B’ ;

I.2) 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 Prof. SOUSSI Ezzeddine Page 1/11

I.3) 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 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 ;
VAR
T.D.O. Ident_tableau : Nom_type ;
Objet Type/Nature Rôle
Exemple :
Ident_tableau Nom_type
Type Tab = Array [1..100] of string ;
Var T : Tab ;

I.4) Le type Enuméré

En algorithmique :
Tableau de déclaration des nouveaux types
Type
Nom_du_type = (valeur1, valeur2, valeur3, …)

En pascal : TYPE Nom_du_type = (valeur1, valeur2, valeur3, …) ;

Exemples : TYPE JOURS = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ;
VOITURE = (renault, citroen, peugeot, ford, toyota) ;
VOYELLE = (A, E, I, O, U, Y) ;

N.B.
Une valeur énumérée ne peut pas être une valeur appartenant à un type prédéfini (entier, réel,
caractère, chaîne, booléen).

I.5) Le type Intervalle

En algorithmique :
Tableau de déclaration des nouveaux types
Type
Nom_du_type = borne inférieur . . borne supérieur

En pascal : TYPE Nom_du_type = borne inférieur . . borne supérieur ;

Exemples : TYPE JOURS = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ;
JOUR_TRAVAIL = lundi . . vendredi ;
MOIS = 1 . . 12 ;
ALPHA = ‘a’ . . ‘z’ ;

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 2/11

 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 (Word) entier (Word) 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 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 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  Prof : SOUSSI Ezzeddine
 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 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înes 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, Entier, Entier Chaîne CH 1:= Copy ('Langage', 4, 3) ;
Retourne une sous chaîne de n
 CH1 = 'gag'
Sous_Chaîne (ch, p, n) Copy (ch, p, n) caractères à partir de la position p
CH 2:= Copy ('Bonjour', 4, 10) ;
de la chaîne ch.
 CH2 = 'jour'
Retourne la concaténation de Chaînes Chaîne CH1 := 'Janvier' ;
Concat (ch1, ch2, …) Concat (ch1, ch2, …) plusieurs chaînes en une seule. C'est CH2 := Concat ('14', ch1, '2011') ;
l'équivalent de ch1+ch2+…  CH2 = '14Janvier2011'

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 à Chaîne, Entier, Entier Chaîne CH := 'Esclave' ;
Efface (ch, p, n) Delete (ch, p, n) ;
partir de la position P. Delete (CH, 1, 3) ;  CH = 'lave'
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 (2015, CH) ; CH = '2015'
Convertit une valeur numérique N
ConvCh (n, ch) Str (n, ch) ; STR (14.52, CH) ; CH = '1.4520000000E+01'
en une chaîne CH.
STR (14.52:8:3, CH) ; CH = '14.520'
Convertit une chaîne de Chaîne/Caractère, Numérique, VAL ('1967', n, err) ; n = 1967 et err = 0
caractères CH en une valeur Numérique, Entier Entier VAL ('5E+3', n, err) ;
numérique N. De plus, elle fournit  Si n est de type entier : n = 0 et err = 2
Valeur (ch, n, err) Val (ch, n, err) ;
un code d'erreur ERR qui indique
si l'opération s'est déroulée  Si n est de type réel : n = 5000 et err = 0
correctement.

LES STRUCTURES DE DONNEES  Prof : SOUSSI Ezzeddine

 II- Les structures simples

II.1) 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) ;

II.2) 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") Write ('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

II.3) 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 … C = 2.5
D4<6 D := 4 < 6 ; D reçoit la valeur de l’expression … D = Vrai

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 3/11

 III- Les structures de contrôles conditionnelles

III.1) La structure de contrôle conditionnelle simple

En Analyse En Algorithmique En Pascal

Nom_objet = [initialisation(s)] initialisation(s) ................. ; {initialisation(s)}
Si condition(s) Si condition(s) IF condition(s)
Alors Traitement 1 Alors Traitement 1 THEN Begin
Sinon Traitement 2 Sinon Traitement 2 Traitement 1 ;
Fin Si Fin Si End
ELSE Begin
Traitement 2 ;
End ;

N.B. : Si traitement2 est vide, on parle de structure conditionnelle simple réduite qui a la
syntaxe suivante :
En Analyse En Algorithmique En Pascal
Nom_objet = [initialisation(s)] initialisation(s) ................. ; {initialisation(s)}
Si condition(s) Si condition(s) IF condition(s)
Alors Traitement Alors Traitement THEN Begin
Fin Si Fin Si Traitement ;
End ;

III.2) La structure de contrôle conditionnelle généralisée

En Analyse En Algorithmique En Pascal

Nom_objet = [initialisation(s)] initialisation(s) ............ ; {initialisation(s)}
Si condition1 Alors Trait1 Si condition1 Alors Trait1 IF condition1 THEN Begin
Sinon Si condition2 Alors Trait2 Sinon Si condition2 Alors Trait2 Trait1;
Sinon Si condition3 Alors Trait3 Sinon Si condition3 Alors Trait3 End
Sinon Si ………………………… Sinon Si ………………………… ELSE IF condition2 THEN Begin
Sinon Si condition n-1 Sinon Si condition n-1 Trait2;
Alors Trait n-1 Alors Trait n-1 End
Sinon Trait n Sinon Trait n ELSE IF …………………………
Fin Si Fin Si ELSE IF condition n-1 THEN Begin
Trait n-1;
End
ELSE Begin
Trait n;
End ;

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

En Analyse En Algorithmique En Pascal

Nom_objet = [initialisation(s)]
Selon sélecteur Faire
valeur1 : trait1
valeur2 : trait2
valeur5, valeur8 : trait3
valeur10..valeur30 : trait4
...
valeur n-1 : trait n-1
Sinon trait n
Fin Selon
initialisation(s)
Selon sélecteur Faire
valeur1 : trait1
valeur2 : trait2
valeur5, valeur8 : trait3
valeur10..valeur30 : trait4
...
valeur n-1 : trait n-1
Sinon trait n
Fin Selon
....................; {initialisation(s)}
CASE sélecteur OF
valeur1 : trait1 ;
valeur2 : trait2 ;
valeur 5, valeur 8 : trait3 ;
valeur 10..valeur 30 : trait4 ;
...
valeur n-1 : trait n-1 ;
Else trait n ;
END ;

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 4/11

 IV- Les structures de contrôles itératives
IV.1) La structure de contrôle itérative complète
En Analyse En Algorithmique En Pascal
Nom_objet = [initialisation(s)] initialisation(s) ............ ; { initialisation(s) }
POUR Cp de Vi à Vf FAIRE POUR Cp de Vi à Vf FAIRE FOR Cp:=Vi TO/DOWNTO Vf DO
Traitement Traitement Begin
Fin Pour Fin Pour Traitement ;
End ;
{TO lorsque Vi  Vf}
{DOWNTO lorsque Vi ≥ Vf}

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

a.Première formulation :
En Analyse En Algorithmique En Pascal
Nom_objet = [initialisation(s)] initialisation(s) ............; {initialisation(s)}
REPETER REPETER REPEAT
Traitement Traitement Traitement ;
JUSQU'A condition(s) JUSQU'A condition(s) UNTIL condition(s) ;
{jusqu’à condition soit vraie}

b.Deuxième formulation :
En Analyse En Algorithmique En Pascal
Nom_objet = [initialisation(s)] initialisation(s) ............; {initialisation(s)}
TANT QUE condition(s) FAIRE TANT QUE condition(s) FAIRE WHILE condition(s) DO
Traitement Traitement Begin
Fin Tant que Fin Tant que Traitement ;
{Tant que condition est vraie End ;
répéter le traitement}

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 5/11

V- Les sous programmes
V.1) 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 analyse et algorithmique :
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 ) ;

V.2) 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 ou chaîne)
au programme appelant. Il s’agit d’un cas particulier des procédures.

 L’entête de la définition :
- En analyse et algorithmique :
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 Prof: SOUSSI Ezzeddine Page 6/11

 Sous Programmes Usuels
En Analyse En Pascal
Saisir un entier avec un contrôle de saisie
DEF PROC Saisie (VAR N : Entier) Procedure Saisie (var n : integer) ;
Résultat = N Begin
N=[ ] Repeat
Répéter Write (‘Donner un entier ’);
N = Donnée ("Donner un entier ") Readln (n);
Jusqu’à (5 ≤ N) ET (N ≤ 500) Until (5 <= N) AND (N <= 500) ;
Fin Saisie End ;

Saisir une chaîne de caractère en majuscule

DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
Résultat = ch Var i : integer;
ch = [ ] verif : Boolean;
Répéter Begin
ch= Donnée ("Saisir une chaîne ") Repeat
i0 Writeln (‘Saisir une chaîne ’) ;
Répéter Readln (ch) ;
ii+1 i := 0 ;
verif  ch[i] dans ["A".."Z"] Repeat
Jusqu’à (non verif) ou (i=long(ch)) i := i+1 ;
Jusqu’à verif Verif := ch[i] in [‘A’..’Z’] ;
Fin Saisie Until (not verif) or (i = length(ch)) ;
Until verif ;
End ;

Saisir une chaîne de caractères distincts

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

Remplir un tableau avec un contrôle de saisie (entiers impairs)

DEF PROC Remplir (N : Entier ; VAR T : Tab) Procedure Remplir (N : integer ; Var T : Tab) ;
Résultat = T Var i : integer;
T=[ ] Begin
Pour i de 1 à n Faire For i:=1 To n Do
Répéter Repeat
T[i] = Donnée ("T[", i, "]= ") Write (‘T[‘,i,’]= ’) ;
Jusqu’à (T[i] mod 2) ≠ 0 Readln (T[i]) ;
Fin Pour Until (T[i] mod 2) <> 0 ;
Fin Remplir End ;

Remplir un tableau par des entiers au hasard entre [a,b]

DEF PROC Remplir (VAR T : Tab ; N : Entier) Procedure Remplir (Var T : Tab ; N : integer) ;
Résultat = T Var a, b, i : integer;
T = [ a,b = données ] Begin
Pour i de 1 à n Faire Readln (a,b);
T[i] a + Aléa (b-a+1) Randomize ;
Fin Pour For i:=1 To n Do
Fin Remplir T[i] := a + Random (b-a+1);
End ;

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 7/11

  Un réel au hasard entre [a,b[
T[i] a+ (b-a) * Aléa
 Une lettre majuscule au hazard
T[i] chr (65 + Aléa(26))

Remplir un tableau par des éléments en ordre croissant

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

Remplir un tableau par des éléments distincts

DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T: Tab);
Résultat = T Var i, j : Integer;
T = [ T[1] = donnée (''Saisir la case 1'') ] Begin
Pour i de 2 à n Faire Writeln ('Saisir la case 1'); Readln (T[1]);
Répéter For i:=2 To n Do
T[i] = Donnée (''Saisir la case '', i) Repeat
j 0 Writeln ('Saisir la case ', i); Readln (T[i]);
Répéter j:=0;
j j+1 Repeat
Jusqu’à (T[i] = T[j]) ou (j = i-1) j:=j+1;
Jusqu’à T[i] ≠ T[j] Until (T[i] = T[j]) or (j = i-1);
Fin Pour Until T[i] <> T[j] ;
Fin Saisie End;

Remplir un tableau par n chaînes de caractères de 8 chiffres

DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : Integer ; Var T : TAB) ;
Résultat = T Var i ,err : Integer ;
T=[ ] x : Longint ;
Pour i de 1 à n Faire Begin
Répéter For i:=1 To n Do
T[i] = Donnée ("T[", i, "]= ") Repeat
Valeur (T[i], x, err) Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;
Jusqu’à (Err = 0) ET (long(T[i]) = 8) Val (T[i],x,err);
Fin Pour Until (Err = 0) and (length(T[i]) = 8) ;
Fin Saisie End;

Affichage d’un tableau de n éléments

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

Affichage d’un tableau, 10 valeurs par ligne

DEF PROC Affiche (T:tab ; n:entier) Procedure Affiche (T:tab ; n:integer);
Résultat = Affichage_T Var i:integer;
Affichage_T = [ ] Begin
Pour i de 1 à n Faire For i:=1 To n Do
Ecrire (T[i], " ") begin
Si (i mod 10) = 0 write(T[i], " ");
Alors Retour_à_la_ligne If (i mod 10) = 0 then writeln ;
Fin Si end;
Fin Pour End ;
Fin Affiche

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 8/11

 Permutation de deux variables réelles
DEF PROC Permut (VAR x, y : Réel) Procedure Permut (VAR x, y : Real) ;
Résultat = (x, y) Var aux : Real ;
X AUX Begin
AUX  Y Aux := Y ;
YX Y := X ;
Fin Permut X := Aux ;
End ;
Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2
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) ;
Résultat = (t1,t2,c1,c2) Var i :integer ;
(t1,t2,c1,c2) = [ c1 0 ; c2  0 ] Begin
Pour i de 1 à n Faire c1 := 0 ;
Si t[i] mod 2 = 0 c2 := 0 ;
Alors c1 c1 +1 For i :=1 To n Do
T1[c1] T[i] If t[i] mod 2 = 0
Sinon c2 c2 +1 Then begin
T2[c2] T[i] c1 := c1 +1 ;
Fin Si T1[c1] := T[i] ;
Fin Pour end
Fin Transfert Else begin
c2 := c2 +1 ;
T2[c2] := T[i] ;
end ;
End ;
Insertion d’un élément X dans un tableau T à une position p
DEF PROC Insertion (Var T : tab ; n,x,p : entier) Procedure Insertion ( Var T : tab ; n,x,p : integer) ;
Résultat = T Var i :integer ;
T=[ ] Begin
Pour i de n+1 à p+1 Faire For i :=n+1 DownTo p+1 Do
T[i]  T[i-1] {décalage des éléments vers droite} T[i] := T[i-1];
Fin Pour T[p] := X ;
T[p]  X {insertion de X à la position p} End;
Fin Insertion

La somme de n réels dans un tableau

DEF FN Somme (T : tab ; n : entier) : réel Function Somme (T : tab ; n : integer) : real ;
Résultat = Somme Var i : integer ;
Somme  S s : real;
S = [ S 0 ] Begin
Pour i de 1 à n Faire s:=0 ;
S S + T[i] For i:=1 To n Do s:=s + T[i] ;
Fin Pour Somme := s ;
Fin Somme End ;

Factorielle de N (n !)
DEF FN Fact (n : entier) : entier long Function Fact (n : integer) : Longint ;
Résultat = Fact Var i : integer ;
Fact  F f : longint ;
F = [ F 1 ] Begin
Pour i de 2 à n Faire f:=1 ;
FF*i For i:=2 To n Do f := f * i ;
Fin Pour Fact := f ;
Fin Fact End ;

Calcul de Xn (n ≥ 0)
DEF FN Puissance (x, n : entier) : entier Function Puissance (x, n : integer) : integer ;
Résultat = puissance Var i , p : integer ;
puissance  p Begin
p = [ p 1 ] p:=1 ;
Pour i de 1 à n Faire For i:=1 To n Do p := p * x ;
pp*x puissance := p ;
Fin Pour End ;
Fin Puissance

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 9/11

 Vérifier si un nombre est premier
DEF FN Premier (n : entier) : booléen Function Premier (N:integer) : boolean ;
Résultat = premier Var i ,nbdiv : integer;
premier  nbdiv = 2 Begin
nbdiv = [ nbdiv 1 ] nbdiv:=1;
Pour i de 1 à (n div 2) Faire For i:=1 To (n div 2) Do
Si (n mod i = 0) If (n mod i = 0)
Alors nbdiv  nbdiv+1 Then nbdiv := nbdiv + 1 ;
Fin Si premier := nbdiv = 2 ;
Fin Pour End ;
Fin Premier

La somme de chiffres d’un entier

DEF FN Som_chif (n : entier) : entier Function Som_Chif ( N : integer ) : integer ;
Résultat = som_chif  som Var som, r : integer ;
som = [ som 0 ] Begin
Répéter som:=0 ;
R n mod 10 repeat
Som  som + r r := n mod 10 ;
N  n div 10 Som := som + r ;
Jusqu’à n = 0 N := n div 10 ;
Fin Som_chif until n=0 ;
Som_chif := som ;
End;

Vérifier si une chaîne est palindrome

DEF FN Palindrome (ch : chaîne) : Booléen Function palindrome(ch:string):boolean;
Résultat = palindrome  verif Var i:integer;
verif = [ i 0 ] verif:boolean;
Répéter Begin
i  i+1 i:=0;
verif  (ch[i] = ch[long(ch)-i+1]) repeat
Jusqu’à (verif=faux) ou (i = long(ch) div 2) i:=i+1;
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

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

Fréquence d’un élément X dans un tableau

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

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 10/11

PROGRAM Nom_programme ; {En-tête du programme}*
Uses ... ; {Utilisation des unités / bibliothèques}*
Const ... ; {Déclaration des constantes}*
Type ... ; {Déclaration des types}*
Var ... ; {Déclaration des variables}*
{============= Définition des procédures ==================}*
Procedure Nom_procédure (pf1 :type1 ; Var pf2 :type2 ; … ; pfn :typen) ;
{Déclarations locales : Const, Type, Var, Function, Procedure, ...}*
Begin
Instructions de la procédure ;
End ;
{============= Définition des fonctions ===================}*
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}
Instructions ;
………………………………… ;
………………………………… ;
………………………………… ;
{Bloc principal du programme avec appel des procédures et des fonctions}
END. {Fin du programme}

* : facultatif

Algorithmique & Programmation Prof: SOUSSI Ezzeddine Page 11/11