Resume Algo 2019

Algorithmique & Programmation
(Résumé)
• Un algorithme est une suite finie et non ambiguë d’opérations ou d'instructions permettant de
résoudre un type de problèmes.
• Un programme est un texte qui décrit un algorithme que l’on souhaite faire exécuter par une
machine. Ce texte est écrit dans un langage particulier appelé « Langage de programmation »
qui sont tous plus ou moins organisés autour de quatre familles d’instructions :
- l’affectation de variables ;
- la lecture / écriture ;
- les tests ;
- les boucles.
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 = 2019
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 = 2019 ;
g = 9.81 ;
ville = ‘Chebba’ ;
existe = True ;
lettre = ‘B’ ;
I.2) Déclaration des variables

En Algorithmique :
T.D.O
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. FENNI-S Page 1/16

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 Exemple :
VAR Moy : array [1..30] of real ;
Deuxième formulation
EN ALGORITHMIQUE EN PASCAL
Tableau de déclarations des nouveaux types TYPE

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

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

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

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

II- Les structures simples
II.1) L’opération d’affectation

Analyse / Algorithme Pascal
Variable  Valeur Variable := Valeur ;
Exemples :
Analyse Pascal Commentaire Résultat

et Algorithme
A5 A := 5 ; La variable A reçoit la valeur 5 A=5
BA+3 B := A + 3 ; B reçoit la valeur de l’expression A+3 B=8
A  A +1 A := A +1 ; A reçoit sa valeur actuelle incrémentée de 1 A=6
C  long("lycée")/2 C := length(‘lycée’)/2 ; C reçoit la valeur de l’expression arithmétique … C = 2.5
D4<6 D := 4 < 6 ; D reçoit la valeur de l’expression logique … D = Vrai
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 A:=10 ;
Ecrire (A) Write (A) ; 10Bonjour
Ecrire ("Bonjour") Writeln ('Bonjour') ;
Ecrire (2 * 8 DIV 3) Writeln (2 * 8 DIV 3) ; 5
Ecrire (5 > 6) Write (5 > 6) ; False
Ecrire (3, "*", A, " = ", 3*A) Writeln (3, '*', A, ' = ', 3*a) ; 3*10 = 30

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

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

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

IV- Les structures de contrôles itératives
IV.1) La structure de contrôle itérative complète
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 :
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 :
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}
Exemples :
• Remplir un tableau T par N éléments :

T=[ ]
POUR i de 1 à N FAIRE
POUR i de 1 à N FAIRE FOR i:=1 TO N DO
Lire (T[i])
T[i] = donnée Readln (T[i]) ;
Fin Pour
Fin Pour
• Afficher un tableau T de N éléments :

Analyse / Algorithmique En Pascal
POUR i de 1 à N FAIRE FOR i:=1 TO N DO

Ecrire (T[i]) Write (T[i], ‘ ‘) ;
Fin Pour
• Afficher une chaîne CH caractère par caractère :

Analyse / Algorithmique En Pascal
POUR i de 1 à Long(ch) FAIRE FOR i:=1 TO Length(ch) DO

Ecrire (ch[i]) Writeln (CH[i]) ;
Fin Pour

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 d’une procédure.
• 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 …
N.B. :
• Dans le cas où une procédure retourne un résultat, on doit choisir le mode de
transmission par variable pour le paramètre résultat en question. On doit faire précéder le
paramètre formel par le mot clé VAR.
• Pour la fonction, on définit seulement le mode de passage des paramètres par valeur.

Sous Programmes Usuels
En Algorithme En Pascal
Saisir un entier N tel que 5 ≤ N ≤ 500
0) DEF PROC Saisie (VAR N : Entier) Procedure Saisie (Var n : integer) ;
1) Répéter Begin
Ecrire ("Donner un entier "), Lire(N) Repeat
Jusqu’à (5 ≤ N) ET (N ≤ 500) Write (‘Donner un entier ’);
2) Fin Saisie Readln (n);
Until (5 <= N) AND (N <= 500) ;
End ;
Saisir une chaîne de caractère en majuscule

