I- Les structures de données

(1)

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

Exemples

Annee G Ville Existe Lettre

Constante = 2015 Constante = 9.81 Constante = "Chebba"

Constante = Vrai 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

Exemples

Code Heure Nb Moy Phrase Let Test

Octet Entier Entier Long Réel

Chaîne de caractères Caractère

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

(2)

I.3) Déclaration d’un tableau à une dimension

Première formulation EN ALGORITHMIQUE

T.D.O.

Objet Type/Nature Rôle

Ident_tableau Tableau de taille et de type_éléments MOY Tableau de 30 Réels

EN PASCAL

VAR

Ident_tableau : ARRAY [Binf..Bsup] OF

Type_éléments ; VAR Moy : array [1..30] of real ;

Deuxième formulation EN ALGORITHMIQUE

Tableau de déclarations des nouveaux types Type

Nom_type = tableau de taille et de type_éléments T.D.O.

Objet Type/Nature Rôle Ident_tableau Nom_type

EN PASCAL

TYPE

Nom_type = ARRAY [Binf..Bsup] OF

Type_éléments ; VAR

Ident_tableau : Nom_type ; Exemple :

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

(3)

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

Tronc (x) TRUNC (x) réel entier partie entière de x TRUNC (3.15) = 3 TRUNC (-3.15) = -3

Ent (x) INT (x) réel réel partie entière de x INT (3.15) = 3.00

Arrondi (x) ROUND (x) réel entier entier le plus proche de x ROUND (9.49) = 9 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]

Odd (x) ODD (x) entier booléen VRAI si x est impair FAUX si x est pair

ODD (3) = True ODD (8) = False

Inc (x) INC (x) ; scalaire type de x

Procédure, qui incrémente x

INC (x) ; l’équivalent de x  x +1 INC(x, n) ; l’équivalent de x  x + n Dec (x) DEC (x) ; scalaire type de x

Procédure, qui décrémente x

DEC (x) ; l’équivalent de x  x - 1

DEC(x, n) ; l’équivalent de x  x - n Pred (x) PRED (x) scalaire type de x prédécesseur de x, s’il existe PRED (5) = 4 ; PRED (‘C’) = ‘B’

PRED (True) = False

Succ (x) SUCC (x) scalaire type de x successeur de x, s’il existe SUCC (5) = 6 ; SUCC (‘C’) = ‘D’

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 Majus (x) UPCASE (x) caractère caractère majuscule de x, s’il est possible UPCASE (‘b’) = ‘B’ ; UPCASE (‘R’) = ‘R’

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

(4)

ANNEXE II

Les fonctions standard relatives aux chaînes de caractères

Syntaxe

Rôle Type

Exemples en Pascal

En Algorithmique En Pascal Paramètres d’entrée Résultat

Long (ch) Length (ch)

Retourne un entier représentant la longueur de ch.

Long (ch) = ord (ch[0])

Chaîne Entier Lg := Length ('L''école');  lg = 7 Lg := Length ('') ;  lg = 0 Lg := Length (' ') ;  lg = 1 Pos (ch1, ch2) Pos (ch1, ch2) Retourne la première position de la

chaîne ch1 dans la chaîne ch2.

Chaînes Entier P := Pos ('T', 'ATTENTION') ;  P = 2 P := Pos ('gra', 'Program') ;  P = 4 P := Pos ('R', 'Professeur') ;  P = 0 Sous_Chaîne (ch, p, n) Copy (ch, p, n)

Retourne une sous chaîne de n caractères à partir de la position p de la chaîne ch.

Chaîne, Entier, Entier Chaîne CH 1:= Copy ('Langage', 4, 3) ;  CH1 = 'gag' CH 2:= Copy ('Bonjour', 4, 10) ;  CH2 = 'jour' Concat (ch1, ch2, …) Concat (ch1, ch2, …)

Retourne la concaténation de plusieurs chaînes en une seule. C'est l'équivalent de ch1+ch2+…

Chaînes Chaîne CH1 := 'Janvier' ;

