Algorithmique programmation2018

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 = 2018
Constante = 9.81
Constante = "Chebba"
Constante = Vrai
Constante = "B"
En Pascal :
• Syntaxe : CONST <nom_constante> = <valeur_constante> ;
• Exemples : CONST annee = 2018 ;
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 ;
Exemple :
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’ ;

II- Les structures simples
II.1) 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 arithmétique …
D reçoit la valeur de l’expression logique …
A = 5
B = 8
A = 6
C = 2.5
D = Vrai
II.2) 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.3) 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

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 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 )
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, chaîne,
énuméré) au programme appelant. Il s’agit d’un cas particulier des procédures.
• L’entête de la définition :
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 …

Sous Programmes Usuels
En Algorithme En Pascal
Saisir un entier N tel que 5 ≤ N ≤ 500
0) DEF PROC Saisie (VAR N : Entier)
1) Répéter
Ecrire ("Donner un entier "), Lire(N)
Jusqu’à (5 ≤ N) ET (N ≤ 500)
2) 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
0) DEF PROC Saisie (VAR ch : Chaîne)
1) Répéter
Ecrire ("Saisir une chaîne "), Lire(CH)
i1
Tant que (ch[i] dans ["A".."Z"]) et
(i ≤ long(ch)) Faire ii+1
Jusqu’à i > long(ch)
2) 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
1) Répéter
Ecrire ("Saisir une chaîne "), Lire (ch)
i0
Répéter
ii+1
verif  pos (ch[i],ch) = i
Jusqu’à (verif=faux) ou (i=long(ch))
Jusqu’à verif
2) 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
1) Répéter
Ecrire ("Ch = "), Lire (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
2) 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 T par N entiers impairs
0) DEF PROC Remplir (N : Entier ; VAR T : Tab)
1) Pour i de 1 à n Faire
Répéter
Ecrire ("T[", i, "] = "), Lire (T[i])
Jusqu’à (T[i] mod 2) ≠ 0
Fin Pour
2) 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]
0) DEF PROC Remplir (VAR T : Tab ; N : Entier)
1) Lire(a, b)
T[i] a + Aléa (b-a+1)
Fin Pour
3) 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 ;
• Un réel au hasard entre [a,b[
T[i] := a+ (b-a) * Random
• Une lettre majuscule au hazard
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)
1) Ecrire ("T[1] : "), Lire(T[1])
Répéter
Ecrire ("T[", i, "] : "), Lire (T[i])
Jusqu’à T[i] > T[i-1]
Fin Pour
3) 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 T par N éléments distincts
Répéter
Ecrire (''Saisir la case '', i), Lire (T[i])
j 1
Tant que T[i] ≠ T[j] Faire
j j+1
Fin Tant que
Jusqu’à (j = i)
Fin Pour
2) Fin Saisie
Procedure Saisie (n : Integer ; Var T: Tab);
Var i, j : Integer;
Begin
For i:=1 To n Do
Repeat
Writeln ('Saisir la case ', i); Readln (T[i]);
j:=1;
While T[i] <> T[j] Do j:=j+1 ;
Until (j = i) ;
End;
Remplir un tableau T par N entiers formés des chiffres non nuls
Répéter
Ecrire ("T[", i, "]= "), Lire (T[i])
Conch (T[i], ch)
Jusqu’à pos("0",ch)= 0
Fin Pour
2) Fin Saisie
Procedure Saisie (n : Integer ; Var T : TAB) ;
Var i : Integer ;
ch : String ;
Begin
For i:=1 To n Do
Repeat
Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;
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)
Ecrire (T[i], " ")
Fin Pour
2) 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
0) DEF PROC Affiche (T:tab ; n:entier)
Ecrire (T[i], " ")
Si (i mod 10) = 0
Alors Retour_à_la_ligne
Fin Si
Fin Pour
2) 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
0) DEF PROC Permut (VAR x, y : Réel)
1) AUX  Y
2) Y  X
3) X AUX
4) 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
0) DEF PROC Transfert (T : tab ; n : entier ; var
t1,t2 : tab ; var c1,c2 : entier)
1) 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
2) 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 ;
Ranger les éléments négatifs d’un tableau T à gauche et les positifs à droite
0) DEF PROC Ranger (Var T : tab ; n : entier)
1) K 0
Si t[i] < 0
Alors k k +1
Aux t[i]
t[i]  t[k]
t[k]  aux
Fin Si
Fin Pour
2) Fin Transfert
Procedure Ranger (Var T : tab ; n : integer) ;
Var i, k, aux : integer ;
Begin
k := 0 ;
For i :=1 To n Do
If t[i] < 0
Then begin
k := k +1 ;
Aux := t[i] ;
t[i] := t[k] ;
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 :
entier)
1) Pour i de (n+1) à (p+1) Faire
T[i]  T[i-1] {décalage des éléments vers droite}
Fin Pour
2) T[p]  X {insertion de X à la position p}
3) 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
0) DEF FN Somme (T : tab ; n : entier) : réel
1) S 0
S S + T[i]
Fin Pour
2) Somme  S
3) 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 ! )
0) DEF FN Fact (n : entier) : entier long
1) F 1
F  F * i
Fin Pour
3) Fact  F
4) 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 Xn
(n ≥ 0)
0) DEF FN Puissance (x, n : entier) : entier
1) p 1
p  p * x
Fin Pour
2) puissance  p
3) 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
0) DEF FN Premier (n : entier) : booléen
1) nbdiv 1
2) Pour i de 1 à (n div 2) Faire
Si (n mod i = 0)
Alors nbdiv  nbdiv+1
Fin Si
Fin Pour
3) premier  (nbdiv = 2)
4) 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 ;
PPCM (a,b)
0) DEF FN PPCM ( a, b : entier) : entier
1) i 1
2) Tant que ((a*i) mod b) ≠ 0 Faire
i  i+1
Fin Tant que
3) ppcm  a*i
4) Fin PPCM
Function PPCM (a ,b :integer) : integer ;
Var i : integer;
Begin
i := 1 ;
While (a*i) mod b <> 0 Do i:=i+1 ;
ppcm := a*i ;
End;
PGCD_Euclide (a,b)
0) DEF FN PGCD_Euclide ( a, b : entier) : entier
1) Tant que b ≠ 0 Faire
r  a mod b
a  b
b  r
Fin Tant que
2) Pgcd_euclide  a
3) Fin PGCD_Euclide
Function PGCD_Euclide (a ,b :integer) : integer ;
Var r : integer;
Begin
While b<>0 Do
Begin
r := a mod b;
a := b;
b := r;
End;
PGCD_Euclide := a;
End;