0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire(CH) Begin
i1 Repeat
Tant que (ch[i] dans ["A".."Z"]) et Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
(i ≤ long(ch)) Faire ii+1 i:=1;
Jusqu’à i > long(ch) While (ch[i] in ['A'..'Z']) and (i<=length(ch)) do
2) Fin Saisie i:=i+1;
Until i > length(ch);
End ;
Saisir une chaîne de caractères distincts
0) DEF PROC Saisie (VAR ch : Chaîne) Procedure Saisie (Var ch : String) ;
1) Répéter Var i : integer;
Ecrire ("Saisir une chaîne "), Lire (ch) verif : Boolean;
i0 Begin
Répéter Repeat
ii+1 Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
verif  pos (ch[i],ch) = i i := 0 ;
Jusqu’à (verif=faux) ou (i=long(ch)) Repeat
Jusqu’à verif i := i+1 ;
2) Fin Saisie Verif := pos(ch[i],ch) = i ;
Until (verif=false) or (i = length(ch)) ;
Until verif ;
End ;
Remplir un tableau T par N entiers impairs
0) DEF PROC Remplir (N : Entier ; VAR T : Tab) Procedure Remplir (N : integer ; Var T : Tab) ;
1) Pour i de 1 à n Faire Var i : integer;
Répéter Begin
Ecrire ("T[", i, "] = "), Lire (T[i]) For i:=1 To n Do
Jusqu’à (T[i] mod 2) ≠ 0 Repeat
Fin Pour Write (‘T[‘,i,’]= ’) ;
2) Fin Remplir Readln (T[i]) ;
Until (T[i] mod 2) <> 0 ;
End ;
Remplir un tableau par des entiers au hasard entre [a,b]
0) DEF PROC Remplir (VAR T : Tab ; N : Entier) Procedure Remplir (Var T : Tab ; N : integer) ;
1) Lire(a, b) Var a, b, i : integer;
2) Pour i de 1 à n Faire Begin
T[i] a + Aléa (b-a+1) Readln (a,b);
Fin Pour Randomize ;
3) Fin Remplir For i:=1 To n Do
T[i] := a + Random (b-a+1);
End ;
• Un réel au hasard entre [a,b[ • Un réel au hasard entre [a,b[

T[i] a+ (b-a) * Aléa T[i] := a+ (b-a) * Random
• Une lettre majuscule au hazard • Une lettre majuscule au hazard
T[i] chr (65 + Aléa(26)) T[i] := chr (65 + Random(26))

Remplir un tableau T par N éléments en ordre croissant
0) DEF PROC Saisie (N : Entier ; VAR T : Tab) Procedure Saisie (n : integer ; var t : tab) ;
1) Ecrire ("T[1] : "), Lire(T[1]) Var i : integer;
Répéter Write ('T[1] : ') ; Readln (T[1]) ;
Ecrire ("T[", i, "] : "), Lire (T[i]) For i:=2 To n Do
Jusqu’à T[i] > T[i-1] Repeat
Fin Pour Write ('T[',i,'] : ') ;
3) Fin Saisie Readln (T[i]) ;
Until T[i] > T[i-1];
End ;
Remplir un tableau T par N éléments distincts

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

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

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

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

Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2
0) DEF PROC Transfert (T : tab ; n : entier ; var Procedure Transfert (T : tab ; n : integer ; var t1,t2 :
t1,t2 : tab ; var c1,c2 : entier) tab ; var c1,c2 : integer) ;
1) c1 0 ; c2  0 Var i :integer ;
Pour i de 1 à n Faire Begin
Si t[i] mod 2 = 0 c1 := 0 ;
Alors c1 c1 +1 c2 := 0 ;
T1[c1] T[i] For i :=1 To n Do
Sinon c2 c2 +1 If t[i] mod 2 = 0
T2[c2] T[i] Then begin
Fin Si c1 := c1 +1 ;
Fin Pour T1[c1] := T[i] ;
2) Fin Transfert end
Else begin
c2 := c2 +1 ;
T2[c2] := T[i] ;
end ;
End ;
Ranger les éléments négatifs d’un tableau T à gauche et les positifs à droite
0) DEF PROC Ranger (Var T : tab ; n : entier) Procedure Ranger (Var T : tab ; n : integer) ;
1) K 0 Var i, k, aux : integer ;
Si t[i] < 0 k := 0 ;
Alors k k +1 For i :=1 To n Do
Aux t[i] If t[i] < 0
t[i]  t[k] Then begin
t[k]  aux k := k +1 ;
Aux := t[i] ;
Fin Si
Fin Pour t[i] := t[k] ;
2) Fin Transfert t[k] := aux ;
end ;
End ;
Insertion d’un élément X dans un tableau T à une position p

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