CH2 := Concat ('14', ch1, '2011') ;

 CH2 = '14Janvier2011'

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

Syntaxe

Rôle Type

Exemples en Pascal

En Algorithmique En Pascal Paramètres d’entrée Résultat

Efface (ch, p, n) Delete (ch, p, n) ; Supprime N caractères de CH à partir de la position P.

Chaîne, Entier, Entier Chaîne CH := 'Esclave' ;

Delete (CH, 1, 3) ;  CH = 'lave' Insère (ch1, ch2, p) Insert (ch1, ch2, p) ; Insère une chaîne CH1 dans une

autre CH2 à la position P.

Chaîne/Caractère, Chaîne, Entier

Chaîne CH1 := 'DA' ; CH2 := 'DIC' ;

Insert (CH1, CH2, 3) ;  CH2 = 'DIDAC' ConvCh (n, ch) Str (n, ch) ; Convertit une valeur numérique N

en une chaîne CH.

Numérique, Chaîne Chaîne STR (2015, CH) ; CH = '2015'

STR (14.52, CH) ; CH = '1.4520000000E+01' STR (14.52:8:3, CH) ; CH = '14.520'

Valeur (ch, n, err) Val (ch, n, err) ;

Convertit une chaîne de caractères CH en une valeur numérique N. De plus, elle fournit un code d'erreur ERR qui indique si l'opération s'est déroulée correctement.

Chaîne/Caractère, Numérique, Entier

Numérique, Entier

VAL ('1967', n, err) ; n = 1967 et err = 0 VAL ('5E+3', n, err) ;



Si n est de type entier : n = 0 et err = 2



Si n est de type réel : n = 5000 et err = 0

LES STRUCTURES DE DONNEES  Prof : SOUSSI Ezzeddine

(5)

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

Ecrire (A)

Ecrire ("Bonjour")

A:=10 ; Write (A) ;

Write ('Bonjour') ; 10Bonjour Ecrire (2 * 8 DIV 3)

Ecrire (5 > 6)

Writeln (2 * 8 DIV 3) ; Write (5 > 6) ;

5 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 et Algorithme

Pascal Commentaire Résultat

A  5 B  A + 3 A  A +1

C  long("lycée")/2 D  4 < 6

A := 5 ; B := A + 3 ; A := A +1 ;

C := length(‘lycée’)/2 ; D := 4 < 6 ;

La variable A reçoit la valeur 5 B reçoit la valeur de l’expression A+3 A reçoit sa valeur actuelle incrémentée de 1 C reçoit la valeur de l’expression …

D reçoit la valeur de l’expression …

A = 5 B = 8 A = 6 C = 2.5 D = Vrai

(6)

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)]

Si condition(s) Alors Traitement 1 Sinon Traitement 2 Fin Si

initialisation(s) Si condition(s) Alors Traitement 1 Sinon Traitement 2 Fin Si

... ; {initialisation(s)}

IF condition(s) THEN Begin

Traitement 1 ; 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 :

Si condition(s) Alors Traitement Fin Si

initialisation(s) Si condition(s) Alors Traitement Fin Si

IF condition(s) THEN Begin

Traitement ; End ;

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

Si condition1 Alors Trait1 Sinon Si condition2 Alors Trait2 Sinon Si condition3 Alors Trait3 Sinon Si ………

Sinon Si condition n-1 Alors Trait n-1

Sinon Trait n Fin Si

initialisation(s)

Si condition1 Alors Trait1 Sinon Si condition2 Alors Trait2 Sinon Si condition3 Alors Trait3 Sinon Si ………

Sinon Si condition n-1 Alors Trait n-1

Sinon Trait n Fin Si

IF condition1 THEN Begin Trait1;

End

ELSE IF condition2 THEN Begin Trait2;

End ELSE IF ………

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

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 ;

(7)

IV- Les structures de contrôles itératives

IV.1) La structure de contrôle itérative complète

POUR Cp de Vi à Vf FAIRE Traitement

Fin Pour

initialisation(s)

POUR Cp de Vi à Vf FAIRE Traitement