La somme de chiffres d’un entier
0) DEF FN Som_chif (n : entier) : entier
1) som 0
2) Répéter
R n mod 10
Som  som + r
N  n div 10
Jusqu’à (n = 0)
3) som_chif  som
4) 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
0) DEF FN Palindrome (ch : chaîne) : Booléen
1) i 0
2) Répéter
i  i+1
verif  ch[i] = ch[long(ch) – i + 1]
Jusqu’à (verif=faux) ou (i = long(ch) div 2)
3) palindrome  verif
4) 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
0) DEF FN Minimum (n : Entier ; T : Tab) : Réel
1) min T[1]
Si (T[i] < min)
Alors min  T[i]
Fin Si
Fin Pour
2) Minimum  min
3) 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
0) DEF FN Recherche (X : réel ; n : Entier ; T :
Tab) : Entier
1) 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)
2) Recherche  p
3) 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
0) DEF FN Frequence (x,n :entier ;T:Tab) : entier
1) f0
Si (T[i] = X)
Alors f  f + 1
Fin Si
Fin Pour
3) frequence  f
4) 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 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] ;
… ;
Var {Déclaration des variables ; Exemples}
X, Y, Z : Real ; I, J : Integer ; Let : Char ; Test : Boolean ; Ch : String ;
Ville : Array [1..10] of String ;
T1, T2 : Tab ;
Jour : Jours_semaine ;
Couleurs : (Rouge, Vert, Bleu, Jaune) ;
Mois : 1..12 ;
… ;
{================= Définition des procédures ==========================}
Procedure Nom_procédure (pf1 : type1 ; VAR pf2 : type2 ; … ; VAR 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}
{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}
D
é
c
l
a
r
a
t
i
o
n
s
g
l
o
b
a
l
e
s

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 long 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 long 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/Caractère 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îne/Caractère 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/Caractère,
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îne/Caractère Chaîne CH2 := ' Janvier' ; CH1 :='14' ;
CH3 := Concat (ch1, ch2, '2011') ;
 CH3 = '14 Janvier2011'
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 (2018, CH) ; CH = '2018'
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

Algorithmique programmation2018

Recommandé

Contenu connexe

Tendances (20)

Similaire à Algorithmique programmation2018 (20)

Plus de salah fenni (8)

Algorithmique programmation2018