0) DEF FN Somme (T : tab ; n : entier) : réel Function Somme (T : tab ; n : integer) : real ;
1) S 0 Var i : integer ;
Pour i de 1 à n Faire s : real;
S S + T[i] Begin
Fin Pour s:=0 ;
2) Somme  S For i:=1 To n Do s:=s + T[i] ;
3) Fin Somme Somme := s ;
End ;
Factorielle de N ( n ! )
0) DEF FN Fact (n : entier) : entier long Function Fact (n : integer) : Longint ;
1) F 1 Var i : integer ;
2) Pour i de 2 à n Faire f : longint ;
FF*i Begin
Fin Pour f:=1 ;
3) Fact  F For i:=2 To n Do f := f * i ;
4) Fin Fact Fact := f ;
End ;

Calcul de Xn (n ≥ 0)
0) DEF FN Puissance (x, n : entier) : entier Function Puissance (x, n : integer) : integer ;
1) p 1 Var i , p : integer ;
pp*x p:=1 ;
Fin Pour For i:=1 To n Do p := p * x ;
2) puissance  p puissance := p ;
3) Fin Puissance End ;
Vérifier si un nombre est premier (le nombre de ses diviseurs =2)
0) DEF FN Premier (n : entier) : booléen Function Premier (N:integer) : boolean ;
1) nbdiv 1 Var i ,nbdiv : integer;
2) Pour i de 1 à (n div 2) Faire Begin
Si (n mod i = 0) nbdiv:=1;
Alors nbdiv  nbdiv+1 For i:=1 To (n div 2) Do
Fin Si If (n mod i = 0)
Fin Pour Then nbdiv := nbdiv + 1 ;
3) premier  (nbdiv = 2) premier := nbdiv = 2 ;
4) Fin Premier End ;
Vérifier si une chaine contient uniquement des consonnes
0) DEF FN Verif (ch : chaîne) : booléen Function verif (ch : String) : Boolean;
1) i0 Var i : Integer;
2) Répéter Test : Boolean;
i  i+1 Begin
test  majus(ch[i]) dans (['’A’'..’'Z’']- i := 0;
[‘'A’',’'E’',’'I’',’'O’',’'U’',’'Y’']) Repeat
Jusqu’à (test=faux) ou (i=long(ch)) i := i+1;
3) Verif  test test := upcase(ch[i]) in (['A'..'Z']-['A','E','I','O','U','Y']);
4) Fin verif Until (test=False) Or (i=Length(ch));
verif := test;
End;
PPCM (a,b)
0) DEF FN PPCM ( a, b : entier) : entier Function PPCM (a ,b :integer) : integer ;
1) i 1 Var i : integer;
2) Tant que ((a*i) mod b) ≠ 0 Faire Begin
i  i+1 i := 1 ;
Fin Tant que While (a*i) mod b <> 0 Do i:=i+1 ;
3) ppcm  a*i
4) Fin PPCM ppcm := a*i ;
End;
PGCD_Euclide (a,b)
0) DEF FN PGCD_Euclide ( a, b : entier) : entier Function PGCD_Euclide (a ,b :integer) : integer ;
1) Tant que b ≠ 0 Faire Var r : integer;
r  a mod b Begin
a b While b<>0 Do
br Begin
Fin Tant que r := a mod b;
2) Pgcd_euclide  a a := b;
3) Fin PGCD_Euclide b := r;
End;
PGCD_Euclide := a;
End;
La somme de chiffres d’un entier
0) DEF FN Som_chif (n : entier) : entier Function Som_Chif ( N : integer ) : integer ;
1) som 0 Var som, r : integer ;
2) Répéter Begin
R n mod 10 som:=0 ;
Som  som + r Repeat
N  n div 10 r := n mod 10 ;
Jusqu’à (n = 0) Som := som + r ;
3) som_chif  som N := n div 10 ;
4) Fin Som_chif Until n=0 ;
Som_chif := som ;
End;