Fin Pour

... ; { initialisation(s) }

FOR Cp:=Vi TO/DOWNTO Vf DO Begin

{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 :

REPETER Traitement

JUSQU'A condition(s)

initialisation(s) REPETER Traitement

JUSQU'A condition(s) {jusqu’à condition soit vraie}

REPEAT

Traitement ; UNTIL condition(s) ;

b.Deuxième formulation :

TANT QUE condition(s) FAIRE Traitement

Fin Tant que

initialisation(s)

TANT QUE condition(s) FAIRE Traitement

Fin Tant que

{Tant que condition est vraie répéter le traitement}

WHILE condition(s) DO Begin

(8)

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 :

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 :

 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 …

(9)

Sous Programmes Usuels

En Analyse En Pascal

Saisir un entier avec un contrôle de saisie DEF PROC Saisie (VAR N : Entier)

Résultat = N N = [ ] Répéter

N = Donnée ("Donner un entier ") Jusqu’à (5 ≤ N) ET (N ≤ 500) Fin Saisie

Procedure Saisie (var n : integer) ; Begin

Repeat

Write (‘Donner un entier ’);

Readln (n);

Until (5 <= N) AND (N <= 500) ; End ;

Saisir une chaîne de caractère en majuscule DEF PROC Saisie (VAR ch : Chaîne)

Résultat = ch ch = [ ] Répéter

ch= Donnée ("Saisir une chaîne ") i0

Répéter ii+1

verif  ch[i] dans ["A".."Z"]

Jusqu’à (non verif) ou (i=long(ch)) Jusqu’à verif

Fin Saisie

Procedure Saisie (Var ch : String) ; Var i : integer;

verif : Boolean;

Begin Repeat

Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;

i := 0 ; Repeat i := i+1 ;

Verif := ch[i] in [‘A’..’Z’] ;

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)

Résultat = ch ch = [ ] Répéter

ch= Donnée ("Saisir une chaîne ") i0

Répéter ii+1

verif  pos (ch[i],ch) = i

Jusqu’à (verif=faux) ou (i=long(ch)) Jusqu’à verif

Fin Saisie

Procedure Saisie (Var ch : String) ; Var i : integer;

verif : Boolean;

Begin Repeat

Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;

i := 0 ; Repeat i := i+1 ;

Verif := pos(ch[i],ch) = i ;

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)

Résultat = T T = [ ]

Pour i de 1 à n Faire Répéter

T[i] = Donnée ("T[", i, "]= ") Jusqu’à (T[i] mod 2) ≠ 0 Fin Pour

Fin Remplir

Procedure Remplir (N : integer ; Var T : Tab) ; Var i : integer;

Begin

For i:=1 To n Do Repeat

Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;

Until (T[i] mod 2) <> 0 ; End ;

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

DEF PROC Remplir (VAR T : Tab ; N : Entier) Résultat = T

T = [ a,b = données ]

Pour i de 1 à n Faire T[i] a + Aléa (b-a+1) Fin Pour

Fin Remplir

Procedure Remplir (Var T : Tab ; N : integer) ; Var a, b, i : integer;

Begin

Readln (a,b);

Randomize ;

For i:=1 To n Do

T[i] := a + Random (b-a+1);

End ;

(10)

 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)

Résultat = T

T = [ T[1] = donnée ("T[1] : ") ] Pour i de 2 à n Faire Répéter

T[i] = Donnée ("T[", i, "] : ") Jusqu’à T[i] > T[i-1]

Fin Pour Fin Saisie

Procedure Saisie (n : integer ; var t : tab) ; Var i : integer;

Begin

Write ('T[1] : ') ; Readln (T[1]) ; For i:=2 To n Do

Repeat

Write ('T[',i,'] : ') ; Readln (T[i]) ; Until T[i] > T[i-1];

End ;

Remplir un tableau par des éléments distincts DEF PROC Saisie (N : Entier ; VAR T : Tab)

Résultat = T

T = [ T[1] = donnée (''Saisir la case 1'') ] Pour i de 2 à n Faire

