resume algo 2019 .pdf
À propos / Télécharger Aperçu
Ce document au format PDF 1.6 a été généré par Acrobat PDFMaker 15 pour Word / Adobe PDF Library 15.0, et a été envoyé sur fichier-pdf.fr le 03/06/2019 à 11:33, depuis l'adresse IP 197.2.x.x.
La présente page de téléchargement du fichier a été vue 452 fois.
Taille du document: 593 Ko (18 pages).
Confidentialité: fichier public
Aperçu du document
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 :
Général
Exemples
En Pascal :
•
Syntaxe :
•
Exemples :
Tableau de Déclaration des Objets
Objets
Type/Nature
Nom
Constante = valeur de la constante
Annee
Constante = 2019
G
Constante = 9.81
Ville
Constante = "Chebba"
Existe
Constante = Vrai
Lettre
Constante = "B"
Rôle
Rôle
CONST <nom_constante> = <valeur_constante> ;
CONST annee = 2019 ;
g = 9.81 ;
ville = ‘Chebba’ ;
existe = True ;
lettre = ‘B’ ;
I.2) Déclaration des variables
En Algorithmique :
Général
Exemples
En Pascal :
•
Syntaxe :
•
Exemples :
Algorithmique & Programmation
VAR
VAR
Objets
Nom
Code
Heure
Nb
Moy
Phrase
Let
Test
T.D.O
Type/Nature
Type de la variable
Octet
Entier
Entier Long
Réel
Chaîne de caractères
Caractère
Booléen
Rôle
Rôle
<nom_variable> : type_variable ;
Code : Byte ;
Heure : Integer ;
Nb : LongInt ;
Moy : Real ;
Phrase : String ;
Let : Char ;
Test : Boolean ;
Prof. FENNI-S
Page 1/16
I.3) Déclaration d’un tableau à une dimension
Première formulation
EN PASCAL
EN ALGORITHMIQUE
Objet
Ident_tableau
MOY
T.D.O.
Type/Nature
Tableau de taille et de
type_éléments
Tableau de 30 Réels
Rôle
Exemple :
VAR
Moy : array [1..30] of real ;
Deuxième formulation
EN PASCAL
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
Objet
Ident_tableau
T
VAR
Ident_tableau : ARRAY [Binf..Bsup] OF
Type_éléments ;
T.D.O.
Type/Nature
Nom_type
Tab
Rôle
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. FENNI-S
Page 2/16
ANNEXE I
Nom Algorithmique
Code en Pascal
Type de x
Type du résultat
Rôle
Abs (x)
Carré (x)
Racine_Carré (x)
Cos (x)
Sin (x)
Tang (x)
Ln (x)
Exp (x)
ABS (x)
SQR (x)
SQRT (x)
COS (x)
SIN (x)
TAN (x)
LN (x)
EXP (x)
entier/réel
entier/réel
entier/réel
entier/réel
entier/réel
entier/réel
entier/réel
entier/réel
type de x
type de x
réel
réel
réel
réel
réel
réel
Tronc (x)
TRUNC (x)
réel
entier
partie entière de x
Ent (x)
INT (x)
réel
réel
partie entière de x
Arrondi (x)
ROUND (x)
réel
entier
Frac (x)
Aléa
Aléa (x)
FRAC (x)
RANDOM
RANDOM (x)
réel
entier (mot)
réel
réel
entier (mot)
Odd (x)
ODD (x)
entier long
booléen
Inc (x)
INC (x) ;
scalaire
type de x
Procédure, qui incrémente x
Dec (x)
DEC (x) ;
scalaire
type de x
Procédure, qui décrémente x
Pred (x)
PRED (x)
scalaire
type de x
prédécesseur de x, s’il existe
Succ (x)
SUCC (x)
scalaire
type de x
successeur de x, s’il existe
Chr (x)
Ord (x)
CHR (x)
ORD (x)
octet
scalaire
caractère
entier long
caractère dont le code ASCII est x
rang de la valeur x
Majus (x)
UPCASE (x)
caractère
caractère
majuscule de x, s’il est possible
valeur absolue de x
carré de x
racine carrée de x
cosinus de x (x en radians)
sinus de x (x en radians)
tangente de x (x en radians)
logarithme népérien de x
exponentiel de x
entier le plus proche de x
partie décimale de x
renvoie un réel aléatoire dans [0, 1[
renvoie un entier aléatoire dans [0, x-1]
VRAI
si x est impair
FAUX
si x est pair
Exemples en Pascal
ABS (-4) = 4 ; ABS (-5.7) = 5.7
SQR (2) = 4 ; SQR (2.5) = 6.25
SQRT (25) = 5.00 ; SQRT (6.25) = 2.5
COS (PI/2) = 0.00
SIN (PI/2) = 1.00
TAN (PI) = 0.00
LN (1) = 0.00
EXP (0) = 1.00
TRUNC (3.15) = 3
TRUNC (-3.15) = -3
INT (3.15) = 3.00
ROUND (9.49) = 9
ROUND (-9.5) = -10
FRAC (2.45) = 0.45
0.36 ; 0.075 ; 0.98 ; 0.02 ; …
Random (7) renvoie un entier dans [0, 6]
ODD (3) = True
ODD (8) = False
INC (x) ;
l’équivalent de x x +1
INC(x, n) ; l’équivalent de x x + n
DEC (x) ;
l’équivalent de x x - 1
DEC(x, n) ; l’équivalent de x x - n
PRED (5) = 4 ; PRED (‘C’) = ‘B’
PRED (True) = False
SUCC (5) = 6 ; SUCC (‘C’) = ‘D’
SUCC (False) = True
CHR (65) = ‘A’ ; CHR (97) = ‘a’
ORD(‘A’)=65 ; ORD(18)=18 ; ORD(true)=1
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
En Algorithmique
Type
Rôle
En Pascal
Long (ch)
Length (ch)
Retourne un entier représentant la
longueur de ch.
Long (ch) = ord (ch[0])
Pos (ch1, ch2)
Pos (ch1, ch2)
Retourne la première position de la
chaîne ch1 dans la chaîne ch2.
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.
Concat (ch1, ch2, …)
Concat (ch1, ch2, …)
Retourne la concaténation de plusieurs
chaînes en une seule. C'est l'équivalent
de ch1+ch2+…
Syntaxe
En Algorithmique
En Pascal
Rôle
Delete (ch, p, n) ;
Supprime N caractères de CH à partir
de la position P.
Insère (ch1, ch2, p)
Insert (ch1, ch2, p) ;
Insère une chaîne CH1 dans une
autre CH2 à la position P.
ConvCh (n, ch)
Str (n, ch) ;
Convertit une valeur numérique N en
une chaîne CH.
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.
LES STRUCTURES DE DONNEES
Résultat
Chaîne/Caractère
Entier
Chaîne/Caractère
Entier
Chaîne/Caractère,
Entier, Entier
Chaîne
Chaîne/Caractère
Chaîne
Exemples en Pascal
Lg := Length ('L''école'); lg = 7
Lg := Length ('') ;
lg = 0
Lg := Length (' ') ;
lg = 1
P := Pos ('T', 'ATTENTION') ; P = 2
P := Pos ('gra', 'Program') ; P = 4
P := Pos ('R', 'Professeur') ; P = 0
CH 1:= Copy ('Langage', 4, 3) ;
CH1 = 'gag'
CH 2:= Copy ('Bonjour', 4, 10) ;
CH2 = 'jour'
CH2 := ' Janvier' ; CH1 :='14' ;
CH3 := Concat (ch1, ch2, '2011') ;
CH3 = '14 Janvier2011'
Les procédures standard relatives aux chaînes de caractères
Efface (ch, p, n)
Valeur (ch, n, err)
Paramètres d’entrée
Type
Paramètres d’entrée
Résultat
Chaîne, Entier, Entier
Chaîne
Chaîne/Caractère,
Chaîne, Entier
Chaîne
Numérique, Chaîne
Chaîne
Chaîne/Caractère,
Numérique, Entier
Numérique,
Entier
Exemples en Pascal
CH := 'Merci' ;
Delete (CH, 4, 2) ; CH = 'Mer'
CH1 := 'DA' ;
CH2 := 'DIC' ;
Insert (CH1, CH2, 3) ; CH2 = 'DIDAC'
STR (2019, CH) ; CH = '2019'
STR (14.52, CH) ; CH = '1.4520000000E+01'
STR (14.52:8:3, CH) ; CH = '14.520'
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
Prof : FENNI-S
II- Les structures simples
II.1) L’opération d’affectation
Analyse / Algorithme
Pascal
Variable Valeur
Variable := Valeur ;
Exemples :
Analyse
et Algorithme
A5
BA+3
A A +1
C long("lycée")/2
D4<6
Pascal
Commentaire
A := 5 ;
B := A + 3 ;
A := A +1 ;
C := length(‘lycée’)/2 ;
D := 4 < 6 ;
Résultat
La variable A reçoit la valeur 5
A=5
B reçoit la valeur de l’expression A+3
B=8
A reçoit sa valeur actuelle incrémentée de 1
A=6
C reçoit la valeur de l’expression arithmétique … C = 2.5
D reçoit la valeur de l’expression logique …
D = Vrai
II.2) L’opération d’entrée (lecture, saisie)
Analyse
Variable = Donnée
Algorithme
Lire (variable)
Var1, Var2, Var3 = Données
Lire (var1, var2, var3)
Variable = Donnée ("Message")
Ecrire ("Message"), Lire (variable)
Pascal
ReadLn (variable) ;
Readln (var1, var2, var3) ;
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
A 10
Ecrire (A)
Ecrire ("Bonjour")
Ecrire (2 * 8 DIV 3)
Ecrire (5 > 6)
Pascal
A:=10 ;
Write (A) ;
Writeln ('Bonjour') ;
Writeln (2 * 8 DIV 3) ;
Write (5 > 6) ;
Ecrire (3, "*", A, " = ", 3*A)
Writeln (3, '*', A, ' = ', 3*a) ;
Algorithmique & Programmation
Prof. FENNI-S
Résultat sur l'écran
10Bonjour
5
False
3*10 = 30
Page 3/16
III- Les structures de contrôles conditionnelles
III.1) La structure de contrôle conditionnelle simple
En Analyse
Nom_objet = [initialisation(s)]
Si condition(s)
Alors Traitement 1
Sinon Traitement 2
Fin Si
En Algorithmique
initialisation(s)
Si condition(s)
Alors Traitement 1
Sinon Traitement 2
Fin Si
En Pascal
................. ; {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 :
En Analyse
Nom_objet = [initialisation(s)]
Si condition(s)
Alors Traitement
Fin Si
En Algorithmique
initialisation(s)
Si condition(s)
Alors Traitement
Fin Si
En Pascal
................. ; {initialisation(s)}
IF condition(s)
THEN Begin
Traitement ;
End ;
III.2) La structure de contrôle conditionnelle généralisée
En Analyse
Nom_objet = [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
En Algorithmique
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
En Pascal
............ ; {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
En Analyse
Nom_objet = [initialisation(s)]
Selon sélecteur Faire
valeur1 : trait1
valeur2 : trait2
valeur5, valeur8 : trait3
valeur10..valeur30 : trait4
...
valeur n-1 : trait n-1
Sinon trait n
Fin Selon
En Algorithmique
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
Algorithmique & Programmation
Prof. FENNI-S
En Pascal
....................; {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 ;
Page 4/16
IV- Les structures de contrôles itératives
IV.1) La structure de contrôle itérative complète
En Analyse
En Algorithmique
Nom_objet = [initialisation(s)]
POUR Cp de Vi à Vf FAIRE
Traitement
Fin Pour
initialisation(s)
POUR Cp de Vi à Vf FAIRE
Traitement
Fin Pour
En Pascal
............ ; { initialisation(s) }
FOR Cp:=Vi TO/DOWNTO Vf
Begin
Traitement ;
End ;
DO
{TO lorsque Vi ≤ Vf}
{DOWNTO lorsque Vi ≥ Vf}
IV.2) La structure de contrôle itérative à condition d’arrêt
a.Première formulation :
En Analyse
Nom_objet = [initialisation(s)]
REPETER
Traitement
JUSQU'A condition(s)
En Algorithmique
initialisation(s)
REPETER
Traitement
JUSQU'A condition(s)
{jusqu’à condition soit vraie}
En Pascal
............; {initialisation(s)}
REPEAT
Traitement ;
UNTIL condition(s) ;
b.Deuxième formulation :
En Analyse
Nom_objet = [initialisation(s)]
TANT QUE condition(s) FAIRE
Traitement
Fin Tant que
En Algorithmique
initialisation(s)
TANT QUE condition(s) FAIRE
Traitement
Fin Tant que
{Tant que
condition est
vraie
répéter le traitement}
En Pascal
............; {initialisation(s)}
WHILE condition(s) DO
Begin
Traitement ;
End ;
Exemples :
•
•
Remplir un tableau T par N éléments :
En Analyse
T=[ ]
POUR i de 1 à N FAIRE
T[i] = donnée
Fin Pour
En Algorithmique
POUR
i de 1 à N FAIRE
Lire (T[i])
Fin Pour
Afficher un tableau T de N éléments :
Analyse / Algorithmique
POUR
i de 1 à N FAIRE
Ecrire (T[i])
Fin Pour
•
FOR i:=1 TO N DO
Write (T[i], ‘ ‘) ;
Analyse / Algorithmique
i de 1 à Long(ch) FAIRE
Ecrire (ch[i])
Fin Pour
Algorithmique & Programmation
FOR i:=1 TO N DO
Readln (T[i]) ;
En Pascal
Afficher une chaîne CH caractère par caractère :
POUR
En Pascal
En Pascal
FOR i:=1 TO Length(ch)
Writeln (CH[i]) ;
Prof. FENNI-S
DO
Page 5/16
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 )
-
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, 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 :
-
En algorithmique :
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.
Algorithmique & Programmation
Prof. FENNI-S
Page 6/16
Sous Programmes Usuels
En Algorithme
En Pascal
Saisir un entier N
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
tel que 5 ≤ N ≤ 500
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)
Procedure Saisie (Var ch : String) ;
Var i : integer;
1) Répéter
Ecrire ("Saisir une chaîne "), Lire(CH)
Begin
i1
Repeat
Tant que (ch[i] dans ["A".."Z"]) et
Writeln (‘Saisir une chaîne ’) ; Readln (ch) ;
(i ≤ long(ch)) Faire ii+1
i:=1;
Jusqu’à i > long(ch)
While (ch[i] in ['A'..'Z']) and (i<=length(ch)) do
i:=i+1;
2) Fin Saisie
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) ;
Var i : integer;
1) Répéter
Ecrire ("Saisir une chaîne "), Lire (ch)
verif : Boolean;
i0
Begin
Répéter
Repeat
ii+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 ;
Verif := pos(ch[i],ch) = i ;
2) Fin Saisie
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) ;
Var i : integer;
1) Pour i de 1 à n Faire
Répéter
Begin
Ecrire ("T[", i, "] = "), Lire (T[i])
For i:=1 To n Do
Jusqu’à (T[i] mod 2) ≠ 0
Repeat
Write (‘T[‘,i,’]= ’) ;
Fin Pour
Readln (T[i]) ;
2) Fin Remplir
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);
Randomize ;
Fin Pour
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[
T[i] a+ (b-a) * Aléa
Une lettre majuscule au hazard
T[i] chr (65 + Aléa(26))
Algorithmique & Programmation
•
•
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))
Prof. FENNI-S
Page 7/16
0)
1)
2)
3)
Remplir un tableau T par N éléments en ordre croissant
DEF PROC Saisie (N : Entier ; VAR T : Tab)
Procedure Saisie (n : integer ; var t : tab) ;
Ecrire ("T[1] : "), Lire(T[1])
Var i : integer;
Pour i de 2 à n Faire
Begin
Write ('T[1] : ') ; Readln (T[1]) ;
Répéter
Ecrire ("T[", i, "] : "), Lire (T[i])
For i:=2 To n Do
Jusqu’à T[i] > T[i-1]
Repeat
Write ('T[',i,'] : ') ;
Fin Pour
Readln (T[i]) ;
Fin Saisie
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);
Var i, j : Integer;
1) Pour i de 1 à n Faire
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;
While T[i] <> T[j] Do j:=j+1 ;
Fin Tant que
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) ;
Var i : Integer ;
1) Pour i de 1 à n Faire
ch : String ;
Répéter
Ecrire ("T[", i, "]= "), Lire (T[i])
Begin
Conch (T[i], ch)
For i:=1 To n Do
Jusqu’à pos("0",ch)= 0
Repeat
Write (‘T[‘,i,’]= ’) ; Readln (T[i]) ;
Fin Pour
Str (T[i], ch);
2) Fin Saisie
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) ;
Var i : Integer ;
1) Pour i de 1 à n Faire
Ecrire (T[i], " ")
Begin
FOR i :=1 TO n DO Write (T[i], ‘ ‘) ;
Fin Pour
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);
Var i : integer;
1) Pour i de 1 à n Faire
Ecrire (T[i], " ")
Begin
Si (i mod 10) = 0
For i:=1 To n Do
Alors Retour_à_la_ligne
begin
write(T[i], " ");
Fin Si
If (i mod 10) = 0 then writeln ;
Fin Pour
2) Fin Affiche
end;
End ;
0)
1)
2)
3)
4)
Permutation de deux variables réelles
DEF PROC Permut (VAR x, y : Réel)
Procedure Permut (VAR x, y : Real) ;
AUX Y
Var aux : Real ;
YX
Begin
X AUX
Aux := Y ;
Y := X ;
Fin Permut
X := Aux ;
End ;
Algorithmique & Programmation
Prof. FENNI-S
Page 8/16
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
c1 := c1 +1 ;
Fin Si
T1[c1] := T[i] ;
Fin Pour
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 ;
Pour i de 1 à n Faire
Begin
Si t[i] < 0
k := 0 ;
Alors k k +1
For i :=1 To n Do
Aux t[i]
If t[i] < 0
Then begin
t[i] t[k]
k := k +1 ;
t[k] aux
Aux := t[i] ;
Fin Si
t[i]
:= t[k] ;
Fin Pour
t[k] := aux ;
2) Fin Transfert
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) ;
Var i :integer ;
entier)
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] ;
T[p] := X ;
Fin Pour
{insertion de X à la position p}
2) T[p] X
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 ;
s : real;
Pour i de 1 à n Faire
S S + T[i]
Begin
s:=0 ;
Fin Pour
2) Somme S
For i:=1 To n Do s:=s + T[i] ;
Somme := s ;
3) Fin Somme
End ;
0) DEF FN Fact (n : entier) : entier long
1) F 1
2) Pour i de 2 à n Faire
FF*i
Fin Pour
3) Fact F
4) Fin Fact
Algorithmique & Programmation
Factorielle de N ( n ! )
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 ;
Prof. FENNI-S
Page 9/16
0)
1)
2)
3)
0)
1)
2)
3)
4)
0)
1)
2)
3)
4)
0)
1)
2)
3)
4)
0)
1)
2)
3)
0)
1)
2)
3)
4)
Calcul de Xn
(n ≥ 0)
DEF FN Puissance (x, n : entier) : entier
Function Puissance (x, n : integer) : integer ;
p 1
Var i , p : integer ;
Pour i de 1 à n Faire
Begin
pp*x
p:=1 ;
For i:=1 To n Do p := p * x ;
Fin Pour
puissance p
puissance := p ;
Fin Puissance
End ;
Vérifier si un nombre est premier (le nombre de ses diviseurs =2)
DEF FN Premier (n : entier) : booléen
Function Premier (N:integer) : boolean ;
nbdiv 1
Var i ,nbdiv : integer;
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
If (n mod i = 0)
Fin Si
Then nbdiv := nbdiv + 1 ;
Fin Pour
premier (nbdiv = 2)
premier := nbdiv = 2 ;
Fin Premier
End ;
Vérifier si une chaine contient uniquement des consonnes
DEF FN Verif (ch : chaîne) : booléen
Function verif (ch : String) : Boolean;
i0
Var i : Integer;
Test : Boolean;
Répéter
i i+1
Begin
test majus(ch[i]) dans (['’A’'..’'Z’']i := 0;
[‘'A’',’'E’',’'I’',’'O’',’'U’',’'Y’'])
Repeat
i := i+1;
Jusqu’à (test=faux) ou (i=long(ch))
Verif test
test := upcase(ch[i]) in (['A'..'Z']-['A','E','I','O','U','Y']);
Until (test=False) Or (i=Length(ch));
Fin verif
verif := test;
End;
PPCM (a,b)
DEF FN PPCM ( a, b : entier) : entier
Function PPCM (a ,b :integer) : integer ;
i 1
Var i : integer;
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 ;
ppcm a*i
Fin PPCM
ppcm := a*i ;
End;
PGCD_Euclide (a,b)
DEF FN PGCD_Euclide ( a, b : entier) : entier Function PGCD_Euclide (a ,b :integer) : integer ;
Tant que b ≠ 0 Faire
Var r : integer;
r a mod b
Begin
a b
While b<>0 Do
br
Begin
r := a mod b;
Fin Tant que
Pgcd_euclide a
a := b;
b := r;
Fin PGCD_Euclide
End;
PGCD_Euclide := a;
End;
La somme de chiffres d’un entier
DEF FN Som_chif (n : entier) : entier
Function Som_Chif ( N : integer ) : integer ;
som 0
Var som, r : integer ;
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 ;
som_chif som
N := n div 10 ;
Until n=0 ;
Fin Som_chif
Som_chif := som ;
End;
Algorithmique & Programmation
Prof. FENNI-S
Page 10/16
0)
1)
2)
3)
4)
Vérifier si une chaîne est palindrome (ou symétrique)
DEF FN Palindrome (ch : chaîne) : Booléen
Function palindrome (ch : string) : boolean;
i 0
Var i:integer;
verif:boolean;
Répéter
i i+1
Begin
verif ch[i] = ch[long(ch) – i + 1]
i:=0;
Jusqu’à (verif=faux) ou (i = long(ch) div 2)
repeat
palindrome verif
i:=i+1;
verif := ch[i] = ch[length(ch)-i+1] ;
Fin Palindrome
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 ;
Min : Real ;
Pour i de 2 à n Faire
Si (T[i] < min)
Begin
Alors min T[i]
Min := T[1] ;
Fin Si
For i :=2 To n Do
If (T[i] < min) Then min := T[i] ;
Fin Pour
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 ; in+1
Var i, p : Integer ;
Répéter
Begin
ii - 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;
If T[i]=X Then p := i ;
3) Fin Recherche
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) f0
Var i, f : Integer ;
2) Pour i de 1 à n Faire
Begin
Si (T[i] = X)
f := 0 ;
Alors f f + 1
For i :=1 To n Do
If (T[i] = X) Then f := f+1 ;
Fin Si
Frequence := f ;
Fin Pour
3) frequence f
End ;
4) Fin Frequence
0)
1)
2)
3)
4)
Miroir (symétrique) d’un entier long
DEF FN Miroir (x : entier long) : entier long
Function miroir (x : longint) : longint ;
Sym 0
Var sym : longint ;
u : 0..9 ;
Répéter
U X mod 10
Begin
Sym sym * 10 + u
sym := 0 ;
X x div 10
Repeat
Jusqu’à x=0
U := X mod 10;
miroir sym
Sym := sym * 10 + u;
X := x div 10 ;
Fin miroir
Until x=0 ;
miroir := sym ;
End ;
Algorithmique & Programmation
Prof. FENNI-S
Page 11/16
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
Objets Type/Nature
Rôle
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
Objets Type/Nature
Rôle
i
Entier
Compteur
Alpha Fonction
Permet de vérifier si une chaîne est alphanumérique ou non
Algorithmique & Programmation
Prof. FENNI-S
Page 12/16
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
Tableau de Déclaration des Objets locaux
Objets Type/Nature
Rôle
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) k0
2) Pour i de 1 à n Faire
Si FN Verif (T[i])
{ Si FN Verif(T[i]) = Vrai }
Alors kk+1
Tc [k] T[i]
Fin si
Fin Pour
3) Fin Ranger
Tableau de Déclaration des Objets locaux
Objets Type/Nature
Rôle
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
Tableau de Déclaration des Objets locaux
Objets Type/Nature
Rôle
j
Entier
Compteur
test
Booléen
Variable intermédiaire
Algorithmique & Programmation
Prof. FENNI-S
Page 13/16
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
Tableau de Déclaration des Objets locaux
Objets Type/Nature
Rôle
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;
Algorithmique & Programmation
Prof. FENNI-S
Page 14/16
(**************************************************************)
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.
Algorithmique & Programmation
Prof. FENNI-S
Page 15/16
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
é
c
l
a
r
a
t
i
o
n
s
g
l
o
b
a
l
e
s
{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}
Algorithmique & Programmation
Prof. FENNI-S
Page 16/16