Algorithmique et programmation en Pascal (résumé)

Algorithmique & Programmation Prof. FENNI-S Page 1/12
Algorithmique & Programmation (Résumé)
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 = 2016
Constante = 9.81
Constante = "Chebba"
Constante = Vrai
Constante = "B"
En Pascal :
• Syntaxe : CONST <nom_constante> = <valeur_constante> ;
• Exemples : CONST annee = 2016 ;
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 ;

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
Tab = tableau de 100 chaînes de caractères
T.D.O.
Objet Type/Nature Rôle
Ident_tableau Nom_type
T Tab
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’ ;

LES STRUCTURES DE DONNEES  Prof : FENNI-S
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 (mot) entier (mot) 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 : FENNI-S
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 := 'Merci' ;
Delete (CH, 4, 2) ;  CH = 'Mer'
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 (2016, CH) ; CH = '2016'
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 ('2010', n, err) ; n = 2010 et err = 0
VAL ('0045', n, err) ; n = 45 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

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) ;
Writeln ('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

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
................. ; {initialisation(s)}
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 …………………………
Sinon Si condition n-1
Alors Trait n-1
Sinon Trait n
Fin Si
initialisation(s)
Si condition1 Alors Trait1
Sinon Si …………………………
Sinon Si condition n-1
Alors Trait n-1
Sinon Trait n
Fin Si
............ ; {initialisation(s)}
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 ;

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
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 :
REPETER
Traitement
JUSQU'A condition(s)
initialisation(s)
REPETER
Traitement
JUSQU'A condition(s)
{jusqu’à condition soit vraie}
............; {initialisation(s)}
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}
............; {initialisation(s)}
WHILE condition(s) DO
Begin
Traitement ;
End ;

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 …

Sous Programmes Usuels
En Analyse En Pascal
Saisir un entier N tel que 5 ≤ N ≤ 500
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1
Tant que (ch[i] dans ["A".."Z"]) et
(i ≤ long(ch)) Faire ii+1
Jusqu’à i > long(ch)
Fin Saisie
Procedure Saisie (Var ch : String) ;
Var i : integer;
Begin
Repeat
Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
i:=1;
While (ch[i] in ['A'..'Z']) and (i<=length(ch)) do
i:=i+1;
Until i > length(ch);
End ;
Saisir une chaîne de caractères distincts
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 ;
Saisir une chaîne formée exactement des quatre lettres A, I, P et F
Résultat = ch
ch = [ ]
Répéter
Ch = Donnée ("Ch = ")
valid  (pos(‘'I’',ch)≠0) et (pos(‘'F’',ch)≠0) et
(pos(‘'A’',ch)≠0) et (pos(‘'P’',ch)≠0)
et (long(ch)=4)
Jusqu’à valid
Fin Saisie
Procedure saisie (Var ch:string);
Var valid : Boolean;
Begin
Repeat
Write ('ch = ');
Readln (ch);
valid := (pos('I',ch)<>0) and (pos('F',ch)<>0) and
(pos('A',ch)<>0) and (pos('P',ch)<>0)
and (length(ch)=4) ;
Until valid ;
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 ]
T[i] a + Aléa (b-a+1)
Fin Pour
Fin Remplir
• 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))
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 ;
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] : ") ]
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
Résultat = T
T = [ T[1] = donnée (''Saisir la case 1'') ]
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
Résultat = T
T = [ ]
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 = [ ]
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 = [ ]
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 ;
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 ]
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)
Résultat = T
T = [ ]
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 ]
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 ]
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
(n ≥ 0)
DEF FN Puissance (x, n : entier) : entier
Résultat = puissance
puissance  p
p = [ p 1 ]
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 ;
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] ]
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 ;
Recherche de la dernière position d’un élément X dans un tableau de n réels
DEF FN Recherche (X :réel ; n : Entier ; T : Tab) :
Entier
Résultat = Recherche  p
p = [ p 0 ; in+1 ]
Répéter
ii-1
Si T[i]=X Alors p  i Fin Si
Jusqu’à (p≠0) OU (i=1)
Fin Recherche
Function Recherche (X:Real ; n : Integer ; T : Tab) :
Integer ;
Var i, p : Integer ;
Begin
p := 0 ;
i:=n+1;
Repeat
i:=i-1;
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
DEF FN Frequence (x, n : entier ; T:Tab) : entier
Résultat = frequence  f
f = [ f0 ]
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 ;

STRUCTURE GENERALE D’UN PROGRAMME PASCAL
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 et programmation en Pascal (résumé)

Contenu connexe

Tendances

Similaire à Algorithmique et programmation en Pascal (résumé)

Plus de salah fenni

Dernier

Algorithmique et programmation en Pascal (résumé)