Vérifier si une chaîne est palindrome (ou symétrique)
0) DEF FN Palindrome (ch : chaîne) : Booléen Function palindrome (ch : string) : boolean;
1) i 0 Var i:integer;
2) Répéter verif:boolean;
i  i+1 Begin
verif  ch[i] = ch[long(ch) – i + 1] i:=0;
Jusqu’à (verif=faux) ou (i = long(ch) div 2) repeat
3) palindrome  verif i:=i+1;
4) Fin Palindrome verif := ch[i] = ch[length(ch)-i+1] ;
until (verif=false) or (i=length(ch) div 2) ;
Palindrome := verif;
End;
Recherche de la première valeur minimum dans un tableau de n réels

0) DEF FN Minimum (n : Entier ; T : Tab) : Réel Function Minimum (n : Integer ; T : Tab) : Real ;
1) min T[1] Var i : Integer ;
Pour i de 2 à n Faire Min : Real ;
Si (T[i] < min) Begin
Alors min  T[i] Min := T[1] ;
Fin Si For i :=2 To n Do
Fin Pour If (T[i] < min) Then min := T[i] ;
2) Minimum  min Minimum := min ;
3) Fin Minimum End ;
Recherche de la dernière position d’un élément X dans un tableau de n réels

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

0) DEF FN Frequence (x,n :entier ;T:Tab) : entier Function Frequence (x, n :integer ; T:Tab):integer;
1) f0 Var i, f : Integer ;
Si (T[i] = X) f := 0 ;
Alors f  f + 1 For i :=1 To n Do
Fin Si If (T[i] = X) Then f := f+1 ;
Fin Pour Frequence := f ;
3) frequence  f End ;
4) Fin Frequence
Miroir (symétrique) d’un entier long

0) DEF FN Miroir (x : entier long) : entier long Function miroir (x : longint) : longint ;
1) Sym  0 Var sym : longint ;
2) Répéter u : 0..9 ;
U  X mod 10 Begin
Sym  sym * 10 + u sym := 0 ;
X  x div 10 Repeat
Jusqu’à x=0 U := X mod 10;
3) miroir  sym Sym := sym * 10 + u;
4) Fin miroir X := x div 10 ;
Until x=0 ;
miroir := sym ;
End ;

Problème :
On se propose d’écrire un programme qui permet de :
• saisir un entier N (avec 10 ≤ N ≤ 50)
• remplir un tableau T par N chaînes alphanumériques
• ranger les chaînes formées uniquement des consonnes de T dans un tableau TC
• afficher les éléments de TC
Travail demandé :
1. Analyser le problème principal en le décomposant en modules.
2. Ecrire les algorithmes et les tableaux de déclaration relatifs aux modules envisagés.
ANALYSE DU P.P. :
Nom : Rangement
Résultat = PROC AFFICHE (K, TC)
(K, TC) = PROC RANGER (N, T, K, TC)
(N, T) = PROC SAISIES (N, T)
FIN Rangement
Tableau de Déclaration des Nouveaux Types
Type
Tab = Tableau de 50 chaînes
Tableau de Déclaration des Objets globaux

T Tab Tableau contenant n chaînes alphanumériques
TC Tab Tableau contenant k chaînes consonnes
N Entier Taille du tableau T
K Entier Taille du tableau TC
Saisies Procédure Permet de saisir un entier N et de remplir un tableau T
Ranger Procédure Permet de ranger les chaînes consonnes de T dans TC
Affiche Procédure Permet d’afficher les k éléments du tableau TC
Algorithme de la procedure saisies :

