resume algo 2019 .pdf



Nom original: resume algo 2019.pdfAuteur: FENNI Salah

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 249 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
A5
BA+3
A  A +1
C  long("lycée")/2
D4<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
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
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;
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 ;
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 ;
YX
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
FF*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
pp*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;
i0
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
br
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 ; 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;
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) f0
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) 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
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


resume algo 2019.pdf - page 1/18
 
resume algo 2019.pdf - page 2/18
resume algo 2019.pdf - page 3/18
resume algo 2019.pdf - page 4/18
resume algo 2019.pdf - page 5/18
resume algo 2019.pdf - page 6/18
 




Télécharger le fichier (PDF)


resume algo 2019.pdf (PDF, 593 Ko)

Télécharger
Formats alternatifs: ZIP



Documents similaires


structures repetitives
les procedures
fiche1 ex sous programme
fiche2 ex sous programme
bac2014seance14h
139