Répéter

T[i] = Donnée (''Saisir la case '', i) j 0

Répéter j j+1

Jusqu’à (T[i] = T[j]) ou (j = i-1) Jusqu’à T[i] ≠ T[j]

Fin Pour Fin Saisie

Procedure Saisie (n : Integer ; Var T: Tab);

Var i, j : Integer;

Begin

Writeln ('Saisir la case 1'); Readln (T[1]);

For i:=2 To n Do Repeat

Writeln ('Saisir la case ', i); Readln (T[i]);

j:=0;

Repeat j:=j+1;

Until (T[i] = T[j]) or (j = i-1);

Until T[i] <> T[j] ; End;

Remplir un tableau par n chaînes de caractères de 8 chiffres DEF PROC Saisie (N : Entier ; VAR T : Tab)

Pour i de 1 à n Faire Répéter

T[i] = Donnée ("T[", i, "]= ") Valeur (T[i], x, err)

Jusqu’à (Err = 0) ET (long(T[i]) = 8) Fin Pour

Fin Saisie

Procedure Saisie (n : Integer ; Var T : TAB) ; Var i ,err : Integer ;

x : Longint ; Begin

For i:=1 To n Do Repeat

Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ; Val (T[i],x,err);

Until (Err = 0) and (length(T[i]) = 8) ; End;

Affichage d’un tableau de n éléments DEF PROC Affiche (N : Entier ; T : Tab)

Résultat = Affichage_T Affichage_T = [ ]

Pour i de 1 à n Faire Ecrire (T[i], " ") Fin Pour

Fin Affiche

Procedure Affiche (n : Integer ; T : TAB) ; Var i : Integer ;

Begin

FOR i :=1 TO n DO Write (T[i], ‘ ‘) ; End ;

Affichage d’un tableau, 10 valeurs par ligne DEF PROC Affiche (T:tab ; n:entier)

Résultat = Affichage_T Affichage_T = [ ]

Pour i de 1 à n Faire Ecrire (T[i], " ")

Si (i mod 10) = 0

Alors Retour_à_la_ligne Fin Si

Fin Pour Fin Affiche

Procedure Affiche (T:tab ; n:integer);

Var i:integer;

Begin

For i:=1 To n Do begin

write(T[i], " ");

If (i mod 10) = 0 then writeln ; end;

End ;

(11)

Permutation de deux variables réelles DEF PROC Permut (VAR x, y : Réel)

Résultat = (x, y) X AUX AUX  Y Y  X Fin Permut

Procedure Permut (VAR x, y : Real) ; Var aux : Real ;

Begin Aux := Y ; Y := X ; 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

t1,t2 : tab ; var c1,c2 : entier) Résultat = (t1,t2,c1,c2)

(t1,t2,c1,c2) = [ c1 0 ; c2  0 ] Pour i de 1 à n Faire Si t[i] mod 2 = 0

Alors c1 c1 +1 T1[c1] T[i]

Sinon c2 c2 +1 T2[c2] T[i]

Fin Si Fin Pour Fin Transfert

Procedure Transfert (T : tab ; n : integer ; var t1,t2 : tab ; var c1,c2 : integer) ;

Var i :integer ; Begin

c1 := 0 ; c2 := 0 ;

For i :=1 To n Do If t[i] mod 2 = 0 Then begin

c1 := c1 +1 ; T1[c1] := T[i] ; end

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)

Pour i de n+1 à p+1 Faire

T[i]  T[i-1] {décalage des éléments vers droite}

Fin Pour

T[p]  X {insertion de X à la position p}

Fin Insertion

Procedure Insertion ( Var T : tab ; n,x,p : integer) ; Var i :integer ;

Begin

For i :=n+1 DownTo p+1 Do T[i] := T[i-1];

T[p] := X ; End;

La somme de n réels dans un tableau DEF FN Somme (T : tab ; n : entier) : réel

Résultat = Somme Somme  S S = [ S 0 ]

Pour i de 1 à n Faire S S + T[i]