0) DEF PROC SAISIES (Var n : Entier ; Var T : tab)
1) Répéter
Ecrire ("N = "), Lire (N)
Jusqu’à n dans [10..50]
2) Pour i de 1 à n Faire
Répéter
Lire (T[i])
Jusqu’à FN Alpha (T[i]) { FN Alpha(T[i]) = Vrai }
Fin Pour
3) Fin Saisies
Tableau de Déclaration des Objets locaux
i Entier Compteur
Alpha Fonction Permet de vérifier si une chaîne est alphanumérique ou non

Algorithme de la fonction alpha :
0) DEF FN ALPHA (ch : chaîne) : Booléen

1) j  0
2) Répéter
j  j+1
test  majus(ch[j]) dans ["A".."Z","0".."9"]
Jusqu’à (test=faux) ou (j=long(ch))
3) Alpha  test
4) Fin Alpha

j Entier Compteur
test Booléen Variable intermédiaire
Algorithme de la procedure ranger :
0) DEF PROC RANGER (n :Entier ; T :Tab ; Var k : Entier ; Var Tc :Tab)

1) k0
2) Pour i de 1 à n Faire
Si FN Verif (T[i]) { Si FN Verif(T[i]) = Vrai }
Alors kk+1
Tc [k] T[i]
Fin si
Fin Pour
3) Fin Ranger

i Entier Compteur
Verif Fonction Permet de vérifier si une chaîne contient uniquement des consonnes
Algorithme de la fonction verif :
0) DEF FN Verif (ch : chaîne) : Booléen

1) j  0
2) Répéter
j  j+1
test  majus(ch[j]) dans (["A".."Z"]-["A","E","I","O","U","Y"])
Jusqu’à (test=faux) ou (j=long(ch))
3) Verif  test
4) Fin Verif

j Entier Compteur
test Booléen Variable intermédiaire

Algorithme de la procedure affiche :
0) DEF PROC Affiche (k : Entier ; Tc : tab)

1) Pour i de 1 à k Faire
Ecrire (Tc[i])
Fin Pour
2) Fin Affiche

i Entier Compteur
Traduction en langage Pascal :
Program rangement;
Uses Wincrt ;
Type Tab = Array [1..50] Of String ;
Var T, Tc : Tab;
n, k : Integer ;
(*************************************************)
Procedure saisies (Var n : Integer;Var t : Tab);
Var i : Integer;
Function alpha (ch : String) : Boolean;

Var j : Integer;
Test : Boolean;
Begin
j := 0;
Repeat
j := j+1;
test := Upcase(ch[j]) In ['A'..'Z','0'..'9'];
Until (test=False) Or (j=Length(ch));
alpha := test;
End;
Begin
Repeat
Write ('N = ') ;
Readln (n) ;
Until n In [10..50] ;
For i:=1 To n Do
Repeat
Write('T[',i,']= ');
Readln (T[i]) ;
Until alpha(T[i]);
End;

(**************************************************************)
Procedure Ranger (n:Integer ; t:Tab ; Var k:Integer ; Var tc:Tab);
Var i : Integer;
Function verif (ch : String) : Boolean;

Var j : Integer;
Test : Boolean;
Begin
j := 0;
Repeat
j := j+1;
test := Upcase(ch[j]) In (['A'..'Z']-['A','E','I','O','U','Y']);
Until (test=False) Or (j=Length(ch));
verif := test;
End;
Begin
k := 0;
For i:=1 To n Do
If verif(T[i])
Then Begin
k := k+1;
Tc[k] := T[i];
End;
End;
(**********************************************)
Procedure affiche (k : Integer ; tc : Tab);
Var i : Integer;
Begin
For i:=1 To k Do
Write (tc[i], ' ');
End;
(****************** P.P. ***************)
Begin
SAISIES (N,T);
RANGER (N, T, k, Tc);
AFFICHE (k, Tc);
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] ; D
…; é
c
Var {Déclaration des variables ; Exemples} l
X, Y, Z : Real ; I, J : Integer ; Let : Char ; Test : Boolean ; Ch : String ; a
Ville : Array [1..10] of String ; r
T1, T2 : Tab ; a
t
Jour : Jours_semaine ;
i
Couleurs : (Rouge, Vert, Bleu, Jaune) ; o
Mois : 1..12 ; n
…; s
{================= Définition des procédures ==========================}
g
Procedure Nom_procédure (pf1 : type1 ; VAR pf2 : type2 ; … ; VAR pfn : typen) ; l
{Déclarations locales : Const, Type, Var, Function, Procedure, ...} o
Begin b
Instructions de la procédure ; a
l
End ;
e
{================== Définition des fonctions ==========================} s
Function Nom_fonction (pf1 : type1 ; pf2 : type2 ; … ; pfn : typen) : Type_résultat ;
{Déclarations locales : Const, Type, Var, Function, Procedure, ...}
Begin
Instructions de la fonction ;
Nom_fonction := résultat ;
End ;
{========================= P. P. ==================================}
BEGIN {Début du programme principal}
{Bloc principal du programme avec appel des procédures et des fonctions}

Instructions ;
Nom_procédure (pe1, pe2, … pen) ;
……………..……… Nom_fonction (pe1, pe2, … pen) …………….……
Instructions ;
END. {Fin du programme}

Resume Algo 2019

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Resume Algo 2019

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique & Programmation

I- Les structures de données

I.2) Déclaration des variables

Algorithmique & Programmation Prof. FENNI-S Page 1/16

Tableau de déclarations des nouveaux types TYPE

I.4) Le type Enuméré

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

I.5) Le type Intervalle

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

Algorithmique & Programmation Prof. FENNI-S Page 2/16

LES STRUCTURES DE DONNEES  Prof : FENNI-S

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

LES STRUCTURES DE DONNEES  Prof : FENNI-S

II.1) L’opération d’affectation

Analyse Pascal Commentaire Résultat

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

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

Algorithmique & Programmation Prof. FENNI-S Page 3/16

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

En Analyse En Algorithmique En Pascal

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

En Analyse En Algorithmique En Pascal

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

En Analyse En Algorithmique En Pascal

Algorithmique & Programmation Prof. FENNI-S Page 4/16

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

• Remplir un tableau T par N éléments :

• Afficher un tableau T de N éléments :

POUR i de 1 à N FAIRE FOR i:=1 TO N DO

• Afficher une chaîne CH caractère par caractère :

POUR i de 1 à Long(ch) FAIRE FOR i:=1 TO Length(ch) DO

Algorithmique & Programmation Prof. FENNI-S Page 5/16

V.2) Les fonctions

Algorithmique & Programmation Prof. FENNI-S Page 6/16

Saisir une chaîne de caractère en majuscule

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

Algorithmique & Programmation Prof. FENNI-S Page 7/16

Remplir un tableau T par N éléments distincts

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

Affichage d’un tableau, 10 valeurs par ligne

Permutation de deux variables réelles

Algorithmique & Programmation Prof. FENNI-S Page 8/16

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

La somme de n réels dans un tableau

Algorithmique & Programmation Prof. FENNI-S Page 9/16

Algorithmique & Programmation Prof. FENNI-S Page 10/16

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

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

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

Miroir (symétrique) d’un entier long

Algorithmique & Programmation Prof. FENNI-S Page 11/16

Tableau de Déclaration des Objets globaux

Algorithme de la procedure saisies :

Algorithmique & Programmation Prof. FENNI-S Page 12/16

0) DEF FN ALPHA (ch : chaîne) : Booléen

Tableau de Déclaration des Objets locaux

Algorithme de la procedure ranger :

0) DEF PROC RANGER (n :Entier ; T :Tab ; Var k : Entier ; Var Tc :Tab)

Tableau de Déclaration des Objets locaux

Algorithme de la fonction verif :

0) DEF FN Verif (ch : chaîne) : Booléen

Tableau de Déclaration des Objets locaux

Algorithmique & Programmation Prof. FENNI-S Page 13/16

0) DEF PROC Affiche (k : Entier ; Tc : tab)