Fin Pour Fin Somme

Function Somme (T : tab ; n : integer) : real ; Var i : integer ;

s : real;

Begin s:=0 ;

For i:=1 To n Do s:=s + T[i] ; Somme := s ;

End ;

Factorielle de N (n !) DEF FN Fact (n : entier) : entier long

Résultat = Fact Fact  F F = [ F 1 ]

Pour i de 2 à n Faire F  F * i

Fin Pour Fin Fact

Function Fact (n : integer) : Longint ; Var i : integer ;

f : longint ; Begin

f:=1 ;

For i:=2 To n Do f := f * i ; Fact := f ;

End ;

Calcul de Xⁿ(n ≥ 0) DEF FN Puissance (x, n : entier) : entier

Résultat = puissance puissance  p p = [ p 1 ]

Pour i de 1 à n Faire p  p * x

Fin Pour Fin Puissance

Function Puissance (x, n : integer) : integer ; Var i , p : integer ;

Begin p:=1 ;

For i:=1 To n Do p := p * x ; puissance := p ;

End ;

(12)

Vérifier si un nombre est premier DEF FN Premier (n : entier) : booléen

Résultat = premier premier  nbdiv = 2 nbdiv = [ nbdiv 1 ]

Pour i de 1 à (n div 2) Faire Si (n mod i = 0)

Alors nbdiv  nbdiv+1 Fin Si

Fin Pour Fin Premier

Function Premier (N:integer) : boolean ; Var i ,nbdiv : integer;

Begin nbdiv:=1;

For i:=1 To (n div 2) Do If (n mod i = 0)

Then nbdiv := nbdiv + 1 ; premier := nbdiv = 2 ;

End ;

La somme de chiffres d’un entier DEF FN Som_chif (n : entier) : entier

Résultat = som_chif  som som = [ som 0 ]

Répéter

R n mod 10 Som  som + r N  n div 10 Jusqu’à n = 0 Fin Som_chif

Function Som_Chif ( N : integer ) : integer ; Var som, r : integer ;

Begin som:=0 ; repeat

r := n mod 10 ; Som := som + r ; N := n div 10 ; until n=0 ; Som_chif := som ; End;

Vérifier si une chaîne est palindrome DEF FN Palindrome (ch : chaîne) : Booléen

Résultat = palindrome  verif verif = [ i 0 ]

Répéter i  i+1

verif  (ch[i] = ch[long(ch)-i+1]) Jusqu’à (verif=faux) ou (i = long(ch) div 2) Fin Palindrome

Function palindrome(ch:string):boolean;

Var i:integer;

verif:boolean;

Begin i:=0;

repeat i:=i+1;

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

Résultat = Minimum  min min = [ min T[1] ]

Pour i de 2 à n Faire Si (T[i] < min)

Alors min  T[i]

Fin Si Fin Pour Fin Minimum

Function Minimum (n : Integer ; T : Tab) : Real ; Var i : Integer ;

Min : Real ; Begin

Min := T[1] ;

For i :=2 To n Do

If (T[i] < min) Then min := T[i] ; Minimum := min ;

End ;

Fréquence d’un élément X dans un tableau DEF FN Frequence (x, n : entier ; T:Tab) : entier

Résultat = frequence  f f = [ f0 ]

Pour i de 1 à n Faire Si (T[i] = X)

Alors f  f + 1 Fin Si

Fin Pour Fin Frequence

Function Frequence (x, n :integer ; T:Tab):integer;

Var i, f : Integer ; Begin

f := 0 ;

For i :=1 To n Do

If (T[i] = X) Then f := f+1 ; Frequence := f ;

End ;

(13)

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

:type

1

; Var pf

2

:type

2

; … ; pf

n

:type

n

) ; {Déclarations locales : Const, Type, Var, Function, Procedure, ...}*

Begin

Instructions de la procédure ;

End ;

{============= Définition des fonctions ===================}*

Function Nom_fonction (pf1

:type

1

; pf

2

:type

2

; … ; pf

n

:type

n

) : 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